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.

1072 lines
29 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 "plCullTree.h"
#include "../plDrawable/plSpaceTree.h"
#include "hsFastMath.h"
#include "hsColorRGBA.h"
#include "plProfile.h"
#include "plTweak.h"
#define MF_DEBUG_NORM
#ifdef MF_DEBUG_NORM
#define IDEBUG_NORMALIZE( a, b ) { hsScalar len = hsFastMath::InvSqrtAppr((a).MagnitudeSquared()); a *= len; b *= len; }
#else // MF_DEBUG_NORM
#define IDEBUG_NORMALIZE( a, b )
#endif // MF_DEBUG_NORM
//#define CULL_SMALL_TOLERANCE
#ifdef CULL_SMALL_TOLERANCE
//static const hsScalar kTolerance = 1.e-5f;
static const hsScalar kTolerance = 1.e-3f;
#else //CULL_SMALL_TOLERANCE
static const hsScalar kTolerance = 1.e-1f;
#endif // CULL_SMALL_TOLERANCE
plProfile_CreateCounter("Harvest Nodes", "Draw", HarvestNodes);
//////////////////////////////////////////////////////////////////////
// Harvest culling section.
// These are the functions used on a built tree
//////////////////////////////////////////////////////////////////////
plCullNode::plCullStatus plCullNode::ITestBoundsRecur(const hsBounds3Ext& bnd) const
{
plCullNode::plCullStatus retVal = TestBounds(bnd);
// No Children, what we say goes.
if( (fOuterChild < 0) && (fInnerChild < 0) )
return retVal;
// No innerchild. If we cull, it's culled, else we
// hope our outerchild culls it.
if( fInnerChild < 0 )
{
if( retVal == kCulled )
return kCulled;
return IGetNode(fOuterChild)->ITestBoundsRecur(bnd);
}
// No outerchild. If we say it's clear, it's clear (or split), but if
// it's culled, we have to pass it to innerchild, who may pronounce it clear
if( fOuterChild < 0 )
{
if( retVal == kClear )
return kClear;
if( retVal == kSplit )
return kSplit;
return IGetNode(fInnerChild)->ITestBoundsRecur(bnd);
}
// We've got both children to feed.
// We pass the clear ones to the inner child, culled to outer,
// and split to both. Remember, a both children have to agree to cull a split.
if( retVal == kClear )
return IGetNode(fOuterChild)->ITestBoundsRecur(bnd);
if( retVal == kCulled )
return IGetNode(fInnerChild)->ITestBoundsRecur(bnd);
// Here's the split, to be culled, both children have to
// say its culled.
if( kCulled != IGetNode(fOuterChild)->ITestBoundsRecur(bnd) )
return kSplit;
if( kCulled != IGetNode(fInnerChild)->ITestBoundsRecur(bnd) )
return kSplit;
return kCulled;
}
plCullNode::plCullStatus plCullNode::TestBounds(const hsBounds3Ext& bnd) const
{
// Not sure if doing a sphere test will pay off or not. Some circumstantial evidence
// from TrueTime suggests it could very well, but I really need to do some side by
// side timings to be sure. Still looking for some reasonably constructed real data sets. mf
#define MF_TEST_SPHERE_FIRST
#ifdef MF_TEST_SPHERE_FIRST
hsScalar dist = fNorm.InnerProduct(bnd.GetCenter()) + fDist;
hsScalar rad = bnd.GetRadius();
if( dist < -rad )
return kCulled;
if( dist > rad )
return kClear;
#endif // MF_TEST_SPHERE_FIRST
hsPoint2 depth;
bnd.TestPlane(fNorm, depth);
const hsScalar kSafetyDist = -0.1f;
if( depth.fY + fDist < kSafetyDist )
return kCulled;
if( depth.fX + fDist >= 0 )
return kClear;
return kSplit;
}
plCullNode::plCullStatus plCullNode::ITestSphereRecur(const hsPoint3& center, hsScalar rad) const
{
plCullNode::plCullStatus retVal = TestSphere(center, rad);
// No Children, what we say goes.
if( (fOuterChild < 0) && (fInnerChild < 0) )
return retVal;
// No innerchild. If we cull, it's culled, else we
// hope our outerchild culls it.
if( fInnerChild < 0 )
{
if( retVal == kCulled )
return kCulled;
return IGetNode(fOuterChild)->ITestSphereRecur(center, rad);
}
// No outerchild. If we say it's clear, it's clear (or split), but if
// it's culled, we have to pass it to innerchild, who may pronounce it clear
if( fOuterChild < 0 )
{
if( retVal == kClear )
return kClear;
if( retVal == kSplit )
return kSplit;
return IGetNode(fInnerChild)->ITestSphereRecur(center, rad);
}
// We've got both children to feed.
// We pass the clear ones to the inner child, culled to outer,
// and split to both. Remember, a both children have to agree to cull a split.
if( retVal == kClear )
return IGetNode(fOuterChild)->ITestSphereRecur(center, rad);
if( retVal == kCulled )
return IGetNode(fInnerChild)->ITestSphereRecur(center, rad);
// Here's the split, to be culled, both children have to
// say its culled.
if( kCulled != IGetNode(fOuterChild)->ITestSphereRecur(center, rad) )
return kSplit;
if( kCulled != IGetNode(fInnerChild)->ITestSphereRecur(center, rad) )
return kSplit;
return kCulled;
}
plCullNode::plCullStatus plCullNode::TestSphere(const hsPoint3& center, hsScalar rad) const
{
hsScalar dist = fNorm.InnerProduct(center) + fDist;
if( dist < -rad )
return kCulled;
if( dist > rad )
return kClear;
return kSplit;
}
// For this Cull Node, recur down the space hierarchy pruning out who to test for the next Cull Node.
plCullNode::plCullStatus plCullNode::ITestNode(const plSpaceTree* space, Int16 who, hsLargeArray<Int16>& clear, hsLargeArray<Int16>& split, hsLargeArray<Int16>& culled) const
{
if( space->IsDisabled(who) || (space->GetNode(who).fWorldBounds.GetType() != kBoundsNormal) )
{
culled.Append(who);
return kCulled;
}
plCullStatus retVal = kClear;
plCullStatus stat = TestBounds(space->GetNode(who).fWorldBounds);
switch( stat )
{
case kClear:
clear.Append(who);
retVal = kClear;
break;
case kCulled:
culled.Append(who);
retVal = kCulled;
break;
case kSplit:
if( space->GetNode(who).fFlags & plSpaceTreeNode::kIsLeaf )
{
// split.Append(who);
retVal = kPureSplit;
}
else
{
plCullStatus child0 = ITestNode(space, space->GetNode(who).GetChild(0), clear, split, culled);
plCullStatus child1 = ITestNode(space, space->GetNode(who).GetChild(1), clear, split, culled);
if( child0 != child1 )
{
if( child0 == kPureSplit )
split.Append(space->GetNode(who).GetChild(0));
else if( child1 == kPureSplit )
split.Append(space->GetNode(who).GetChild(1));
retVal = kSplit;
}
else if( child0 == kPureSplit )
{
retVal = kPureSplit;
}
}
}
return retVal;
}
// Cycle through the Cull Nodes, paring down the list of who to test (through ITestNode above).
// We reclaim the scratch indices in clear and split when we're done (SetCount(0)), but we can't
// reclaim the culled, because our caller may be looking at who all we culled. See below in split.
// If a node is disabled, we can just ignore we ever got called.
void plCullNode::ITestNode(const plSpaceTree* space, Int16 who, hsBitVector& totList, hsBitVector& outList) const
{
if( space->IsDisabled(who) )
return;
UInt32 myClearStart = ScratchClear().GetCount();
UInt32 mySplitStart = ScratchSplit().GetCount();
UInt32 myCullStart = ScratchCulled().GetCount();
if( kPureSplit == ITestNode(space, who, ScratchClear(), ScratchSplit(), ScratchCulled()) )
ScratchSplit().Append(who);
UInt32 myClearEnd = ScratchClear().GetCount();
UInt32 mySplitEnd = ScratchSplit().GetCount();
UInt32 myCullEnd = ScratchCulled().GetCount();
int i;
// If there's no OuterChild, everything in clear and split is visible. Everything in culled
// goes to innerchild (if any).
if( fOuterChild < 0 )
{
plProfile_IncCount(HarvestNodes, myClearEnd - myClearStart + mySplitEnd - mySplitStart);
// Replace these with a memcopy or something!!!!
for( i = myClearStart; i < myClearEnd; i++ )
{
space->HarvestLeaves(ScratchClear()[i], totList, outList);
}
for( i = mySplitStart; i < mySplitEnd; i++ )
{
space->HarvestLeaves(ScratchSplit()[i], totList, outList);
}
if( fInnerChild >= 0 )
{
for( i = myCullStart; i < myCullEnd; i++ )
{
IGetNode(fInnerChild)->ITestNode(space, ScratchCulled()[i], totList, outList);
}
}
ScratchClear().SetCount(myClearStart);
ScratchSplit().SetCount(mySplitStart);
ScratchCulled().SetCount(myCullStart);
return;
}
// There is an OuterChild, so whether there's an InnerChild or not,
// everything in ClearList is visible soley on the discretion of OuterChild.
for( i = myClearStart; i < myClearEnd; i++ )
{
IGetNode(fOuterChild)->ITestNode(space, ScratchClear()[i], totList, outList);
}
// If there's no InnerChild, then the SplitList is also visible soley
// on the discretion of OuterChild.
if( fInnerChild < 0 )
{
for( i = mySplitStart; i < mySplitEnd; i++ )
{
IGetNode(fOuterChild)->ITestNode(space, ScratchSplit()[i], totList, outList);
}
ScratchClear().SetCount(myClearStart);
ScratchSplit().SetCount(mySplitStart);
ScratchCulled().SetCount(myCullStart);
return;
}
// There is an inner child. Everything in culled list is visible
// soley on its discretion.
for( i = myCullStart; i < myCullEnd; i++ )
{
IGetNode(fInnerChild)->ITestNode(space, ScratchCulled()[i], totList, outList);
}
// Okay, here's the rub.
// Everyone in the split list needs to be tested against InnerChild and OuterChild.
// If either child says it's okay (puts it in OutList), then it's okay.
// The problem is that if both children say it's okay, it will wind up in outList twice.
// This is complicated by the fact that outList is still subTrees at this point,
// so InnerChild adding a subTree and OuterChild adding a child of that subTree isn't
// even appending the same value to the list.
// Sooooo.
// What we do is keep track of every node (interior and leaf) that gets harvested.
// When we go to harvest a subtree, we check in totList for its bit being set. Bits
// set in totList are ENTIRE SUBTREE IS HARVESTED. SpaceTree understands this too in
// its HarvestLeaves. Seems obvious now, but I didn't hear you suggest it.
for( i = mySplitStart; i < mySplitEnd; i++ )
{
IGetNode(fOuterChild)->ITestNode(space, ScratchSplit()[i], totList, outList);
}
for( i = mySplitStart; i < mySplitEnd; i++ )
{
if( !totList.IsBitSet(ScratchSplit()[i]) )
IGetNode(fInnerChild)->ITestNode(space, ScratchSplit()[i], totList, outList);
}
ScratchClear().SetCount(myClearStart);
ScratchSplit().SetCount(mySplitStart);
ScratchCulled().SetCount(myCullStart);
}
void plCullNode::IHarvest(const plSpaceTree* space, hsTArray<Int16>& outList) const
{
ITestNode(space, space->GetRoot(), ScratchTotVec(), ScratchBitVec());
space->BitVectorToList(outList, ScratchBitVec());
ScratchBitVec().Clear();
ScratchTotVec().Clear();
ScratchClear().SetCount(0);
ScratchSplit().SetCount(0);
ScratchCulled().SetCount(0);
}
//////////////////////////////////////////////////////////////////////
// This section builds the tree from the input cullpoly's
//////////////////////////////////////////////////////////////////////
void plCullNode::IBreakPoly(const plCullPoly& poly, const hsTArray<hsScalar>& depths,
hsBitVector& inVerts,
hsBitVector& outVerts,
hsBitVector& onVerts,
plCullPoly& outPoly) const
{
inVerts.Clear();
outVerts.Clear();
onVerts.Clear();
outPoly.Init(poly);
if( depths[0] < -kTolerance )
inVerts.SetBit(0);
else if( depths[0] > kTolerance )
outVerts.SetBit(0);
else
onVerts.SetBit(0);
if( poly.fClipped.IsBitSet(0) )
outPoly.fClipped.SetBit(0);
outPoly.fVerts.Append(poly.fVerts[0]);
int i;
for( i = 1; i < poly.fVerts.GetCount(); i++ )
{
if( depths[i] < -kTolerance )
{
if( outVerts.IsBitSet(outPoly.fVerts.GetCount()-1) )
{
hsPoint3 interp;
hsScalar t = IInterpVert(poly.fVerts[i-1], poly.fVerts[i], interp);
// add interp
onVerts.SetBit(outPoly.fVerts.GetCount());
if( poly.fClipped.IsBitSet(i-1) )
outPoly.fClipped.SetBit(outPoly.fVerts.GetCount());
outPoly.fVerts.Append(interp);
}
inVerts.SetBit(outPoly.fVerts.GetCount());
}
else if( depths[i] > kTolerance )
{
if( inVerts.IsBitSet(outPoly.fVerts.GetCount()-1) )
{
hsPoint3 interp;
hsScalar t = IInterpVert(poly.fVerts[i-1], poly.fVerts[i], interp);
// add interp
onVerts.SetBit(outPoly.fVerts.GetCount());
if( poly.fClipped.IsBitSet(i-1) )
outPoly.fClipped.SetBit(outPoly.fVerts.GetCount());
outPoly.fVerts.Append(interp);
}
outVerts.SetBit(outPoly.fVerts.GetCount());
}
else
{
onVerts.SetBit(outPoly.fVerts.GetCount());
}
if( poly.fClipped.IsBitSet(i) )
outPoly.fClipped.SetBit(outPoly.fVerts.GetCount());
outPoly.fVerts.Append(poly.fVerts[i]);
}
if( (inVerts.IsBitSet(outPoly.fVerts.GetCount()-1) && outVerts.IsBitSet(0))
||(outVerts.IsBitSet(outPoly.fVerts.GetCount()-1) && inVerts.IsBitSet(0)) )
{
hsPoint3 interp;
hsScalar t = IInterpVert(poly.fVerts[poly.fVerts.GetCount()-1], poly.fVerts[0], interp);
onVerts.SetBit(outPoly.fVerts.GetCount());
if( poly.fClipped.IsBitSet(poly.fVerts.GetCount()-1) )
outPoly.fClipped.SetBit(outPoly.fVerts.GetCount());
outPoly.fVerts.Append(interp);
}
}
void plCullNode::ITakeHalfPoly(const plCullPoly& srcPoly,
const hsTArray<int>& vtxIdx,
const hsBitVector& onVerts,
plCullPoly& outPoly) const
{
if( vtxIdx.GetCount() > 2 )
{
int i;
for( i = 0; i < vtxIdx.GetCount(); i++ )
{
int next = i < vtxIdx.GetCount()-1 ? i+1 : 0;
int last = i ? i-1 : vtxIdx.GetCount()-1;
// If these 3 verts are all on the plane, we may have created a collinear vertex (the middle one)
// which we now want to skip.
if( onVerts.IsBitSet(vtxIdx[i]) && onVerts.IsBitSet(vtxIdx[last]) && onVerts.IsBitSet(vtxIdx[next]) )
{
#if 0 // FISH
hsScalar dot = hsVector3(&srcPoly.fVerts[vtxIdx[last]], &srcPoly.fVerts[vtxIdx[i]]).InnerProduct(hsVector3(&srcPoly.fVerts[vtxIdx[next]], &srcPoly.fVerts[vtxIdx[i]]));
if( dot <= 0 )
#endif // FISH
continue;
}
if( srcPoly.fClipped.IsBitSet(vtxIdx[i])
||(onVerts.IsBitSet(vtxIdx[i]) && onVerts.IsBitSet(vtxIdx[next])) )
outPoly.fClipped.SetBit(outPoly.fVerts.GetCount());
outPoly.fVerts.Append(srcPoly.fVerts[vtxIdx[i]]);
}
}
else
{
// Just need a break point
hsStatusMessage("Under 2"); // FISH
}
}
void plCullNode::IMarkClipped(const plCullPoly& poly, const hsBitVector& onVerts) const
{
int i;
for( i = 1; i < poly.fVerts.GetCount(); i++ )
{
int last = i-1;
if( onVerts[i] && onVerts[last] )
poly.fClipped.SetBit(last);
}
if( onVerts[i] && onVerts[0] )
poly.fClipped.SetBit(0);
}
plCullNode::plCullStatus plCullNode::ISplitPoly(const plCullPoly& poly,
plCullPoly*& innerPoly,
plCullPoly*& outerPoly) const
{
static hsTArray<hsScalar> depths;
depths.SetCount(poly.fVerts.GetCount());
static hsBitVector onVerts;
onVerts.Clear();
hsBool someInner = false;
hsBool someOuter = false;
hsBool someOn = false;
int i;
for( i = 0; i < poly.fVerts.GetCount(); i++ )
{
depths[i] = fNorm.InnerProduct(poly.fVerts[i]) + fDist;
if( depths[i] < -kTolerance )
someInner = true;
else if( depths[i] > kTolerance )
someOuter = true;
else
{
someOn = true;
onVerts.SetBit(i);
}
}
if( !(someInner || someOuter) )
{
(innerPoly = ScratchPolys().Push())->Init(poly);
(outerPoly = ScratchPolys().Push())->Init(poly);
return kSplit;
}
else if( !someInner )
{
IMarkClipped(poly, onVerts);
return kClear;
}
else if( !someOuter )
{
IMarkClipped(poly, onVerts);
return kCulled;
}
// Okay, it's split, now break it into the two polys
(innerPoly = ScratchPolys().Push())->Init(poly);
(outerPoly = ScratchPolys().Push())->Init(poly);
static plCullPoly scrPoly;
static hsBitVector inVerts;
static hsBitVector outVerts;
IBreakPoly(poly, depths,
inVerts,
outVerts,
onVerts,
scrPoly);
static hsTArray<int> inPolyIdx;
inPolyIdx.SetCount(0);
static hsTArray<int> outPolyIdx;
outPolyIdx.SetCount(0);
for( i = 0; i < scrPoly.fVerts.GetCount(); i++ )
{
if( inVerts.IsBitSet(i) )
{
inPolyIdx.Append(i);
}
else if( outVerts.IsBitSet(i) )
{
outPolyIdx.Append(i);
}
else
{
inPolyIdx.Append(i);
outPolyIdx.Append(i);
}
}
ITakeHalfPoly(scrPoly, inPolyIdx, onVerts, *innerPoly);
ITakeHalfPoly(scrPoly, outPolyIdx, onVerts, *outerPoly);
return kSplit;
}
hsScalar plCullNode::IInterpVert(const hsPoint3& p0, const hsPoint3& p1, hsPoint3& out) const
{
hsVector3 oneToOh;
oneToOh.Set(&p0, &p1);
hsScalar t = -(fNorm.InnerProduct(p1) + fDist) / fNorm.InnerProduct(oneToOh);
if( t >= 1.f )
{
out = p0;
return 1.f;
}
if( t <= 0 )
{
out = p1;
return 0;
}
out = p1;
out += oneToOh * t;
return t;
}
// We use indices so our tree can actually be an array, which may be
// resized at any time, which would invalidate any pointers we have.
// But debugging a large tree is hard enough when stepping through pointers,
// it's pretty much impossible with indices. So when debugging we can
// setup these pointers for stepping through the tree. We just need to
// reset them every time we add a poly, because that's when the tree
// may have been resized invalidating the old pointers.
#ifdef DEBUG_POINTERS
void plCullNode::ISetPointersRecur() const
{
if( fInnerPtr = IGetNode(fInnerChild) )
fInnerPtr->ISetPointersRecur();
if( fOuterPtr = IGetNode(fOuterChild) )
fOuterPtr->ISetPointersRecur();
}
#endif // DEBUG_POINTERS
//////////////////////////////////////////////////////////////////////
// Now the tree proper
//////////////////////////////////////////////////////////////////////
// Build the tree
plCullTree::plCullTree()
: fRoot(-1),
fCapturePolys(false)
{
}
plCullTree::~plCullTree()
{
}
void plCullTree::AddPoly(const plCullPoly& poly)
{
const plCullPoly* usePoly = &poly;
hsVector3 cenToEye(&fViewPos, &poly.fCenter);
hsFastMath::NormalizeAppr(cenToEye);
hsScalar camDist = cenToEye.InnerProduct(poly.fNorm);
plConst(hsScalar) kTol(0.1f);
hsBool backFace = camDist < -kTol;
if( !backFace && (camDist < kTol) )
return;
plCullPoly scratchPoly;
if( poly.IsHole() )
{
if( !backFace )
return;
}
else
if( backFace )
{
plConst(hsBool) kAllowTwoSided(true);
if( !kAllowTwoSided || !poly.IsTwoSided() )
return;
scratchPoly.Flip(poly);
usePoly = &scratchPoly;
}
if( !SphereVisible(usePoly->GetCenter(), usePoly->GetRadius()) )
return;
usePoly->fClipped.Clear();
usePoly->Validate();
// Make sure we have enough scratch polys. Each node
// can potentially split this poly, so...
ISetupScratch(fNodeList.GetCount());
#if 1
if( IGetRoot() && IGetNode(IGetRoot()->fOuterChild) )
{
IAddPolyRecur(*usePoly, IGetRoot()->fOuterChild);
}
else
#endif
{
fRoot = IAddPolyRecur(*usePoly, fRoot);
}
#ifdef DEBUG_POINTERS
if( IGetRoot() )
IGetRoot()->ISetPointersRecur();
#endif // DEBUG_POINTERS
}
Int16 plCullTree::IAddPolyRecur(const plCullPoly& poly, Int16 iNode)
{
if( poly.fVerts.GetCount() < 3 )
return iNode;
if( iNode < 0 )
return IMakePolySubTree(poly);
hsBool addInner = (IGetNode(iNode)->fInnerChild >= 0)
|| ((iNode > 5) && poly.IsHole());
hsBool addOuter = !poly.IsHole() || (IGetNode(iNode)->fOuterChild >= 0);
plCullPoly* innerPoly = nil;
plCullPoly* outerPoly = nil;
plCullNode::plCullStatus test = IGetNode(iNode)->ISplitPoly(poly, innerPoly, outerPoly);
switch( test )
{
case plCullNode::kClear:
if( addOuter )
{
int child = IAddPolyRecur(poly, IGetNode(iNode)->fOuterChild);
IGetNode(iNode)->fOuterChild = child;
}
break;
case plCullNode::kCulled:
if( addInner )
{
int child = IAddPolyRecur(poly, IGetNode(iNode)->fInnerChild);
IGetNode(iNode)->fInnerChild = child;
}
break;
case plCullNode::kSplit:
hsAssert(innerPoly && outerPoly, "Poly should have been split into inner and outer in SplitPoly");
if( addOuter )
{
int child = IAddPolyRecur(*outerPoly, IGetNode(iNode)->fOuterChild);
IGetNode(iNode)->fOuterChild = child;
}
if( addInner )
{
int child = IAddPolyRecur(*innerPoly, IGetNode(iNode)->fInnerChild);
IGetNode(iNode)->fInnerChild = child;
}
break;
}
return iNode;
}
Int16 plCullTree::IMakePolyNode(const plCullPoly& poly, int i0, int i1) const
{
Int16 retINode = fNodeList.GetCount();
plCullNode* nextNode = fNodeList.Push();
hsVector3 a;
hsVector3 b;
a.Set(&poly.fVerts[i0], &fViewPos);
b.Set(&poly.fVerts[i1], &fViewPos);
hsVector3 n = a % b;
hsScalar d = -n.InnerProduct(fViewPos);
IDEBUG_NORMALIZE(n, d);
nextNode->Init(this, n, d);
return retINode;
}
Int16 plCullTree::IMakeHoleSubTree(const plCullPoly& poly) const
{
if( fCapturePolys )
IVisPoly(poly, true);
int firstNode = fNodeList.GetCount();
Int16 iNode = -1;
int i;
for( i = 0; i < poly.fVerts.GetCount()-1; i++ )
{
if( !poly.fClipped.IsBitSet(i) )
{
Int16 child = IMakePolyNode(poly, i, i+1);
if( iNode >= 0 )
IGetNode(iNode)->fOuterChild = child;
iNode = child;
}
}
if( !poly.fClipped.IsBitSet(i) )
{
Int16 child = IMakePolyNode(poly, i, 0);
if( iNode >= 0 )
IGetNode(iNode)->fOuterChild = child;
iNode = child;
}
plCullNode* child = fNodeList.Push();
child->Init(this, poly.fNorm, poly.fDist);
if( iNode >= 0 )
IGetNode(iNode)->fOuterChild = fNodeList.GetCount()-1;
return firstNode;
}
Int16 plCullTree::IMakePolySubTree(const plCullPoly& poly) const
{
poly.Validate();
if( poly.IsHole() )
return IMakeHoleSubTree(poly);
if( fCapturePolys )
IVisPoly(poly, false);
int firstNode = fNodeList.GetCount();
Int16 iNode = -1;
int i;
for( i = 0; i < poly.fVerts.GetCount()-1; i++ )
{
if( !poly.fClipped.IsBitSet(i) )
{
Int16 child = IMakePolyNode(poly, i, i+1);
if( iNode >= 0 )
IGetNode(iNode)->fInnerChild = child;
iNode = child;
}
}
if( !poly.fClipped.IsBitSet(i) )
{
Int16 child = IMakePolyNode(poly, i, 0);
if( iNode >= 0 )
IGetNode(iNode)->fInnerChild = child;
iNode = child;
}
plCullNode* child = fNodeList.Push();
child->Init(this, poly.fNorm, poly.fDist);
child->fIsFace = true;
if( iNode >= 0 )
IGetNode(iNode)->fInnerChild = fNodeList.GetCount()-1;
return firstNode;
}
///////////////////////////////////////////////////////////////////
// Begin visualization section of the program
///////////////////////////////////////////////////////////////////
void plCullTree::IVisPolyShape(const plCullPoly& poly, hsBool dark) const
{
int i;
int vertStart = fVisVerts.GetCount();
hsColorRGBA color;
if( dark )
color.Set(0.2f, 0.2f, 0.2f, 1.f);
else
color.Set(1.f, 1.f, 1.f, 1.f);
hsVector3 norm = dark ? -poly.fNorm : poly.fNorm;
for( i = 0; i < poly.fVerts.GetCount(); i++ )
{
fVisVerts.Append(poly.fVerts[i]);
fVisNorms.Append(poly.fNorm);
fVisColors.Append(color);
}
if( !dark )
{
for( i = 2; i < poly.fVerts.GetCount(); i++ )
{
fVisTris.Append(vertStart);
fVisTris.Append(vertStart + i-1);
fVisTris.Append(vertStart + i);
}
}
else
{
for( i = 2; i < poly.fVerts.GetCount(); i++ )
{
fVisTris.Append(vertStart);
fVisTris.Append(vertStart + i);
fVisTris.Append(vertStart + i-1);
}
}
}
void plCullTree::IVisPolyEdge(const hsPoint3& p0, const hsPoint3& p1, hsBool dark) const
{
hsColorRGBA color;
if( dark )
color.Set(0.2f, 0.2f, 0.2f, 1.f);
else
color.Set(1.f, 1.f, 1.f, 1.f);
int vertStart = fVisVerts.GetCount();
hsVector3 dir0(&p0, &fViewPos);
hsFastMath::NormalizeAppr(dir0);
dir0 *= fVisYon;
hsVector3 dir1(&p1, &fViewPos);
hsFastMath::NormalizeAppr(dir1);
dir1 *= fVisYon;
hsPoint3 p3 = fViewPos;
p3 += dir0;
hsPoint3 p2 = fViewPos;
p2 += dir1;
hsVector3 norm = hsVector3(&p0, &fViewPos) % hsVector3(&p1, &fViewPos);
hsFastMath::NormalizeAppr(norm);
fVisVerts.Append(p0);
fVisNorms.Append(norm);
fVisColors.Append(color);
fVisVerts.Append(p1);
fVisNorms.Append(norm);
fVisColors.Append(color);
fVisVerts.Append(p2);
fVisNorms.Append(norm);
fVisColors.Append(color);
fVisVerts.Append(p3);
fVisNorms.Append(norm);
fVisColors.Append(color);
fVisTris.Append(vertStart + 0);
fVisTris.Append(vertStart + 2);
fVisTris.Append(vertStart + 1);
fVisTris.Append(vertStart + 0);
fVisTris.Append(vertStart + 3);
fVisTris.Append(vertStart + 2);
}
void plCullTree::IVisPoly(const plCullPoly& poly, hsBool dark) const
{
IVisPolyShape(poly, dark);
int i;
for( i = 0; i < poly.fVerts.GetCount()-1; i++ )
{
if( !poly.fClipped.IsBitSet(i) )
IVisPolyEdge(poly.fVerts[i], poly.fVerts[i+1], dark);
}
if( !poly.fClipped.IsBitSet(i) )
IVisPolyEdge(poly.fVerts[i], poly.fVerts[0], dark);
}
void plCullTree::ReleaseCapture() const
{
fVisVerts.Reset();
fVisNorms.Reset();
fVisColors.Reset();
fVisTris.Reset();
}
///////////////////////////////////////////////////////////////////
// End visualization section of the program
///////////////////////////////////////////////////////////////////
void plCullTree::ISetupScratch(UInt16 nNodes)
{
ScratchPolys().SetCount(nNodes << 1);
ScratchPolys().SetCount(0);
}
void plCullTree::Reset()
{
// Using NodeList as scratch will only work if we use indices,
// because a push invalidates any pointers we've stored away.
fNodeList.SetCount(0);
fRoot = -1;
ScratchPolys().SetCount(0);
}
void plCullTree::InitFrustum(const hsMatrix44& world2NDC)
{
Reset();
fNodeList.SetCount(6);
fNodeList.SetCount(0);
Int16 lastIdx = -1;
plCullNode* node;
hsVector3 norm;
hsScalar dist;
int i;
for( i = 0; i < 2; i++ )
{
norm.Set(world2NDC.fMap[3][0] - world2NDC.fMap[i][0], world2NDC.fMap[3][1] - world2NDC.fMap[i][1], world2NDC.fMap[3][2] - world2NDC.fMap[i][2]);
dist = world2NDC.fMap[3][3] - world2NDC.fMap[i][3];
IDEBUG_NORMALIZE( norm, dist );
node = fNodeList.Push();
node->Init(this, norm, dist);
node->fOuterChild = lastIdx;
lastIdx = fNodeList.GetCount()-1;
norm.Set(world2NDC.fMap[3][0] + world2NDC.fMap[i][0], world2NDC.fMap[3][1] + world2NDC.fMap[i][1], world2NDC.fMap[3][2] + world2NDC.fMap[i][2]);
dist = world2NDC.fMap[3][3] + world2NDC.fMap[i][3];
IDEBUG_NORMALIZE( norm, dist );
node = fNodeList.Push();
node->Init(this, norm, dist);
node->fOuterChild = lastIdx;
lastIdx = fNodeList.GetCount()-1;
}
norm.Set(world2NDC.fMap[3][0] - world2NDC.fMap[2][0], world2NDC.fMap[3][1] - world2NDC.fMap[2][1], world2NDC.fMap[3][2] - world2NDC.fMap[2][2]);
dist = world2NDC.fMap[3][3] - world2NDC.fMap[2][3];
IDEBUG_NORMALIZE( norm, dist );
node = fNodeList.Push();
node->Init(this, norm, dist);
node->fOuterChild = lastIdx;
lastIdx = fNodeList.GetCount()-1;
#ifdef SYMMET
norm.Set(world2NDC.fMap[3][0] + world2NDC.fMap[2][0], world2NDC.fMap[3][1] + world2NDC.fMap[2][1], world2NDC.fMap[3][2] + world2NDC.fMap[2][2]);
dist = world2NDC.fMap[3][3] + world2NDC.fMap[2][3];
#else // SYMMET
norm.Set(world2NDC.fMap[2][0], world2NDC.fMap[2][1], world2NDC.fMap[2][2]);
dist = world2NDC.fMap[2][3];
#endif // SYMMET
IDEBUG_NORMALIZE( norm, dist );
node = fNodeList.Push();
node->Init(this, norm, dist);
node->fOuterChild = lastIdx;
lastIdx = fNodeList.GetCount()-1;
fRoot = fNodeList.GetCount()-1;
#ifdef DEBUG_POINTERS
if( IGetRoot() )
IGetRoot()->ISetPointersRecur();
#endif // DEBUG_POINTERS
}
void plCullTree::SetViewPos(const hsPoint3& p)
{
fViewPos = p;
}
//////////////////////////////////////////////////////////////////////
// Use the tree
//////////////////////////////////////////////////////////////////////
void plCullTree::Harvest(const plSpaceTree* space, hsTArray<Int16>& outList) const
{
outList.SetCount(0);
if (!space->IsEmpty())
IGetRoot()->IHarvest(space, outList);
}
hsBool plCullTree::BoundsVisible(const hsBounds3Ext& bnd) const
{
return plCullNode::kCulled != IGetRoot()->ITestBoundsRecur(bnd);
}
hsBool plCullTree::SphereVisible(const hsPoint3& center, hsScalar rad) const
{
return plCullNode::kCulled != IGetRoot()->ITestSphereRecur(center, rad);
}