Initial commit

Torque/SDK/engine/collision/polyhedron.cc

@@ -0,0 +1,150 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+
+#include "platform/platform.h"
+#include "dgl/dgl.h"
+#include "console/console.h"
+#include "collision/polyhedron.h"
+
+
+//----------------------------------------------------------------------------
+
+void Polyhedron::buildBox(const MatrixF& transform,const Box3F& box)
+{
+   // Box is assumed to be axis aligned in the source space.
+   // Transform into geometry space
+   Point3F xvec,yvec,zvec,min;
+   transform.getColumn(0,&xvec);
+   xvec *= box.len_x();
+   transform.getColumn(1,&yvec);
+   yvec *= box.len_y();
+   transform.getColumn(2,&zvec);
+   zvec *= box.len_z();
+   transform.mulP(box.min,&min);
+
+   // Initial vertices
+   pointList.setSize(8);
+   pointList[0] = min;
+   pointList[1] = min + yvec;
+   pointList[2] = min + xvec + yvec;
+   pointList[3] = min + xvec;
+   pointList[4] = pointList[0] + zvec;
+   pointList[5] = pointList[1] + zvec;
+   pointList[6] = pointList[2] + zvec;
+   pointList[7] = pointList[3] + zvec;
+
+   // Initial faces
+   planeList.setSize(6);
+   planeList[0].set(pointList[0],xvec);
+   planeList[0].invert();
+   planeList[1].set(pointList[2],yvec);
+   planeList[2].set(pointList[2],xvec);
+   planeList[3].set(pointList[0],yvec);
+   planeList[3].invert();
+   planeList[4].set(pointList[0],zvec);
+   planeList[4].invert();
+   planeList[5].set(pointList[4],zvec);
+
+   // The edges are constructed so that the vertices
+   // are oriented clockwise for face[0]
+   edgeList.setSize(12);
+   Edge* edge = edgeList.begin();
+   S32 nextEdge = 0;
+   for (int i = 0; i < 4; i++) {
+      S32 n = (i == 3)? 0: i + 1;
+      S32 p = (i == 0)? 3: i - 1;
+      edge->vertex[0] = i;
+      edge->vertex[1] = n;
+      edge->face[0] = i;
+      edge->face[1] = 4;
+      edge++;
+      edge->vertex[0] = 4 + i;
+      edge->vertex[1] = 4 + n;
+      edge->face[0] = 5;
+      edge->face[1] = i;
+      edge++;
+      edge->vertex[0] = i;
+      edge->vertex[1] = 4 + i;
+      edge->face[0] = p;
+      edge->face[1] = i;
+      edge++;
+   }
+}
+
+
+//----------------------------------------------------------------------------
+
+void Polyhedron::render()
+{
+   glVertexPointer(3,GL_FLOAT,sizeof(Point3F),pointList.address());
+   glEnableClientState(GL_VERTEX_ARRAY);
+   glColor3f(1, 0, 1);
+
+   for (S32 e = 0; e < edgeList.size(); e++)
+      glDrawElements(GL_LINES,2,GL_UNSIGNED_INT,&edgeList[e].vertex);
+
+   for (U32 i = 0; i < planeList.size(); i++) {
+      Point3F origin(0, 0, 0);
+      U32 num = 0;
+      for (U32 j = 0; j < edgeList.size(); j++) {
+         if (edgeList[j].face[0] == i || edgeList[j].face[1] == i) {
+            origin += pointList[edgeList[j].vertex[0]];
+            origin += pointList[edgeList[j].vertex[1]];
+            num += 2;
+         }
+      }
+      origin /= F32(num);
+
+      glColor3f(1, 1, 1);
+      glBegin(GL_LINES);
+         glVertex3fv(origin);
+         glVertex3f(origin.x + planeList[i].x * 0.2,
+                    origin.y + planeList[i].y * 0.2,
+                    origin.z + planeList[i].z * 0.2);
+      glEnd();
+   }
+
+   glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void Polyhedron::render(const VectorF& vec,F32 time)
+{
+   bool faceVisible[50];
+   for (int f = 0; f < planeList.size(); f++)
+      faceVisible[f] = mDot(planeList[f],vec) > 0;
+
+   VectorF tvec = vec;
+   tvec *= time;
+   for (int e = 0; e < edgeList.size(); e++) {
+      Polyhedron::Edge const& edge = edgeList[e];
+      if (faceVisible[edge.face[0]] || faceVisible[edge.face[1]]) {
+         Point3F pp;
+
+         glBegin(GL_LINE_LOOP);
+         glColor3f(0.5,0.5,0.5);
+         const Point3F& p1 = pointList[edge.vertex[0]];
+         const Point3F& p2 = pointList[edge.vertex[1]];
+         glVertex3fv(p1);
+         glVertex3fv(p2);
+         pp = p2 + vec;
+         glVertex3fv(pp);
+         pp = p1 + vec;
+         glVertex3fv(pp);
+         glEnd();
+
+         if (time <= 1.0) {
+            glBegin(GL_LINES);
+            glColor3f(0.5,0.5,0);
+            pp = pointList[edge.vertex[0]];
+            pp += tvec;
+            glVertex3fv(pp);
+            pp = pointList[edge.vertex[1]];
+            pp += tvec;
+            glVertex3fv(pp);
+            glEnd();
+         }
+      }
+   }
+}