@bloomengine/engine 0.3.1

package/native/shared/src/renderer/types.rs

@@ -0,0 +1,259 @@
+//! Uniform + vertex types used throughout the renderer.
+//!
+//! Pure POD data (`bytemuck::Pod`-derived structs) — no Renderer state,
+//! no wgpu resource ownership, no behavior beyond tiny constructors /
+//! VertexBufferLayout descriptors. Split out of the 11 500-line
+//! renderer monolith so the wiring and the data types are separable.
+//!
+//! `pub` items that external modules import (`Vertex3D`,
+//! `SceneMaterialUniforms`) are re-exported from `renderer/mod.rs`
+//! with `pub use types::*;` so their public paths
+//! (`crate::renderer::Vertex3D`, etc.) stay stable.
+
+use crate::renderer::IDENTITY_MAT4;
+
+// ============================================================
+// Constants
+// ============================================================
+
+pub(super) const MAX_UNIFORM_SLOTS: usize = 8;
+
+// ============================================================
+// Vertex and Uniform types
+// ============================================================
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub(super) struct Uniforms2D {
+    pub(super) screen_size: [f32; 2],
+    pub(super) _pad: [f32; 2],
+    pub(super) view_proj: [[f32; 4]; 4],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub(super) struct Uniforms3D {
+    pub(super) mvp: [[f32; 4]; 4],
+    pub(super) model: [[f32; 4]; 4],
+    pub(super) prev_mvp: [[f32; 4]; 4],
+    pub(super) model_tint: [f32; 4],
+}
+
+/// Scene-pipeline per-material factors — the scalar parts of a glTF
+/// PBR material that get multiplied onto the corresponding texture
+/// samples. Sized to a multiple of 16 bytes for UBO alignment.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct SceneMaterialUniforms {
+    /// x = metallic_factor, y = roughness_factor,
+    /// z = has_mr_texture (1.0 = sample mr_tex and multiply, 0.0 = ignore
+    ///     mr_tex and use factors directly),
+    /// w = alpha_cutoff (0.0 = OPAQUE mode, >0 = MASK/BLEND — fragments
+    ///     whose base-colour alpha is below this are discarded).
+    pub metal_rough: [f32; 4],
+    /// rgb = emissive_factor, w = padding
+    pub emissive: [f32; 4],
+}
+
+impl SceneMaterialUniforms {
+    pub fn new(
+        metallic: f32,
+        roughness: f32,
+        emissive: [f32; 3],
+        has_mr_texture: bool,
+        alpha_cutoff: f32,
+    ) -> Self {
+        Self {
+            metal_rough: [
+                metallic,
+                roughness,
+                if has_mr_texture { 1.0 } else { 0.0 },
+                alpha_cutoff,
+            ],
+            emissive: [emissive[0], emissive[1], emissive[2], 0.0],
+        }
+    }
+}
+
+pub(super) const MAX_DIR_LIGHTS: usize = 4;
+pub(super) const MAX_POINT_LIGHTS: usize = 16;
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub(super) struct DirLight {
+    pub(super) direction: [f32; 4],  // xyz + intensity
+    pub(super) color: [f32; 4],      // rgb + _pad
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub(super) struct PointLight {
+    pub(super) position: [f32; 4],   // xyz + range
+    pub(super) color: [f32; 4],      // rgb + intensity
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub(super) struct LightingUniforms {
+    pub(super) ambient: [f32; 4],                              // rgb + intensity
+    pub(super) light_dir: [f32; 4],                             // xyz + intensity (legacy, kept for compat)
+    pub(super) light_color: [f32; 4],                           // rgb + _pad (legacy)
+    pub(super) dir_light_count: [f32; 4],                       // [count, 0, 0, 0]
+    pub(super) dir_lights: [DirLight; MAX_DIR_LIGHTS],          // additional directional lights
+    pub(super) point_light_count: [f32; 4],                     // [count, 0, 0, 0]
+    pub(super) point_lights: [PointLight; MAX_POINT_LIGHTS],    // point lights
+    /// Camera world-space position (xyz) + env intensity multiplier
+    /// (w). Scene shader uses xyz to compute V = normalize(camera_pos
+    /// - world_pos) for GGX specular, and multiplies w into every env
+    /// sample so IBL stays in sync with the sky pass when the user
+    /// scales their HDR. Written once per frame before the main pass.
+    pub(super) camera_pos: [f32; 4],
+    /// Cascaded shadow map: 3 light view-projection matrices (one per
+    /// cascade). Scene shader selects the tightest cascade based on
+    /// the fragment's view-space depth and projects through the
+    /// corresponding matrix for shadow-map UV.
+    pub(super) shadow_cascade_vps: [[[f32; 4]; 4]; 3],
+    /// View-space Z split distances for cascade selection (xyz = split
+    /// distances for cascades 0/1/2, w = unused). Fragment at depth z
+    /// uses cascade i where z <= cascade_splits[i].
+    pub(super) shadow_cascade_splits: [f32; 4],
+    /// Camera view matrix — passed to the shader so the fragment shader
+    /// can compute view-space Z for cascade selection without an extra
+    /// buffer binding.
+    pub(super) shadow_view_matrix: [[f32; 4]; 4],
+}
+
+impl LightingUniforms {
+    pub(super) fn defaults() -> Self {
+        Self {
+            ambient: [1.0, 1.0, 1.0, 0.3],
+            light_dir: [0.5, 1.0, 0.3, 0.7],
+            light_color: [1.0, 1.0, 1.0, 0.0],
+            dir_light_count: [0.0; 4],
+            dir_lights: [DirLight { direction: [0.0; 4], color: [0.0; 4] }; MAX_DIR_LIGHTS],
+            point_light_count: [0.0; 4],
+            point_lights: [PointLight { position: [0.0; 4], color: [0.0; 4] }; MAX_POINT_LIGHTS],
+            // w = env_intensity multiplier for IBL + sky. 1.0 matches
+            // the path-traced reference; apps with bright HDR envs
+            // typically dial to 0.2–0.5 via set_env_intensity.
+            camera_pos: [0.0, 0.0, 0.0, 1.0],
+            shadow_cascade_vps: [IDENTITY_MAT4; 3],
+            shadow_cascade_splits: [8.0, 25.0, 80.0, 0.0],
+            shadow_view_matrix: IDENTITY_MAT4,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct Vertex2D {
+    pub position: [f32; 2],
+    pub uv: [f32; 2],
+    pub color: [f32; 4],
+}
+
+impl Vertex2D {
+    pub fn desc() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute { offset: 0, shader_location: 0, format: wgpu::VertexFormat::Float32x2 },
+                wgpu::VertexAttribute { offset: 8, shader_location: 1, format: wgpu::VertexFormat::Float32x2 },
+                wgpu::VertexAttribute { offset: 16, shader_location: 2, format: wgpu::VertexFormat::Float32x4 },
+            ],
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct Vertex3D {
+    pub position: [f32; 3],
+    pub normal: [f32; 3],
+    pub color: [f32; 4],
+    pub uv: [f32; 2],
+    pub joints: [f32; 4],   // bone indices (as floats for simplicity)
+    pub weights: [f32; 4],  // bone weights (sum to 1.0, or all 0.0 for unskinned)
+    pub tangent: [f32; 4],  // xyz = tangent direction, w = bitangent sign (±1). All zero = no tangent data; scene shader then skips normal mapping.
+}
+
+impl Default for Vertex3D {
+    fn default() -> Self {
+        bytemuck::Zeroable::zeroed()
+    }
+}
+
+impl Vertex3D {
+    pub fn desc() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute { offset: 0, shader_location: 0, format: wgpu::VertexFormat::Float32x3 },   // position
+                wgpu::VertexAttribute { offset: 12, shader_location: 1, format: wgpu::VertexFormat::Float32x3 },  // normal
+                wgpu::VertexAttribute { offset: 24, shader_location: 2, format: wgpu::VertexFormat::Float32x4 },  // color
+                wgpu::VertexAttribute { offset: 40, shader_location: 3, format: wgpu::VertexFormat::Float32x2 },  // uv
+                wgpu::VertexAttribute { offset: 48, shader_location: 4, format: wgpu::VertexFormat::Float32x4 },  // joints
+                wgpu::VertexAttribute { offset: 64, shader_location: 5, format: wgpu::VertexFormat::Float32x4 },  // weights
+                wgpu::VertexAttribute { offset: 80, shader_location: 6, format: wgpu::VertexFormat::Float32x4 },  // tangent
+            ],
+        }
+    }
+}
+
+/// Per-instance data for materials compiled with `wants_instancing = true`.
+/// Bound at vertex buffer slot 1, step_mode = Instance. Layout is fixed
+/// at engine V1; future extensions can parameterise from a material desc.
+///
+/// Per-vertex attributes use shader_location 0..6. Per-instance
+/// attributes start at shader_location 7. The TS-side flat layout is 9
+/// floats per instance (pos.xyz, rot_y, scale, tint.rgba); the Rust
+/// side pads each instance to 12 floats so the GPU stride matches the
+/// 48-byte vec4-aligned layout.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct InstanceData3D {
+    pub position: [f32; 3],   // world-space position
+    pub rot_y:    f32,        // Y-axis rotation in radians
+    pub scale:    f32,        // uniform scale multiplier (1.0 = no scale)
+    pub tint:     [f32; 4],   // RGBA tint multiplier (1,1,1,1 = no tint)
+    pub _pad:     [f32; 3],   // pad to 16-byte alignment (vec4 boundary)
+}
+
+impl InstanceData3D {
+    pub fn desc() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Instance,
+            attributes: &[
+                wgpu::VertexAttribute { offset: 0,  shader_location: 7,  format: wgpu::VertexFormat::Float32x3 },  // position
+                wgpu::VertexAttribute { offset: 12, shader_location: 8,  format: wgpu::VertexFormat::Float32 },    // rot_y
+                wgpu::VertexAttribute { offset: 16, shader_location: 9,  format: wgpu::VertexFormat::Float32 },    // scale
+                wgpu::VertexAttribute { offset: 20, shader_location: 10, format: wgpu::VertexFormat::Float32x4 },  // tint
+            ],
+        }
+    }
+}
+
+// ============================================================
+// Draw call tracking
+// ============================================================
+
+pub(super) struct DrawCall2D {
+    pub(super) texture_idx: u32,
+    pub(super) uniform_idx: u32,
+    pub(super) index_start: u32,
+}
+
+pub(super) struct DrawCall3D {
+    pub(super) texture_idx: u32,
+    pub(super) index_start: u32,
+}
+
+#[derive(PartialEq, Clone, Copy)]
+pub enum RenderMode {
+    ScreenSpace,
+    Mode2D,
+    Mode3D,
+}

package/native/shared/src/renderer/util.rs

@@ -0,0 +1,151 @@
+//! Pure utility helpers extracted from the renderer monolith.
+//!
+//! - `IDENTITY_MAT4` + the `mat4_*` family: column-major 4×4 matrix
+//!   math used by the renderer internally *and* by sibling modules
+//!   (`shadows`, `picking`) via `crate::renderer::mat4_*`. Reexported
+//!   from `renderer/mod.rs` with `pub use util::*;` so external paths
+//!   stay stable.
+//! - `encode_png_simple`: RGB → PNG byte blob, used by the screenshot
+//!   path. `pub(super)` — only `renderer::` needs it.
+
+pub const IDENTITY_MAT4: [[f32; 4]; 4] = [
+    [1.0, 0.0, 0.0, 0.0],
+    [0.0, 1.0, 0.0, 0.0],
+    [0.0, 0.0, 1.0, 0.0],
+    [0.0, 0.0, 0.0, 1.0],
+];
+
+// ============================================================
+// Matrix math helpers (column-major for WGSL)
+// ============================================================
+
+pub fn mat4_perspective(fovy: f32, aspect: f32, near: f32, far: f32) -> [[f32; 4]; 4] {
+    let f = 1.0 / (fovy / 2.0).tan();
+    let nf = 1.0 / (near - far);
+    [
+        [f / aspect, 0.0, 0.0, 0.0],
+        [0.0, f, 0.0, 0.0],
+        [0.0, 0.0, (far + near) * nf, -1.0],
+        [0.0, 0.0, 2.0 * far * near * nf, 0.0],
+    ]
+}
+
+pub fn mat4_ortho(left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32) -> [[f32; 4]; 4] {
+    // wgpu NDC z range is [0, 1] (not OpenGL's [-1, 1]). Matching
+    // this so shadow-map fragments at near half-depth don't get
+    // clipped and sample_shadow's in-frustum test (z in [0, 1])
+    // actually works.
+    let lr = 1.0 / (left - right);
+    let bt = 1.0 / (bottom - top);
+    let nf = 1.0 / (near - far);
+    [
+        [-2.0 * lr, 0.0, 0.0, 0.0],
+        [0.0, -2.0 * bt, 0.0, 0.0],
+        [0.0, 0.0, nf,   0.0],
+        [(left + right) * lr, (top + bottom) * bt, near * nf, 1.0],
+    ]
+}
+
+pub fn mat4_look_at(eye: [f32; 3], center: [f32; 3], up: [f32; 3]) -> [[f32; 4]; 4] {
+    let fx = center[0] - eye[0];
+    let fy = center[1] - eye[1];
+    let fz = center[2] - eye[2];
+    let flen = (fx*fx + fy*fy + fz*fz).sqrt();
+    let (fx, fy, fz) = (fx/flen, fy/flen, fz/flen);
+
+    let sx = fy * up[2] - fz * up[1];
+    let sy = fz * up[0] - fx * up[2];
+    let sz = fx * up[1] - fy * up[0];
+    let slen = (sx*sx + sy*sy + sz*sz).sqrt();
+    let (sx, sy, sz) = (sx/slen, sy/slen, sz/slen);
+
+    let ux = sy * fz - sz * fy;
+    let uy = sz * fx - sx * fz;
+    let uz = sx * fy - sy * fx;
+
+    [
+        [sx, ux, -fx, 0.0],
+        [sy, uy, -fy, 0.0],
+        [sz, uz, -fz, 0.0],
+        [-(sx*eye[0]+sy*eye[1]+sz*eye[2]), -(ux*eye[0]+uy*eye[1]+uz*eye[2]), fx*eye[0]+fy*eye[1]+fz*eye[2], 1.0],
+    ]
+}
+
+pub fn mat4_multiply(a: [[f32; 4]; 4], b: [[f32; 4]; 4]) -> [[f32; 4]; 4] {
+    let mut out = [[0.0f32; 4]; 4];
+    for col in 0..4 {
+        for row in 0..4 {
+            out[col][row] = a[0][row]*b[col][0] + a[1][row]*b[col][1] + a[2][row]*b[col][2] + a[3][row]*b[col][3];
+        }
+    }
+    out
+}
+
+/// Multiply a column-major 4x4 matrix by a column vector.
+pub fn mat4_mul_vec4(m: &[[f32; 4]; 4], v: &[f32; 4]) -> [f32; 4] {
+    [
+        m[0][0]*v[0] + m[1][0]*v[1] + m[2][0]*v[2] + m[3][0]*v[3],
+        m[0][1]*v[0] + m[1][1]*v[1] + m[2][1]*v[2] + m[3][1]*v[3],
+        m[0][2]*v[0] + m[1][2]*v[1] + m[2][2]*v[2] + m[3][2]*v[3],
+        m[0][3]*v[0] + m[1][3]*v[1] + m[2][3]*v[2] + m[3][3]*v[3],
+    ]
+}
+
+pub fn mat4_translate(m: [[f32; 4]; 4], v: [f32; 3]) -> [[f32; 4]; 4] {
+    let mut out = m;
+    for i in 0..4 {
+        out[3][i] += m[0][i]*v[0] + m[1][i]*v[1] + m[2][i]*v[2];
+    }
+    out
+}
+
+pub fn mat4_scale(m: [[f32; 4]; 4], v: [f32; 3]) -> [[f32; 4]; 4] {
+    let mut out = m;
+    for i in 0..4 { out[0][i] *= v[0]; }
+    for i in 0..4 { out[1][i] *= v[1]; }
+    for i in 0..4 { out[2][i] *= v[2]; }
+    out
+}
+
+pub fn mat4_invert(m: [[f32; 4]; 4]) -> [[f32; 4]; 4] {
+    let m = |r: usize, c: usize| m[c][r]; // accessor for row-major style
+    let mut inv = [0.0f32; 16];
+    inv[0]  =  m(1,1)*m(2,2)*m(3,3) - m(1,1)*m(2,3)*m(3,2) - m(2,1)*m(1,2)*m(3,3) + m(2,1)*m(1,3)*m(3,2) + m(3,1)*m(1,2)*m(2,3) - m(3,1)*m(1,3)*m(2,2);
+    inv[4]  = -m(1,0)*m(2,2)*m(3,3) + m(1,0)*m(2,3)*m(3,2) + m(2,0)*m(1,2)*m(3,3) - m(2,0)*m(1,3)*m(3,2) - m(3,0)*m(1,2)*m(2,3) + m(3,0)*m(1,3)*m(2,2);
+    inv[8]  =  m(1,0)*m(2,1)*m(3,3) - m(1,0)*m(2,3)*m(3,1) - m(2,0)*m(1,1)*m(3,3) + m(2,0)*m(1,3)*m(3,1) + m(3,0)*m(1,1)*m(2,3) - m(3,0)*m(1,3)*m(2,1);
+    inv[12] = -m(1,0)*m(2,1)*m(3,2) + m(1,0)*m(2,2)*m(3,1) + m(2,0)*m(1,1)*m(3,2) - m(2,0)*m(1,2)*m(3,1) - m(3,0)*m(1,1)*m(2,2) + m(3,0)*m(1,2)*m(2,1);
+    inv[1]  = -m(0,1)*m(2,2)*m(3,3) + m(0,1)*m(2,3)*m(3,2) + m(2,1)*m(0,2)*m(3,3) - m(2,1)*m(0,3)*m(3,2) - m(3,1)*m(0,2)*m(2,3) + m(3,1)*m(0,3)*m(2,2);
+    inv[5]  =  m(0,0)*m(2,2)*m(3,3) - m(0,0)*m(2,3)*m(3,2) - m(2,0)*m(0,2)*m(3,3) + m(2,0)*m(0,3)*m(3,2) + m(3,0)*m(0,2)*m(2,3) - m(3,0)*m(0,3)*m(2,2);
+    inv[9]  = -m(0,0)*m(2,1)*m(3,3) + m(0,0)*m(2,3)*m(3,1) + m(2,0)*m(0,1)*m(3,3) - m(2,0)*m(0,3)*m(3,1) - m(3,0)*m(0,1)*m(2,3) + m(3,0)*m(0,3)*m(2,1);
+    inv[13] =  m(0,0)*m(2,1)*m(3,2) - m(0,0)*m(2,2)*m(3,1) - m(2,0)*m(0,1)*m(3,2) + m(2,0)*m(0,2)*m(3,1) + m(3,0)*m(0,1)*m(2,2) - m(3,0)*m(0,2)*m(2,1);
+    inv[2]  =  m(0,1)*m(1,2)*m(3,3) - m(0,1)*m(1,3)*m(3,2) - m(1,1)*m(0,2)*m(3,3) + m(1,1)*m(0,3)*m(3,2) + m(3,1)*m(0,2)*m(1,3) - m(3,1)*m(0,3)*m(1,2);
+    inv[6]  = -m(0,0)*m(1,2)*m(3,3) + m(0,0)*m(1,3)*m(3,2) + m(1,0)*m(0,2)*m(3,3) - m(1,0)*m(0,3)*m(3,2) - m(3,0)*m(0,2)*m(1,3) + m(3,0)*m(0,3)*m(1,2);
+    inv[10] =  m(0,0)*m(1,1)*m(3,3) - m(0,0)*m(1,3)*m(3,1) - m(1,0)*m(0,1)*m(3,3) + m(1,0)*m(0,3)*m(3,1) + m(3,0)*m(0,1)*m(1,3) - m(3,0)*m(0,3)*m(1,1);
+    inv[14] = -m(0,0)*m(1,1)*m(3,2) + m(0,0)*m(1,2)*m(3,1) + m(1,0)*m(0,1)*m(3,2) - m(1,0)*m(0,2)*m(3,1) - m(3,0)*m(0,1)*m(1,2) + m(3,0)*m(0,2)*m(1,1);
+    inv[3]  = -m(0,1)*m(1,2)*m(2,3) + m(0,1)*m(1,3)*m(2,2) + m(1,1)*m(0,2)*m(2,3) - m(1,1)*m(0,3)*m(2,2) - m(2,1)*m(0,2)*m(1,3) + m(2,1)*m(0,3)*m(1,2);
+    inv[7]  =  m(0,0)*m(1,2)*m(2,3) - m(0,0)*m(1,3)*m(2,2) - m(1,0)*m(0,2)*m(2,3) + m(1,0)*m(0,3)*m(2,2) + m(2,0)*m(0,2)*m(1,3) - m(2,0)*m(0,3)*m(1,2);
+    inv[11] = -m(0,0)*m(1,1)*m(2,3) + m(0,0)*m(1,3)*m(2,1) + m(1,0)*m(0,1)*m(2,3) - m(1,0)*m(0,3)*m(2,1) - m(2,0)*m(0,1)*m(1,3) + m(2,0)*m(0,3)*m(1,1);
+    inv[15] =  m(0,0)*m(1,1)*m(2,2) - m(0,0)*m(1,2)*m(2,1) - m(1,0)*m(0,1)*m(2,2) + m(1,0)*m(0,2)*m(2,1) + m(2,0)*m(0,1)*m(1,2) - m(2,0)*m(0,2)*m(1,1);
+
+    let det = m(0,0)*inv[0] + m(0,1)*inv[4] + m(0,2)*inv[8] + m(0,3)*inv[12];
+    if det.abs() < 1e-10 { return IDENTITY_MAT4; }
+    let inv_det = 1.0 / det;
+    let mut out = [[0.0f32; 4]; 4];
+    for col in 0..4 {
+        for row in 0..4 {
+            out[col][row] = inv[col * 4 + row] * inv_det;
+        }
+    }
+    out
+}
+
+/// Encode an RGB byte buffer (no alpha) as a PNG. Used by the
+/// pending-screenshot path so callers can hand us a path and get a
+/// PNG written to disk without worrying about cross-FFI buffer handoff.
+pub(super) fn encode_png_simple(width: u32, height: u32, rgb: &[u8]) -> Option<Vec<u8>> {
+    use image::{ImageBuffer, Rgb};
+    let buf: ImageBuffer<Rgb<u8>, Vec<u8>> = ImageBuffer::from_raw(width, height, rgb.to_vec())?;
+    let mut out = std::io::Cursor::new(Vec::new());
+    buf.write_to(&mut out, image::ImageFormat::Png).ok()?;
+    Some(out.into_inner())
+}