Struct SurtrRenderer 

pub struct SurtrRenderer {
    pub headless_context: Option<HeadlessContext>,
    pub telemetry: TelemetryData,
    pub frame_budget: FrameBudget,
    pub last_redraw_start: Instant,
    pub last_frame_start: Instant,
    pub redraw_requested: bool,
    pub last_gpu_time_ns: u64,
    /* private fields */
}

SurtrRenderer implements the high-performance GPU backend.

Fields

headless_context: Option<HeadlessContext>

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.

last_gpu_time_ns: u64

Implementations

impl SurtrRenderer

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.

pub fn get_telemetry(&self) -> TelemetryData

Get real-time performance telemetry.

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

resize — Reconfigures a specific surface and its internal textures.

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 register_window(&mut self, window: Arc<Window>)

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

pub fn reset_time(&mut self)

pub fn reclaim_vram(&mut self)

reclaim_vram — Atomic recycling of the Mega-Atlas and all associated caches. This prevents OOM and silent failures by quenching the atlas when full.

pub fn fill_rect_with_mode( &mut self, rect: Rect, color: [f32; 4], mode: 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)

end_frame — Quench the blade by submitting the full Muspelheim multi-pass effect.

impl SurtrRenderer

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

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

impl SurtrRenderer

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 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 SurtrRenderer

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

impl SurtrRenderer

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]>, mode: u32, )

draw_svg — Renders a pre-loaded SVG icon at the specified logical rect.

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

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

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

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

Trait Implementations

impl Drop for SurtrRenderer

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 SurtrRenderer

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 SurtrRenderer

fn begin_frame(&mut self) -> CommandEncoder

fn render_frame(&mut self)

fn end_frame(&mut self, encoder: CommandEncoder)

impl Renderer for SurtrRenderer

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

fill_rect — Standard rectangle drawing method.

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 blending mode 18 (GPU drop shadow/glow) to rasterize the glow with specialized radius-to-margin uv coordinate mappings.

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

measure_text — Calculates the dimensions of a text string without rendering.

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

load_image — Proactively pushes a raw asset into the Mega-Atlas. 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 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 fill_rect(&mut self, rect: Rect, color: [f32; 4])

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

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_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 draw_text(&mut self, text: &str, x: f32, y: f32, size: f32, color: [f32; 4])

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 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 set_rage(&mut self, rage: f32)

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])

Draw a Mjolnir Bolt (lightning strike) between two points.

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 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 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 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 get_pointer_position(&self) -> [f32; 2]

Get the current pointer (mouse/touch) position.

fn set_berserker_mode(&mut self, _state: BerserkerMode)

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

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

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_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 load_svg(&mut self, _name: &str, _svg_data: &[u8])

Load an SVG model from raw bytes.

fn draw_svg(&mut self, _name: &str, _rect: Rect)

Draw a pre-loaded SVG model.

fn query_layout(&self, _node_id: NodeId) -> 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.