Initial commit

Torque/SDK/engine/interior/forceField.cc

@@ -0,0 +1,469 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+
+#include "interior/forceField.h"
+#include "core/stream.h"
+#include "math/mathIO.h"
+#include "console/console.h"
+#include "dgl/gTexManager.h"
+#include "dgl/dgl.h"
+#include "collision/abstractPolyList.h"
+#include "sim/sceneObject.h"
+
+//--------------------------------------------------------------------------
+ForceField::ForceField()
+{
+   mPreppedForRender = false;
+   mWhite            = NULL;
+}
+
+ForceField::~ForceField()
+{
+   mPreppedForRender = false;
+
+   delete mWhite;
+   mWhite = NULL;
+}
+
+
+bool ForceField::prepForRendering()
+{
+   if (mPreppedForRender == true)
+      return true;
+
+   mPreppedForRender = true;
+   return true;
+}
+
+
+void ForceField::render(const ColorF& rColor, const F32 fade)
+{
+   // All our transform what not has already been specified...
+
+   glDisable(GL_TEXTURE_2D);
+   glEnable(GL_CULL_FACE);
+   glEnable(GL_BLEND);
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+   glVertexPointer(3, GL_FLOAT, sizeof(Point3F), mPoints.address());
+   glEnable(GL_VERTEX_ARRAY);
+
+   for (U32 i = 0; i < mSurfaces.size(); i++) {
+      Surface& rSurface = mSurfaces[i];
+
+      glColor4f(rColor.red, rColor.green, rColor.blue, fade);
+      glBegin(GL_TRIANGLE_STRIP);
+      for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++)
+         glArrayElement(mWindings[j]);
+      glEnd();
+   }
+
+   glDisable(GL_VERTEX_ARRAY);
+   glDisable(GL_CULL_FACE);
+}
+
+
+//--------------------------------------------------------------------------
+//-------------------------------------- Persistence interfaces
+//
+const U32 ForceField::smFileVersion = 0;
+
+bool ForceField::read(Stream& stream)
+{
+   AssertFatal(stream.hasCapability(Stream::StreamRead), "ForceField::read: non-read capable stream passed");
+   AssertFatal(stream.getStatus() == Stream::Ok, "ForceField::read: Error, stream in inconsistent state");
+
+   U32 i;
+
+   // Version this stream
+   U32 fileVersion;
+   stream.read(&fileVersion);
+   if (fileVersion != smFileVersion) {
+      Con::errorf(ConsoleLogEntry::General, "ForceField::read: incompatible file version found.");
+      return false;
+   }
+
+   mName = stream.readSTString();
+   U32 numTriggers;
+   stream.read(&numTriggers);
+   mTriggers.setSize(numTriggers);
+   for (i = 0; i < mTriggers.size(); i++)
+      mTriggers[i] = stream.readSTString();
+
+   // Geometry factors...
+   mathRead(stream, &mBoundingBox);
+   mathRead(stream, &mBoundingSphere);
+
+   // Now read in our data vectors.
+   U32 vectorSize;
+   // mPlanes
+   readPlaneVector(stream);
+
+   // mPoints
+   stream.read(&vectorSize);
+   mPoints.setSize(vectorSize);
+   for (i = 0; i < mPoints.size(); i++)
+      mathRead(stream, &mPoints[i]);
+
+   // mBSPNodes;
+   stream.read(&vectorSize);
+   mBSPNodes.setSize(vectorSize);
+   for (i = 0; i < mBSPNodes.size(); i++) {
+      stream.read(&mBSPNodes[i].planeIndex);
+      stream.read(&mBSPNodes[i].frontIndex);
+      stream.read(&mBSPNodes[i].backIndex);
+   }
+
+   // mBSPSolidLeaves
+   stream.read(&vectorSize);
+   mBSPSolidLeaves.setSize(vectorSize);
+   for (i = 0; i < mBSPSolidLeaves.size(); i++) {
+      stream.read(&mBSPSolidLeaves[i].surfaceIndex);
+      stream.read(&mBSPSolidLeaves[i].surfaceCount);
+   }
+
+   // mWindings
+   stream.read(&vectorSize);
+   mWindings.setSize(vectorSize);
+   for (i = 0; i < mWindings.size(); i++) {
+      stream.read(&mWindings[i]);
+   }
+
+   // mSurfaces
+   stream.read(&vectorSize);
+   mSurfaces.setSize(vectorSize);
+   for (i = 0; i < mSurfaces.size(); i++) {
+      stream.read(&mSurfaces[i].windingStart);
+      stream.read(&mSurfaces[i].windingCount);
+      stream.read(&mSurfaces[i].planeIndex);
+      stream.read(&mSurfaces[i].surfaceFlags);
+      stream.read(&mSurfaces[i].fanMask);
+   }
+
+   // mSolidLeafSurfaces
+   stream.read(&vectorSize);
+   mSolidLeafSurfaces.setSize(vectorSize);
+   for (i = 0; i < mSolidLeafSurfaces.size(); i++) {
+      stream.read(&mSolidLeafSurfaces[i]);
+   }
+
+   stream.read(&mColor);
+
+   return stream.getStatus() == Stream::Ok;
+}
+
+bool ForceField::write(Stream& stream) const
+{
+   AssertFatal(stream.hasCapability(Stream::StreamWrite), "Interior::write: non-write capable stream passed");
+   AssertFatal(stream.getStatus() == Stream::Ok, "Interior::write: Error, stream in inconsistent state");
+
+   U32 i;
+
+   // Version this stream
+   stream.write(smFileVersion);
+
+   stream.writeString(mName);
+   stream.write(mTriggers.size());
+   for (i = 0; i < mTriggers.size(); i++)
+      stream.writeString(mTriggers[i]);
+
+   mathWrite(stream, mBoundingBox);
+   mathWrite(stream, mBoundingSphere);
+
+   // Now write out our data vectors.  Remember, for cross-platform capability, no
+   //  structure writing is allowed...
+
+   // mPlanes
+   writePlaneVector(stream);
+
+   // mPoints
+   stream.write(mPoints.size());
+   for (i = 0; i < mPoints.size(); i++)
+      mathWrite(stream, mPoints[i]);
+
+   // mBSPNodes;
+   stream.write(mBSPNodes.size());
+   for (i = 0; i < mBSPNodes.size(); i++) {
+      stream.write(mBSPNodes[i].planeIndex);
+      stream.write(mBSPNodes[i].frontIndex);
+      stream.write(mBSPNodes[i].backIndex);
+   }
+
+   // mBSPSolidLeaves
+   stream.write(mBSPSolidLeaves.size());
+   for (i = 0; i < mBSPSolidLeaves.size(); i++) {
+      stream.write(mBSPSolidLeaves[i].surfaceIndex);
+      stream.write(mBSPSolidLeaves[i].surfaceCount);
+   }
+
+   // mWindings
+   stream.write(mWindings.size());
+   for (i = 0; i < mWindings.size(); i++) {
+      stream.write(mWindings[i]);
+   }
+
+   // mSurfaces
+   stream.write(mSurfaces.size());
+   for (i = 0; i < mSurfaces.size(); i++) {
+      stream.write(mSurfaces[i].windingStart);
+      stream.write(mSurfaces[i].windingCount);
+      stream.write(mSurfaces[i].planeIndex);
+      stream.write(mSurfaces[i].surfaceFlags);
+      stream.write(mSurfaces[i].fanMask);
+   }
+
+   // mSolidLeafSurfaces
+   stream.write(mSolidLeafSurfaces.size());
+   for (i = 0; i < mSolidLeafSurfaces.size(); i++) {
+      stream.write(mSolidLeafSurfaces[i]);
+   }
+
+   stream.write(mColor);
+
+   return stream.getStatus() == Stream::Ok;
+}
+
+bool ForceField::writePlaneVector(Stream& stream) const
+{
+   // This is pretty slow, but who cares?
+   //
+   Vector<Point3F> uniqueNormals(mPlanes.size());
+   Vector<U16>  uniqueIndices(mPlanes.size());
+
+   U32 i;
+
+   for (i = 0; i < mPlanes.size(); i++) {
+      bool inserted = false;
+      for (U32 j = 0; j < uniqueNormals.size(); j++) {
+         if (mPlanes[i] == uniqueNormals[j]) {
+            // Hah!  Already have this one...
+            uniqueIndices.push_back(j);
+            inserted = true;
+            break;
+         }
+      }
+
+      if (inserted == false) {
+         // Gotta do it ourselves...
+         uniqueIndices.push_back(uniqueNormals.size());
+         uniqueNormals.push_back(Point3F(mPlanes[i].x, mPlanes[i].y, mPlanes[i].z));
+      }
+   }
+
+   // Ok, what we have now, is a list of unique normals, a set of indices into
+   //  that vector, and the distances that we still have to write out by hand.
+   //  Hop to it!
+   stream.write(uniqueNormals.size());
+   for (i = 0; i < uniqueNormals.size(); i++)
+      mathWrite(stream, uniqueNormals[i]);
+
+   stream.write(mPlanes.size());
+   for (i = 0; i < mPlanes.size(); i++) {
+      stream.write(uniqueIndices[i]);
+      stream.write(mPlanes[i].d);
+   }
+
+   return (stream.getStatus() == Stream::Ok);
+}
+
+bool ForceField::readPlaneVector(Stream& stream)
+{
+   Vector<Point3F> normals;
+   U32 vectorSize;
+
+   stream.read(&vectorSize);
+   normals.setSize(vectorSize);
+   U32 i;
+   for (i = 0; i < normals.size(); i++)
+      mathRead(stream, &normals[i]);
+
+   U16 index;
+   stream.read(&vectorSize);
+   mPlanes.setSize(vectorSize);
+   for (i = 0; i < mPlanes.size(); i++) {
+      stream.read(&index);
+      stream.read(&mPlanes[i].d);
+      mPlanes[i].x = normals[index].x;
+      mPlanes[i].y = normals[index].y;
+      mPlanes[i].z = normals[index].z;
+   }
+
+   return (stream.getStatus() == Stream::Ok);
+}
+
+
+//--------------------------------------------------------------------------
+//-------------------------------------- Collision support.  Essentially
+//                                        copied from the interiorCollision
+//
+void ForceField::collisionFanFromSurface(const Surface& rSurface, U32* fanIndices, U32* numIndices) const
+{
+   U32 tempIndices[32];
+
+   tempIndices[0] = 0;
+   U32 idx = 1;
+   U32 i;
+   for (i = 1; i < rSurface.windingCount; i += 2)
+      tempIndices[idx++] = i;
+   for (i = ((rSurface.windingCount - 1) & (~0x1)); i > 0; i -= 2)
+      tempIndices[idx++] = i;
+
+   idx = 0;
+   for (i = 0; i < rSurface.windingCount; i++) {
+      if (rSurface.fanMask & (1 << i)) {
+         fanIndices[idx++] = mWindings[rSurface.windingStart + tempIndices[i]];
+      }
+   }
+   *numIndices = idx;
+}
+
+bool ForceField::castRay(const Point3F& s, const Point3F& e, RayInfo* info)
+{
+   bool hit = castRay_r(0, s, e, info);
+   if (hit) {
+      Point3F vec = e - s;
+      F32 len = vec.len();
+      vec /= len;
+      info->t = mDot(info->point - s, vec) / len;
+   }
+
+   return hit;
+}
+
+bool ForceField::castRay_r(const U16      node,
+                         const Point3F& s,
+                         const Point3F& e,
+                         RayInfo*       info)
+{
+   if (isBSPLeafIndex(node) == false) {
+      const IBSPNode& rNode = mBSPNodes[node];
+      const PlaneF& rPlane  = getPlane(rNode.planeIndex);
+
+      PlaneF::Side sSide = rPlane.whichSide(s);
+      PlaneF::Side eSide = rPlane.whichSide(e);
+
+      switch (PlaneSwitchCode(sSide, eSide)) {
+        case PlaneSwitchCode(PlaneF::Front, PlaneF::Front):
+        case PlaneSwitchCode(PlaneF::Front, PlaneF::On):
+        case PlaneSwitchCode(PlaneF::On,    PlaneF::Front):
+         return castRay_r(rNode.frontIndex, s, e, info);
+         break;
+
+        case PlaneSwitchCode(PlaneF::On,   PlaneF::Back):
+        case PlaneSwitchCode(PlaneF::Back, PlaneF::On):
+        case PlaneSwitchCode(PlaneF::Back, PlaneF::Back):
+         return castRay_r(rNode.backIndex, s, e, info);
+         break;
+
+        case PlaneSwitchCode(PlaneF::On, PlaneF::On):
+         // Line lies on the plane
+         if (isBSPLeafIndex(rNode.backIndex) == false) {
+            if (castRay_r(rNode.backIndex, s, e, info))
+               return true;
+         }
+         if (isBSPLeafIndex(rNode.frontIndex) == false) {
+            if (castRay_r(rNode.frontIndex, s, e, info))
+               return true;
+         }
+         return false;
+         break;
+
+        case PlaneSwitchCode(PlaneF::Front, PlaneF::Back): {
+            Point3F ip;
+            F32     intersectT = rPlane.intersect(s, e);
+            AssertFatal(intersectT != PARALLEL_PLANE, "Error, this should never happen in this case!");
+            ip.interpolate(s, e, intersectT);
+            if (castRay_r(rNode.frontIndex, s, ip, info))
+               return true;
+            return castRay_r(rNode.backIndex, ip, e, info);
+         }
+         break;
+
+        case PlaneSwitchCode(PlaneF::Back, PlaneF::Front): {
+            Point3F ip;
+            F32     intersectT = rPlane.intersect(s, e);
+            AssertFatal(intersectT != PARALLEL_PLANE, "Error, this should never happen in this case!");
+            ip.interpolate(s, e, intersectT);
+            if (castRay_r(rNode.backIndex, s, ip, info))
+               return true;
+            return castRay_r(rNode.frontIndex, ip, e, info);
+         }
+         break;
+
+        default:
+         AssertFatal(false, "Misunderstood switchCode in ForceField::castRay_r");
+         return false;
+      }
+   }
+
+   if (isBSPSolidLeaf(node)) {
+      // DMM: Set material info here
+      info->point = s;
+      return true;
+   }
+   return false;
+}
+
+void ForceField::buildPolyList_r(const U16 node, Vector<U16>& collPlanes, AbstractPolyList* list, SphereF& s)
+{
+   if (isBSPLeafIndex(node) == false) {
+      const IBSPNode& rNode = mBSPNodes[node];
+      const PlaneF& rPlane  = getPlane(rNode.planeIndex);
+
+      F32 dist = rPlane.distToPlane(s.center);
+      if (mFabs(dist) <= s.radius) {
+         // Have to do both, and push the plane back on the list...
+         collPlanes.push_back(rNode.planeIndex);
+         buildPolyList_r(rNode.frontIndex, collPlanes, list, s);
+         buildPolyList_r(rNode.backIndex, collPlanes, list, s);
+         collPlanes.pop_back();
+      } else if (dist > 0.0f) {
+         buildPolyList_r(rNode.frontIndex, collPlanes, list, s);
+      } else {
+         buildPolyList_r(rNode.backIndex, collPlanes, list, s);
+      }
+      return;
+   }
+
+   if (isBSPSolidLeaf(node)) {
+      const IBSPLeafSolid& rLeaf = mBSPSolidLeaves[getBSPSolidLeafIndex(node)];
+      for (U32 i = 0; i < rLeaf.surfaceCount; i++) {
+         U32 surfaceIndex = mSolidLeafSurfaces[rLeaf.surfaceIndex + i];
+         const Surface& rSurface = mSurfaces[surfaceIndex];
+         for (U32 j = 0; j < collPlanes.size(); j++) {
+            if (areEqualPlanes(rSurface.planeIndex, collPlanes[j]) == true) {
+
+               U32 fanVerts[32];
+               U32 numVerts;
+               collisionFanFromSurface(rSurface, fanVerts, &numVerts);
+
+               // DMM: Material here
+               list->begin(0, rSurface.planeIndex);
+
+               U32 vertStart = list->addPoint(mPoints[fanVerts[0]]);
+               list->vertex(vertStart);
+               for (U32 k = 1; k < numVerts; k++) {
+                  list->addPoint(mPoints[fanVerts[k]]);
+                  list->vertex(vertStart + k);
+               }
+               list->plane(vertStart, vertStart + 1, vertStart + 2);
+               list->end();
+
+               break;
+            }
+         }
+
+      }
+   }
+}
+
+bool ForceField::buildPolyList(AbstractPolyList* list, SphereF& sphere)
+{
+   Vector<U16> planes;
+   buildPolyList_r(0, planes, list, sphere);
+   AssertFatal(planes.size() == 0, "Error, unbalanced plane stack!");
+
+   return !list->isEmpty();
+}