Trait glow::HasContext[−][src]

pub trait HasContext {
    type Shader: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Program: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Buffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type VertexArray: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Texture: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Sampler: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Fence: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Framebuffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Renderbuffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type Query: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type TransformFeedback: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
    type UniformLocation: Clone + Debug;

Show 264 methods    fn supported_extensions(&self) -> &HashSet<String>;

    fn supports_debug(&self) -> bool;

    fn version(&self) -> &Version;

    unsafe fn create_framebuffer(&self) -> Result<Self::Framebuffer, String>;

    unsafe fn is_framebuffer(&self, framebuffer: Self::Framebuffer) -> bool;

    unsafe fn create_query(&self) -> Result<Self::Query, String>;

    unsafe fn create_renderbuffer(&self) -> Result<Self::Renderbuffer, String>;

    unsafe fn is_renderbuffer(&self, renderbuffer: Self::Renderbuffer) -> bool;

    unsafe fn create_sampler(&self) -> Result<Self::Sampler, String>;

    unsafe fn create_shader(
        &self, 
        shader_type: u32
    ) -> Result<Self::Shader, String>;

    unsafe fn is_shader(&self, shader: Self::Shader) -> bool;

    unsafe fn create_texture(&self) -> Result<Self::Texture, String>;

    unsafe fn is_texture(&self, texture: Self::Texture) -> bool;

    unsafe fn delete_shader(&self, shader: Self::Shader);

    unsafe fn shader_source(&self, shader: Self::Shader, source: &str);

    unsafe fn compile_shader(&self, shader: Self::Shader);

    unsafe fn get_shader_compile_status(&self, shader: Self::Shader) -> bool;

    unsafe fn get_shader_info_log(&self, shader: Self::Shader) -> String;

    unsafe fn get_tex_image(
        &self, 
        target: u32, 
        level: i32, 
        format: u32, 
        ty: u32, 
        pixels: PixelPackData<'_>
    );

    unsafe fn create_program(&self) -> Result<Self::Program, String>;

    unsafe fn is_program(&self, program: Self::Program) -> bool;

    unsafe fn delete_program(&self, program: Self::Program);

    unsafe fn attach_shader(&self, program: Self::Program, shader: Self::Shader);

    unsafe fn detach_shader(&self, program: Self::Program, shader: Self::Shader);

    unsafe fn link_program(&self, program: Self::Program);

    unsafe fn get_program_link_status(&self, program: Self::Program) -> bool;

    unsafe fn get_program_info_log(&self, program: Self::Program) -> String;

    unsafe fn get_active_uniforms(&self, program: Self::Program) -> u32;

    unsafe fn get_active_uniform(
        &self, 
        program: Self::Program, 
        index: u32
    ) -> Option<ActiveUniform>;

    unsafe fn use_program(&self, program: Option<Self::Program>);

    unsafe fn create_buffer(&self) -> Result<Self::Buffer, String>;

    unsafe fn is_buffer(&self, buffer: Self::Buffer) -> bool;

    unsafe fn bind_buffer(&self, target: u32, buffer: Option<Self::Buffer>);

    unsafe fn bind_buffer_base(
        &self, 
        target: u32, 
        index: u32, 
        buffer: Option<Self::Buffer>
    );

    unsafe fn bind_buffer_range(
        &self, 
        target: u32, 
        index: u32, 
        buffer: Option<Self::Buffer>, 
        offset: i32, 
        size: i32
    );

    unsafe fn bind_vertex_buffer(
        &self, 
        binding_index: u32, 
        buffer: Option<Buffer>, 
        offset: i32, 
        stride: i32
    );

    unsafe fn bind_framebuffer(
        &self, 
        target: u32, 
        framebuffer: Option<Self::Framebuffer>
    );

    unsafe fn bind_renderbuffer(
        &self, 
        target: u32, 
        renderbuffer: Option<Self::Renderbuffer>
    );

    unsafe fn blit_framebuffer(
        &self, 
        src_x0: i32, 
        src_y0: i32, 
        src_x1: i32, 
        src_y1: i32, 
        dst_x0: i32, 
        dst_y0: i32, 
        dst_x1: i32, 
        dst_y1: i32, 
        mask: u32, 
        filter: u32
    );

    unsafe fn create_vertex_array(&self) -> Result<Self::VertexArray, String>;

    unsafe fn delete_vertex_array(&self, vertex_array: Self::VertexArray);

    unsafe fn bind_vertex_array(&self, vertex_array: Option<Self::VertexArray>);

    unsafe fn clear_color(&self, red: f32, green: f32, blue: f32, alpha: f32);

    unsafe fn supports_f64_precision() -> bool;

    unsafe fn clear_depth_f64(&self, depth: f64);

    unsafe fn clear_depth_f32(&self, depth: f32);

    unsafe fn clear_stencil(&self, stencil: i32);

    unsafe fn clear(&self, mask: u32);

    unsafe fn patch_parameter_i32(&self, parameter: u32, value: i32);

    unsafe fn pixel_store_i32(&self, parameter: u32, value: i32);

    unsafe fn pixel_store_bool(&self, parameter: u32, value: bool);

    unsafe fn bind_frag_data_location(
        &self, 
        program: Self::Program, 
        color_number: u32, 
        name: &str
    );

    unsafe fn buffer_data_size(&self, target: u32, size: i32, usage: u32);

    unsafe fn buffer_data_u8_slice(&self, target: u32, data: &[u8], usage: u32);

    unsafe fn buffer_sub_data_u8_slice(
        &self, 
        target: u32, 
        offset: i32, 
        src_data: &[u8]
    );

    unsafe fn get_buffer_sub_data(
        &self, 
        target: u32, 
        offset: i32, 
        dst_data: &mut [u8]
    );

    unsafe fn buffer_storage(
        &self, 
        target: u32, 
        size: i32, 
        data: Option<&[u8]>, 
        flags: u32
    );

    unsafe fn check_framebuffer_status(&self, target: u32) -> u32;

    unsafe fn clear_buffer_i32_slice(
        &self, 
        target: u32, 
        draw_buffer: u32, 
        values: &[i32]
    );

    unsafe fn clear_buffer_u32_slice(
        &self, 
        target: u32, 
        draw_buffer: u32, 
        values: &[u32]
    );

    unsafe fn clear_buffer_f32_slice(
        &self, 
        target: u32, 
        draw_buffer: u32, 
        values: &[f32]
    );

    unsafe fn clear_buffer_depth_stencil(
        &self, 
        target: u32, 
        draw_buffer: u32, 
        depth: f32, 
        stencil: i32
    );

    unsafe fn client_wait_sync(
        &self, 
        fence: Self::Fence, 
        flags: u32, 
        timeout: i32
    ) -> u32;

    unsafe fn wait_sync(&self, fence: Self::Fence, flags: u32, timeout: u64);

    unsafe fn copy_buffer_sub_data(
        &self, 
        src_target: u32, 
        dst_target: u32, 
        src_offset: i32, 
        dst_offset: i32, 
        size: i32
    );

    unsafe fn copy_tex_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: u32, 
        x: i32, 
        y: i32, 
        width: i32, 
        height: i32, 
        border: i32
    );

    unsafe fn copy_tex_sub_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        x: i32, 
        y: i32, 
        width: i32, 
        height: i32
    );

    unsafe fn copy_tex_sub_image_3d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        z_offset: i32, 
        x: i32, 
        y: i32, 
        width: i32, 
        height: i32
    );

    unsafe fn delete_buffer(&self, buffer: Self::Buffer);

    unsafe fn delete_framebuffer(&self, framebuffer: Self::Framebuffer);

    unsafe fn delete_query(&self, query: Self::Query);

    unsafe fn delete_renderbuffer(&self, renderbuffer: Self::Renderbuffer);

    unsafe fn delete_sampler(&self, texture: Self::Sampler);

    unsafe fn delete_sync(&self, fence: Self::Fence);

    unsafe fn delete_texture(&self, texture: Self::Texture);

    unsafe fn disable(&self, parameter: u32);

    unsafe fn disable_draw_buffer(&self, parameter: u32, draw_buffer: u32);

    unsafe fn disable_vertex_attrib_array(&self, index: u32);

    unsafe fn dispatch_compute(
        &self, 
        groups_x: u32, 
        groups_y: u32, 
        groups_z: u32
    );

    unsafe fn dispatch_compute_indirect(&self, offset: i32);

    unsafe fn draw_arrays(&self, mode: u32, first: i32, count: i32);

    unsafe fn draw_arrays_instanced(
        &self, 
        mode: u32, 
        first: i32, 
        count: i32, 
        instance_count: i32
    );

    unsafe fn draw_arrays_instanced_base_instance(
        &self, 
        mode: u32, 
        first: i32, 
        count: i32, 
        instance_count: i32, 
        base_instance: u32
    );

    unsafe fn draw_arrays_indirect_offset(&self, mode: u32, offset: i32);

    unsafe fn draw_buffer(&self, buffer: u32);

    unsafe fn draw_buffers(&self, buffers: &[u32]);

    unsafe fn draw_elements(
        &self, 
        mode: u32, 
        count: i32, 
        element_type: u32, 
        offset: i32
    );

    unsafe fn draw_elements_base_vertex(
        &self, 
        mode: u32, 
        count: i32, 
        element_type: u32, 
        offset: i32, 
        base_vertex: i32
    );

    unsafe fn draw_elements_instanced(
        &self, 
        mode: u32, 
        count: i32, 
        element_type: u32, 
        offset: i32, 
        instance_count: i32
    );

    unsafe fn draw_elements_instanced_base_vertex(
        &self, 
        mode: u32, 
        count: i32, 
        element_type: u32, 
        offset: i32, 
        instance_count: i32, 
        base_vertex: i32
    );

    unsafe fn draw_elements_instanced_base_vertex_base_instance(
        &self, 
        mode: u32, 
        count: i32, 
        element_type: u32, 
        offset: i32, 
        instance_count: i32, 
        base_vertex: i32, 
        base_instance: u32
    );

    unsafe fn draw_elements_indirect_offset(
        &self, 
        mode: u32, 
        element_type: u32, 
        offset: i32
    );

    unsafe fn enable(&self, parameter: u32);

    unsafe fn is_enabled(&self, parameter: u32) -> bool;

    unsafe fn enable_draw_buffer(&self, parameter: u32, draw_buffer: u32);

    unsafe fn enable_vertex_attrib_array(&self, index: u32);

    unsafe fn flush(&self);

    unsafe fn framebuffer_renderbuffer(
        &self, 
        target: u32, 
        attachment: u32, 
        renderbuffer_target: u32, 
        renderbuffer: Option<Self::Renderbuffer>
    );

    unsafe fn framebuffer_texture(
        &self, 
        target: u32, 
        attachment: u32, 
        texture: Option<Self::Texture>, 
        level: i32
    );

    unsafe fn framebuffer_texture_2d(
        &self, 
        target: u32, 
        attachment: u32, 
        texture_target: u32, 
        texture: Option<Self::Texture>, 
        level: i32
    );

    unsafe fn framebuffer_texture_3d(
        &self, 
        target: u32, 
        attachment: u32, 
        texture_target: u32, 
        texture: Option<Self::Texture>, 
        level: i32, 
        layer: i32
    );

    unsafe fn framebuffer_texture_layer(
        &self, 
        target: u32, 
        attachment: u32, 
        texture: Option<Self::Texture>, 
        level: i32, 
        layer: i32
    );

    unsafe fn front_face(&self, value: u32);

    unsafe fn get_error(&self) -> u32;

    unsafe fn get_tex_parameter_i32(&self, target: u32, parameter: u32) -> i32;

    unsafe fn get_buffer_parameter_i32(
        &self, 
        target: u32, 
        parameter: u32
    ) -> i32;

    unsafe fn get_parameter_i32(&self, parameter: u32) -> i32;

    unsafe fn get_parameter_i32_slice(&self, parameter: u32, out: &mut [i32]);

    unsafe fn get_parameter_f32(&self, parameter: u32) -> f32;

    unsafe fn get_parameter_f32_slice(&self, parameter: u32, out: &mut [f32]);

    unsafe fn get_parameter_indexed_i32(
        &self, 
        parameter: u32, 
        index: u32
    ) -> i32;

    unsafe fn get_parameter_indexed_string(
        &self, 
        parameter: u32, 
        index: u32
    ) -> String;

    unsafe fn get_parameter_string(&self, parameter: u32) -> String;

    unsafe fn get_active_uniform_block_parameter_i32(
        &self, 
        program: Self::Program, 
        uniform_block_index: u32, 
        parameter: u32
    ) -> i32;

    unsafe fn get_active_uniform_block_parameter_i32_slice(
        &self, 
        program: Self::Program, 
        uniform_block_index: u32, 
        parameter: u32, 
        out: &mut [i32]
    );

    unsafe fn get_active_uniform_block_name(
        &self, 
        program: Self::Program, 
        uniform_block_index: u32
    ) -> String;

    unsafe fn get_uniform_location(
        &self, 
        program: Self::Program, 
        name: &str
    ) -> Option<Self::UniformLocation>;

    unsafe fn get_attrib_location(
        &self, 
        program: Self::Program, 
        name: &str
    ) -> Option<u32>;

    unsafe fn bind_attrib_location(
        &self, 
        program: Self::Program, 
        index: u32, 
        name: &str
    );

    unsafe fn get_active_attributes(&self, program: Self::Program) -> u32;

    unsafe fn get_active_attribute(
        &self, 
        program: Self::Program, 
        index: u32
    ) -> Option<ActiveAttribute>;

    unsafe fn get_sync_status(&self, fence: Self::Fence) -> u32;

    unsafe fn is_sync(&self, fence: Self::Fence) -> bool;

    unsafe fn renderbuffer_storage(
        &self, 
        target: u32, 
        internal_format: u32, 
        width: i32, 
        height: i32
    );

    unsafe fn renderbuffer_storage_multisample(
        &self, 
        target: u32, 
        samples: i32, 
        internal_format: u32, 
        width: i32, 
        height: i32
    );

    unsafe fn sampler_parameter_f32(
        &self, 
        sampler: Self::Sampler, 
        name: u32, 
        value: f32
    );

    unsafe fn sampler_parameter_f32_slice(
        &self, 
        sampler: Self::Sampler, 
        name: u32, 
        value: &[f32]
    );

    unsafe fn sampler_parameter_i32(
        &self, 
        sampler: Self::Sampler, 
        name: u32, 
        value: i32
    );

    unsafe fn generate_mipmap(&self, target: u32);

    unsafe fn tex_image_1d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        border: i32, 
        format: u32, 
        ty: u32, 
        pixels: Option<&[u8]>
    );

    unsafe fn compressed_tex_image_1d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        border: i32, 
        image_size: i32, 
        pixels: &[u8]
    );

    unsafe fn tex_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        height: i32, 
        border: i32, 
        format: u32, 
        ty: u32, 
        pixels: Option<&[u8]>
    );

    unsafe fn tex_image_2d_multisample(
        &self, 
        target: u32, 
        samples: i32, 
        internal_format: i32, 
        width: i32, 
        height: i32, 
        fixed_sample_locations: bool
    );

    unsafe fn compressed_tex_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        height: i32, 
        border: i32, 
        image_size: i32, 
        pixels: &[u8]
    );

    unsafe fn tex_image_3d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        height: i32, 
        depth: i32, 
        border: i32, 
        format: u32, 
        ty: u32, 
        pixels: Option<&[u8]>
    );

    unsafe fn compressed_tex_image_3d(
        &self, 
        target: u32, 
        level: i32, 
        internal_format: i32, 
        width: i32, 
        height: i32, 
        depth: i32, 
        border: i32, 
        image_size: i32, 
        pixels: &[u8]
    );

    unsafe fn tex_storage_1d(
        &self, 
        target: u32, 
        levels: i32, 
        internal_format: u32, 
        width: i32
    );

    unsafe fn tex_storage_2d(
        &self, 
        target: u32, 
        levels: i32, 
        internal_format: u32, 
        width: i32, 
        height: i32
    );

    unsafe fn tex_storage_2d_multisample(
        &self, 
        target: u32, 
        samples: i32, 
        internal_format: u32, 
        width: i32, 
        height: i32, 
        fixed_sample_locations: bool
    );

    unsafe fn tex_storage_3d(
        &self, 
        target: u32, 
        levels: i32, 
        internal_format: u32, 
        width: i32, 
        height: i32, 
        depth: i32
    );

    unsafe fn get_uniform_i32(
        &self, 
        program: Self::Program, 
        location: &Self::UniformLocation, 
        v: &mut [i32]
    );

    unsafe fn get_uniform_f32(
        &self, 
        program: Self::Program, 
        location: &Self::UniformLocation, 
        v: &mut [f32]
    );

    unsafe fn uniform_1_i32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: i32
    );

    unsafe fn uniform_2_i32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: i32, 
        y: i32
    );

    unsafe fn uniform_3_i32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: i32, 
        y: i32, 
        z: i32
    );

    unsafe fn uniform_4_i32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: i32, 
        y: i32, 
        z: i32, 
        w: i32
    );

    unsafe fn uniform_1_i32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[i32]
    );

    unsafe fn uniform_2_i32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[i32]
    );

    unsafe fn uniform_3_i32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[i32]
    );

    unsafe fn uniform_4_i32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[i32]
    );

    unsafe fn uniform_1_u32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: u32
    );

    unsafe fn uniform_2_u32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: u32, 
        y: u32
    );

    unsafe fn uniform_3_u32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: u32, 
        y: u32, 
        z: u32
    );

    unsafe fn uniform_4_u32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: u32, 
        y: u32, 
        z: u32, 
        w: u32
    );

    unsafe fn uniform_1_u32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[u32]
    );

    unsafe fn uniform_2_u32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[u32]
    );

    unsafe fn uniform_3_u32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[u32]
    );

    unsafe fn uniform_4_u32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[u32]
    );

    unsafe fn uniform_1_f32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: f32
    );

    unsafe fn uniform_2_f32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: f32, 
        y: f32
    );

    unsafe fn uniform_3_f32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: f32, 
        y: f32, 
        z: f32
    );

    unsafe fn uniform_4_f32(
        &self, 
        location: Option<&Self::UniformLocation>, 
        x: f32, 
        y: f32, 
        z: f32, 
        w: f32
    );

    unsafe fn uniform_1_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[f32]
    );

    unsafe fn uniform_2_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[f32]
    );

    unsafe fn uniform_3_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[f32]
    );

    unsafe fn uniform_4_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        v: &[f32]
    );

    unsafe fn uniform_matrix_2_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        transpose: bool, 
        v: &[f32]
    );

    unsafe fn uniform_matrix_3_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        transpose: bool, 
        v: &[f32]
    );

    unsafe fn uniform_matrix_4_f32_slice(
        &self, 
        location: Option<&Self::UniformLocation>, 
        transpose: bool, 
        v: &[f32]
    );

    unsafe fn unmap_buffer(&self, target: u32);

    unsafe fn cull_face(&self, value: u32);

    unsafe fn color_mask(&self, red: bool, green: bool, blue: bool, alpha: bool);

    unsafe fn color_mask_draw_buffer(
        &self, 
        buffer: u32, 
        red: bool, 
        green: bool, 
        blue: bool, 
        alpha: bool
    );

    unsafe fn depth_mask(&self, value: bool);

    unsafe fn blend_color(&self, red: f32, green: f32, blue: f32, alpha: f32);

    unsafe fn line_width(&self, width: f32);

    unsafe fn map_buffer_range(
        &self, 
        target: u32, 
        offset: i32, 
        length: i32, 
        access: u32
    ) -> *mut u8;

    unsafe fn flush_mapped_buffer_range(
        &self, 
        target: u32, 
        offset: i32, 
        length: i32
    );

    unsafe fn invalidate_buffer_sub_data(
        &self, 
        target: u32, 
        offset: i32, 
        length: i32
    );

    unsafe fn invalidate_framebuffer(&self, target: u32, attachments: &[u32]);

    unsafe fn polygon_offset(&self, factor: f32, units: f32);

    unsafe fn polygon_mode(&self, face: u32, mode: u32);

    unsafe fn finish(&self);

    unsafe fn bind_texture(&self, target: u32, texture: Option<Self::Texture>);

    unsafe fn bind_sampler(&self, unit: u32, sampler: Option<Self::Sampler>);

    unsafe fn active_texture(&self, unit: u32);

    unsafe fn fence_sync(
        &self, 
        condition: u32, 
        flags: u32
    ) -> Result<Self::Fence, String>;

    unsafe fn tex_parameter_f32(&self, target: u32, parameter: u32, value: f32);

    unsafe fn tex_parameter_i32(&self, target: u32, parameter: u32, value: i32);

    unsafe fn tex_parameter_f32_slice(
        &self, 
        target: u32, 
        parameter: u32, 
        values: &[f32]
    );

    unsafe fn tex_parameter_i32_slice(
        &self, 
        target: u32, 
        parameter: u32, 
        values: &[i32]
    );

    unsafe fn tex_sub_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        width: i32, 
        height: i32, 
        format: u32, 
        ty: u32, 
        pixels: PixelUnpackData<'_>
    );

    unsafe fn compressed_tex_sub_image_2d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        width: i32, 
        height: i32, 
        format: u32, 
        pixels: CompressedPixelUnpackData<'_>
    );

    unsafe fn tex_sub_image_3d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        z_offset: i32, 
        width: i32, 
        height: i32, 
        depth: i32, 
        format: u32, 
        ty: u32, 
        pixels: PixelUnpackData<'_>
    );

    unsafe fn compressed_tex_sub_image_3d(
        &self, 
        target: u32, 
        level: i32, 
        x_offset: i32, 
        y_offset: i32, 
        z_offset: i32, 
        width: i32, 
        height: i32, 
        depth: i32, 
        format: u32, 
        pixels: CompressedPixelUnpackData<'_>
    );

    unsafe fn depth_func(&self, func: u32);

    unsafe fn depth_range_f32(&self, near: f32, far: f32);

    unsafe fn depth_range_f64(&self, near: f64, far: f64);

    unsafe fn depth_range_f64_slice(
        &self, 
        first: u32, 
        count: i32, 
        values: &[[f64; 2]]
    );

    unsafe fn scissor(&self, x: i32, y: i32, width: i32, height: i32);

    unsafe fn scissor_slice(
        &self, 
        first: u32, 
        count: i32, 
        scissors: &[[i32; 4]]
    );

    unsafe fn vertex_attrib_divisor(&self, index: u32, divisor: u32);

    unsafe fn vertex_attrib_pointer_f32(
        &self, 
        index: u32, 
        size: i32, 
        data_type: u32, 
        normalized: bool, 
        stride: i32, 
        offset: i32
    );

    unsafe fn vertex_attrib_pointer_i32(
        &self, 
        index: u32, 
        size: i32, 
        data_type: u32, 
        stride: i32, 
        offset: i32
    );

    unsafe fn vertex_attrib_pointer_f64(
        &self, 
        index: u32, 
        size: i32, 
        data_type: u32, 
        stride: i32, 
        offset: i32
    );

    unsafe fn vertex_attrib_format_f32(
        &self, 
        index: u32, 
        size: i32, 
        data_type: u32, 
        normalized: bool, 
        relative_offset: u32
    );

    unsafe fn vertex_attrib_format_i32(
        &self, 
        index: u32, 
        size: i32, 
        data_type: u32, 
        relative_offset: u32
    );

    unsafe fn vertex_attrib_1_f32(&self, index: u32, x: f32);

    unsafe fn vertex_attrib_2_f32(&self, index: u32, x: f32, y: f32);

    unsafe fn vertex_attrib_3_f32(&self, index: u32, x: f32, y: f32, z: f32);

    unsafe fn vertex_attrib_4_f32(
        &self, 
        index: u32, 
        x: f32, 
        y: f32, 
        z: f32, 
        w: f32
    );

    unsafe fn vertex_attrib_1_f32_slice(&self, index: u32, v: &[f32]);

    unsafe fn vertex_attrib_2_f32_slice(&self, index: u32, v: &[f32]);

    unsafe fn vertex_attrib_3_f32_slice(&self, index: u32, v: &[f32]);

    unsafe fn vertex_attrib_4_f32_slice(&self, index: u32, v: &[f32]);

    unsafe fn vertex_attrib_binding(
        &self, 
        attrib_index: u32, 
        binding_index: u32
    );

    unsafe fn vertex_binding_divisor(&self, binding_index: u32, divisor: u32);

    unsafe fn viewport(&self, x: i32, y: i32, width: i32, height: i32);

    unsafe fn viewport_f32_slice(
        &self, 
        first: u32, 
        count: i32, 
        values: &[[f32; 4]]
    );

    unsafe fn blend_equation(&self, mode: u32);

    unsafe fn blend_equation_draw_buffer(&self, draw_buffer: u32, mode: u32);

    unsafe fn blend_equation_separate(&self, mode_rgb: u32, mode_alpha: u32);

    unsafe fn blend_equation_separate_draw_buffer(
        &self, 
        buffer: u32, 
        mode_rgb: u32, 
        mode_alpha: u32
    );

    unsafe fn blend_func(&self, src: u32, dst: u32);

    unsafe fn blend_func_draw_buffer(
        &self, 
        draw_buffer: u32, 
        src: u32, 
        dst: u32
    );

    unsafe fn blend_func_separate(
        &self, 
        src_rgb: u32, 
        dst_rgb: u32, 
        src_alpha: u32, 
        dst_alpha: u32
    );

    unsafe fn blend_func_separate_draw_buffer(
        &self, 
        draw_buffer: u32, 
        src_rgb: u32, 
        dst_rgb: u32, 
        src_alpha: u32, 
        dst_alpha: u32
    );

    unsafe fn stencil_func(&self, func: u32, reference: i32, mask: u32);

    unsafe fn stencil_func_separate(
        &self, 
        face: u32, 
        func: u32, 
        reference: i32, 
        mask: u32
    );

    unsafe fn stencil_mask(&self, mask: u32);

    unsafe fn stencil_mask_separate(&self, face: u32, mask: u32);

    unsafe fn stencil_op(&self, stencil_fail: u32, depth_fail: u32, pass: u32);

    unsafe fn stencil_op_separate(
        &self, 
        face: u32, 
        stencil_fail: u32, 
        depth_fail: u32, 
        pass: u32
    );

    unsafe fn debug_message_control(
        &self, 
        source: u32, 
        msg_type: u32, 
        severity: u32, 
        ids: &[u32], 
        enabled: bool
    );

    unsafe fn debug_message_insert<S>(
        &self, 
        source: u32, 
        msg_type: u32, 
        id: u32, 
        severity: u32, 
        msg: S
    )
    where
        S: AsRef<str>;

    unsafe fn debug_message_callback<F>(&self, callback: F)
    where
        F: FnMut(u32, u32, u32, u32, &str);

    unsafe fn get_debug_message_log(
        &self, 
        count: u32
    ) -> Vec<DebugMessageLogEntry>;

    unsafe fn push_debug_group<S>(&self, source: u32, id: u32, message: S)
    where
        S: AsRef<str>;

    unsafe fn pop_debug_group(&self);

    unsafe fn object_label<S>(
        &self, 
        identifier: u32, 
        name: u32, 
        label: Option<S>
    )
    where
        S: AsRef<str>;

    unsafe fn get_object_label(&self, identifier: u32, name: u32) -> String;

    unsafe fn object_ptr_label<S>(&self, sync: Self::Fence, label: Option<S>)
    where
        S: AsRef<str>;

    unsafe fn get_object_ptr_label(&self, sync: Self::Fence) -> String;

    unsafe fn get_uniform_block_index(
        &self, 
        program: Self::Program, 
        name: &str
    ) -> Option<u32>;

    unsafe fn uniform_block_binding(
        &self, 
        program: Self::Program, 
        index: u32, 
        binding: u32
    );

    unsafe fn get_shader_storage_block_index(
        &self, 
        program: Self::Program, 
        name: &str
    ) -> Option<u32>;

    unsafe fn shader_storage_block_binding(
        &self, 
        program: Self::Program, 
        index: u32, 
        binding: u32
    );

    unsafe fn read_buffer(&self, src: u32);

    unsafe fn read_pixels(
        &self, 
        x: i32, 
        y: i32, 
        width: i32, 
        height: i32, 
        format: u32, 
        gltype: u32, 
        pixels: PixelPackData<'_>
    );

    unsafe fn begin_query(&self, target: u32, query: Self::Query);

    unsafe fn end_query(&self, target: u32);

    unsafe fn get_query_parameter_u32(
        &self, 
        query: Self::Query, 
        parameter: u32
    ) -> u32;

    unsafe fn delete_transform_feedback(
        &self, 
        transform_feedback: Self::TransformFeedback
    );

    unsafe fn create_transform_feedback(
        &self
    ) -> Result<Self::TransformFeedback, String>;

    unsafe fn bind_transform_feedback(
        &self, 
        target: u32, 
        transform_feedback: Option<Self::TransformFeedback>
    );

    unsafe fn begin_transform_feedback(&self, primitive_mode: u32);

    unsafe fn end_transform_feedback(&self);

    unsafe fn pause_transform_feedback(&self);

    unsafe fn resume_transform_feedback(&self);

    unsafe fn transform_feedback_varyings(
        &self, 
        program: Self::Program, 
        varyings: &[&str], 
        buffer_mode: u32
    );

    unsafe fn get_transform_feedback_varying(
        &self, 
        program: Self::Program, 
        index: u32
    ) -> Option<ActiveTransformFeedback>;

    unsafe fn memory_barrier(&self, barriers: u32);

    unsafe fn memory_barrier_by_region(&self, barriers: u32);

    unsafe fn bind_image_texture(
        &self, 
        unit: u32, 
        texture: Self::Texture, 
        level: i32, 
        layered: bool, 
        layer: i32, 
        access: u32, 
        format: u32
    );

}

Associated Types

Required methods

Implementors