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.
3962 lines
118 KiB
3962 lines
118 KiB
14 years ago
|
/*==LICENSE==*
|
||
|
|
||
|
CyanWorlds.com Engine - MMOG client, server and tools
|
||
13 years ago
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
||
14 years ago
|
|
||
|
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
|
||
13 years ago
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 years ago
|
GNU General Public License for more details.
|
||
|
|
||
|
You should have received a copy of the GNU General Public License
|
||
13 years ago
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
||
|
Additional permissions under GNU GPL version 3 section 7
|
||
|
|
||
|
If you modify this Program, or any covered work, by linking or
|
||
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
||
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
||
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
||
|
(or a modified version of those libraries),
|
||
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
||
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
||
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
||
|
licensors of this Program grant you additional
|
||
|
permission to convey the resulting work. Corresponding Source for a
|
||
|
non-source form of such a combination shall include the source code for
|
||
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
||
|
work.
|
||
14 years ago
|
|
||
|
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==*/
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
// //
|
||
|
// plDrawableSpans Class Functions //
|
||
|
// //
|
||
|
//// Version History /////////////////////////////////////////////////////////
|
||
|
// //
|
||
|
// 4.3.2001 mcn - Created. //
|
||
|
// 5.3.2001 mcn - Completely revamped. Now plDrawableSpans *IS* the group //
|
||
|
// of spans, and each span is either an icicle or patch. //
|
||
|
// This eliminates the need entirely for separate drawables,//
|
||
|
// at the cost of having to do a bit of extra work to //
|
||
|
// maintain different types of spans in the same drawable. //
|
||
|
// //
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
#include "hsTypes.h"
|
||
|
|
||
|
#include "plAccessSpan.h"
|
||
|
#include "plAccessTriSpan.h"
|
||
|
|
||
|
#include "plDrawableSpans.h"
|
||
|
#include "hsStream.h"
|
||
|
#include "hsResMgr.h"
|
||
|
#include "plPipeline.h"
|
||
|
#include "plGeometrySpan.h"
|
||
|
#include "plSpaceTree.h"
|
||
|
#include "plParticleFiller.h"
|
||
|
#include "plSpaceTreeMaker.h"
|
||
|
|
||
|
#include "plClusterGroup.h"
|
||
|
#include "plCluster.h"
|
||
|
#include "plSpanTemplate.h"
|
||
|
|
||
|
#include "../plMath/hsRadixSort.h"
|
||
|
#include "../plSurface/hsGMaterial.h"
|
||
|
#include "../plSurface/plLayerInterface.h"
|
||
|
#include "../plPipeline/plFogEnvironment.h"
|
||
|
#include "../plPipeline/hsGDeviceRef.h"
|
||
|
#include "../plPipeline/plPipeDebugFlags.h"
|
||
|
#include "../pnMessage/plRefMsg.h"
|
||
|
#include "../pnMessage/plNodeRefMsg.h"
|
||
|
#include "../pnMessage/plDISpansMsg.h"
|
||
|
#include "../plMessage/plDeviceRecreateMsg.h"
|
||
|
#include "../plMessage/plRenderMsg.h"
|
||
|
#include "../plPipeline/plGBufferGroup.h"
|
||
|
#include "../pnSceneObject/plDrawInterface.h"
|
||
|
#include "../pnKeyedObject/plKey.h"
|
||
|
#include "../plParticleSystem/plParticleEmitter.h"
|
||
|
#include "../plParticleSystem/plParticle.h"
|
||
|
#include "../plGLight/plLightInfo.h"
|
||
|
#include "plgDispatch.h"
|
||
|
#include "plProfile.h"
|
||
|
|
||
|
#include "../plMath/plTriUtils.h"
|
||
|
|
||
|
#include "../pnMessage/plPipeResMakeMsg.h"
|
||
|
|
||
|
#include "../plScene/plVisMgr.h"
|
||
|
#include "../plScene/plVisRegion.h"
|
||
|
|
||
|
#include <algorithm>
|
||
|
|
||
|
//// Local Konstants /////////////////////////////////////////////////////////
|
||
|
|
||
|
const UInt32 plDrawableSpans::kSpanTypeMask = 0xc0000000;
|
||
|
const UInt32 plDrawableSpans::kSpanIDMask = ~kSpanTypeMask;
|
||
|
const UInt32 plDrawableSpans::kSpanTypeIcicle = 0x00000000;
|
||
|
const UInt32 plDrawableSpans::kSpanTypeParticleSpan = 0xc0000000;
|
||
|
|
||
|
//// Constructor & Destructor ////////////////////////////////////////////////
|
||
|
|
||
|
plDrawableSpans::plDrawableSpans() :
|
||
|
fSceneNode(nil),
|
||
|
fSpaceTree(nil)
|
||
|
{
|
||
|
fReadyToRender = false;
|
||
|
fProps = 0;
|
||
|
fCriteria = 0;
|
||
|
fRegisteredForRecreate = false;
|
||
|
fRegisteredForRender = false;
|
||
|
fNeedCleanup = false;
|
||
|
|
||
|
fOptimized = true;
|
||
|
|
||
|
fSettingMatIdxLock = false;
|
||
|
|
||
|
fSkinTime = 0;
|
||
|
|
||
|
fType = kNormal;
|
||
|
fMaterials.Reset();
|
||
|
|
||
|
fLocalToWorld.Reset();
|
||
|
fWorldToLocal.Reset();
|
||
|
|
||
|
fVisSet.SetBit(0);
|
||
|
}
|
||
|
|
||
|
plDrawableSpans::~plDrawableSpans()
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
|
||
|
for( i = 0; i < fGroups.GetCount(); i++ )
|
||
|
{
|
||
|
delete fGroups[ i ];
|
||
|
}
|
||
|
fGroups.Reset();
|
||
|
|
||
|
/// Loop and delete both our types of spans
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
fSpans[ i ]->Destroy();
|
||
|
fSpans.Reset();
|
||
|
fIcicles.Reset();
|
||
|
fParticleSpans.Reset();
|
||
|
|
||
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
delete fSourceSpans[ i ];
|
||
|
fSourceSpans.Reset();
|
||
|
|
||
|
/// Loop and unref our materials
|
||
|
if( GetKey() != nil )
|
||
|
{
|
||
|
for( i = 0; i < fMaterials.GetCount(); i++ )
|
||
|
{
|
||
|
if( fMaterials[ i ] != nil && fMaterials[ i ]->GetKey() != nil )
|
||
|
GetKey()->Release( fMaterials[ i ]->GetKey() );
|
||
|
}
|
||
|
}
|
||
|
fMaterials.Reset();
|
||
|
|
||
|
delete fSpaceTree;
|
||
|
|
||
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
delete fDIIndices[ i ];
|
||
|
fDIIndices.Reset();
|
||
|
|
||
|
if( fRegisteredForRecreate )
|
||
|
plgDispatch::Dispatch()->UnRegisterForExactType( plDeviceRecreateMsg::Index(), GetKey() );
|
||
|
|
||
|
if( fRegisteredForRender )
|
||
|
plgDispatch::Dispatch()->UnRegisterForExactType( plRenderMsg::Index(), GetKey() );
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::SetKey(plKey k)
|
||
|
{
|
||
|
hsKeyedObject::SetKey(k);
|
||
|
if( k )
|
||
|
{
|
||
|
fRegisteredForRecreate = true;
|
||
|
plgDispatch::Dispatch()->RegisterForExactType(plDeviceRecreateMsg::Index(), GetKey());
|
||
|
plgDispatch::Dispatch()->RegisterForExactType(plPipeGeoMakeMsg::Index(), GetKey());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//// ChangeSceneNode /////////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::SetSceneNode( plKey newNode )
|
||
|
{
|
||
|
plKey curNode=GetSceneNode();
|
||
|
if( curNode == newNode )
|
||
|
return;
|
||
|
if( newNode )
|
||
|
{
|
||
|
plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(newNode, plNodeRefMsg::kOnRequest, -1, plNodeRefMsg::kDrawable);
|
||
|
hsgResMgr::ResMgr()->SendRef(GetKey(), refMsg, plRefFlags::kActiveRef);
|
||
|
}
|
||
|
if( curNode )
|
||
|
{
|
||
|
curNode->Release(GetKey());
|
||
|
}
|
||
|
fSceneNode = newNode;
|
||
|
}
|
||
|
|
||
|
//// PrepForRender ///////////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::PrepForRender( plPipeline *p )
|
||
|
{
|
||
|
/// If we're not registered for this message, register for it so we know when
|
||
|
/// we need to refresh the buffers
|
||
|
if( !fRegisteredForRecreate && GetKey() != nil )
|
||
|
{
|
||
|
fRegisteredForRecreate = true;
|
||
|
plgDispatch::Dispatch()->RegisterForExactType( plDeviceRecreateMsg::Index(), GetKey() );
|
||
|
}
|
||
|
|
||
|
if( !fReadyToRender )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
|
||
|
for( i = 0; i < fGroups.GetCount(); i++ )
|
||
|
{
|
||
|
// Each group will decide whether it needs to be prepped
|
||
|
fGroups[ i ]->PrepForRendering( p, false );
|
||
|
}
|
||
|
|
||
|
fReadyToRender = true;
|
||
|
}
|
||
|
|
||
|
if( fParticleSpans.GetCount() )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
#if 0
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[ i ]->fTypeMask & plSpan::kParticleSpan )
|
||
|
{
|
||
|
plParticleSpan* span = (plParticleSpan*)fSpans[i];
|
||
|
|
||
|
plParticleFiller::FillParticles(p, this, span);
|
||
|
}
|
||
|
}
|
||
|
#else
|
||
|
for( i = 0; i < fParticleSpans.GetCount(); i++ )
|
||
|
{
|
||
|
plParticleFiller::FillParticles(p, this, &fParticleSpans[i]);
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::SetDISpanVisSet(UInt32 diIndex, hsKeyedObject* ref, hsBool on)
|
||
|
{
|
||
|
// Could actually do something here to neutralize bones, but we're not.
|
||
|
// Main thing is that if it's Matrix Only, then the indices are into
|
||
|
// the LocalToWorlds, not into fSpans
|
||
|
if( fDIIndices[diIndex]->IsMatrixOnly() )
|
||
|
return;
|
||
|
|
||
|
plVisRegion* reg = plVisRegion::ConvertNoRef(ref);
|
||
|
if( !reg )
|
||
|
return;
|
||
|
hsBool isNot = reg->GetProperty(plVisRegion::kIsNot);
|
||
|
UInt32 visRegIndex = reg->GetIndex();
|
||
|
|
||
|
if( isNot )
|
||
|
{
|
||
|
fVisNot.SetBit(visRegIndex, on);
|
||
|
int i;
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->SetVisNot(visRegIndex, on);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fVisSet.SetBit(visRegIndex, on);
|
||
|
int i;
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->SetVisBit(visRegIndex, on);
|
||
|
|
||
|
// HACKAGE
|
||
|
// We need to be more careful about when we set and clear this bit,
|
||
|
// but not today.
|
||
|
// Okay, today. mf
|
||
|
if( reg->ReplaceNormal() )
|
||
|
fSpans[spanIndex]->SetVisBit(plVisMgr::kNormal, false);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::SetVisSet(plVisMgr* visMgr)
|
||
|
{
|
||
|
plProfile_Extern(VisSelect);
|
||
|
plProfile_BeginTiming(VisSelect);
|
||
|
if( visMgr )
|
||
|
{
|
||
|
const hsBitVector& visSet = visMgr->GetVisSet();
|
||
|
const hsBitVector& visNot = visMgr->GetVisNot();
|
||
|
|
||
|
// Go through some contortions to not be new[]'ing and delete[]'ing.
|
||
|
static hsBitVector myVis;
|
||
|
static hsBitVector myNot;
|
||
|
|
||
|
// myVis = (visSet ^ fLastVisSet) & fVisSet;
|
||
|
myVis = visSet;
|
||
|
myVis ^= fLastVisSet;
|
||
|
myVis &= fVisSet;
|
||
|
|
||
|
// myNot = (visNot ^ fLastVisNot) & fVisNot;
|
||
|
myNot = visNot;
|
||
|
myNot ^= fLastVisNot;
|
||
|
myNot &= fVisNot;
|
||
|
|
||
|
// myVis = myVis | myNot
|
||
|
myVis |= myNot;
|
||
|
|
||
|
GetSpaceTree()->SetCache(&fVisCache);
|
||
|
if( !myVis.Empty() )
|
||
|
{
|
||
|
fVisCache.Clear();
|
||
|
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( !fSpans[i]->GetVisNot().Overlap(visNot) && fSpans[i]->GetVisSet().Overlap(visSet) )
|
||
|
{
|
||
|
GetSpaceTree()->EnableLeaf(i, fVisCache);
|
||
|
}
|
||
|
}
|
||
|
fLastVisSet = visSet;
|
||
|
fLastVisNot = visNot;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GetSpaceTree()->SetCache(nil);
|
||
|
}
|
||
|
plProfile_EndTiming(VisSelect);
|
||
|
}
|
||
|
|
||
|
// Here's the problem. When we update one of the matrices in the matrix palette,
|
||
|
// we've invalidated the current bounds of all the spans that use it. The skinning
|
||
|
// matrix may have moved the spans, or may just have stretched them, but either
|
||
|
// way, they aren't right any more. Wait, it gets worse. We're going to have a bunch
|
||
|
// of SetTransform calls come in, and then some time later, without our knowledge,
|
||
|
// our bounds (via the space tree and PageTreeMgr) will be used to evaluate whether
|
||
|
// to bother drawing us. Clearly, if we're going to keep our bounds up to date, we
|
||
|
// want to wait until all the SetTransforms have come in, and then update our bounds
|
||
|
// all at once, but before the visibility determination phase kicks in.
|
||
|
// The alternative is to make the local bounds conservative. We bloat out the local
|
||
|
// bounds on export so that whereever the skinning matrices push us around, we're
|
||
|
// still inside the local bounds. This is certainly cheaper to compute (all computation
|
||
|
// is offline), but gives a less tight bounds. Whether the conservative bounds is
|
||
|
// tight enough will depend on how the skinning is actually being used.
|
||
|
//
|
||
|
// Therefore I'm deferring decision on which way to go, and putting in this temp hack
|
||
|
// which does it the dumbest way possible while still being correct.
|
||
|
//
|
||
|
// So recap:
|
||
|
// If we need tight up-to-date bounds, we'll probably send a system message between
|
||
|
// the update phase (Eval Msg) and the render phase, only marking as dirty the changed
|
||
|
// palette matrices.
|
||
|
// If conservative bounds are good enough, we'll need to compute those from the skinning
|
||
|
// animations offline.
|
||
|
void plDrawableSpans::IUpdateMatrixPaletteBoundsHack()
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[i]->fNumMatrices && !(fSpans[i]->fProps & plSpan::kPropNoDraw) )
|
||
|
{
|
||
|
hsBounds3Ext bnd = fSpans[i]->fLocalBounds;
|
||
|
const hsMatrix44& xfm0 = fSpans[i]->fMaxBoneIdx ? fLocalToWorlds[fSpans[i]->fBaseMatrix + fSpans[i]->fMaxBoneIdx] : fSpans[i]->fLocalToWorld;
|
||
|
bnd.Transform(&xfm0);
|
||
|
fSpans[i]->fWorldBounds = bnd;
|
||
|
|
||
|
bnd = fSpans[i]->fLocalBounds;
|
||
|
const hsMatrix44& xfm1 = fSpans[i]->fPenBoneIdx ? fLocalToWorlds[fSpans[i]->fBaseMatrix + fSpans[i]->fPenBoneIdx] : fSpans[i]->fLocalToWorld;
|
||
|
bnd.Transform(&xfm1);
|
||
|
fSpans[i]->fWorldBounds.Union(&bnd);
|
||
|
|
||
|
GetSpaceTree()->MoveLeaf(i, fSpans[i]->fWorldBounds);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
hsBool plDrawableSpans::IBoundsInvalid(const hsBounds3Ext& bnd) const
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < 3; i++ )
|
||
|
{
|
||
|
const hsScalar kLimit(1.e5f);
|
||
|
|
||
|
if( bnd.GetMaxs()[i] > kLimit )
|
||
|
return true;
|
||
|
if( bnd.GetMins()[i] < -kLimit )
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//// SetTransform ////////////////////////////////////////////////////////////
|
||
|
|
||
|
static inline hsMatrix44 IMatrixMul34(const hsMatrix44& lhs, const hsMatrix44& rhs)
|
||
|
{
|
||
|
hsMatrix44 ret;
|
||
|
ret.NotIdentity();
|
||
|
ret.fMap[3][0] = ret.fMap[3][1] = ret.fMap[3][2] = 0;
|
||
|
ret.fMap[3][3] = 1.f;
|
||
|
|
||
|
ret.fMap[0][0] = lhs.fMap[0][0] * rhs.fMap[0][0]
|
||
|
+ lhs.fMap[0][1] * rhs.fMap[1][0]
|
||
|
+ lhs.fMap[0][2] * rhs.fMap[2][0];
|
||
|
|
||
|
ret.fMap[0][1] = lhs.fMap[0][0] * rhs.fMap[0][1]
|
||
|
+ lhs.fMap[0][1] * rhs.fMap[1][1]
|
||
|
+ lhs.fMap[0][2] * rhs.fMap[2][1];
|
||
|
|
||
|
ret.fMap[0][2] = lhs.fMap[0][0] * rhs.fMap[0][2]
|
||
|
+ lhs.fMap[0][1] * rhs.fMap[1][2]
|
||
|
+ lhs.fMap[0][2] * rhs.fMap[2][2];
|
||
|
|
||
|
ret.fMap[0][3] = lhs.fMap[0][0] * rhs.fMap[0][3]
|
||
|
+ lhs.fMap[0][1] * rhs.fMap[1][3]
|
||
|
+ lhs.fMap[0][2] * rhs.fMap[2][3]
|
||
|
+ lhs.fMap[0][3];
|
||
|
|
||
|
ret.fMap[1][0] = lhs.fMap[1][0] * rhs.fMap[0][0]
|
||
|
+ lhs.fMap[1][1] * rhs.fMap[1][0]
|
||
|
+ lhs.fMap[1][2] * rhs.fMap[2][0];
|
||
|
|
||
|
ret.fMap[1][1] = lhs.fMap[1][0] * rhs.fMap[0][1]
|
||
|
+ lhs.fMap[1][1] * rhs.fMap[1][1]
|
||
|
+ lhs.fMap[1][2] * rhs.fMap[2][1];
|
||
|
|
||
|
ret.fMap[1][2] = lhs.fMap[1][0] * rhs.fMap[0][2]
|
||
|
+ lhs.fMap[1][1] * rhs.fMap[1][2]
|
||
|
+ lhs.fMap[1][2] * rhs.fMap[2][2];
|
||
|
|
||
|
ret.fMap[1][3] = lhs.fMap[1][0] * rhs.fMap[0][3]
|
||
|
+ lhs.fMap[1][1] * rhs.fMap[1][3]
|
||
|
+ lhs.fMap[1][2] * rhs.fMap[2][3]
|
||
|
+ lhs.fMap[1][3];
|
||
|
|
||
|
ret.fMap[2][0] = lhs.fMap[2][0] * rhs.fMap[0][0]
|
||
|
+ lhs.fMap[2][1] * rhs.fMap[1][0]
|
||
|
+ lhs.fMap[2][2] * rhs.fMap[2][0];
|
||
|
|
||
|
ret.fMap[2][1] = lhs.fMap[2][0] * rhs.fMap[0][1]
|
||
|
+ lhs.fMap[2][1] * rhs.fMap[1][1]
|
||
|
+ lhs.fMap[2][2] * rhs.fMap[2][1];
|
||
|
|
||
|
ret.fMap[2][2] = lhs.fMap[2][0] * rhs.fMap[0][2]
|
||
|
+ lhs.fMap[2][1] * rhs.fMap[1][2]
|
||
|
+ lhs.fMap[2][2] * rhs.fMap[2][2];
|
||
|
|
||
|
ret.fMap[2][3] = lhs.fMap[2][0] * rhs.fMap[0][3]
|
||
|
+ lhs.fMap[2][1] * rhs.fMap[1][3]
|
||
|
+ lhs.fMap[2][2] * rhs.fMap[2][3]
|
||
|
+ lhs.fMap[2][3];
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
#include "../plStatusLog/plStatusLog.h"
|
||
|
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_CreateCounter("DSSetTrans", "Update", DSSetTrans);
|
||
|
plProfile_CreateCounter("DSMatSpans", "Update", DSMatSpans);
|
||
|
plProfile_CreateCounter("DSRegSpans", "Update", DSRegSpans);
|
||
|
|
||
|
plProfile_CreateTimer("DSSetTransT", "Update", DSSetTransT);
|
||
|
plProfile_CreateTimer("DSMatTransT", "Update", DSMatTransT);
|
||
|
plProfile_CreateTimer("DSRegTransT", "Update", DSRegTransT);
|
||
|
plProfile_CreateTimer("DSBndTransT", "Update", DSBndTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
|
||
|
|
||
|
plDrawable& plDrawableSpans::SetTransform( UInt32 index, const hsMatrix44& l2w, const hsMatrix44& w2l )
|
||
|
{
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_IncCount(DSSetTrans, 1);
|
||
|
plProfile_BeginTiming(DSSetTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
|
||
|
if( index == (UInt32)-1 )
|
||
|
{
|
||
|
fLocalToWorld = l2w;
|
||
|
fWorldToLocal = w2l;
|
||
|
|
||
|
fWorldBounds = fLocalBounds;
|
||
|
fWorldBounds.Transform( &l2w );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int i;
|
||
|
UInt32 idx;
|
||
|
plDISpanIndex *spans = fDIIndices[ index ];
|
||
|
|
||
|
|
||
|
if( spans->IsMatrixOnly() )
|
||
|
{
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_IncCount(DSMatSpans, spans->GetCount());
|
||
|
plProfile_BeginTiming(DSMatTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
{
|
||
|
#if 0
|
||
|
fLocalToWorlds[ (*spans)[ i ] ] = l2w * fLocalToBones[ (*spans)[ i ] ];
|
||
|
fWorldToLocals[ (*spans)[ i ] ] = fBoneToLocals[ (*spans)[ i ] ] * w2l;
|
||
|
#else
|
||
|
fLocalToWorlds[ (*spans)[ i ] ] = IMatrixMul34(l2w, fLocalToBones[ (*spans)[ i ] ]);
|
||
|
fWorldToLocals[ (*spans)[ i ] ] = IMatrixMul34(fBoneToLocals[ (*spans)[ i ] ], w2l);
|
||
|
#endif
|
||
|
}
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_EndTiming(DSMatTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
}
|
||
|
else if( !spans->DontTransform() )
|
||
|
{
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_IncCount(DSRegSpans, spans->GetCount());
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
{
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_BeginTiming(DSRegTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
|
||
|
idx = (*spans)[ i ];
|
||
|
plSpan *mSpan = fSpans[ idx ];
|
||
|
mSpan->fLocalToWorld = l2w;
|
||
|
mSpan->fWorldToLocal = w2l;
|
||
|
|
||
|
mSpan->fWorldBounds = mSpan->fLocalBounds;
|
||
|
mSpan->fWorldBounds.Transform( &l2w );
|
||
|
|
||
|
if( fSourceSpans.GetCount() > idx )
|
||
|
{
|
||
|
/// If we have a geoSpan for this, update its transform as well,
|
||
|
/// just in case we need to use it later (<cough> SceneViewer reshade <cough>)
|
||
|
if( fSourceSpans[ idx ] == nil )
|
||
|
{
|
||
|
plStatusLog::AddLineS( "pipeline.log", 0xffffffff, "Nil source spans found in SetTransform()" );
|
||
|
}
|
||
|
|
||
|
fSourceSpans[ idx ]->fLocalToWorld = l2w;
|
||
|
fSourceSpans[ idx ]->fWorldToLocal = w2l;
|
||
|
}
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_EndTiming(DSRegTransT);
|
||
|
|
||
|
plProfile_BeginTiming(DSBndTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
if( IBoundsInvalid(mSpan->fWorldBounds) )
|
||
|
{
|
||
|
mSpan->fProps |= kPropNoDraw;
|
||
|
GetSpaceTree()->SetLeafFlag((Int16)idx, plSpaceTreeNode::kDisabled, true);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GetSpaceTree()->MoveLeaf((Int16)((*spans)[i]), mSpan->fWorldBounds);
|
||
|
}
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_EndTiming(DSBndTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_BeginTiming(DSBndTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
fWorldBounds = GetSpaceTree()->GetNode(GetSpaceTree()->GetRoot()).GetWorldBounds();
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_EndTiming(DSBndTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
}
|
||
|
|
||
|
#ifdef MF_TEST_UPDATE
|
||
|
plProfile_EndTiming(DSSetTransT);
|
||
|
#endif // MF_TEST_UPDATE
|
||
|
// Might want to assert that MaxWorldBounds still contains WorldBounds.
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::SetNativeTransform(UInt32 idx, const hsMatrix44& l2w, const hsMatrix44& w2l)
|
||
|
{
|
||
|
if( idx == UInt32(-1) )
|
||
|
{
|
||
|
hsAssert(false, "Invalid index to SetNativeTransform");
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
plSpan* span = fSpans[idx];
|
||
|
span->fLocalToWorld = l2w;
|
||
|
span->fWorldToLocal = w2l;
|
||
|
|
||
|
span->fWorldBounds = span->fLocalBounds;
|
||
|
span->fWorldBounds.Transform(&l2w);
|
||
|
|
||
|
if( fSourceSpans.GetCount() > idx )
|
||
|
{
|
||
|
fSourceSpans[idx]->fLocalToWorld = l2w;
|
||
|
fSourceSpans[idx]->fWorldToLocal = w2l;
|
||
|
}
|
||
|
|
||
|
if( IBoundsInvalid(span->fWorldBounds) )
|
||
|
{
|
||
|
SetNativeProperty( idx, kPropNoDraw, true);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GetSpaceTree()->MoveLeaf((Int16)idx, span->fWorldBounds);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//// GetLocalToWorld & GetWorldToLocal ///////////////////////////////////////
|
||
|
|
||
|
const hsMatrix44& plDrawableSpans::GetLocalToWorld( UInt32 span ) const
|
||
|
{
|
||
|
if( span == (UInt32)-1 )
|
||
|
return fLocalToWorld;
|
||
|
|
||
|
return fSpans[ span ]->fLocalToWorld;
|
||
|
}
|
||
|
|
||
|
const hsMatrix44& plDrawableSpans::GetWorldToLocal( UInt32 span ) const
|
||
|
{
|
||
|
if( span == (UInt32)-1 )
|
||
|
return fWorldToLocal;
|
||
|
|
||
|
return fSpans[ span ]->fWorldToLocal;
|
||
|
}
|
||
|
|
||
|
|
||
|
//// Set/GetNativeProperty ///////////////////////////////////////////////////
|
||
|
|
||
|
plDrawable& plDrawableSpans::SetNativeProperty( UInt32 index, int prop, hsBool on)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
|
||
|
if( index == (UInt32)-1 )
|
||
|
{
|
||
|
hsAssert(false, "Invalid index to SetNativeProperty");
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
plDISpanIndex *spans = fDIIndices[ index ];
|
||
|
|
||
|
if( !spans->IsMatrixOnly() )
|
||
|
{
|
||
|
if( on )
|
||
|
{
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
fSpans[ (*spans)[ i ] ]->fProps |= prop;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
fSpans[ (*spans)[ i ] ]->fProps &= ~prop;
|
||
|
}
|
||
|
if( (prop & kPropNoDraw) )
|
||
|
{
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
GetSpaceTree()->SetLeafFlag((Int16)((*spans)[ i ]), plSpaceTreeNode::kDisabled, on);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
hsBool plDrawableSpans::GetNativeProperty( UInt32 index, int prop ) const
|
||
|
{
|
||
|
int i;
|
||
|
UInt32 ret = false;
|
||
|
|
||
|
|
||
|
if( index == (UInt32)-1 )
|
||
|
{
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
ret |= ( fSpans[ i ]->fProps & prop );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
plDISpanIndex& spans = *fDIIndices[ index ];
|
||
|
|
||
|
if( !spans.IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
ret |= ( fSpans[ spans[ i ] ]->fProps & prop );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return ret != 0;
|
||
|
}
|
||
|
|
||
|
plDrawable& plDrawableSpans::SetSubType(UInt32 index, plSubDrawableType t, hsBool on)
|
||
|
{
|
||
|
if( UInt32(-1) == index )
|
||
|
{
|
||
|
if( on )
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
fSpans[i]->fSubType |= t;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
fSpans[i]->fSubType &= ~t;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
plDISpanIndex& spans = *fDIIndices[ index ];
|
||
|
|
||
|
if( on )
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
fSpans[ spans[i] ]->fSubType |= t;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
fSpans[ spans[i] ]->fSubType &= ~t;
|
||
|
}
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
UInt32 plDrawableSpans::GetSubType(UInt32 index) const
|
||
|
{
|
||
|
UInt32 retVal = 0;
|
||
|
|
||
|
if( UInt32(-1) == index )
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
retVal |= fSpans[i]->fSubType;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
plDISpanIndex& spans = *fDIIndices[ index ];
|
||
|
|
||
|
int i;
|
||
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
retVal |= fSpans[ spans[i] ]->fSubType;
|
||
|
}
|
||
|
return retVal;
|
||
|
}
|
||
|
|
||
|
//// IXlateSpanProps /////////////////////////////////////////////////////////
|
||
|
// Never used yet--just here in case we ever need it
|
||
|
|
||
|
UInt32 plDrawableSpans::IXlateSpanProps( UInt32 props, hsBool xlateToSpan )
|
||
|
{
|
||
|
UInt32 retProps = 0;
|
||
|
|
||
|
|
||
|
if( xlateToSpan )
|
||
|
{
|
||
|
/// Drawable props to plSpan props
|
||
|
if( props & kPropNoDraw ) retProps |= plSpan::kPropNoDraw;
|
||
|
if( props & kPropSortFaces ) retProps |= plSpan::kPropFacesSortable;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/// plSpan props to Drawable props
|
||
|
if( props & plSpan::kPropNoDraw ) retProps |= kPropNoDraw;
|
||
|
if( props & plSpan::kPropFacesSortable ) retProps |= kPropSortFaces;
|
||
|
}
|
||
|
|
||
|
return retProps;
|
||
|
}
|
||
|
|
||
|
//// Set/GetProperty /////////////////////////////////////////////////////////
|
||
|
// Sets/gets a property just like the normal Set/GetNativeProperty, but the
|
||
|
// flag taken in is from plDrawInterface, not our props flags. So we have to
|
||
|
// translate...
|
||
|
|
||
|
plDrawable& plDrawableSpans::SetProperty( UInt32 index, int diProp, hsBool on )
|
||
|
{
|
||
|
switch( diProp )
|
||
|
{
|
||
|
case plDrawInterface::kDisable:
|
||
|
return SetNativeProperty( index, kPropNoDraw, on );
|
||
|
default:
|
||
|
hsAssert( false, "Bad property passed to SetProperty" );
|
||
|
}
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
hsBool plDrawableSpans::GetProperty( UInt32 index, int diProp ) const
|
||
|
{
|
||
|
switch( diProp )
|
||
|
{
|
||
|
case plDrawInterface::kDisable:
|
||
|
return GetNativeProperty( index, kPropNoDraw );
|
||
|
default:
|
||
|
hsAssert( false, "Bad property passed to SetProperty" );
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
plDrawable& plDrawableSpans::SetProperty( int prop, hsBool on )
|
||
|
{
|
||
|
switch( prop )
|
||
|
{
|
||
|
case plDrawInterface::kDisable:
|
||
|
{
|
||
|
int i;
|
||
|
for (i=0; i<fIcicles.Count(); i++)
|
||
|
if (on)
|
||
|
fIcicles[i].fProps |= kPropNoDraw;
|
||
|
else
|
||
|
fIcicles[i].fProps &= ~kPropNoDraw;
|
||
|
IQuickSpaceTree();
|
||
|
}
|
||
|
return SetNativeProperty( kPropNoDraw, on );
|
||
|
default:
|
||
|
hsAssert( false, "Bad property passed to SetProperty" );
|
||
|
}
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
hsBool plDrawableSpans::GetProperty( int prop ) const
|
||
|
{
|
||
|
switch( prop )
|
||
|
{
|
||
|
case plDrawInterface::kDisable:
|
||
|
return GetNativeProperty( kPropNoDraw );
|
||
|
default:
|
||
|
hsAssert( false, "Bad property passed to SetProperty" );
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
//// Get*Bounds //////////////////////////////////////////////////////////////
|
||
|
|
||
|
const hsBounds3Ext& plDrawableSpans::GetLocalBounds( UInt32 index ) const
|
||
|
{
|
||
|
int i;
|
||
|
static hsBounds3Ext bnd;
|
||
|
|
||
|
|
||
|
if( index == (UInt32)-1 )
|
||
|
return fLocalBounds;
|
||
|
|
||
|
plDISpanIndex *spans = fDIIndices[ index ];
|
||
|
|
||
|
bnd.MakeEmpty();
|
||
|
if( !spans->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
{
|
||
|
bnd.Union( &fSpans[ (*spans)[ i ] ]->fLocalBounds );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return bnd;
|
||
|
}
|
||
|
|
||
|
const hsBounds3Ext& plDrawableSpans::GetWorldBounds( UInt32 index ) const
|
||
|
{
|
||
|
int i;
|
||
|
static hsBounds3Ext bnd;
|
||
|
|
||
|
|
||
|
if( index == (UInt32)-1 )
|
||
|
return fWorldBounds;
|
||
|
|
||
|
plDISpanIndex *spans = fDIIndices[ index ];
|
||
|
|
||
|
bnd.MakeEmpty();
|
||
|
if( !spans->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < spans->GetCount(); i++ )
|
||
|
{
|
||
|
bnd.Union( &fSpans[ (*spans)[ i ] ]->fWorldBounds );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return bnd;
|
||
|
}
|
||
|
|
||
|
const hsBounds3Ext& plDrawableSpans::GetMaxWorldBounds( UInt32 index ) const
|
||
|
{
|
||
|
return GetWorldBounds( index );
|
||
|
}
|
||
|
|
||
|
//// Read ////////////////////////////////////////////////////////////////////
|
||
|
// We read each in the array of icicles,
|
||
|
// then we read in an array of indices that we translate into
|
||
|
// pointers. Note: since materials and fog environments are shared,
|
||
|
// we read those keys last, so we don't have to have separate messages for
|
||
|
// each.
|
||
|
|
||
|
void plDrawableSpans::Read( hsStream* s, hsResMgr* mgr )
|
||
|
{
|
||
|
UInt32 i, j, count, count2;
|
||
|
hsBool gotSkin = false;
|
||
|
plGBufferGroup *group;
|
||
|
plRefMsg *refMsg;
|
||
|
|
||
|
|
||
|
plDrawable::Read(s, mgr);
|
||
|
|
||
|
fProps = s->ReadSwap32();
|
||
|
fCriteria = s->ReadSwap32();
|
||
|
fRenderLevel.fLevel = s->ReadSwap32();
|
||
|
|
||
|
/// Read in the material keys
|
||
|
count = s->ReadSwap32();
|
||
|
fMaterials.SetCountAndZero( count );
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
refMsg = TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, i, kMsgMaterial );
|
||
|
mgr->ReadKeyNotifyMe( s, refMsg, plRefFlags::kActiveRef );
|
||
|
}
|
||
|
|
||
|
/// Read the icicles in
|
||
|
count = s->ReadSwap32();
|
||
|
fIcicles.SetCount( count );
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
fIcicles[ i ].Read( s );
|
||
|
if( fIcicles[ i ].fNumMatrices )
|
||
|
gotSkin = true;
|
||
|
}
|
||
|
|
||
|
/// Read the patches in
|
||
|
// FIXME MAJOR VERSION
|
||
|
// no more patches, remove this line
|
||
|
count = s->ReadSwap32();
|
||
|
|
||
|
/// Now read the index array in and use it to create a pointer table
|
||
|
fSpanSourceIndices.Reset();
|
||
|
fSpans.Reset();
|
||
|
count = s->ReadSwap32();
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
j = s->ReadSwap32();
|
||
|
switch( j & kSpanTypeMask )
|
||
|
{
|
||
|
case kSpanTypeIcicle: fSpans.Append( (plSpan *)&fIcicles[ j & kSpanIDMask ] ); break;
|
||
|
case kSpanTypeParticleSpan: fSpans.Append( (plSpan *)&fParticleSpans[ j & kSpanIDMask ] ); break;
|
||
|
}
|
||
|
|
||
|
fSpanSourceIndices.Append( j );
|
||
|
|
||
|
if( fSpans[ fSpans.GetCount() - 1 ]->fTypeMask & plSpan::kParticleSpan )
|
||
|
{
|
||
|
plParticleSpan *span = (plParticleSpan *)fSpans[ fSpans.GetCount() - 1 ];
|
||
|
span->fSrcSpanIdx = fSpans.GetCount() - 1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Rebuild bit vectors for various span types
|
||
|
IBuildVectors();
|
||
|
|
||
|
/// Now that we have our pointer array, read in the common keys (fog environs, etc)
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
// Ref message for the fog environment
|
||
|
refMsg = TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, i, kMsgFogEnviron );
|
||
|
mgr->ReadKeyNotifyMe( s, refMsg, plRefFlags::kActiveRef );
|
||
|
}
|
||
|
|
||
|
/// Read in bounds and stuff
|
||
|
if( count > 0 )
|
||
|
{
|
||
|
fLocalBounds.Read(s);
|
||
|
fWorldBounds.Read(s);
|
||
|
fMaxWorldBounds.Read(s);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fLocalBounds.MakeEmpty();
|
||
|
fWorldBounds.MakeEmpty();
|
||
|
fMaxWorldBounds.MakeEmpty();
|
||
|
}
|
||
|
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
if( fSpans[i]->fProps & plSpan::kPropHasPermaLights )
|
||
|
{
|
||
|
UInt32 lcnt = s->ReadSwap32();
|
||
|
int j;
|
||
|
for( j = 0; j < lcnt; j++ )
|
||
|
{
|
||
|
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, kMsgPermaLight), plRefFlags::kPassiveRef);
|
||
|
}
|
||
|
}
|
||
|
if( fSpans[i]->fProps & plSpan::kPropHasPermaProjs )
|
||
|
{
|
||
|
UInt32 lcnt = s->ReadSwap32();
|
||
|
int j;
|
||
|
for( j = 0; j < lcnt; j++ )
|
||
|
{
|
||
|
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, kMsgPermaProj), plRefFlags::kPassiveRef);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Read in the source spans if necessary
|
||
|
count = s->ReadSwap32();
|
||
|
if( count > 0 )
|
||
|
{
|
||
|
fSourceSpans.SetCount( count );
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
fSourceSpans[ i ] = TRACKED_NEW plGeometrySpan;
|
||
|
fSourceSpans[ i ]->Read( s );
|
||
|
fSourceSpans[ i ]->fMaterial = GetMaterial( fSpans[ i ]->fMaterialIdx );
|
||
|
fSourceSpans[ i ]->fFogEnviron = fSpans[ i ]->fFogEnvironment;
|
||
|
fSourceSpans[ i ]->fSpanRefIndex = i;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
fSourceSpans.Reset();
|
||
|
|
||
|
/// Read in the matrix palette (if any)
|
||
|
count = s->ReadSwap32();
|
||
|
fLocalToWorlds.SetCount(count);
|
||
|
fWorldToLocals.SetCount(count);
|
||
|
fLocalToBones.SetCount(count);
|
||
|
fBoneToLocals.SetCount(count);
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
fLocalToWorlds[i].Read(s);
|
||
|
fWorldToLocals[i].Read(s);
|
||
|
|
||
|
fLocalToBones[i].Read(s);
|
||
|
fBoneToLocals[i].Read(s);
|
||
|
}
|
||
|
|
||
|
/// Read in the drawInterface index arrays
|
||
|
count = s->ReadSwap32();
|
||
|
fDIIndices.SetCountAndZero( count );
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
fDIIndices[ i ] = TRACKED_NEW plDISpanIndex;
|
||
|
|
||
|
fDIIndices[ i ]->fFlags = (UInt8)(s->ReadSwap32());
|
||
|
count2 = s->ReadSwap32();
|
||
|
fDIIndices[ i ]->SetCountAndZero( count2 );
|
||
|
for( j = 0; j < count2; j++ )
|
||
|
(*fDIIndices[ i ])[ j ] = s->ReadSwap32();
|
||
|
}
|
||
|
|
||
|
/// Read the groups in
|
||
|
count = s->ReadSwap32();
|
||
|
while( count-- )
|
||
|
{
|
||
|
group = TRACKED_NEW plGBufferGroup(0, fProps & kPropVolatile, fProps & kPropSortFaces);
|
||
|
group->Read( s );
|
||
|
|
||
|
fGroups.Append( group );
|
||
|
|
||
|
}
|
||
|
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
IMakeSpanSortable(i);
|
||
|
}
|
||
|
|
||
|
/// Other stuff now
|
||
|
fSpaceTree = plSpaceTree::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
|
||
|
fSceneNode = mgr->ReadKey(s);
|
||
|
plNodeRefMsg* nRefMsg = TRACKED_NEW plNodeRefMsg(fSceneNode, plRefMsg::kOnCreate, -1, plNodeRefMsg::kDrawable);
|
||
|
mgr->AddViaNotify(GetKey(), nRefMsg, plRefFlags::kActiveRef);
|
||
|
|
||
|
if( GetNativeProperty(plDrawable::kPropCharacter) )
|
||
|
{
|
||
|
fVisSet.SetBit(plVisMgr::kCharacter, true);
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
fSpans[i]->SetVisBit(plVisMgr::kCharacter, true);
|
||
|
}
|
||
|
|
||
|
// Placeholder hack - see IUpdateMatrixPaletteBoundsHack() for comments
|
||
|
if( gotSkin )
|
||
|
{
|
||
|
fRegisteredForRender = true;
|
||
|
plgDispatch::Dispatch()->RegisterForExactType( plRenderMsg::Index(), GetKey() );
|
||
|
}
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
}
|
||
|
|
||
|
//// ITestMatForSpecularity //////////////////////////////////////////////////
|
||
|
|
||
|
hsBool plDrawableSpans::ITestMatForSpecularity( hsGMaterial *mat )
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
|
||
|
for( i = 0; i < mat->GetNumLayers(); i++ )
|
||
|
{
|
||
|
if( mat->GetLayer( i )->GetShadeFlags() && hsGMatState::kShadeSpecular )
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
#include "plProfile.h"
|
||
|
plProfile_CreateTimer("MatrixPalleteHack", "RenderSetup", PalletteHack);
|
||
|
//// MsgReceive //////////////////////////////////////////////////////////////
|
||
|
|
||
|
hsBool plDrawableSpans::MsgReceive( plMessage* msg )
|
||
|
{
|
||
|
plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef( msg );
|
||
|
int i;
|
||
|
hsBool hasSpec;
|
||
|
|
||
|
|
||
|
if( refMsg )
|
||
|
{
|
||
|
if( refMsg->fType == kMsgMaterial )
|
||
|
{
|
||
|
/// Material add/remove on this drawable
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fMaterials.GetCount(), "Invalid material index" );
|
||
|
|
||
|
fMaterials[ refMsg->fWhich ] = hsGMaterial::ConvertNoRef( refMsg->GetRef() );
|
||
|
|
||
|
if( !fSettingMatIdxLock )
|
||
|
{
|
||
|
// Now find all spans with this material and mark them as using or not using specular
|
||
|
hasSpec = ITestMatForSpecularity( fMaterials[ refMsg->fWhich ] );
|
||
|
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[ i ] != nil && fSpans[ i ]->fMaterialIdx == refMsg->fWhich )
|
||
|
{
|
||
|
if( hasSpec )
|
||
|
fSpans[ i ]->fProps |= plSpan::kPropMatHasSpecular;
|
||
|
else
|
||
|
fSpans[ i ]->fProps &= ~plSpan::kPropMatHasSpecular;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fMaterials.GetCount(), "Invalid material index" );
|
||
|
|
||
|
fMaterials[ refMsg->fWhich ] = nil;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
else if( refMsg->fType == kMsgFogEnviron )
|
||
|
{
|
||
|
/// Fog environment add/remove on this drawable
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fSpans.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
|
||
|
fSpans[ refMsg->fWhich ]->fFogEnvironment = plFogEnvironment::ConvertNoRef( refMsg->GetRef() );
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
plFogEnvironment *fog = plFogEnvironment::ConvertNoRef( refMsg->GetRef() );
|
||
|
|
||
|
for( i = 0; i < GetNumSpans(); i++ )
|
||
|
{
|
||
|
if( fSpans[ i ]->fFogEnvironment == fog )
|
||
|
{
|
||
|
fSpans[ i ]->fFogEnvironment = nil;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
else if( refMsg->fType == kMsgPermaLight )
|
||
|
{
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fSpans.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
fSpans[refMsg->fWhich]->AddPermaLight(li, false);
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fSpans.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = (plLightInfo*)refMsg->GetRef();
|
||
|
fSpans[refMsg->fWhich]->RemovePermaLight(li, false);
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
else if( refMsg->fType == kMsgPermaProj )
|
||
|
{
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fSpans.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
fSpans[refMsg->fWhich]->AddPermaLight(li, true);
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fSpans.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = (plLightInfo*)refMsg->GetRef();
|
||
|
fSpans[refMsg->fWhich]->RemovePermaLight(li, true);
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
else if( refMsg->fType == kMsgPermaLightDI )
|
||
|
{
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fDIIndices.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
|
||
|
int diIndex = int(refMsg->fWhich);
|
||
|
if( (diIndex >= 0)
|
||
|
&& !fDIIndices[ diIndex ]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->AddPermaLight(li, false);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fDIIndices.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
|
||
|
int diIndex = int(refMsg->fWhich);
|
||
|
if( (diIndex >= 0)
|
||
|
&& !fDIIndices[ diIndex ]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->RemovePermaLight(li, false);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
else if( refMsg->fType == kMsgPermaProjDI )
|
||
|
{
|
||
|
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fDIIndices.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
|
||
|
int diIndex = int(refMsg->fWhich);
|
||
|
if( (diIndex >= 0)
|
||
|
&& !fDIIndices[ diIndex ]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->AddPermaLight(li, true);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
|
||
|
{
|
||
|
hsAssert( refMsg->fWhich < fDIIndices.GetCount(), "Shesh, send us valid data, will ya??" );
|
||
|
plLightInfo* li = plLightInfo::ConvertNoRef(refMsg->GetRef());
|
||
|
|
||
|
int diIndex = int(refMsg->fWhich);
|
||
|
if( (diIndex >= 0)
|
||
|
&& !fDIIndices[ diIndex ]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( i = 0; i < fDIIndices[ diIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
int spanIndex = (*fDIIndices[diIndex])[i];
|
||
|
fSpans[spanIndex]->RemovePermaLight(li, true);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
else if( plDeviceRecreateMsg::ConvertNoRef( msg ) != nil )
|
||
|
{
|
||
|
/// Device recreation message--just reset our flag so we refresh buffer groups
|
||
|
fReadyToRender = false;
|
||
|
return true;
|
||
|
}
|
||
|
else if( plRenderMsg::ConvertNoRef( msg ) )
|
||
|
{
|
||
|
plProfile_BeginLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName());
|
||
|
|
||
|
IUpdateMatrixPaletteBoundsHack();
|
||
|
|
||
|
// Last thing here. We have a bit list of which of our spans are skinned and
|
||
|
// thus need to be re-blended each frame. However, we don't want to blend them
|
||
|
// multiple times per frame if at all possible. Since the pipeline already checks
|
||
|
// our bitfield, what we *really* do is make a copy and give the pipeline our copy.
|
||
|
// The pipeline will then clear out those bits as it blends them, and then we simply
|
||
|
// re-set them here, since plRenderMsg is sent once before all the rendering is done :)
|
||
|
fFakeBlendingSpanVector = fBlendingSpanVector;
|
||
|
plProfile_EndLap(PalletteHack, this->GetKey()->GetUoid().GetObjectName());
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
plDISpansMsg* diMsg = plDISpansMsg::ConvertNoRef(msg);
|
||
|
if( diMsg )
|
||
|
{
|
||
|
if( diMsg->fType == plDISpansMsg::kRemovingSpan )
|
||
|
{
|
||
|
// If the only set of spans we've got is about to be removed,
|
||
|
// (and we're not flagged to stick around) then just
|
||
|
// kill ourselves entirely.
|
||
|
if( fDIIndices.GetCount() < 2 && !(diMsg->fFlags & plDISpansMsg::kLeaveEmptyDrawable) )
|
||
|
{
|
||
|
hsAssert(diMsg->fIndex + 1 == fDIIndices.GetCount(), "Deleting the an unknown set of indices");
|
||
|
if( GetSceneNode() )
|
||
|
{
|
||
|
GetSceneNode()->Release(GetKey());
|
||
|
}
|
||
|
}
|
||
|
else /// plDrawInterface telling us to remove some spans
|
||
|
{
|
||
|
RemoveDISpans( (Int32)diMsg->fIndex );
|
||
|
}
|
||
|
}
|
||
|
#ifdef HS_DEBUGGING
|
||
|
else if( diMsg->fType == plDISpansMsg::kAddingSpan )
|
||
|
{
|
||
|
/// plDrawInterface telling us which spans it owns
|
||
|
Int32 i, spanIndex = (Int32)diMsg->fIndex;
|
||
|
|
||
|
if( spanIndex == -1 )
|
||
|
return true;
|
||
|
|
||
|
for( i = 0; i < fDIIndices[ spanIndex ]->GetCount(); i++ )
|
||
|
{
|
||
|
if( !fDIIndices[ spanIndex ]->IsMatrixOnly() )
|
||
|
fSpans[ (*fDIIndices[ spanIndex])[ i ] ]->fOwnerKey = diMsg->GetSender();
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
plPipeGeoMakeMsg* make = plPipeGeoMakeMsg::ConvertNoRef(msg);
|
||
|
if( make )
|
||
|
{
|
||
|
fReadyToRender = false;
|
||
|
PrepForRender(make->Pipeline());
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return plDrawable::MsgReceive(msg);
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::SetRenderLevel(const plRenderLevel& l)
|
||
|
{
|
||
|
fRenderLevel = l;
|
||
|
}
|
||
|
|
||
|
const plRenderLevel& plDrawableSpans::GetRenderLevel() const
|
||
|
{
|
||
|
return fRenderLevel;
|
||
|
}
|
||
|
|
||
|
|
||
|
//// DoIMatch ////////////////////////////////////////////////////////////////
|
||
|
// Called by the sceneNode to determine if we match the criteria
|
||
|
|
||
|
hsBool plDrawableSpans::DoIMatch( const plDrawableCriteria& crit )
|
||
|
{
|
||
|
if( crit.fCriteria ^ fCriteria )
|
||
|
return false;
|
||
|
|
||
|
if( crit.fLevel != fRenderLevel )
|
||
|
return false;
|
||
|
|
||
|
if( crit.fType != fType )
|
||
|
return false;
|
||
|
|
||
|
if( crit.fLoadMask != fLoadMask )
|
||
|
return false;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
//// SetCriteria /////////////////////////////////////////////////////////////
|
||
|
// Sets the criteria that this ice matches to. Needed since some ice will
|
||
|
// be static per sceneNode while others wont, etc.
|
||
|
|
||
|
void plDrawableSpans::SetCriteria( const plDrawableCriteria& crit )
|
||
|
{
|
||
|
// Very simple right now. May be more complicated later...
|
||
|
fCriteria = crit.fCriteria;
|
||
|
fRenderLevel = crit.fLevel;
|
||
|
fType = crit.fType;
|
||
|
fLoadMask = crit.fLoadMask;
|
||
|
|
||
|
if( fCriteria & kCritSortSpans )
|
||
|
fProps |= kPropSortSpans;
|
||
|
if( fCriteria & kCritSortFaces )
|
||
|
fProps |= kPropSortFaces;
|
||
|
if( fCriteria & kCritCharacter )
|
||
|
fProps |= kPropCharacter;
|
||
|
}
|
||
|
|
||
|
//// IQuickSpaceTree ///////////////////////////////////////////////////
|
||
|
// Creates a fast, space tree for use at run-time (like in the
|
||
|
// SceneViewer). Any time a space tree is requested but there isn't
|
||
|
// one available, this will be supplied. This is a full featured
|
||
|
// hierarchical bounds which is pretty fast to compute. A more highly
|
||
|
// optimized version may be plugged into the Optimize function at a later
|
||
|
// date if this one doesn't perform enough (it does so far).
|
||
|
|
||
|
void plDrawableSpans::IQuickSpaceTree( void ) const
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
// Make the space tree (hierarchical bounds).
|
||
|
plSpaceTreeMaker maker;
|
||
|
maker.Reset();
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
maker.AddLeaf( fSpans[ i ]->fWorldBounds, fSpans[ i ]->fProps & plSpan::kPropNoDraw );
|
||
|
}
|
||
|
plSpaceTree* tree = maker.MakeTree();
|
||
|
SetSpaceTree(tree);
|
||
|
}
|
||
|
|
||
|
//// SetSpaceTree ////////////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::SetSpaceTree( plSpaceTree *st ) const
|
||
|
{
|
||
|
delete fSpaceTree;
|
||
|
fSpaceTree = st;
|
||
|
fLastVisSet.Clear();
|
||
|
fLastVisNot.Clear();
|
||
|
}
|
||
|
|
||
|
//// GetDISpans //////////////////////////////////////////////////////////////
|
||
|
|
||
|
plDISpanIndex& plDrawableSpans::GetDISpans( UInt32 index ) const
|
||
|
{
|
||
|
return *fDIIndices[index];
|
||
|
}
|
||
|
|
||
|
//// GetVertex/IndexRef //////////////////////////////////////////////////////
|
||
|
|
||
|
hsGDeviceRef *plDrawableSpans::GetVertexRef( UInt32 group, UInt32 idx )
|
||
|
{
|
||
|
return fGroups[ group ]->GetVertexBufferRef( idx );
|
||
|
}
|
||
|
|
||
|
hsGDeviceRef *plDrawableSpans::GetIndexRef( UInt32 group, UInt32 idx )
|
||
|
{
|
||
|
return fGroups[ group ]->GetIndexBufferRef( idx );
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::DirtyVertexBuffer(UInt32 group, UInt32 idx)
|
||
|
{
|
||
|
hsAssert(group < fGroups.GetCount(), "Dirtying vtx buffer I don't have");
|
||
|
GetBufferGroup(group)->DirtyVertexBuffer(idx);
|
||
|
|
||
|
SetNotReadyToRender();
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::DirtyIndexBuffer(UInt32 group, UInt32 idx)
|
||
|
{
|
||
|
hsAssert(group < fGroups.GetCount(), "Dirtying index buffer I don't have");
|
||
|
GetBufferGroup(group)->DirtyIndexBuffer(idx);
|
||
|
|
||
|
SetNotReadyToRender();
|
||
|
}
|
||
|
|
||
|
hsGMaterial* plDrawableSpans::GetSubMaterial(int index) const
|
||
|
{
|
||
|
return GetMaterial(fSpans[index]->fMaterialIdx);
|
||
|
}
|
||
|
|
||
|
// return true if span invisible before minDist and/or after maxDist
|
||
|
hsBool plDrawableSpans::GetSubVisDists(int index, hsScalar& minDist, hsScalar& maxDist) const
|
||
|
{
|
||
|
return (minDist = fSpans[index]->GetMinDist()) < (maxDist = fSpans[index]->GetMaxDist());
|
||
|
}
|
||
|
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
//// Runtime Dynamics ////////////////////////////////////////////////////////
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//// SortSpan ////////////////////////////////////////////////////////////////
|
||
|
// Given the index of the span to sort, sorts the triangles of that span
|
||
|
// based on the sorting data. Note: the span MUST be of type plIcicle.
|
||
|
|
||
|
plProfile_CreateTimer("Face Sort", "Draw", FaceSort);
|
||
|
plProfile_CreateCounter("Face Sort Calls", "Draw", FaceSortCalls);
|
||
|
plProfile_CreateCounter("Faces Sorted", "Draw", FacesSorted);
|
||
|
|
||
|
void plDrawableSpans::SortSpan( UInt32 index, plPipeline *pipe )
|
||
|
{
|
||
|
plProfile_Inc(FaceSortCalls);
|
||
|
|
||
|
plProfile_BeginLap(FaceSort, "0");
|
||
|
|
||
|
plIcicle *span = (plIcicle *)fSpans[ index ];
|
||
|
plGBufferTriangle *list, temp;
|
||
|
UInt32 numTris;
|
||
|
int i;
|
||
|
hsMatrix44 w2cMatrix = pipe->GetWorldToCamera() * pipe->GetLocalToWorld();
|
||
|
hsScalar dist;
|
||
|
|
||
|
ICheckSpanForSortable(index);
|
||
|
|
||
|
static hsTArray<hsRadixSort::Elem> sortList;
|
||
|
static hsTArray<UInt16> tempTriList;
|
||
|
hsRadixSort::Elem *elem;
|
||
|
|
||
|
|
||
|
/// Get some stuff
|
||
|
list = span->fSortData;
|
||
|
numTris = span->fILength / 3;
|
||
|
|
||
|
plProfile_IncCount(FacesSorted, numTris);
|
||
|
|
||
|
hsAssert( numTris > 0, "How could we start sorting no triangles??" );
|
||
|
|
||
|
/// Sort the triangles in "list"
|
||
|
sortList.SetCount( numTris );
|
||
|
tempTriList.SetCount( numTris * 3 );
|
||
|
elem = sortList.AcquireArray();
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
plProfile_BeginLap(FaceSort, "1");
|
||
|
|
||
|
hsVector3 vec(w2cMatrix.fMap[2][0], w2cMatrix.fMap[2][1], w2cMatrix.fMap[2][2]);
|
||
|
hsScalar trans = w2cMatrix.fMap[2][3];
|
||
|
|
||
|
// Fill out the radix sort elements with our data
|
||
|
for( i = 0; i < numTris; i++ )
|
||
|
{
|
||
|
dist = vec.InnerProduct(list[ i ].fCenter) + trans;
|
||
|
elem[ i ].fKey.fFloat = dist;
|
||
|
elem[ i ].fBody = &list[ i ];
|
||
|
elem[ i ].fNext = elem + i + 1;
|
||
|
}
|
||
|
elem[ i - 1 ].fNext = nil;
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "1");
|
||
|
plProfile_BeginLap(FaceSort, "2");
|
||
|
|
||
|
// Do da sort thingy
|
||
|
hsRadixSort rad;
|
||
|
hsRadixSort::Elem *sortedList = rad.Sort( elem, 0 );
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "2");
|
||
|
plProfile_BeginLap(FaceSort, "3");
|
||
|
|
||
|
UInt16* indices = tempTriList.AcquireArray();
|
||
|
// Stuff into the temp array
|
||
|
for( i = 0, elem = sortedList; i < numTris; i++ )
|
||
|
{
|
||
|
*indices++ = ((plGBufferTriangle *)elem->fBody)->fIndex1;
|
||
|
*indices++ = ((plGBufferTriangle *)elem->fBody)->fIndex2;
|
||
|
*indices++ = ((plGBufferTriangle *)elem->fBody)->fIndex3;
|
||
|
elem = elem->fNext;
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "3");
|
||
|
plProfile_BeginLap(FaceSort, "4");
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
numTris, tempTriList.AcquireArray() );
|
||
|
|
||
|
/// Optional step in a way: copy back our new, sorted list to our original
|
||
|
/// array. This lets us do less sorting next call, since the order should
|
||
|
/// remain largely unchanged from the last call. If this turns out NOT to
|
||
|
/// be the case, or if the sorting step takes less time than this copy,
|
||
|
/// take this out!
|
||
|
// memcpy( list, tempTriList.AcquireArray(), numTris * sizeof( plGBufferTriangle ) );
|
||
|
|
||
|
/// All done! (force buffer groups to refresh during next render call)
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "4");
|
||
|
}
|
||
|
|
||
|
//// SortVisibleSpans ////////////////////////////////////////////////////////
|
||
|
// Sorts the visible spans's triangles in one big lump, for proper back-to-
|
||
|
// front display.
|
||
|
// Updated 5.14.2001 mcn - Fixed so loops don't assume spans are icicles
|
||
|
|
||
|
void plDrawableSpans::SortVisibleSpans(const hsTArray<Int16>& visList, plPipeline* pipe)
|
||
|
{
|
||
|
#define MF_CHUNKSORT
|
||
|
#ifndef MF_CHUNKSORT
|
||
|
|
||
|
plProfile_Inc(FaceSortCalls);
|
||
|
|
||
|
if( !visList.GetCount() )
|
||
|
return;
|
||
|
|
||
|
|
||
|
static hsLargeArray<hsRadixSort::Elem> sortScratch;
|
||
|
static hsLargeArray<UInt16> triList;
|
||
|
static hsTArray<Int32> counters;
|
||
|
static hsTArray<UInt32> startIndex;
|
||
|
|
||
|
int i;
|
||
|
|
||
|
plProfile_BeginTiming(FaceSort);
|
||
|
if( pipe->IsDebugFlagSet( plPipeDbg::kFlagDontSortFaces ) )
|
||
|
{
|
||
|
/// Don't sort, just send unchanged
|
||
|
int j, idx;
|
||
|
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
ICheckSpanForSortable(visList[i]);
|
||
|
|
||
|
/// Build a fake list of indices....
|
||
|
plGBufferTriangle* list = span->fSortData;
|
||
|
triList.SetCount( span->fILength );
|
||
|
for( j = 0, idx = 0; j < span->fILength / 3; j++, idx += 3 )
|
||
|
{
|
||
|
triList[ idx ] = list[ j ].fIndex1;
|
||
|
triList[ idx + 1 ] = list[ j ].fIndex2;
|
||
|
triList[ idx + 2 ] = list[ j ].fIndex3;
|
||
|
}
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() );
|
||
|
}
|
||
|
fReadyToRender = false;
|
||
|
return;
|
||
|
}
|
||
|
plProfile_EndTiming(FaceSort);
|
||
|
|
||
|
plProfile_BeginLap(FaceSort, "0");
|
||
|
|
||
|
startIndex.SetCount(fSpans.GetCount());
|
||
|
|
||
|
// First figure out the total number of tris to deal with.
|
||
|
int totTris = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
startIndex[visList[i]] = totTris * 3;
|
||
|
if( span->fProps & plSpan::kPropReverseSort )
|
||
|
startIndex[visList[i]] += span->fILength - 3;
|
||
|
|
||
|
totTris += span->fILength / 3;
|
||
|
}
|
||
|
if( totTris == 0 )
|
||
|
{
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plProfile_IncCount(FacesSorted, totTris);
|
||
|
|
||
|
sortScratch.SetCount(totTris);
|
||
|
triList.SetCount(3 * totTris);
|
||
|
|
||
|
hsRadixSort::Elem* elem = sortScratch.AcquireArray();
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
plProfile_BeginLap(FaceSort, "1");
|
||
|
|
||
|
// Pack them into the sort structure. We probably want to make the
|
||
|
// plGBufferTriangle look like plTriSortData (just add span index)
|
||
|
// which would get rid of this copy and help the data alignment.
|
||
|
// Oops, I already did.
|
||
|
int cnt = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
int nTris = span->fILength / 3;
|
||
|
|
||
|
hsPoint3 viewPos = span->fWorldToLocal * pipe->GetViewPositionWorld();
|
||
|
|
||
|
plGBufferTriangle* list = span->fSortData;
|
||
|
int j;
|
||
|
for( j = 0; j < nTris; j++ )
|
||
|
{
|
||
|
hsScalar dist = -(viewPos - list[j].fCenter).MagnitudeSquared();
|
||
|
elem[cnt].fKey.fFloat = dist;
|
||
|
elem[cnt].fBody = &list[j];
|
||
|
elem[cnt].fNext = elem + cnt + 1;
|
||
|
|
||
|
cnt++;
|
||
|
}
|
||
|
}
|
||
|
elem[cnt-1].fNext = nil;
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "1");
|
||
|
plProfile_BeginLap(FaceSort, "2");
|
||
|
|
||
|
// Actual sort
|
||
|
hsRadixSort rad;
|
||
|
hsRadixSort::Elem* sortedList = rad.Sort( elem, 0 );
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "2");
|
||
|
plProfile_BeginLap(FaceSort, "3");
|
||
|
|
||
|
counters.SetCountAndZero(fSpans.GetCount());
|
||
|
|
||
|
while( sortedList )
|
||
|
{
|
||
|
plGBufferTriangle* data = (plGBufferTriangle*)sortedList->fBody;
|
||
|
plIcicle* span = (plIcicle*)fSpans[data->fSpanIndex];
|
||
|
|
||
|
UInt16* idx = &triList[startIndex[data->fSpanIndex] + counters[data->fSpanIndex]];
|
||
|
*idx++ = data->fIndex1;
|
||
|
*idx++ = data->fIndex2;
|
||
|
*idx++ = data->fIndex3;
|
||
|
if( span->fProps & plSpan::kPropReverseSort )
|
||
|
counters[data->fSpanIndex] -= 3;
|
||
|
else
|
||
|
counters[data->fSpanIndex] += 3;
|
||
|
|
||
|
sortedList = sortedList->fNext;
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "3");
|
||
|
plProfile_BeginLap(FaceSort, "4");
|
||
|
|
||
|
const int kMaxBufferGroups = 20;
|
||
|
const int kMaxIndexBuffers = 20;
|
||
|
static Int16 newStarts[kMaxBufferGroups][kMaxIndexBuffers];
|
||
|
|
||
|
// Temp hack stuff so we can switch back and forth (to see if it really does any good).
|
||
|
static int oldWay = false;
|
||
|
static int lastOldWay = oldWay;
|
||
|
if( oldWay != lastOldWay )
|
||
|
{
|
||
|
memset(newStarts, 0, kMaxBufferGroups * kMaxIndexBuffers * sizeof(Int16));
|
||
|
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[i];
|
||
|
|
||
|
span->fPackedIdx = span->fIStartIdx = newStarts[span->fGroupIdx][span->fIBufferIdx];
|
||
|
newStarts[span->fGroupIdx][span->fIBufferIdx] += span->fILength;
|
||
|
}
|
||
|
lastOldWay = oldWay;
|
||
|
}
|
||
|
|
||
|
if( oldWay )
|
||
|
{
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() + startIndex[visList[i]]);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
memset(newStarts, 0, kMaxBufferGroups * kMaxIndexBuffers * sizeof(Int16));
|
||
|
|
||
|
UInt32 start = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
span->fPackedIdx = span->fIStartIdx = newStarts[span->fGroupIdx][span->fIBufferIdx];
|
||
|
newStarts[span->fGroupIdx][span->fIBufferIdx] += span->fILength;
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() + startIndex[visList[i]]);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "4");
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
return;
|
||
|
|
||
|
#else // MF_CHUNKSORT
|
||
|
|
||
|
plProfile_Inc(FaceSortCalls);
|
||
|
|
||
|
if( !visList.GetCount() )
|
||
|
return;
|
||
|
|
||
|
plProfile_BeginTiming(FaceSort);
|
||
|
|
||
|
static hsLargeArray<hsRadixSort::Elem> sortScratch;
|
||
|
static hsLargeArray<UInt16> triList;
|
||
|
static hsTArray<Int32> counters;
|
||
|
static hsTArray<UInt32> startIndex;
|
||
|
|
||
|
int i;
|
||
|
|
||
|
if( pipe->IsDebugFlagSet( plPipeDbg::kFlagDontSortFaces ) )
|
||
|
{
|
||
|
/// Don't sort, just send unchanged
|
||
|
int j, idx;
|
||
|
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
ICheckSpanForSortable(visList[i]);
|
||
|
|
||
|
/// Build a fake list of indices....
|
||
|
plGBufferTriangle* list = span->fSortData;
|
||
|
triList.SetCount( span->fILength );
|
||
|
for( j = 0, idx = 0; j < span->fILength / 3; j++, idx += 3 )
|
||
|
{
|
||
|
triList[ idx ] = list[ j ].fIndex1;
|
||
|
triList[ idx + 1 ] = list[ j ].fIndex2;
|
||
|
triList[ idx + 2 ] = list[ j ].fIndex3;
|
||
|
}
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() );
|
||
|
}
|
||
|
fReadyToRender = false;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plProfile_EndTiming(FaceSort);
|
||
|
|
||
|
plProfile_BeginLap(FaceSort, "0");
|
||
|
|
||
|
startIndex.SetCount(fSpans.GetCount());
|
||
|
|
||
|
// First figure out the total number of tris to deal with.
|
||
|
int totTris = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
ICheckSpanForSortable(visList[i]);
|
||
|
|
||
|
startIndex[visList[i]] = totTris * 3;
|
||
|
if( span->fProps & plSpan::kPropReverseSort )
|
||
|
startIndex[visList[i]] += span->fILength - 3;
|
||
|
|
||
|
|
||
|
totTris += span->fILength / 3;
|
||
|
}
|
||
|
if( totTris == 0 )
|
||
|
{
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plProfile_IncCount(FacesSorted, totTris);
|
||
|
|
||
|
sortScratch.SetCount(totTris);
|
||
|
triList.SetCount(3 * totTris);
|
||
|
|
||
|
hsRadixSort::Elem* elem = sortScratch.AcquireArray();
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
|
||
|
int iVis = 0;
|
||
|
while( iVis < visList.GetCount() )
|
||
|
{
|
||
|
plProfile_BeginLap(FaceSort, "1");
|
||
|
|
||
|
// Pack them into the sort structure. We probably want to make the
|
||
|
// plGBufferTriangle look like plTriSortData (just add span index)
|
||
|
// which would get rid of this copy and help the data alignment.
|
||
|
// Oops, I already did.
|
||
|
const int kTriCutoff = 4000;
|
||
|
int cnt = 0;
|
||
|
while( (iVis < visList.GetCount()) && (cnt < kTriCutoff) )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[iVis]];
|
||
|
|
||
|
int nTris = span->fILength / 3;
|
||
|
|
||
|
hsPoint3 viewPos = span->fWorldToLocal * pipe->GetViewPositionWorld();
|
||
|
|
||
|
plGBufferTriangle* list = span->fSortData;
|
||
|
int j;
|
||
|
for( j = 0; j < nTris; j++ )
|
||
|
{
|
||
|
hsScalar dist = -(viewPos - list[j].fCenter).MagnitudeSquared();
|
||
|
elem[cnt].fKey.fFloat = dist;
|
||
|
elem[cnt].fBody = &list[j];
|
||
|
elem[cnt].fNext = elem + cnt + 1;
|
||
|
|
||
|
cnt++;
|
||
|
}
|
||
|
iVis++;
|
||
|
}
|
||
|
elem[cnt-1].fNext = nil;
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "1");
|
||
|
plProfile_BeginLap(FaceSort, "2");
|
||
|
|
||
|
// Actual sort
|
||
|
hsRadixSort rad;
|
||
|
hsRadixSort::Elem* sortedList = rad.Sort( elem, 0 );
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "2");
|
||
|
plProfile_BeginLap(FaceSort, "3");
|
||
|
|
||
|
counters.SetCountAndZero(fSpans.GetCount());
|
||
|
|
||
|
while( sortedList )
|
||
|
{
|
||
|
plGBufferTriangle* data = (plGBufferTriangle*)sortedList->fBody;
|
||
|
plIcicle* span = (plIcicle*)fSpans[data->fSpanIndex];
|
||
|
|
||
|
UInt16* idx = &triList[startIndex[data->fSpanIndex] + counters[data->fSpanIndex]];
|
||
|
*idx++ = data->fIndex1;
|
||
|
*idx++ = data->fIndex2;
|
||
|
*idx++ = data->fIndex3;
|
||
|
if( span->fProps & plSpan::kPropReverseSort )
|
||
|
counters[data->fSpanIndex] -= 3;
|
||
|
else
|
||
|
counters[data->fSpanIndex] += 3;
|
||
|
|
||
|
sortedList = sortedList->fNext;
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "3");
|
||
|
}
|
||
|
|
||
|
plProfile_BeginLap(FaceSort, "4");
|
||
|
|
||
|
const int kMaxBufferGroups = 20;
|
||
|
const int kMaxIndexBuffers = 20;
|
||
|
static Int16 newStarts[kMaxBufferGroups][kMaxIndexBuffers];
|
||
|
|
||
|
hsAssert(kMaxBufferGroups >= GetNumBufferGroups(), "Bigger than we counted on num groups sort.");
|
||
|
|
||
|
memset(newStarts, 0, kMaxBufferGroups * kMaxIndexBuffers * sizeof(Int16));
|
||
|
|
||
|
UInt32 start = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
hsAssert(kMaxIndexBuffers > span->fIBufferIdx, "Bigger than we counted on num buffers sort.");
|
||
|
|
||
|
if( span->fProps & plSpan::kPropReverseSort )
|
||
|
startIndex[visList[i]] -= span->fILength - 3;
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
span->fIPackedIdx = span->fIStartIdx = newStarts[span->fGroupIdx][span->fIBufferIdx];
|
||
|
newStarts[span->fGroupIdx][span->fIBufferIdx] += (Int16)(span->fILength);
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() + startIndex[visList[i]]);
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "4");
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
#endif // MF_CHUNKSORT
|
||
|
}
|
||
|
|
||
|
struct buffTriCmpBackToFront : public std::binary_function<plGBufferTriangle, plGBufferTriangle, bool>
|
||
|
{
|
||
|
hsPoint3 fViewPos;
|
||
|
buffTriCmpBackToFront(const hsPoint3& p) : fViewPos(p) {}
|
||
|
|
||
|
bool operator()( const plGBufferTriangle& lhs, const plGBufferTriangle& rhs) const
|
||
|
{
|
||
|
return hsVector3(&fViewPos, &lhs.fCenter).MagnitudeSquared() > hsVector3(&fViewPos, &rhs.fCenter).MagnitudeSquared();
|
||
|
}
|
||
|
};
|
||
|
|
||
|
struct buffTriCmpFrontToBack : public std::binary_function<plGBufferTriangle, plGBufferTriangle, bool>
|
||
|
{
|
||
|
hsPoint3 fViewPos;
|
||
|
buffTriCmpFrontToBack(const hsPoint3& p) : fViewPos(p) {}
|
||
|
|
||
|
bool operator()( const plGBufferTriangle& lhs, const plGBufferTriangle& rhs) const
|
||
|
{
|
||
|
return hsVector3(&fViewPos, &lhs.fCenter).MagnitudeSquared() < hsVector3(&fViewPos, &rhs.fCenter).MagnitudeSquared();
|
||
|
}
|
||
|
};
|
||
|
|
||
|
void plDrawableSpans::SortVisibleSpansPartial(const hsTArray<Int16>& visList, plPipeline* pipe)
|
||
|
{
|
||
|
plProfile_Inc(FaceSortCalls);
|
||
|
|
||
|
plProfile_BeginTiming(FaceSort);
|
||
|
|
||
|
int i;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
hsAssert(fSpans[visList[i]]->fTypeMask & plSpan::kIcicleSpan, "Unknown type for sorting faces");
|
||
|
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
if( span->fProps & plSpan::kPartialSort )
|
||
|
{
|
||
|
hsAssert(fGroups[span->fGroupIdx]->AreIdxVolatile(), "Badly setup buffer group - set PartialSort too late?");
|
||
|
|
||
|
ICheckSpanForSortable(visList[i]);
|
||
|
|
||
|
const hsPoint3 viewPos = span->fWorldToLocal * pipe->GetViewPositionWorld();
|
||
|
|
||
|
const int numTris = span->fILength/3;
|
||
|
std::sort(span->fSortData, span->fSortData+numTris, buffTriCmpBackToFront(viewPos));
|
||
|
|
||
|
UInt16* idx = fGroups[span->fGroupIdx]->GetIndexBufferData(span->fIBufferIdx) + span->fIStartIdx;
|
||
|
plGBufferTriangle* iter = span->fSortData;
|
||
|
int j;
|
||
|
for( j = 0; j < numTris; j++ )
|
||
|
{
|
||
|
*idx++ = iter->fIndex1;
|
||
|
*idx++ = iter->fIndex2;
|
||
|
*idx++ = iter->fIndex3;
|
||
|
iter++;
|
||
|
}
|
||
|
|
||
|
fGroups[span->fGroupIdx]->DirtyIndexBuffer(span->fIBufferIdx);
|
||
|
fReadyToRender = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
plProfile_EndTiming(FaceSort);
|
||
|
}
|
||
|
|
||
|
#if 0
|
||
|
|
||
|
void plDrawableSpans::SortVisibleSpansUnit(const hsTArray<Int16>& visList, plPipeline* pipe)
|
||
|
{
|
||
|
plProfile_Inc(FaceSortCalls);
|
||
|
|
||
|
if( !visList.GetCount() )
|
||
|
return;
|
||
|
|
||
|
plProfile_BeginTiming(FaceSort);
|
||
|
|
||
|
static hsLargeArray<UInt16> triList;
|
||
|
|
||
|
int i;
|
||
|
|
||
|
if( pipe->IsDebugFlagSet( plPipeDbg::kFlagDontSortFaces ) )
|
||
|
{
|
||
|
/// Don't sort, just send unchanged
|
||
|
int j, idx;
|
||
|
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
ICheckSpanForSortable(visList[i]);
|
||
|
|
||
|
/// Build a fake list of indices....
|
||
|
plGBufferTriangle* list = span->fSortData;
|
||
|
triList.SetCount( span->fILength );
|
||
|
for( j = 0, idx = 0; j < span->fILength / 3; j++, idx += 3 )
|
||
|
{
|
||
|
triList[ idx ] = list[ j ].fIndex1;
|
||
|
triList[ idx + 1 ] = list[ j ].fIndex2;
|
||
|
triList[ idx + 2 ] = list[ j ].fIndex3;
|
||
|
}
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() );
|
||
|
}
|
||
|
fReadyToRender = false;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plProfile_EndTiming(FaceSort);
|
||
|
|
||
|
plProfile_BeginLap(FaceSort, "0");
|
||
|
|
||
|
struct sortFace
|
||
|
{
|
||
|
UInt16 fIndex0;
|
||
|
UInt16 fIndex1;
|
||
|
UInt16 fIndex2;
|
||
|
hsScalar fDist;
|
||
|
};
|
||
|
static hsLargeArray<sortFace> sortList;
|
||
|
|
||
|
struct SelectCloserFace
|
||
|
{
|
||
|
bool operator()(const sortFace* face0, const sortFace* face1) const
|
||
|
{
|
||
|
return face0->fDist < face1->fDist;
|
||
|
}
|
||
|
};
|
||
|
hsPoint3 viewPos = fSpans[visList[0]]->fWorldToLocal * pipe->GetViewPositionWorld();
|
||
|
|
||
|
hsScalar dist1 = (fViewPos - face1->fCenter).MagnitudeSquared();
|
||
|
|
||
|
// First figure out the total number of tris to deal with.
|
||
|
sortList.SetCount(0);
|
||
|
int totTris = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
int nTris = span->fILength / 3;
|
||
|
sortList.Expand(sortList.GetCount() + nTris);
|
||
|
|
||
|
plGBufferTriangle* sortData = span->fSortData;
|
||
|
for( j = 0; j < nTris; j++ )
|
||
|
{
|
||
|
sortList.Append(*sortData++);
|
||
|
}
|
||
|
|
||
|
totTris += nTris;
|
||
|
}
|
||
|
if( totTris == 0 )
|
||
|
{
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plProfile_IncCount(FacesSorted, totTris);
|
||
|
|
||
|
sortFace* pBegin = sortList.AcquireArray();
|
||
|
sortFace* pEnd = pBegin + totTris;
|
||
|
|
||
|
stl::sort(pBegin, pEnd, SelectCloserFace);
|
||
|
|
||
|
triList.SetCount(sortList.GetCount());
|
||
|
|
||
|
UInt16* pTri = triList.AcquireArray();
|
||
|
|
||
|
while( pBegin < pEnd )
|
||
|
{
|
||
|
*pTri = pBegin->fIndex1;
|
||
|
pTri++;
|
||
|
*pTri = pBegin->fIndex2;
|
||
|
pTri++;
|
||
|
*pTri = pBegin->fIndex3;
|
||
|
pTri++;
|
||
|
}
|
||
|
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "0");
|
||
|
|
||
|
UInt32 start = 0;
|
||
|
for( i = 0; i < visList.GetCount(); i++ )
|
||
|
{
|
||
|
plIcicle* span = (plIcicle*)fSpans[visList[i]];
|
||
|
|
||
|
/// Now send them on to the buffer group
|
||
|
span->fIPackedIdx = span->fIStartIdx = newStarts[span->fGroupIdx][span->fIBufferIdx];
|
||
|
newStarts[span->fGroupIdx][span->fIBufferIdx] += span->fILength;
|
||
|
fGroups[ span->fGroupIdx ]->StuffFromTriList( span->fIBufferIdx, span->fIStartIdx,
|
||
|
span->fILength / 3, triList.AcquireArray() + startIndex[visList[i]]);
|
||
|
}
|
||
|
|
||
|
plProfile_EndLap(FaceSort, "4");
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
void plDrawableSpans::SetInitialBone(int i, const hsMatrix44& l2b, const hsMatrix44& b2l)
|
||
|
{
|
||
|
fLocalToBones[ i ] = l2b;
|
||
|
fBoneToLocals[ i ] = b2l;
|
||
|
}
|
||
|
|
||
|
//// AppendDIMatrixSpans ///////////////////////////////////////////////////////////
|
||
|
// Adds a di span which will only reference into the matrix palette. That is,
|
||
|
// these indices won't index into any drawable data, they will only index into
|
||
|
// the same matrix list that the drawable data itself can index into. When
|
||
|
// an object (through its DrawInterface) sets a transform, it doesn't know
|
||
|
// whether it's setting the transform for some drawable data it owns, or just
|
||
|
// setting one of the matrices which influence the drawable data someone else
|
||
|
// owns.
|
||
|
UInt32 plDrawableSpans::AppendDIMatrixSpans(int n)
|
||
|
{
|
||
|
/// Do garbage cleanup first
|
||
|
if( fNeedCleanup )
|
||
|
IRemoveGarbage();
|
||
|
|
||
|
UInt32 baseIdx = fLocalToWorlds.GetCount();
|
||
|
fLocalToWorlds.Expand(baseIdx + n);
|
||
|
fLocalToWorlds.SetCount(baseIdx + n);
|
||
|
fWorldToLocals.Expand(baseIdx + n);
|
||
|
fWorldToLocals.SetCount(baseIdx + n);
|
||
|
|
||
|
fLocalToBones.Expand(baseIdx + n);
|
||
|
fLocalToBones.SetCount(baseIdx + n);
|
||
|
fBoneToLocals.Expand(baseIdx + n);
|
||
|
fBoneToLocals.SetCount(baseIdx + n);
|
||
|
|
||
|
int i;
|
||
|
for( i = baseIdx; i < baseIdx + n; i++ )
|
||
|
{
|
||
|
fLocalToWorlds[i].Reset();
|
||
|
fWorldToLocals[i].Reset();
|
||
|
|
||
|
fLocalToBones[i].Reset();
|
||
|
fBoneToLocals[i].Reset();
|
||
|
}
|
||
|
|
||
|
return baseIdx;
|
||
|
}
|
||
|
|
||
|
// Look for a compatible set of palette matrices. Compatible means:
|
||
|
// a) Same number bones
|
||
|
// b) Same LocalToBones matrices (which implies same BoneToLocal matrices.
|
||
|
// Note that the LocalToBone transform is dependent on both the bone's transform
|
||
|
// and the transform of the object being skinned. In general, objects can only
|
||
|
// share a palette set if they have been flattened into world space (the object's
|
||
|
// transform is identity). Fortunately, this is a common case.
|
||
|
UInt32 plDrawableSpans::FindBoneBaseMatrix(const hsTArray<hsMatrix44>& initL2B, hsBool searchAll) const
|
||
|
{
|
||
|
if (!searchAll)
|
||
|
{
|
||
|
// Just look amongst the added spans for a matching set
|
||
|
int i;
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[i] && (initL2B.GetCount() == fSpans[i]->fNumMatrices) )
|
||
|
{
|
||
|
int j;
|
||
|
for( j = 0; j < initL2B.GetCount(); j++ )
|
||
|
{
|
||
|
if( initL2B[j] != fLocalToBones[j + fSpans[i]->fBaseMatrix] )
|
||
|
break;
|
||
|
}
|
||
|
if( initL2B.GetCount() == j )
|
||
|
return fSpans[i]->fBaseMatrix;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Since swappable geometry spans aren't added to the drawable until
|
||
|
// runtime, a sharable bone pallete won't be found by scanning fSpans.
|
||
|
// We have to do a larger search through all bone matrices.
|
||
|
int i;
|
||
|
for( i = 0; i + initL2B.GetCount() < fLocalToBones.GetCount(); i++ )
|
||
|
{
|
||
|
int j;
|
||
|
for( j = 0; j < initL2B.GetCount(); j++ )
|
||
|
{
|
||
|
if( initL2B[j] != fLocalToBones[j + i] )
|
||
|
break;
|
||
|
}
|
||
|
if( initL2B.GetCount() == j )
|
||
|
return i;
|
||
|
}
|
||
|
}
|
||
|
return UInt32(-1);
|
||
|
}
|
||
|
|
||
|
UInt32 plDrawableSpans::NewDIMatrixIndex()
|
||
|
{
|
||
|
int index;
|
||
|
/// Do we have a free lookup entry?
|
||
|
for( index = 0; index < fDIIndices.GetCount(); index++ )
|
||
|
{
|
||
|
if( !fDIIndices[ index ]->GetCount() )
|
||
|
break;
|
||
|
}
|
||
|
if( index == fDIIndices.GetCount() )
|
||
|
fDIIndices.Append( TRACKED_NEW plDISpanIndex );
|
||
|
|
||
|
fDIIndices[index]->Reset();
|
||
|
fDIIndices[index]->fFlags = plDISpanIndex::kMatrixOnly;
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
//// IFindDIIndices //////////////////////////////////////////////////////////
|
||
|
// Finds the given DIIndices array and returns a pointer to it, or creates
|
||
|
// a new one if requested
|
||
|
|
||
|
plDISpanIndex *plDrawableSpans::IFindDIIndices( UInt32 &index )
|
||
|
{
|
||
|
plDISpanIndex *spanLookup;
|
||
|
|
||
|
|
||
|
/// Do we have a free lookup entry?
|
||
|
if( index == (UInt32)-1 ) // new index
|
||
|
{
|
||
|
for( index = 0; index < fDIIndices.GetCount(); index++ )
|
||
|
{
|
||
|
if( fDIIndices[ index ]->GetCount() == 0 )
|
||
|
break;
|
||
|
}
|
||
|
if( index == fDIIndices.GetCount() )
|
||
|
fDIIndices.Append( TRACKED_NEW plDISpanIndex );
|
||
|
|
||
|
spanLookup = fDIIndices[ index ];
|
||
|
spanLookup->fFlags = plDISpanIndex::kNone;
|
||
|
}
|
||
|
else
|
||
|
spanLookup = fDIIndices[ index ]; // Just grab the one we requested
|
||
|
|
||
|
return spanLookup;
|
||
|
}
|
||
|
|
||
|
//// AppendDISpans ///////////////////////////////////////////////////////////
|
||
|
// Given a set of DI spans, appends them to the current storage buffers.
|
||
|
// Note: AddDISpans() adds the spans to a list to be sorted, THEN put into
|
||
|
// the buffers; this shoves them right in, bypassing the sorting altogether.
|
||
|
|
||
|
UInt32 plDrawableSpans::AppendDISpans( hsTArray<plGeometrySpan *> &spans, UInt32 index, hsBool clearSpansAfterAdd,
|
||
|
hsBool doNotAddToSource, hsBool addToFront, int lod)
|
||
|
{
|
||
|
hsAssert(spans.GetCount(), "Adding no spans? Blow me.");
|
||
|
|
||
|
int i, j;
|
||
|
UInt32 spanIdx;
|
||
|
plSpan *span;
|
||
|
hsBounds3Ext bounds;
|
||
|
plDISpanIndex *spanLookup;
|
||
|
UInt32 numAddedIcicle = 0;
|
||
|
|
||
|
// hsAssert( fProps & kPropVolatile, "Trying to add spans on a non-volatile drawable" );
|
||
|
|
||
|
/// Do garbage cleanup first
|
||
|
if( fNeedCleanup )
|
||
|
IRemoveGarbage();
|
||
|
|
||
|
spanLookup = IFindDIIndices( index );
|
||
|
|
||
|
if( GetNativeProperty(plDrawable::kPropCharacter) )
|
||
|
fVisSet.SetBit(plVisMgr::kCharacter, true);
|
||
|
|
||
|
int insertionPoint = 0;
|
||
|
if( spans[0]->fProps & plGeometrySpan::kPartialSort )
|
||
|
{
|
||
|
insertionPoint = fSpans.GetCount();
|
||
|
}
|
||
|
else if( !addToFront )
|
||
|
{
|
||
|
int idx;
|
||
|
for( idx = 0; (idx < fSpans.GetCount()) && !(fSpans[idx]->fProps & plSpan::kPartialSort); idx++ )
|
||
|
{
|
||
|
}
|
||
|
insertionPoint = idx;
|
||
|
}
|
||
|
hsBool inserted = insertionPoint < fSpans.GetCount();
|
||
|
|
||
|
/// Add the geometry spans to our list. Also add our internal span
|
||
|
/// copies
|
||
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
{
|
||
|
spanIdx = fIcicles.GetCount();
|
||
|
fIcicles.Append( plIcicle() );
|
||
|
plIcicle *icicle = &fIcicles[ spanIdx ];
|
||
|
IConvertGeoSpanToIcicle( spans[ i ], icicle, lod );
|
||
|
span = (plSpan *)icicle;
|
||
|
numAddedIcicle++;
|
||
|
|
||
|
/// Add to our source indices
|
||
|
spans[ i ]->fSpanRefIndex = insertionPoint+i;
|
||
|
spanLookup->Append( spans[ i ]->fSpanRefIndex );
|
||
|
fSpans.Insert( spans[ i ]->fSpanRefIndex, span );
|
||
|
fSpanSourceIndices.Insert( spans[ i ]->fSpanRefIndex, spanIdx );
|
||
|
|
||
|
if( GetNativeProperty(plDrawable::kPropCharacter) )
|
||
|
span->SetVisBit(plVisMgr::kCharacter, true);
|
||
|
|
||
|
/// Add the material to our list if necessary
|
||
|
IAssignMatIdxToSpan( span, spans[ i ]->fMaterial );
|
||
|
|
||
|
if( clearSpansAfterAdd )
|
||
|
{
|
||
|
delete spans[ i ];
|
||
|
spans[ i ] = nil;
|
||
|
}
|
||
|
else if( !doNotAddToSource )
|
||
|
{
|
||
|
if( fSourceSpans.GetCount() < fSpans.GetCount() )
|
||
|
{
|
||
|
fSourceSpans.Expand( fSpans.GetCount() );
|
||
|
// Since that does not change the use count, we still have to do that ourselves. ARGH!
|
||
|
fSourceSpans.SetCount( fSpans.GetCount() );
|
||
|
}
|
||
|
|
||
|
fSourceSpans[ spans[ i ]->fSpanRefIndex ] = spans[ i ];
|
||
|
}
|
||
|
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
// Should add sort data too...
|
||
|
IMakeSpanSortable( fSpans.GetCount() - 1 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (inserted)
|
||
|
{
|
||
|
/// Go adjusting indices in the DI index list
|
||
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
{
|
||
|
if( !fDIIndices[ i ]->IsMatrixOnly() )
|
||
|
{
|
||
|
if (fDIIndices[ i ] == spanLookup)
|
||
|
continue;
|
||
|
|
||
|
for( j = 0; j < fDIIndices[ i ]->GetCount(); j++ )
|
||
|
{
|
||
|
if( (*fDIIndices[i])[j] >= insertionPoint )
|
||
|
{
|
||
|
(*fDIIndices[ i ])[ j ] += spans.GetCount();
|
||
|
hsAssert((*fDIIndices[ i ])[ j ] < fSpans.GetCount(), "Span index snafu");
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Update fLocalBounds, since we were updating the world bounds
|
||
|
fLocalBounds = fWorldBounds;
|
||
|
fLocalBounds.Transform( &fWorldToLocal );
|
||
|
fMaxWorldBounds = fWorldBounds;
|
||
|
|
||
|
/// Rebuild the pointer array
|
||
|
IRebuildSpanArray();
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
//// IAddAMaterial ///////////////////////////////////////////////////////////
|
||
|
|
||
|
UInt32 plDrawableSpans::IAddAMaterial( hsGMaterial *material )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
|
||
|
|
||
|
// Scan for if we already have it
|
||
|
for( i = 0; i < fMaterials.GetCount(); i++ )
|
||
|
{
|
||
|
if( fMaterials[ i ] == material )
|
||
|
return i;
|
||
|
}
|
||
|
|
||
|
// Scan again for a blank space to add into, if possible
|
||
|
for( i = 0; i < fMaterials.GetCount(); i++ )
|
||
|
{
|
||
|
if( fMaterials[ i ] == nil )
|
||
|
{
|
||
|
fMaterials[ i ] = material;
|
||
|
IRefMaterial( i );
|
||
|
return i;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Add in to the end
|
||
|
i = fMaterials.GetCount();
|
||
|
fMaterials.Append( material );
|
||
|
|
||
|
// Plus ref it
|
||
|
IRefMaterial( i );
|
||
|
|
||
|
return i;
|
||
|
}
|
||
|
|
||
|
//// IRefMaterial ////////////////////////////////////////////////////////////
|
||
|
// Called if we already have a material index that we just want to use
|
||
|
// again...
|
||
|
|
||
|
UInt32 plDrawableSpans::IRefMaterial( UInt32 index )
|
||
|
{
|
||
|
hsGMaterial *material = fMaterials[ index ];
|
||
|
|
||
|
if( GetKey() && material != nil && material->GetKey() != nil )
|
||
|
hsgResMgr::ResMgr()->AddViaNotify( material->GetKey(), TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, index, 0 ), plRefFlags::kActiveRef );
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
//// ICheckToRemoveMaterial //////////////////////////////////////////////////
|
||
|
// Runs through the span array to see if the given material index is still
|
||
|
// used. If not, Release()s it and nil's it.
|
||
|
|
||
|
void plDrawableSpans::ICheckToRemoveMaterial( UInt32 materialIdx )
|
||
|
{
|
||
|
int j;
|
||
|
hsGMaterial *mat;
|
||
|
|
||
|
|
||
|
for( j = 0; j < fSpans.GetCount(); j++ )
|
||
|
{
|
||
|
if( fSpans[ j ]->fMaterialIdx == materialIdx )
|
||
|
break;
|
||
|
}
|
||
|
if( j == fSpans.GetCount() )
|
||
|
{
|
||
|
/// No longer used--Release() it
|
||
|
mat = fMaterials[ materialIdx ];
|
||
|
if( GetKey() && mat != nil && mat->GetKey() != nil )
|
||
|
GetKey()->Release( mat->GetKey() );
|
||
|
fMaterials[ materialIdx ] = nil;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//// IConvertGeoSpanToVertexSpan /////////////////////////////////////////////
|
||
|
// Helper function for the two vertex-based convert functions.
|
||
|
|
||
|
hsBool plDrawableSpans::IConvertGeoSpanToVertexSpan( plGeometrySpan *geoSpan, plVertexSpan *span, int lod, plVertexSpan *instancedParent)
|
||
|
{
|
||
|
hsBounds3Ext bounds;
|
||
|
UInt8 groupIdx;
|
||
|
UInt32 vbIndex, cellIdx, cellOffset;
|
||
|
|
||
|
|
||
|
span->fLocalToWorld = geoSpan->fLocalToWorld;
|
||
|
span->fWorldToLocal = geoSpan->fWorldToLocal;
|
||
|
span->fProps |= ( geoSpan->fProps & plGeometrySpan::kPropRunTimeLight ) ? plSpan::kPropRunTimeLight : 0;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropNoShadowCast )
|
||
|
span->fProps |= plSpan::kPropNoShadowCast;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropNoShadow )
|
||
|
span->fProps |= plSpan::kPropNoShadow;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropForceShadow )
|
||
|
span->fProps |= plSpan::kPropForceShadow;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropReverseSort )
|
||
|
span->fProps |= plSpan::kPropReverseSort;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPartialSort )
|
||
|
span->fProps |= plSpan::kPartialSort;
|
||
|
switch( geoSpan->fProps & plGeometrySpan::kLiteMask )
|
||
|
{
|
||
|
case plGeometrySpan::kLiteMaterial: span->fProps |= plSpan::kLiteMaterial; break;
|
||
|
case plGeometrySpan::kLiteVtxPreshaded: span->fProps |= plSpan::kLiteVtxPreshaded; break;
|
||
|
case plGeometrySpan::kLiteVtxNonPreshaded: span->fProps |= plSpan::kLiteVtxNonPreshaded; break;
|
||
|
}
|
||
|
if( geoSpan->fProps & plGeometrySpan::kWaterHeight )
|
||
|
{
|
||
|
span->fProps |= plSpan::kWaterHeight;
|
||
|
span->fWaterHeight = geoSpan->fWaterHeight;
|
||
|
}
|
||
|
if( geoSpan->fProps & plGeometrySpan::kVisLOS )
|
||
|
{
|
||
|
span->fProps |= plSpan::kVisLOS;
|
||
|
fProps |= plDrawable::kPropHasVisLOS;
|
||
|
}
|
||
|
|
||
|
span->fNumMatrices = geoSpan->fNumMatrices;
|
||
|
span->fBaseMatrix = geoSpan->fBaseMatrix;
|
||
|
span->fLocalUVWChans = geoSpan->fLocalUVWChans;
|
||
|
span->fMaxBoneIdx = geoSpan->fMaxBoneIdx;
|
||
|
span->fPenBoneIdx = (UInt16)(geoSpan->fPenBoneIdx);
|
||
|
span->fMinDist = geoSpan->fMinDist;
|
||
|
span->fMaxDist = geoSpan->fMaxDist;
|
||
|
|
||
|
bounds = geoSpan->fLocalBounds;
|
||
|
span->fLocalBounds = bounds;
|
||
|
bounds.Transform( &span->fLocalToWorld );
|
||
|
span->fWorldBounds = bounds;
|
||
|
fWorldBounds.Union( &bounds );
|
||
|
span->fFogEnvironment = geoSpan->fFogEnviron;
|
||
|
|
||
|
hsBool vertsVol = false;
|
||
|
if( fProps & kPropVolatile )
|
||
|
vertsVol = true;
|
||
|
|
||
|
hsBool idxVol = false;
|
||
|
if( fProps & kPropSortFaces )
|
||
|
idxVol = true;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPartialSort )
|
||
|
idxVol = true;
|
||
|
|
||
|
// Are we instanced?
|
||
|
if( instancedParent != nil /*&& !( fProps & kPropVolatile )*/ )
|
||
|
{
|
||
|
/// We can instance w/o vert data IF 1) we're not the first span, 2) we can fit into the same buffer group, and
|
||
|
/// 3) we can fit into the same vertex buffer in the buffer group
|
||
|
if( instancedParent != span && ( geoSpan->fProps & plGeometrySpan::kPropNoPreShade ) )
|
||
|
{
|
||
|
/// WOW! We can actually share the *exact* same data, since we don't do any preshading. Coooooool!
|
||
|
span->fGroupIdx = instancedParent->fGroupIdx;
|
||
|
span->fVBufferIdx = instancedParent->fVBufferIdx;
|
||
|
span->fVStartIdx = instancedParent->fVStartIdx;
|
||
|
cellIdx = instancedParent->fCellIdx;
|
||
|
cellOffset = instancedParent->fCellOffset;
|
||
|
}
|
||
|
else if( instancedParent != span &&
|
||
|
( IFindBufferGroup( geoSpan->fFormat, geoSpan->fNumVerts, lod, vertsVol, idxVol ) == instancedParent->fGroupIdx ) &&
|
||
|
fGroups[ instancedParent->fGroupIdx ]->GetNumVertsLeft( instancedParent->fVBufferIdx ) >= geoSpan->fNumVerts )
|
||
|
{
|
||
|
/// Boooring....
|
||
|
/// Append the colors, but the vertices themselves we don't use, rather we point
|
||
|
/// to our parent's verts (or rather, the cell will take care of that for us)
|
||
|
groupIdx = (UInt8)(instancedParent->fGroupIdx);
|
||
|
fGroups[ groupIdx ]->AppendToColorStorage( geoSpan, &vbIndex, &cellIdx, &cellOffset, instancedParent->fCellIdx );
|
||
|
|
||
|
span->fGroupIdx = groupIdx;
|
||
|
span->fVBufferIdx = instancedParent->fVBufferIdx;
|
||
|
// Do a new vStart here, since it's really the colorStart, but oh well
|
||
|
span->fVStartIdx = fGroups[ groupIdx ]->GetVertStartFromCell( vbIndex, cellIdx, cellOffset );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/// WE'RE the parent?? This means we're the first to get converted
|
||
|
groupIdx = IFindBufferGroup( geoSpan->fFormat, geoSpan->fNumVerts, lod, vertsVol, idxVol );
|
||
|
fGroups[ groupIdx ]->AppendToVertAndColorStorage( geoSpan, &vbIndex, &cellIdx, &cellOffset );
|
||
|
|
||
|
span->fGroupIdx = groupIdx;
|
||
|
span->fVBufferIdx = vbIndex;
|
||
|
span->fVStartIdx = fGroups[ groupIdx ]->GetVertStartFromCell( vbIndex, cellIdx, cellOffset );
|
||
|
geoSpan->fProps |= plGeometrySpan::kFirstInstance;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Pack the vertices in
|
||
|
groupIdx = IFindBufferGroup( geoSpan->fFormat, geoSpan->fNumVerts, lod, vertsVol, idxVol );
|
||
|
fGroups[ groupIdx ]->AppendToVertStorage( geoSpan, &vbIndex, &cellIdx, &cellOffset );
|
||
|
|
||
|
span->fGroupIdx = groupIdx;
|
||
|
span->fVBufferIdx = vbIndex;
|
||
|
span->fVStartIdx = fGroups[ groupIdx ]->GetVertStartFromCell( vbIndex, cellIdx, cellOffset );
|
||
|
geoSpan->fProps |= plGeometrySpan::kFirstInstance;
|
||
|
}
|
||
|
|
||
|
span->fCellIdx = cellIdx;
|
||
|
span->fCellOffset = cellOffset;
|
||
|
span->fVLength = geoSpan->fNumVerts;
|
||
|
|
||
|
/// Add the material to our list if necessary
|
||
|
span->fMaterialIdx = IAddAMaterial( geoSpan->fMaterial );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
//// IConvertGeoSpanToIcicle /////////////////////////////////////////////////
|
||
|
|
||
|
hsBool plDrawableSpans::IConvertGeoSpanToIcicle(plGeometrySpan *geoSpan, plIcicle *icicle, int lod, plIcicle *instancedParent)
|
||
|
{
|
||
|
UInt32 ibIndex, ibStart;
|
||
|
|
||
|
|
||
|
IConvertGeoSpanToVertexSpan(geoSpan, icicle, lod, instancedParent);
|
||
|
|
||
|
/*
|
||
|
Disabling this 8.16.2001. Works great until you have to SORT the faces, then things blow up. We could
|
||
|
do this only when we won't sort faces, but it's easier right now to just never do this ever.
|
||
|
|
||
|
if( instancedParent != nil && instancedParent != icicle && ( icicle->fProps & plSpan::kPropRunTimeLight ) )
|
||
|
{
|
||
|
/// WOW! We can actually share the *exact* same data, since we don't do any preshading. Coooooool!
|
||
|
icicle->fIBufferIdx = instancedParent->fIBufferIdx;
|
||
|
icicle->fIStartIdx = instancedParent->fIStartIdx;
|
||
|
icicle->fILength = instancedParent->fILength;
|
||
|
icicle->fSortData = nil;
|
||
|
}
|
||
|
else
|
||
|
*/
|
||
|
{
|
||
|
// Pack the indices in (automagically offsets by the start we give it)
|
||
|
fGroups[ icicle->fGroupIdx ]->AppendToIndexStorage( geoSpan->fNumIndices, geoSpan->fIndexData,
|
||
|
icicle->fVStartIdx, &ibIndex, &ibStart );
|
||
|
|
||
|
icicle->fIBufferIdx = ibIndex;
|
||
|
icicle->fIPackedIdx = icicle->fIStartIdx = ibStart;
|
||
|
icicle->fILength = geoSpan->fNumIndices;
|
||
|
icicle->fSortData = nil;
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
//// RemoveDIMatrixSpans
|
||
|
// Nuke out a matrix only DI index set someone doesn't need anymore (cuz they're dead).
|
||
|
// Since there's no data associated, there's not much to do, except mark the slot as
|
||
|
// free and that some cleanup is in order some time.
|
||
|
void plDrawableSpans::RemoveDIMatrixSpans( UInt32 index )
|
||
|
{
|
||
|
plDISpanIndex* spanIndices = fDIIndices[ index ];
|
||
|
if( !spanIndices->IsMatrixOnly() )
|
||
|
return;
|
||
|
|
||
|
/// Flag that we need garbage cleanup now
|
||
|
fNeedCleanup = true;
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
spanIndices->Reset();
|
||
|
}
|
||
|
|
||
|
//// RemoveDISpans ///////////////////////////////////////////////////////////
|
||
|
// Given a drawInterface index (i.e. the index into fDIIndices), deletes
|
||
|
// the spans associated with that entry and clears the entry. Also packs
|
||
|
// the spans, deletes the verts/indices associated with the deleted spans
|
||
|
// and packs the vertex/index buffers as well.
|
||
|
|
||
|
void plDrawableSpans::RemoveDISpans( UInt32 index )
|
||
|
{
|
||
|
plDISpanIndex *spanIndices = fDIIndices[ index ];
|
||
|
|
||
|
if( spanIndices->IsMatrixOnly() )
|
||
|
{
|
||
|
RemoveDIMatrixSpans( index );
|
||
|
}
|
||
|
|
||
|
UInt32 i, j, k, idxRemoving, materialIdx;
|
||
|
|
||
|
|
||
|
// #define MF_RENDDEP
|
||
|
#ifdef MF_RENDDEP
|
||
|
hsTArray<UInt32> spanInverseTable;
|
||
|
spanInverseTable.SetCount(fSpans.GetCount());
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
spanInverseTable[i] = i;
|
||
|
#endif // MF_RENDDEP
|
||
|
|
||
|
// hsAssert( fProps & kPropVolatile, "Trying to remove spans on a non-volatile drawable" );
|
||
|
hsAssert( spanIndices->GetCount() > 0, "If there are no DI spans, why were we called?" );
|
||
|
|
||
|
/// Delete the actual spans themselves
|
||
|
for( i = 0; i < spanIndices->GetCount(); i++ )
|
||
|
{
|
||
|
/// If this is the last use of this material, Release() it
|
||
|
materialIdx = fSpans[ (*spanIndices)[ i ] ]->fMaterialIdx;
|
||
|
|
||
|
/// Remove the source index and the object itself
|
||
|
if( fSourceSpans.GetCount() && !( fSpans[ (*spanIndices)[ i ] ]->fTypeMask & plSpan::kParticleSpan ) )
|
||
|
{
|
||
|
delete fSourceSpans[ (*spanIndices)[i] ];
|
||
|
fSourceSpans.Remove( (*spanIndices)[i] );
|
||
|
for( j = (*spanIndices)[ i ]; j < fSourceSpans.GetCount(); j++ )
|
||
|
fSourceSpans[ j ]->fSpanRefIndex = j;
|
||
|
}
|
||
|
fSpans[ (*spanIndices)[ i ] ]->Destroy();
|
||
|
fSpans.Remove( (*spanIndices)[ i ] );
|
||
|
idxRemoving = fSpanSourceIndices[ (*spanIndices)[ i ] ];
|
||
|
fSpanSourceIndices.Remove( (*spanIndices)[ i ] );
|
||
|
|
||
|
switch( idxRemoving & kSpanTypeMask )
|
||
|
{
|
||
|
case kSpanTypeIcicle: fIcicles.Remove( idxRemoving & kSpanIDMask ); break;
|
||
|
case kSpanTypeParticleSpan: fParticleSpans.Remove( idxRemoving & kSpanIDMask ); break;
|
||
|
}
|
||
|
|
||
|
// Do this AFTER the span array has been updated
|
||
|
ICheckToRemoveMaterial( materialIdx );
|
||
|
|
||
|
/// Go adjusting the source indices
|
||
|
for( j = 0; j < fSpanSourceIndices.GetCount(); j++ )
|
||
|
{
|
||
|
if( ( ( fSpanSourceIndices[ j ] ^ idxRemoving ) & kSpanTypeMask ) == 0 )
|
||
|
{
|
||
|
/// Same type
|
||
|
k = fSpanSourceIndices[ j ] & kSpanIDMask;
|
||
|
if( k > ( idxRemoving & kSpanIDMask ) )
|
||
|
{
|
||
|
k--;
|
||
|
fSpanSourceIndices[ j ] &= kSpanTypeMask;
|
||
|
fSpanSourceIndices[ j ] |= k;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#ifndef MF_RENDDEP
|
||
|
/// Go adjusting indices in the DI index list
|
||
|
for( j = 0; j < fDIIndices.GetCount(); j++ )
|
||
|
{
|
||
|
if( !fDIIndices[ j ]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( k = 0; k < fDIIndices[ j ]->GetCount(); k++ )
|
||
|
{
|
||
|
if( (*fDIIndices[ j ])[ k ] > (*spanIndices)[ i ] )
|
||
|
(*fDIIndices[ j ])[ k ]--;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#else MF_RENDDEP
|
||
|
spanInverseTable[(*spanIndices)[i]] = -1;
|
||
|
for( j = (*spanIndices)[i]; j < fSpans.GetCount(); j++ )
|
||
|
spanInverseTable[j]--;
|
||
|
#endif // MF_RENDDEP
|
||
|
|
||
|
}
|
||
|
#ifdef MF_RENDDEP
|
||
|
for( j = 0; j < fDIIndices.GetCount(); j++ )
|
||
|
{
|
||
|
if( !fDIIndices[j]->IsMatrixOnly() )
|
||
|
{
|
||
|
for( k = 0; k < fDIIndices[j]->GetCount(); k++ )
|
||
|
{
|
||
|
int idx = (*fDIIndices[j])[k];
|
||
|
hsAssert(idx >= 0, "Just deleted a span another DI was pointing at");
|
||
|
(*fDIIndices[j])[k] = spanInverseTable[idx];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif // MF_RENDDEP
|
||
|
|
||
|
/// Rebuild the pointer array, since it's now invalid
|
||
|
IRebuildSpanArray();
|
||
|
|
||
|
/// Flag that we need garbage cleanup now
|
||
|
fNeedCleanup = true;
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
/// Clear this entry. Note: DON'T DELETE IT! Otherwise they'll be hell
|
||
|
/// to pay. Just clear it, so if we go looking for a free index, we just
|
||
|
/// look for one with zero spans.
|
||
|
spanIndices->Reset();
|
||
|
|
||
|
/// All done!
|
||
|
}
|
||
|
|
||
|
//// IRebuildSpanArray ///////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::IRebuildSpanArray( void )
|
||
|
{
|
||
|
UInt32 j, i;
|
||
|
plIcicle *icicle = nil;
|
||
|
|
||
|
|
||
|
for( j = 0; j < fSpans.GetCount(); j++ )
|
||
|
{
|
||
|
switch( fSpanSourceIndices[ j ] & kSpanTypeMask )
|
||
|
{
|
||
|
case kSpanTypeIcicle:
|
||
|
icicle = &fIcicles[ fSpanSourceIndices[ j ] & kSpanIDMask ];
|
||
|
fSpans[ j ] = (plSpan *)icicle;
|
||
|
if( icicle->fSortData != nil )
|
||
|
{
|
||
|
// GOTTA RESET THE SPAN INDICES TOO!!!
|
||
|
for( i = 0; i < icicle->fILength / 3; i++ )
|
||
|
icicle->fSortData[ i ].fSpanIndex = (UInt16)j;
|
||
|
}
|
||
|
break;
|
||
|
case kSpanTypeParticleSpan:
|
||
|
fSpans[ j ] = (plSpan *)&fParticleSpans[ fSpanSourceIndices[ j ] & kSpanIDMask ];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Redid the span array, so cause the space tree to rebuild to match
|
||
|
SetSpaceTree( nil );
|
||
|
|
||
|
// Rebuild bit vectors for various span types
|
||
|
IBuildVectors();
|
||
|
}
|
||
|
|
||
|
|
||
|
//// ICleanupMatrices
|
||
|
// Find all the matrix slots in the palette that aren't being used, collapse
|
||
|
// them out and adjust the indices into the matrix palette (the MatrixOnly DIIndices)
|
||
|
void plDrawableSpans::ICleanupMatrices()
|
||
|
{
|
||
|
// We really don't want to do this at runtime. The spans as read in have their bone
|
||
|
// matrices fixed (via plSpan::fBaseMatrix && plSpan::fNumMatrices). We can't just
|
||
|
// change where in our palette (fLocalToWorlds) bones will point, because the skinned spans
|
||
|
// will still be looking in the same place. I'm not sure why we'd want to either.
|
||
|
// Commenting out for the moment (so things will work), will look into why this was
|
||
|
// ever here, and more mysterious, how it ever worked. mf
|
||
|
#if 0
|
||
|
hsBitVector usedMatrices;
|
||
|
|
||
|
int i, j, k;
|
||
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
{
|
||
|
plDISpanIndex& indices = *fDIIndices[i];
|
||
|
if( indices.IsMatrixOnly() )
|
||
|
{
|
||
|
for( j = 0; j < indices.GetCount(); j++ )
|
||
|
usedMatrices.SetBit(indices[j]);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for( j = 0; j < fLocalToWorlds.GetCount(); j++ )
|
||
|
{
|
||
|
if( !usedMatrices.IsBitSet(j) )
|
||
|
{
|
||
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
{
|
||
|
plDISpanIndex& indices = *fDIIndices[i];
|
||
|
if( indices.IsMatrixOnly() )
|
||
|
{
|
||
|
for( k = 0; k < indices.GetCount(); k++ )
|
||
|
{
|
||
|
if( indices[k] > j )
|
||
|
indices[k]--;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
for( i = j+1; i < fLocalToWorlds.GetCount(); i++ )
|
||
|
{
|
||
|
fLocalToWorlds[i] = fLocalToWorlds[i-1];
|
||
|
fWorldToLocals[i] = fWorldToLocals[i-1];
|
||
|
fLocalToBones[i] = fLocalToBones[i-1];
|
||
|
fBoneToLocals[i] = fBoneToLocals[i-1];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
//// IRemoveGarbage //////////////////////////////////////////////////////////
|
||
|
// Cleans out all the unused spans. Oh, joy.
|
||
|
|
||
|
void plDrawableSpans::IRemoveGarbage( void )
|
||
|
{
|
||
|
int groupIdx, ibIdx, i, j, k, count, offset;
|
||
|
|
||
|
hsTArray<hsTArray<bool> *> usedFlags;
|
||
|
hsTArray<hsTArray<hsTArray<bool> *> *> usedIdxFlags;
|
||
|
plGBufferGroup *group;
|
||
|
|
||
|
|
||
|
ICleanupMatrices();
|
||
|
|
||
|
/// Getting rid of verts
|
||
|
usedFlags.SetCount( fGroups.GetCount() );
|
||
|
usedIdxFlags.SetCount( fGroups.GetCount() );
|
||
|
for( i = 0; i < fGroups.GetCount(); i++ )
|
||
|
{
|
||
|
hsAssert( fGroups[ i ]->GetNumVertexBuffers() == 1, "Cannot clean garbage on a non-volatile buffer group!" );
|
||
|
usedFlags[ i ] = TRACKED_NEW hsTArray<bool>;
|
||
|
usedFlags[ i ]->SetCountAndZero( fGroups[ i ]->GetVertBufferCount( 0 ) );
|
||
|
|
||
|
usedIdxFlags[ i ] = TRACKED_NEW hsTArray<hsTArray<bool> *>;
|
||
|
usedIdxFlags[ i ]->SetCount( fGroups[ i ]->GetNumIndexBuffers() );
|
||
|
for( j = 0; j < fGroups[ i ]->GetNumIndexBuffers(); j++ )
|
||
|
{
|
||
|
(*usedIdxFlags[ i ])[ j ] = TRACKED_NEW hsTArray<bool>;
|
||
|
(*usedIdxFlags[ i ])[ j ]->SetCountAndZero( fGroups[ i ]->GetIndexBufferCount( j ) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for( i = 0; i < fIcicles.GetCount(); i++ )
|
||
|
{
|
||
|
// Set the flags so we know these verts are used
|
||
|
groupIdx = fIcicles[ i ].fGroupIdx;
|
||
|
|
||
|
for( j = fIcicles[ i ].fCellOffset; j < fIcicles[ i ].fCellOffset + fIcicles[ i ].fVLength; j++ )
|
||
|
(*usedFlags[ groupIdx ])[ j ] = true;
|
||
|
|
||
|
for( j = fIcicles[ i ].fIStartIdx; j < fIcicles[ i ].fIStartIdx + fIcicles[ i ].fILength; j++ )
|
||
|
(*((*usedIdxFlags[ groupIdx ])[ fIcicles[ i ].fIBufferIdx ]))[ j ] = true;
|
||
|
}
|
||
|
for( i = 0; i < fParticleSpans.GetCount(); i++ )
|
||
|
{
|
||
|
// Set the flags so we know these verts are used
|
||
|
groupIdx = fParticleSpans[ i ].fGroupIdx;
|
||
|
|
||
|
for( j = fParticleSpans[ i ].fCellOffset; j < fParticleSpans[ i ].fCellOffset + fParticleSpans[ i ].fVLength; j++ )
|
||
|
(*usedFlags[ groupIdx ])[ j ] = true;
|
||
|
|
||
|
for( j = fParticleSpans[ i ].fIStartIdx; j < fParticleSpans[ i ].fIStartIdx + fParticleSpans[ i ].fILength; j++ )
|
||
|
(*((*usedIdxFlags[ groupIdx ])[ fParticleSpans[ i ].fIBufferIdx ]))[ j ] = true;
|
||
|
}
|
||
|
|
||
|
/// Now loop through and delete any unused
|
||
|
for( groupIdx = 0; groupIdx < fGroups.GetCount(); groupIdx++ )
|
||
|
{
|
||
|
group = fGroups[ groupIdx ];
|
||
|
hsTArray<bool> &uFlags = *usedFlags[ groupIdx ];
|
||
|
|
||
|
// Find groups of verts to delete!
|
||
|
count = uFlags.GetCount();
|
||
|
for( i = 0; i < count; )
|
||
|
{
|
||
|
// Skip through used verts
|
||
|
for( ; i < count && uFlags[ i ] == true; i++ );
|
||
|
|
||
|
// Find span of unused verts
|
||
|
for( j = i; j < count && uFlags[ j ] == false; j++ );
|
||
|
|
||
|
if( j > i )
|
||
|
{
|
||
|
// Delete this span of vertices
|
||
|
group->DeleteVertsFromStorage( 0, i, j - i );
|
||
|
|
||
|
// Adjust indices in this group
|
||
|
for( ibIdx = 0; ibIdx < group->GetNumIndexBuffers(); ibIdx++ )
|
||
|
group->AdjustIndicesInStorage( ibIdx, i, -(Int16)( j - i ) );
|
||
|
|
||
|
// Adjust spans that use this vertex buffer
|
||
|
for( k = 0; k < fIcicles.GetCount(); k++ )
|
||
|
{
|
||
|
if( fIcicles[ k ].fGroupIdx == groupIdx && fIcicles[ k ].fVBufferIdx == 0 &&
|
||
|
fIcicles[ k ].fCellOffset >= i )
|
||
|
fIcicles[ k ].fCellOffset -= j - i;
|
||
|
|
||
|
// Adjust sorting data, if necessary
|
||
|
if( fIcicles[ k ].fSortData != nil )
|
||
|
IAdjustSortData( fIcicles[ k ].fSortData, fIcicles[ k ].fILength / 3, i, -(Int16)( j - i ) );
|
||
|
}
|
||
|
for( k = 0; k < fParticleSpans.GetCount(); k++ )
|
||
|
{
|
||
|
if( fParticleSpans[ k ].fGroupIdx == groupIdx && fParticleSpans[ k ].fVBufferIdx == 0 &&
|
||
|
fParticleSpans[ k ].fCellOffset >= i )
|
||
|
fParticleSpans[ k ].fCellOffset -= j - i;
|
||
|
|
||
|
// Adjust sorting data, if necessary
|
||
|
if( fParticleSpans[ k ].fSortData != nil )
|
||
|
IAdjustSortData( fParticleSpans[ k ].fSortData, fParticleSpans[ k ].fILength / 3, i, -(Int16)( j - i ) );
|
||
|
}
|
||
|
|
||
|
// Move the flags too, lest we start deleting the wrong vertices
|
||
|
count -= j - i;
|
||
|
for( offset = j - i; i < count; i++ )
|
||
|
uFlags[ i ] = uFlags[ i + offset ];
|
||
|
}
|
||
|
|
||
|
// Keep going
|
||
|
i = j;
|
||
|
}
|
||
|
|
||
|
/// Getting rid of indices now
|
||
|
/// IF WE ARE SORTING, then the fIStartIdx positions of the spans are not necessarily
|
||
|
/// valid (since they're refreshed every frame, and not all are guaranteed to be refreshed).
|
||
|
/// However, since we will be refilling the buffer next frame anyway, it doesn't really
|
||
|
/// matter <crosses fingers> WHAT indices we delete, so long as the total length of the
|
||
|
/// buffer is correct.
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
for( ibIdx = 0; ibIdx < group->GetNumIndexBuffers(); ibIdx++ )
|
||
|
{
|
||
|
// For this index buffer, find the total length we want
|
||
|
i = 0;
|
||
|
for( j = 0; j < fIcicles.GetCount(); j++ )
|
||
|
{
|
||
|
if( fIcicles[ j ].fGroupIdx == groupIdx && fIcicles[ j ].fIBufferIdx == ibIdx )
|
||
|
i += fIcicles[ j ].fILength;
|
||
|
}
|
||
|
for( j = 0; j < fParticleSpans.GetCount(); j++ )
|
||
|
{
|
||
|
if( fParticleSpans[ j ].fGroupIdx == groupIdx && fParticleSpans[ j ].fIBufferIdx == ibIdx )
|
||
|
i += fParticleSpans[ j ].fILength;
|
||
|
}
|
||
|
|
||
|
/// i is the total length
|
||
|
group->DeleteIndicesFromStorage( ibIdx, i, group->GetIndexBufferCount( ibIdx ) - i );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/// Non-sorting, we have to figure out exactly which indices we aren't using
|
||
|
|
||
|
for( ibIdx = 0; ibIdx < group->GetNumIndexBuffers(); ibIdx++ )
|
||
|
{
|
||
|
hsTArray<bool> &uiFlags = *((*usedIdxFlags[ groupIdx ])[ ibIdx ]);
|
||
|
|
||
|
// Find groups of indices to delete!
|
||
|
count = uiFlags.GetCount();
|
||
|
for( i = 0; i < count; )
|
||
|
{
|
||
|
// Skip through used verts
|
||
|
for( ; i < count && uiFlags[ i ] == true; i++ );
|
||
|
|
||
|
// Find span of unused verts
|
||
|
for( j = i; j < count && uiFlags[ j ] == false; j++ );
|
||
|
|
||
|
if( j > i )
|
||
|
{
|
||
|
// Delete this span of indices
|
||
|
group->DeleteIndicesFromStorage( ibIdx, i, j - i );
|
||
|
|
||
|
// Adjust spans that use this index buffer (only icicles use them)
|
||
|
for( k = 0; k < fIcicles.GetCount(); k++ )
|
||
|
{
|
||
|
if( fIcicles[ k ].fGroupIdx == groupIdx && fIcicles[ k ].fIBufferIdx == ibIdx &&
|
||
|
fIcicles[ k ].fIStartIdx >= i )
|
||
|
{
|
||
|
fIcicles[k].fIPackedIdx = (fIcicles[ k ].fIStartIdx -= j - i);
|
||
|
}
|
||
|
}
|
||
|
// and particle spans :)
|
||
|
for( k = 0; k < fParticleSpans.GetCount(); k++ )
|
||
|
{
|
||
|
if( fParticleSpans[ k ].fGroupIdx == groupIdx && fParticleSpans[ k ].fIBufferIdx == ibIdx &&
|
||
|
fParticleSpans[ k ].fIStartIdx >= i )
|
||
|
{
|
||
|
fParticleSpans[k].fIPackedIdx = (fParticleSpans[ k ].fIStartIdx -= j - i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Move the flags too, lest we start deleting the wrong vertices
|
||
|
count -= j - i;
|
||
|
for( offset = j - i; i < count; i++ )
|
||
|
uiFlags[ i ] = uiFlags[ i + offset ];
|
||
|
}
|
||
|
|
||
|
// Keep going
|
||
|
i = j;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Refresh all vStartIdx entries
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[ i ]->fTypeMask & plSpan::kVertexSpan )
|
||
|
{
|
||
|
plVertexSpan *vtx = (plVertexSpan *)fSpans[ i ];
|
||
|
vtx->fVStartIdx = fGroups[ vtx->fGroupIdx ]->GetVertStartFromCell( vtx->fVBufferIdx, vtx->fCellIdx, vtx->fCellOffset );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Destroy!!!
|
||
|
for( i = 0; i < usedFlags.GetCount(); i++ )
|
||
|
delete usedFlags[ i ];
|
||
|
usedFlags.Reset();
|
||
|
|
||
|
for( i = 0; i < usedIdxFlags.GetCount(); i++ )
|
||
|
{
|
||
|
for( j = 0; j < usedIdxFlags[ i ]->GetCount(); j++ )
|
||
|
delete ((*usedIdxFlags[ i ])[ j ]);
|
||
|
delete usedIdxFlags[ i ];
|
||
|
}
|
||
|
usedIdxFlags.Reset();
|
||
|
|
||
|
/// This will let us query the buffer group as to whether its ready to render or not.
|
||
|
/// If not, we'll force it then to reload from its storage
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
// Whew!
|
||
|
fNeedCleanup = false;
|
||
|
}
|
||
|
|
||
|
//// IAdjustSortData /////////////////////////////////////////////////////////
|
||
|
// Adjusts the indices in the given sort data, using the delta and threshhold
|
||
|
// given.
|
||
|
|
||
|
void plDrawableSpans::IAdjustSortData( plGBufferTriangle *triList, UInt32 count, UInt32 threshhold, Int32 delta )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
|
||
|
|
||
|
for( i = 0; i < count; i++ )
|
||
|
{
|
||
|
if( triList[ i ].fIndex1 >= threshhold )
|
||
|
triList[ i ].fIndex1 = (UInt16)( triList[ i ].fIndex1 + delta );
|
||
|
if( triList[ i ].fIndex2 >= threshhold )
|
||
|
triList[ i ].fIndex2 = (UInt16)( triList[ i ].fIndex2 + delta );
|
||
|
if( triList[ i ].fIndex3 >= threshhold )
|
||
|
triList[ i ].fIndex3 = (UInt16)( triList[ i ].fIndex3 + delta );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//// IMakeSpanSortable ////////////////////////////////////////////////////////
|
||
|
// Given an index of a span, flags it sortable and creates the sorting data
|
||
|
// for that span.
|
||
|
|
||
|
void plDrawableSpans::IMakeSpanSortable( UInt32 index )
|
||
|
{
|
||
|
plIcicle *span = (plIcicle *)fSpans[ index ];
|
||
|
plGBufferTriangle *list;
|
||
|
|
||
|
|
||
|
if( span->fProps & plSpan::kPropFacesSortable )
|
||
|
return;
|
||
|
|
||
|
/// Create data for it
|
||
|
list = fGroups[ span->fGroupIdx ]->ConvertToTriList( (Int16)index, span->fIBufferIdx, span->fVBufferIdx, span->fCellIdx,
|
||
|
span->fIStartIdx, span->fILength / 3 );
|
||
|
if( list == nil )
|
||
|
return;
|
||
|
|
||
|
span->fSortData = list;
|
||
|
|
||
|
/// Mark as sortable
|
||
|
span->fProps |= plSpan::kPropFacesSortable;
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::UnPackCluster(plClusterGroup* cluster)
|
||
|
{
|
||
|
const UInt32 vertsPerInst = cluster->GetTemplate()->NumVerts();
|
||
|
const UInt32 idxPerInst = cluster->GetTemplate()->NumIndices();
|
||
|
|
||
|
const UInt32 numClust = cluster->GetNumClusters();
|
||
|
|
||
|
fVisSet |= cluster->GetVisSet();
|
||
|
fVisNot |= cluster->GetVisNot();
|
||
|
|
||
|
fIcicles.SetCount(numClust);
|
||
|
fSpans.SetCount(numClust);
|
||
|
int iSpan;
|
||
|
for( iSpan = 0; iSpan < numClust; iSpan++ )
|
||
|
fSpans[iSpan] = &fIcicles[iSpan];
|
||
|
iSpan = 0;
|
||
|
|
||
|
UInt32 vtxFormat =
|
||
|
cluster->GetTemplate()->NumUVWs()
|
||
|
| cluster->GetTemplate()->NumWeights() << 4;
|
||
|
if( cluster->GetTemplate()->NumWgtIdx() )
|
||
|
vtxFormat |= plGBufferGroup::kSkinIndices;
|
||
|
|
||
|
const hsTArray<plLightInfo*>& lights = cluster->GetLights();
|
||
|
|
||
|
int iStart;
|
||
|
for( iStart = 0; iStart < cluster->GetNumClusters(); )
|
||
|
{
|
||
|
int numVerts = 0;
|
||
|
int numIdx = 0;
|
||
|
int iEnd;
|
||
|
for( iEnd = iStart; iEnd < cluster->GetNumClusters(); iEnd++ )
|
||
|
{
|
||
|
numVerts += vertsPerInst * cluster->GetCluster(iEnd)->NumInsts();
|
||
|
numIdx += idxPerInst * cluster->GetCluster(iEnd)->NumInsts();
|
||
|
|
||
|
if( (numVerts > plGBufferGroup::kMaxNumVertsPerBuffer)
|
||
|
||(numIdx > plGBufferGroup::kMaxNumIndicesPerBuffer) )
|
||
|
{
|
||
|
// Oops, too much.
|
||
|
numVerts -= vertsPerInst * cluster->GetCluster(iEnd)->NumInsts();
|
||
|
numIdx -= idxPerInst * cluster->GetCluster(iEnd)->NumInsts();
|
||
|
|
||
|
iEnd--;
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Still in trouble here. We need to fake up that cell crap for each of
|
||
|
// our clusters to make a span for it. Whoo-hoo.
|
||
|
UInt8 grpIdx = IFindBufferGroup((UInt8)vtxFormat, numVerts, 0, false, false);
|
||
|
|
||
|
UInt32 vbufferIdx;
|
||
|
UInt32 cellIdx;
|
||
|
UInt32 cellOffset;
|
||
|
fGroups[grpIdx]->ReserveVertStorage(numVerts, &vbufferIdx, &cellIdx, &cellOffset, plGBufferGroup::kReserveInterleaved | plGBufferGroup::kReserveIsolate);
|
||
|
hsAssert(!cellOffset, "This should be our own personal group");
|
||
|
hsAssert(fGroups[grpIdx]->GetVertexSize() == cluster->GetTemplate()->Stride(), "Mismatch on src and dst sizes");
|
||
|
|
||
|
UInt32 ibufferIdx;
|
||
|
UInt32 istartIdx;
|
||
|
fGroups[grpIdx]->ReserveIndexStorage(numIdx, &ibufferIdx, &istartIdx);
|
||
|
UInt32 iOffset = 0;
|
||
|
|
||
|
UInt8* vData = fGroups[grpIdx]->GetVertBufferData(vbufferIdx);
|
||
|
UInt16* iData = fGroups[grpIdx]->GetIndexBufferData(ibufferIdx);
|
||
|
UInt8* pvData = vData;
|
||
|
UInt16* piData = iData;
|
||
|
int i;
|
||
|
for( i = iStart; i < iEnd; i++ )
|
||
|
{
|
||
|
hsBounds3Ext bnd;
|
||
|
cluster->GetCluster(i)->UnPack(pvData, piData, cellOffset, bnd);
|
||
|
fIcicles[iSpan].fLocalBounds = bnd;
|
||
|
fIcicles[iSpan].fWorldBounds = bnd;
|
||
|
|
||
|
fIcicles[iSpan].fTypeMask = plSpan::kSpan | plSpan::kVertexSpan | plSpan::kIcicleSpan;
|
||
|
// STUB - need to set whether strictly runtime lit or preshaded based on cluster.
|
||
|
// fIcicles[iSpan].fProps = plSpan::kLiteMaterial;
|
||
|
fIcicles[iSpan].fProps = plSpan::kLiteVtxNonPreshaded | plSpan::kPropRunTimeLight;
|
||
|
if (fProps & plSpan::kPropNoDraw)
|
||
|
fIcicles[iSpan].fProps |= plSpan::kPropNoDraw;
|
||
|
fIcicles[iSpan].fMaterialIdx = 0;
|
||
|
fIcicles[iSpan].fLocalToWorld.Reset();
|
||
|
fIcicles[iSpan].fWorldToLocal.Reset();
|
||
|
fIcicles[iSpan].fBaseMatrix = 0;
|
||
|
fIcicles[iSpan].fNumMatrices = 0;
|
||
|
fIcicles[iSpan].fLocalUVWChans = 0;
|
||
|
fIcicles[iSpan].fMaxBoneIdx = 0;
|
||
|
fIcicles[iSpan].fPenBoneIdx = 0;
|
||
|
fIcicles[iSpan].fFogEnvironment = nil;
|
||
|
fIcicles[iSpan].fMaxDist = cluster->GetLOD().fMaxDist;
|
||
|
fIcicles[iSpan].fMinDist = cluster->GetLOD().fMinDist;
|
||
|
fIcicles[iSpan].fWaterHeight = 0;
|
||
|
fIcicles[iSpan].fVisSet = cluster->GetVisSet();
|
||
|
fIcicles[iSpan].fVisNot = cluster->GetVisNot();
|
||
|
|
||
|
if( lights.GetCount() )
|
||
|
{
|
||
|
int iLight;
|
||
|
for( iLight = 0; iLight < lights.GetCount(); iLight++ )
|
||
|
fIcicles[iSpan].AddPermaLight(lights[iLight], lights[iLight]->GetProjection() != nil);
|
||
|
}
|
||
|
|
||
|
fIcicles[iSpan].fGroupIdx = grpIdx;
|
||
|
fIcicles[iSpan].fVBufferIdx = vbufferIdx;
|
||
|
fIcicles[iSpan].fCellIdx = cellIdx;
|
||
|
fIcicles[iSpan].fCellOffset = cellOffset;
|
||
|
fIcicles[iSpan].fVStartIdx = cellOffset;
|
||
|
const UInt32 numVerts = cluster->GetCluster(i)->NumInsts() * vertsPerInst;
|
||
|
fIcicles[iSpan].fVLength = numVerts;
|
||
|
cellOffset += numVerts;
|
||
|
|
||
|
fIcicles[iSpan].fIBufferIdx = ibufferIdx;
|
||
|
fIcicles[iSpan].fIPackedIdx = fIcicles[iSpan].fIStartIdx = iOffset;
|
||
|
const UInt32 iLength = cluster->GetCluster(i)->NumInsts() * cluster->GetTemplate()->NumIndices();
|
||
|
fIcicles[iSpan].fILength = iLength;
|
||
|
iOffset += iLength;
|
||
|
|
||
|
iSpan++;
|
||
|
|
||
|
const UInt32 vSize = cluster->GetCluster(i)->NumInsts() * cluster->GetTemplate()->VertSize();
|
||
|
pvData += vSize;
|
||
|
piData += iLength;
|
||
|
}
|
||
|
|
||
|
iStart = iEnd;
|
||
|
}
|
||
|
fMaterials.SetCountAndZero(1);
|
||
|
plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kMsgMaterial);
|
||
|
hsgResMgr::ResMgr()->SendRef(cluster->GetMaterial()->GetKey(), refMsg, plRefFlags::kActiveRef);
|
||
|
|
||
|
fRenderLevel = cluster->GetRenderLevel();
|
||
|
GetSpaceTree();
|
||
|
}
|
||
|
|
||
|
//// IFindBufferGroup ////////////////////////////////////////////////////////
|
||
|
|
||
|
UInt8 plDrawableSpans::IFindBufferGroup(UInt8 vtxFormat, UInt32 numVertsNeeded, int lod, hsBool vertVolatile, hsBool idxVolatile)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
|
||
|
// Scan through the buffer groups, looking for a good format. If there isn't
|
||
|
// one, add it
|
||
|
if( fProps & kPropVolatile )
|
||
|
vertVolatile = true;
|
||
|
if( fProps & kPropSortFaces )
|
||
|
idxVolatile = true;
|
||
|
|
||
|
for( i = 0; i < fGroups.GetCount(); i++ )
|
||
|
{
|
||
|
if( (fGroups[ i ]->GetVertexFormat() == vtxFormat)
|
||
|
&& (!vertVolatile == !fGroups[i]->AreVertsVolatile())
|
||
|
&& (!idxVolatile == !fGroups[i]->AreIdxVolatile())
|
||
|
&& (lod == fGroups[i]->GetLOD()) )
|
||
|
{
|
||
|
if( fGroups[ i ]->GetNumPrimaryVertsLeft() >= numVertsNeeded )
|
||
|
return i;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Add a new one of the right format
|
||
|
fGroups.Append( TRACKED_NEW plGBufferGroup(vtxFormat, vertVolatile, idxVolatile, lod) );
|
||
|
return i;
|
||
|
}
|
||
|
|
||
|
//// GetParticleSpanVector ///////////////////////////////////////////////////
|
||
|
// Get a bitVector of the spans that are particle spans
|
||
|
|
||
|
hsBitVector const &plDrawableSpans::GetParticleSpanVector( void ) const
|
||
|
{
|
||
|
return fParticleSpanVector;
|
||
|
}
|
||
|
|
||
|
//// GetBlendingSpanVector ///////////////////////////////////////////////////
|
||
|
// Get a bitVector of the spans that are blending (i.e. numMatrices > 0)
|
||
|
|
||
|
hsBitVector const &plDrawableSpans::GetBlendingSpanVector( void ) const
|
||
|
{
|
||
|
/// See the plRenderMsg handler for why we do this
|
||
|
return fFakeBlendingSpanVector;
|
||
|
}
|
||
|
|
||
|
//// SetBlendingSpanVectorBit ////////////////////////////////////////////////
|
||
|
// Could just make GetBlendingSpanVector() non-const, but this way it's harder
|
||
|
// for the end user, thus I'm hoping to discourage them from doing it too much.
|
||
|
|
||
|
void plDrawableSpans::SetBlendingSpanVectorBit( UInt32 bitNumber, hsBool on )
|
||
|
{
|
||
|
fFakeBlendingSpanVector.SetBit( bitNumber, on );
|
||
|
}
|
||
|
|
||
|
//// IBuildVectors ///////////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::IBuildVectors( void )
|
||
|
{
|
||
|
int i;
|
||
|
bool needRenderMsg = false;
|
||
|
|
||
|
|
||
|
fParticleSpanVector.Clear();
|
||
|
fBlendingSpanVector.Clear();
|
||
|
for( i = 0; i < fSpans.GetCount(); i++ )
|
||
|
{
|
||
|
if( fSpans[ i ]->fTypeMask & plSpan::kParticleSpan )
|
||
|
fParticleSpanVector.SetBit( i );
|
||
|
// BoneUpdate
|
||
|
if( ( fSpans[ i ]->fTypeMask & plSpan::kVertexSpan ) && (fSpans[ i ]->fNumMatrices > 2) )
|
||
|
// if( ( fSpans[ i ]->fTypeMask & plSpan::kVertexSpan ) && (fSpans[ i ]->fNumMatrices > 1) )
|
||
|
{
|
||
|
fBlendingSpanVector.SetBit( i );
|
||
|
needRenderMsg = true;
|
||
|
}
|
||
|
}
|
||
|
// Reset this sucker too
|
||
|
fFakeBlendingSpanVector = fBlendingSpanVector;
|
||
|
|
||
|
if( needRenderMsg && !fRegisteredForRender )
|
||
|
{
|
||
|
// Placeholder hack - see IUpdateMatrixPaletteBoundsHack() for comments
|
||
|
fRegisteredForRender = true;
|
||
|
plgDispatch::Dispatch()->RegisterForExactType( plRenderMsg::Index(), GetKey() );
|
||
|
}
|
||
|
else if( !needRenderMsg && fRegisteredForRender )
|
||
|
{
|
||
|
plgDispatch::Dispatch()->UnRegisterForExactType( plRenderMsg::Index(), GetKey() );
|
||
|
fRegisteredForRender = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
//// Particle Sets ///////////////////////////////////////////////////////////
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//// CreateParticleSystem ////////////////////////////////////////////////////
|
||
|
|
||
|
UInt32 plDrawableSpans::CreateParticleSystem( UInt32 maxNumSpans, UInt32 maxNumParticles, hsGMaterial *material )
|
||
|
{
|
||
|
UInt32 i, numVerts, numIndices;
|
||
|
plParticleSet *set;
|
||
|
plDISpanIndex *spanLookup;
|
||
|
|
||
|
|
||
|
// Make a shiny new set
|
||
|
set = TRACKED_NEW plParticleSet;
|
||
|
set->fRefCount = 0;
|
||
|
|
||
|
/// Fill out info
|
||
|
numVerts = maxNumParticles * 4; // 4 verts per particle
|
||
|
numIndices = maxNumParticles * 6; // 6 indices per particle
|
||
|
|
||
|
if( material != nil && material->GetLayer( 0 ) != nil && material->GetLayer( 0 )->GetTexture() != nil )
|
||
|
set->fFormat = plGeometrySpan::UVCountToFormat( 1 );
|
||
|
else
|
||
|
set->fFormat = plGeometrySpan::UVCountToFormat( 0 );
|
||
|
|
||
|
// Reserve space
|
||
|
set->fGroupIdx = IFindBufferGroup( set->fFormat, numVerts, 0, true, false ); // Force them to volatile even if the drawable isn't
|
||
|
fGroups[ set->fGroupIdx ]->ReserveVertStorage( numVerts, &set->fVBufferIdx, &set->fCellIdx, &set->fCellOffset, plGBufferGroup::kReserveInterleaved | plGBufferGroup::kReserveIsolate );
|
||
|
fGroups[ set->fGroupIdx ]->ReserveIndexStorage( numIndices, &set->fIBufferIdx, &set->fIStartIdx );
|
||
|
|
||
|
set->fVStartIdx = fGroups[ set->fGroupIdx ]->GetVertStartFromCell( set->fVBufferIdx, set->fCellIdx, set->fCellOffset );
|
||
|
set->fVLength = numVerts;
|
||
|
set->fILength = numIndices;
|
||
|
|
||
|
UInt32 vIdx = set->fVStartIdx;
|
||
|
UInt16* idx = fGroups[set->fGroupIdx]->GetIndexBufferData(set->fIBufferIdx) + set->fIStartIdx;
|
||
|
for( i = 0; i < maxNumParticles; i++ )
|
||
|
{
|
||
|
*idx++ = (UInt16)vIdx;
|
||
|
*idx++ = (UInt16)(vIdx + 1);
|
||
|
*idx++ = (UInt16)(vIdx + 2);
|
||
|
|
||
|
*idx++ = (UInt16)vIdx;
|
||
|
*idx++ = (UInt16)(vIdx + 2);
|
||
|
*idx++ = (UInt16)(vIdx + 3);
|
||
|
|
||
|
vIdx += 4;
|
||
|
}
|
||
|
|
||
|
// Create us some spans
|
||
|
set->fDIEntry = -1;
|
||
|
spanLookup = IFindDIIndices( set->fDIEntry );
|
||
|
spanLookup->fFlags |= plDISpanIndex::kDontTransformSpans;
|
||
|
|
||
|
set->fNumSpans = maxNumSpans;
|
||
|
for( i = 0; i < maxNumSpans; i++ )
|
||
|
ICreateParticleIcicle( material, set );
|
||
|
|
||
|
set->fNextIStartIdx = set->fIStartIdx;
|
||
|
set->fNextVStartIdx = set->fVStartIdx;
|
||
|
set->fNextCellOffset = set->fCellOffset;
|
||
|
|
||
|
|
||
|
/// Rebuild the pointer array
|
||
|
IRebuildSpanArray();
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
return set->fDIEntry;
|
||
|
}
|
||
|
|
||
|
//// IAssignMatIdxToSpan /////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::IAssignMatIdxToSpan( plSpan *span, hsGMaterial *mtl )
|
||
|
{
|
||
|
fSettingMatIdxLock = true;
|
||
|
|
||
|
if( mtl != nil )
|
||
|
span->fMaterialIdx = IAddAMaterial( mtl );
|
||
|
|
||
|
if( fMaterials[ span->fMaterialIdx ] != nil )
|
||
|
{
|
||
|
if( ITestMatForSpecularity( fMaterials[ span->fMaterialIdx ] ) )
|
||
|
span->fProps |= plSpan::kPropMatHasSpecular;
|
||
|
else
|
||
|
span->fProps &= ~plSpan::kPropMatHasSpecular;
|
||
|
}
|
||
|
|
||
|
fSettingMatIdxLock = false;
|
||
|
}
|
||
|
|
||
|
//// ICreateParticleIcicle ///////////////////////////////////////////////////
|
||
|
// Creates a shiny new plIcicle for use with particle sets.
|
||
|
|
||
|
plParticleSpan *plDrawableSpans::ICreateParticleIcicle( hsGMaterial *material, plParticleSet *set )
|
||
|
{
|
||
|
UInt32 spanIdx;
|
||
|
hsMatrix44 ident;
|
||
|
plDISpanIndex *spanLookup;
|
||
|
|
||
|
|
||
|
/// Ahh, an icicle span
|
||
|
spanIdx = fParticleSpans.GetCount();
|
||
|
fParticleSpans.Append( plParticleSpan() );
|
||
|
plParticleSpan *icicle = &fParticleSpans[ spanIdx ];
|
||
|
|
||
|
ident.Reset();
|
||
|
IAssignMatIdxToSpan( icicle, material );
|
||
|
icicle->fMaterialIdx = IAddAMaterial( material );
|
||
|
icicle->fLocalToWorld = ident;
|
||
|
icicle->fWorldToLocal = ident;
|
||
|
icicle->fProps |= plSpan::kPropRunTimeLight | plSpan::kPropNoDraw | plSpan::kLiteVtxPreshaded;
|
||
|
if( fProps & kPropSortSpans )
|
||
|
icicle->fProps |= plSpan::kPropFacesSortable;
|
||
|
|
||
|
icicle->fLocalBounds.MakeEmpty();
|
||
|
icicle->fWorldBounds.MakeEmpty();
|
||
|
|
||
|
icicle->fLocalBounds.Union( &hsPoint3(0,0,0) );
|
||
|
icicle->fWorldBounds.Union( &hsPoint3(0,0,0) );
|
||
|
|
||
|
icicle->fGroupIdx = set->fGroupIdx;
|
||
|
icicle->fVBufferIdx = set->fVBufferIdx;
|
||
|
icicle->fCellIdx = set->fCellIdx;
|
||
|
icicle->fCellOffset = set->fCellOffset;
|
||
|
icicle->fVStartIdx = set->fVStartIdx;
|
||
|
icicle->fVLength = 0;
|
||
|
|
||
|
icicle->fIBufferIdx = set->fIBufferIdx;
|
||
|
icicle->fIPackedIdx = icicle->fIStartIdx = set->fIStartIdx;
|
||
|
icicle->fILength = 0;
|
||
|
icicle->fFogEnvironment = nil;
|
||
|
icicle->fSortData = nil;
|
||
|
|
||
|
icicle->fSrcSpanIdx = fSpans.GetCount();
|
||
|
|
||
|
spanLookup = IFindDIIndices( set->fDIEntry );
|
||
|
spanLookup->Append( fSpans.GetCount() );
|
||
|
fSpans.Append( (plSpan *)icicle );
|
||
|
fSpanSourceIndices.Append( spanIdx | kSpanTypeParticleSpan );
|
||
|
|
||
|
/// Set our pointer to the set and inc it's refCount
|
||
|
icicle->fParentSet = set;
|
||
|
set->fRefCount++;
|
||
|
|
||
|
/// Flag that we need garbage cleanup now
|
||
|
fNeedCleanup = true;
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
// Cause us to rebuild the space tree when needed
|
||
|
SetSpaceTree( nil );
|
||
|
|
||
|
return icicle;
|
||
|
}
|
||
|
|
||
|
//// ResetParticleSystem /////////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::ResetParticleSystem( UInt32 setIndex )
|
||
|
{
|
||
|
UInt32 i;
|
||
|
plDISpanIndex *indices = IFindDIIndices( setIndex );
|
||
|
plParticleSet *set;
|
||
|
plParticleSpan *span;
|
||
|
|
||
|
for( i = 0; i < indices->GetCount(); i++ )
|
||
|
{
|
||
|
span = (plParticleSpan *)fSpans[ (*indices)[ i ] ];
|
||
|
span->fVStartIdx = 0;
|
||
|
span->fCellIdx = 0;
|
||
|
span->fCellOffset = 0;
|
||
|
span->fVLength = 0;
|
||
|
span->fIPackedIdx = span->fIStartIdx = 0;
|
||
|
span->fILength = 0;
|
||
|
span->fSource = nil;
|
||
|
span->fProps |= plSpan::kPropNoDraw;
|
||
|
GetSpaceTree()->SetLeafFlag( (Int16)(span->fSrcSpanIdx), plSpaceTreeNode::kDisabled );
|
||
|
|
||
|
set = span->fParentSet; // To use at the end of the loop
|
||
|
}
|
||
|
|
||
|
set->fNextIStartIdx = set->fIStartIdx;
|
||
|
set->fNextVStartIdx = set->fVStartIdx;
|
||
|
set->fNextCellOffset = set->fCellOffset;
|
||
|
|
||
|
fGroups[set->fGroupIdx]->SetVertBufferEnd(set->fVBufferIdx, set->fNextVStartIdx);
|
||
|
if( fProps & kPropSortFaces )
|
||
|
fGroups[set->fGroupIdx]->SetIndexBufferEnd(set->fIBufferIdx, set->fNextIStartIdx);
|
||
|
}
|
||
|
|
||
|
|
||
|
//// AssignEmitterToParticleSystem ///////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::AssignEmitterToParticleSystem( UInt32 setIndex, plParticleEmitter *emitter )
|
||
|
{
|
||
|
plDISpanIndex *indices = IFindDIIndices( setIndex );
|
||
|
plParticleSet *set;
|
||
|
plParticleSpan *icicle;
|
||
|
UInt32 i, index, numParticles = emitter->GetParticleCount();
|
||
|
plParticleCore *array = emitter->GetParticleArray();
|
||
|
hsMatrix44 ident;
|
||
|
|
||
|
plGBufferTriangle *sortArray;
|
||
|
|
||
|
|
||
|
icicle = (plParticleSpan *)fSpans[ (*indices)[ emitter->GetSpanIndex() ] ];
|
||
|
set = icicle->fParentSet;
|
||
|
|
||
|
icicle->fCellIdx = set->fCellIdx;
|
||
|
icicle->fCellOffset = set->fNextCellOffset;
|
||
|
icicle->fVStartIdx = set->fNextVStartIdx;
|
||
|
icicle->fIPackedIdx = icicle->fIStartIdx = set->fNextIStartIdx;
|
||
|
icicle->fVLength = numParticles * 4;
|
||
|
icicle->fILength = numParticles * 6;
|
||
|
icicle->fSource = emitter;
|
||
|
icicle->fProps &= ~plSpan::kPropNoDraw;
|
||
|
GetSpaceTree()->ClearLeafFlag( (Int16)(icicle->fSrcSpanIdx), plSpaceTreeNode::kDisabled );
|
||
|
icicle->fNumParticles = numParticles;
|
||
|
set->fNextVStartIdx += numParticles * 4;
|
||
|
set->fNextIStartIdx += numParticles * 6;
|
||
|
set->fNextCellOffset += numParticles * 4;
|
||
|
|
||
|
fGroups[set->fGroupIdx]->SetVertBufferEnd(set->fVBufferIdx, set->fNextVStartIdx);
|
||
|
if( fProps & kPropSortFaces )
|
||
|
fGroups[set->fGroupIdx]->SetIndexBufferEnd(set->fIBufferIdx, set->fNextIStartIdx);
|
||
|
|
||
|
hsAssert( set->fNextVStartIdx <= set->fVStartIdx + set->fVLength, "Buffer overflow in AddParticlesToSet()" );
|
||
|
hsAssert( set->fNextIStartIdx <= set->fIStartIdx + set->fILength, "Buffer overflow in AddParticlesToSet()" );
|
||
|
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
// Prep sorting data
|
||
|
if( icicle->fSortData == nil || icicle->fSortCount < ( numParticles << 1 ) )
|
||
|
{
|
||
|
delete [] icicle->fSortData;
|
||
|
icicle->fSortData = sortArray = TRACKED_NEW plGBufferTriangle[ numParticles << 1 ];
|
||
|
icicle->fSortCount = numParticles << 1;
|
||
|
}
|
||
|
else
|
||
|
sortArray = icicle->fSortData;
|
||
|
|
||
|
// Find our bounds and fill out sorting data
|
||
|
for( i = 0, index = icicle->fVStartIdx; i < numParticles; i++ )
|
||
|
{
|
||
|
sortArray->fCenter = array[ i ].fPos;
|
||
|
sortArray->fIndex1 = (UInt16)index;
|
||
|
sortArray->fIndex2 = (UInt16)(index + 1);
|
||
|
sortArray->fIndex3 = (UInt16)(index + 2);
|
||
|
sortArray->fSpanIndex = (UInt16)(icicle->fSrcSpanIdx);
|
||
|
sortArray++;
|
||
|
|
||
|
sortArray->fCenter = array[ i ].fPos;
|
||
|
sortArray->fIndex1 = (UInt16)index;
|
||
|
sortArray->fIndex2 = (UInt16)(index + 2);
|
||
|
sortArray->fIndex3 = (UInt16)(index + 3);
|
||
|
sortArray->fSpanIndex = (UInt16)(icicle->fSrcSpanIdx);
|
||
|
sortArray++;
|
||
|
|
||
|
index += 4;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
icicle->fLocalBounds = emitter->GetBoundingBox();
|
||
|
icicle->fWorldBounds = icicle->fLocalBounds;
|
||
|
|
||
|
GetSpaceTree()->MoveLeaf( (Int16)(icicle->fSrcSpanIdx), icicle->fWorldBounds );
|
||
|
// Done for now, we'll fill on the pipeline side
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
//// Dynamic Functions for SceneViewer ///////////////////////////////////////
|
||
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
//// RefreshDISpans //////////////////////////////////////////////////////////
|
||
|
// Given a set of plGeometrySpans, replaces the data in the given DI span set
|
||
|
// with the vertices in the plGeometrySpans. Does NOT replace the indices,
|
||
|
// and the count must be EXACT, or this function gets pyst.
|
||
|
//MFREPACK
|
||
|
// don't need to pass in spans, they're already in fSourceSpans.
|
||
|
// clearSpansAfterRefresh is ignored anyway, nuke it.
|
||
|
UInt32 plDrawableSpans::RefreshDISpans( UInt32 index )
|
||
|
{
|
||
|
int i;
|
||
|
UInt32 spanIdx;
|
||
|
plSpan *span;
|
||
|
hsBounds3Ext bounds;
|
||
|
plDISpanIndex *spanLookup;
|
||
|
|
||
|
// hsAssert( fProps & kPropVolatile, "Trying to add spans on a non-volatile drawable" );
|
||
|
hsAssert( index != (UInt32)-1, "Invalid DI span index" );
|
||
|
|
||
|
/// Do garbage cleanup first
|
||
|
if( fNeedCleanup )
|
||
|
IRemoveGarbage();
|
||
|
|
||
|
spanLookup = IFindDIIndices( index );
|
||
|
|
||
|
/// Loop through the spans and copy the vertex data over
|
||
|
for( i = 0; i < spanLookup->GetCount(); i++ )
|
||
|
{
|
||
|
// Main info
|
||
|
plGeometrySpan *geoSpan = fSourceSpans[ (*spanLookup)[i] ];
|
||
|
spanIdx = fSpanSourceIndices[ (*spanLookup)[ i ] ];
|
||
|
hsAssert( ( spanIdx & kSpanTypeMask ) == kSpanTypeIcicle, "Mismatch in span formats" );
|
||
|
plIcicle *icicle = &fIcicles[ spanIdx & kSpanIDMask ];
|
||
|
IUpdateIcicleFromGeoSpan( geoSpan, icicle );
|
||
|
span = (plSpan *)icicle;
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
// Should add sort data too...
|
||
|
IMakeSpanSortable( (*spanLookup)[ i ] );
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
// Update fLocalBounds, since we were updating the world bounds
|
||
|
fLocalBounds = fWorldBounds;
|
||
|
fLocalBounds.Transform( &fWorldToLocal );
|
||
|
fMaxWorldBounds = fWorldBounds;
|
||
|
|
||
|
// Cause us to rebuild the space tree when needed
|
||
|
SetSpaceTree( nil );
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
// Same as above, but takes an actual span index (not a DI Index).
|
||
|
UInt32 plDrawableSpans::RefreshSpan( UInt32 index )
|
||
|
{
|
||
|
UInt32 spanIdx;
|
||
|
plSpan *span;
|
||
|
hsBounds3Ext bounds;
|
||
|
|
||
|
// hsAssert( fProps & kPropVolatile, "Trying to add spans on a non-volatile drawable" );
|
||
|
hsAssert( index < fSourceSpans.GetCount(), "Invalid span index" );
|
||
|
|
||
|
/// Do garbage cleanup first
|
||
|
if( fNeedCleanup )
|
||
|
IRemoveGarbage();
|
||
|
|
||
|
// Main info
|
||
|
plGeometrySpan *geoSpan = fSourceSpans[ index ];
|
||
|
spanIdx = fSpanSourceIndices[ index ];
|
||
|
hsAssert( ( spanIdx & kSpanTypeMask ) == kSpanTypeIcicle, "Mismatch in span formats" );
|
||
|
plIcicle *icicle = &fIcicles[ spanIdx & kSpanIDMask ];
|
||
|
IUpdateIcicleFromGeoSpan( geoSpan, icicle );
|
||
|
span = (plSpan *)icicle;
|
||
|
if( fProps & kPropSortFaces )
|
||
|
{
|
||
|
// Should add sort data too...
|
||
|
IMakeSpanSortable( index );
|
||
|
}
|
||
|
|
||
|
// Update fLocalBounds, since we were updating the world bounds
|
||
|
fLocalBounds = fWorldBounds;
|
||
|
fLocalBounds.Transform( &fWorldToLocal );
|
||
|
fMaxWorldBounds = fWorldBounds;
|
||
|
|
||
|
// Cause us to rebuild the space tree when needed
|
||
|
SetSpaceTree( nil );
|
||
|
|
||
|
fReadyToRender = false;
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
//// IUpdateVertexSpanFromGeoSpan ////////////////////////////////////////////
|
||
|
// Common function for the two functions that follow.
|
||
|
|
||
|
void plDrawableSpans::IUpdateVertexSpanFromGeoSpan( plGeometrySpan *geoSpan, plVertexSpan *span )
|
||
|
{
|
||
|
hsBounds3Ext bounds;
|
||
|
|
||
|
// This function looks pretty dubious to me. It or's in properties instead of setting them, and
|
||
|
// it doesn't set all the available properties (like the skinning matrix indices). It clearly should
|
||
|
// be doing more or doing less, but it's unclear which. I'm guessing the latter, but until there's
|
||
|
// a reason to dig through this trash, here it stays. mf
|
||
|
|
||
|
hsAssert( geoSpan->fNumVerts == span->fVLength, "Vertex count mismatch in IUpdateVertexSpanFromGeoSpan()" );
|
||
|
|
||
|
span->fLocalToWorld = geoSpan->fLocalToWorld;
|
||
|
span->fWorldToLocal = geoSpan->fWorldToLocal;
|
||
|
span->fProps |= ( geoSpan->fProps & plGeometrySpan::kPropRunTimeLight ) ? plSpan::kPropRunTimeLight : 0;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropNoShadowCast )
|
||
|
span->fProps |= plSpan::kPropNoShadowCast;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropNoShadow )
|
||
|
span->fProps |= plSpan::kPropNoShadow;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropForceShadow )
|
||
|
span->fProps |= plSpan::kPropForceShadow;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPropReverseSort )
|
||
|
span->fProps |= plSpan::kPropReverseSort;
|
||
|
if( geoSpan->fProps & plGeometrySpan::kPartialSort )
|
||
|
span->fProps |= plSpan::kPartialSort;
|
||
|
switch( geoSpan->fProps & plGeometrySpan::kLiteMask )
|
||
|
{
|
||
|
case plGeometrySpan::kLiteMaterial: span->fProps |= plSpan::kLiteMaterial; break;
|
||
|
case plGeometrySpan::kLiteVtxPreshaded: span->fProps |= plSpan::kLiteVtxPreshaded; break;
|
||
|
case plGeometrySpan::kLiteVtxNonPreshaded: span->fProps |= plSpan::kLiteVtxNonPreshaded; break;
|
||
|
}
|
||
|
if( geoSpan->fProps & plGeometrySpan::kWaterHeight )
|
||
|
{
|
||
|
span->fProps |= plSpan::kWaterHeight;
|
||
|
span->fWaterHeight = geoSpan->fWaterHeight;
|
||
|
}
|
||
|
if( geoSpan->fProps & plGeometrySpan::kVisLOS )
|
||
|
{
|
||
|
span->fProps |= plSpan::kVisLOS;
|
||
|
fProps |= plDrawable::kPropHasVisLOS;
|
||
|
}
|
||
|
|
||
|
bounds = geoSpan->fLocalBounds;
|
||
|
span->fLocalBounds = bounds;
|
||
|
bounds.Transform( &span->fLocalToWorld );
|
||
|
span->fWorldBounds = bounds;
|
||
|
fWorldBounds.Union( &bounds );
|
||
|
|
||
|
// Pack the vertices in
|
||
|
fGroups[ span->fGroupIdx ]->StuffToVertStorage( geoSpan, span->fVBufferIdx, span->fCellIdx, span->fCellOffset,
|
||
|
plGBufferGroup::kReserveInterleaved );
|
||
|
|
||
|
span->fFogEnvironment = geoSpan->fFogEnviron;
|
||
|
|
||
|
/// Add the material to our list if necessary
|
||
|
IAssignMatIdxToSpan( span, geoSpan->fMaterial );
|
||
|
}
|
||
|
|
||
|
//// IUpdateIcicleFromGeoSpan ////////////////////////////////////////////////
|
||
|
|
||
|
void plDrawableSpans::IUpdateIcicleFromGeoSpan( plGeometrySpan *geoSpan, plIcicle *icicle )
|
||
|
{
|
||
|
IUpdateVertexSpanFromGeoSpan( geoSpan, icicle );
|
||
|
}
|
||
|
|
||
|
hsPoint3& plDrawableSpans::GetPosition(int spanIdx, int vtxIdx)
|
||
|
{
|
||
|
hsAssert(fSpans[spanIdx]->fTypeMask & plSpan::kVertexSpan, "Getting vertex info on non-vertex based span");
|
||
|
plVertexSpan* span = (plVertexSpan*)fSpans[spanIdx];
|
||
|
|
||
|
return fGroups[span->fGroupIdx]->Position(span->fVBufferIdx, span->fCellIdx, vtxIdx);
|
||
|
}
|
||
|
hsVector3& plDrawableSpans::GetNormal(int spanIdx, int vtxIdx)
|
||
|
{
|
||
|
hsAssert(fSpans[spanIdx]->fTypeMask & plSpan::kVertexSpan, "Getting vertex info on non-vertex based span");
|
||
|
plVertexSpan* span = (plVertexSpan*)fSpans[spanIdx];
|
||
|
|
||
|
return fGroups[span->fGroupIdx]->Normal(span->fVBufferIdx, span->fCellIdx, vtxIdx);
|
||
|
}
|
||
|
|
||
|
UInt32 plDrawableSpans::GetNumTris(int spanIdx)
|
||
|
{
|
||
|
hsAssert(fSpans[spanIdx]->fTypeMask & plSpan::kIcicleSpan, "Asking for index info on non-triangle based span");
|
||
|
plIcicle* span = (plIcicle*)fSpans[spanIdx];
|
||
|
return fGroups[span->fGroupIdx]->GetIndexBufferCount(span->fIBufferIdx) / 3;
|
||
|
}
|
||
|
|
||
|
UInt16* plDrawableSpans::GetIndexList(int spanIdx)
|
||
|
{
|
||
|
hsAssert(fSpans[spanIdx]->fTypeMask & plSpan::kIcicleSpan, "Asking for index info on non-triangle based span");
|
||
|
plIcicle* span = (plIcicle*)fSpans[spanIdx];
|
||
|
return fGroups[span->fGroupIdx]->GetIndexBufferData(span->fIBufferIdx);
|
||
|
}
|
||
|
|
||
|
hsPoint3& plDrawableSpans::CvtGetPosition(int spanIdx, int vtxIdx)
|
||
|
{
|
||
|
return *(hsPoint3*)(fSourceSpans[spanIdx]->fVertexData + vtxIdx * plGeometrySpan::GetVertexSize(fSourceSpans[spanIdx]->fFormat));
|
||
|
}
|
||
|
|
||
|
hsVector3& plDrawableSpans::CvtGetNormal(int spanIdx, int vtxIdx)
|
||
|
{
|
||
|
// Normal follows the position (+ 12bytes)
|
||
|
return *(hsVector3*)(fSourceSpans[spanIdx]->fVertexData + vtxIdx * plGeometrySpan::GetVertexSize(fSourceSpans[spanIdx]->fFormat) + 12);
|
||
|
}
|
||
|
|
||
|
UInt32 plDrawableSpans::CvtGetNumTris(int spanIdx)
|
||
|
{
|
||
|
return fSourceSpans[spanIdx]->fNumIndices / 3;
|
||
|
}
|
||
|
|
||
|
UInt16* plDrawableSpans::CvtGetIndexList(int spanIdx)
|
||
|
{
|
||
|
return fSourceSpans[spanIdx]->fIndexData;
|
||
|
}
|
||
|
|
||
|
UInt32 plDrawableSpans::CvtGetNumVerts(int spanIdx) const
|
||
|
{
|
||
|
return fSourceSpans[spanIdx]->fNumVerts;
|
||
|
}
|
||
|
|
||
|
plGeometrySpan* plDrawableSpans::GetGeometrySpan(int spanIdx)
|
||
|
{
|
||
|
return fSourceSpans[spanIdx];
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::GetOrigGeometrySpans( UInt32 diIndex, hsTArray<plGeometrySpan *> &arrayToFill )
|
||
|
{
|
||
|
if( diIndex >= fDIIndices.GetCount() )
|
||
|
{
|
||
|
hsAssert( false, "Invalid diIndex to GetOrigGeometrySpans()" );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
plDISpanIndex *indices = fDIIndices[ diIndex ];
|
||
|
UInt32 i;
|
||
|
|
||
|
|
||
|
arrayToFill.Reset();
|
||
|
for( i = 0; i < indices->GetCount(); i++ )
|
||
|
arrayToFill.Append( fSourceSpans[ (*indices)[ i ] ] );
|
||
|
|
||
|
// HA!
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
void plDrawableSpans::ClearAndSetMaterialCount(UInt32 count)
|
||
|
{
|
||
|
// Release the old materials
|
||
|
for (int i = 0; i < fMaterials.GetCount(); i++)
|
||
|
{
|
||
|
if ( fMaterials[ i ] != nil && fMaterials[ i ]->GetKey() != nil )
|
||
|
GetKey()->Release( fMaterials[ i ]->GetKey() );
|
||
|
}
|
||
|
|
||
|
fMaterials.SetCountAndZero(count);
|
||
|
}
|
||
|
|