CWE-ou-minkata/Sources/Plasma/PubUtilLib/plDrawable/plDrawableSpansExport.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	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;
}