Demonstrate lighting in solids demo

Author: jdahlstrom

demos/src/bin/solids.rs

@@ -4,11 +4,13 @@ use minifb::{Key, KeyRepeat};
 
 use re::prelude::*;
 
+use re::core::render::light::normalize_approx;
 use re::core::{
     geom::Polyline,
     math::{ProjMat3, ProjVec3, color::gray},
-    render::cam::Fov,
-    render::{Model, ModelToWorld, shader},
+    render::{
+        Model, View, World, cam::Fov, debug::dir_to_rgb, light::Kind, shader,
+    },
 };
 use re::front::{Frame, minifb::Window};
 use re::geom::{io::read_obj, solids::*};
@@ -47,6 +49,17 @@ impl Carousel {
     }
 }
 
+#[inline]
+fn phong<B>(
+    normal: Vec3<B>,
+    view_dir: Vec3<B>,
+    light_dir: Vec3<B>,
+    r: i32,
+) -> f32 {
+    let refl_dir = light_dir.reflect(normal);
+    view_dir.dot(&refl_dir).max(0.0).powi(r)
+}
+
 fn main() {
     eprintln!("Press Space to cycle between objects...");
 
@@ -59,36 +72,70 @@ fn main() {
 
     let (w, h) = win.dims;
     let cam = Camera::new(win.dims)
-        .transform(scale3(1.0, -1.0, -1.0).to())
+        .transform(Mat4::identity())
         .perspective(Fov::Equiv35mm(28.0), 0.1..1000.0)
         .viewport(pt2(10, h - 10)..pt2(w - 10, 10));
 
+    type Varyings = (Point3<View>, Normal3);
     type VertexIn = Vertex3<Normal3>;
-    type VertexOut = Vertex<ProjVec3, Color3f>;
-    type Uniform<'a> = (&'a ProjMat3<Model>, &'a Mat4);
+    type VertexOut = Vertex<ProjVec3, Varyings>;
+    struct Uniform {
+        pub mv: Mat4<Model, View>,
+        pub proj: ProjMat3<View>,
+        pub norm: Mat4,
+        pub light: Light<View>,
+    }
 
-    fn vtx_shader(v: VertexIn, (mvp, spin): Uniform) -> VertexOut {
+    #[inline]
+    fn vtx_shader(v: VertexIn, u: &Uniform) -> VertexOut {
         // Transform vertex normal
-        let norm = spin.apply(&v.attrib);
+        let view_normal = u.norm.apply(&v.attrib);
+
         // Calculate diffuse shading
-        let diffuse = (norm.z() + 0.2).max(0.2) * 0.8;
-        // Visualize normal by mapping to RGB values
-        let [r, g, b] = (0.45 * (v.attrib + splat(1.1))).0;
-        let col = diffuse * rgb(r, g, b);
-        vertex(mvp.apply(&v.pos), col)
+        // let diffuse = (norm.z() + 0.2).max(0.2) * 0.8;
+        // // Visualize normal by mapping to RGB values
+        // let [r, g, b] = (0.45 * (v.attrib + splat(1.1))).0;
+        // let col = diffuse * rgb(r, g, b);
+
+        let view_pos = u.mv.apply(&v.pos);
+        let clip_pos = u.proj.apply(&view_pos);
+        vertex(clip_pos, (view_pos, view_normal))
     }
 
-    fn frag_shader(f: Frag<Color3f>, _: Uniform) -> Color4 {
-        f.var.to_color4()
+    #[inline]
+    fn frag_shader(f: Frag<Varyings>, u: &Uniform) -> Color4 {
+        let (view_pos, view_normal) = f.var;
+
+        let (light_col, light_dir) = u.light.eval(view_pos);
+        let camera_dir = -normalize_approx(view_pos.to_vec());
+        //let view_normal = normalize_approx(view_normal);
+
+        let ambient = rgb(0.15, 0.18, 0.25);
+
+        let diffuse = 0.4 * light_dir.dot(&view_normal.to());
+
+        let specular = 0.4 * phong(view_normal.to(), camera_dir, light_dir, 30);
+
+        let color = gray(1.0);
+
+        (light_col * color * diffuse + light_col * specular + ambient)
+            .to_color4()
+        //color.to_color4()
     }
 
     let shader = shader::new(vtx_shader, frag_shader);
 
-    let objects = objects_n(8);
+    let objects = objects_n(16);
 
-    let translate = translate(-3.0 * Vec3::Z);
+    let translate = translate(3.0 * Vec3::Z);
     let mut carousel = Carousel::default();
 
+    let _light: Light<World> =
+        Light::new(rgb(1.0, 1.0, 1.0), Kind::Directional(vec3(0.0, 0.0, -1.0)));
+
+    let light: Light<World> =
+        Light::new(rgb(1.0, 0.9, 0.6), Kind::Point(pt3(-2.0, 3.0, 1.0)));
+
     win.run(|frame| {
         let Frame { t, dt, win, .. } = frame;
 
@@ -102,19 +149,22 @@ fn main() {
         let carouse = carousel.update(dt.as_secs_f32());
 
         // Compose transform stack
-        let model_view_project: ProjMat3<Model> = spin
-            .then(&translate)
-            .then(&carouse)
-            .to::<ModelToWorld>()
-            .then(&cam.world_to_project());
+        let modelview: Mat4<Model, View> =
+            spin.then(&translate).then(&carouse).to();
 
         let object = &objects[carousel.idx % objects.len()];
 
+        let uniform = &Uniform {
+            mv: modelview,
+            proj: cam.project,
+            norm: spin,
+            light: light.transform(&cam.world_to_view()),
+        };
         Batch {
             prims: object.faces.clone(),
             verts: object.verts.clone(),
-            uniform: (&model_view_project, &spin),
-            shader: shader,
+            uniform,
+            shader,
             viewport: cam.viewport,
             target: frame.buf,
             ctx: &*frame.ctx,
@@ -148,7 +198,7 @@ fn objects_n(res: u32) -> [Mesh<Normal3>; 14] {
         lathe(sectors),
         Sphere { radius: 1.0, sectors, segments, }.build(),
         Cylinder { radius: 0.8, sectors, segments, capped: true }.build(),
-        Cone { base_radius: 1.1, apex_radius: 0.3, sectors, segments, capped: true }.build(),
+        Cone { base_radius: 1.0, apex_radius: 0.3, sectors, segments, capped: true }.build(),
         Capsule { radius: 0.5, sectors, body_segments, cap_segments }.build(),
         Torus { major_radius: 0.9, minor_radius: 0.3, major_sectors, minor_sectors }.build(),