Correct Proj4 to Proj3

The correct name for a projective space over R^4 is P_3(R).

Author: jdahlstrom

core/src/math/mat.rs

@@ -16,8 +16,8 @@ use crate::render::{NdcToScreen, ViewToProj};
 use super::{
     float::f32,
     point::{Point2, Point2u, Point3},
-    space::{Linear, Proj4, Real},
-    vec::{ProjVec4, Vec2, Vec3, Vector},
+    space::{Linear, Proj3, Real},
+    vec::{ProjVec3, Vec2, Vec3, Vector},
 };
 
 /// A linear transform from one space (or basis) to another.
@@ -401,7 +401,7 @@ impl<Src> Mat4x4<RealToProj<Src>> {
     ///         \ ·  ·  M33 / \  1 /     \ v3' /
     /// ```
     #[must_use]
-    pub fn apply(&self, p: &Point3<Src>) -> ProjVec4 {
+    pub fn apply(&self, p: &Point3<Src>) -> ProjVec3 {
         let v = Vector::new([p.x(), p.y(), p.z(), 1.0]);
         from_fn(|i| self.row_vec(i).dot(&v)).into()
     }
@@ -424,7 +424,7 @@ impl<const DIM: usize, S, I, D> Compose<RealToReal<DIM, S, I>>
 
 impl<S> LinearMap for RealToProj<S> {
     type Source = Real<3, S>;
-    type Dest = Proj4;
+    type Dest = Proj3;
 }
 
 impl<S, I> Compose<RealToReal<3, S, I>> for RealToProj<I> {

core/src/math/space.rs

@@ -74,12 +74,12 @@ pub trait Linear: Affine<Diff = Self> {
 #[derive(Copy, Clone, Default, Eq, PartialEq)]
 pub struct Real<const DIM: usize, Basis = ()>(PhantomData<Basis>);
 
-/// Tag type for the projective 4-space over reals, 𝗣<sub>4</sub>(ℝ).
+/// Tag type for the projective 3-space over the reals, 𝗣<sub>3</sub>(ℝ).
 ///
 /// The properties of this space make it useful for implementing perspective
 /// projection. Clipping is also done in the projective space.
 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub struct Proj4;
+pub struct Proj3;
 
 impl Affine for f32 {
     type Space = ();

core/src/math/vec.rs

@@ -14,7 +14,7 @@ use core::{
 use crate::math::{
     Affine, ApproxEq, Linear, Point,
     float::f32,
-    space::{Proj4, Real},
+    space::{Proj3, Real},
     vary::ZDiv,
 };
 
@@ -42,7 +42,7 @@ pub type Vec2<Basis = ()> = Vector<[f32; 2], Real<2, Basis>>;
 /// A 3-vector with `f32` components.
 pub type Vec3<Basis = ()> = Vector<[f32; 3], Real<3, Basis>>;
 /// A `f32` 4-vector in the projective 3-space over ℝ, aka P<sub>3</sub>(ℝ).
-pub type ProjVec4 = Vector<[f32; 4], Proj4>;
+pub type ProjVec3 = Vector<[f32; 4], Proj3>;
 
 /// A 2-vector with `i32` components.
 pub type Vec2i<Basis = ()> = Vector<[i32; 2], Real<2, Basis>>;
@@ -366,7 +366,7 @@ impl<B> Vec3<B> {
     pub const Z: Self = vec3(0.0, 0.0, 1.0);
 }
 
-impl<R, Sc> Vector<R, Proj4>
+impl<R, Sc> Vector<R, Proj3>
 where
     R: Index<usize, Output = Sc>,
     Sc: Copy,

core/src/render.rs

@@ -12,7 +12,7 @@ use crate::geom::Vertex;
 use crate::math::{
     Lerp, Mat4x4, Vary,
     mat::{RealToProj, RealToReal},
-    vec::ProjVec4,
+    vec::ProjVec3,
 };
 
 use {
@@ -116,11 +116,11 @@ pub type NdcToScreen = RealToReal<3, Ndc, Screen>;
 
 /// Alias for combined vertex+fragment shader types
 pub trait Shader<Vtx, Var, Uni>:
-    VertexShader<Vtx, Uni, Output = Vertex<ProjVec4, Var>> + FragmentShader<Var>
+    VertexShader<Vtx, Uni, Output = Vertex<ProjVec3, Var>> + FragmentShader<Var>
 {
 }
 impl<S, Vtx, Var, Uni> Shader<Vtx, Var, Uni> for S where
-    S: VertexShader<Vtx, Uni, Output = Vertex<ProjVec4, Var>>
+    S: VertexShader<Vtx, Uni, Output = Vertex<ProjVec3, Var>>
         + FragmentShader<Var>
 {
 }

core/src/render/clip.rs

@@ -19,7 +19,7 @@ use core::iter::zip;
 use view_frustum::{outcode, status};
 
 use crate::geom::{Tri, Vertex, vertex};
-use crate::math::{Lerp, vec::ProjVec4};
+use crate::math::{Lerp, vec::ProjVec3};
 
 /// Trait for types that can be [clipped][self] against planes.
 ///
@@ -50,7 +50,7 @@ pub trait Clip {
 }
 
 /// A vector in clip space.
-pub type ClipVec = ProjVec4;
+pub type ClipVec = ProjVec3;
 
 /// A vertex in clip space.
 #[derive(Copy, Clone, Debug, PartialEq)]

core/src/render/shader.rs

@@ -16,7 +16,7 @@
 
 use crate::{
     geom::Vertex,
-    math::{Color4, vec::ProjVec4},
+    math::{Color4, vec::ProjVec3},
 };
 
 use super::raster::Frag;
@@ -77,7 +77,7 @@ where
 
 pub fn new<Vs, Fs, Vtx, Var, Uni>(vs: Vs, fs: Fs) -> Shader<Vs, Fs>
 where
-    Vs: VertexShader<Vtx, Uni, Output = Vertex<ProjVec4, Var>>,
+    Vs: VertexShader<Vtx, Uni, Output = Vertex<ProjVec3, Var>>,
     Fs: FragmentShader<Var>,
 {
     Shader::new(vs, fs)

demos/src/bin/solids.rs

@@ -6,7 +6,7 @@ use re::prelude::*;
 
 use re::geom::Polyline;
 use re::math::{
-    color::gray, mat::RealToReal, pt2, smootherstep, vec::ProjVec4,
+    color::gray, mat::RealToReal, pt2, smootherstep, vec::ProjVec3,
 };
 use re::render::{
     Batch, Camera, ModelToProj, ModelToWorld, cam::Fov, raster::Frag,
@@ -66,7 +66,7 @@ fn main() {
         .viewport(pt2(10, 10)..pt2(w - 10, h - 10));
 
     type VertexIn = Vertex3<Normal3>;
-    type VertexOut = Vertex<ProjVec4, Color3f>;
+    type VertexOut = Vertex<ProjVec3, Color3f>;
     type Uniform<'a> = (&'a Mat4x4<ModelToProj>, &'a Mat4x4<RealToReal<3>>);
 
     fn vtx_shader(v: VertexIn, (mvp, spin): Uniform) -> VertexOut {