Struct WebGlRenderer 

pub struct WebGlRenderer { /* private fields */ }

Vello GPU’s WebGL2 renderer.

Note that any operation of WebGlRenderer might modify the global state of the underlying WebGL context; state like the active texture unit and texture bindings are therefore not guaranteed to be restored to their original value after each method call.

Context loss

Methods on WebGlRenderer are not guaranteed to return an error if the WebGL context has been lost; therefore, if not handled properly, rendering or other operations might silently fail. To prevent this, clients should create their own listener for the WebGL context lost event and react to it appropriately.

Implementations

impl WebGlRenderer

pub fn probe( &mut self, elements: &[ProbeFeature], ) -> Result<WebGlPendingProbe, WebGlProbeError>

Conduct a probing operation.

The WebGL drivers of certain devices are known to be buggy and might therefore not work correctly with Vello GPU. In the best case, it will simply result in a program crash, but in the worst case it can instead result in a silent failure, meaning that no explicit error is thrown, but the rendered contents of Vello GPU will either be completely empty or look glitchy.

The purpose of this method is to run a sanity check to ensure that running Vello GPU on this device actually results in visible and correct output. How this achieved is by drawing a selection of small elements into a small canvas, and comparing the final output against a reference image.

This method will return a handle that allows inspecting the results of the probe once the results of the probe scene can be copied back from GPU to CPU. For performance reasons, anything in-between mostly happens asynchronously.

impl WebGlRenderer

pub fn new(canvas: &HtmlCanvasElement) -> Result<(Self, Resources), WebGlError>

Creates a new WebGL2 renderer and its persistent resources.

This blocks until shader compilation and linking finish. Use WebGlRenderer::begin when initialization must not block the browser’s main thread.

pub fn new_with( canvas: &HtmlCanvasElement, settings: RenderSettings, use_depth_buffer: bool, ) -> Result<(Self, Resources), WebGlError>

Creates a new WebGL2 renderer and its persistent resources with specific settings.

When use_depth_buffer is true, the WebGL context allocates a depth buffer and the renderer uses it for opaque-strip occlusion. Disabling it reduces GPU memory usage, but can increase overdraw.

pub fn begin( canvas: &HtmlCanvasElement, ) -> Result<(WebGlRendererInit, Resources), WebGlError>

Begins creating a WebGL2 renderer and its persistent resources.

When KHR_parallel_shader_compile is available, shader compilation and program linking can continue while the caller yields to the browser. Poll the returned initialization with WebGlRendererInit::try_finish on successive animation frames.

If the extension is unavailable, the first poll synchronously finishes shader compilation and linking.

pub fn begin_with( canvas: &HtmlCanvasElement, settings: RenderSettings, use_depth_buffer: bool, ) -> Result<(WebGlRendererInit, Resources), WebGlError>

Begins creating a WebGL2 renderer with specific settings.

See WebGlRenderer::begin for polling and fallback behavior.

pub fn render( &mut self, scene: &Scene, resources: &mut Resources, render_size: &RenderSize, texture_bindings: &WebGlTextureBindings, clear_color: AlphaColor<Srgb>, ) -> Result<(), WebGlError>

Render scene using WebGL2

This method creates GPU resources as needed and schedules potentially multiple draw calls.

Every TextureId referenced by the scene must have a binding; this returns WebGlError::Render containing RenderError::MissingTextureBinding otherwise. See WebGlTextureBindings::insert for the requirements on the bound textures.

To render without any texture bindings, you can pass an empty WebGlTextureBindings.

pub fn gl_context(&self) -> &WebGl2RenderingContext

Get a reference to the underlying WebGL context.

This allows direct access to WebGL operations for advanced use cases like texture creation.

pub fn upload_image<T: WebGlAtlasWriter>( &mut self, resources: &mut Resources, writer: &T, ) -> Result<ImageId, WebGlError>

Upload image to cache and atlas in one step. Returns the ImageId.

This is the WebGL analogue of the wgpu Renderer’s upload_image method. It allocates space in the image cache and uploads the image data to the atlas texture.

pub fn destroy_image( &mut self, resources: &mut Resources, image_id: ImageId, ) -> Result<(), WebGlError>

Destroy an image from the cache and clear the allocated slot in the atlas.

pub fn atlas_texture(&self, atlas_id: AtlasId) -> &WebGlTexture

Returns an individual image atlas texture.

pub fn atlas_info(&self) -> AtlasTextureInfo

Returns the current allocation state of the image/glyph atlas texture.

Trait Implementations

impl Debug for WebGlRenderer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.