Struct WebGLThread 

pub(crate) struct WebGLThread {
    device_map: HashMap<PainterId, Rc<Device>>,
    compositor_api: CrossProcessCompositorApi,
    contexts: FxHashMap<WebGLContextId, GLContextData>,
    cached_context_info: FxHashMap<WebGLContextId, WebGLContextInfo>,
    bound_context_id: Option<WebGLContextId>,
    external_image_id_manager: WebRenderExternalImageIdManager,
    receiver: RoutedReceiver<WebGLMsg>,
    sender: WebGLSender<WebGLMsg>,
    webrender_swap_chains: SwapChains<WebGLContextId, Device>,
    painter_surfman_details_map: PainterSurfmanDetailsMap,
    busy_webgl_context_map: WebGLContextBusyMap,
    pub webxr_bridge: Option<WebXRBridge>,
}

A WebGLThread manages the life cycle and message multiplexing of a set of WebGLContexts living in the same thread.

Fields

device_map: HashMap<PainterId, Rc<Device>>

The GPU device.

compositor_api: CrossProcessCompositorApi

Channel used to generate/update or delete ImageKeys.

contexts: FxHashMap<WebGLContextId, GLContextData>

Map of live WebGLContexts.

cached_context_info: FxHashMap<WebGLContextId, WebGLContextInfo>

Cached information for WebGLContexts.

bound_context_id: Option<WebGLContextId>

Current bound context.

external_image_id_manager: WebRenderExternalImageIdManager

A WebRenderExternalImageIdManager used to generate new ExternalImageIds for our WebGL contexts.

receiver: RoutedReceiver<WebGLMsg>

The receiver that will be used for processing WebGL messages.

sender: WebGLSender<WebGLMsg>

The receiver that should be used to send WebGL messages for processing.

webrender_swap_chains: SwapChains<WebGLContextId, Device>

The swap chains used by webrender

painter_surfman_details_map: PainterSurfmanDetailsMap

The per-painter details of the underlying surfman connection.

busy_webgl_context_map: WebGLContextBusyMap

A usage map used to delay the deletion of WebGL contexts until all WebRender rendering is finished, so that any existing Surfaces can be properly released.

webxr_bridge: Option<WebXRBridge>

The bridge to WebXR

Implementations

impl WebGLThread

pub(crate) fn new(_: WebGLThreadInit) -> Self

Create a new instance of WebGLThread.

pub(crate) fn run_on_own_thread(init: WebGLThreadInit)

Perform all initialization required to run an instance of WebGLThread in parallel on its own dedicated thread.

fn process(&mut self)

fn handle_msg(&mut self, msg: WebGLMsg, webgl_chan: &WebGLChan) -> bool

Handles a generic WebGLMsg message

fn get_or_create_device_for_painter( &mut self, painter_id: PainterId, ) -> Rc<Device>

fn handle_webxr_command(&mut self, command: WebXRCommand)

Handles a WebXR message

fn device_for_context(&self, context_id: WebGLContextId) -> Rc<Device>

pub(crate) fn maybe_device_for_context( &self, context_id: WebGLContextId, ) -> Option<Rc<Device>>

A function like Self::device_for_context, except that it does not panic if the context cannot be found. This is useful for WebXR, which might try to access WebGL contexts after they have been cleaned up.

fn handle_webgl_command( &mut self, context_id: WebGLContextId, command: WebGLCommand, backtrace: WebGLCommandBacktrace, )

Handles a WebGLCommand for a specific WebGLContext

fn create_webgl_context( &mut self, painter_id: PainterId, webgl_version: WebGLVersion, requested_size: Size2D<u32>, attributes: GLContextAttributes, ) -> Result<(WebGLContextId, GLLimits), String>

Creates a new WebGLContext

fn resize_webgl_context( &mut self, context_id: WebGLContextId, requested_size: Size2D<u32>, ) -> Result<(), String>

Resizes a WebGLContext

fn handle_finished_rendering_to_context(&mut self, context_id: WebGLContextId)

Note that rendering has finished in WebRender for this context. If the context is marked for deletion, it will now be deleted.

fn remove_webgl_context(&mut self, context_id: WebGLContextId)

Removes a WebGLContext and releases attached resources.

fn handle_swap_buffers( &mut self, canvas_epoch: Option<Epoch>, context_ids: Vec<WebGLContextId>, _sent_time: u64, )

fn surface_access(&self) -> SurfaceAccess

Which access mode to use

pub(crate) fn make_current_if_needed( &mut self, context_id: WebGLContextId, ) -> Option<&GLContextData>

Gets a reference to a Context for a given WebGLContextId and makes it current if required.

pub(crate) fn make_current_if_needed_mut( &mut self, context_id: WebGLContextId, ) -> Option<&mut GLContextData>

Gets a mutable reference to a GLContextWrapper for a WebGLContextId and makes it current if required.

fn update_webrender_image_for_context( &mut self, context_id: WebGLContextId, size: Size2D<i32>, has_alpha: bool, canvas_epoch: Option<Epoch>, )

Tell WebRender to invalidate any cached tiles for a given WebGLContextId when the underlying surface has changed e.g due to resize or buffer swap

fn external_image_data( &self, context_id: WebGLContextId, ) -> SerializableImageData

Helper function to create a ImageData::External instance.

fn get_glsl_version(gl: &Gl) -> WebGLSLVersion

Gets the GLSL Version supported by a GLContext.

fn handle_set_image_key( &mut self, context_id: WebGLContextId, image_key: ImageKey, )

Trait Implementations

impl GLContexts<SurfmanGL> for WebGLThread

fn device(&self, context_id: WebXRContextId) -> Option<Rc<Device>>

fn context(&mut self, context_id: WebXRContextId) -> Option<&mut Context>

fn bindings(&mut self, context_id: WebXRContextId) -> Option<&Context>