Struct GpuRenderer 

pub struct GpuRenderer {

    pub ai_material_rx: Option<Receiver<Result<CompiledMaterial, GeneratorError>>>,
    pub headless_context: Option<HeadlessContext>,
    pub blur_pipeline: Option<RenderPipeline>,
    pub blur_uniform: Option<Buffer>,
    pub blur_bind_group_layout: Option<BindGroupLayout>,
    pub blend_pipeline: Option<RenderPipeline>,
    pub blend_bind_group_layout: Option<BindGroupLayout>,
    pub flood_pipeline: Option<RenderPipeline>,
    pub copy_bind_group_layout: Option<BindGroupLayout>,
    pub telemetry: TelemetryData,
    pub frame_budget: FrameBudget,
    pub last_redraw_start: Instant,
    pub last_frame_start: Instant,
    pub redraw_requested: bool,
    pub bloom_enabled: bool,
    pub volumetric_enabled: bool,
    pub color_blind_mode: ColorBlindMode,
    pub color_blind_intensity: f32,
    pub last_gpu_time_ns: u64,
    /* private fields */
}

GpuRenderer implements the high-performance GPU backend.

Fields

ai_material_rx: Option<Receiver<Result<CompiledMaterial, GeneratorError>>>

headless_context: Option<HeadlessContext>

blur_pipeline: Option<RenderPipeline>

Render pipeline for Gaussian blur (two-pass separable kernel). Initialized lazily on first use.

blur_uniform: Option<Buffer>

Uniform buffer for blur parameters (std_deviation, kernel_size, direction). Initialized lazily on first use.

blur_bind_group_layout: Option<BindGroupLayout>

Bind group layout for blur shader. Initialized lazily on first use.

blend_pipeline: Option<RenderPipeline>

Render pipeline for blend operations (feBlend, feComposite). Initialized lazily on first use.

blend_bind_group_layout: Option<BindGroupLayout>

Bind group layout for blend shader. Initialized lazily on first use.

flood_pipeline: Option<RenderPipeline>

Render pipeline for flood fill (feFlood). Initialized lazily on first use.

copy_bind_group_layout: Option<BindGroupLayout>

Bind group layout for copy/offset operations. Initialized lazily on first use.

telemetry: TelemetryData

frame_budget: FrameBudget

Configuration for render-loop frame timing and degradation strategies.

last_redraw_start: Instant

Instant at the start of the last redraw, used for measuring frame timings.

last_frame_start: Instant

Instant at the start of the last frame, used for frame_time_ms calculation.

redraw_requested: bool

Whether a redraw has been requested for the next frame.

bloom_enabled: bool

Bloom post-processing enabled flag.

volumetric_enabled: bool

Dynamic toggle to enable or disable the volumetric raymarching pass, which handles fog and light shaft simulations.

color_blind_mode: ColorBlindMode

Color blindness simulation mode (Normal = disabled).

color_blind_intensity: f32

Color blindness effect intensity (0.0–1.0).

last_gpu_time_ns: u64

Implementations

impl GpuRenderer

pub fn stroke_path_impl( &mut self, path: &Path, color: [f32; 4], stroke_width: f32, )

Inherent method: stroke a lyon path using wgpu.

impl GpuRenderer

pub fn clear_text_cache_impl(&mut self)

Inherent method: clear the text shaping cache.

impl GpuRenderer

pub fn clear_event_handlers(&mut self)

Clear all registered event handlers. Call at the start of each frame before re-rendering the component tree.

pub fn clear_text_cache(&mut self)

Phase 2.1: clear the text shaping cache at the start of each frame.

pub fn get_handlers( &self, event_type: &str, ) -> Option<&Vec<Arc<dyn Fn(Event) + Send + Sync>>>

Get all registered event handlers for a specific event type.

pub fn stroke_path(&mut self, path: &Path, color: [f32; 4], stroke_width: f32)

impl GpuRenderer

pub fn begin_frame_headless(&mut self) -> CommandEncoder

begin_frame_headless – Strike the flaming sword to begin a new GPU frame for headless rendering.

pub fn begin_frame(&mut self, window_id: WindowId) -> CommandEncoder

begin_frame – Strike the flaming sword to begin a new GPU frame for a specific window.

pub fn begin_frame_reuse(&mut self, window_id: WindowId) -> CommandEncoder

Begin a frame without resetting per-frame state. Used when reusing the previous frame’s draw calls (view unchanged).

pub fn register_window(&mut self, window: Arc<Window>)

register_window – Attaches a new OS window to the shared GPU context.

pub fn fill_rect_with_mode( &mut self, rect: Rect, color: [f32; 4], material_id: u32, texture_id: Option<u32>, )

fill_rect_with_mode – Specialized rectangle drawing with mode-specific shader logic.

pub fn end_frame(&mut self, encoder: CommandEncoder)

Pass 1: Clear scene+depth, draw atmosphere, draw opaque geometry. end_frame – Quench the blade by submitting the full Muspelheim multi-pass effect.

Since the Renderer 3.0 migration, the pass sequence is driven by a Kvasir dependency graph rather than hardcoded ordering. The graph is built each frame (cheap – just node/edge allocation), validated (cycle detection, input satisfiability), then executed. Conditional passes (glass, bloom, accessibility) are automatically eliminated when not needed.

pub fn submit_buckets(&mut self, buckets: &CommandBuckets)

Submit pre-routed draw command buckets from the cvkg-compositor.

Accepts CommandBuckets produced by CompositorEngine::flatten_and_route() and submits draw calls in the correct pass order for the Backdrop Capture Architecture:

1. Scene commands (opaque) → Scene Capture pass
2. Glass commands → Material Composite pass (samples blur pyramid)
3. Overlay commands → Top-Level Foreground pass

pub async fn capture_frame(&self) -> Result<Vec<u8>, String>

capture_frame – Read back the rendered frame as a byte buffer (RGBA8).

pub fn draw_gradient_multi( &mut self, rect: Rect, stops: &[[f32; 4]], angle: f32, is_radial: bool, )

Draw a multi-stop gradient quad using the GPU shader. rect: bounding rectangle in logical pixels stops: array of [R, G, B, A] where A is the position (0.0-1.0) angle: gradient angle in radians (for linear gradients) is_radial: true for radial gradient, false for linear

pub fn submit_mesh_3d( &mut self, mesh: &Mesh, material: &Material3D, transform: &Transform3D, )

Submit a 3D mesh instance to the GPU-ready staging buffer.

Creates GPU vertex and index buffers for the mesh and stores the instance in pending_mesh_instances_3d. The instance will be consumed by the frame graph during end_frame to construct the Shadow and Opaque3d pass nodes.

WHY: This enables the Kvasir render graph to render true 3D meshes with instanced rendering, separate from the CPU-baked 2D vertex buffer path.

impl GpuRenderer

pub async fn forge(window: Arc<Window>) -> Self

forge – Initializes the Surtr GPU renderer from a winit window.

This method performs the following:

1. Negotiates a wgpu surface and adapter.
2. Forges the Muspelheim multi-pass pipeline layouts.
3. Initializes the Berserker state buffers and texture registries.

impl GpuRenderer

pub fn load_svg(&mut self, name: &str, data: &[u8])

load_svg – Parses an SVG file and tessellates its paths into GPU triangles.

pub fn draw_svg( &mut self, name: &str, rect: Rect, color: Option<[f32; 4]>, material_id: u32, )

draw_svg – Renders a pre-loaded SVG icon at the specified logical rect. animation_time_offset shifts the animation phase for this instance, allowing multiple draws of the same SVG to animate independently.

pub fn draw_svg_with_offset( &mut self, name: &str, rect: Rect, color: Option<[f32; 4]>, material_id: u32, animation_time_offset: f32, )

pub fn draw_svg_with_order( &mut self, name: &str, rect: Rect, color: Option<[f32; 4]>, material_id: u32, animation_time_offset: f32, draw_order: i32, )

impl GpuRenderer

pub fn hologram_instances(&self) -> &[HologramInstance]

Access the hologram instances submitted this frame.

pub fn set_quality_level(&mut self, level: QualityLevel)

pub fn set_config(&mut self, config: RendererConfig)

pub fn config(&self) -> &RendererConfig

pub fn quality_level(&self) -> QualityLevel

pub fn update_mouse(&mut self, mouse: [f32; 2], velocity: [f32; 2])

pub fn invalidate_material_cache(&mut self)

pub fn invalidate_all_caches(&mut self) -> usize

pub fn prewarm_text_cache(&mut self, labels: &[(&str, f32)])

pub fn get_telemetry(&self) -> TelemetryData

pub fn resize( &mut self, window_id: WindowId, width: u32, height: u32, scale_factor: f32, )

pub fn reset_time(&mut self)

pub fn reclaim_vram(&mut self)

impl GpuRenderer

pub async fn forge_headless(width: u32, height: u32) -> Self

forge_headless – Initializes Surtr without a window for visual regression testing.

pub fn readback_headless_rgba8(&self) -> Vec<u8>

Read back the headless output texture as RGBA8 pixels. Must be called after end_frame on a headless renderer.

pub fn render_headless_frame<F>(&mut self, draw: F) -> Vec<u8>

where F: FnOnce(&mut Self),

Render a headless frame with a draw callback and read back pixels.

pub async fn from_external( device: Arc<Device>, queue: Arc<Queue>, surface: Surface<'static>, width: u32, height: u32, ) -> Self

Create a headless GpuRenderer from an existing device and surface.

This constructor does not require an event loop and is suitable for headless rendering (e.g., server-side rendering, tests). It delegates to the existing forge_internal which handles all pipeline, buffer, and bind group initialization.

pub fn set_world_space_panels(&mut self, panels: Vec<(u64, WorldSpacePanel)>)

pub fn begin_world_space_panel( &mut self, node_id: u64, transform: &Transform3D, glass: Option<GlassMaterial>, pixels_per_unit: f32, world_size: (f32, f32), )

pub fn end_world_space_panel(&mut self, _node_id: u64)

impl GpuRenderer

pub fn load_image_to_heim(&mut self, name: &str, data: &[u8])

load_image_to_heim – Packs a raw asset into the Mega-Heim. This is used for common icons to enable aggressive batching (1 draw call).

Trait Implementations

impl Drop for GpuRenderer

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl ElapsedTime for GpuRenderer

fn delta_time(&self) -> f32

Returns the time elapsed since the last frame in seconds.

fn elapsed_time(&self) -> f32

Returns the cumulative time since the renderer started in seconds.

impl FrameRenderer<CommandEncoder> for GpuRenderer

fn begin_frame(&mut self) -> CommandEncoder

fn render_frame(&mut self)

fn end_frame(&mut self, encoder: CommandEncoder)

impl Renderer for GpuRenderer

fn fill_glass_rect(&mut self, rect: Rect, radius: f32, blur_radius: f32)

Fill a rounded rect with glass material for frosted backdrop effect. This is the proper way to render glass cards that need macOS Tahoe-style blur. The blur_radius controls the intensity of the backdrop blur. The glass_intensity controls overall glass effect strength (0.0 = solid, 1.0 = full glass). For Tahoe parity, this registers the rect as a portal region for per-element isolated backdrop blur when z_index != 0.

fn fill_glass_rect_with_intensity( &mut self, rect: Rect, radius: f32, blur_radius: f32, glass_intensity: f32, )

Fill a rounded rect with glass material with explicit intensity control. glass_intensity ranges from 0.0 (solid, no glass effect) to 1.0 (full glass). This allows per-component control over glass strength.

fn fill_glass_rect_with_tint( &mut self, rect: Rect, radius: f32, blur_radius: f32, tint_color: [f32; 4], glass_intensity: f32, )

Fill a rounded rect with glass material with explicit tint color and intensity. tint_color is the glass base color (RGBA). glass_intensity controls effect strength.

fn set_default_background_color(&mut self, color: [f32; 4])

Set the default background color for the canvas. This color is used when the app does not draw its own background. Default: [0.02, 0.02, 0.05, 1.0] (Deep Void).

fn fill_squircle(&mut self, rect: Rect, n: f32, color: [f32; 4])

Fill a squircle (superellipse) for Apple-style icon silhouettes. n controls the squareness: 2.0 = rounded rect, 4.0 = classic squircle, higher = more square.

fn stroke_squircle( &mut self, rect: Rect, n: f32, color: [f32; 4], stroke_width: f32, )

Stroke a squircle (superellipse) outline.

fn draw_focus_ring( &mut self, rect: Rect, radius: f32, offset: f32, width: f32, color: [f32; 4], )

Draw a focus ring around a rect (for keyboard navigation accessibility). offset is the gap between the rect and the ring, width is the ring thickness.

fn gungnir_soft( &mut self, rect: Rect, color: [f32; 4], radius: f32, intensity: f32, )

Soft glow variant – half the intensity of gungnir(). Use for hover highlights, non-critical indicators.

fn mani_glow(&mut self, rect: Rect, color: [f32; 4], radius: f32)

Renders a dynamic glowing hover boundary field around a hit target.

Contract

Expands the bounding box of the visual target by radius to establish a continuous proximity glow. Uses the drop shadow/glow SDF material to rasterize the glow with specialized radius-to-margin uv coordinate mappings.

fn load_image(&mut self, name: &str, data: &[u8])

load_image – Proactively pushes a raw asset into the Mega-Heim. load_image – Proactively pushes a raw asset into the Texture Array.

fn push_mjolnir_slice(&mut self, angle: f32, offset: f32)

push_mjolnir_slice – Pushes a geometric clipping plane onto the stack. All subsequent draw calls will be sliced by this plane until it is popped.

fn pop_mjolnir_slice(&mut self)

pop_mjolnir_slice – Removes the top-most geometric clipping plane from the stack.

fn render_scene_node_3d( &mut self, position: [f32; 3], rotation: [f32; 4], scale: [f32; 3], color: [f32; 4], meshes: &[Mesh], )

Render a 3D scene graph node using the GPU backend.

Contract

PBR lighting and opacity are computed using base color, metallic (0.0), and roughness (0.5) to support standard matte opaque 3D meshes.

Uses the proper 3D instanced rendering path via submit_mesh_3d which creates dedicated per-mesh vertex buffers for GPU skinning, rather than CPU-baked transforms.

fn enter_portal(&mut self, z_index: i32)

Begin rendering into the portal root layer instead of the inline tree. All draw calls between enter_portal and exit_portal are collected into a separate buffer that is composited AFTER the main tree.

WHY separate buffer: The main tree may have clipping, transforms, or opacity that should NOT affect overlays. The portal layer renders on top of everything, ignoring the local coordinate system.

z_index controls the layer ordering for portal content.

fn exit_portal(&mut self)

Exit the portal layer and return to inline rendering. The portal content collected since enter_portal is now sealed – no more draw calls will be appended to it.

fn draw_svg_with_order(&mut self, name: &str, rect: Rect, draw_order: i32)

Draw SVG content with explicit draw_order for z-sorting within the same pass. Use draw_order=200 for SVG content that should render above UI chrome (draw_order=0).

fn is_over_budget(&self) -> bool

Returns true if the current frame is over the time budget. This can be used to skip expensive visual effects.

fn text_scale_factor(&self) -> f32

Scale factor used by text measurement helpers.

fn prewarm_vram(&mut self, assets: Vec<(String, Vec<u8>)>)

Pre-warm the renderer with assets. Implementations can use this to populate texture atlases or warm up shader caches.

fn fill_rect(&mut self, rect: Rect, color: [f32; 4])

fn fill_rounded_rect(&mut self, rect: Rect, radius: f32, color: [f32; 4])

fn fill_glass_rect_with_pressure( &mut self, rect: Rect, radius: f32, blur_radius: f32, pressure: f32, )

Fill a rounded rect with glass material, modulated by touch pressure. pressure ranges from 0.0 (no touch) to 1.0 (full pressure). When pressure > 0, refraction distortion is scaled by pressure amount. Desktop stub: pressure is always 1.0 for mouse clicks, 0.0 otherwise.

fn fill_ellipse(&mut self, rect: Rect, color: [f32; 4])

Fill an ellipse/circle that fits inside rect.

fn draw_3d_cube(&mut self, rect: Rect, color: [f32; 4], rotation: [f32; 3])

Draw a high-fidelity 3D cube inside the given rectangle using specialized shader logic. rotation is [pitch, yaw, roll] in radians.

fn bifrost(&mut self, rect: Rect, blur: f32, _saturation: f32, opacity: f32)

Apply a Bifrost (Frosted Glass) effect to the specified rect.

fn gungnir(&mut self, rect: Rect, color: [f32; 4], radius: f32, intensity: f32)

Apply a Gungnir (Neon Glow) effect to the specified rect.

fn stroke_rect(&mut self, rect: Rect, color: [f32; 4], stroke_width: f32)

fn stroke_rounded_rect( &mut self, rect: Rect, radius: f32, color: [f32; 4], stroke_width: f32, )

fn stroke_ellipse(&mut self, rect: Rect, color: [f32; 4], stroke_width: f32)

Stroke an ellipse/circle that fits inside rect.

fn draw_linear_gradient( &mut self, rect: Rect, start_color: [f32; 4], end_color: [f32; 4], angle: f32, )

Draw a linear gradient between two colors at the specified angle.

fn draw_radial_gradient( &mut self, rect: Rect, inner_color: [f32; 4], outer_color: [f32; 4], )

Draw a radial gradient between two colors.

fn draw_linear_gradient_multi( &mut self, rect: Rect, stops: &[[f32; 4]], angle: f32, )

Draw a multi-stop linear gradient (GPU-accelerated). stops: array of [R, G, B, position] where position is 0.0-1.0. angle: gradient angle in radians.

fn draw_radial_gradient_multi(&mut self, rect: Rect, stops: &[[f32; 4]])

Draw a multi-stop radial gradient (GPU-accelerated). stops: array of [R, G, B, position] where position is 0.0-1.0.

fn draw_drop_shadow( &mut self, rect: Rect, radius: f32, color: [f32; 4], blur: f32, spread: f32, )

Draw a high-fidelity drop shadow for a rounded rectangle.

fn stroke_dashed_rounded_rect( &mut self, rect: Rect, radius: f32, color: [f32; 4], width: f32, dash: f32, gap: f32, )

Draw a dashed border for a rounded rectangle.

fn draw_9slice( &mut self, image_name: &str, rect: Rect, left: f32, top: f32, right: f32, bottom: f32, )

Draw a 9-slice / patch scaled image.

fn draw_line( &mut self, x1: f32, y1: f32, x2: f32, y2: f32, color: [f32; 4], stroke_width: f32, )

Draw a straight line from (x1,y1) to (x2,y2).

fn draw_image(&mut self, image_name: &str, rect: Rect)

Draw an image asset by name or path.

fn shape_rich_text( &mut self, spans: &[TextSpan], max_width: Option<f32>, align: TextAlign, overflow: TextOverflow, ) -> Option<ShapedText>

fn draw_shaped_text(&mut self, shaped: &ShapedText, x: f32, y: f32)

fn draw_texture(&mut self, texture_id: u32, rect: Rect)

Draw a texture (GPU-side) at the specified rect.

fn push_clip_rect(&mut self, rect: Rect)

Push a clip rectangle. All subsequent drawing is clipped to rect. Implementations that do not support clipping may ignore this call.

fn pop_clip_rect(&mut self)

Pop the most recently pushed clip rectangle.

fn current_clip_rect(&self) -> Rect

Get the current clip rectangle in screen coordinates. Returns a rect covering the entire screen if no clip is active.

fn memoize( &mut self, id: u64, data_hash: u64, render_fn: &dyn Fn(&mut dyn Renderer), )

Execute a render function with memoization. If the renderer supports caching and the id + data_hash match a previous run, it may replay cached commands instead of executing the function.

fn snapshot_render_state(&self) -> RenderStateSnapshot

Capture current renderer stack depths for later panic recovery. The default implementation returns RenderStateSnapshot::default(), which is safe but does nothing useful – backends with stack state must override this to record their actual depths.

fn restore_render_state(&mut self, snap: RenderStateSnapshot)

Restore renderer stack state by popping items pushed beyond the snapshot point. Used by ErrorBoundary to recover from mid-render panics so sibling views don’t inherit leaked clip/opacity/transform state. Idempotent: a no-op if stacks are already at or below the snapshot depths. Default implementation is a no-op for backends that have no stack state.

fn push_opacity(&mut self, opacity: f32)

Set a global opacity multiplier applied to all subsequent draw calls until pop_opacity is called. opacity is in [0.0, 1.0].

fn pop_opacity(&mut self)

Restore the previous opacity level.

fn push_shadow(&mut self, radius: f32, color: [f32; 4], offset: [f32; 2])

Push a shadow state to the stack. All following draw calls will have this shadow.

fn pop_shadow(&mut self)

Pop the last shadow state from the stack.

fn push_transform( &mut self, translation: [f32; 2], scale: [f32; 2], rotation: f32, )

Push a 2D transform (translation, scale, rotation) onto the stack. This transform should be applied to all subsequent draw calls until popped. Transform-only animations use this to avoid re-triggering the layout engine.

fn push_affine(&mut self, transform: [f32; 6])

Push a raw 2D affine transform matrix [a, b, c, d, e, f] corresponding to [m11, m12, m21, m22, tx, ty].

fn pop_transform(&mut self)

Pop the last 2D transform from the stack.

fn set_theme(&mut self, theme: ColorTheme)

fn push_theme(&mut self, theme: ColorTheme)

Push a theme override for the current subtree. All child nodes rendered until pop_theme() are drawn with this theme.

fn pop_theme(&mut self)

Pop the theme override and restore the previous theme.

fn current_theme(&self) -> ColorTheme

Return the current theme at the current stack depth. Falls back to the default theme if no theme has been pushed.

fn set_rage(&mut self, rage: f32)

fn set_fireball_pos(&mut self, pos: [f32; 2])

Set the fireball position for dynamic glass specular highlights.

fn trigger_shatter_event(&mut self, origin: [f32; 2], force: f32)

fn set_scene_preset(&mut self, preset: u32)

fn mjolnir_shatter( &mut self, rect: Rect, pieces: u32, force: f32, color: [f32; 4], )

Apply a Mjolnir Shatter effect (fragmentation) to the specified rect.

fn mjolnir_fluid_shatter( &mut self, rect: Rect, pieces: u32, force: f32, color: [f32; 4], )

fn draw_mjolnir_bolt(&mut self, from: [f32; 2], to: [f32; 2], color: [f32; 4])

fn dispatch_particles( &mut self, origin: [f32; 2], count: u32, effect_type: &str, color: [f32; 4], )

Dispatches a burst of GPU particles (e.g. fireworks, data streams).

fn draw_hologram(&mut self, rect: Rect, hologram_id: &str, time: f32)

Draws a volumetric hologram into the specified bounding rectangle.

fn upload_data_texture( &mut self, id: &str, data: &[f32], width: u32, height: u32, )

Upload raw float data as a GPU texture for heatmap rendering.

fn draw_heatmap(&mut self, texture_id: &str, rect: Rect, _palette: &str)

Draw a heatmap using a previously uploaded data texture.

fn draw_mesh(&mut self, mesh: &Mesh, color: [f32; 4], transform: Mat4)

Draw a 3D mesh.

fn draw_mesh_3d( &mut self, mesh: &Mesh, material: &Material3D, transform: &Transform3D, )

Draw a 3D mesh with full material and transform support.

fn set_camera_3d(&mut self, camera: &Camera3D)

Set the 3D camera for perspective/orthographic projection. If not called, rendering defaults to the 2D orthographic projection.

fn push_transform_3d(&mut self, transform: &Transform3D)

Push a 3D transform onto the transform stack. All subsequent drawing is affected until pop_transform_3d.

fn pop_transform_3d(&mut self)

Pop the most recently pushed 3D transform.

fn register_shared_element(&mut self, id: &str, rect: Rect)

Register a shared element for Bifrost Bridge transitions.

fn set_z_index(&mut self, z: f32)

Set the current Z-index for depth sorting. Higher values appear closer to the viewer.

fn set_material(&mut self, material: DrawMaterial)

Set the active material for subsequent draw calls. Controls which pass a draw call is routed to in the multi-pass pipeline.

fn current_material(&self) -> DrawMaterial

Return the currently active material (defaults to Opaque).

fn get_z_index(&self) -> f32

Get the current Z-index.

fn request_redraw(&mut self)

Requests that the renderer redraws as soon as possible. Used for continuous animations.

fn push_vnode(&mut self, rect: Rect, name: &'static str)

Push a Virtual DOM node onto the stack for hierarchy tracking.

fn pop_vnode(&mut self)

Pop the current Virtual DOM node from the stack.

fn register_handler( &mut self, event_type: &str, handler: Arc<dyn Fn(Event) + Send + Sync>, )

Register an event handler for the current VDOM node.

fn load_svg(&mut self, name: &str, svg_data: &[u8])

fn draw_svg(&mut self, name: &str, rect: Rect)

Draw a pre-loaded SVG model.

fn draw_svg_with_offset( &mut self, name: &str, rect: Rect, animation_time_offset: f32, )

Draw a pre-loaded SVG model with a per-instance animation time offset. The offset shifts the animation phase, allowing multiple draws of the same SVG to animate independently. Default delegates to draw_svg (no offset).

fn serialize_svg(&mut self, name: &str) -> Result<String, String>

Serialize a pre-loaded SVG model back to SVG XML markup. Returns the serialized SVG string, or an error if the model is not loaded or serialization is not supported by this renderer.

fn apply_svg_filter( &mut self, name: &str, filter_id: &str, _region: Rect, ) -> Result<String, String>

Apply an SVG filter to a pre-loaded SVG model by filter element ID. The filter is evaluated and the result composited back into the SVG. Returns the filtered SVG as XML, or an error if not supported.

fn measure_text(&mut self, text: &str, size: f32) -> (f32, f32)

Measure the width and height of the specified text.

fn draw_text( &mut self, text: &str, rect: &Rect, size: f32, color: [f32; 4], h_align: TextHAlign, v_align: TextVAlign, )

Draw text aligned within a bounding box. This is the primary method — callers should use this for proper vertical and horizontal alignment within their layout rects.

fn draw_background_image(&mut self, image_name: &str, rect: Rect)

Draw a background image that fills the entire rect. This is a convenience wrapper around draw_image for the common case of a full-rect background. The image must have been pre-warmed via prewarm_vram before the first frame.

fn fill_polygon(&mut self, _vertices: &[[f32; 2]], _color: [f32; 4])

Fill a polygon defined by a set of vertices.

fn stroke_polygon( &mut self, _vertices: &[[f32; 2]], _color: [f32; 4], _stroke_width: f32, )

Stroke a polygon defined by a set of vertices.

fn draw_text_raw( &mut self, text: &str, x: f32, y: f32, size: f32, color: [f32; 4], )

Draw text at a raw baseline position (x = left, y = baseline). Use this when you need precise control over baseline positioning.

fn draw_text_centered( &mut self, text: &str, rect: &Rect, size: f32, color: [f32; 4], )

Draw text centered within a bounding box (convenience).

fn measure_text_baseline(&mut self, text: &str, size: f32) -> f32

Return the baseline offset (ascent) for the given text and size. This is the distance from the text origin (y in draw_text) to the baseline. Default returns 0.0; override in renderers that support text shaping.

fn get_pointer_position(&self) -> [f32; 2]

Get the current pointer (mouse/touch) position.

fn set_berserker_mode(&mut self, _state: RenderIntensityMode)

fn set_scene(&mut self, _scene: &str)

Set the desktop scene preset (Aurora, Void, Nebula, Glitch, Yggdrasil).

fn set_scene_by_name(&mut self, name: &str)

Set the desktop scene by name. Case-insensitive. Supports: “aurora”, “void”, “nebula”, “glitch”, “yggdrasil”. Aliases: “empty”, “none”, “blank” → Void.

fn capture_png(&mut self) -> Vec<u8>

Capture the current frame as a PNG byte buffer.

fn print(&mut self)

Trigger a native print dialog or spooling operation.

fn set_aria_role(&mut self, _role: &str)

fn set_aria_label(&mut self, _label: &str)

fn set_aria_valuemin(&mut self, _min: f32)

fn set_aria_valuemax(&mut self, _max: f32)

fn set_aria_valuenow(&mut self, _now: f32)

fn register_a11y(&mut self, role: &str, label: &str)

Convenience method: register aria role and label in one call. Components with both role and label props should call this.

fn push_focus_trap(&mut self, _element_id: &str) -> u64

Push a focus trap onto the stack. While active, keyboard focus is trapped within the specified element and its children. Returns a trap ID that must be passed to pop_focus_trap.

fn pop_focus_trap(&mut self, _trap_id: u64)

Pop the most recently pushed focus trap.

fn set_key(&mut self, _key: &str)

Set a unique key for the current VDOM node to ensure stable identity during diffing.

fn get_telemetry(&self) -> TelemetryData

Get real-time performance telemetry.

fn push_vnode_with_companions( &mut self, rect: Rect, name: &'static str, _companions: Vec<Box<dyn Companion>>, )

Push a Virtual DOM node with companion state auto-initialization. Default implementation ignores companions and delegates to push_vnode.

fn current_companion(&self) -> Option<&(dyn Companion + 'static)>

Retrieve a companion state for the VNode currently at the top of the stack. Returns None if the companion type is not registered on this node.

fn begin_world_space_panel( &mut self, node_id: u64, transform: &Transform3D, glass: Option<GlassMaterial>, pixels_per_unit: f32, world_size: (f32, f32), )

Called when the traversal enters a VNode with a WorldSpacePanel configured. Redirects subsequent draw calls into an offscreen texture for the panel, similar to push_target.

fn end_world_space_panel(&mut self, node_id: u64)

Called when the traversal exits a VNode with a WorldSpacePanel configured. Ends offscreen redirection and records the panel into the renderer state for 3D compositing later in the frame graph.

fn query_layout(&self, _node_id: KvasirId) -> Option<Rect>

Return the resolved layout bounds for a specific node ID if it exists.

fn set_debug_layout(&mut self, _enabled: bool)

Enable or disable the layout debug overlay (bounds, padding, margin).

fn get_debug_layout(&self) -> bool

Check if the layout debug overlay is currently enabled.

fn mimir_intent(&self) -> [f32; 2]

Compute the user’s velocity/intent vector.

fn magnetic_warp( &self, pointer: [f32; 2], anchor_rect: Rect, strength: f32, ) -> [f32; 2]

Calculate magnetic coordinate warp towards an anchor.

fn mani_glow_intensity( &self, pointer: [f32; 2], bounds: Rect, radius: f32, ) -> f32

Calculate kinematic glow intensity based on proximity.

fn fafnir_evolve(&self, pointer: [f32; 2], bounds: Rect, max_scale: f32) -> f32

Calculate dynamic element attention (scaling/morphing) statelessly per frame.

fn set_sdf_shape(&mut self, _shape: SdfShape)

Sets the precise Vili SDF Shape boundary for hit-testing.

fn save_theme(&mut self)

Save theme state for portal inheritance before entering a new buffer. Legacy — prefer using the theme stack (push_theme/pop_theme) instead.

fn restore_theme(&mut self)

Restore the saved theme when exiting a portal buffer. Legacy — prefer using the theme stack (push_theme/pop_theme) instead.

fn viewport_size(&self) -> Rect

Get the current viewport size in logical pixels. Used by portal content to size itself to the full screen.

fn announce(&mut self, _message: &str, _priority: AnnouncementPriority)

Announce a message to screen readers via the platform accessibility API. This call is non-blocking. The message is queued and the screen reader will speak it at its own pace.

impl RendererErrorHandler for GpuRenderer

fn on_render_error(&mut self, error: &CvkgError)

Called when a non-fatal render error occurs during a draw operation. The renderer continues operating. Backends should log and optionally track error counts for health monitoring.

fn on_fatal_error(&mut self, error: &CvkgError)

Called when a fatal error occurs that prevents further rendering. The backend should attempt graceful shutdown.

fn has_error(&self) -> bool

Returns true if the backend is in an error state.