webizen_studio/render/
native.rs1use 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"))]
13pub struct NativeRenderer {
15 inner: WgpuRenderer<'static>,
16}
17
18#[cfg(not(target_arch = "wasm32"))]
19impl NativeRenderer {
20 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 pub fn resize(&mut self, width: u32, height: u32) {
33 self.inner.resize(width, height);
34 }
35
36 pub fn read_pixels(&self) -> Option<Vec<u8>> {
38 self.inner.read_pixels()
39 }
40
41 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}