cvkg_render_native/
renderer.rs

1use crate::asset_manager::NativeAssetManager;
2use crate::audio::{RodioAudioEngine, VisualHapticEngine};
3use crate::main_loop::{App, AppEvent};
4use crate::window::{SafeAreaInsets, WindowManager};
5use cvkg_core::{
6    ColorTheme, DrawMaterial, FrameRenderer, Mesh, Rect, RenderIntensityMode, RenderStateSnapshot,
7    Renderer, TelemetryData,
8};
9use std::sync::Arc;
10use winit::event_loop::{ControlFlow, EventLoop};
11#[cfg(target_os = "linux")]
12use winit::platform::wayland::EventLoopBuilderExtWayland;
13use winit::window::Window;
14
15thread_local! {
16    /// Thread-local raw pointer to the locked GpuRenderer for the duration of one render pass.
17    ///
18    /// # Safety
19    /// This pointer is ONLY valid when a `MutexGuard<GpuRenderer>` is held on the same thread's
20    /// call stack. It is set at the start of `begin_frame` and cleared at the end of `end_frame`.
21    /// Accessing the pointer when no guard is held is undefined behavior.
22    ///
23    /// PRIVATE: Not `pub` to prevent external crates from creating dangling references.
24    pub(crate) static GPU_FRAME_PTR: std::cell::Cell<*mut cvkg_render_gpu::GpuRenderer> =
25        const { std::cell::Cell::new(std::ptr::null_mut()) };
26}
27
28/// RAII guard that clears `GPU_FRAME_PTR` on drop.
29///
30/// # Safety
31/// Construct ONLY while holding a `MutexGuard<GpuRenderer>` that outlives this guard.
32pub(crate) struct GpuFramePtrGuard;
33
34impl GpuFramePtrGuard {
35    /// Set the thread-local raw pointer. Cleared automatically on drop.
36    ///
37    /// # Safety
38    /// `ptr` must reference memory that outlives this guard (typically a MutexGuard).
39    pub(crate) unsafe fn set(ptr: *mut cvkg_render_gpu::GpuRenderer) -> Self {
40        GPU_FRAME_PTR.with(|cell| cell.set(ptr));
41        Self
42    }
43}
44
45impl Drop for GpuFramePtrGuard {
46    fn drop(&mut self) {
47        GPU_FRAME_PTR.with(|cell| cell.set(std::ptr::null_mut()));
48    }
49}
50
51/// Native renderer backend implementing the Renderer trait.
52/// It wraps a shared GpuRenderer for high-performance GPU drawing.
53/// During a render pass, GPU_FRAME_PTR is set so draw calls bypass the mutex.
54pub struct NativeRenderer {
55    pub(crate) gpu: Arc<std::sync::Mutex<cvkg_render_gpu::GpuRenderer>>,
56    pub(crate) delta_time: f32,
57    pub(crate) elapsed_time: f32,
58    pub(crate) berserker_mode: RenderIntensityMode,
59    pub(crate) rage: f32,
60    pub(crate) window: Arc<Window>,
61}
62
63impl NativeRenderer {
64    /// Returns a reference to the GPU renderer.
65    /// If GPU_FRAME_PTR is set (we're inside a locked render pass) uses that directly.
66    /// Otherwise falls back to acquiring the mutex (safe for calls outside the render pass).
67    ///
68    /// # Safety
69    /// GPU_FRAME_PTR is only non-null when a MutexGuard is live on the same thread's call stack.
70    #[inline(always)]
71    fn gpu_ref(&mut self) -> impl std::ops::DerefMut<Target = cvkg_render_gpu::GpuRenderer> + '_ {
72        GPU_FRAME_PTR.with(|ptr| {
73            let raw = ptr.get();
74            if !raw.is_null() {
75                // SAFETY: Pointer is valid and the mutex guard is live above us on the call stack.
76                GpuRef::Ptr(unsafe { &mut *raw })
77            } else {
78                GpuRef::Guard(self.gpu.lock().unwrap_or_else(|p| p.into_inner()))
79            }
80        })
81    }
82
83    /// Read-only variant for &self Renderer methods.
84    /// Uses the same thread_local fast path; falls back to mutex for out-of-pass calls.
85    ///
86    /// # Safety
87    /// GPU_FRAME_PTR is only non-null when a MutexGuard is live above us on the call stack.
88    #[inline(always)]
89    fn gpu_ref_shared(&self) -> impl std::ops::Deref<Target = cvkg_render_gpu::GpuRenderer> + '_ {
90        GPU_FRAME_PTR.with(|ptr| {
91            let raw = ptr.get();
92            if !raw.is_null() {
93                // SAFETY: Pointer is valid; the mutex guard is held for the render pass duration.
94                // We only read via this path during &self methods, which is safe.
95                GpuRefShared::Ptr(unsafe { &*raw })
96            } else {
97                GpuRefShared::Guard(self.gpu.lock().unwrap_or_else(|p| p.into_inner()))
98            }
99        })
100    }
101
102    /// Create a new NativeRenderer (internal use by App)
103    pub(crate) fn new(
104        window: Arc<Window>,
105        gpu: Arc<std::sync::Mutex<cvkg_render_gpu::GpuRenderer>>,
106        delta_time: f32,
107        elapsed_time: f32,
108        berserker_mode: RenderIntensityMode,
109        rage: f32,
110    ) -> Self {
111        Self {
112            gpu,
113            delta_time,
114            elapsed_time,
115            berserker_mode,
116            rage,
117            window,
118        }
119    }
120
121    /// Start the CVKG native application with the given view.
122    /// `prewarm_assets` is a list of (name, raw_bytes) pairs uploaded to the GPU
123    /// texture atlas on the first frame before any draw calls.
124    pub fn run<V: cvkg_core::View + 'static>(
125        view: V,
126        prewarm_assets: Option<Vec<(String, Vec<u8>)>>,
127    ) {
128        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
129            .format_timestamp_millis()
130            .try_init()
131            .ok();
132
133        let event_loop = EventLoop::<AppEvent>::with_user_event()
134            .with_any_thread(true)
135            .build()
136            .expect("failed to create winit event loop: platform initialization failed");
137        event_loop.set_control_flow(ControlFlow::Wait);
138
139        let mut app = App {
140            view,
141            window_manager: WindowManager::new(),
142            gpu: None,
143            asset_manager: std::sync::Arc::new(NativeAssetManager::new()),
144            proxy: event_loop.create_proxy(),
145            start_time: std::time::Instant::now(),
146            last_frame_time: std::time::Instant::now(),
147            berserker_mode: RenderIntensityMode::Normal,
148            rage: 0.0,
149            state_detector: crate::window::WindowStateDetector::new(),
150            frame_budget: cvkg_core::FrameBudgetTracker::default_120fps(),
151            modifiers: winit::keyboard::ModifiersState::default(),
152            audio_engine: None,
153            haptic_engine: Arc::new(VisualHapticEngine::new()),
154            pending_prewarm: prewarm_assets,
155        };
156
157        event_loop
158            .run_app(&mut app)
159            .expect("winit event loop terminated with error");
160    }
161
162    /// Convenience: run with a single background image loaded from a file path.
163    /// The image is loaded from disk and pre-warmed on the first frame.
164    /// `image_name` is the key used in `draw_image` / `draw_background_image`.
165    pub fn run_with_background<V: cvkg_core::View + 'static>(
166        view: V,
167        image_name: &str,
168        image_path: &str,
169    ) {
170        let image_data = std::fs::read(image_path)
171            .unwrap_or_else(|e| panic!("Failed to load background image '{}': {}", image_path, e));
172        let assets = vec![(image_name.to_string(), image_data)];
173        Self::run(view, Some(assets));
174    }
175}
176
177/// Returned by NativeRenderer::gpu_ref() — either a direct pointer ref or a mutex guard.
178enum GpuRef<'a> {
179    Ptr(&'a mut cvkg_render_gpu::GpuRenderer),
180    Guard(std::sync::MutexGuard<'a, cvkg_render_gpu::GpuRenderer>),
181}
182
183impl<'a> std::ops::Deref for GpuRef<'a> {
184    type Target = cvkg_render_gpu::GpuRenderer;
185    fn deref(&self) -> &Self::Target {
186        match self {
187            GpuRef::Ptr(r) => r,
188            GpuRef::Guard(g) => g,
189        }
190    }
191}
192
193impl<'a> std::ops::DerefMut for GpuRef<'a> {
194    fn deref_mut(&mut self) -> &mut Self::Target {
195        match self {
196            GpuRef::Ptr(r) => r,
197            GpuRef::Guard(g) => &mut *g,
198        }
199    }
200}
201
202/// Read-only variant returned by NativeRenderer::gpu_ref_shared().
203enum GpuRefShared<'a> {
204    Ptr(&'a cvkg_render_gpu::GpuRenderer),
205    Guard(std::sync::MutexGuard<'a, cvkg_render_gpu::GpuRenderer>),
206}
207
208impl<'a> std::ops::Deref for GpuRefShared<'a> {
209    type Target = cvkg_render_gpu::GpuRenderer;
210    fn deref(&self) -> &Self::Target {
211        match self {
212            GpuRefShared::Ptr(r) => r,
213            GpuRefShared::Guard(g) => g,
214        }
215    }
216}
217
218impl cvkg_core::ElapsedTime for NativeRenderer {
219    fn delta_time(&self) -> f32 {
220        self.delta_time
221    }
222
223    fn elapsed_time(&self) -> f32 {
224        self.elapsed_time
225    }
226}
227
228impl cvkg_core::RendererErrorHandler for NativeRenderer {}
229
230impl cvkg_core::Renderer for NativeRenderer {
231    fn begin_world_space_panel(
232        &mut self,
233        node_id: u64,
234        transform: &cvkg_core::Transform3D,
235        glass: Option<cvkg_materials::GlassMaterial>,
236        pixels_per_unit: f32,
237        world_size: (f32, f32),
238    ) {
239        self.gpu_ref().begin_world_space_panel(node_id, transform, glass, pixels_per_unit, world_size);
240    }
241
242    fn end_world_space_panel(&mut self, node_id: u64) {
243        self.gpu_ref().end_world_space_panel(node_id);
244    }
245
246    fn fill_rect(&mut self, rect: Rect, color: [f32; 4]) {
247        self.gpu_ref().fill_rect(rect, color);
248    }
249    fn fill_rounded_rect(&mut self, rect: Rect, radius: f32, color: [f32; 4]) {
250        self.gpu_ref().fill_rounded_rect(rect, radius, color);
251    }
252    fn fill_ellipse(&mut self, rect: Rect, color: [f32; 4]) {
253        self.gpu_ref().fill_ellipse(rect, color);
254    }
255    fn stroke_rect(&mut self, rect: Rect, color: [f32; 4], stroke_width: f32) {
256        self.gpu_ref().stroke_rect(rect, color, stroke_width);
257    }
258    fn stroke_rounded_rect(&mut self, rect: Rect, radius: f32, color: [f32; 4], stroke_width: f32) {
259        self.gpu_ref()
260            .stroke_rounded_rect(rect, radius, color, stroke_width);
261    }
262    fn stroke_ellipse(&mut self, rect: Rect, color: [f32; 4], stroke_width: f32) {
263        self.gpu_ref().stroke_ellipse(rect, color, stroke_width);
264    }
265    fn draw_line(
266        &mut self,
267        x1: f32,
268        y1: f32,
269        x2: f32,
270        y2: f32,
271        color: [f32; 4],
272        stroke_width: f32,
273    ) {
274        self.gpu_ref()
275            .draw_line(x1, y1, x2, y2, color, stroke_width);
276    }
277
278    fn fill_glass_rect(&mut self, rect: Rect, radius: f32, blur_radius: f32) {
279        self.gpu_ref().fill_glass_rect(rect, radius, blur_radius);
280    }
281
282    fn fill_glass_rect_with_intensity(
283        &mut self,
284        rect: Rect,
285        radius: f32,
286        blur_radius: f32,
287        glass_intensity: f32,
288    ) {
289        self.gpu_ref()
290            .fill_glass_rect_with_intensity(rect, radius, blur_radius, glass_intensity);
291    }
292
293    fn fill_glass_rect_with_pressure(
294        &mut self,
295        rect: Rect,
296        radius: f32,
297        blur_radius: f32,
298        pressure: f32,
299    ) {
300        self.gpu_ref()
301            .fill_glass_rect_with_intensity(rect, radius, blur_radius, pressure);
302    }
303
304    fn fill_squircle(&mut self, rect: Rect, n: f32, color: [f32; 4]) {
305        self.gpu_ref().fill_squircle(rect, n, color);
306    }
307
308    fn stroke_squircle(&mut self, rect: Rect, n: f32, color: [f32; 4], stroke_width: f32) {
309        self.gpu_ref().stroke_squircle(rect, n, color, stroke_width);
310    }
311
312    fn draw_focus_ring(
313        &mut self,
314        rect: Rect,
315        radius: f32,
316        offset: f32,
317        width: f32,
318        color: [f32; 4],
319    ) {
320        self.gpu_ref()
321            .draw_focus_ring(rect, radius, offset, width, color);
322    }
323
324    fn draw_linear_gradient(
325        &mut self,
326        rect: Rect,
327        start_color: [f32; 4],
328        end_color: [f32; 4],
329        angle: f32,
330    ) {
331        self.gpu_ref()
332            .draw_linear_gradient(rect, start_color, end_color, angle);
333    }
334    fn draw_radial_gradient(&mut self, rect: Rect, inner_color: [f32; 4], outer_color: [f32; 4]) {
335        self.gpu_ref()
336            .draw_radial_gradient(rect, inner_color, outer_color);
337    }
338    fn draw_texture(&mut self, texture_id: u32, rect: Rect) {
339        self.gpu_ref().draw_texture(texture_id, rect);
340    }
341    fn draw_image(&mut self, image_name: &str, rect: Rect) {
342        self.gpu_ref().draw_image(image_name, rect);
343    }
344    fn load_image(&mut self, name: &str, data: &[u8]) {
345        self.gpu_ref().load_image(name, data);
346    }
347    fn push_clip_rect(&mut self, rect: Rect) {
348        self.gpu_ref().push_clip_rect(rect);
349    }
350    fn pop_clip_rect(&mut self) {
351        self.gpu_ref().pop_clip_rect();
352    }
353    fn push_opacity(&mut self, opacity: f32) {
354        self.gpu_ref().push_opacity(opacity);
355    }
356    fn draw_3d_cube(&mut self, rect: Rect, color: [f32; 4], rotation: [f32; 3]) {
357        self.gpu_ref().draw_3d_cube(rect, color, rotation);
358    }
359    fn render_scene_node_3d(
360        &mut self,
361        position: [f32; 3],
362        rotation: [f32; 4],
363        scale: [f32; 3],
364        color: [f32; 4],
365        meshes: &[Mesh],
366    ) {
367        self.gpu_ref()
368            .render_scene_node_3d(position, rotation, scale, color, meshes);
369    }
370    fn pop_opacity(&mut self) {
371        self.gpu_ref().pop_opacity();
372    }
373    fn bifrost(&mut self, rect: Rect, blur: f32, saturation: f32, opacity: f32) {
374        self.gpu_ref().bifrost(rect, blur, saturation, opacity);
375    }
376    fn push_mjolnir_slice(&mut self, angle: f32, offset: f32) {
377        self.gpu_ref().push_mjolnir_slice(angle, offset);
378    }
379    fn pop_mjolnir_slice(&mut self) {
380        self.gpu_ref().pop_mjolnir_slice();
381    }
382    fn mjolnir_shatter(&mut self, rect: Rect, pieces: u32, force: f32, color: [f32; 4]) {
383        self.gpu_ref().mjolnir_shatter(rect, pieces, force, color);
384    }
385    fn mjolnir_fluid_shatter(&mut self, rect: Rect, pieces: u32, force: f32, color: [f32; 4]) {
386        self.gpu_ref()
387            .mjolnir_fluid_shatter(rect, pieces, force, color);
388    }
389    fn draw_mjolnir_bolt(&mut self, from: [f32; 2], to: [f32; 2], color: [f32; 4]) {
390        self.gpu_ref().draw_mjolnir_bolt(from, to, color);
391    }
392    fn gungnir(&mut self, rect: Rect, color: [f32; 4], radius: f32, intensity: f32) {
393        self.gpu_ref().gungnir(rect, color, radius, intensity);
394    }
395    fn mani_glow(&mut self, rect: Rect, color: [f32; 4], radius: f32) {
396        self.gpu_ref().mani_glow(rect, color, radius);
397    }
398    fn register_handler(
399        &mut self,
400        event_type: &str,
401        handler: Arc<dyn Fn(cvkg_core::Event) + Send + Sync>,
402    ) {
403        self.gpu_ref().register_handler(event_type, handler);
404    }
405    fn push_vnode(&mut self, rect: Rect, name: &'static str) {
406        self.gpu_ref().push_vnode(rect, name);
407    }
408    fn pop_vnode(&mut self) {
409        self.gpu_ref().pop_vnode();
410    }
411    fn set_z_index(&mut self, z: f32) {
412        self.gpu_ref().set_z_index(z);
413    }
414    fn get_z_index(&self) -> f32 {
415        self.gpu_ref_shared().get_z_index()
416    }
417    fn register_shared_element(&mut self, id: &str, rect: Rect) {
418        self.gpu_ref().register_shared_element(id, rect);
419    }
420    fn set_material(&mut self, material: DrawMaterial) {
421        self.gpu_ref().set_material(material);
422    }
423    fn current_material(&self) -> DrawMaterial {
424        self.gpu_ref_shared().current_material()
425    }
426    fn serialize_svg(&mut self, name: &str) -> Result<String, String> {
427        self.gpu_ref().serialize_svg(name)
428    }
429    fn apply_svg_filter(
430        &mut self,
431        name: &str,
432        filter_id: &str,
433        region: Rect,
434    ) -> Result<String, String> {
435        self.gpu_ref().apply_svg_filter(name, filter_id, region)
436    }
437    fn push_shadow(&mut self, radius: f32, color: [f32; 4], offset: [f32; 2]) {
438        self.gpu_ref().push_shadow(radius, color, offset);
439    }
440    fn pop_shadow(&mut self) {
441        self.gpu_ref().pop_shadow();
442    }
443    fn push_affine(&mut self, transform: [f32; 6]) {
444        self.gpu_ref().push_affine(transform);
445    }
446    fn enter_portal(&mut self, z_index: i32) {
447        tracing::warn!(
448            "Portal rendering (enter_portal) not yet implemented in GPU backend; z_index={}",
449            z_index
450        );
451    }
452    fn exit_portal(&mut self) {
453        tracing::warn!("Portal rendering (exit_portal) not yet implemented in GPU backend");
454    }
455    fn viewport_size(&self) -> Rect {
456        let size = self.window.inner_size();
457        let scale = self.window.scale_factor();
458        let logical = size.to_logical::<f32>(scale);
459        Rect::new(0.0, 0.0, logical.width, logical.height)
460    }
461    fn announce(&mut self, message: &str, priority: cvkg_core::AnnouncementPriority) {
462        tracing::info!("Accessibility announcement [{:?}]: {}", priority, message);
463    }
464    fn load_svg(&mut self, name: &str, svg_data: &[u8]) {
465        self.gpu_ref().load_svg(name, svg_data);
466    }
467    fn draw_svg(&mut self, name: &str, rect: Rect) {
468        self.gpu_ref().draw_svg(name, rect, None, 0);
469    }
470    fn draw_svg_with_offset(&mut self, name: &str, rect: Rect, animation_time_offset: f32) {
471        self.gpu_ref()
472            .draw_svg_with_offset(name, rect, None, 0, animation_time_offset);
473    }
474    fn get_telemetry(&self) -> TelemetryData {
475        self.gpu_ref_shared().telemetry.clone()
476    }
477    fn prewarm_vram(&mut self, assets: Vec<(String, Vec<u8>)>) {
478        self.gpu_ref().prewarm_vram(assets);
479    }
480
481    fn text_scale_factor(&self) -> f32 {
482        self.gpu_ref_shared().text_scale_factor()
483    }
484
485    fn is_over_budget(&self) -> bool {
486        self.gpu_ref_shared().is_over_budget()
487    }
488
489    fn draw_text(&mut self, text: &str, rect: &Rect, size: f32, color: [f32; 4], h_align: cvkg_core::TextHAlign, v_align: cvkg_core::TextVAlign) {
490        self.gpu_ref().draw_text(text, rect, size, color, h_align, v_align);
491    }
492
493    fn measure_text(&mut self, text: &str, size: f32) -> (f32, f32) {
494        self.gpu_ref().measure_text(text, size)
495    }
496
497    fn shape_rich_text(
498        &mut self,
499        spans: &[runic_text::TextSpan],
500        max_width: Option<f32>,
501        align: runic_text::TextAlign,
502        overflow: runic_text::TextOverflow,
503    ) -> Option<runic_text::ShapedText> {
504        self.gpu_ref()
505            .shape_rich_text(spans, max_width, align, overflow)
506    }
507
508    fn draw_shaped_text(&mut self, shaped: &runic_text::ShapedText, x: f32, y: f32) {
509        self.gpu_ref().draw_shaped_text(shaped, x, y);
510    }
511
512    fn fill_glass_rect_with_tint(
513        &mut self,
514        rect: Rect,
515        radius: f32,
516        blur_radius: f32,
517        tint_color: [f32; 4],
518        glass_intensity: f32,
519    ) {
520        self.gpu_ref().fill_glass_rect_with_tint(
521            rect,
522            radius,
523            blur_radius,
524            tint_color,
525            glass_intensity,
526        );
527    }
528
529    fn set_theme(&mut self, theme: ColorTheme) {
530        self.gpu_ref().set_theme(theme);
531    }
532
533    fn trigger_shatter_event(&mut self, origin: [f32; 2], force: f32) {
534        self.gpu_ref().trigger_shatter_event(origin, force);
535    }
536
537    fn set_fireball_pos(&mut self, pos: [f32; 2]) {
538        self.gpu_ref().set_fireball_pos(pos);
539    }
540
541    fn set_scene(&mut self, scene: &str) {
542        self.gpu_ref().set_scene(scene);
543    }
544
545    fn set_scene_preset(&mut self, preset: u32) {
546        self.gpu_ref().set_scene_preset(preset);
547    }
548
549    fn set_default_background_color(&mut self, color: [f32; 4]) {
550        self.gpu_ref().set_default_background_color(color);
551    }
552    fn push_transform(&mut self, translation: [f32; 2], scale: [f32; 2], rotation: f32) {
553        self.gpu_ref().push_transform(translation, scale, rotation);
554    }
555    fn pop_transform(&mut self) {
556        self.gpu_ref().pop_transform();
557    }
558
559    fn set_berserker_mode(&mut self, state: RenderIntensityMode) {
560        self.berserker_mode = state;
561
562        if state == RenderIntensityMode::GodMode {
563            tracing::info!("ENTERING GOD MODE: Activating Berserker Determinism (High Priority)");
564            #[cfg(target_os = "linux")]
565            unsafe {
566                let ret = libc::setpriority(libc::PRIO_PROCESS, 0, -10);
567                if ret != 0 {
568                    tracing::warn!(
569                        "GodMode: setpriority failed (errno: {}) — need CAP_SYS_NIO",
570                        std::io::Error::last_os_error()
571                    );
572                }
573            }
574        } else {
575            #[cfg(target_os = "linux")]
576            unsafe {
577                let _ = libc::setpriority(libc::PRIO_PROCESS, 0, 0);
578            }
579        }
580
581        self.gpu_ref().set_berserker_mode(state);
582    }
583
584    fn set_rage(&mut self, rage: f32) {
585        self.rage = rage;
586        self.gpu_ref().set_rage(rage);
587    }
588
589    fn memoize(&mut self, id: u64, data_hash: u64, render_fn: &dyn Fn(&mut dyn Renderer)) {
590        self.gpu_ref().memoize(id, data_hash, render_fn);
591    }
592
593    fn snapshot_render_state(&self) -> RenderStateSnapshot {
594        self.gpu_ref_shared().snapshot_render_state()
595    }
596
597    fn restore_render_state(&mut self, snap: RenderStateSnapshot) {
598        self.gpu_ref().restore_render_state(snap);
599    }
600    fn request_redraw(&mut self) {
601        self.window.request_redraw();
602    }
603
604    fn capture_png(&mut self) -> Vec<u8> {
605        tracing::info!("CAPTURING_FRAME: Initiating GPU readback...");
606        let gpu = self.gpu.lock().unwrap_or_else(|p| p.into_inner());
607        pollster::block_on(gpu.capture_frame()).unwrap_or_else(|e| {
608            tracing::error!("GPU frame capture failed: {}", e);
609            Vec::new()
610        })
611    }
612
613    fn print(&mut self) {
614        tracing::info!("PRINT_BRIDGE: Spooling mission status to native printer...");
615        tracing::debug!("[BRIDGE] PRINTER_READY // SPOOLING_DATA...");
616    }
617}
cvkg_render_native/renderer.rs

cvkg_render_native/
renderer.rs
