You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

989 lines
22 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "hsTypes.h"
#include "plVolumeIsect.h"
#include "hsBounds.h"
#include "hsFastMath.h"
#include "hsStream.h"
#include "hsResMgr.h"
#include "plIntersect/plClosest.h"
static const hsScalar kDefLength = 5.f;
plSphereIsect::plSphereIsect()
: fRadius(1.f)
{
fCenter.Set(0,0,0);
int i;
for( i = 0; i < 3; i++ )
{
fMins[i] = -fRadius;
fMaxs[i] = fRadius;
}
}
plSphereIsect::~plSphereIsect()
{
}
void plSphereIsect::SetCenter(const hsPoint3& c)
{
fWorldCenter = fCenter = c;
int i;
for( i = 0; i < 3; i++ )
{
fMins[i] += c[i];
fMaxs[i] += c[i];
}
}
void plSphereIsect::SetRadius(hsScalar r)
{
hsScalar del = r - fRadius;
int i;
for( i = 0; i < 3; i++ )
{
fMins[i] -= del;
fMaxs[i] += del;
}
fRadius = r;
}
void plSphereIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
fWorldCenter = l2w * fCenter;
fMaxs = fMins = fWorldCenter;
int i;
for( i = 0; i < 3; i++ )
{
fMins[i] -= fRadius;
fMaxs[i] += fRadius;
}
}
// Could use ClosestPoint to find the closest point on the bounds
// to our center, and do a distance test on that. Would be more
// accurate than this box test approx, but whatever.
plVolumeCullResult plSphereIsect::Test(const hsBounds3Ext& bnd) const
{
const hsPoint3& maxs = bnd.GetMaxs();
const hsPoint3& mins = bnd.GetMins();
if( (maxs.fX < fMins.fX)
||
(maxs.fY < fMins.fY)
||
(maxs.fZ < fMins.fZ) )
return kVolumeCulled;
if( (mins.fX > fMaxs.fX)
||
(mins.fY > fMaxs.fY)
||
(mins.fZ > fMaxs.fZ) )
return kVolumeCulled;
if( (maxs.fX > fMaxs.fX)
||
(maxs.fY > fMaxs.fY)
||
(maxs.fZ > fMaxs.fZ) )
return kVolumeSplit;
if( (mins.fX < fMins.fX)
||
(mins.fY < fMins.fY)
||
(mins.fZ < fMins.fZ) )
return kVolumeSplit;
return kVolumeClear;
}
hsScalar plSphereIsect::Test(const hsPoint3& pos) const
{
hsScalar dist = (pos - fWorldCenter).MagnitudeSquared();
if( dist < fRadius*fRadius )
return 0;
dist = hsSquareRoot(dist);
return dist - fRadius;
}
void plSphereIsect::Read(hsStream* s, hsResMgr* mgr)
{
fCenter.Read(s);
fWorldCenter.Read(s);
fRadius = s->ReadSwapScalar();
fMins.Read(s);
fMaxs.Read(s);
}
void plSphereIsect::Write(hsStream* s, hsResMgr* mgr)
{
fCenter.Write(s);
fWorldCenter.Write(s);
s->WriteSwapScalar(fRadius);
fMins.Write(s);
fMaxs.Write(s);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plConeIsect::plConeIsect()
: fLength(kDefLength), fRadAngle(hsScalarPI*0.25f), fCapped(false)
{
ISetup();
}
plConeIsect::~plConeIsect()
{
}
void plConeIsect::SetAngle(hsScalar rads)
{
fRadAngle = rads;
ISetup();
}
void plConeIsect::ISetup()
{
hsScalar sinAng, cosAng;
hsFastMath::SinCosInRangeAppr(fRadAngle, sinAng, cosAng);
const hsScalar kHither = 0.1f;
fLightToNDC.Reset();
fLightToNDC.fMap[0][0] = hsScalarDiv( cosAng, sinAng );
fLightToNDC.fMap[1][1] = hsScalarDiv( cosAng, sinAng );
fLightToNDC.fMap[2][2] = -hsScalarDiv( fLength, fLength - kHither );
fLightToNDC.fMap[3][3] = hsIntToScalar( 0 );
fLightToNDC.fMap[3][2] = hsIntToScalar( -1 );
fLightToNDC.fMap[2][3] = -hsScalarMulDiv( fLength, kHither, fLength - kHither );
fLightToNDC.NotIdentity();
}
plVolumeCullResult plConeIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult retVal = kVolumeClear;
hsPoint2 depth;
hsVector3 normDir = -fWorldNorm;
bnd.TestPlane(normDir, depth);
if( depth.fY < normDir.InnerProduct(fWorldTip) )
return kVolumeCulled;
int last = fCapped ? 5 : 4;
int i;
for( i = 0; i < last; i++ )
{
bnd.TestPlane(fNorms[i], depth);
if( depth.fY + fDists[i] <= 0 )
return kVolumeCulled;
if( depth.fX + fDists[i] <= 0 )
retVal = kVolumeSplit;
}
if( retVal == kVolumeSplit )
{
hsVector3 axis = normDir % hsVector3(&bnd.GetCenter(), &fWorldTip);
hsFastMath::NormalizeAppr(axis);
hsVector3 perp = axis % normDir;
hsScalar sinAng, cosAng;
hsFastMath::SinCosInRangeAppr(fRadAngle, sinAng, cosAng);
hsVector3 tangent = normDir + sinAng * perp + (1-cosAng) * (axis % perp);
hsVector3 normIn = tangent % axis;
hsVector3 normIn2 = perp + sinAng * (perp % axis) + (1-cosAng) * (axis % (axis % perp));
bnd.TestPlane(normIn, depth);
hsScalar normInDotTip = normIn.InnerProduct(fWorldTip);
if( depth.fY < normInDotTip )
return kVolumeCulled;
}
return retVal;
}
hsScalar plConeIsect::Test(const hsPoint3& pos) const
{
UInt32 clampFlags = fCapped ? plClosest::kClamp : plClosest::kClampLower;
hsPoint3 cp;
plClosest::PointOnLine(pos,
fWorldTip, fWorldNorm,
cp,
clampFlags);
hsScalar radDist = (pos - cp).Magnitude();
hsScalar axDist = fWorldNorm.InnerProduct(pos - fWorldTip) / fLength;
if( axDist < 0 )
{
return radDist;
}
hsScalar sinAng, cosAng;
hsFastMath::SinCosInRangeAppr(fRadAngle, sinAng, cosAng);
hsScalar radius = axDist * sinAng / cosAng;
radDist -= radius;
axDist -= fLength;
if( fCapped && (axDist > 0) )
{
return axDist > radDist ? axDist : radDist;
}
return radDist > 0 ? radDist : 0;
}
//#define MF_DEBUG_NORM
#ifdef MF_DEBUG_NORM
#define IDEBUG_NORMALIZE( a, b ) { hsScalar len = 1.f / a.Magnitude(); a *= len; b *= len; }
#else // MF_DEBUG_NORM
#define IDEBUG_NORMALIZE( a, b )
#endif // MF_DEBUG_NORM
void plConeIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
fWorldTip = l2w.GetTranslate();
fWorldNorm.Set(l2w.fMap[0][2], l2w.fMap[1][2], l2w.fMap[2][2]);
fWorldToNDC = fLightToNDC * w2l;
int i;
for( i = 0; i < 2; i++ )
{
fNorms[i].Set(fWorldToNDC.fMap[3][0] - fWorldToNDC.fMap[i][0], fWorldToNDC.fMap[3][1] - fWorldToNDC.fMap[i][1], fWorldToNDC.fMap[3][2] - fWorldToNDC.fMap[i][2]);
fDists[i] = fWorldToNDC.fMap[3][3] - fWorldToNDC.fMap[i][3];
IDEBUG_NORMALIZE( fNorms[i], fDists[i] );
fNorms[i+2].Set(fWorldToNDC.fMap[3][0] + fWorldToNDC.fMap[i][0], fWorldToNDC.fMap[3][1] + fWorldToNDC.fMap[i][1], fWorldToNDC.fMap[3][2] + fWorldToNDC.fMap[i][2]);
fDists[i+2] = fWorldToNDC.fMap[3][3] + fWorldToNDC.fMap[i][3];
IDEBUG_NORMALIZE( fNorms[i+2], fDists[i+2] );
}
if( fCapped )
{
fNorms[4].Set(fWorldToNDC.fMap[3][0] - fWorldToNDC.fMap[2][0], fWorldToNDC.fMap[3][1] - fWorldToNDC.fMap[2][1], fWorldToNDC.fMap[3][2] - fWorldToNDC.fMap[2][2]);
fDists[4] = fWorldToNDC.fMap[3][3] - fWorldToNDC.fMap[2][3];
IDEBUG_NORMALIZE( fNorms[4], fDists[4] );
}
}
void plConeIsect::SetLength(hsScalar d)
{
if( d > 0 )
{
fCapped = true;
fLength = d;
}
else
{
fCapped = false;
fLength = kDefLength;
}
ISetup();
}
void plConeIsect::Read(hsStream* s, hsResMgr* mgr)
{
fCapped = s->ReadSwap32();
fRadAngle = s->ReadSwapScalar();
fLength = s->ReadSwapScalar();
fWorldTip.Read(s);
fWorldNorm.Read(s);
fWorldToNDC.Read(s);
fLightToNDC.Read(s);
int n = fCapped ? 5 : 4;
int i;
for(i = 0; i < n; i++ )
{
fNorms[i].Read(s);
fDists[i] = s->ReadSwapScalar();
}
}
void plConeIsect::Write(hsStream* s, hsResMgr* mgr)
{
s->WriteSwap32(fCapped);
s->WriteSwapScalar(fRadAngle);
s->WriteSwapScalar(fLength);
fWorldTip.Write(s);
fWorldNorm.Write(s);
fWorldToNDC.Write(s);
fLightToNDC.Write(s);
int n = fCapped ? 5 : 4;
int i;
for(i = 0; i < n; i++ )
{
fNorms[i].Write(s);
s->WriteSwapScalar(fDists[i]);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plCylinderIsect::plCylinderIsect()
{
}
plCylinderIsect::~plCylinderIsect()
{
}
void plCylinderIsect::ISetupCyl(const hsPoint3& wTop, const hsPoint3& wBot, hsScalar radius)
{
fWorldNorm.Set(&wTop, &wBot);
fLength = fWorldNorm.Magnitude();
fMin = fWorldNorm.InnerProduct(wBot);
fMax = fWorldNorm.InnerProduct(wTop);
if( fMin > fMax )
{
hsScalar t = fMin;
fMin = fMax;
fMax = t;
}
fRadius = radius;
}
void plCylinderIsect::SetCylinder(const hsPoint3& lTop, const hsPoint3& lBot, hsScalar radius)
{
fTop = lTop;
fBot = lBot;
fRadius = radius;
ISetupCyl(fTop, fBot, fRadius);
}
void plCylinderIsect::SetCylinder(const hsPoint3& lBot, const hsVector3& axis, hsScalar radius)
{
fBot = lBot;
fTop = fBot;
fTop += axis;
ISetupCyl(fTop, fBot, radius);
}
void plCylinderIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
hsPoint3 wTop = l2w * fTop;
hsPoint3 wBot = l2w * fBot;
ISetupCyl(wTop, wBot, fRadius);
}
plVolumeCullResult plCylinderIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult radVal = kVolumeClear;
// Central axis test
hsPoint2 depth;
bnd.TestPlane(fWorldNorm, depth);
if( depth.fX > fMax )
return kVolumeCulled;
if( depth.fY < fMin )
return kVolumeCulled;
if( (depth.fX < fMin)
||(depth.fY > fMax) )
{
radVal = kVolumeSplit;
}
// Radial test
plVolumeCullResult retVal = kVolumeCulled;
// Find the closest point on/in the bounds to our central axis.
// If that closest point is inside the cylinder, we have a hit.
hsPoint3 corner;
bnd.GetCorner(&corner);
hsVector3 axes[3];
bnd.GetAxes(axes+0, axes+1, axes+2);
hsPoint3 cp = corner;
hsScalar bndRadiusSq = bnd.GetRadius();
bndRadiusSq *= bndRadiusSq;
hsScalar radiusSq = fRadius*fRadius;
hsScalar maxClearDistSq = fRadius - bnd.GetRadius();
maxClearDistSq *= maxClearDistSq;
int i;
for( i = 0; i < 3; i++ )
{
hsPoint3 cp0;
hsPoint3 currPt;
plClosest::PointsOnLines(fWorldBot, fWorldNorm,
cp, axes[i],
cp0, currPt,
plClosest::kClamp);
hsScalar distSq = (cp0 - currPt).MagnitudeSquared();
if( distSq < radiusSq )
{
if( distSq < maxClearDistSq )
{
return kVolumeClear == radVal ? kVolumeClear : kVolumeSplit;
}
retVal = kVolumeSplit;
}
cp = currPt;
}
return retVal;
}
hsScalar plCylinderIsect::Test(const hsPoint3& pos) const
{
hsPoint3 cp;
plClosest::PointOnLine(pos,
fWorldBot, fWorldNorm,
cp,
plClosest::kClamp);
hsScalar radDist = (pos - cp).Magnitude() - fRadius;
hsScalar axDist = fWorldNorm.InnerProduct(pos - fWorldBot) / fLength;
if( axDist < 0 )
axDist = -axDist;
else
axDist -= fLength;
hsScalar dist = axDist > radDist ? axDist : radDist;
return dist > 0 ? dist : 0;
}
void plCylinderIsect::Read(hsStream* s, hsResMgr* mgr)
{
fTop.Read(s);
fBot.Read(s);
fRadius = s->ReadSwapScalar();
fWorldBot.Read(s);
fWorldNorm.Read(s);
fLength = s->ReadSwapScalar();
fMin = s->ReadSwapScalar();
fMax = s->ReadSwapScalar();
}
void plCylinderIsect::Write(hsStream* s, hsResMgr* mgr)
{
fTop.Write(s);
fBot.Write(s);
s->WriteSwapScalar(fRadius);
fWorldBot.Write(s);
fWorldNorm.Write(s);
s->WriteSwapScalar(fLength);
s->WriteSwapScalar(fMin);
s->WriteSwapScalar(fMax);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plParallelIsect::plParallelIsect()
{
}
plParallelIsect::~plParallelIsect()
{
}
void plParallelIsect::SetNumPlanes(int n)
{
fPlanes.SetCount(n);
}
void plParallelIsect::SetPlane(int which, const hsPoint3& locPosOne, const hsPoint3& locPosTwo)
{
fPlanes[which].fPosOne = locPosOne;
fPlanes[which].fPosTwo = locPosTwo;
}
void plParallelIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsPoint3 wPosOne = l2w * fPlanes[i].fPosOne;
hsPoint3 wPosTwo = l2w * fPlanes[i].fPosTwo;
hsVector3 norm;
norm.Set(&wPosOne, &wPosTwo);
fPlanes[i].fNorm = norm;
hsScalar t0 = norm.InnerProduct(wPosOne);
hsScalar t1 = norm.InnerProduct(wPosTwo);
if( t0 > t1 )
{
fPlanes[i].fMin = t1;
fPlanes[i].fMax = t0;
}
else
{
fPlanes[i].fMin = t0;
fPlanes[i].fMax = t1;
}
}
}
plVolumeCullResult plParallelIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult retVal = kVolumeClear;
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsPoint2 depth;
bnd.TestPlane(fPlanes[i].fNorm, depth);
if( depth.fY < fPlanes[i].fMin )
return kVolumeCulled;
if( depth.fX > fPlanes[i].fMax )
return kVolumeCulled;
if( depth.fX < fPlanes[i].fMin )
retVal = kVolumeSplit;
if( depth.fY > fPlanes[i].fMax )
retVal = kVolumeSplit;
}
return retVal;
}
hsScalar plParallelIsect::Test(const hsPoint3& pos) const
{
hsScalar maxDist = 0;
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsScalar dist = fPlanes[i].fNorm.InnerProduct(pos);
if( dist > fPlanes[i].fMax )
{
dist -= fPlanes[i].fMax;
dist *= hsFastMath::InvSqrtAppr(fPlanes[i].fNorm.MagnitudeSquared());
if( dist > maxDist )
maxDist = dist;
}
else if( dist < fPlanes[i].fMin )
{
dist = fPlanes[i].fMin - dist;
dist *= hsFastMath::InvSqrtAppr(fPlanes[i].fNorm.MagnitudeSquared());
if( dist > maxDist )
maxDist = dist;
}
}
return maxDist;
}
void plParallelIsect::Read(hsStream* s, hsResMgr* mgr)
{
int n = s->ReadSwap16();
fPlanes.SetCount(n);
int i;
for( i = 0; i < n; i++ )
{
fPlanes[i].fNorm.Read(s);
fPlanes[i].fMin = s->ReadSwapScalar();
fPlanes[i].fMax = s->ReadSwapScalar();
fPlanes[i].fPosOne.Read(s);
fPlanes[i].fPosTwo.Read(s);
}
}
void plParallelIsect::Write(hsStream* s, hsResMgr* mgr)
{
s->WriteSwap16(fPlanes.GetCount());
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
fPlanes[i].fNorm.Write(s);
s->WriteSwapScalar(fPlanes[i].fMin);
s->WriteSwapScalar(fPlanes[i].fMax);
fPlanes[i].fPosOne.Write(s);
fPlanes[i].fPosTwo.Write(s);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plConvexIsect::plConvexIsect()
{
}
plConvexIsect::~plConvexIsect()
{
}
void plConvexIsect::AddPlaneUnchecked(const hsVector3& n, hsScalar dist)
{
SinglePlane plane;
plane.fNorm = n;
plane.fPos.Set(0,0,0);
plane.fDist = dist;
fPlanes.Append(plane);
}
void plConvexIsect::AddPlane(const hsVector3& n, const hsPoint3& p)
{
hsVector3 nNorm = n;
hsFastMath::Normalize(nNorm);
// First, make sure some idiot isn't adding the same plane in twice.
// Also, look for the degenerate case of two parallel planes. In that
// case, take the outer.
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
const hsScalar kCloseToOne = 1.f - 1.e-4f;
if( fPlanes[i].fNorm.InnerProduct(nNorm) >= kCloseToOne )
{
hsScalar dist = nNorm.InnerProduct(p);
if( dist > fPlanes[i].fDist )
{
fPlanes[i].fDist = dist;
fPlanes[i].fPos = p;
}
return;
}
}
SinglePlane plane;
plane.fNorm = nNorm;
plane.fPos = p;
plane.fDist = nNorm.InnerProduct(p);
fPlanes.Append(plane);
}
void plConvexIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsPoint3 wPos = l2w * fPlanes[i].fPos;
// Normal gets transpose of inverse.
fPlanes[i].fWorldNorm.fX = w2l.fMap[0][0] * fPlanes[i].fNorm.fX
+ w2l.fMap[1][0] * fPlanes[i].fNorm.fY
+ w2l.fMap[2][0] * fPlanes[i].fNorm.fZ;
fPlanes[i].fWorldNorm.fY = w2l.fMap[0][1] * fPlanes[i].fNorm.fX
+ w2l.fMap[1][1] * fPlanes[i].fNorm.fY
+ w2l.fMap[2][1] * fPlanes[i].fNorm.fZ;
fPlanes[i].fWorldNorm.fZ = w2l.fMap[0][2] * fPlanes[i].fNorm.fX
+ w2l.fMap[1][2] * fPlanes[i].fNorm.fY
+ w2l.fMap[2][2] * fPlanes[i].fNorm.fZ;
hsFastMath::NormalizeAppr(fPlanes[i].fWorldNorm);
fPlanes[i].fWorldDist = fPlanes[i].fWorldNorm.InnerProduct(wPos);
}
}
plVolumeCullResult plConvexIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult retVal = kVolumeClear;
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsPoint2 depth;
bnd.TestPlane(fPlanes[i].fWorldNorm, depth);
if( depth.fX > fPlanes[i].fWorldDist )
return kVolumeCulled;
if( depth.fY > fPlanes[i].fWorldDist )
retVal = kVolumeSplit;
}
return retVal;
}
hsScalar plConvexIsect::Test(const hsPoint3& pos) const
{
hsScalar maxDist = 0;
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
hsScalar dist = fPlanes[i].fWorldNorm.InnerProduct(pos) - fPlanes[i].fWorldDist;
if( dist > maxDist )
maxDist = dist;
}
return maxDist;
}
void plConvexIsect::Read(hsStream* s, hsResMgr* mgr)
{
Int16 n = s->ReadSwap16();
fPlanes.SetCount(n);
int i;
for( i = 0; i < n; i++ )
{
fPlanes[i].fNorm.Read(s);
fPlanes[i].fPos.Read(s);
fPlanes[i].fDist = s->ReadSwapScalar();
fPlanes[i].fWorldNorm.Read(s);
fPlanes[i].fWorldDist = s->ReadSwapScalar();
}
}
void plConvexIsect::Write(hsStream* s, hsResMgr* mgr)
{
s->WriteSwap16(fPlanes.GetCount());
int i;
for( i = 0; i < fPlanes.GetCount(); i++ )
{
fPlanes[i].fNorm.Write(s);
fPlanes[i].fPos.Write(s);
s->WriteSwapScalar(fPlanes[i].fDist);
fPlanes[i].fWorldNorm.Write(s);
s->WriteSwapScalar(fPlanes[i].fWorldDist);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plBoundsIsect::plBoundsIsect()
{
}
plBoundsIsect::~plBoundsIsect()
{
}
void plBoundsIsect::SetBounds(const hsBounds3Ext& bnd)
{
fLocalBounds = bnd;
fWorldBounds = bnd;
}
void plBoundsIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
fWorldBounds = fLocalBounds;
fWorldBounds.Transform(&l2w);
}
plVolumeCullResult plBoundsIsect::Test(const hsBounds3Ext& bnd) const
{
int retVal = fWorldBounds.TestBound(bnd);
if( retVal < 0 )
return kVolumeCulled;
if( retVal > 0 )
return kVolumeClear;
retVal = bnd.TestBound(fWorldBounds);
return retVal < 0 ? kVolumeCulled : kVolumeSplit;
}
hsScalar plBoundsIsect::Test(const hsPoint3& pos) const
{
hsAssert(false, "Unimplemented");
return 0.f;
}
void plBoundsIsect::Read(hsStream* s, hsResMgr* mgr)
{
fLocalBounds.Read(s);
fWorldBounds.Read(s);
}
void plBoundsIsect::Write(hsStream* s, hsResMgr* mgr)
{
fLocalBounds.Write(s);
fWorldBounds.Write(s);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plComplexIsect::plComplexIsect()
{
}
plComplexIsect::~plComplexIsect()
{
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
delete fVolumes[i];
}
void plComplexIsect::AddVolume(plVolumeIsect* v)
{
fVolumes.Append(v);
}
void plComplexIsect::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
fVolumes[i]->SetTransform(l2w, w2l);
}
void plComplexIsect::Read(hsStream* s, hsResMgr* mgr)
{
int n = s->ReadSwap16();
fVolumes.SetCount(n);
int i;
for( i = 0; i < n; i++ )
{
fVolumes[i] = plVolumeIsect::ConvertNoRef(mgr->ReadCreatable(s));
hsAssert(fVolumes[i], "Failure reading in a sub-volume");
}
}
void plComplexIsect::Write(hsStream* s, hsResMgr* mgr)
{
s->WriteSwap16(fVolumes.GetCount());
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
mgr->WriteCreatable(s, fVolumes[i]);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plUnionIsect::plUnionIsect()
{
}
plUnionIsect::~plUnionIsect()
{
}
plVolumeCullResult plUnionIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult retVal = kVolumeCulled;
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
{
plVolumeCullResult ret = fVolumes[i]->Test(bnd);
switch( ret )
{
case kVolumeCulled:
break;
case kVolumeClear:
return kVolumeClear;
case kVolumeSplit:
retVal = kVolumeSplit;
break;
};
}
return retVal;
}
hsScalar plUnionIsect::Test(const hsPoint3& pos) const
{
hsScalar retVal = 1.e33f;
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
{
hsScalar ret = fVolumes[i]->Test(pos);
if( ret <= 0 )
return 0;
if( ret < retVal )
retVal = ret;
}
return retVal;
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
plIntersectionIsect::plIntersectionIsect()
{
}
plIntersectionIsect::~plIntersectionIsect()
{
}
plVolumeCullResult plIntersectionIsect::Test(const hsBounds3Ext& bnd) const
{
plVolumeCullResult retVal = kVolumeClear;
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
{
plVolumeCullResult ret = fVolumes[i]->Test(bnd);
switch( ret )
{
case kVolumeCulled:
return kVolumeCulled;
case kVolumeClear:
break;
case kVolumeSplit:
retVal = kVolumeSplit;
break;
};
}
return retVal;
}
hsScalar plIntersectionIsect::Test(const hsPoint3& pos) const
{
hsScalar retVal = -1.f;
int i;
for( i = 0; i < fVolumes.GetCount(); i++ )
{
hsScalar ret = fVolumes[i]->Test(pos);
if( ret > retVal )
retVal = ret;
}
return retVal;
}