Add support for light sources

jdahlstrom · jdahlstrom · commit 6f9d3c108b46 · 2025-12-21T23:44:57.000+02:00
Directional, point, and spot lights are implemented.
diff --git a/core/src/render.rs b/core/src/render.rs
@@ -26,6 +26,7 @@ pub(super) mod re_exports {
         cam::Camera,
         clip::Clip,
         ctx::Context,
+        light::Light,
         raster::Frag,
         shader::{FragmentShader, VertexShader},
         stats::Stats,
@@ -41,6 +42,7 @@ pub mod cam;
 pub mod clip;
 pub mod ctx;
 pub mod debug;
+pub mod light;
 pub mod prim;
 pub mod raster;
 pub mod scene;
diff --git a/core/src/render/cam.rs b/core/src/render/cam.rs
@@ -210,6 +210,9 @@ impl<T> Camera<T> {
     }
 }
 
+// TODO Should probably pass view and projection matrices separately
+pub type CameraUni<'a, B, Uni> = (&'a ProjMat3<B>, Uni);
+
 impl<T: Transform> Camera<T> {
     /// Returns the camera matrix.
     pub fn world_to_view(&self) -> Mat4<World, View> {
@@ -224,6 +227,10 @@ impl<T: Transform> Camera<T> {
     pub fn world_to_project(&self) -> ProjMat3<World> {
         self.world_to_view().then(&self.project)
     }
+    /// Returns the camera (view) matrix.
+    pub fn world_to_view(&self) -> Mat4<World, View> {
+        self.transform.world_to_view()
+    }
 
     /// Renders the given geometry from the viewpoint of this camera.
     pub fn render<B, Prim, Vtx: Clone, Var: Vary, Uni: Copy, Shd>(
@@ -238,15 +245,14 @@ impl<T: Transform> Camera<T> {
     ) where
         Prim: Render<Var> + Clone,
         [<Prim>::Clip]: Clip<Item = Prim::Clip>,
-        Shd: for<'a> Shader<Vtx, Var, (&'a ProjMat3<B>, Uni)>,
+        Shd: for<'a> Shader<Vtx, Var, CameraUni<'a, B, Uni>>,
     {
-        let tf = to_world.then(&self.world_to_project());
-
+        let to_proj = to_world.then(&self.world_to_project());
         super::render(
             prims.as_ref(),
             verts.as_ref(),
             shader,
-            (&tf, uniform),
+            (&to_proj, uniform),
             self.viewport,
             target,
             ctx,
diff --git a/core/src/render/light.rs b/core/src/render/light.rs
@@ -0,0 +1,107 @@
+//! Light sources
+
+use core::fmt::Debug;
+
+use crate::math::{Color3f, Linear, Mat4, Point3, Vec3, color::gray};
+
+#[derive(Copy, Clone, Debug)]
+pub struct Light<B: Default> {
+    pub color: Color3f,
+    pub kind: Kind<B>,
+    pub falloff: u8,
+}
+
+impl<B: Default> Default for Light<B> {
+    fn default() -> Self {
+        Self {
+            color: gray(1.0),
+            kind: Kind::default(),
+            falloff: 0,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum Kind<B: Default> {
+    Directional {
+        dir: Vec3<B>,
+    },
+    Point {
+        pos: Point3<B>,
+    },
+    Spot {
+        pos: Point3<B>,
+        dir: Vec3<B>,
+        radii: (f32, f32),
+    },
+}
+
+impl<B: Default> Default for Kind<B> {
+    fn default() -> Self {
+        Self::Directional { dir: -Vec3::Y }
+    }
+}
+
+impl<B: Debug + Default> Light<B> {
+    pub fn new(color: Color3f, kind: Kind<B>) -> Self {
+        Self { color, kind, ..Self::default() }
+    }
+
+    pub fn direction(&self, pt: Point3<B>) -> Vec3<B> {
+        match self.kind {
+            Kind::Point { pos, .. } => pos - pt,
+            Kind::Directional { dir } => dir,
+            Kind::Spot { pos, .. } => pos - pt,
+        }
+        .normalize()
+    }
+
+    pub fn eval(&self, pt: Point3<B>) -> (Color3f, Vec3<B>) {
+        match self.kind {
+            Kind::Point { pos } => (self.color, (pos - pt).normalize()),
+            Kind::Directional { dir } => (self.color, dir),
+            Kind::Spot { pos, dir, radii } => {
+                // TODO pt.direction_to(pt2) method?
+                let pt_dir = (pt - pos).normalize();
+                let dir = dir.normalize();
+                let dot = pt_dir.dot(&dir);
+                let (r0, r1) = (1.0 - radii.0, 1.0 - radii.1);
+                let color = if dot > r0 {
+                    self.color
+                } else if dot > r1 {
+                    // TODO inv_lerp
+                    let t = (dot - r1) / (r0 - r1); // ok: r0 - r1 != 0
+                    self.color.mul(t)
+                } else {
+                    gray(0.0)
+                };
+                (color, -pt_dir)
+            }
+        }
+        /*if self.falloff > 0 {
+            let dist = (pt - self.pos).len_sqr() * 0.5 + 1.0;
+            color.mul(dist) //.powi(-(self.falloff as i32)))
+        } else {
+            color
+        }*/
+    }
+
+    pub fn transform<C: Default>(&self, mat: &Mat4<B, C>) -> Light<C> {
+        let kind = match self.kind {
+            Kind::Point { pos } => Kind::Point { pos: mat.apply(&pos) },
+            Kind::Directional { dir } => {
+                Kind::Directional { dir: mat.to().apply(&dir) }
+            }
+            Kind::Spot { pos, dir, radii } => Kind::Spot {
+                pos: mat.apply(&pos),
+                dir: mat.to().apply(&dir),
+                radii,
+            },
+        };
+        Light {
+            kind,
+            color: self.color,
+            falloff: self.falloff,
+        }
+    }
+}
diff --git a/demos/src/bin/crates.rs b/demos/src/bin/crates.rs
@@ -6,6 +6,7 @@ use re::core::math::color::gray;
 use re::core::render::{
     cam::{FirstPerson, Fov},
     clip::Status::*,
+    light::Kind,
     scene::Obj,
     shader,
     tex::SamplerClamp,
@@ -16,6 +17,14 @@ use re::core::util::{pixfmt::Rgba8888, pnm::read_pnm};
 use re::front::sdl2::Window;
 use re::geom::solids::{Build, Cube};
 
+struct Uniform {
+    pub mv: Mat4<Model, View>,
+    pub proj: ProjMat3<View>,
+    pub light: Light<View>,
+}
+
+type Varying = (Normal3, TexCoord);
+
 fn main() {
     let mut win = Window::builder()
         .title("retrofire//crates")
@@ -29,30 +38,82 @@ fn main() {
     let light_dir = vec3(-2.0, 1.0, -4.0).normalize();
 
     let floor_shader = shader::new(
-        |v: Vertex3<_>, mvp: &ProjMat3<_>| vertex(mvp.apply(&v.pos), v.attrib),
+        |v: Vertex3<_>, u: &Uniform| {
+            vertex(u.mv.then(&u.proj).apply(&v.pos), v.attrib)
+        },
         |frag: Frag<Vec2>| {
             let even_odd = (frag.var.x() > 0.5) ^ (frag.var.y() > 0.5);
             gray(if even_odd { 0.8 } else { 0.1 }).to_color4()
         },
     );
     let crate_shader = shader::new(
-        |v: Vertex3<(Normal3, TexCoord)>, mvp: &ProjMat3<_>| {
-            vertex(mvp.apply(&v.pos), v.attrib)
+        |v: Vertex3<Varying>, u: &Uniform| {
+            vertex(u.mv.then(&u.proj).apply(&v.pos), v.attrib)
         },
-        |frag: Frag<(Normal3, TexCoord)>| {
+        |frag: Frag<Varying>| {
             let (n, uv) = frag.var;
             let kd = lerp(n.dot(&light_dir).max(0.0), 0.4, 1.0);
             let col = SamplerClamp.sample(&tex, uv);
             (col.to_color3f() * kd).to_color4()
         },
     );
+    let shader3 = shader::new(
+        |v: Vertex3<Color3f>, u: &Uniform| {
+            let pos = u.mv.apply(&v.pos);
+            let (light_col, light_dir) = u.light.eval(pos);
+            let light_col = light_col.add(&gray(0.05));
+            let lam = -light_dir.y();
+            // TODO light_col * surface_col should be compwise multiplication
+            vertex(u.proj.apply(&pos), light_col.mul(lam).mul(v.attrib.r()))
+        },
+        |f: Frag<Color3f>| f.var.to_color4(),
+    );
+
+    let crate_shader2 = shader::new(
+        |v: Vertex3<Normal3>, u: &Uniform| {
+            let n_modl = v.attrib.to();
+            let n_view = u.mv.apply(&n_modl);
+            let pos_view = u.mv.apply(&v.pos);
+            let (light_col, light_dir) = u.light.eval(pos_view);
+
+            let refl = light_dir.reflect(n_view);
+
+            let specular = (-pos_view.to_vec())
+                .normalize()
+                .dot(&refl)
+                .max(0.0)
+                .powi(20);
+
+            let lam = n_view.dot(&light_dir).max(0.0);
+
+            let pos_proj = u.proj.apply(&pos_view);
+            let color = light_col.mul(lam + specular);
+
+            vertex(pos_proj, color)
+        },
+        |frag: Frag<Color3f>| {
+            //let [x, y, z] = ((f.var + splat(1.0)) / 2.0).0;
+            //rgb(x, y, z).to_color4()
+            frag.var.to_color4()
+        },
+    );
 
     let (w, h) = win.dims;
     let mut cam = Camera::new(win.dims)
         .transform(FirstPerson::default())
-        .viewport((10..w - 10, h - 10..10))
+        .viewport((0..w, h..0))
         .perspective(Fov::Diagonal(degs(90.0)), 0.1..1000.0);
 
+    let light = Light::<Model> {
+        color: rgb(1.0, 0.5, 0.1) * 1.1,
+        kind: Kind::Spot {
+            pos: pt3(0.0, -8.0, 0.0),
+            dir: vec3(0.0, 1.0, 0.0),
+            radii: (0.1, 0.3),
+        },
+        falloff: 0,
+    };
+
     let floor = floor();
     let crates = crates();
 
@@ -84,6 +145,13 @@ fn main() {
         cam.transform
             .translate(cam_vel.mul(frame.dt.as_secs_f32()));
 
+        let light_to_view = translate(4.0 * Vec3::X)
+            .then(&rotate_y(turns(frame.t.as_secs_f32() * 0.1)))
+            .to()
+            .then(&cam.world_to_view());
+
+        let light = light.transform(&light_to_view);
+
         //
         // Render
         //
@@ -97,15 +165,19 @@ fn main() {
 
         // Floor
         {
-            let Obj { bbox, tf, geom } = &floor;
-            let model_to_project = tf.then(&world_to_project);
-            if bbox.visibility(&model_to_project) != Hidden {
-                let mut b = batch
+            let Obj { geom, bbox, tf } = &floor;
+            let mv = tf.then(&cam.world_to_view());
+            let proj = cam.project;
+            let mvp = mv.then(&proj);
+            let light = Default::default();
+
+            if bbox.visibility(&mvp) != Hidden {
+                batch
                     .clone()
                     .mesh(geom)
+                    .uniform(&Uniform { mv, proj, light })
                     .shader(floor_shader)
-                    .uniform(&model_to_project);
-                b.render();
+                    .render();
             }
         }
 
@@ -114,19 +186,21 @@ fn main() {
         for Obj { geom, bbox, tf } in &crates {
             frame.ctx.stats.borrow_mut().objs.i += 1;
 
-            let model_to_project = tf.then(&world_to_project);
+            let mv = tf.then(&cam.world_to_view());
+            let proj = cam.project;
+            let mvp = mv.then(&proj);
 
             // TODO Also if `Visible`, no further clipping or culling needed
-            if bbox.visibility(&model_to_project) == Hidden {
+            if bbox.visibility(&mvp) == Hidden {
                 continue;
             }
 
             batch
                 // TODO Try to get rid of clone
                 .clone()
                 .mesh(geom)
+                .uniform(&Uniform { mv, proj, light })
                 .shader(crate_shader)
-                .uniform(&model_to_project)
                 .render();
 
             frame.ctx.stats.borrow_mut().objs.o += 1;
@@ -140,6 +214,23 @@ fn main() {
 fn crates() -> Vec<Obj<(Normal3, TexCoord)>> {
     let obj = Obj::new(Cube { side_len: 2.0 }.build());
 
+    // let obj = Sphere {
+    //     sectors: 80,
+    //     segments: 50,
+    //     radius: 1.0,
+    // }
+    // .build();
+
+    // let obj = parse_obj(*include_bytes!("../../assets/teapot.obj"))
+    //     .unwrap()
+    //     .transform(
+    //         &scale(splat(0.4))
+    //             .then(&translate(-0.5 * Vec3::Y))
+    //             .to(),
+    //     )
+    //     .with_vertex_normals()
+    //     .build();
+
     let mut res = vec![];
     let n = 30;
     for i in (-n..=n).step_by(5) {
