wsg/lib/examples/cube.rs

//! Étape 5 — MVP 3D : un cube unitaire éclairé qui tourne ; **Étape 10** — le cube est **texturé**
//! (damier procédural) via le nouveau chemin diffues (bind group `@group(2)`).
//!
//! Démonstration de l'objectif MVP du ROADMAP 1.3 + 1.5 : un mesh 3D avec éclairage Phong à l'écran.
//! On suit le workflow déclaratif (comme `simple`) : `AppBuilder` + scène automatique, **sans importer
//! wgpu**. Depuis l'Étape 7 la scène possède son `PipelineCache` : on passe par `register_shader` +
//! `add_material_shader`/`add_material_texture` + `create_mesh` + `add_entity`. Depuis l'Étape 8 le mesh
//! est déclaré à partir d'une **`Geometry`** (positions, normales, indices). Depuis l'Étape 10 (D4) on
//! enregistre une texture par id (`add_texture`) puis on lie un matériau texturé (`add_material_texture`) ;
//! la texture est générée *procéduralement* (damier RGBA 8×8) pour rester autonome, sans asset sur disque.
//! La caméra active par défaut (`Scene::default`, position (0,0,3), fov 45°) cadre le cube, et
//! `AppHandler::update` fait tourner l'entité via `set_entity_transform` chaque frame.
use glam::{Quat, Vec3};
use wsg_lib::AppHandler;
use wsg_lib::app::AppBuilder;
use wsg_lib::resources::{Geometry, Texture};
use wsg_lib::utils::WsgError;

/// Handler de démonstration : fait tourner le cube texturé dans `update`.
struct Cube {
    /// Angle de rotation cumulé (radians), incrémenté à chaque frame.
    angle: f32,
}

/// Construit la `Geometry` d'un cube unitaire centré à l'origine (arête de 1), une normale et des
/// coordonnées UV par face. 24 sommets (4 par face) + 36 indices ; la couleur est absente (défaut
/// blanc opaque via `Geometry::to_vertices`). Depuis l'Étape 10, chaque face reçoit des UV [0,1]² pour
/// que la texture diffuse soit proprement projetée sur le cube.
fn cube_geometry() -> Geometry {
    let s = 0.5; // demi-arête
    // Chaque face : (normale sortante, 4 coins). Le culling est désactivé par défaut (PrimitiveState
    // par défaut), donc l'ordre d'enroulement n'affecte pas la visibilité ; seules les normales comptent
    // pour l'éclairage.
    let faces: [([f32; 3], [[f32; 3]; 4]); 6] = [
        (
            [0.0, 0.0, 1.0],
            [[-s, -s, s], [s, -s, s], [s, s, s], [-s, s, s]],
        ), // +Z
        (
            [0.0, 0.0, -1.0],
            [[s, -s, -s], [-s, -s, -s], [-s, s, -s], [s, s, -s]],
        ), // -Z
        (
            [1.0, 0.0, 0.0],
            [[s, -s, -s], [s, s, -s], [s, s, s], [s, -s, s]],
        ), // +X
        (
            [-1.0, 0.0, 0.0],
            [[-s, -s, s], [-s, s, s], [-s, s, -s], [-s, -s, -s]],
        ), // -X
        (
            [0.0, 1.0, 0.0],
            [[-s, s, -s], [s, s, -s], [s, s, s], [-s, s, s]],
        ), // +Y
        (
            [0.0, -1.0, 0.0],
            [[-s, -s, s], [s, -s, s], [s, -s, -s], [-s, -s, -s]],
        ), // -Y
    ];

    let mut positions = Vec::with_capacity(24);
    let mut normals = Vec::with_capacity(24);
    let mut uvs = Vec::with_capacity(24);
    // Mapping UV canonique d'un carré : BL(0,0) BR(1,0) TR(1,1) TL(0,1).
    let quad_uvs = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]];
    for (normal, corners) in faces {
        for (i, corner) in corners.iter().enumerate() {
            positions.push(*corner);
            normals.push(normal);
            uvs.push(quad_uvs[i]);
        }
    }

    // 2 triangles par face, 36 indices.
    let mut indices = Vec::with_capacity(36);
    for face in 0..6u16 {
        let b = face * 4;
        indices.extend_from_slice(&[b, b + 1, b + 2, b, b + 2, b + 3]);
    }

    Geometry::new(positions)
        .with_normals(normals)
        .with_uvs(uvs)
        .with_indices(indices)
}

/// Génère un damier RGBA 8×8 (blanc/brique) *procédural*, sans asset sur disque, pour texturer le
/// cube (Étape 10, D3/D4). Renvoyé en `Vec<u8>` brut RGBA8, chargeable via `Texture::from_rgba8`.
fn checkerboard_rgba() -> Vec<u8> {
    const SIZE: u32 = 8;
    let mut rgba = Vec::with_capacity((SIZE * SIZE * 4) as usize);
    for y in 0..SIZE {
        for x in 0..SIZE {
            let even = (x + y) % 2 == 0;
            let (r, g, b) = if even { (255, 255, 255) } else { (190, 40, 40) };
            rgba.extend_from_slice(&[r, g, b, 255]);
        }
    }
    rgba
}

impl AppHandler for Cube {
    fn setup(&mut self, app: &mut wsg_lib::App) {
        // Shader Phong `standard` (porteur des bind groups frame + object + texture, Étape 10).
        app.scene
            .register_shader("standard", wsg_lib::utils::STANDARD_SHADER_PATH)
            .unwrap();

        // Construit la texture damier avec le device/queue du Context (via `app.context()`), puis
        // l'enregistre dans la scène par id ; on lie ensuite un matériau texturé à cette id.
        let (device, queue) = {
            let ctx = app.context();
            (ctx.device.clone(), ctx.queue.clone())
        };
        let texture =
            Texture::from_rgba8(&device, &queue, 8, 8, &checkerboard_rgba(), "checker").unwrap();
        app.scene.add_texture("checker_texture", texture).unwrap();
        app.scene
            .add_material_texture("cube_material", "standard", "checker_texture")
            .unwrap();

        app.scene
            .create_mesh("cube_mesh", cube_geometry(), Some("cube_material"))
            .unwrap();
        app.scene.add_entity("cube", "cube_mesh").unwrap();

        // Étape 12 (Phase 4.2) : en plus de la lumière directionnelle par défaut (+Z), on ajoute
        // une lumière **ponctuelle** chaude devant le cube. Son halo (atténuation linéaire dans le
        // rayon) est visible sur la face proche du cube, en superposition à l'éclairage directionnel.
        app.scene
            .add_point_light(
                Vec3::new(1.0, 0.5, 1.5), // position monde, devant/droite du cube
                [1.0, 0.7, 0.3],          // teinte chaude
                1.0,                      // intensité
                3.0,                      // rayon d'atténuation
            )
            .unwrap();

        // Étape 13 (Phase 4.2) : une lumière **spot** verte pointée vers le cube depuis la gauche.
        // Le cône (demi-angle ~20°) projette un faisceau orienté sur les faces du cube, avec une
        // pénombre lissée au bord et une atténuation linéaire dans le rayon.
        app.scene
            .add_spot_light(
                Vec3::new(-2.0, 1.0, 1.5), // position monde, à gauche/dessus/derrière-caméra
                Vec3::new(2.0, -1.0, -1.5).normalize(), // axe du cône, vers le cube (origine)
                [0.3, 1.0, 0.4],           // teinte verte
                1.2,                       // intensité
                4.0,                       // rayon d'atténuation
                0.35,                      // demi-angle (~20°) en radians
            )
            .unwrap();
    }

    fn update(&mut self, app: &mut wsg_lib::App) {
        // Rotation cumulée du cube (double axe pour un mouvement plus lisible).
        self.angle += 0.02;
        let base = *app
            .scene
            .entity_transform("cube")
            .expect("cube entity present");
        let mut transform = base;
        transform.rotation =
            Quat::from_rotation_y(self.angle) * Quat::from_rotation_x(self.angle * 0.3);
        app.scene.set_entity_transform("cube", transform);
    }
}

#[pollster::main]
async fn main() -> Result<(), WsgError> {
    let app = AppBuilder::new().title("WSG Cube").build().await?;
    app.run(Cube { angle: 0.0 })
}