examples: apply real texture assets to multi-mesh examples

- meshes/cube: procedural checkerboard -> uv_texture.jpg (8x8 UV grid)
- meshes/pbr: floor -> ground.jpeg, bump cube -> cave.jpg + caveNormal.jpg
  (normal map pre-encoded via sRGB OETF to cancel the GPU sRGB decode)
- lights/shadow: ground -> ground.jpeg, cube -> uv_texture.jpg
- effects/demo: ground -> ground.jpeg, cube -> uv_texture.jpg
- effects/fog: ground -> ground.jpeg (tiled 80x80), cubes -> stonewall.jpg
- effects/dof: ground -> ground.jpeg, cubes -> uv_texture.jpg
- cameras/culling: shared cube mesh -> uv_texture.jpg
- add lib/examples/assets/textures/ (19 assets, 6.5 MB)
- document assets + usage in examples READMEs, docs/user/examples.md,
  docs/user/meshes/materials.md (CARGO_MANIFEST_DIR pattern, sRGB caveat)

lib/examples/lights/README.md

@@ -5,7 +5,7 @@ emissive materials.
 
 | Example | Run command | What it shows |
 |---------|-------------|---------------|
-| `shadow` | `cargo run -p wsg-lib --example shadow` | Shadow mapping in isolation (directional light, 4 objects on a floor) |
+| `shadow` | `cargo run -p wsg-lib --example shadow` | Shadow mapping in isolation (directional light, 4 objects on a textured floor) |
 | `shadow_test` | `cargo run -p wsg-lib --example shadow_test` | Dedicated shadow test: one directional caster, cube on a ground slab, PCF-softened |
 | `spot_test` | `cargo run -p wsg-lib --example spot_test` | Isolated spot light: directed beam, penumbra, attenuation |
 | `emissive` | `cargo run -p wsg-lib --example emissive` | Emissive materials (increasing intensities 0 → 4.0) |
@@ -18,7 +18,9 @@ emissive materials.
 
 Four objects (cube, sphere, cone, cylinder) on a floor, lit by a directional
 light that casts shadows. Shadow quality is controlled by `ShadowConfig`
-(map size, anti-acne bias).
+(map size, anti-acne bias). The floor is textured (`ground.jpeg`, tiled) and
+the rotating cube uses the `uv_texture.jpg` UV atlas — the textures make the
+shadow shapes and their movement clearly readable.
 
 ```sh
 cargo run -p wsg-lib --example shadow

lib/examples/lights/shadow.rs

@@ -4,6 +4,10 @@
 //! casts shadows. The shadow quality is controlled by `ShadowConfig` (map size,
 //! depth/slope bias, ortho frustum radius).
 //!
+//! The ground is textured (`ground.jpeg`, tiled via the Repeat sampler) and the
+//! cube uses the `uv_texture.jpg` UV atlas — textured surfaces make the shadow
+//! shapes and their movement clearly readable.
+//!
 //! ## Controls
 //! | Key | Action |
 //! |-----|--------|
@@ -32,12 +36,16 @@ use wsg_lib::app::AppBuilder;
 use wsg_lib::camera::CameraController;
 use wsg_lib::core::{ShadowConfig, Transform};
 use wsg_lib::mesh::{cone, cube, cylinder, icosphere, plane};
+use wsg_lib::resources::Texture;
 use wsg_lib::AppHandler;
 use wsg_lib::utils::WsgError;
 
 /// Shadow map size — change to test quality (256, 512, 1024, 2048).
 const SHADOW_MAP_SIZE: u32 = 1024;
 
+/// Texture asset directory, resolved against the crate root so the example works from any CWD.
+const TEXTURES: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/assets/textures");
+
 /// Light directions to cycle through (normalized at runtime).
 fn light_dirs() -> [Vec3; 3] {
     [
@@ -59,15 +67,39 @@ impl AppHandler for ShadowDemo {
             .register_shader("standard", wsg_lib::utils::STANDARD_SHADER_PATH)
             .unwrap();
 
+        // Textured ground + cube (assets make the shadows readable): ground.jpeg on the
+        // floor, uv_texture.jpg on the rotating cube. Paths resolve against CARGO_MANIFEST_DIR.
+        let (device, queue) = {
+            let ctx = app.context();
+            (ctx.device.clone(), ctx.queue.clone())
+        };
+        let ground_tex =
+            Texture::from_file(&device, &queue, "ground", &format!("{TEXTURES}/ground.jpeg")).unwrap();
+        app.scene.add_texture("ground_texture", ground_tex).unwrap();
+        app.scene
+            .add_material_texture("ground_mat", "standard", "ground_texture")
+            .unwrap();
+        let uv_tex = Texture::from_file(
+            &device,
+            &queue,
+            "uv_atlas",
+            &format!("{TEXTURES}/uv_texture.jpg"),
+        )
+        .unwrap();
+        app.scene.add_texture("uv_texture", uv_tex).unwrap();
+        app.scene
+            .add_material_texture("cube_mat", "standard", "uv_texture")
+            .unwrap();
+
         // Large ground plane (receives shadows).
         app.scene
-            .create_mesh("ground_mesh", plane(8.0, 8.0, 1, 1), None)
+            .create_mesh("ground_mesh", plane(8.0, 8.0, 1, 1), Some("ground_mat"))
             .unwrap();
         app.scene.add_entity("ground", "ground_mesh").unwrap();
 
         // Cube (casts + receives shadow).
         app.scene
-            .create_mesh("cube_mesh", cube(0.8), None)
+            .create_mesh("cube_mesh", cube(0.8), Some("cube_mat"))
             .unwrap();
         let mut cube_tf = Transform::identity();
         cube_tf.translation = Vec3::new(0.8, 0.4, 0.0);