modif appbuilder

lib/examples/manual.rs

@@ -0,0 +1,101 @@
+use std::sync::Arc;
+use winit::event_loop::EventLoop;
+use winit::window::WindowBuilder;
+use wsg_lib::core::Context;
+use wsg_lib::core::Frame;
+use wsg_lib::core::Renderer;
+use wsg_lib::pipeline::PipelineCache;
+use wsg_lib::resources::Material;
+use wsg_lib::resources::Mesh;
+use wsg_lib::resources::Vertex;
+use wsg_lib::utils;
+
+fn main() {
+    println!(
+        "Répertoire courant : {:?}",
+        std::env::current_dir().unwrap()
+    );
+    let event_loop = EventLoop::new().unwrap();
+    let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());
+
+    // 1. Initialisation
+    let context = pollster::block_on(Context::new(window.clone())).expect("Échec init GPU");
+
+    // Configuration de la surface et récupération du format
+    let format = context
+        .configure(&context.adapter, 800, 600)
+        .expect("Échec configuration");
+
+    // 2. Initialisation du Renderer (Il récupère tout ce dont il a besoin)
+    let device = Arc::new(context.device.clone());
+    let mut cache = PipelineCache::new(device);
+    cache
+        .register_shader("basic", utils::BASIC_SHADER_PATH)
+        .unwrap();
+
+    let renderer = Renderer::new(&context, format);
+
+    // 3. Material : On utilise renderer.device() et renderer.format()
+    let material = Material::new(renderer.format(), "basic", &mut cache);
+
+    // Mesh : On utilise le device du renderer
+    let vertices = [
+        // Position (x,y,z) | Normale (x,y,z) | UV (u,v) | Couleur (r,g,b,a)
+        Vertex {
+            position: [-0.5, 0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [0.0, 0.0],
+            color: [1.0, 0.0, 0.0, 1.0],
+        }, // Haut-Gauche (Rouge)
+        Vertex {
+            position: [0.5, 0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [1.0, 0.0],
+            color: [0.0, 1.0, 0.0, 1.0],
+        }, // Haut-Droite (Vert)
+        Vertex {
+            position: [0.5, -0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [1.0, 1.0],
+            color: [0.0, 0.0, 1.0, 1.0],
+        }, // Bas-Droite (Bleu)
+        Vertex {
+            position: [-0.5, -0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [0.0, 1.0],
+            color: [1.0, 1.0, 0.0, 1.0],
+        }, // Bas-Gauche (Jaune)
+    ];
+    let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
+    let mesh = Mesh::new(renderer.device(), &vertices, Some(&indices));
+
+    // Render loop
+    event_loop
+        .run(|event, elwt| {
+            match event {
+                winit::event::Event::AboutToWait => {
+                    window.request_redraw();
+                }
+                winit::event::Event::WindowEvent {
+                    event: winit::event::WindowEvent::RedrawRequested,
+                    ..
+                } => {
+                    if let Some(frame) = Frame::try_new(&context.surface) {
+                        // 1. Rendu (plus d'arguments device/queue inutiles)
+                        renderer.render(frame.view(), &mesh, &material);
+
+                        // 2. Présentation
+                        renderer.present(frame);
+                    }
+                }
+                winit::event::Event::WindowEvent {
+                    event: winit::event::WindowEvent::CloseRequested,
+                    ..
+                } => {
+                    elwt.exit(); // C'est ici que tu demandes à la boucle de s'arrêter
+                }
+                _ => (),
+            }
+        })
+        .unwrap();
+}

lib/examples/simple.rs

@@ -0,0 +1,70 @@
+use wsg_lib::app::{App, AppHandler};
+use wsg_lib::resources::{Material, Mesh, Vertex};
+use wsg_lib::utils;
+
+// 1. On définit notre "Jeu" qui implémente le comportement
+struct MonQuad {
+    mesh: Mesh,
+    material: Material,
+}
+
+impl AppHandler for MonQuad {
+    fn render(&mut self, app: &mut App) {
+        // Le rendu devient simple : on accède aux outils via &mut app
+        if let Some(frame) = app.context.get_next_frame() {
+            app.renderer
+                .render(frame.view(), &self.mesh, &self.material);
+            app.renderer.present(frame);
+        }
+    }
+}
+
+#[pollster::main]
+async fn main() -> Result<(), wsg_lib::utils::WsgError> {
+    // 2. Initialisation via le Builder
+    let mut app = App::builder()
+        .title("Exemple Simple")
+        .size(800, 600)
+        .build()
+        .await?;
+
+    // 3. Setup des ressources (déclaration)
+    app.cache
+        .register_shader("basic", utils::BASIC_SHADER_PATH)
+        .unwrap();
+
+    let vertices: [Vertex; 4] = [
+        Vertex {
+            position: [-0.5, 0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [0.0, 0.0],
+            color: [1.0, 0.0, 0.0, 1.0],
+        },
+        Vertex {
+            position: [0.5, 0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [1.0, 0.0],
+            color: [0.0, 1.0, 0.0, 1.0],
+        },
+        Vertex {
+            position: [0.5, -0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [1.0, 1.0],
+            color: [0.0, 0.0, 1.0, 1.0],
+        },
+        Vertex {
+            position: [-0.5, -0.5, 0.0],
+            normal: [0.0, 0.0, 1.0],
+            uv: [0.0, 1.0],
+            color: [1.0, 1.0, 0.0, 1.0],
+        },
+    ];
+    let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
+
+    let mesh = Mesh::new(app.context.device(), &vertices, Some(&indices));
+    let material = Material::new(app.renderer.format(), "basic", &mut app.cache);
+
+    // 4. Lancement de la boucle (la magie opère ici)
+    let handler = MonQuad { mesh, material };
+    app.run(handler)
+}