OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
29 Commits
80 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 3bf6b7e182
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3bf6b7e182'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plSpaceTreeMaker.cpp

721 lines
16 KiB
Raw Blame History

/*==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 "plSpaceTreeMaker.h"
#include "plMath/hsRadixSort.h"
#include "plDrawable/plSpaceTree.h"
#include "hsUtils.h" // for testing, get hsRand()
#include "hsTimer.h"
#include "plIntersect/plVolumeIsect.h"
//#define MF_DO_TIMES
enum mfTimeTypes
{
kMakeTree = 0,
kMakeFatTree,
kSortList,
kHarvest,
kMakeSpaceTree,
kMakeTreeAll,
kHarvestSphere,
kHarvestCone,
kHarvestCapped,
kNumTimes
};
#ifdef MF_DO_TIMES
double times[kNumTimes];
#define StartTimer(i) { times[(i)] -= hsTimer::GetSeconds(); }
#define StopTimer(i) { times[(i)] += hsTimer::GetSeconds(); }
#define InitTimers() { for( int i = 0; i < kNumTimes; i++ )times[i] = 0; }
#else // MF_DO_TIMES
#define StartTimer(i)
#define StopTimer(i)
#define InitTimers()
#endif // MF_DO_TIMES
// Create the tree
// more temp testing garbage
#if 0
plSpaceCullResult mySpaceCullFunction(const hsBounds3Ext& bnd)
{
const hsPoint3& maxs = bnd.GetMaxs();
const hsPoint3& mins = bnd.GetMins();
if( maxs.fX < 0.25f )
return kSpaceCulled;
if( maxs.fY < 0.25f )
return kSpaceCulled;
if( maxs.fZ < 0.25f )
return kSpaceCulled;
if( mins.fX > 0.75f )
return kSpaceCulled;
if( mins.fY > 0.75f )
return kSpaceCulled;
if( mins.fZ > 0.75f )
return kSpaceCulled;
if( maxs.fX > 0.75f )
return kSpaceSplit;
if( maxs.fY > 0.75f )
return kSpaceSplit;
if( maxs.fZ > 0.75f )
return kSpaceSplit;
if( mins.fX < 0.25f )
return kSpaceSplit;
if( mins.fY < 0.25f )
return kSpaceSplit;
if( mins.fZ < 0.25f )
return kSpaceSplit;
return kSpaceClear;
}
#endif
void plSpaceTreeMaker::ISortList(hsTArray<plSpacePrepNode*>& nodes, const hsVector3& axis)
{
StartTimer(kSortList);
hsRadixSort::Elem* list = fSortScratch;
hsRadixSort::Elem* listTrav = list;
Int32 n = nodes.GetCount();
while( n-- )
{
listTrav->fKey.fFloat = axis.InnerProduct(nodes[n]->fWorldBounds.GetCenter());
listTrav->fBody = (void*)nodes[n];
listTrav->fNext = listTrav+1;
listTrav++;
}
list[nodes.GetCount()-1].fNext = nil;
UInt32 sortFlags = 0;
hsRadixSort rad;
hsRadixSort::Elem* sortedList = rad.Sort(list, sortFlags);
listTrav = sortedList;
int i;
for( i = 0; i < nodes.GetCount(); i++ )
{
nodes[i] = (plSpacePrepNode*)(listTrav->fBody);
listTrav = listTrav->fNext;
}
StopTimer(kSortList);
return;
}
void plSpaceTreeMaker::ISplitList(hsTArray<plSpacePrepNode*>& nodes, const hsVector3& axis, hsTArray<plSpacePrepNode*>& lower, hsTArray<plSpacePrepNode*>& upper)
{
ISortList(nodes, axis);
int lowerCount = nodes.GetCount() / 2;
int upperCount = nodes.GetCount() - lowerCount;
lower.SetCount(lowerCount);
upper.SetCount(upperCount);
int i;
for( i = 0; i < lowerCount; i++ )
lower[i] = nodes[i];
for( i = 0; i < upperCount; i++ )
upper[i] = nodes[i + lowerCount];
}
hsBounds3Ext plSpaceTreeMaker::IFindDistToCenterAxis(hsTArray<plSpacePrepNode*>& nodes, hsScalar& length, hsVector3& axis)
{
hsBounds3Ext bnd;
bnd.MakeEmpty();
hsAssert(nodes.GetCount() > 1, "Degenerate case");
int i;
for( i = 0; i < nodes.GetCount(); i++ )
{
bnd.Union(&nodes[i]->fWorldBounds);
}
length = 0;
for( i = 0; i < nodes.GetCount(); i++ )
{
hsVector3 sep;
sep.Set(&bnd.GetCenter(), &nodes[i]->fWorldBounds.GetCenter());
hsScalar len = sep.MagnitudeSquared();
if( len > length )
{
axis = sep;
length = len;
}
}
length = hsSquareRoot(length);
if( length > 1.e-3f )
axis /= length;
else
return IFindSplitAxis(nodes, length, axis);
return bnd;
}
plSpacePrepNode* plSpaceTreeMaker::IMakeFatTreeRecur(hsTArray<plSpacePrepNode*>& nodes)
{
if( !nodes.GetCount() )
return nil;
StartTimer(kMakeFatTree);
plSpacePrepNode* subRoot = TRACKED_NEW plSpacePrepNode;
fTreeSize++;
if( nodes.GetCount() == 1 )
{
*subRoot = *nodes[0];
subRoot->fChildren[0] = nil;
subRoot->fChildren[1] = nil;
StopTimer(kMakeFatTree);
return subRoot;
}
// Find the overall bounds of the list.
// Find the maximum length vector from nodes[i] center to list center.
// If that length is zero, just use the maximum dimension of overall bounds.
hsScalar length;
hsVector3 axis;
hsBounds3Ext bnd = IFindDistToCenterAxis(nodes, length, axis);
hsTArray<plSpacePrepNode*> list0;
hsTArray<plSpacePrepNode*> list1;
ISplitList(nodes, axis, list0, list1);
subRoot->fChildren[0] = IMakeTreeRecur(list0);
subRoot->fChildren[1] = IMakeTreeRecur(list1);
subRoot->fWorldBounds = bnd;
StopTimer(kMakeFatTree);
return subRoot;
}
hsBounds3Ext plSpaceTreeMaker::IFindSplitAxis(hsTArray<plSpacePrepNode*>& nodes, hsScalar& length, hsVector3& axis)
{
hsBounds3Ext bnd;
bnd.MakeEmpty();
int i;
for( i = 0; i < nodes.GetCount(); i++ )
{
bnd.Union(&nodes[i]->fWorldBounds);
}
hsScalar maxLen = bnd.GetMaxs()[0] - bnd.GetMins()[0];
int maxAxis = 0;
if( bnd.GetMaxs()[1] - bnd.GetMins()[1] > maxLen )
{
maxLen = bnd.GetMaxs()[1] - bnd.GetMins()[1];
maxAxis = 1;
}
if( bnd.GetMaxs()[2] - bnd.GetMins()[2] > maxLen )
{
maxLen = bnd.GetMaxs()[2] - bnd.GetMins()[2];
maxAxis = 2;
}
length = maxLen;
switch( maxAxis )
{
case 0:
axis.Set(1.f, 0, 0);
break;
case 1:
axis.Set(0, 1.f, 0);
break;
case 2:
axis.Set(0, 0, 1.f);
break;
}
return bnd;
}
void plSpaceTreeMaker::IFindBigList(hsTArray<plSpacePrepNode*>& nodes, hsScalar length, const hsVector3& axis, hsTArray<plSpacePrepNode*>& giants, hsTArray<plSpacePrepNode*>& strimps)
{
const hsScalar kCutoffFrac = 0.5f;
giants.SetCount(0);
strimps.SetCount(0);
int i;
for( i = 0; i < nodes.GetCount(); i++ )
{
hsPoint2 depth;
nodes[i]->fWorldBounds.TestPlane(axis, depth);
if( depth.fY - depth.fX > length * kCutoffFrac )
giants.Append(nodes[i]);
else
strimps.Append(nodes[i]);
}
}
plSpacePrepNode* plSpaceTreeMaker::INewSubRoot(const hsBounds3Ext& bnd)
{
plSpacePrepNode* subRoot = TRACKED_NEW plSpacePrepNode;
subRoot->fDataIndex = Int16(-1);
fTreeSize++;
subRoot->fWorldBounds = bnd;
return subRoot;
}
plSpacePrepNode* plSpaceTreeMaker::IMakeTreeRecur(hsTArray<plSpacePrepNode*>& nodes)
{
if( !nodes.GetCount() )
return nil;
if( nodes.GetCount() == 1 )
{
return IMakeFatTreeRecur(nodes);
}
StartTimer(kMakeTree);
// Find the maximum bounds dimension
hsScalar length;
hsVector3 axis;
hsBounds3Ext bnd = IFindSplitAxis(nodes, length, axis);
// Find everyone with bounds over half that size in the same dimension as list0.
hsTArray<plSpacePrepNode*> list0;
hsTArray<plSpacePrepNode*> list1;
IFindBigList(nodes, length, axis, list0, list1);
plSpacePrepNode* subRoot = nil;
// If list0 not empty, put them in first child, recur on remainder,
if( list0.GetCount() && list1.GetCount() )
{
subRoot = INewSubRoot(bnd);
subRoot->fChildren[0] = IMakeFatTreeRecur(list0); // too big
subRoot->fChildren[1] = IMakeTreeRecur(list1); // remainder
}
else if( list0.GetCount() )
{
subRoot = IMakeFatTreeRecur(list0);
}
// Else sort along axis by bounds center, recur separately on lower and upper halves.
else
{
ISplitList(nodes, axis, list0, list1);
subRoot = INewSubRoot(bnd);
subRoot->fChildren[0] = IMakeTreeRecur(list0);
subRoot->fChildren[1] = IMakeTreeRecur(list1);
}
StopTimer(kMakeTree);
return subRoot;
}
void plSpaceTreeMaker::IMakeTree()
{
fSortScratch = TRACKED_NEW hsRadixSort::Elem[fLeaves.GetCount()];
fPrepTree = IMakeTreeRecur(fLeaves);
delete [] fSortScratch;
fSortScratch = nil;
}
void plSpaceTreeMaker::Reset()
{
fLeaves.Reset();
fPrepTree = nil;
fTreeSize = 0;
fSortScratch = nil;
}
void plSpaceTreeMaker::IDeleteTreeRecur(plSpacePrepNode* node)
{
if( node )
{
IDeleteTreeRecur(node->fChildren[0]);
IDeleteTreeRecur(node->fChildren[1]);
delete node;
}
}
void plSpaceTreeMaker::Cleanup()
{
IDeleteTreeRecur(fPrepTree);
fPrepTree = nil;
int i;
for( i = 0; i < fLeaves.GetCount(); i++ )
delete fLeaves[i];
fLeaves.Reset();
fDisabled.Reset();
}
Int32 plSpaceTreeMaker::AddLeaf(const hsBounds3Ext& worldBnd, hsBool disable)
{
plSpacePrepNode* leaf = TRACKED_NEW plSpacePrepNode;
fLeaves.Append(leaf);
leaf->fDataIndex = fLeaves.GetCount()-1;
leaf->fChildren[0] = nil;
leaf->fChildren[1] = nil;
leaf->fWorldBounds = worldBnd;
if( leaf->fWorldBounds.GetType() != kBoundsNormal )
{
static const hsPoint3 zero(0.f, 0.f, 0.f);
leaf->fWorldBounds.Reset(&zero);
}
fDisabled.SetBit(leaf->fDataIndex, disable);
return leaf->fDataIndex;
}
//#define MF_DO_RAND
#define MF_DO_3D
#ifdef MF_DO_RAND
#define MF_SETPOINT(pt,a,b,c) pt.Set(hsRand()/32767.f, hsRand()/32767.f, hsRand()/32767.f)
#else // MF_DO_RAND
#define MF_SETPOINT(pt,a,b,c) pt.Set(a,b,c)
#endif // MF_DO_RAND
void plSpaceTreeMaker::TestTree()
{
Reset();
const int kTestSize = 10;
int i;
for( i = 0; i < kTestSize; i++ )
{
int j;
for( j = 0; j < kTestSize; j++ )
{
int k;
#ifdef MF_DO_3D
for( k = 0; k < kTestSize; k++ )
#else // MF_DO_3D
k = 0;
#endif // MF_DO_3D
{
hsBounds3Ext bnd;
hsPoint3 pt;
MF_SETPOINT(pt, float(i-1)/kTestSize, float(j-1)/kTestSize, float(k-1)/kTestSize);
bnd.Reset(&pt);
MF_SETPOINT(pt, float(i)/kTestSize, float(j)/kTestSize, float(k)/kTestSize);
bnd.Union(&pt);
AddLeaf(bnd);
}
}
}
hsBitVector list;
plSpaceTree* tree = MakeTree();
#if 0 // HACK TESTING MOVE TO VOLUMECULL
hsMatrix44 liX;
hsMatrix44 invLiX;
liX.MakeTranslateMat(&hsVector3(0.5f, 0.5f, 0));
liX.GetInverse(&invLiX);
plSphereIsect sphere;
sphere.SetRadius(0.2);
sphere.SetTransform(liX, invLiX);
tree->SetViewPos(*hsPoint3().Set(0,0,0));
plConeIsect cone;
cone.SetAngle(hsScalarPI*0.25f);
cone.SetTransform(liX, invLiX);
StartTimer(kHarvestCone);
list.Clear();
tree->HarvestLeaves(&cone, list);
StopTimer(kHarvestCone);
plConeIsect capped;
capped.SetAngle(hsScalarPI*0.25f);
capped.SetLength(0.5f);
capped.SetTransform(liX, invLiX);
StartTimer(kHarvestCapped);
list.Clear();
tree->HarvestLeaves(&capped, list);
StopTimer(kHarvestCapped);
StartTimer(kHarvestSphere);
list.Clear();
tree->HarvestLeaves(&sphere, list);
StopTimer(kHarvestSphere);
#endif // HACK TESTING MOVE TO VOLUMECULL
delete tree;
}
plSpaceTree* plSpaceTreeMaker::MakeTree()
{
// DEBUG FISH
InitTimers();
// DEBUG FISH
StartTimer(kMakeTreeAll);
if( !fLeaves.GetCount() )
return IMakeEmptyTree();
if( fLeaves.GetCount() < 2 )
return IMakeDegenerateTree();
IMakeTree();
plSpaceTree* retVal = IMakeSpaceTree();
Cleanup();
StopTimer(kMakeTreeAll);
return retVal;
}
plSpaceTree* plSpaceTreeMaker::IMakeEmptyTree()
{
plSpaceTree* tree = TRACKED_NEW plSpaceTree;
tree->fTree.SetCount(1);
tree->fTree[0].fWorldBounds.Reset(&hsPoint3(0,0,0));
tree->fTree[0].fFlags = plSpaceTreeNode::kEmpty;
tree->fRoot = 0;
tree->fNumLeaves = 0;
Cleanup();
return tree;
}
plSpaceTree* plSpaceTreeMaker::IMakeDegenerateTree()
{
plSpaceTree* tree = TRACKED_NEW plSpaceTree;
tree->fTree.Push();
tree->fRoot = 0;
tree->fTree[0].fWorldBounds = fLeaves[0]->fWorldBounds;
tree->fTree[0].fFlags = plSpaceTreeNode::kIsLeaf;
tree->fTree[0].fLeafIndex = 0;
tree->fTree[0].fParent = plSpaceTree::kRootParent;
tree->fNumLeaves = 1;
if( fDisabled.IsBitSet(0) )
tree->SetLeafFlag(0, plSpaceTreeNode::kDisabled, true);
Cleanup();
return tree;
}
int plSpaceTreeMaker::ITreeDepth(plSpacePrepNode* subRoot)
{
if( !subRoot )
return 0;
int dep0 = ITreeDepth(subRoot->fChildren[0]);
int dep1 = ITreeDepth(subRoot->fChildren[1]);
int dep = hsMaximum(dep0, dep1);
return dep+1;
}
plSpaceTree* plSpaceTreeMaker::IMakeSpaceTree()
{
StartTimer(kMakeSpaceTree);
plSpaceTree* tree = TRACKED_NEW plSpaceTree;
plSpacePrepNode* head = fPrepTree;
tree->fTree.SetCount(fLeaves.GetCount());
IGatherLeavesRecur(head, tree);
int level = ITreeDepth(head);
while( level > 0 )
IMakeSpaceTreeRecur(head, tree, --level, 0);
tree->fRoot = tree->fTree.GetCount()-1;
tree->fTree[tree->fRoot].fParent = plSpaceTree::kRootParent;
tree->fNumLeaves = fLeaves.GetCount();
int i;
for( i = 0; i < fLeaves.GetCount(); i++ )
{
if( fDisabled.IsBitSet(i) )
tree->SetLeafFlag(i, plSpaceTreeNode::kDisabled, true);
}
StopTimer(kMakeSpaceTree);
return tree;
}
// The following goofy cache-friendly tree set up slows down the tree build by 10%, but speeds up the runtime by 9%.
// Sounds fair.
#if 0 // Leaves first
Int16 plSpaceTreeMaker::IMakeSpaceTreeRecur(plSpacePrepNode* sub, plSpaceTree* tree, const int targetLevel, int currLevel)
{
if( currLevel == targetLevel )
{
Int16 nodeIdx = tree->fTree.GetCount();
tree->fTree.Push();
tree->fTree[nodeIdx].fWorldBounds = sub->fWorldBounds;
sub->fIndex = nodeIdx;
if( !sub->fChildren[0] )
{
hsAssert(!sub->fChildren[1], "Unsupported unbalance of tree");
tree->fTree[nodeIdx].fFlags = plSpaceTreeNode::kIsLeaf;
tree->fTree[nodeIdx].fLeafIndex = sub->fDataIndex;
return nodeIdx;
}
hsAssert(sub->fChildren[1], "Unsupported unbalance of tree");
tree->fTree[nodeIdx].fFlags = plSpaceTreeNode::kNone;
return nodeIdx;
}
Int16 nodeIdx = sub->fIndex;
if( !sub->fChildren[0] )
{
hsAssert(!sub->fChildren[1] , "Unsupported unbalance of tree");
return nodeIdx;
}
hsAssert(sub->fChildren[1] , "Unsupported unbalance of tree");
tree->fTree[nodeIdx].fChildren[0] = IMakeSpaceTreeRecur(sub->fChildren[0], tree, targetLevel, currLevel+1);
tree->fTree[tree->fTree[nodeIdx].fChildren[0]].fParent = nodeIdx;
tree->fTree[nodeIdx].fChildren[1] = IMakeSpaceTreeRecur(sub->fChildren[1], tree, targetLevel, currLevel+1);
tree->fTree[tree->fTree[nodeIdx].fChildren[1]].fParent = nodeIdx;
return nodeIdx;
}
#else // Leaves first
void plSpaceTreeMaker::IGatherLeavesRecur(plSpacePrepNode* sub, plSpaceTree* tree)
{
// if it's a leaf, stuff it in the right slot, else recur
if( !sub->fChildren[0] )
{
hsAssert(!sub->fChildren[1], "Unsupported unbalance of tree");
plSpaceTreeNode& leaf = tree->fTree[sub->fDataIndex];
Int16 nodeIdx = sub->fDataIndex;
leaf.fWorldBounds = sub->fWorldBounds;
sub->fIndex = nodeIdx;
leaf.fFlags = plSpaceTreeNode::kIsLeaf;
leaf.fLeafIndex = nodeIdx;
return;
}
hsAssert(sub->fChildren[1], "Unsupported unbalance of tree");
IGatherLeavesRecur(sub->fChildren[0], tree);
IGatherLeavesRecur(sub->fChildren[1], tree);
}
void plSpaceTreeMaker::IMakeSpaceTreeRecur(plSpacePrepNode* sub, plSpaceTree* tree, const int targetLevel, int currLevel)
{
// If it's a leaf, we've already done it.
if( !sub->fChildren[0] )
{
hsAssert(!sub->fChildren[1], "Unsupported unbalance of tree");
return;
}
hsAssert(sub->fChildren[0] && sub->fChildren[1], "Shouldn't get this deep, already got the leaves");
if( currLevel == targetLevel )
{
Int16 nodeIdx = tree->fTree.GetCount();
tree->fTree.Push();
tree->fTree[nodeIdx].fWorldBounds = sub->fWorldBounds;
sub->fIndex = nodeIdx;
tree->fTree[nodeIdx].fFlags = plSpaceTreeNode::kNone;
tree->fTree[nodeIdx].fChildren[0] = sub->fChildren[0]->fIndex;
tree->fTree[sub->fChildren[0]->fIndex].fParent = nodeIdx;
tree->fTree[nodeIdx].fChildren[1] = sub->fChildren[1]->fIndex;
tree->fTree[sub->fChildren[1]->fIndex].fParent = nodeIdx;
return;
}
IMakeSpaceTreeRecur(sub->fChildren[0], tree, targetLevel, currLevel+1);
IMakeSpaceTreeRecur(sub->fChildren[1], tree, targetLevel, currLevel+1);
}
#endif // Leaves first