fixed perspective calculations

8 files changed, 382 insertions, 323 deletions

diff --git a/src/o3d/deriv_vertex.cpp b/src/o3d/deriv_vertex.cpp
new file mode 100644
index 0000000..dcb2bff
--- /dev/null
+++ b/src/o3d/deriv_vertex.cpp
@@ -0,0 +1,11 @@
+#include "o3d/deriv_vertex.h"
+#include "math/vector.h"
+
+using namespace engine::o3d;
+
+DerivedVertex4::DerivedVertex4(engine::math::Vector4 point, float b0, float b1) : point{point}, b0{b0}, b1{b1} {
+}
+
+DerivedVertex4 DerivedVertex4::div_by_w() const {
+    return {point.div_by_w(), b0, b1};
+}
diff --git a/src/o3d/deriv_vertex.h b/src/o3d/deriv_vertex.h
new file mode 100644
index 0000000..8945696
--- /dev/null
+++ b/src/o3d/deriv_vertex.h
@@ -0,0 +1,19 @@
+#ifndef O3D_DERIV_VERTEX_H
+#define O3D_DERIV_VERTEX_H
+
+#include "math/vector.h"
+
+namespace engine::o3d {
+
+class DerivedVertex4 {
+    public:
+        engine::math::Vector4 point;
+        float b0, b1;
+
+        DerivedVertex4(engine::math::Vector4 point, float b0, float b1);
+        DerivedVertex4 div_by_w() const;
+};
+
+}
+
+#endif // O3D_DERIV_VERTEX_H
diff --git a/src/o3d/tri_deriv_vertex.cpp b/src/o3d/tri_deriv_vertex.cpp
new file mode 100644
index 0000000..3605b51
--- /dev/null
+++ b/src/o3d/tri_deriv_vertex.cpp
@@ -0,0 +1,321 @@
+#include "o3d/tri_deriv_vertex.h"
+#include <vector>
+#include "math/vector.h"
+#include "o3d/deriv_vertex.h"
+
+using namespace engine::o3d;
+
+TriangleDerivedVertex4::TriangleDerivedVertex4(DerivedVertex4 derived_vertex1, DerivedVertex4 derived_vertex2, DerivedVertex4 derived_vertex3)
+    : derived_vertex1{derived_vertex1}, derived_vertex2{derived_vertex2}, derived_vertex3{derived_vertex3} {
+}
+
+#define P1_OUT 1
+#define P2_OUT 2
+#define P3_OUT 4
+static void _perspective_crop_x(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVertex4 t, int n, float x) {
+    switch (n) {
+    case 0:
+        tris.push_back(t);
+        break;
+    case P1_OUT:
+    case P2_OUT:
+    case P3_OUT:
+    case P2_OUT | P3_OUT:
+    case P1_OUT | P3_OUT:
+    case P1_OUT | P2_OUT:
+        {
+            DerivedVertex4* q1;
+            DerivedVertex4* q2;
+            DerivedVertex4* q3;
+            switch (n) {
+            case P1_OUT:
+            case P2_OUT | P3_OUT:
+                q1 = &t.derived_vertex1;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex3;
+                break;
+            case P2_OUT:
+            case P1_OUT | P3_OUT:
+                q1 = &t.derived_vertex2;
+                q2 = &t.derived_vertex1;
+                q3 = &t.derived_vertex3;
+                break;
+            case P3_OUT:
+            case P1_OUT | P2_OUT:
+                q1 = &t.derived_vertex3;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex1;
+                break;
+            }
+            engine::math::Vector4 dq2 = q1->point - q2->point;
+            float fac2 = (x - q2->point.x) / dq2.x;
+            float r2w = 1.f / (fac2 / q1->point.w + (1.f - fac2) / q2->point.w);
+            float fac2_b = r2w * fac2 / q1->point.w;
+            DerivedVertex4 r2{
+                {
+                    x,
+                    q2->point.y + fac2 * dq2.y,
+                    fac2_b * q1->point.z + (1.f - fac2_b) * q2->point.z,
+                    r2w
+                },
+                fac2_b * q1->b0 + (1.f - fac2_b) * q2->b0,
+                fac2_b * q1->b1 + (1.f - fac2_b) * q2->b1
+            };
+            engine::math::Vector4 dq3 = q1->point - q3->point;
+            float fac3 = (x - q3->point.x) / dq3.x;
+            float r3w = 1.f / (fac3 / q1->point.w + (1.f - fac3) / q3->point.w);
+            float fac3_b = r3w * fac3 / q1->point.w;
+            DerivedVertex4 r3{
+                {
+                    x,
+                    q3->point.y + fac3 * dq3.y,
+                    fac3_b * q1->point.z + (1.f - fac3_b) * q3->point.z,
+                    r3w
+                },
+                fac3_b * q1->b0 + (1.f - fac3_b) * q3->b0,
+                fac3_b * q1->b1 + (1.f - fac3_b) * q3->b1
+            };
+            switch (n) {
+            case P1_OUT:
+                tris.push_back({r3, *q2, *q3});
+                tris.push_back({r3, r2, *q2});
+                break;
+            case P2_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P3_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P2_OUT | P3_OUT:
+                tris.push_back({*q1, r2, r3});
+                break;
+            case P1_OUT | P3_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            case P1_OUT | P2_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            }
+        }
+        break;
+    case P1_OUT | P2_OUT | P3_OUT:
+        break;
+    }
+}
+
+static void _perspective_crop_y(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVertex4 t, int n, float y) {
+    switch (n) {
+    case 0:
+        tris.push_back(t);
+        break;
+    case P1_OUT:
+    case P2_OUT:
+    case P3_OUT:
+    case P2_OUT | P3_OUT:
+    case P1_OUT | P3_OUT:
+    case P1_OUT | P2_OUT:
+        {
+            DerivedVertex4* q1;
+            DerivedVertex4* q2;
+            DerivedVertex4* q3;
+            switch (n) {
+            case P1_OUT:
+            case P2_OUT | P3_OUT:
+                q1 = &t.derived_vertex1;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex3;
+                break;
+            case P2_OUT:
+            case P1_OUT | P3_OUT:
+                q1 = &t.derived_vertex2;
+                q2 = &t.derived_vertex1;
+                q3 = &t.derived_vertex3;
+                break;
+            case P3_OUT:
+            case P1_OUT | P2_OUT:
+                q1 = &t.derived_vertex3;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex1;
+                break;
+            }
+            engine::math::Vector4 dq2 = q1->point - q2->point;
+            float fac2 = (y - q2->point.y) / dq2.y;
+            float r2w = 1.f / (fac2 / q1->point.w + (1.f - fac2) / q2->point.w);
+            float fac2_b = r2w * fac2 / q1->point.w;
+            DerivedVertex4 r2{
+                {
+                    q2->point.x + fac2 * dq2.x,
+                    y,
+                    fac2_b * q1->point.z + (1.f - fac2_b) * q2->point.z,
+                    r2w
+                },
+                fac2_b * q1->b0 + (1.f - fac2_b) * q2->b0,
+                fac2_b * q1->b1 + (1.f - fac2_b) * q2->b1
+            };
+            engine::math::Vector4 dq3 = q1->point - q3->point;
+            float fac3 = (y - q3->point.y) / dq3.y;
+            float r3w = 1.f / (fac3 / q1->point.w + (1.f - fac3) / q3->point.w);
+            float fac3_b = r3w * fac3 / q1->point.w;
+            DerivedVertex4 r3{
+                {
+                    q3->point.x + fac3 * dq3.x,
+                    y,
+                    fac3_b * q1->point.z + (1.f - fac3_b) * q3->point.z,
+                    r3w
+                },
+                fac3_b * q1->b0 + (1.f - fac3_b) * q3->b0,
+                fac3_b * q1->b1 + (1.f - fac3_b) * q3->b1
+            };
+            switch (n) {
+            case P1_OUT:
+                tris.push_back({r3, *q2, *q3});
+                tris.push_back({r3, r2, *q2});
+                break;
+            case P2_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P3_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P2_OUT | P3_OUT:
+                tris.push_back({*q1, r2, r3});
+                break;
+            case P1_OUT | P3_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            case P1_OUT | P2_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            }
+        }
+        break;
+    case P1_OUT | P2_OUT | P3_OUT:
+        break;
+    }
+}
+
+std::vector<TriangleDerivedVertex4> TriangleDerivedVertex4::perspective_crop_xy_out(float x1, float x2, float y1, float y2) const {
+    std::vector<TriangleDerivedVertex4> tris_final;
+    std::vector<TriangleDerivedVertex4> tris1;
+    _perspective_crop_x(tris1, *this, (derived_vertex1.point.x < x1) | ((derived_vertex2.point.x < x1) << 1) | ((derived_vertex3.point.x < x1) << 2), x1);
+    for (auto t1 : tris1) {
+        std::vector<TriangleDerivedVertex4> tris2;
+        _perspective_crop_x(tris2, t1, (t1.derived_vertex1.point.x > x2) | ((t1.derived_vertex2.point.x > x2) << 1) | ((t1.derived_vertex3.point.x > x2) << 2), x2);
+        for (auto t2 : tris2) {
+            std::vector<TriangleDerivedVertex4> tris3;
+            _perspective_crop_y(tris3, t2, (t2.derived_vertex1.point.y < y1) | ((t2.derived_vertex2.point.y < y1) << 1) | ((t2.derived_vertex3.point.y < y1) << 2), y1);
+            for (auto t3 : tris3)
+                _perspective_crop_y(tris_final, t3, (t3.derived_vertex1.point.y > y2) | ((t3.derived_vertex2.point.y > y2) << 1) | ((t3.derived_vertex3.point.y > y2) << 2), y2);
+        }
+    }
+    return tris_final;
+}
+
+static void _crop_z(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVertex4 t, int n, float z) {
+    switch (n) {
+    case 0:
+        tris.push_back(t);
+        break;
+    case P1_OUT:
+    case P2_OUT:
+    case P3_OUT:
+    case P2_OUT | P3_OUT:
+    case P1_OUT | P3_OUT:
+    case P1_OUT | P2_OUT:
+        {
+            DerivedVertex4* q1;
+            DerivedVertex4* q2;
+            DerivedVertex4* q3;
+            switch (n) {
+            case P1_OUT:
+            case P2_OUT | P3_OUT:
+                q1 = &t.derived_vertex1;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex3;
+                break;
+            case P2_OUT:
+            case P1_OUT | P3_OUT:
+                q1 = &t.derived_vertex2;
+                q2 = &t.derived_vertex1;
+                q3 = &t.derived_vertex3;
+                break;
+            case P3_OUT:
+            case P1_OUT | P2_OUT:
+                q1 = &t.derived_vertex3;
+                q2 = &t.derived_vertex2;
+                q3 = &t.derived_vertex1;
+                break;
+            }
+            engine::math::Vector4 dq2 = q1->point - q2->point;
+            float fac2 = (z - q2->point.z) / dq2.z;
+            DerivedVertex4 r2{
+                {
+                    q2->point.x + fac2 * dq2.x,
+                    q2->point.y + fac2 * dq2.y,
+                    z,
+                    q2->point.w + fac2 * dq2.w
+                },
+                fac2 * q1->b0 + (1.f - fac2) * q2->b0,
+                fac2 * q1->b1 + (1.f - fac2) * q2->b1
+            };
+            engine::math::Vector4 dq3 = q1->point - q3->point;
+            float fac3 = (z - q3->point.z) / dq3.z;
+            DerivedVertex4 r3{
+                {
+                    q3->point.x + fac3 * dq3.x,
+                    q3->point.y + fac3 * dq3.y,
+                    z,
+                    q3->point.w + fac3 * dq3.w
+                },
+                fac3 * q1->b0 + (1.f - fac3) * q3->b0,
+                fac3 * q1->b1 + (1.f - fac3) * q3->b1
+            };
+            switch (n) {
+            case P1_OUT:
+                tris.push_back({r3, *q2, *q3});
+                tris.push_back({r3, r2, *q2});
+                break;
+            case P2_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P3_OUT:
+                tris.push_back({r2, *q3, *q2});
+                tris.push_back({r2, r3, *q3});
+                break;
+            case P2_OUT | P3_OUT:
+                tris.push_back({*q1, r2, r3});
+                break;
+            case P1_OUT | P3_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            case P1_OUT | P2_OUT:
+                tris.push_back({*q1, r3, r2});
+                break;
+            }
+        }
+        break;
+    case P1_OUT | P2_OUT | P3_OUT:
+        break;
+    }
+}
+
+std::vector<TriangleDerivedVertex4> TriangleDerivedVertex4::crop_z_out(float z1, float z2) const {
+    std::vector<TriangleDerivedVertex4> tris;
+    _crop_z(tris, *this, (derived_vertex1.point.z < z1) | ((derived_vertex2.point.z < z1) << 1) | ((derived_vertex3.point.z < z1) << 2), z1);
+    std::vector<TriangleDerivedVertex4> tris2;
+    for (auto t : tris)
+        _crop_z(tris2, t, (t.derived_vertex1.point.z > z2) | ((t.derived_vertex2.point.z > z2) << 1) | ((t.derived_vertex3.point.z > z2) << 2), z2);
+    return tris2;
+}
+#undef P1_OUT
+#undef P2_OUT
+#undef P3_OUT
+
+TriangleDerivedVertex4 TriangleDerivedVertex4::div_by_w() const {
+    return {derived_vertex1.div_by_w(), derived_vertex2.div_by_w(), derived_vertex3.div_by_w()};
+}
diff --git a/src/o3d/tri_deriv_vertex.h b/src/o3d/tri_deriv_vertex.h
new file mode 100644
index 0000000..41ed4dc
--- /dev/null
+++ b/src/o3d/tri_deriv_vertex.h
@@ -0,0 +1,24 @@
+#ifndef O3D_TRI_DERIV_VERTEX_H
+#define O3D_TRI_DERIV_VERTEX_H
+
+#include <vector>
+#include "o3d/vertex.h"
+#include "o3d/deriv_vertex.h"
+
+namespace engine::o3d {
+
+class TriangleDerivedVertex4 {
+    public:
+        DerivedVertex4 derived_vertex1;
+        DerivedVertex4 derived_vertex2;
+        DerivedVertex4 derived_vertex3;
+
+        TriangleDerivedVertex4(DerivedVertex4 derived_vertex1, DerivedVertex4 derived_vertex2, DerivedVertex4 derived_vertex3);
+        std::vector<TriangleDerivedVertex4> perspective_crop_xy_out(float x1, float x2, float y1, float y2) const;
+        std::vector<TriangleDerivedVertex4> crop_z_out(float z1, float z2) const;
+        TriangleDerivedVertex4 div_by_w() const;
+};
+
+}
+
+#endif // O3D_TRI_DERIV_VERTEX_H
diff --git a/src/o3d/tri_vertex.cpp b/src/o3d/tri_vertex.cpp
index bda219a..08f5e7e 100644
--- a/src/o3d/tri_vertex.cpp
+++ b/src/o3d/tri_vertex.cpp
@@ -2,315 +2,15 @@
 #include <vector>
 #include "math/vector.h"
 #include "o3d/vertex_data.h"
+#include "o3d/deriv_vertex.h"
 #include "o3d/vertex.h"
-#include "o3d/tri_vertex.h"
+#include "o3d/tri_deriv_vertex.h"
 
 using namespace engine::o3d;
 
-TriangleVertex3::TriangleVertex3(Vertex3 vertex1, Vertex3 vertex2, Vertex3 vertex3) : vertex1{vertex1}, vertex2{vertex2}, vertex3{vertex3} {
-}
-
-#define P1_OUT 1
-#define P2_OUT 2
-#define P3_OUT 4
-static void _crop_x(std::vector<TriangleVertex3>& tris, TriangleVertex3 t, int n, float x) {
-    switch (n) {
-    case 0:
-        tris.push_back(t);
-        break;
-    case P1_OUT:
-    case P2_OUT:
-    case P3_OUT:
-    case P2_OUT | P3_OUT:
-    case P1_OUT | P3_OUT:
-    case P1_OUT | P2_OUT:
-        {
-            Vertex3* q1;
-            Vertex3* q2;
-            Vertex3* q3;
-            switch (n) {
-            case P1_OUT:
-            case P2_OUT | P3_OUT:
-                q1 = &t.vertex1;
-                q2 = &t.vertex2;
-                q3 = &t.vertex3;
-                break;
-            case P2_OUT:
-            case P1_OUT | P3_OUT:
-                q1 = &t.vertex2;
-                q2 = &t.vertex1;
-                q3 = &t.vertex3;
-                break;
-            case P3_OUT:
-            case P1_OUT | P2_OUT:
-                q1 = &t.vertex3;
-                q2 = &t.vertex2;
-                q3 = &t.vertex1;
-                break;
-            }
-            engine::math::Vector3 dq2 = q1->point - q2->point;
-            float fac2 = (x - q2->point.x) / dq2.x;
-            Vertex3 r2{
-                {
-                    x,
-                    q2->point.y + fac2 * dq2.y,
-                    q2->point.z + fac2 * dq2.z
-                },
-                VertexData::lerp(q2->data, q1->data, fac2)
-            };
-            engine::math::Vector3 dq3 = q1->point - q3->point;
-            float fac3 = (x - q3->point.x) / dq3.x;
-            Vertex3 r3{
-                {
-                    x,
-                    q3->point.y + fac3 * dq3.y,
-                    q3->point.z + fac3 * dq3.z
-                },
-                VertexData::lerp(q3->data, q1->data, fac3)
-            };
-            switch (n) {
-            case P1_OUT:
-                tris.push_back({r3, *q2, *q3});
-                tris.push_back({r3, r2, *q2});
-                break;
-            case P2_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P3_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P2_OUT | P3_OUT:
-                tris.push_back({*q1, r2, r3});
-                break;
-            case P1_OUT | P3_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            case P1_OUT | P2_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            }
-        }
-        break;
-    case P1_OUT | P2_OUT | P3_OUT:
-        break;
-    }
-}
-
-static void _crop_y(std::vector<TriangleVertex3>& tris, TriangleVertex3 t, int n, float y) {
-    switch (n) {
-    case 0:
-        tris.push_back(t);
-        break;
-    case P1_OUT:
-    case P2_OUT:
-    case P3_OUT:
-    case P2_OUT | P3_OUT:
-    case P1_OUT | P3_OUT:
-    case P1_OUT | P2_OUT:
-        {
-            Vertex3* q1;
-            Vertex3* q2;
-            Vertex3* q3;
-            switch (n) {
-            case P1_OUT:
-            case P2_OUT | P3_OUT:
-                q1 = &t.vertex1;
-                q2 = &t.vertex2;
-                q3 = &t.vertex3;
-                break;
-            case P2_OUT:
-            case P1_OUT | P3_OUT:
-                q1 = &t.vertex2;
-                q2 = &t.vertex1;
-                q3 = &t.vertex3;
-                break;
-            case P3_OUT:
-            case P1_OUT | P2_OUT:
-                q1 = &t.vertex3;
-                q2 = &t.vertex2;
-                q3 = &t.vertex1;
-                break;
-            }
-            engine::math::Vector3 dq2 = q1->point - q2->point;
-            float fac2 = (y - q2->point.y) / dq2.y;
-            Vertex3 r2{
-                {
-                    q2->point.x + fac2 * dq2.x,
-                    y,
-                    q2->point.z + fac2 * dq2.z
-                },
-                VertexData::lerp(q2->data, q1->data, fac2)
-            };
-            engine::math::Vector3 dq3 = q1->point - q3->point;
-            float fac3 = (y - q3->point.y) / dq3.y;
-            Vertex3 r3{
-                {
-                    q3->point.x + fac3 * dq3.x,
-                    y,
-                    q3->point.z + fac3 * dq3.z
-                },
-                VertexData::lerp(q3->data, q1->data, fac3)
-            };
-            switch (n) {
-            case P1_OUT:
-                tris.push_back({r3, *q2, *q3});
-                tris.push_back({r3, r2, *q2});
-                break;
-            case P2_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P3_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P2_OUT | P3_OUT:
-                tris.push_back({*q1, r2, r3});
-                break;
-            case P1_OUT | P3_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            case P1_OUT | P2_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            }
-        }
-        break;
-    case P1_OUT | P2_OUT | P3_OUT:
-        break;
-    }
-}
-
-std::vector<TriangleVertex3> TriangleVertex3::crop_xy_out(float x1, float x2, float y1, float y2) const {
-    std::vector<TriangleVertex3> tris_final;
-    std::vector<TriangleVertex3> tris1;
-    _crop_x(tris1, *this, (vertex1.point.x < x1) | ((vertex2.point.x < x1) << 1) | ((vertex3.point.x < x1) << 2), x1);
-    for (auto t1 : tris1) {
-        std::vector<TriangleVertex3> tris2;
-        _crop_x(tris2, t1, (t1.vertex1.point.x > x2) | ((t1.vertex2.point.x > x2) << 1) | ((t1.vertex3.point.x > x2) << 2), x2);
-        for (auto t2 : tris2) {
-            std::vector<TriangleVertex3> tris3;
-            _crop_y(tris3, t2, (t2.vertex1.point.y < y1) | ((t2.vertex2.point.y < y1) << 1) | ((t2.vertex3.point.y < y1) << 2), y1);
-            for (auto t3 : tris3)
-                _crop_y(tris_final, t3, (t3.vertex1.point.y > y2) | ((t3.vertex2.point.y > y2) << 1) | ((t3.vertex3.point.y > y2) << 2), y2);
-        }
-    }
-    return tris_final;
-}
-#undef P1_OUT
-#undef P2_OUT
-#undef P3_OUT
-
 TriangleVertex4::TriangleVertex4(Vertex4 vertex1, Vertex4 vertex2, Vertex4 vertex3) : vertex1{vertex1}, vertex2{vertex2}, vertex3{vertex3} {
 }
 
-TriangleVertex4::TriangleVertex4(TriangleVertex3 triangle) : vertex1{triangle.vertex1}, vertex2{triangle.vertex2}, vertex3{triangle.vertex3} {
-}
-
-#define P1_OUT 1
-#define P2_OUT 2
-#define P3_OUT 4
-static void _crop_z(std::vector<TriangleVertex4>& tris, TriangleVertex4 t, int n, float z) {
-    switch (n) {
-    case 0:
-        tris.push_back(t);
-        break;
-    case P1_OUT:
-    case P2_OUT:
-    case P3_OUT:
-    case P2_OUT | P3_OUT:
-    case P1_OUT | P3_OUT:
-    case P1_OUT | P2_OUT:
-        {
-            Vertex4* q1;
-            Vertex4* q2;
-            Vertex4* q3;
-            switch (n) {
-            case P1_OUT:
-            case P2_OUT | P3_OUT:
-                q1 = &t.vertex1;
-                q2 = &t.vertex2;
-                q3 = &t.vertex3;
-                break;
-            case P2_OUT:
-            case P1_OUT | P3_OUT:
-                q1 = &t.vertex2;
-                q2 = &t.vertex1;
-                q3 = &t.vertex3;
-                break;
-            case P3_OUT:
-            case P1_OUT | P2_OUT:
-                q1 = &t.vertex3;
-                q2 = &t.vertex2;
-                q3 = &t.vertex1;
-                break;
-            }
-            engine::math::Vector4 dq2 = q1->point - q2->point;
-            float fac2 = (z - q2->point.z) / dq2.z;
-            Vertex4 r2{
-                {
-                    q2->point.x + fac2 * dq2.x,
-                    q2->point.y + fac2 * dq2.y,
-                    z,
-                    q2->point.w + fac2 * dq2.w
-                },
-                VertexData::lerp(q2->data, q1->data, fac2)
-            };
-            engine::math::Vector4 dq3 = q1->point - q3->point;
-            float fac3 = (z - q3->point.z) / dq3.z;
-            Vertex4 r3{
-                {
-                    q3->point.x + fac3 * dq3.x,
-                    q3->point.y + fac3 * dq3.y,
-                    z,
-                    q3->point.w + fac3 * dq3.w
-                },
-                VertexData::lerp(q3->data, q1->data, fac3)
-            };
-            switch (n) {
-            case P1_OUT:
-                tris.push_back({r3, *q2, *q3});
-                tris.push_back({r3, r2, *q2});
-                break;
-            case P2_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P3_OUT:
-                tris.push_back({r2, *q3, *q2});
-                tris.push_back({r2, r3, *q3});
-                break;
-            case P2_OUT | P3_OUT:
-                tris.push_back({*q1, r2, r3});
-                break;
-            case P1_OUT | P3_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            case P1_OUT | P2_OUT:
-                tris.push_back({*q1, r3, r2});
-                break;
-            }
-        }
-        break;
-    case P1_OUT | P2_OUT | P3_OUT:
-        break;
-    }
-}
-
-std::vector<TriangleVertex4> TriangleVertex4::crop_z_out(float z1, float z2) const {
-    std::vector<TriangleVertex4> tris;
-    _crop_z(tris, *this, (vertex1.point.z < z1) | ((vertex2.point.z < z1) << 1) | ((vertex3.point.z < z1) << 2), z1);
-    std::vector<TriangleVertex4> tris2;
-    for (auto t : tris)
-        _crop_z(tris2, t, (t.vertex1.point.z > z2) | ((t.vertex2.point.z > z2) << 1) | ((t.vertex3.point.z > z2) << 2), z2);
-    return tris2;
-}
-#undef P1_OUT
-#undef P2_OUT
-#undef P3_OUT
-
-TriangleVertex3 TriangleVertex4::div_by_w() const {
-    return {vertex1.div_by_w(), vertex2.div_by_w(), vertex3.div_by_w()};
+TriangleDerivedVertex4 TriangleVertex4::to_derived() const {
+    return {{vertex1.point, 1.f, 0.f}, {vertex2.point, 0.f, 1.f}, {vertex3.point, 0.f, 0.f}};
 }
diff --git a/src/o3d/tri_vertex.h b/src/o3d/tri_vertex.h
index 368a5e0..715f649 100644
--- a/src/o3d/tri_vertex.h
+++ b/src/o3d/tri_vertex.h
@@ -1,21 +1,12 @@
 #ifndef O3D_TRI_VERTEX_H
 #define O3D_TRI_VERTEX_H
 
-#include "o3d/vertex.h"
 #include <vector>
+#include "o3d/vertex.h"
+#include "o3d/tri_deriv_vertex.h"
 
 namespace engine::o3d {
 
-class TriangleVertex3 {
-    public:
-        Vertex3 vertex1;
-        Vertex3 vertex2;
-        Vertex3 vertex3;
-
-        TriangleVertex3(Vertex3 vertex1, Vertex3 vertex2, Vertex3 vertex3);
-        std::vector<TriangleVertex3> crop_xy_out(float x1, float x2, float y1, float y2) const;
-};
-
 class TriangleVertex4 {
     public:
         Vertex4 vertex1;
@@ -23,9 +14,7 @@ class TriangleVertex4 {
         Vertex4 vertex3;
 
         TriangleVertex4(Vertex4 vertex1, Vertex4 vertex2, Vertex4 vertex3);
-        TriangleVertex4(TriangleVertex3 triangle);
-        std::vector<TriangleVertex4> crop_z_out(float z1, float z2) const;
-        TriangleVertex3 div_by_w() const;
+        TriangleDerivedVertex4 to_derived() const;
 };
 
 }
diff --git a/src/o3d/vertex.cpp b/src/o3d/vertex.cpp
index 641eef4..ec9c05f 100644
--- a/src/o3d/vertex.cpp
+++ b/src/o3d/vertex.cpp
@@ -12,7 +12,3 @@ Vertex4::Vertex4(engine::math::Vector4 point, VertexData data) : point{point}, d
 
 Vertex4::Vertex4(Vertex3 vertex) : point{vertex.point}, data{vertex.data} {
 }
-
-Vertex3 Vertex4::div_by_w() const {
-    return {point.div_by_w(), data};
-}
diff --git a/src/o3d/vertex.h b/src/o3d/vertex.h
index 022fdf7..b0dd195 100644
--- a/src/o3d/vertex.h
+++ b/src/o3d/vertex.h
@@ -21,7 +21,6 @@ class Vertex4 {
 
         Vertex4(engine::math::Vector4 point, VertexData data);
         Vertex4(Vertex3 vertex);
-        Vertex3 div_by_w() const;
 };
 
 }