Struct webrender::Device

pub struct Device { /* fields omitted */ }

Methods

impl Device

pub fn new(
    gl: Rc<dyn Gl>,
    resource_override_path: Option<PathBuf>,
    upload_method: UploadMethod,
    cached_programs: Option<Rc<ProgramCache>>,
    allow_pixel_local_storage_support: bool,
    allow_texture_storage_support: bool,
    allow_texture_swizzling: bool,
    dump_shader_source: Option<String>,
    surface_origin_is_top_left: bool,
    panic_on_gl_error: bool
) -> Device

pub fn gl(&self) -> &dyn Gl

pub fn rc_gl(&self) -> &Rc<dyn Gl>

pub fn update_program_cache(&mut self, cached_programs: Rc<ProgramCache>)

pub fn clamp_max_texture_size(&mut self, size: i32)

Ensures that the maximum texture size is less than or equal to the provided value. If the provided value is less than the value supported by the driver, the latter is used.

pub fn max_texture_size(&self) -> i32

Returns the limit on texture dimensions (width or height).

pub fn surface_origin_is_top_left(&self) -> bool

pub fn max_texture_layers(&self) -> usize

Returns the limit on texture array layers.

pub fn get_capabilities(&self) -> &Capabilities

pub fn preferred_color_formats(&self) -> TextureFormatPair<ImageFormat>

pub fn swizzle_settings(&self) -> Option<SwizzleSettings>

pub fn optimal_pbo_stride(&self) -> NonZeroUsize

pub fn reset_state(&mut self)

pub fn compile_shader(
    gl: &dyn Gl,
    name: &str,
    shader_type: GLenum,
    source: &String,
    requires_null_terminated_shader_source: bool
) -> Result<GLuint, ShaderError>

pub fn begin_frame(&mut self) -> GpuFrameId

pub fn bind_texture<S>(&mut self, slot: S, texture: &Texture, swizzle: Swizzle) where
    S: Into<TextureSlot>, 

pub fn bind_external_texture<S>(
    &mut self,
    slot: S,
    external_texture: &ExternalTexture
) where
    S: Into<TextureSlot>, 

pub fn bind_read_target_impl(&mut self, fbo_id: FBOId)

pub fn bind_read_target(&mut self, target: ReadTarget)

pub fn reset_read_target(&mut self)

pub fn reset_draw_target(&mut self)

pub fn bind_draw_target(&mut self, target: DrawTarget)

pub fn create_fbo(&mut self) -> FBOId

Creates an unbound FBO object. Additional attachment API calls are required to make it complete.

pub fn create_fbo_for_external_texture(&mut self, texture_id: u32) -> FBOId

Creates an FBO with the given texture bound as the color attachment.

pub fn delete_fbo(&mut self, fbo: FBOId)

pub fn bind_external_draw_target(&mut self, fbo_id: FBOId)

pub fn link_program(
    &mut self,
    program: &mut Program,
    descriptor: &VertexDescriptor
) -> Result<(), ShaderError>

Link a program, attaching the supplied vertex format.

If create_program() finds a binary shader on disk, it will kick off linking immediately, which some drivers (notably ANGLE) run in parallel on background threads. As such, this function should ideally be run sometime later, to give the driver time to do that before blocking due to an API call accessing the shader.

This generally means that the first run of the application will have to do a bunch of blocking work to compile the shader from source, but subsequent runs should load quickly.

pub fn bind_program(&mut self, program: &Program)

pub fn create_texture(
    &mut self,
    target: TextureTarget,
    format: ImageFormat,
    width: i32,
    height: i32,
    filter: TextureFilter,
    render_target: Option<RenderTargetInfo>,
    layer_count: i32
) -> Texture

pub fn blit_renderable_texture(&mut self, dst: &mut Texture, src: &Texture)

Copies the contents from one renderable texture to another.

pub fn invalidate_render_target(&mut self, texture: &Texture)

Notifies the device that the contents of a render target are no longer needed.

FIXME(bholley): We could/should invalidate the depth targets earlier than the color targets, i.e. immediately after each pass.

pub fn reuse_render_target<T: Texel>(
    &mut self,
    texture: &mut Texture,
    rt_info: RenderTargetInfo
)

Notifies the device that a render target is about to be reused.

This method adds or removes a depth target as necessary.

pub fn blit_render_target(
    &mut self,
    src_target: ReadTarget,
    src_rect: FramebufferIntRect,
    dest_target: DrawTarget,
    dest_rect: FramebufferIntRect,
    filter: TextureFilter
)

Perform a blit between src_target and dest_target. This will overwrite self.bound_read_fbo and self.bound_draw_fbo.

pub fn blit_render_target_invert_y(
    &mut self,
    src_target: ReadTarget,
    src_rect: FramebufferIntRect,
    dest_target: DrawTarget,
    dest_rect: FramebufferIntRect
)

Performs a blit while flipping vertically. Useful for blitting textures (which use origin-bottom-left) to the main framebuffer (which uses origin-top-left).

pub fn delete_texture(&mut self, texture: Texture)

pub fn delete_program(&mut self, program: Program)

pub fn create_program_linked(
    &mut self,
    base_filename: &'static str,
    features: String,
    descriptor: &VertexDescriptor
) -> Result<Program, ShaderError>

Create a shader program and link it immediately.

pub fn create_program(
    &mut self,
    base_filename: &'static str,
    features: String
) -> Result<Program, ShaderError>

Create a shader program. This does minimal amount of work to start loading a binary shader. If a binary shader is found, we invoke glProgramBinary, which, at least on ANGLE, will load and link the binary on a background thread. This can speed things up later when we invoke link_program().

pub fn bind_shader_samplers<S>(
    &mut self,
    program: &Program,
    bindings: &[(&'static str, S)]
) where
    S: Into<TextureSlot> + Copy, 

pub fn get_uniform_location(
    &self,
    program: &Program,
    name: &str
) -> UniformLocation

pub fn set_uniforms(&self, program: &Program, transform: &Transform3D<f32>)

pub fn switch_mode(&self, mode: i32)

pub fn create_pbo(&mut self) -> PBO

pub fn create_pbo_with_size(&mut self, size: usize) -> PBO

pub fn read_pixels_into_pbo(
    &mut self,
    read_target: ReadTarget,
    rect: DeviceIntRect,
    format: ImageFormat,
    pbo: &PBO
)

pub fn map_pbo_for_readback<'a>(
    &'a mut self,
    pbo: &'a PBO
) -> Option<BoundPBO<'a>>

pub fn delete_pbo(&mut self, pbo: PBO)

pub fn required_upload_size_and_stride(
    &self,
    size: DeviceIntSize,
    format: ImageFormat
) -> (usize, usize)

Returns the size and stride in bytes required to upload an area of pixels of the specified size, to a texture of the specified format.

pub fn upload_texture<'a, T>(
    &'a mut self,
    texture: &'a Texture,
    pbo: &PBO,
    upload_size: usize
) -> TextureUploader<'a, T>

Returns a TextureUploader which can be used to upload texture data to texture. The total size in bytes is specified by upload_size, and must be greater than zero and at least as large as the sum of the sizes returned from required_upload_size_and_stride() for each subsequent call to TextureUploader.upload().

pub fn upload_texture_immediate<T: Texel>(
    &mut self,
    texture: &Texture,
    pixels: &[T]
)

Performs an immediate (non-PBO) texture upload.

pub fn read_pixels(&mut self, img_desc: &ImageDescriptor) -> Vec<u8>

pub fn read_pixels_into(
    &mut self,
    rect: FramebufferIntRect,
    format: ImageFormat,
    output: &mut [u8]
)

Read rectangle of pixels into the specified output slice.

pub fn get_tex_image_into(
    &mut self,
    texture: &Texture,
    format: ImageFormat,
    output: &mut [u8]
)

Get texels of a texture into the specified output slice.

pub fn attach_read_texture_external(
    &mut self,
    texture_id: GLuint,
    target: TextureTarget,
    layer_id: i32
)

pub fn attach_read_texture(&mut self, texture: &Texture, layer_id: i32)

pub fn bind_vao(&mut self, vao: &VAO)

pub fn bind_custom_vao(&mut self, vao: &CustomVAO)

pub fn create_custom_vao(&mut self, streams: &[Stream]) -> CustomVAO

pub fn delete_custom_vao(&mut self, vao: CustomVAO)

pub fn create_vbo<T>(&mut self) -> VBO<T>

pub fn delete_vbo<T>(&mut self, vbo: VBO<T>)

pub fn create_vao(&mut self, descriptor: &VertexDescriptor) -> VAO

pub fn delete_vao(&mut self, vao: VAO)

pub fn allocate_vbo<V>(
    &mut self,
    vbo: &mut VBO<V>,
    count: usize,
    usage_hint: VertexUsageHint
)

pub fn fill_vbo<V>(&mut self, vbo: &VBO<V>, data: &[V], offset: usize)

pub fn create_vao_with_new_instances(
    &mut self,
    descriptor: &VertexDescriptor,
    base_vao: &VAO
) -> VAO

pub fn update_vao_main_vertices<V>(
    &mut self,
    vao: &VAO,
    vertices: &[V],
    usage_hint: VertexUsageHint
)

pub fn update_vao_instances<V>(
    &mut self,
    vao: &VAO,
    instances: &[V],
    usage_hint: VertexUsageHint
)

pub fn update_vao_indices<I>(
    &mut self,
    vao: &VAO,
    indices: &[I],
    usage_hint: VertexUsageHint
)

pub fn draw_triangles_u16(&mut self, first_vertex: i32, index_count: i32)

pub fn draw_triangles_u32(&mut self, first_vertex: i32, index_count: i32)

pub fn draw_nonindexed_points(&mut self, first_vertex: i32, vertex_count: i32)

pub fn draw_nonindexed_lines(&mut self, first_vertex: i32, vertex_count: i32)

pub fn draw_indexed_triangles_instanced_u16(
    &mut self,
    index_count: i32,
    instance_count: i32
)

pub fn end_frame(&mut self)

pub fn clear_target(
    &self,
    color: Option<[f32; 4]>,
    depth: Option<f32>,
    rect: Option<FramebufferIntRect>
)

pub fn enable_depth(&self)

pub fn disable_depth(&self)

pub fn set_depth_func(&self, depth_func: DepthFunction)

pub fn enable_depth_write(&self)

pub fn disable_depth_write(&self)

pub fn disable_stencil(&self)

pub fn set_scissor_rect(&self, rect: FramebufferIntRect)

pub fn enable_scissor(&self)

pub fn disable_scissor(&self)

pub fn set_blend(&mut self, enable: bool)

pub fn set_blend_mode_alpha(&mut self)

pub fn set_blend_mode_premultiplied_alpha(&mut self)

pub fn set_blend_mode_premultiplied_dest_out(&mut self)

pub fn set_blend_mode_multiply(&mut self)

pub fn set_blend_mode_subpixel_pass0(&mut self)

pub fn set_blend_mode_subpixel_pass1(&mut self)

pub fn set_blend_mode_subpixel_with_bg_color_pass0(&mut self)

pub fn set_blend_mode_subpixel_with_bg_color_pass1(&mut self)

pub fn set_blend_mode_subpixel_with_bg_color_pass2(&mut self)

pub fn set_blend_mode_subpixel_constant_text_color(&mut self, color: ColorF)

pub fn set_blend_mode_subpixel_dual_source(&mut self)

pub fn set_blend_mode_show_overdraw(&mut self)

pub fn set_blend_mode_max(&mut self)

pub fn set_blend_mode_min(&mut self)

pub fn set_blend_mode_advanced(&mut self, mode: MixBlendMode)

pub fn supports_extension(&self, extension: &str) -> bool

pub fn enable_pixel_local_storage(&mut self, enable: bool)

Enable the pixel local storage functionality. Caller must have already confirmed the device supports this.

pub fn echo_driver_messages(&self)

pub fn gl_describe_format(&self, format: ImageFormat) -> FormatDesc

pub fn report_memory(&self) -> MemoryReport

Generates a memory report for the resources managed by the device layer.