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.
785 lines
22 KiB
785 lines
22 KiB
4 years ago
|
/*==LICENSE==*
|
||
|
|
|
||
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
||
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
||
|
|
|
||
|
|
This program is free software: you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation, either version 3 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
This program is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
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.
|
||
|
|
|
||
|
|
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 Export-only Functions //
|
||
|
|
// //
|
||
|
|
//// Version History /////////////////////////////////////////////////////////
|
||
|
|
// //
|
||
|
|
// Created 4.3.2001 mcn //
|
||
|
|
// //
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
#include "hsTypes.h"
|
||
|
|
#include "plDrawableSpans.h"
|
||
|
|
#include "hsStream.h"
|
||
|
|
#include "hsResMgr.h"
|
||
|
|
#include "plPipeline.h"
|
||
|
|
#include "plGeometrySpan.h"
|
||
|
|
|
||
|
|
#include "plSpaceTree.h"
|
||
|
|
#include "plSpaceTreeMaker.h" // This is fun and amusing and wonderful to have here.
|
||
|
|
// Keep it here forever.
|
||
|
|
#include "../plSurface/hsGMaterial.h"
|
||
|
|
#include "../plPipeline/plFogEnvironment.h"
|
||
|
|
#include "../pnMessage/plRefMsg.h"
|
||
|
|
#include "../pnMessage/plNodeRefMsg.h" // for NodeRefMsg
|
||
|
|
#include "../plMessage/plDeviceRecreateMsg.h"
|
||
|
|
#include "../plPipeline/plGBufferGroup.h"
|
||
|
|
#include "../plSurface/hsGMaterial.h"
|
||
|
|
#include "../plSurface/plLayerInterface.h"
|
||
|
|
#include "../plGImage/plBitmap.h"
|
||
|
|
#include "../plGLight/plLightInfo.h"
|
||
|
|
#include "plgDispatch.h"
|
||
|
|
|
||
|
|
#include "../plStatusLog/plStatusLog.h"
|
||
|
|
|
||
|
|
//#define VERT_LOG
|
||
|
|
|
||
|
|
//// Write ///////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
void plDrawableSpans::Write( hsStream* s, hsResMgr* mgr )
|
||
|
|
{
|
||
|
|
UInt32 i, j, count;
|
||
|
|
|
||
|
|
// Make sure we're optimized before we write (should be tho)
|
||
|
|
// Optimize();
|
||
|
|
|
||
|
|
// Make sure all the garbage is cleaned up
|
||
|
|
if( fNeedCleanup )
|
||
|
|
IRemoveGarbage();
|
||
|
|
|
||
|
|
// Parent write
|
||
|
|
plDrawable::Write(s, mgr);
|
||
|
|
|
||
|
|
s->WriteSwap32( fProps );
|
||
|
|
s->WriteSwap32( fCriteria );
|
||
|
|
s->WriteSwap32( fRenderLevel.fLevel );
|
||
|
|
|
||
|
|
/// Write out the material keys
|
||
|
|
s->WriteSwap32( fMaterials.GetCount() );
|
||
|
|
for( i = 0; i < fMaterials.GetCount(); i++ )
|
||
|
|
mgr->WriteKey( s, fMaterials[ i ] );
|
||
|
|
|
||
|
|
/// Write out the icicles
|
||
|
|
s->WriteSwap32( fIcicles.GetCount() );
|
||
|
|
for( i = 0; i < fIcicles.GetCount(); i++ )
|
||
|
|
fIcicles[ i ].Write( s );
|
||
|
|
|
||
|
|
/// Write out the patches
|
||
|
|
// FIXME MAJOR VERSION
|
||
|
|
// no more patches, remove this line
|
||
|
|
s->WriteSwap32(0);
|
||
|
|
|
||
|
|
/// Write out the index table based on the pointer array
|
||
|
|
count = fSpans.GetCount();
|
||
|
|
s->WriteSwap32( count );
|
||
|
|
for( i = 0; i < count; i++ )
|
||
|
|
{
|
||
|
|
UInt8 *icicle = (UInt8 *)fSpans[ i ], *base = (UInt8 *)fIcicles.AcquireArray();
|
||
|
|
j = (UInt32)( icicle - base ) / sizeof( plIcicle );
|
||
|
|
s->WriteSwap32( j );
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write out the common keys
|
||
|
|
for( i = 0; i < count; i++ )
|
||
|
|
{
|
||
|
|
// The fog environ key
|
||
|
|
mgr->WriteKey( s, fSpans[ i ]->fFogEnvironment );
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write out the bounds and stuff
|
||
|
|
if( count > 0 )
|
||
|
|
{
|
||
|
|
fLocalBounds.Write(s);
|
||
|
|
fWorldBounds.Write(s);
|
||
|
|
fMaxWorldBounds.Write(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
for( i = 0; i < count; i++ )
|
||
|
|
{
|
||
|
|
if( fSpans[i]->fProps & plSpan::kPropHasPermaLights )
|
||
|
|
{
|
||
|
|
UInt32 lcnt = fSpans[i]->fPermaLights.GetCount();
|
||
|
|
s->WriteSwap32(lcnt);
|
||
|
|
int j;
|
||
|
|
for( j = 0; j < lcnt; j++ )
|
||
|
|
mgr->WriteKey( s, fSpans[i]->fPermaLights[j]);
|
||
|
|
}
|
||
|
|
if( fSpans[i]->fProps & plSpan::kPropHasPermaProjs )
|
||
|
|
{
|
||
|
|
UInt32 lcnt = fSpans[i]->fPermaProjs.GetCount();
|
||
|
|
s->WriteSwap32(lcnt);
|
||
|
|
int j;
|
||
|
|
for( j = 0; j < lcnt; j++ )
|
||
|
|
mgr->WriteKey( s, fSpans[i]->fPermaProjs[j]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write out the source spans if necessary
|
||
|
|
s->WriteSwap32( fSourceSpans.GetCount() );
|
||
|
|
if( fSourceSpans.GetCount() > 0 )
|
||
|
|
{
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
fSourceSpans[ i ]->Write( s );
|
||
|
|
}
|
||
|
|
|
||
|
|
count = fLocalToWorlds.GetCount();
|
||
|
|
s->WriteSwap32(count);
|
||
|
|
for( i = 0; i < count; i++ )
|
||
|
|
{
|
||
|
|
fLocalToWorlds[i].Write(s);
|
||
|
|
fWorldToLocals[i].Write(s);
|
||
|
|
|
||
|
|
fLocalToBones[i].Write(s);
|
||
|
|
fBoneToLocals[i].Write(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Write out the drawInterface index arrays
|
||
|
|
s->WriteSwap32( fDIIndices.GetCount() );
|
||
|
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
plDISpanIndex *array = fDIIndices[ i ];
|
||
|
|
|
||
|
|
s->WriteSwap32( array->fFlags );
|
||
|
|
s->WriteSwap32( array->GetCount() );
|
||
|
|
for( j = 0; j < array->GetCount(); j++ )
|
||
|
|
s->WriteSwap32( (*array)[ j ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Write the groups out
|
||
|
|
count = fGroups.GetCount();
|
||
|
|
|
||
|
|
s->WriteSwap( count );
|
||
|
|
for( i = 0; i < count; i++ )
|
||
|
|
{
|
||
|
|
#ifdef VERT_LOG
|
||
|
|
|
||
|
|
hsUNIXStream log;
|
||
|
|
log.Open("log\\GBuf.log", "ab");
|
||
|
|
char buf[256];
|
||
|
|
sprintf(buf, "Drawable Span: %s, GroupNum: %u\r\n", GetKeyName(), i);
|
||
|
|
log.WriteString(buf);
|
||
|
|
log.Close();
|
||
|
|
#endif
|
||
|
|
fGroups[ i ]->Write( s );
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Other stuff
|
||
|
|
mgr->WriteCreatable(s, fSpaceTree);
|
||
|
|
|
||
|
|
mgr->WriteKey(s, fSceneNode);
|
||
|
|
|
||
|
|
/// All done!
|
||
|
|
}
|
||
|
|
|
||
|
|
//// AddDISpans //////////////////////////////////////////////////////////////
|
||
|
|
// Adds a drawInterface's geometry spans to the list to be collapsed into
|
||
|
|
// buffers.
|
||
|
|
|
||
|
|
UInt32 plDrawableSpans::AddDISpans( hsTArray<plGeometrySpan *> &spans, UInt32 index )
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
UInt32 spanIdx;
|
||
|
|
plSpan *span;
|
||
|
|
hsBounds3Ext bounds;
|
||
|
|
|
||
|
|
|
||
|
|
/// Do garbage cleanup first
|
||
|
|
if( fNeedCleanup )
|
||
|
|
IRemoveGarbage();
|
||
|
|
|
||
|
|
if (index == (UInt32)-1) // need a new one
|
||
|
|
{
|
||
|
|
/// Create a lookup entry
|
||
|
|
index = fDIIndices.GetCount();
|
||
|
|
fDIIndices.Append( TRACKED_NEW plDISpanIndex );
|
||
|
|
fDIIndices[ index ]->fFlags = plDISpanIndex::kNone;
|
||
|
|
}
|
||
|
|
plDISpanIndex *spanLookup = fDIIndices[ index ];
|
||
|
|
|
||
|
|
|
||
|
|
/// Add the geometry spans to our list. Also add our internal span
|
||
|
|
/// copies
|
||
|
|
for( i = 0; i < spans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
spanLookup->Append( fSourceSpans.GetCount() );
|
||
|
|
spans[ i ]->fSpanRefIndex = fSourceSpans.GetCount();
|
||
|
|
fSourceSpans.Append( spans[ i ] );
|
||
|
|
|
||
|
|
spanIdx = fIcicles.GetCount();
|
||
|
|
fIcicles.Append( plIcicle() );
|
||
|
|
plIcicle *icicle = &fIcicles[ spanIdx ];
|
||
|
|
span = (plSpan *)icicle;
|
||
|
|
|
||
|
|
/// Set common stuff
|
||
|
|
IAssignMatIdxToSpan( span, spans[ i ]->fMaterial );
|
||
|
|
span->fLocalToWorld = spans[ i ]->fLocalToWorld;
|
||
|
|
span->fWorldToLocal = spans[ i ]->fWorldToLocal;
|
||
|
|
span->fProps |= ( spans[ i ]->fProps & plGeometrySpan::kPropRunTimeLight ) ? plSpan::kPropRunTimeLight : 0;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kPropNoShadowCast )
|
||
|
|
span->fProps |= plSpan::kPropNoShadowCast;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kPropNoShadow )
|
||
|
|
span->fProps |= plSpan::kPropNoShadow;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kPropForceShadow )
|
||
|
|
span->fProps |= plSpan::kPropForceShadow;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kPropReverseSort )
|
||
|
|
span->fProps |= plSpan::kPropReverseSort;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kPartialSort )
|
||
|
|
span->fProps |= plSpan::kPartialSort;
|
||
|
|
if( spans[i]->fProps & plGeometrySpan::kVisLOS )
|
||
|
|
{
|
||
|
|
span->fProps |= plSpan::kVisLOS;
|
||
|
|
fProps |= plDrawable::kPropHasVisLOS;
|
||
|
|
}
|
||
|
|
|
||
|
|
span->fNumMatrices = spans[ i ]->fNumMatrices;
|
||
|
|
span->fBaseMatrix = spans[ i ]->fBaseMatrix;
|
||
|
|
span->fLocalUVWChans = spans[i]->fLocalUVWChans;
|
||
|
|
span->fMaxBoneIdx = spans[i]->fMaxBoneIdx;
|
||
|
|
span->fPenBoneIdx = (UInt16)(spans[i]->fPenBoneIdx);
|
||
|
|
|
||
|
|
bounds = spans[ i ]->fLocalBounds;
|
||
|
|
span->fLocalBounds = bounds;
|
||
|
|
bounds.Transform( &span->fLocalToWorld );
|
||
|
|
span->fWorldBounds = bounds;
|
||
|
|
span->fFogEnvironment = spans[ i ]->fFogEnviron;
|
||
|
|
|
||
|
|
/// Add to our source indices
|
||
|
|
fSpans.Append( span );
|
||
|
|
fSpanSourceIndices.Append( spanIdx );
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Rebuild the pointer array
|
||
|
|
IRebuildSpanArray();
|
||
|
|
|
||
|
|
SetSpaceTree(nil);
|
||
|
|
|
||
|
|
fOptimized = false;
|
||
|
|
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
|
||
|
|
//// Optimize ////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
void plDrawableSpans::Optimize( void )
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if( fOptimized )
|
||
|
|
return;
|
||
|
|
|
||
|
|
/// Sort all the source spans
|
||
|
|
if( !(fProps & kPropNoReSort) )
|
||
|
|
ISortSourceSpans();
|
||
|
|
|
||
|
|
/// Pack the source spans into spans and indices
|
||
|
|
IPackSourceSpans();
|
||
|
|
|
||
|
|
/// Now that we're done with the source spans, get rid of them! (BLEAH!)
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
delete fSourceSpans[ i ];
|
||
|
|
fSourceSpans.Reset();
|
||
|
|
|
||
|
|
if( fCriteria & kCritSortSpans )
|
||
|
|
{
|
||
|
|
if( !(fProps & kPropNoReSort) )
|
||
|
|
fProps |= kPropSortSpans;
|
||
|
|
}
|
||
|
|
if( fCriteria & kCritSortFaces )
|
||
|
|
{
|
||
|
|
fProps |= kPropSortFaces;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Now we do a pass at the buffer groups, asking them to tidy up
|
||
|
|
for( i = 0; i < fGroups.GetCount(); i++ )
|
||
|
|
fGroups[ i ]->TidyUp();
|
||
|
|
|
||
|
|
// Look to see if we have any materials we aren't using anymore.
|
||
|
|
for( i = 0; i < fMaterials.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
ICheckToRemoveMaterial(i);
|
||
|
|
}
|
||
|
|
|
||
|
|
fReadyToRender = false;
|
||
|
|
|
||
|
|
// Make the space tree (hierarchical bounds).
|
||
|
|
plSpaceTreeMaker maker;
|
||
|
|
maker.Reset();
|
||
|
|
for( i = 0; i < GetNumSpans(); i++ )
|
||
|
|
{
|
||
|
|
maker.AddLeaf( fSpans[ i ]->fWorldBounds, fSpans[ i ]->fProps & plSpan::kPropNoDraw );
|
||
|
|
}
|
||
|
|
plSpaceTree* tree = maker.MakeTree();
|
||
|
|
SetSpaceTree(tree);
|
||
|
|
|
||
|
|
/// All done!
|
||
|
|
fOptimized = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static plStatusLog* IStartLog(const char* name, int numSpans)
|
||
|
|
{
|
||
|
|
static char buff[256];
|
||
|
|
sprintf(buff, "x%s.log", name);
|
||
|
|
|
||
|
|
plStatusLog* statusLog = plStatusLogMgr::GetInstance().CreateStatusLog(
|
||
|
|
plStatusLogMgr::kDefaultNumLines,
|
||
|
|
buff,
|
||
|
|
plStatusLog::kFilledBackground | plStatusLog::kDeleteForMe );
|
||
|
|
return statusLog;
|
||
|
|
}
|
||
|
|
|
||
|
|
static plStatusLog* IEndLog(plStatusLog* statusLog)
|
||
|
|
{
|
||
|
|
delete statusLog;
|
||
|
|
return nil;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void ILogSpan(plStatusLog* statusLog, plGeometrySpan* geo, plVertexSpan* span, plGBufferGroup* group)
|
||
|
|
{
|
||
|
|
if( span->fTypeMask & plSpan::kIcicleSpan )
|
||
|
|
{
|
||
|
|
plIcicle* ice = (plIcicle*)span;
|
||
|
|
if( geo->fProps & plGeometrySpan::kFirstInstance )
|
||
|
|
{
|
||
|
|
plGBufferCell* cell = group->GetCell(span->fVBufferIdx, span->fCellIdx);
|
||
|
|
UInt32 stride = group->GetVertexSize();
|
||
|
|
UInt32 ptr = cell->fVtxStart + span->fCellOffset * stride;
|
||
|
|
|
||
|
|
statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d offset)",
|
||
|
|
geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
|
||
|
|
geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
|
||
|
|
geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(UInt16) * geo->fNumIndices,
|
||
|
|
span->fGroupIdx,
|
||
|
|
ptr
|
||
|
|
);
|
||
|
|
// span->fVBufferIdx,
|
||
|
|
// span->fCellIdx,
|
||
|
|
// span->fCellOffset,
|
||
|
|
// span->fVStartIdx,
|
||
|
|
// span->fVLength,
|
||
|
|
// ice->fIBufferIdx,
|
||
|
|
// ice->fIStartIdx,
|
||
|
|
// ice->fILength
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d/%d/%d/%d)",
|
||
|
|
geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
|
||
|
|
geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
|
||
|
|
span->fGroupIdx,
|
||
|
|
span->fVBufferIdx,
|
||
|
|
span->fCellIdx,
|
||
|
|
span->fCellOffset,
|
||
|
|
span->fVStartIdx,
|
||
|
|
span->fVLength,
|
||
|
|
ice->fIBufferIdx,
|
||
|
|
ice->fIStartIdx,
|
||
|
|
ice->fILength
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( geo->fProps & plGeometrySpan::kFirstInstance )
|
||
|
|
{
|
||
|
|
statusLog->AddLineF("From obj <%s> mat <%s> size %d bytes grp=%d (%d/%d/%d/%d/%d)",
|
||
|
|
geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
|
||
|
|
geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
|
||
|
|
geo->GetVertexSize(geo->fFormat) * geo->fNumVerts + sizeof(UInt16) * geo->fNumIndices,
|
||
|
|
span->fGroupIdx,
|
||
|
|
span->fVBufferIdx,
|
||
|
|
span->fCellIdx,
|
||
|
|
span->fCellOffset,
|
||
|
|
span->fVStartIdx,
|
||
|
|
span->fVLength
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
statusLog->AddLineF("Instanced obj <%s> mat <%s> grp=%d (%d/%d/%d/%d/%d)",
|
||
|
|
geo->fMaxOwner ? geo->fMaxOwner : "<unknown>",
|
||
|
|
geo->fMaterial ? geo->fMaterial->GetKey()->GetName() : "<unknown>",
|
||
|
|
span->fGroupIdx,
|
||
|
|
span->fVBufferIdx,
|
||
|
|
span->fCellIdx,
|
||
|
|
span->fCellOffset,
|
||
|
|
span->fVStartIdx,
|
||
|
|
span->fVLength
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//// IPackSourceSpans ////////////////////////////////////////////////////////
|
||
|
|
// Takes the array of source spans and converts them to our internal icicle
|
||
|
|
// spans, vertex buffers and index buffers.
|
||
|
|
|
||
|
|
void plDrawableSpans::IPackSourceSpans( void )
|
||
|
|
{
|
||
|
|
int i, j;
|
||
|
|
hsBounds3Ext bounds;
|
||
|
|
hsBitVector doneSpans;
|
||
|
|
|
||
|
|
|
||
|
|
/// Calc bounds
|
||
|
|
fLocalBounds.MakeEmpty();
|
||
|
|
fWorldBounds.MakeEmpty();
|
||
|
|
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
hsBounds3Ext bnd = fSourceSpans[ i ]->fLocalBounds;
|
||
|
|
bnd.Transform( &fSourceSpans[ i ]->fLocalToWorld );
|
||
|
|
fWorldBounds.Union( &bnd );
|
||
|
|
}
|
||
|
|
|
||
|
|
fLocalBounds = fWorldBounds;
|
||
|
|
fLocalBounds.Transform( &fWorldToLocal );
|
||
|
|
fMaxWorldBounds = fWorldBounds;
|
||
|
|
|
||
|
|
// It could be that instance refs in spans that we (the drawable) own
|
||
|
|
// are actually spans in some other drawable. That's not currently handled.
|
||
|
|
// (Making that case handled would involve rewriting the instancing implementation
|
||
|
|
// to not suck ass).
|
||
|
|
// So for each instance set, we make two lists of instance refs, the ones also
|
||
|
|
// in this drawable (refsHere), and ones not (refsThere). If there are refsThere,
|
||
|
|
// we split out the refsHere into a new instance group, removing them from the
|
||
|
|
// refsThere list. If refsThere still contains spans from separate drawables,
|
||
|
|
// that will be dealt with in those drawables' Optimize calls.
|
||
|
|
doneSpans.Clear();
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
if( !doneSpans.IsBitSet(i) )
|
||
|
|
{
|
||
|
|
plGeometrySpan* span = fSourceSpans[i];
|
||
|
|
if( span->fInstanceRefs )
|
||
|
|
{
|
||
|
|
hsTArray<plGeometrySpan*>& refs = *(span->fInstanceRefs);
|
||
|
|
hsTArray<plGeometrySpan*> refsHere;
|
||
|
|
hsTArray<plGeometrySpan*> refsThere;
|
||
|
|
|
||
|
|
int k;
|
||
|
|
for( k = 0; k < refs.GetCount(); k++ )
|
||
|
|
{
|
||
|
|
plGeometrySpan* other = refs[k];
|
||
|
|
if( other != span )
|
||
|
|
{
|
||
|
|
int idx = fSourceSpans.Find(other);
|
||
|
|
if( fSourceSpans.kMissingIndex == idx )
|
||
|
|
{
|
||
|
|
refsThere.Append(other);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
refsHere.Append(other);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if( refsThere.GetCount() )
|
||
|
|
{
|
||
|
|
if( refsHere.GetCount() )
|
||
|
|
{
|
||
|
|
span->BreakInstance();
|
||
|
|
|
||
|
|
// Okay, got to form a new instance group out of refsHere.
|
||
|
|
for( k = 0; k < refsHere.GetCount(); k++ )
|
||
|
|
{
|
||
|
|
plGeometrySpan* other = refsHere[k];
|
||
|
|
|
||
|
|
other->ChangeInstance(span);
|
||
|
|
|
||
|
|
doneSpans.SetBit(other->fSpanRefIndex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
span->UnInstance();
|
||
|
|
}
|
||
|
|
if( refsThere.GetCount() == 1 )
|
||
|
|
{
|
||
|
|
refsThere[0]->UnInstance();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
doneSpans.SetBit(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Now pack the spans
|
||
|
|
doneSpans.Clear();
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
// Now we fill the rest of the data in for our span
|
||
|
|
if( !doneSpans.IsBitSet( i ) )
|
||
|
|
{
|
||
|
|
if( fSourceSpans[ i ]->fProps & plGeometrySpan::kInstanced )
|
||
|
|
{
|
||
|
|
// Instanced spans--convert the first as normal, then convert the rest
|
||
|
|
// using the first as reference
|
||
|
|
doneSpans.SetBit( i, true );
|
||
|
|
|
||
|
|
plIcicle *baseIcicle = (plIcicle *)fSpans[ i ];
|
||
|
|
IConvertGeoSpanToIcicle( fSourceSpans[ i ], baseIcicle, 0, baseIcicle );
|
||
|
|
|
||
|
|
// Loop through the rest
|
||
|
|
for( j = 0; j < fSourceSpans[ i ]->fInstanceRefs->GetCount(); j++ )
|
||
|
|
{
|
||
|
|
plGeometrySpan *other = (*fSourceSpans[ i ]->fInstanceRefs)[ j ];
|
||
|
|
if( other == fSourceSpans[ i ] )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
#if 0 // What exactly is this supposed to be doing? My guess is, NADA.
|
||
|
|
if( IConvertGeoSpanToIcicle( other, (plIcicle *)fSpans[ other->fSpanRefIndex ], 0, baseIcicle ) )
|
||
|
|
baseIcicle = (plIcicle *)fSpans[ other->fSpanRefIndex ];
|
||
|
|
#else // What exactly is this supposed to be doing? My guess is, NADA.
|
||
|
|
IConvertGeoSpanToIcicle( other, (plIcicle *)fSpans[ other->fSpanRefIndex ], 0, baseIcicle );
|
||
|
|
#endif // What exactly is this supposed to be doing? My guess is, NADA.
|
||
|
|
doneSpans.SetBit( other->fSpanRefIndex, true );
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Do normal, uninstanced conversion
|
||
|
|
IConvertGeoSpanToIcicle( fSourceSpans[ i ], (plIcicle *)fSpans[ i ], 0 );
|
||
|
|
doneSpans.SetBit( i, true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef VERT_LOG
|
||
|
|
hsTArray<plGeometrySpan*> order;
|
||
|
|
order.SetCount(fSourceSpans.GetCount());
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
order[fSourceSpans[i]->fSpanRefIndex] = fSourceSpans[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
plStatusLog* statusLog = IStartLog(GetKey()->GetName(), fSourceSpans.GetCount());
|
||
|
|
for( i = 0; i < order.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
plVertexSpan* vSpan = (plVertexSpan*)fSpans[i];
|
||
|
|
ILogSpan(statusLog, order[i], vSpan, fGroups[vSpan->fGroupIdx]);
|
||
|
|
}
|
||
|
|
statusLog = IEndLog(statusLog);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
//// ISortSourceSpans ////////////////////////////////////////////////////////
|
||
|
|
// Does our actual optimization path by resorting all the spans into the
|
||
|
|
// most efficient order possible. Also has to re-order the span lookup
|
||
|
|
// table.
|
||
|
|
|
||
|
|
void plDrawableSpans::ISortSourceSpans( void )
|
||
|
|
{
|
||
|
|
hsTArray<UInt32> spanReorderTable, spanInverseTable;
|
||
|
|
int i, j, idx;
|
||
|
|
plGeometrySpan *tmpSpan;
|
||
|
|
UInt32 tmpIdx;
|
||
|
|
plSpan *tmpSpanPtr;
|
||
|
|
|
||
|
|
|
||
|
|
// Init the reorder table
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount(); i++ )
|
||
|
|
spanReorderTable.Append( i );
|
||
|
|
|
||
|
|
// Do a nice, if naiive, sort by material (hehe by the pointers, no less)
|
||
|
|
for( i = 0; i < fSourceSpans.GetCount() - 1; i++ )
|
||
|
|
{
|
||
|
|
for( j = i + 1, idx = i; j < fSourceSpans.GetCount(); j++ )
|
||
|
|
{
|
||
|
|
if( ICompareSpans( fSourceSpans[ j ], fSourceSpans[ idx ] ) < 0 )
|
||
|
|
idx = j;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Swap idx with i, so we get the smallest pointer on top
|
||
|
|
if( i != idx )
|
||
|
|
{
|
||
|
|
// Swap both the source span and our internal span
|
||
|
|
tmpSpan = fSourceSpans[ i ];
|
||
|
|
fSourceSpans[ i ] = fSourceSpans[ idx ];
|
||
|
|
fSourceSpans[ idx ] = tmpSpan;
|
||
|
|
|
||
|
|
fSourceSpans[ i ]->fSpanRefIndex = i;
|
||
|
|
fSourceSpans[ idx ]->fSpanRefIndex = idx;
|
||
|
|
|
||
|
|
tmpSpanPtr = fSpans[ i ];
|
||
|
|
fSpans[ i ] = fSpans[ idx ];
|
||
|
|
fSpans[ idx ] = tmpSpanPtr;
|
||
|
|
|
||
|
|
// Also swap the entries in the reorder table
|
||
|
|
tmpIdx = spanReorderTable[ i ];
|
||
|
|
spanReorderTable[ i ] = spanReorderTable[ idx ];
|
||
|
|
spanReorderTable[ idx ] = tmpIdx;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Next!
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/// Problem: our reorder table is inversed(y->x instead of x->y). Either we search for numbers,
|
||
|
|
/// or we just flip it first...
|
||
|
|
spanInverseTable.SetCountAndZero( spanReorderTable.GetCount() );
|
||
|
|
for( i = 0; i < spanReorderTable.GetCount(); i++ )
|
||
|
|
spanInverseTable[ spanReorderTable[ i ] ] = i;
|
||
|
|
|
||
|
|
/// Now update our span xlate table
|
||
|
|
for( i = 0; i < fDIIndices.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
if( !fDIIndices[ i ]->IsMatrixOnly() )
|
||
|
|
{
|
||
|
|
for( j = 0; j < fDIIndices[ i ]->GetCount(); j++ )
|
||
|
|
{
|
||
|
|
idx = (*fDIIndices[ i ])[ j ];
|
||
|
|
|
||
|
|
(*fDIIndices[ i ])[ j ] = spanInverseTable[ idx ];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Use our pointer array to rebuild the icicle array (UUUUGLY)
|
||
|
|
hsTArray<plIcicle> tempIcicles;
|
||
|
|
plIcicle *newIcicle;
|
||
|
|
|
||
|
|
tempIcicles.SetCount( fIcicles.GetCount() );
|
||
|
|
|
||
|
|
for( i = 0, newIcicle = tempIcicles.AcquireArray();
|
||
|
|
i < fSpans.GetCount(); i++ )
|
||
|
|
{
|
||
|
|
*newIcicle = *( (plIcicle *)fSpans[ i ] );
|
||
|
|
fSpans[ i ] = newIcicle;
|
||
|
|
newIcicle++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Swap the two arrays out. This will basically swap the actual memory blocks, so be careful...
|
||
|
|
fIcicles.Swap( tempIcicles );
|
||
|
|
tempIcicles.Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
//// ICompareSpans ///////////////////////////////////////////////////////////
|
||
|
|
// Sorting function for ISortSpans(). Kinda like strcmp(): returns -1 if
|
||
|
|
// span1 < span2, 1 if span1 > span2, 0 if "equal".
|
||
|
|
|
||
|
|
short plDrawableSpans::ICompareSpans( plGeometrySpan *span1, plGeometrySpan *span2 )
|
||
|
|
{
|
||
|
|
hsBool b1, b2;
|
||
|
|
int i, j, numLayers;
|
||
|
|
plBitmap *t1, *t2;
|
||
|
|
|
||
|
|
|
||
|
|
/// Quick check--identical materials are easy to compare :)
|
||
|
|
if( span1->fMaterial == span2->fMaterial )
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/// Compare features from most to least important...
|
||
|
|
|
||
|
|
// Any decal span should come after a non-decal
|
||
|
|
if( span1->fDecalLevel < span2->fDecalLevel )
|
||
|
|
return -1;
|
||
|
|
if( span1->fDecalLevel > span2->fDecalLevel )
|
||
|
|
return 1;
|
||
|
|
// Ok, they're equal decal-wise, so find something else to judge on
|
||
|
|
|
||
|
|
// Most important: is one of the materials an alpha blend? (if so, gotta
|
||
|
|
// put at end, so it's "bigger")
|
||
|
|
if( span1->fMaterial->GetNumLayers() > 0 &&
|
||
|
|
( span1->fMaterial->GetLayer( 0 )->GetState().fBlendFlags & hsGMatState::kBlendMask ) != 0 )
|
||
|
|
b1 = true;
|
||
|
|
else
|
||
|
|
b1 = false;
|
||
|
|
|
||
|
|
if( span2->fMaterial->GetNumLayers() > 0 &&
|
||
|
|
( span2->fMaterial->GetLayer( 0 )->GetState().fBlendFlags & hsGMatState::kBlendMask ) != 0 )
|
||
|
|
b2 = true;
|
||
|
|
else
|
||
|
|
b2 = false;
|
||
|
|
|
||
|
|
if( b1 != b2 )
|
||
|
|
return( b1 ? 1 : -1 );
|
||
|
|
|
||
|
|
// Next is texture (name). We do this kinda like strings: compare the first layer's
|
||
|
|
// textures and go upwards, so that we group materials together starting with the
|
||
|
|
// base layer's texture and going upwards
|
||
|
|
numLayers = span1->fMaterial->GetNumLayers();
|
||
|
|
if( span2->fMaterial->GetNumLayers() < numLayers )
|
||
|
|
numLayers = span2->fMaterial->GetNumLayers();
|
||
|
|
|
||
|
|
for( i = 0; i < numLayers; i++ )
|
||
|
|
{
|
||
|
|
t1 = span1->fMaterial->GetLayer( i )->GetTexture();
|
||
|
|
t2 = span2->fMaterial->GetLayer( i )->GetTexture();
|
||
|
|
|
||
|
|
if( t1 != nil && t2 == nil )
|
||
|
|
return 1;
|
||
|
|
else if( t1 == nil && t2 != nil )
|
||
|
|
return -1;
|
||
|
|
else if( t1 == nil && t2 == nil )
|
||
|
|
break; // Textures equal up to here--keep going with rest of tests
|
||
|
|
|
||
|
|
if( t1->GetKeyName() != nil && t2->GetKeyName() != nil )
|
||
|
|
{
|
||
|
|
j = stricmp( t1->GetKeyName(), t2->GetKeyName() );
|
||
|
|
if( j != 0 )
|
||
|
|
return (short)j;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Finally, by material itself.
|
||
|
|
if( span1->fMaterial->GetKeyName() != nil && span2->fMaterial->GetKeyName() != nil )
|
||
|
|
{
|
||
|
|
j = stricmp( span1->fMaterial->GetKeyName(), span2->fMaterial->GetKeyName() );
|
||
|
|
if( j != 0 )
|
||
|
|
return (short)j;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( span1->fLocalToWorld.fFlags != span2->fLocalToWorld.fFlags )
|
||
|
|
{
|
||
|
|
if( span1->fLocalToWorld.fFlags )
|
||
|
|
return -1;
|
||
|
|
else
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Equal in our book...
|
||
|
|
return 0;
|
||
|
|
}
|