Skip to main content

webizen_render/
zero_copy_views.rs

1//! Zero-copy WASM buffer views and std140-aligned uniform layouts.
2//!
3//! Re-exports the canonical zero-copy views and std140 layout primitives from
4//! `etalon_render::webizen_core::zero_copy_views`.
5
6pub use etalon_render::webizen_core::zero_copy_views::*;
7
8#[cfg(test)]
9mod tests {
10    use super::*;
11
12    #[test]
13    fn camera_uniform_is_128_bytes() {
14        assert_eq!(std::mem::size_of::<CameraUniform>(), 128);
15    }
16
17    #[test]
18    fn model_uniform_is_80_bytes() {
19        assert_eq!(std::mem::size_of::<ModelUniform>(), 80);
20    }
21
22    #[test]
23    fn time_uniform_is_16_bytes() {
24        assert_eq!(std::mem::size_of::<TimeUniform>(), 16);
25    }
26
27    #[test]
28    fn camera_uniform_alignment_is_16() {
29        assert_eq!(std::mem::align_of::<CameraUniform>(), 16);
30    }
31
32    #[test]
33    fn std140_layout_camera_struct() {
34        let (layout, total) =
35            std140_layout(&[("view", Std140Type::Mat4), ("proj", Std140Type::Mat4)]);
36        assert_eq!(layout.len(), 2);
37        assert_eq!(layout[0].name, "view");
38        assert_eq!(layout[0].offset, 0);
39        assert_eq!(layout[0].size, 64);
40        assert_eq!(layout[1].name, "proj");
41        assert_eq!(layout[1].offset, 64);
42        assert_eq!(layout[1].size, 64);
43        assert_eq!(total, 128);
44    }
45
46    #[test]
47    fn std140_layout_vec3_then_scalar() {
48        // vec3 at offset 0 (size 12, align 16), then f32 at offset 12
49        // (fits in the vec4 padding, no extra alignment needed since 12 is
50        // 4-byte aligned for a scalar).
51        let (layout, total) = std140_layout(&[("a", Std140Type::Vec3), ("b", Std140Type::Scalar)]);
52        assert_eq!(layout[0].offset, 0);
53        assert_eq!(layout[0].size, 12);
54        assert_eq!(layout[0].align, 16);
55        assert_eq!(layout[1].offset, 12);
56        assert_eq!(layout[1].size, 4);
57        // Total: 16 (rounded up from 16 to 16)
58        assert_eq!(total, 16);
59    }
60
61    #[test]
62    fn std140_layout_array_of_floats() {
63        // array<f32, 4>: stride 16 (std140 rounds up to vec4), total 64
64        let (layout, total) = std140_layout(&[(
65            "data",
66            Std140Type::Array {
67                elem: Std140TypeSimple::Scalar,
68                count: 4,
69            },
70        )]);
71        assert_eq!(layout[0].offset, 0);
72        assert_eq!(layout[0].size, 64); // 4 × 16
73        assert_eq!(layout[0].align, 16); // stride
74        assert_eq!(total, 64);
75    }
76
77    #[test]
78    fn std140_layout_mixed_struct() {
79        // mat4 (64B) + vec3 (12B, aligned 16) + f32 (4B)
80        let (layout, total) = std140_layout(&[
81            ("model", Std140Type::Mat4),
82            ("color", Std140Type::Vec3),
83            ("intensity", Std140Type::Scalar),
84        ]);
85        assert_eq!(layout[0].offset, 0);
86        assert_eq!(layout[0].size, 64);
87        assert_eq!(layout[1].offset, 64); // 64 is 16-aligned
88        assert_eq!(layout[1].size, 12);
89        assert_eq!(layout[2].offset, 76); // 64+12=76, 76 is 4-aligned
90        assert_eq!(layout[2].size, 4);
91        // Total: 80 (76+4=80, already 16-aligned)
92        assert_eq!(total, 80);
93    }
94
95    #[test]
96    fn camera_uniform_bytes_roundtrip() {
97        let cam = CameraUniform::new([[1.0; 4]; 4], [[2.0; 4]; 4]);
98        let bytes = cam.as_bytes();
99        assert_eq!(bytes.len(), 128);
100        // First 4 bytes should be 1.0f32 (view matrix [0][0])
101        let first_f32 = f32::from_le_bytes(bytes[0..4].try_into().unwrap());
102        assert_eq!(first_f32, 1.0);
103        // Byte 64 should be 2.0f32 (proj matrix [0][0])
104        let proj_f32 = f32::from_le_bytes(bytes[64..68].try_into().unwrap());
105        assert_eq!(proj_f32, 2.0);
106    }
107
108    #[test]
109    fn time_uniform_bytes_roundtrip() {
110        let t = TimeUniform::new(1.5, 800.0, 600.0);
111        let bytes = t.as_bytes();
112        assert_eq!(bytes.len(), 16);
113        let time = f32::from_le_bytes(bytes[0..4].try_into().unwrap());
114        assert_eq!(time, 1.5);
115        let width = f32::from_le_bytes(bytes[4..8].try_into().unwrap());
116        assert_eq!(width, 800.0);
117    }
118}