Struct NativeRenderer 

pub struct NativeRenderer { /* private fields */ }

Native renderer backend implementing the Renderer trait. It wraps a shared SurtrRenderer for high-performance GPU drawing.

Implementations

impl NativeRenderer

pub fn run<V: View + 'static>(view: V)

Start the CVKG native application with the given view. This is the main entry point for desktop applications.

Trait Implementations

impl ElapsedTime for NativeRenderer

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 Renderer for NativeRenderer

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

Captures the current frame as a PNG-encoded byte buffer via GPU readback. Captures the current frame as a PNG-encoded byte buffer via GPU readback.

FIX #4: capture_frame() returns a Future that borrows the SurtrRenderer, so the MutexGuard must remain alive until block_on completes — the guard cannot be dropped before the future is driven to completion. The lock is held for the duration of the GPU readback. This is acceptable because capture_png is an infrequent, explicit user-triggered operation (not called on the hot render path), so blocking other render calls for the readback duration is not a practical concern.

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

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

Measure the width and height of the specified text.

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_texture(&mut self, texture_id: u32, rect: Rect)

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

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

Draw an image asset by name or path.

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

Load an image asset from memory.

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 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 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 pop_opacity(&mut self)

Restore the previous opacity level.

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

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

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

Push a Mjolnir Slice (geometric clipping).

fn pop_mjolnir_slice(&mut self)

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 gungnir(&mut self, rect: Rect, color: [f32; 4], radius: f32, intensity: f32)

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

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

Apply a ManiGlow (Lunar Illuminator) effect.

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

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

fn get_z_index(&self) -> f32

Get the current Z-index.

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

Register a shared element for Bifrost Bridge transitions.

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 get_telemetry(&self) -> TelemetryData

Get real-time performance telemetry.

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 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 pop_transform(&mut self)

Pop the last 2D transform from the stack.

fn set_berserker_mode(&mut self, state: BerserkerMode)

fn set_rage(&mut self, rage: f32)

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 request_redraw(&mut self)

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

fn print(&mut self)

Trigger a native print dialog or spooling operation.

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_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 shape_rich_text( &mut self, _spans: &[TextSpan], _max_width: Option<f32>, _align: TextAlign, _overflow: TextOverflow, ) -> Option<ShapedText>

fn draw_shaped_text(&mut self, _text: &ShapedText, _x: f32, _y: f32)

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

Get the current pointer (mouse/touch) position.

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_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 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 set_theme(&mut self, _theme: ColorTheme)

fn trigger_shatter_event(&mut self, _origin: [f32; 2], _force: f32)

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

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

fn set_scene_preset(&mut self, _preset: u32)

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