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