tawasuyu/llimphi

1//! Geometría de mallas: el vértice 3D ([`Vertex3d`]), un cubo de prueba
2//! ([`cube`]) y un compositor de cajas transformadas ([`push_cube`]) para armar
3//! mallas multi-caja en CPU — p.ej. un **muñeco articulado** (cabeza/torso/
4//! miembros como cajas rotadas en sus articulaciones).
5//!
6//! Sigue el idiom de `llimphi-raster::gpu` (subir a GPU vía `to_ne_bytes`, sin
7//! `bytemuck`) para no agregar una dependencia nueva al workspace.
8
9use glam::{Mat4, Vec3};
10
11/// Vértice 3D: posición en mundo + color RGB lineal.
12#[derive(Debug, Clone, Copy)]
13pub struct Vertex3d {
14    pub pos: [f32; 3],
15    pub color: [f32; 3],
16}
17
18impl Vertex3d {
19    /// Tamaño en bytes de un vértice empaquetado (`6 × f32`).
20    pub const SIZE: usize = 6 * 4;
21
22    /// Vuelca este vértice al buffer en orden `pos.xyz, color.rgb` (native
23    /// endian, como hace `GpuBatch`).
24    pub fn write_to(&self, out: &mut Vec<u8>) {
25        for v in self.pos {
26            out.extend_from_slice(&v.to_ne_bytes());
27        }
28        for v in self.color {
29            out.extend_from_slice(&v.to_ne_bytes());
30        }
31    }
32}
33
34/// Las 8 esquinas del cubo unitario centrado en el origen (lado 1, `-0.5..0.5`).
35const CUBE_CORNERS: [[f32; 3]; 8] = [
36    [-0.5, -0.5, -0.5],
37    [0.5, -0.5, -0.5],
38    [0.5, 0.5, -0.5],
39    [-0.5, 0.5, -0.5],
40    [-0.5, -0.5, 0.5],
41    [0.5, -0.5, 0.5],
42    [0.5, 0.5, 0.5],
43    [-0.5, 0.5, 0.5],
44];
45
46/// Los 36 índices (12 triángulos) del cubo, winding CCW visto desde afuera.
47#[rustfmt::skip]
48pub const CUBE_INDICES: [u16; 36] = [
49    0, 2, 1, 0, 3, 2, // -Z (atrás)
50    4, 5, 6, 4, 6, 7, // +Z (frente)
51    0, 4, 7, 0, 7, 3, // -X (izquierda)
52    1, 2, 6, 1, 6, 5, // +X (derecha)
53    0, 1, 5, 0, 5, 4, // -Y (abajo)
54    3, 7, 6, 3, 6, 2, // +Y (arriba)
55];
56
57/// Cubo unitario centrado en el origen (lado 1, de `-0.5` a `0.5`). 8 vértices
58/// coloreados por su posición (`color = pos + 0.5`) → un degradé que deja ver
59/// las tres caras visibles distintas. 36 índices (12 triángulos), winding CCW.
60pub fn cube() -> (Vec<Vertex3d>, Vec<u16>) {
61    let verts = CUBE_CORNERS
62        .iter()
63        .map(|&[x, y, z]| Vertex3d {
64            pos: [x, y, z],
65            color: [x + 0.5, y + 0.5, z + 0.5],
66        })
67        .collect();
68    (verts, CUBE_INDICES.to_vec())
69}
70
71/// Apila un cubo transformado por `m` (mapea el cubo unitario `[-0.5,0.5]³` a su
72/// caja en mundo) con color plano `color`, en `verts`/`indices`. Es el ladrillo
73/// para componer mallas multi-caja en CPU: cada llamada agrega 8 vértices + 36
74/// índices con la base reubicada. Para un miembro articulado, `m` suele ser
75/// `T(articulación) · R(ángulo) · T(0,-largo/2,0) · S(tamaño)`.
76pub fn push_cube(verts: &mut Vec<Vertex3d>, indices: &mut Vec<u16>, m: Mat4, color: [f32; 3]) {
77    let base = verts.len() as u16;
78    for c in CUBE_CORNERS {
79        let p = m.transform_point3(Vec3::from_array(c));
80        verts.push(Vertex3d { pos: p.to_array(), color });
81    }
82    for i in CUBE_INDICES {
83        indices.push(base + i);
84    }
85}