Add basis parameter to Normal3

Author: jdahlstrom

core/src/geom/mesh.rs

@@ -205,7 +205,7 @@ impl<A> Builder<A> {
     /// This is an eager operation, that is, only vertices *currently* added
     /// to the builder are transformed. The attribute type of the result is
     /// `Normal3`; the vertex type it accepts is changed accordingly.
-    pub fn with_vertex_normals(self) -> Builder<Normal3> {
+    pub fn with_vertex_normals(self) -> Builder<Normal3<Model>> {
         let Mesh { verts, faces } = self.mesh;
 
         // Compute weighted face normals...

core/src/geom/prim.rs

@@ -66,7 +66,8 @@ pub struct Sphere<B = ()>(pub Point3<B>, pub f32);
 
 /// A surface normal in 3D.
 // TODO Use distinct type rather than alias
-pub type Normal3 = Vec3;
+pub type Normal3<B> = Vec3<B>;
+
 /// A surface normal in 2D.
 pub type Normal2 = Vec2;
 
@@ -239,7 +240,7 @@ impl<A, B> Tri<Vertex3<A, B>> {
     /// ]);
     /// assert_eq!(tri.normal(), vec3(0.0, SQRT_2 / 2.0, -SQRT_2 / 2.0));
     /// ```
-    pub fn normal(&self) -> Normal3 {
+    pub fn normal(&self) -> Normal3<B> {
         let [t, u] = self.tangents();
         // TODO normal with basis
         t.cross(&u).normalize_or_zero().to()
@@ -383,7 +384,7 @@ impl<B> Plane3<B> {
     /// assert_eq!(p.offset(), 3.0);
     ///
     /// ```
-    pub fn from_point_and_normal(pt: Point3<B>, n: Normal3) -> Self {
+    pub fn from_point_and_normal(pt: Point3<B>, n: Normal3<B>) -> Self {
         let n = n.normalize();
         let d = pt.to_vec().dot(&n.to());
         Plane::new(n.x(), n.y(), n.z(), d)
@@ -400,7 +401,7 @@ impl<B> Plane3<B> {
     /// assert_eq!(<Plane3>::XY.normal(), Vec3::Z);
     /// assert_eq!(<Plane3>::YZ.normal(), Vec3::X);
     #[inline]
-    pub fn normal(&self) -> Normal3 {
+    pub fn normal(&self) -> Normal3<B> {
         self.abc().normalize().to()
     }
 

core/src/render/tex.rs

@@ -80,7 +80,7 @@ pub const fn uv(u: f32, v: f32) -> TexCoord {
 ///   1 +------+------+------+
 ///
 /// ```
-pub fn cube_map(pos: Vec3, dir: Normal3) -> TexCoord {
+pub fn cube_map(pos: Vec3, dir: Normal3<()>) -> TexCoord {
     // -1.0..1.0 -> 0.0..1.0
     let [x, y, z] = (0.5 * pos + splat(0.5))
         .clamp(&splat(0.0), &splat(1.0))

demos/src/bin/crates.rs

@@ -35,10 +35,10 @@ fn main() {
         },
     );
     let crate_shader = shader::new(
-        |v: Vertex3<(Normal3, TexCoord)>, mvp: &ProjMat3<_>| {
+        |v: Vertex3<(Normal3<_>, TexCoord)>, mvp: &ProjMat3<_>| {
             vertex(mvp.apply(&v.pos), v.attrib)
         },
-        |frag: Frag<(Normal3, TexCoord)>| {
+        |frag: Frag<(Normal3<_>, TexCoord)>| {
             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);
@@ -136,7 +136,7 @@ fn main() {
     .expect("should run");
 }
 
-fn crates() -> Vec<Obj<(Normal3, TexCoord)>> {
+fn crates() -> Vec<Obj<(Normal3<Model>, TexCoord)>> {
     let obj = Obj::new(Cube { side_len: 2.0 }.build());
 
     let mut res = vec![];

demos/src/bin/solids.rs

@@ -4,10 +4,11 @@ use minifb::{Key, KeyRepeat};
 
 use re::prelude::*;
 
-use re::core::geom::Polyline;
-use re::core::math::{ProjMat3, ProjVec3, color::gray};
-use re::core::render::cam::Fov;
-
+use re::core::{
+    geom::Polyline,
+    math::{ProjMat3, ProjVec3, color::gray},
+    render::cam::{Fov, Transform},
+};
 use re::front::{Frame, minifb::Window};
 use re::geom::{io::parse_obj, solids::*};
 
@@ -61,15 +62,17 @@ fn main() {
         .perspective(Fov::Equiv35mm(28.0), 0.1..1000.0)
         .viewport(pt2(10, h - 10)..pt2(w - 10, 10));
 
-    type VertexIn = Vertex3<Normal3>;
+    type VertexIn = Vertex3<Normal3<Model>>;
     type VertexOut = Vertex<ProjVec3, Color3f>;
-    type Uniform<'a> = (&'a ProjMat3<Model>, &'a Mat4);
 
-    fn vtx_shader(v: VertexIn, (mvp, spin): Uniform) -> VertexOut {
+    type NormalMat = Mat3<Model, View, 3>;
+    type Uniform<'a> = (&'a ProjMat3<Model>, &'a NormalMat);
+
+    fn vtx_shader(v: VertexIn, (mvp, n): Uniform) -> VertexOut {
         // Transform vertex normal
-        let norm = spin.apply(&v.attrib.to());
+        let norm = n.apply(&v.attrib);
         // Calculate diffuse shading
-        let diffuse = (norm.z() + 0.2).max(0.2) * 0.8;
+        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);
@@ -106,12 +109,17 @@ fn main() {
             .to::<ModelToWorld>()
             .then(&cam.world_to_project());
 
+        let normal: NormalMat = spin
+            .to()
+            .linear()
+            .then(&cam.transform.world_to_view().linear());
+
         let object = &objects[carousel.idx % objects.len()];
 
         Batch {
             prims: object.faces.clone(),
             verts: object.verts.clone(),
-            uniform: (&model_view_project, &spin),
+            uniform: (&model_view_project, &normal),
             shader: shader,
             viewport: cam.viewport,
             target: frame.buf,
@@ -125,7 +133,7 @@ fn main() {
 
 // Creates the 14 objects exhibited.
 #[rustfmt::skip]
-fn objects_n(res: u32) -> [Mesh<Normal3>; 14] {
+fn objects_n(res: u32) -> [Mesh<Normal3<Model>>; 14] {
     let segments = res;
     let sectors = 2 * res;
 
@@ -158,7 +166,7 @@ fn objects_n(res: u32) -> [Mesh<Normal3>; 14] {
 }
 
 // Creates a Lathe mesh.
-fn lathe(secs: u32) -> Mesh<Normal3> {
+fn lathe(secs: u32) -> Mesh<Normal3<Model>> {
     let pts = [
         (pt2(0.75, -0.5), vec2(1.0, 1.0)),
         (pt2(0.55, -0.25), vec2(1.0, 0.5)),
@@ -174,7 +182,7 @@ fn lathe(secs: u32) -> Mesh<Normal3> {
 }
 
 // Loads the Utah teapot model.
-fn teapot() -> Mesh<Normal3> {
+fn teapot() -> Mesh<Normal3<Model>> {
     parse_obj(*include_bytes!("../../assets/teapot.obj"))
         .unwrap()
         .transform(
@@ -187,7 +195,7 @@ fn teapot() -> Mesh<Normal3> {
 }
 
 // Loads the Stanford bunny model.
-fn bunny() -> Mesh<Normal3> {
+fn bunny() -> Mesh<Normal3<Model>> {
     parse_obj::<()>(*include_bytes!("../../assets/bunny.obj"))
         .unwrap()
         .transform(&scale(splat(0.12)).then(&translate(-Vec3::Y)).to())
@@ -196,7 +204,7 @@ fn bunny() -> Mesh<Normal3> {
 }
 
 // Loads the Stanford dragon model.
-fn dragon() -> Mesh<Normal3> {
+fn dragon() -> Mesh<Normal3<Model>> {
     static DRAGON: &[u8] = include_bytes!("../../assets/dragon.obj");
     parse_obj::<()>(DRAGON.iter().copied())
         .unwrap()

geom/src/io.rs

@@ -79,7 +79,7 @@ pub enum Error {
 pub struct Obj {
     faces: Vec<Tri<Indices>>,
     coords: Vec<Point3<Model>>,
-    norms: Vec<Normal3>,
+    norms: Vec<Normal3<Model>>,
     texcs: Vec<TexCoord>,
 }
 
@@ -235,7 +235,7 @@ impl TryFrom<Obj> for Builder<()> {
         o.try_into_with(|_| Some(()))
     }
 }
-impl TryFrom<Obj> for Builder<Normal3> {
+impl TryFrom<Obj> for Builder<Normal3<Model>> {
     type Error = Error;
 
     fn try_from(o: Obj) -> Result<Self> {
@@ -255,7 +255,7 @@ impl TryFrom<Obj> for Builder<TexCoord> {
         o.try_into_with(|i| i.uv.map(|ti| o.texcs[ti]))
     }
 }
-impl TryFrom<Obj> for Builder<(Normal3, TexCoord)> {
+impl TryFrom<Obj> for Builder<(Normal3<Model>, TexCoord)> {
     type Error = Error;
 
     fn try_from(o: Obj) -> Result<Self> {
@@ -335,7 +335,9 @@ fn parse_vector<'a>(
     Ok(vec3(x, y, z))
 }
 
-fn parse_normal<'a>(i: &mut impl Iterator<Item = &'a str>) -> Result<Normal3> {
+fn parse_normal<'a>(
+    i: &mut impl Iterator<Item = &'a str>,
+) -> Result<Normal3<Model>> {
     Ok(parse_vector(i)?.to())
 }
 
@@ -506,7 +508,7 @@ v 0.0 -2.0 0.0
             v 1.0 2.0 3.0
             vn 0.0 0.0 -1.0";
 
-        let m: Mesh<Normal3> = parse_obj(input).unwrap().build();
+        let m: Mesh<Normal3<_>> = parse_obj(input).unwrap().build();
 
         assert_eq!(m.faces.len(), 2);
         assert_eq!(m.verts.len(), 5);
@@ -585,7 +587,7 @@ v 0.0 -2.0 0.0
             vt 0.0 -1.0
             vn 0.0 0.0 1.0";
 
-        let m = &parse_obj::<(Normal3, TexCoord)>(input)
+        let m = &parse_obj::<(Normal3<_>, TexCoord)>(input)
             .unwrap()
             .build();
         assert_eq!(m.faces.len(), 2);

geom/src/solids.rs

@@ -13,6 +13,7 @@ use retrofire_core::math::{Lerp, Vec3};
 pub use lathe::*;
 
 pub use platonic::*;
+use retrofire_core::render::Model;
 
 pub trait Build<A>: Sized {
     fn build(self) -> Mesh<A>;
@@ -24,8 +25,8 @@ pub trait Build<A>: Sized {
 
 pub struct Icosphere(pub f32, pub u8);
 
-impl Build<Normal3> for Icosphere {
-    fn build(self) -> Mesh<Normal3> {
+impl Build<Normal3<Model>> for Icosphere {
+    fn build(self) -> Mesh<Normal3<Model>> {
         #[derive(Default)]
         struct Tessellator {
             coords: Vec<Vec3>,
@@ -70,7 +71,7 @@ impl Build<Normal3> for Icosphere {
         }
 
         let verts = recurser.coords.iter().map(|&p| {
-            vertex((p.normalize() * self.0).to().to_pt(), p.normalize())
+            vertex((p.normalize() * self.0).to().to_pt(), p.normalize().to())
         });
 
         Mesh::new(recurser.faces, verts)

geom/src/solids/lathe.rs

@@ -11,7 +11,7 @@ use retrofire_core::math::{
     Angle, Lerp, Parametric, Point3, Vary, Vec3, polar, pt2, pt3, rotate2,
     turns, vec2, vec3,
 };
-use retrofire_core::render::{TexCoord, uv};
+use retrofire_core::render::{Model, TexCoord, uv};
 
 use super::Build;
 
@@ -96,7 +96,7 @@ impl<P: Parametric<Vertex2<Normal2, ()>>> Lathe<P> {
     /// Builds the lathe mesh.
     pub fn build_with<A, F>(self, mut f: F) -> Mesh<A>
     where
-        F: FnMut(Point3, Normal3, TexCoord) -> Vertex3<A>,
+        F: FnMut(Point3, Normal3<Model>, TexCoord) -> Vertex3<A>,
     {
         let secs = self.sectors as usize;
         let segs = self.segments as usize;
@@ -155,7 +155,7 @@ fn create_faces(secs: usize, verts_per_sec: usize, out: &mut Vec<Tri<usize>>) {
 
 #[inline(never)]
 fn create_verts<A>(
-    f: &mut dyn FnMut(Point3, Normal3, TexCoord) -> Vertex3<A>,
+    f: &mut dyn FnMut(Point3, Normal3<Model>, TexCoord) -> Vertex3<A>,
     pts: &dyn Parametric<Vertex2<Normal2, ()>>,
     secs: usize,
     verts_per_sec: usize,
@@ -188,9 +188,9 @@ fn create_verts<A>(
 
 fn make_cap<A>(
     m: &mut Mesh<A>,
-    f: &mut dyn FnMut(Point3, Normal3, TexCoord) -> Vertex3<A>,
+    f: &mut dyn FnMut(Point3, Normal3<Model>, TexCoord) -> Vertex3<A>,
     rg: Range<usize>,
-    n: Normal3,
+    n: Normal3<Model>,
 ) {
     let verts = &mut m.verts;
     let secs = rg.len();
@@ -214,8 +214,8 @@ fn make_cap<A>(
 // Local trait impls
 //
 
-impl<P: Parametric<Vertex2<Normal2, ()>>> Build<Normal3> for Lathe<P> {
-    fn build(self) -> Mesh<Normal3> {
+impl<P: Parametric<Vertex2<Normal2, ()>>> Build<Normal3<Model>> for Lathe<P> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.build_with(|p, n, _| vertex(p.to(), n))
     }
 }
@@ -224,10 +224,10 @@ impl<P: Parametric<Vertex2<Normal2, ()>>> Build<TexCoord> for Lathe<P> {
         self.build_with(|p, _, tc| vertex(p.to(), tc))
     }
 }
-impl<P: Parametric<Vertex2<Normal2, ()>>> Build<(Normal3, TexCoord)>
+impl<P: Parametric<Vertex2<Normal2, ()>>> Build<(Normal3<Model>, TexCoord)>
     for Lathe<P>
 {
-    fn build(self) -> Mesh<(Normal3, TexCoord)> {
+    fn build(self) -> Mesh<(Normal3<Model>, TexCoord)> {
         self.build_with(|p, n, tc| vertex(p.to(), (n, tc)))
     }
 }
@@ -244,9 +244,9 @@ impl Sphere {
     }
 }
 
-impl Build<Normal3> for Sphere {
+impl Build<Normal3<Model>> for Sphere {
     /// Builds a spherical mesh with normals.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.lathe().build()
     }
 }
@@ -267,9 +267,9 @@ impl Torus {
         Lathe::new(pts, self.major_sectors, self.minor_sectors)
     }
 }
-impl Build<Normal3> for Torus {
+impl Build<Normal3<Model>> for Torus {
     /// Builds the toroidal mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.lathe().build()
     }
 }
@@ -280,9 +280,9 @@ impl Build<TexCoord> for Torus {
     }
 }
 
-impl Build<Normal3> for Cylinder {
+impl Build<Normal3<Model>> for Cylinder {
     /// Builds the cylindrical mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         #[rustfmt::skip]
         let Self { sectors, segments, capped, radius } = self;
         Cone {
@@ -326,9 +326,9 @@ impl Cone {
         Lathe::new(pts, self.sectors, self.segments).capped(self.capped)
     }
 }
-impl Build<Normal3> for Cone {
+impl Build<Normal3<Model>> for Cone {
     /// Builds the conical mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.lathe().build()
     }
 }
@@ -377,9 +377,9 @@ impl Capsule {
     }
 }
 
-impl Build<Normal3> for Capsule {
+impl Build<Normal3<Model>> for Capsule {
     /// Builds the capsule mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.lathe().build()
     }
 }
@@ -394,7 +394,7 @@ impl Build<TexCoord> for Capsule {
 mod tests {
     use super::*;
 
-    type Mesh = super::Mesh<Normal3>;
+    type Mesh = super::Mesh<Normal3<Model>>;
 
     #[test]
     fn sphere_verts_faces() {