Skip to main content

webizen_studio/render/
native.rs

1//! Native WebGPU renderer using webizen-render crate
2//!
3//! This module provides a native implementation of the Renderer trait using
4//! the WgpuRenderer from the webizen-render crate, enabling GPU-accelerated
5//! rendering with Projective Geometric Algebra support.
6
7use crate::render::{Camera, Renderer, ScreenPoint, Vec3};
8use webizen_render::{
9    Camera as WebCamera, ScreenPoint as WebScreenPoint, Vec3 as WebVec3, WgpuRenderer,
10};
11
12#[cfg(not(target_arch = "wasm32"))]
13/// Native WebGPU renderer implementation
14pub struct NativeRenderer {
15    inner: WgpuRenderer<'static>,
16}
17
18#[cfg(not(target_arch = "wasm32"))]
19impl NativeRenderer {
20    /// Create a new native WebGPU renderer backed by an offscreen target.
21    ///
22    /// The native studio runs inside a aether/webview host, so there is no OS
23    /// window to provide a `etalon::Surface`. We render headless into a texture and
24    /// expose the frame via [`NativeRenderer::read_pixels`], to be displayed
25    /// through the same CPU frame-buffer path the diffusion compute already uses.
26    pub async fn new(width: u32, height: u32) -> Result<Self, String> {
27        let inner = WgpuRenderer::new_offscreen(width, height).await?;
28        Ok(Self { inner })
29    }
30
31    /// Resize the offscreen render target.
32    pub fn resize(&mut self, width: u32, height: u32) {
33        self.inner.resize(width, height);
34    }
35
36    /// Read the current frame back as tightly-packed RGBA8 (`width*height*4` bytes).
37    pub fn read_pixels(&self) -> Option<Vec<u8>> {
38        self.inner.read_pixels()
39    }
40
41    /// Read the current frame back as PNG-encoded bytes (for webview delivery).
42    pub fn read_png(&self) -> Option<Vec<u8>> {
43        self.inner.read_png()
44    }
45}
46
47#[cfg(not(target_arch = "wasm32"))]
48impl Renderer for NativeRenderer {
49    fn viewport(&self) -> (f64, f64) {
50        self.inner.viewport()
51    }
52
53    fn set_camera(&mut self, camera: Camera) {
54        let render_camera = WebCamera {
55            position: WebVec3 {
56                x: camera.eye.x,
57                y: camera.eye.y,
58                z: camera.eye.z,
59            },
60            target: WebVec3 {
61                x: camera.target.x,
62                y: camera.target.y,
63                z: camera.target.z,
64            },
65            up: WebVec3 {
66                x: camera.world_up.x,
67                y: camera.world_up.y,
68                z: camera.world_up.z,
69            },
70            fov: camera.focal_scale,
71        };
72        self.inner.set_camera(render_camera);
73    }
74
75    fn clear(&self, color: &str) {
76        self.inner.clear(color);
77    }
78
79    fn project(&self, world: Vec3) -> Option<ScreenPoint> {
80        let render_world = WebVec3 {
81            x: world.x,
82            y: world.y,
83            z: world.z,
84        };
85        let result = self.inner.project(render_world);
86        result.map(|sp| ScreenPoint {
87            x: sp.x,
88            y: sp.y,
89            depth: 0.0,
90        })
91    }
92
93    fn line(&self, a: ScreenPoint, b: ScreenPoint, color: &str, alpha: f64, width: f64) {
94        let render_a = WebScreenPoint { x: a.x, y: a.y };
95        let render_b = WebScreenPoint { x: b.x, y: b.y };
96        self.inner.line(render_a, render_b, color, alpha, width);
97    }
98
99    fn point(&self, p: ScreenPoint, radius: f64, color: &str, alpha: f64) {
100        let render_p = WebScreenPoint { x: p.x, y: p.y };
101        self.inner.point(render_p, radius, color, alpha);
102    }
103
104    fn fill_polygon(&self, points: &[ScreenPoint], color: &str, alpha: f64) {
105        let render_points: Vec<WebScreenPoint> = points
106            .iter()
107            .map(|sp| WebScreenPoint { x: sp.x, y: sp.y })
108            .collect();
109        self.inner.fill_polygon(&render_points, color, alpha);
110    }
111}