improved mesh definition

- In the context of mesh definition, splited
  indices into vertex index, normal index and
  vertex data index to be able to specify
  different normals and vertex data for
  different faces using the same vertex

1 files changed, 69 insertions, 69 deletions

diff --git a/src/o3d/tri_deriv.cpp b/src/o3d/tri_deriv.cpp
index 3605b51..81f60a0 100644
--- a/src/o3d/tri_deriv.cpp
+++ b/src/o3d/tri_deriv.cpp
@@ -1,18 +1,18 @@
-#include "o3d/tri_deriv_vertex.h"
+#include "o3d/tri_deriv.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)
+TriangleDerived::TriangleDerived(DerivedVertex derived_vertex1, DerivedVertex derived_vertex2, DerivedVertex 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) {
+static void _perspective_crop_x(std::vector<TriangleDerived>& tris, TriangleDerived t, int n, float x) {
     switch (n) {
     case 0:
         tris.push_back(t);
@@ -24,9 +24,9 @@ static void _perspective_crop_x(std::vector<TriangleDerivedVertex4>& tris, Trian
     case P1_OUT | P3_OUT:
     case P1_OUT | P2_OUT:
         {
-            DerivedVertex4* q1;
-            DerivedVertex4* q2;
-            DerivedVertex4* q3;
+            DerivedVertex* q1;
+            DerivedVertex* q2;
+            DerivedVertex* q3;
             switch (n) {
             case P1_OUT:
             case P2_OUT | P3_OUT:
@@ -47,29 +47,29 @@ static void _perspective_crop_x(std::vector<TriangleDerivedVertex4>& tris, Trian
                 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{
+            engine::math::Vector4 dq2 = q1->vertex - q2->vertex;
+            float fac2 = (x - q2->vertex.x) / dq2.x;
+            float r2w = 1.f / (fac2 / q1->vertex.w + (1.f - fac2) / q2->vertex.w);
+            float fac2_b = r2w * fac2 / q1->vertex.w;
+            DerivedVertex r2{
                 {
                     x,
-                    q2->point.y + fac2 * dq2.y,
-                    fac2_b * q1->point.z + (1.f - fac2_b) * q2->point.z,
+                    q2->vertex.y + fac2 * dq2.y,
+                    fac2_b * q1->vertex.z + (1.f - fac2_b) * q2->vertex.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{
+            engine::math::Vector4 dq3 = q1->vertex - q3->vertex;
+            float fac3 = (x - q3->vertex.x) / dq3.x;
+            float r3w = 1.f / (fac3 / q1->vertex.w + (1.f - fac3) / q3->vertex.w);
+            float fac3_b = r3w * fac3 / q1->vertex.w;
+            DerivedVertex r3{
                 {
                     x,
-                    q3->point.y + fac3 * dq3.y,
-                    fac3_b * q1->point.z + (1.f - fac3_b) * q3->point.z,
+                    q3->vertex.y + fac3 * dq3.y,
+                    fac3_b * q1->vertex.z + (1.f - fac3_b) * q3->vertex.z,
                     r3w
                 },
                 fac3_b * q1->b0 + (1.f - fac3_b) * q3->b0,
@@ -105,7 +105,7 @@ static void _perspective_crop_x(std::vector<TriangleDerivedVertex4>& tris, Trian
     }
 }
 
-static void _perspective_crop_y(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVertex4 t, int n, float y) {
+static void _perspective_crop_y(std::vector<TriangleDerived>& tris, TriangleDerived t, int n, float y) {
     switch (n) {
     case 0:
         tris.push_back(t);
@@ -117,9 +117,9 @@ static void _perspective_crop_y(std::vector<TriangleDerivedVertex4>& tris, Trian
     case P1_OUT | P3_OUT:
     case P1_OUT | P2_OUT:
         {
-            DerivedVertex4* q1;
-            DerivedVertex4* q2;
-            DerivedVertex4* q3;
+            DerivedVertex* q1;
+            DerivedVertex* q2;
+            DerivedVertex* q3;
             switch (n) {
             case P1_OUT:
             case P2_OUT | P3_OUT:
@@ -140,29 +140,29 @@ static void _perspective_crop_y(std::vector<TriangleDerivedVertex4>& tris, Trian
                 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{
+            engine::math::Vector4 dq2 = q1->vertex - q2->vertex;
+            float fac2 = (y - q2->vertex.y) / dq2.y;
+            float r2w = 1.f / (fac2 / q1->vertex.w + (1.f - fac2) / q2->vertex.w);
+            float fac2_b = r2w * fac2 / q1->vertex.w;
+            DerivedVertex r2{
                 {
-                    q2->point.x + fac2 * dq2.x,
+                    q2->vertex.x + fac2 * dq2.x,
                     y,
-                    fac2_b * q1->point.z + (1.f - fac2_b) * q2->point.z,
+                    fac2_b * q1->vertex.z + (1.f - fac2_b) * q2->vertex.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{
+            engine::math::Vector4 dq3 = q1->vertex - q3->vertex;
+            float fac3 = (y - q3->vertex.y) / dq3.y;
+            float r3w = 1.f / (fac3 / q1->vertex.w + (1.f - fac3) / q3->vertex.w);
+            float fac3_b = r3w * fac3 / q1->vertex.w;
+            DerivedVertex r3{
                 {
-                    q3->point.x + fac3 * dq3.x,
+                    q3->vertex.x + fac3 * dq3.x,
                     y,
-                    fac3_b * q1->point.z + (1.f - fac3_b) * q3->point.z,
+                    fac3_b * q1->vertex.z + (1.f - fac3_b) * q3->vertex.z,
                     r3w
                 },
                 fac3_b * q1->b0 + (1.f - fac3_b) * q3->b0,
@@ -198,24 +198,24 @@ static void _perspective_crop_y(std::vector<TriangleDerivedVertex4>& tris, Trian
     }
 }
 
-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);
+std::vector<TriangleDerived> TriangleDerived::perspective_crop_xy_out(float x1, float x2, float y1, float y2) const {
+    std::vector<TriangleDerived> tris_final;
+    std::vector<TriangleDerived> tris1;
+    _perspective_crop_x(tris1, *this, (derived_vertex1.vertex.x < x1) | ((derived_vertex2.vertex.x < x1) << 1) | ((derived_vertex3.vertex.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);
+        std::vector<TriangleDerived> tris2;
+        _perspective_crop_x(tris2, t1, (t1.derived_vertex1.vertex.x > x2) | ((t1.derived_vertex2.vertex.x > x2) << 1) | ((t1.derived_vertex3.vertex.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);
+            std::vector<TriangleDerived> tris3;
+            _perspective_crop_y(tris3, t2, (t2.derived_vertex1.vertex.y < y1) | ((t2.derived_vertex2.vertex.y < y1) << 1) | ((t2.derived_vertex3.vertex.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);
+                _perspective_crop_y(tris_final, t3, (t3.derived_vertex1.vertex.y > y2) | ((t3.derived_vertex2.vertex.y > y2) << 1) | ((t3.derived_vertex3.vertex.y > y2) << 2), y2);
         }
     }
     return tris_final;
 }
 
-static void _crop_z(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVertex4 t, int n, float z) {
+static void _crop_z(std::vector<TriangleDerived>& tris, TriangleDerived t, int n, float z) {
     switch (n) {
     case 0:
         tris.push_back(t);
@@ -227,9 +227,9 @@ static void _crop_z(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVe
     case P1_OUT | P3_OUT:
     case P1_OUT | P2_OUT:
         {
-            DerivedVertex4* q1;
-            DerivedVertex4* q2;
-            DerivedVertex4* q3;
+            DerivedVertex* q1;
+            DerivedVertex* q2;
+            DerivedVertex* q3;
             switch (n) {
             case P1_OUT:
             case P2_OUT | P3_OUT:
@@ -250,26 +250,26 @@ static void _crop_z(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVe
                 q3 = &t.derived_vertex1;
                 break;
             }
-            engine::math::Vector4 dq2 = q1->point - q2->point;
-            float fac2 = (z - q2->point.z) / dq2.z;
-            DerivedVertex4 r2{
+            engine::math::Vector4 dq2 = q1->vertex - q2->vertex;
+            float fac2 = (z - q2->vertex.z) / dq2.z;
+            DerivedVertex r2{
                 {
-                    q2->point.x + fac2 * dq2.x,
-                    q2->point.y + fac2 * dq2.y,
+                    q2->vertex.x + fac2 * dq2.x,
+                    q2->vertex.y + fac2 * dq2.y,
                     z,
-                    q2->point.w + fac2 * dq2.w
+                    q2->vertex.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{
+            engine::math::Vector4 dq3 = q1->vertex - q3->vertex;
+            float fac3 = (z - q3->vertex.z) / dq3.z;
+            DerivedVertex r3{
                 {
-                    q3->point.x + fac3 * dq3.x,
-                    q3->point.y + fac3 * dq3.y,
+                    q3->vertex.x + fac3 * dq3.x,
+                    q3->vertex.y + fac3 * dq3.y,
                     z,
-                    q3->point.w + fac3 * dq3.w
+                    q3->vertex.w + fac3 * dq3.w
                 },
                 fac3 * q1->b0 + (1.f - fac3) * q3->b0,
                 fac3 * q1->b1 + (1.f - fac3) * q3->b1
@@ -304,18 +304,18 @@ static void _crop_z(std::vector<TriangleDerivedVertex4>& tris, TriangleDerivedVe
     }
 }
 
-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;
+std::vector<TriangleDerived> TriangleDerived::crop_z_out(float z1, float z2) const {
+    std::vector<TriangleDerived> tris;
+    _crop_z(tris, *this, (derived_vertex1.vertex.z < z1) | ((derived_vertex2.vertex.z < z1) << 1) | ((derived_vertex3.vertex.z < z1) << 2), z1);
+    std::vector<TriangleDerived> 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);
+        _crop_z(tris2, t, (t.derived_vertex1.vertex.z > z2) | ((t.derived_vertex2.vertex.z > z2) << 1) | ((t.derived_vertex3.vertex.z > z2) << 2), z2);
     return tris2;
 }
 #undef P1_OUT
 #undef P2_OUT
 #undef P3_OUT
 
-TriangleDerivedVertex4 TriangleDerivedVertex4::div_by_w() const {
+TriangleDerived TriangleDerived::div_by_w() const {
     return {derived_vertex1.div_by_w(), derived_vertex2.div_by_w(), derived_vertex3.div_by_w()};
 }