réorg doc

lib/examples/effects/msaa.rs

@@ -0,0 +1,151 @@
+//! **MSAA (Multi-Sample Anti-Aliasing)** — demonstrates 4× MSAA edge smoothing.
+//!
+//! Shows how MSAA eliminates the jagged "staircase" artifacts (aliasing) along
+//! sharp edges. The scene contains a cube (sharp edges), a sphere (curved surface),
+//! and a ground plane — all with high-contrast edges where aliasing is most visible.
+//!
+//! To compare with/without MSAA: remove the `.with_msaa(4)` line from the builder
+//! below and rebuild. The scene and lighting are identical — only the edge
+//! smoothness differs.
+//!
+//! ## Pipeline (MSAA + HDR)
+//! ```text
+//! Main pass → MSAA texture (4 samples, Rgba16Float)
+//!             ↓ resolve (average 4 samples → 1)
+//!           HDR texture (single sample)
+//!             ↓
+//!           Tone Mapping → surface
+//! ```
+//!
+//! ## Controls
+//! | Key | Action |
+//! |-----|--------|
+//! | Drag (LMB) | Orbit camera |
+//! | Wheel | Zoom |
+//! | `R` | Reset camera |
+//! | `M` | Toggle MSAA info (shows sample count) |
+//!
+//! ## Build & Run
+//! ```sh
+//! cargo run -p wsg-lib --example msaa
+//! ```
+
+use glam::Vec3;
+use winit::event::MouseButton;
+use winit::keyboard::KeyCode;
+use wsg_lib::app::AppBuilder;
+use wsg_lib::camera::CameraController;
+use wsg_lib::core::{Transform, ToneMapper};
+use wsg_lib::mesh::{cube, icosphere, plane};
+use wsg_lib::AppHandler;
+use wsg_lib::utils::WsgError;
+
+struct MsaaDemo {
+    camera: CameraController,
+    show_info: bool,
+}
+
+impl AppHandler for MsaaDemo {
+    fn setup(&mut self, app: &mut wsg_lib::App) {
+        app.scene
+            .register_shader("standard", wsg_lib::utils::STANDARD_SHADER_PATH)
+            .unwrap();
+
+        // Ground plane.
+        app.scene
+            .create_mesh("ground_mesh", plane(10.0, 10.0, 1, 1), None)
+            .unwrap();
+        app.scene.add_entity("ground", "ground_mesh").unwrap();
+
+        // Cube — sharp edges make aliasing very visible.
+        app.scene
+            .create_mesh("cube_mesh", cube(1.0), None)
+            .unwrap();
+        let mut cube_tf = Transform::identity();
+        cube_tf.translation = Vec3::new(1.5, 0.5, 0.0);
+        app.scene
+            .add_entity_with_transform("cube", "cube_mesh", cube_tf)
+            .unwrap();
+
+        // Sphere — curved surface, aliasing visible on the silhouette.
+        app.scene
+            .create_mesh("sphere_mesh", icosphere(0.6, 3), None)
+            .unwrap();
+        let mut sphere_tf = Transform::identity();
+        sphere_tf.translation = Vec3::new(-1.5, 0.6, 0.0);
+        app.scene
+            .add_entity_with_transform("sphere", "sphere_mesh", sphere_tf)
+            .unwrap();
+
+        // Small cube near the camera — very close edges, maximum aliasing.
+        app.scene
+            .create_mesh("small_cube_mesh", cube(0.3), None)
+            .unwrap();
+        let mut small_tf = Transform::identity();
+        small_tf.translation = Vec3::new(0.0, 0.15, 1.5);
+        app.scene
+            .add_entity_with_transform("small_cube", "small_cube_mesh", small_tf)
+            .unwrap();
+
+        // Directional light (strong, creates high-contrast edges).
+        let light_dir = Vec3::new(0.5, 1.0, 0.3).normalize();
+        app.scene
+            .add_directional_light(light_dir, [1.0, 0.95, 0.85], 1.5)
+            .unwrap();
+        app.scene.set_ambient([0.08, 0.08, 0.1]);
+
+        // Camera.
+        self.camera.yaw = 0.4;
+        self.camera.pitch = 0.2;
+        self.camera.distance = 4.0;
+        self.camera.target = Vec3::new(0.0, 0.4, 0.0);
+        self.camera.apply_to(app.scene.camera_mut());
+
+        // Print MSAA status.
+        let sc = app.renderer().msaa_sample_count();
+        eprintln!("[MSAA] sample_count = {} ({})", sc, if sc > 1 { "active" } else { "disabled" });
+    }
+
+    fn update(&mut self, app: &mut wsg_lib::App) {
+        // Orbit camera.
+        let (dx, dy) = app.input.mouse_delta();
+        if app.input.mouse_button_held(MouseButton::Left) {
+            self.camera.orbit(dx, dy);
+        }
+        let (_, sy) = app.input.scroll_delta();
+        self.camera.zoom(sy);
+
+        if app.input.key_pressed(KeyCode::KeyR) {
+            self.camera.yaw = 0.4;
+            self.camera.pitch = 0.2;
+            self.camera.distance = 4.0;
+        }
+        self.camera.apply_to(app.scene.camera_mut());
+
+        // Toggle info display.
+        if app.input.key_pressed(KeyCode::KeyM) {
+            self.show_info = !self.show_info;
+            let sc = app.renderer().msaa_sample_count();
+            eprintln!("[MSAA] {}× {}", sc, if sc > 1 { "enabled" } else { "disabled (single sample)" });
+        }
+    }
+
+    fn render(&mut self, app: &mut wsg_lib::App, frame: &wsg_lib::core::Frame) {
+        app.render_scene(frame.view());
+    }
+}
+
+#[pollster::main]
+async fn main() -> Result<(), WsgError> {
+    let app = AppBuilder::new()
+        .title("WSG MSAA 4×")
+        .size(960, 640)
+        .with_msaa(4)               // ← Enable 4× MSAA (remove for comparison)
+        .with_hdr(ToneMapper::Aces) // MSAA works with or without HDR
+        .build()
+        .await?;
+    app.run(MsaaDemo {
+        camera: CameraController::default(),
+        show_info: false,
+    })
+}