diff --git a/core/src/geom/mesh.rs b/core/src/geom/mesh.rs
index f04a50cb..a4fc1d72 100644
--- a/core/src/geom/mesh.rs
+++ b/core/src/geom/mesh.rs
@@ -202,7 +202,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...
@@ -210,7 +210,7 @@ impl<A> Builder<A> {
             // TODO If n-gonal faces are supported some day, the cross
             //      product is not proportional to area anymore
             let [a, b, c] = tri.map(|i| verts[i].pos).0;
-            (b - a).cross(&(c - a)).to()
+            (b - a).cross(&(c - a))
         });
         // ...initialize vertex normals to zero...
         let mut verts: Vec<_> = verts
diff --git a/core/src/geom/prim.rs b/core/src/geom/prim.rs
index 623dff04..ed8395f6 100644
--- a/core/src/geom/prim.rs
+++ b/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;
 
@@ -248,10 +249,9 @@ impl<A, B> Tri<Vertex3<A, B>> {
     /// ]);
     /// assert_approx_eq!(tri.normal(), vec3(0.0, FRAC_1_SQRT_2, -FRAC_1_SQRT_2));
     /// ```
-    pub fn normal(&self) -> Normal3 {
+    pub fn normal(&self) -> Normal3<B> {
         let [t, u] = self.tangents();
-        // TODO add basis parameter to normals
-        t.cross(&u).normalize_or_zero().to()
+        t.cross(&u).normalize_or_zero()
     }
 
     /// Returns the plane that `self` lies on.
@@ -372,7 +372,7 @@ impl<B> Plane3<B> {
     ///
     /// ```
     pub fn from_points(a: Point3<B>, b: Point3<B>, c: Point3<B>) -> Self {
-        let n = (b - a).cross(&(c - a)).to();
+        let n = (b - a).cross(&(c - a));
         Self::from_point_and_normal(a, n)
     }
 
@@ -392,10 +392,9 @@ 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 = dot(&pt.0, &n.0);
-        Plane::new(n.x(), n.y(), n.z(), d)
+        Plane::new(n.x(), n.y(), n.z(), dot(&pt.0, &n.0))
     }
 
     /// Returns the normal vector of `self`.
@@ -409,7 +408,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> {
         let [a, b, c, _] = self.0.0;
         let n = vec3(a, b, c);
         debug_assert!(n.len_sqr().approx_eq(&1.0));
diff --git a/core/src/render/debug.rs b/core/src/render/debug.rs
index b1b6646a..36b40bc4 100644
--- a/core/src/render/debug.rs
+++ b/core/src/render/debug.rs
@@ -90,7 +90,7 @@ pub fn ray<'a, B>(o: Point3<B>, dir: Vec3<B>) -> DbgBatch<B> {
 pub fn face_normal<A, B: Debug + Default>(
     tri: Tri<Vertex3<A, B>>,
 ) -> DbgBatch<B> {
-    ray(tri.centroid(), tri.normal().to())
+    ray(tri.centroid(), tri.normal())
 }
 
 /// Draws a visualization of an affine basis.
diff --git a/core/src/render/tex.rs b/core/src/render/tex.rs
index 5a95c203..f341b3dd 100644
--- a/core/src/render/tex.rs
+++ b/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))
diff --git a/demos/src/bin/crates.rs b/demos/src/bin/crates.rs
index 555659b3..71d92c25 100644
--- a/demos/src/bin/crates.rs
+++ b/demos/src/bin/crates.rs
@@ -36,10 +36,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);
@@ -137,7 +137,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![];
diff --git a/demos/src/bin/curses.rs b/demos/src/bin/curses.rs
index 05112783..e2b1df16 100644
--- a/demos/src/bin/curses.rs
+++ b/demos/src/bin/curses.rs
@@ -50,7 +50,7 @@ fn main() {
         |v: Vertex3<_>, mvp: &ProjMat3<Model>| {
             vertex(mvp.apply(&v.pos), v.attrib)
         },
-        |frag: Frag<Normal3>| {
+        |frag: Frag<Normal3<Model>>| {
             let [x, y, z] = (frag.var / 2.0 + splat(0.5)).0;
             rgb(x, y, z).to_color4()
         },
diff --git a/demos/src/bin/solids.rs b/demos/src/bin/solids.rs
index 59d63504..c640f51c 100644
--- a/demos/src/bin/solids.rs
+++ b/demos/src/bin/solids.rs
@@ -7,8 +7,8 @@ use re::prelude::*;
 use re::core::{
     geom::Polyline,
     math::{ProjMat3, ProjVec3, color::gray},
-    render::cam::Fov,
-    render::{Model, ModelToWorld, shader},
+    render::cam::{Fov, Transform},
+    render::{Model, ModelToWorld, View, shader},
 };
 use re::front::{Frame, minifb::Window};
 use re::geom::{io::read_obj, solids::*};
@@ -63,15 +63,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);
+        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);
@@ -108,12 +110,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,
@@ -127,7 +134,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;
 
@@ -160,7 +167,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)),
@@ -176,10 +183,10 @@ fn lathe(secs: u32) -> Mesh<Normal3> {
 }
 
 // Loads the Utah teapot model.
-fn teapot() -> Mesh<Normal3> {
+fn teapot() -> Mesh<Normal3<Model>> {
     static TEAPOT: &[u8] = include_bytes!("../../assets/teapot.obj");
     read_obj(TEAPOT)
-        .unwrap()
+        .expect("valid .obj, included in binary")
         .transform(
             &scale(splat(0.4))
                 .then(&translate(-0.5 * Vec3::Y))
@@ -189,20 +196,20 @@ fn teapot() -> Mesh<Normal3> {
 }
 
 // Loads the Stanford bunny model.
-fn bunny() -> Mesh<Normal3> {
+fn bunny() -> Mesh<Normal3<Model>> {
     static BUNNY: &[u8] = include_bytes!("../../assets/bunny.obj");
     read_obj::<()>(BUNNY)
-        .unwrap()
+        .expect("valid .obj, included in binary")
         .transform(&scale(splat(0.12)).then(&translate(-Vec3::Y)).to())
         .with_vertex_normals()
         .build()
 }
 
 // Loads the Stanford dragon model.
-fn dragon() -> Mesh<Normal3> {
+fn dragon() -> Mesh<Normal3<Model>> {
     static DRAGON: &[u8] = include_bytes!("../../assets/dragon.obj");
     read_obj::<()>(DRAGON)
-        .unwrap()
+        .expect("valid .obj, included in binary")
         .with_vertex_normals()
         .transform(
             &scale(splat(0.18))
diff --git a/geom/src/io.rs b/geom/src/io.rs
index 885f9e6d..1c1a287d 100644
--- a/geom/src/io.rs
+++ b/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,8 +335,10 @@ fn parse_vector<'a>(
     Ok(vec3(x, y, z))
 }
 
-fn parse_normal<'a>(i: &mut impl Iterator<Item = &'a str>) -> Result<Normal3> {
-    Ok(parse_vector(i)?.to())
+fn parse_normal<'a>(
+    i: &mut impl Iterator<Item = &'a str>,
+) -> Result<Normal3<Model>> {
+    Ok(parse_vector(i)?)
 }
 
 fn parse_point<'a>(
@@ -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);
diff --git a/geom/src/solids.rs b/geom/src/solids.rs
index 52c311bd..f39abdf4 100644
--- a/geom/src/solids.rs
+++ b/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)
diff --git a/geom/src/solids/lathe.rs b/geom/src/solids/lathe.rs
index 534488c5..b508cd57 100644
--- a/geom/src/solids/lathe.rs
+++ b/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;
 
@@ -97,7 +97,7 @@ impl<P: Parametric<Vertex2<Normal2, ()>>> Lathe<P> {
     #[inline(never)]
     pub fn build_with<A>(
         self,
-        f: &mut dyn FnMut(Point3, Normal3, TexCoord) -> Vertex3<A>,
+        f: &mut dyn FnMut(Point3, Normal3<Model>, TexCoord) -> Vertex3<A>,
     ) -> Mesh<A> {
         let secs = self.sectors as usize;
         let segs = self.segments as usize;
@@ -158,7 +158,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,
@@ -192,9 +192,9 @@ fn create_verts<A>(
 #[inline(never)]
 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();
@@ -218,8 +218,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(&mut |p, n, _| vertex(p.to(), n))
     }
 }
@@ -228,10 +228,10 @@ impl<P: Parametric<Vertex2<Normal2, ()>>> Build<TexCoord> for Lathe<P> {
         self.build_with(&mut |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(&mut |p, n, tc| vertex(p.to(), (n, tc)))
     }
 }
@@ -248,9 +248,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()
     }
 }
@@ -271,9 +271,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()
     }
 }
@@ -284,9 +284,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 {
@@ -330,9 +330,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()
     }
 }
@@ -381,9 +381,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()
     }
 }
@@ -398,7 +398,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() {
diff --git a/geom/src/solids/platonic.rs b/geom/src/solids/platonic.rs
index dda3279e..48648238 100644
--- a/geom/src/solids/platonic.rs
+++ b/geom/src/solids/platonic.rs
@@ -115,13 +115,13 @@ impl Tetrahedron {
     ];
 
     /// Builds the tetrahedral mesh.
-    pub fn build(self) -> Mesh<Normal3> {
+    pub fn build(self) -> Mesh<Normal3<Model>> {
         let mut b = Mesh::builder();
         for (vs, i) in zip(Self::FACES, 0..) {
             b.push_face(i * 3, i * 3 + 1, i * 3 + 2);
             let n = -Self::NORMS[i]; // already unit length
             for v in vs {
-                b.push_vert(Self::COORDS[v].to_pt(), n);
+                b.push_vert(Self::COORDS[v].to_pt(), n.to());
             }
         }
         b.build()
@@ -141,7 +141,7 @@ impl Box {
         vec3(1.0, 1.0, 0.0), // 0b110
         vec3(1.0, 1.0, 1.0), // 0b111
     ];
-    const NORMS: [Normal3; 6] = [
+    const NORMS: [Normal3<Model>; 6] = [
         vec3(-1.0, 0.0, 0.0),
         vec3(1.0, 0.0, 0.0),
         vec3(0.0, -1.0, 0.0),
@@ -190,7 +190,7 @@ impl Box {
     /// Builds the cuboid mesh.
     pub fn build_with<A>(
         self,
-        mut f: impl FnMut(Point3<Model>, Normal3, TexCoord) -> Vertex3<A>,
+        mut f: impl FnMut(Point3<Model>, Normal3<Model>, TexCoord) -> Vertex3<A>,
     ) -> Mesh<A> {
         let mut b = Mesh::builder();
         b.push_faces(Self::FACES);
@@ -209,8 +209,8 @@ impl Box {
     }
 }
 
-impl Build<Normal3> for Box {
-    fn build(self) -> Mesh<Normal3> {
+impl Build<Normal3<Model>> for Box {
+    fn build(self) -> Mesh<Normal3<Model>> {
         self.build_with(|p, n, _| vertex(p, n))
     }
 }
@@ -219,8 +219,8 @@ impl Build<TexCoord> for Box {
         self.build_with(|p, _, uv| vertex(p, uv))
     }
 }
-impl Build<(Normal3, TexCoord)> for Box {
-    fn build(self) -> Mesh<(Normal3, TexCoord)> {
+impl Build<(Normal3<Model>, TexCoord)> for Box {
+    fn build(self) -> Mesh<(Normal3<Model>, TexCoord)> {
         self.build_with(|p, n, uv| vertex(p, (n, uv)))
     }
 }
@@ -251,7 +251,7 @@ impl Octahedron {
         pt3(0.0, 0.0, 1.0),
         pt3(1.0, 0.0, 0.0),
     ];
-    const NORMS: [Normal3; 8] = [
+    const NORMS: [Normal3<()>; 8] = [
         vec3(-1.0, -1.0, -1.0),
         vec3(-1.0, 1.0, -1.0),
         vec3(-1.0, 1.0, 1.0),
@@ -284,16 +284,16 @@ impl Octahedron {
     ];
 }
 
-impl Build<Normal3> for Octahedron {
+impl Build<Normal3<Model>> for Octahedron {
     /// Builds the octahedral mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         let mut b = Mesh::builder();
         for (vs, i) in zip(&Self::FACES, 0..) {
             b.push_face(i * 3, i * 3 + 1, i * 3 + 2);
             for &vi in vs {
                 let pos = Self::COORDS[Self::VERTS[vi].0];
                 let n = Self::NORMS[i].normalize();
-                b.push_vert(pos, n);
+                b.push_vert(pos, n.to());
             }
         }
         b.build()
@@ -346,9 +346,9 @@ impl Dodecahedron {
     const NORMALS: [Vec3; 12] = Icosahedron::COORDS;
 }
 
-impl Build<Normal3> for Dodecahedron {
+impl Build<Normal3<Model>> for Dodecahedron {
     /// Builds the dodecahedral mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         let mut b = Mesh::builder();
 
         for (face, i) in zip(&Self::FACES, 0..) {
@@ -360,7 +360,7 @@ impl Build<Normal3> for Dodecahedron {
             b.push_face(i5, i5 + 3, i5 + 4);
             for &j in face {
                 let pos = Self::COORDS[j].normalize().to_pt();
-                b.push_vert(pos, n);
+                b.push_vert(pos, n.to());
             }
         }
         b.build()
@@ -399,16 +399,16 @@ impl Icosahedron {
     const NORMALS: [Vec3; 20] = Dodecahedron::COORDS;
 }
 
-impl Build<Normal3> for Icosahedron {
+impl Build<Normal3<Model>> for Icosahedron {
     /// Builds the icosahedral mesh.
-    fn build(self) -> Mesh<Normal3> {
+    fn build(self) -> Mesh<Normal3<Model>> {
         let mut b = Mesh::builder();
         for (vs, i) in zip(&Self::FACES, 0..) {
             let n = Self::NORMALS[i].normalize();
             b.push_face(i * 3, i * 3 + 1, i * 3 + 2);
             for &vi in vs {
                 let pos = Self::COORDS[vi].normalize().to_pt();
-                b.push_vert(pos, n);
+                b.push_vert(pos, n.to());
             }
         }
         b.build()