470 lines
14 KiB
C++
Executable File
470 lines
14 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// 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();
|
|
}
|