fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            run_destructor: true,

        }

    }

    fn drop(&mut self) {

        self.run_destructor = false;

    }

    fn clone(&self) -> Self {

        Self { ptr: self.ptr }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_str().fmt(f)

    }

    pub fn as_str(&self) -> &str {

        unsafe { core::str::from_utf8_unchecked(core::slice::from_raw_parts(self.ptr, self.len)) }

    }

    fn from(s: &str) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    pub fn as_slice(&self) -> &[Refstr] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn from(s: &[Refstr]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &mut [GLint64]) -> Self {

        Self {

            ptr: s.as_mut_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLint64] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn as_mut_slice(&mut self) -> &mut [GLint64] {

        unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &mut [GLfloat]) -> Self {

        Self {

            ptr: s.as_mut_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLfloat] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn as_mut_slice(&mut self) -> &mut [GLfloat] {

        unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &mut [GLint]) -> Self {

        Self {

            ptr: s.as_mut_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLint] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn as_mut_slice(&mut self) -> &mut [GLint] {

        unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &[GLuint]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLuint] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &[GLenum]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLenum] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn from(s: &[u8]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[u8] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        self.as_slice().fmt(f)

    }

    fn partial_cmp(&self, rhs: &Self) -> Option<core::cmp::Ordering> {

        self.as_slice().partial_cmp(rhs.as_slice())

    }

    fn cmp(&self, rhs: &Self) -> core::cmp::Ordering {

        self.as_slice().cmp(rhs.as_slice())

    }

    fn eq(&self, rhs: &Self) -> bool {

        self.as_slice().eq(rhs.as_slice())

    }

    fn hash<H>(&self, state: &mut H)

    where

        H: core::hash::Hasher,

        self.as_slice().hash(state)

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &[f32]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[f32] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &[i32]) -> Self {

        Self {

            ptr: s.as_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[i32] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &mut [GLboolean]) -> Self {

        Self {

            ptr: s.as_mut_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[GLboolean] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn as_mut_slice(&mut self) -> &mut [GLboolean] {

        unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) }

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            len: self.len,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        self.as_slice().fmt(f)

    }

    fn from(s: &mut [u8]) -> Self {

        Self {

            ptr: s.as_mut_ptr(),

            len: s.len(),

        }

    }

    pub fn as_slice(&self) -> &[u8] {

        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }

    }

    fn as_mut_slice(&mut self) -> &mut [u8] {

        unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) }

    }

    fn from(a: GlContextGlType) -> GlType {

        match a {

            GlContextGlType::Gl => GlType::Gl,

            GlContextGlType::GlEs => GlType::Gles,

    }

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr,

            run_destructor: true,

        }

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        write!(f, "0x{:0x}", self.ptr as usize)

    }

    pub fn new(p: GLsync) -> Self {

        Self {

            ptr: p as *const c_void,

            run_destructor: true,

        }

    }

    pub fn get(self) -> GLsync {

        self.ptr as GLsync

    }

    fn drop(&mut self) {

        self.run_destructor = false;

    }

pub fn insert_into_active_gl_textures(

    document_id: DocumentId,

    epoch: Epoch,

    texture: Texture,

) -> ExternalImageId {

    let external_image_id = ExternalImageId::new();

        if ACTIVE_GL_TEXTURES.is_none() {

            ACTIVE_GL_TEXTURES = Some(OrderedMap::new());

        }

        let active_textures = ACTIVE_GL_TEXTURES.as_mut().unwrap();

        let active_epochs = active_textures

            .entry(document_id)

            .or_insert_with(|| OrderedMap::new());

        let active_textures_for_epoch = active_epochs

            .entry(epoch)

            .or_insert_with(|| OrderedMap::new());

        active_textures_for_epoch.insert(external_image_id, texture);

    external_image_id

}

pub fn gl_textures_remove_epochs_from_pipeline(document_id: &DocumentId, epoch: Epoch) {

        let active_textures = match ACTIVE_GL_TEXTURES.as_mut() {

            Some(s) => s,

            None => return,

        let active_epochs = match active_textures.get_mut(document_id) {

            Some(s) => s,

            None => return,

        let mut epochs_to_remove = Vec::new();

        for (gl_texture_epoch, _) in active_epochs.iter() {

            if *gl_texture_epoch < epoch {

                epochs_to_remove.push(*gl_texture_epoch);

            }

        for epoch in epochs_to_remove {

            active_epochs.remove(&epoch);

        }

}

pub fn remove_single_texture_from_active_gl_textures(

    document_id: &DocumentId,

    epoch: &Epoch,

    external_image_id: &ExternalImageId,

) -> Option<()> {

    let mut active_textures = unsafe { ACTIVE_GL_TEXTURES.as_mut()? };

    let mut epochs = active_textures.get_mut(document_id)?;

    let mut images_in_epoch = epochs.get_mut(epoch)?;

    images_in_epoch.remove(external_image_id);

    Some(())

}

pub fn gl_textures_remove_active_pipeline(document_id: &DocumentId) {

        let active_textures = match ACTIVE_GL_TEXTURES.as_mut() {

            Some(s) => s,

            None => return,

        active_textures.remove(document_id);

}

pub fn gl_textures_clear_opengl_cache() {

    unsafe {

        ACTIVE_GL_TEXTURES = None;

    }

}

pub fn get_opengl_texture(image_key: &ExternalImageId) -> Option<(GLuint, (f32, f32))> {

    let active_textures = unsafe { ACTIVE_GL_TEXTURES.as_ref()? };

    active_textures

        .values()

        .flat_map(|active_document| active_document.values())

        .find_map(|active_epoch| active_epoch.get(image_key))

        .map(|tex| {

            (

                tex.texture_id,

                (tex.size.width as f32, tex.size.height as f32),

            )

        })

}

    fn clone(&self) -> Self {

        Self {

            ptr: self.ptr.clone(),

            renderer_type: self.renderer_type.clone(),

            run_destructor: true,

        }

    }

    fn drop(&mut self) {

        self.run_destructor = false;

    }

    pub fn get_svg_shader(&self) -> GLuint {

        self.ptr.svg_shader

    }

    pub fn get_fxaa_shader(&self) -> GLuint {

        self.ptr.fxaa_shader

    }

    fn drop(&mut self) {

        self.ptr.delete_program(self.svg_shader);

        self.ptr.delete_program(self.svg_multicolor_shader);

        self.ptr.delete_program(self.fxaa_shader);

    }

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        write!(f, "0x{:0x}", self.as_usize())

    }

fn check_shader_compile(gl_context: &GenericGlContext, shader: GLuint, _label: &str) {

    let mut status = [0_i32];

    unsafe { gl_context.get_shader_iv(shader, gl::COMPILE_STATUS, &mut status) };

    if status[0] != gl::TRUE as i32 {

        {

            let log = gl_context.get_shader_info_log(shader);

            eprintln!("azul: {} shader compile error: {}", _label, log);

        }

    }

}

fn check_program_link(gl_context: &GenericGlContext, program: GLuint, _label: &str) {

    let mut status = [0_i32];

    unsafe { gl_context.get_program_iv(program, gl::LINK_STATUS, &mut status) };

    if status[0] != gl::TRUE as i32 {

        {

            let log = gl_context.get_program_info_log(program);

            eprintln!("azul: {} program link error: {}", _label, log);

        }

    }

}

    pub fn new(renderer_type: RendererType, gl_context: Rc<GenericGlContext>) -> Self {

        let vertex_shader_object = gl_context.create_shader(gl::VERTEX_SHADER);

        gl_context.shader_source(vertex_shader_object, &[SVG_VERTEX_SHADER]);

        gl_context.compile_shader(vertex_shader_object);

        check_shader_compile(&gl_context, vertex_shader_object, "SVG vertex");

        let fragment_shader_object = gl_context.create_shader(gl::FRAGMENT_SHADER);

        gl_context.shader_source(fragment_shader_object, &[SVG_FRAGMENT_SHADER]);

        gl_context.compile_shader(fragment_shader_object);

        check_shader_compile(&gl_context, fragment_shader_object, "SVG fragment");

        let svg_program_id = gl_context.create_program();

        gl_context.attach_shader(svg_program_id, vertex_shader_object);

        gl_context.attach_shader(svg_program_id, fragment_shader_object);

        gl_context.bind_attrib_location(svg_program_id, 0, "vAttrXY".into());

        gl_context.link_program(svg_program_id);

        check_program_link(&gl_context, svg_program_id, "SVG");

        gl_context.delete_shader(vertex_shader_object);

        gl_context.delete_shader(fragment_shader_object);

        let vertex_shader_object = gl_context.create_shader(gl::VERTEX_SHADER);

        gl_context.shader_source(vertex_shader_object, &[SVG_MULTICOLOR_VERTEX_SHADER]);

        gl_context.compile_shader(vertex_shader_object);

        check_shader_compile(&gl_context, vertex_shader_object, "SVG multicolor vertex");

        let fragment_shader_object = gl_context.create_shader(gl::FRAGMENT_SHADER);

        gl_context.shader_source(fragment_shader_object, &[SVG_MULTICOLOR_FRAGMENT_SHADER]);

        gl_context.compile_shader(fragment_shader_object);

        check_shader_compile(&gl_context, fragment_shader_object, "SVG multicolor fragment");

        let svg_multicolor_program_id = gl_context.create_program();

        gl_context.attach_shader(svg_multicolor_program_id, vertex_shader_object);

        gl_context.attach_shader(svg_multicolor_program_id, fragment_shader_object);

        gl_context.bind_attrib_location(svg_multicolor_program_id, 0, "vAttrXY".into());

        gl_context.bind_attrib_location(svg_multicolor_program_id, 1, "vColor".into());

        gl_context.link_program(svg_multicolor_program_id);

        check_program_link(&gl_context, svg_multicolor_program_id, "SVG multicolor");

        gl_context.delete_shader(vertex_shader_object);

        gl_context.delete_shader(fragment_shader_object);

        let vertex_shader_object = gl_context.create_shader(gl::VERTEX_SHADER);

        gl_context.shader_source(vertex_shader_object, &[FXAA_VERTEX_SHADER]);

        gl_context.compile_shader(vertex_shader_object);

        check_shader_compile(&gl_context, vertex_shader_object, "FXAA vertex");

        let fragment_shader_object = gl_context.create_shader(gl::FRAGMENT_SHADER);

        gl_context.shader_source(fragment_shader_object, &[FXAA_FRAGMENT_SHADER]);

        gl_context.compile_shader(fragment_shader_object);

        check_shader_compile(&gl_context, fragment_shader_object, "FXAA fragment");

        let fxaa_program_id = gl_context.create_program();

        gl_context.attach_shader(fxaa_program_id, vertex_shader_object);

        gl_context.attach_shader(fxaa_program_id, fragment_shader_object);

        gl_context.bind_attrib_location(fxaa_program_id, 0, "vAttrXY".into());

        gl_context.link_program(fxaa_program_id);

        check_program_link(&gl_context, fxaa_program_id, "FXAA");

        gl_context.delete_shader(vertex_shader_object);

        gl_context.delete_shader(fragment_shader_object);

        Self {

            ptr: Box::new(Rc::new(GlContextPtrInner {

                svg_shader: svg_program_id,

                svg_multicolor_shader: svg_multicolor_program_id,

                fxaa_shader: fxaa_program_id,

                ptr: gl_context,

            })),

            renderer_type,

            run_destructor: true,

        }

    }

    pub fn get<'a>(&'a self) -> &'a Rc<GenericGlContext> {

        &self.ptr.ptr

    }

    fn as_usize(&self) -> usize {

        (Rc::as_ptr(&self.ptr.ptr) as *const c_void) as usize

    }

    pub fn get_type(&self) -> GlType {

        self.get().get_type().into()

    }

    pub fn buffer_data_untyped(

        &self,

        target: GLenum,

        size: GLsizeiptr,

        data: GlVoidPtrConst,

        usage: GLenum,

    ) {

        self.get()

            .buffer_data_untyped(target, size, data.ptr, usage)

    }

    pub fn buffer_sub_data_untyped(

        &self,

        target: GLenum,

        offset: isize,

        size: GLsizeiptr,

        data: GlVoidPtrConst,

    ) {

        self.get()

            .buffer_sub_data_untyped(target, offset, size, data.ptr)

    }

    pub fn map_buffer(&self, target: GLenum, access: GLbitfield) -> GlVoidPtrMut {

        GlVoidPtrMut {

            ptr: self.get().map_buffer(target, access),

        }

    }

    pub fn map_buffer_range(

        &self,

        target: GLenum,

        offset: GLintptr,

        length: GLsizeiptr,

        access: GLbitfield,

    ) -> GlVoidPtrMut {

        GlVoidPtrMut {

            ptr: self.get().map_buffer_range(target, offset, length, access),

        }

    }

    pub fn unmap_buffer(&self, target: GLenum) -> GLboolean {

        self.get().unmap_buffer(target)

    }

    pub fn tex_buffer(&self, target: GLenum, internal_format: GLenum, buffer: GLuint) {

        self.get().tex_buffer(target, internal_format, buffer)

    }

    pub fn shader_source(&self, shader: GLuint, strings: StringVec) {

        fn str_to_bytes(input: &str) -> Vec<u8> {

            let mut v: Vec<u8> = input.into();

            v.push(0);

            v

        }

        let shaders_as_bytes = strings

            .iter()

            .map(|s| str_to_bytes(s.as_str()))

            .collect::<Vec<_>>();

        let shaders_as_bytes = shaders_as_bytes

            .iter()

            .map(|s| s.as_ref())

            .collect::<Vec<_>>();

        self.get().shader_source(shader, &shaders_as_bytes)

    }

    pub fn read_buffer(&self, mode: GLenum) {

        self.get().read_buffer(mode)

    }

    pub fn read_pixels_into_buffer(

        &self,

        x: GLint,

        y: GLint,

        width: GLsizei,

        height: GLsizei,

        format: GLenum,

        pixel_type: GLenum,

        mut dst_buffer: U8VecRefMut,

    ) {

        self.get().read_pixels_into_buffer(

            x,

            y,

            width,

            height,

            format,

            pixel_type,

            dst_buffer.as_mut_slice(),

        )

    }

    pub fn read_pixels(

        &self,

        x: GLint,

        y: GLint,

        width: GLsizei,

        height: GLsizei,

        format: GLenum,

        pixel_type: GLenum,

    ) -> U8Vec {

        self.get()

            .read_pixels(x, y, width, height, format, pixel_type)

            .into()

    }

    pub fn read_pixels_into_pbo(

        &self,

        x: GLint,

        y: GLint,

        width: GLsizei,

        height: GLsizei,

        format: GLenum,

        pixel_type: GLenum,

    ) {

            self.get()

                .read_pixels_into_pbo(x, y, width, height, format, pixel_type)

    }

    pub fn sample_coverage(&self, value: GLclampf, invert: bool) {

        self.get().sample_coverage(value, invert)

    }

    pub fn polygon_offset(&self, factor: GLfloat, units: GLfloat) {

        self.get().polygon_offset(factor, units)

    }

    pub fn pixel_store_i(&self, name: GLenum, param: GLint) {

        self.get().pixel_store_i(name, param)

    }

    pub fn gen_buffers(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_buffers(n).into()

    }

    pub fn gen_renderbuffers(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_renderbuffers(n).into()

    }

    pub fn gen_framebuffers(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_framebuffers(n).into()

    }

    pub fn gen_textures(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_textures(n).into()

    }

    pub fn gen_vertex_arrays(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_vertex_arrays(n).into()

    }

    pub fn gen_queries(&self, n: GLsizei) -> GLuintVec {

        self.get().gen_queries(n).into()

    }

    pub fn begin_query(&self, target: GLenum, id: GLuint) {

        self.get().begin_query(target, id)

    }

    pub fn end_query(&self, target: GLenum) {

        self.get().end_query(target)

    }

    pub fn query_counter(&self, id: GLuint, target: GLenum) {

        self.get().query_counter(id, target)

    }

    pub fn get_query_object_iv(&self, id: GLuint, pname: GLenum) -> i32 {

        self.get().get_query_object_iv(id, pname)

    }

    pub fn get_query_object_uiv(&self, id: GLuint, pname: GLenum) -> u32 {

        self.get().get_query_object_uiv(id, pname)

    }

    pub fn get_query_object_i64v(&self, id: GLuint, pname: GLenum) -> i64 {

        self.get().get_query_object_i64v(id, pname)

    }

    pub fn get_query_object_ui64v(&self, id: GLuint, pname: GLenum) -> u64 {

        self.get().get_query_object_ui64v(id, pname)

    }

    pub fn delete_queries(&self, queries: GLuintVecRef) {

        self.get().delete_queries(queries.as_slice())

    }

    pub fn delete_vertex_arrays(&self, vertex_arrays: GLuintVecRef) {

        self.get().delete_vertex_arrays(vertex_arrays.as_slice())

    }

    pub fn delete_buffers(&self, buffers: GLuintVecRef) {

        self.get().delete_buffers(buffers.as_slice())

    }

    pub fn delete_renderbuffers(&self, renderbuffers: GLuintVecRef) {

        self.get().delete_renderbuffers(renderbuffers.as_slice())

    }

    pub fn delete_framebuffers(&self, framebuffers: GLuintVecRef) {

        self.get().delete_framebuffers(framebuffers.as_slice())

    }

    pub fn delete_textures(&self, textures: GLuintVecRef) {

        self.get().delete_textures(textures.as_slice())

    }

    pub fn framebuffer_renderbuffer(

        &self,

        target: GLenum,

        attachment: GLenum,

        renderbuffertarget: GLenum,

        renderbuffer: GLuint,

    ) {

        self.get()

            .framebuffer_renderbuffer(target, attachment, renderbuffertarget, renderbuffer)

    }

    pub fn renderbuffer_storage(

        &self,

        target: GLenum,

        internalformat: GLenum,

        width: GLsizei,

        height: GLsizei,

    ) {

        self.get()

            .renderbuffer_storage(target, internalformat, width, height)

    }

    pub fn depth_func(&self, func: GLenum) {

        self.get().depth_func(func)

    }

    pub fn active_texture(&self, texture: GLenum) {

        self.get().active_texture(texture)

    }

    pub fn attach_shader(&self, program: GLuint, shader: GLuint) {

        self.get().attach_shader(program, shader)

    }

    pub fn bind_attrib_location(&self, program: GLuint, index: GLuint, name: &str) {

        self.get()

            .bind_attrib_location(program, index, name)

    }

    pub fn get_uniform_iv(&self, program: GLuint, location: GLint, mut result: GLintVecRefMut) {

            self.get()

                .get_uniform_iv(program, location, result.as_mut_slice())