feat: add spot light shadow mapping

Author: matthewjberger

apps/shadows/src/main.rs

@@ -17,6 +17,10 @@ freecs::ecs! {
     ShadowsDemoResources {
         time: f32,
         light_entity: Option<Entity>,
+        light_cone_entity: Option<Entity>,
+        spot_light_entity: Option<Entity>,
+        flashlight_entity: Option<Entity>,
+        flashlight_enabled: bool,
         spheres: Vec<(Entity, f32, f32)>,
     }
 }
@@ -27,6 +31,10 @@ impl State for ShadowsDemo {
 
         self.resources.time = 0.0;
         self.resources.light_entity = None;
+        self.resources.light_cone_entity = None;
+        self.resources.spot_light_entity = None;
+        self.resources.flashlight_entity = None;
+        self.resources.flashlight_enabled = true;
         self.resources.spheres = Vec::new();
 
         let floor = world.spawn_entities(
@@ -46,6 +54,8 @@ impl State for ShadowsDemo {
                 scale: Vec3::new(30.0, 0.1, 20.0),
             },
         );
+        world.set_global_transform(floor, GlobalTransform(nalgebra_glm::Mat4::identity()));
+        world.set_local_transform_dirty(floor, LocalTransformDirty);
         world.set_render_mesh(
             floor,
             RenderMesh {
@@ -63,6 +73,42 @@ impl State for ShadowsDemo {
         );
         world.set_casts_shadow(floor, CastsShadow);
 
+        let wall = world.spawn_entities(
+            LOCAL_TRANSFORM
+                | LOCAL_TRANSFORM_DIRTY
+                | GLOBAL_TRANSFORM
+                | RENDER_MESH
+                | MATERIAL
+                | CASTS_SHADOW,
+            1,
+        )[0];
+        world.set_local_transform(
+            wall,
+            LocalTransform {
+                translation: Vec3::new(0.0, -3.0, -10.0),
+                rotation: Quat::identity(),
+                scale: Vec3::new(30.0, 20.0, 0.1),
+            },
+        );
+        world.set_global_transform(wall, GlobalTransform(nalgebra_glm::Mat4::identity()));
+        world.set_local_transform_dirty(wall, LocalTransformDirty);
+        world.set_render_mesh(
+            wall,
+            RenderMesh {
+                name: "Cube".to_string(),
+            },
+        );
+        world.set_material(
+            wall,
+            Material {
+                base_color: [0.7, 0.6, 0.5, 1.0],
+                roughness: 0.9,
+                metallic: 0.0,
+                ..Default::default()
+            },
+        );
+        world.set_casts_shadow(wall, CastsShadow);
+
         let torus = world.spawn_entities(
             LOCAL_TRANSFORM
                 | LOCAL_TRANSFORM_DIRTY
@@ -84,6 +130,8 @@ impl State for ShadowsDemo {
                 scale: Vec3::new(4.0, 4.0, 4.0),
             },
         );
+        world.set_global_transform(torus, GlobalTransform(nalgebra_glm::Mat4::identity()));
+        world.set_local_transform_dirty(torus, LocalTransformDirty);
         world.set_render_mesh(
             torus,
             RenderMesh {
@@ -109,6 +157,72 @@ impl State for ShadowsDemo {
         );
         world.set_casts_shadow(torus, CastsShadow);
 
+        let torus_light_cube = world.spawn_entities(
+            LOCAL_TRANSFORM | LOCAL_TRANSFORM_DIRTY | GLOBAL_TRANSFORM | RENDER_MESH | MATERIAL,
+            1,
+        )[0];
+        world.set_local_transform(
+            torus_light_cube,
+            LocalTransform {
+                translation: Vec3::new(0.0, -4.7, 0.0),
+                rotation: Quat::identity(),
+                scale: Vec3::new(0.5, 0.5, 0.5),
+            },
+        );
+        world.set_global_transform(
+            torus_light_cube,
+            GlobalTransform(nalgebra_glm::Mat4::identity()),
+        );
+        world.set_local_transform_dirty(torus_light_cube, LocalTransformDirty);
+        world.set_render_mesh(
+            torus_light_cube,
+            RenderMesh {
+                name: "Cube".to_string(),
+            },
+        );
+        world.set_material(
+            torus_light_cube,
+            Material {
+                base_color: [1.0, 0.8, 0.6, 1.0],
+                emissive_factor: [2.0, 1.6, 1.2],
+                roughness: 0.0,
+                metallic: 0.0,
+                unlit: true,
+                ..Default::default()
+            },
+        );
+
+        let torus_point_light = world.spawn_entities(
+            LOCAL_TRANSFORM | LOCAL_TRANSFORM_DIRTY | GLOBAL_TRANSFORM | LIGHT,
+            1,
+        )[0];
+        world.set_local_transform(
+            torus_point_light,
+            LocalTransform {
+                translation: Vec3::new(0.0, -4.7, 0.0),
+                rotation: Quat::identity(),
+                scale: Vec3::new(1.0, 1.0, 1.0),
+            },
+        );
+        world.set_global_transform(
+            torus_point_light,
+            GlobalTransform(nalgebra_glm::Mat4::identity()),
+        );
+        world.set_local_transform_dirty(torus_point_light, LocalTransformDirty);
+        world.set_light(
+            torus_point_light,
+            Light {
+                light_type: LightType::Point,
+                color: Vec3::new(1.0, 0.8, 0.6),
+                intensity: 10.0,
+                range: 20.0,
+                inner_cone_angle: 0.0,
+                outer_cone_angle: 0.0,
+                cast_shadows: true,
+                shadow_bias: 0.007,
+            },
+        );
+
         for _ in 0..18 {
             let x = rng.random_range(-15.0..15.0);
             let y = rng.random_range(-11.0..11.0);
@@ -134,6 +248,7 @@ impl State for ShadowsDemo {
                     scale: Vec3::new(scale, scale, scale),
                 },
             );
+            world.set_local_transform_dirty(sphere, LocalTransformDirty);
             world.set_render_mesh(
                 sphere,
                 RenderMesh {
@@ -160,23 +275,20 @@ impl State for ShadowsDemo {
             LOCAL_TRANSFORM | LOCAL_TRANSFORM_DIRTY | GLOBAL_TRANSFORM | LIGHT,
             1,
         )[0];
-        world.set_local_transform(
-            light,
-            LocalTransform {
-                translation: Vec3::new(0.0, 100.0, 0.0),
-                rotation: nalgebra_glm::quat_angle_axis(
-                    -std::f32::consts::FRAC_PI_2,
-                    &Vec3::x_axis(),
-                ),
-                scale: Vec3::new(1.0, 1.0, 1.0),
-            },
-        );
+        let light_transform = LocalTransform {
+            translation: Vec3::new(0.0, 100.0, 0.0),
+            rotation: nalgebra_glm::quat_angle_axis(-std::f32::consts::FRAC_PI_2, &Vec3::x_axis()),
+            scale: Vec3::new(1.0, 1.0, 1.0),
+        };
+        world.set_local_transform(light, light_transform);
+        world.set_global_transform(light, GlobalTransform(light_transform.as_matrix()));
+        world.set_local_transform_dirty(light, LocalTransformDirty);
         world.set_light(
             light,
             Light {
                 light_type: LightType::Directional,
                 color: Vec3::new(1.0, 1.0, 1.0),
-                intensity: 3.0,
+                intensity: 1.0,
                 range: 100.0,
                 inner_cone_angle: 0.0,
                 outer_cone_angle: 0.0,
@@ -187,35 +299,85 @@ impl State for ShadowsDemo {
 
         self.resources.light_entity = Some(light);
 
+        let light_cone = world.spawn_entities(
+            LOCAL_TRANSFORM | LOCAL_TRANSFORM_DIRTY | GLOBAL_TRANSFORM | RENDER_MESH | MATERIAL,
+            1,
+        )[0];
+        world.set_local_transform(
+            light_cone,
+            LocalTransform {
+                translation: Vec3::new(0.0, 100.0, 0.0),
+                rotation: nalgebra_glm::quat_angle_axis(
+                    -std::f32::consts::FRAC_PI_2,
+                    &Vec3::x_axis(),
+                ),
+                scale: Vec3::new(3.0, 3.0, 3.0),
+            },
+        );
+        world.set_global_transform(light_cone, GlobalTransform(nalgebra_glm::Mat4::identity()));
+        world.set_local_transform_dirty(light_cone, LocalTransformDirty);
+        world.set_render_mesh(
+            light_cone,
+            RenderMesh {
+                name: "Cone".to_string(),
+            },
+        );
+        world.set_material(
+            light_cone,
+            Material {
+                base_color: [1.0, 1.0, 0.8, 1.0],
+                emissive_factor: [1.0, 1.0, 0.8],
+                roughness: 0.0,
+                metallic: 0.0,
+                unlit: true,
+                ..Default::default()
+            },
+        );
+
+        self.resources.light_cone_entity = Some(light_cone);
+
         let camera_position = Vec3::new(0.0, 10.0, 20.0);
         let camera = spawn_camera(world, camera_position, "Main Camera".to_string());
+        if let Some(camera_transform) = world.get_local_transform(camera) {
+            world.set_global_transform(camera, GlobalTransform(camera_transform.as_matrix()));
+        }
         world.resources.active_camera = Some(camera);
-    }
 
-    fn run_systems(&mut self, world: &mut World) {
-        let delta = world.resources.window.timing.delta_time;
-        self.resources.time += delta;
-
-        if let Some(light_entity) = self.resources.light_entity {
-            if let Some(mut transform) = world.get_local_transform(light_entity).cloned() {
-                let x = 50.0 * self.resources.time.sin();
-                let z = 50.0 * self.resources.time.cos();
-                transform.translation.x = x;
-                transform.translation.z = z;
+        let flashlight = world.spawn_entities(
+            LOCAL_TRANSFORM | LOCAL_TRANSFORM_DIRTY | GLOBAL_TRANSFORM | LIGHT | PARENT,
+            1,
+        )[0];
 
-                let target = Vec3::zeros();
-                let direction = (target - transform.translation).normalize();
+        let flashlight_transform = LocalTransform {
+            translation: Vec3::new(0.5, -1.2, 0.3),
+            rotation: Quat::identity(),
+            scale: Vec3::new(1.0, 1.0, 1.0),
+        };
+        world.set_local_transform(flashlight, flashlight_transform);
+        world.set_parent(flashlight, Parent(Some(camera)));
+        world.set_local_transform_dirty(flashlight, LocalTransformDirty);
+        world.set_light(
+            flashlight,
+            Light {
+                light_type: LightType::Spot,
+                color: Vec3::new(1.0, 1.0, 0.9),
+                intensity: 15.0,
+                range: 100.0,
+                inner_cone_angle: 0.15,
+                outer_cone_angle: 0.4,
+                cast_shadows: true,
+                shadow_bias: 0.007,
+            },
+        );
 
-                let pitch = direction.y.asin();
-                let yaw = direction.z.atan2(direction.x);
+        self.resources.flashlight_entity = Some(flashlight);
 
-                transform.rotation = nalgebra_glm::quat_angle_axis(yaw, &Vec3::y())
-                    * nalgebra_glm::quat_angle_axis(pitch, &Vec3::x());
+        nightshade::ecs::transform::systems::run_systems(world);
+    }
 
-                world.set_local_transform(light_entity, transform);
-                world.set_local_transform_dirty(light_entity, LocalTransformDirty);
-            }
-        }
+    fn run_systems(&mut self, world: &mut World) {
+        let delta = world.resources.window.timing.delta_time;
+        self.resources.time += delta;
 
         for (sphere_entity, _initial_y, velocity) in &mut self.resources.spheres {
             if let Some(mut transform) = world.get_local_transform(*sphere_entity).cloned() {
@@ -252,7 +414,66 @@ impl State for ShadowsDemo {
             }
         }
 
+        if let Some(light_entity) = self.resources.light_entity {
+            let cycle_speed = 0.2;
+            let angle = self.resources.time * cycle_speed;
+            let radius = 25.0;
+
+            let light_x = angle.sin() * radius;
+            let light_y = angle.cos() * radius;
+            let light_position = Vec3::new(light_x, light_y, 0.0);
+
+            let scene_center = Vec3::new(0.0, 0.0, 0.0);
+            let light_direction_toward_scene = (scene_center - light_position).normalize();
+
+            let up = if light_direction_toward_scene.y.abs() > 0.99 {
+                Vec3::new(1.0, 0.0, 0.0)
+            } else {
+                Vec3::new(0.0, 1.0, 0.0)
+            };
+
+            let light_rotation = nalgebra_glm::quat_look_at_rh(&light_direction_toward_scene, &up);
+
+            let transform = LocalTransform {
+                translation: light_position,
+                rotation: light_rotation,
+                scale: Vec3::new(1.0, 1.0, 1.0),
+            };
+
+            world.set_local_transform(light_entity, transform);
+            world.set_local_transform_dirty(light_entity, LocalTransformDirty);
+
+            if let Some(light_cone_entity) = self.resources.light_cone_entity {
+                let cone_rotation = light_rotation
+                    * nalgebra_glm::quat_angle_axis(std::f32::consts::FRAC_PI_2, &Vec3::x_axis());
+                let cone_transform = LocalTransform {
+                    translation: light_position,
+                    rotation: cone_rotation,
+                    scale: Vec3::new(3.0, 3.0, 3.0),
+                };
+                world.set_local_transform(light_cone_entity, cone_transform);
+                world.set_local_transform_dirty(light_cone_entity, LocalTransformDirty);
+            }
+        }
+
         escape_key_exit_system(world);
         fly_camera_system(world);
+        nightshade::ecs::transform::systems::run_systems(world);
+    }
+
+    fn on_keyboard_input(&mut self, world: &mut World, key_code: KeyCode, key_state: KeyState) {
+        if matches!((key_code, key_state), (KeyCode::KeyF, KeyState::Pressed)) {
+            self.resources.flashlight_enabled = !self.resources.flashlight_enabled;
+            if let Some(flashlight_entity) = self.resources.flashlight_entity {
+                if let Some(mut light) = world.get_light(flashlight_entity).cloned() {
+                    light.intensity = if self.resources.flashlight_enabled {
+                        15.0
+                    } else {
+                        0.0
+                    };
+                    world.set_light(flashlight_entity, light);
+                }
+            }
+        }
     }
 }

crates/nightshade/src/ecs/camera/components/orthographic.rs

@@ -26,8 +26,8 @@ impl OrthographicCamera {
             self.x_mag,
             -self.y_mag,
             self.y_mag,
-            self.z_near,
             self.z_far,
+            self.z_near,
         )
     }
 }