/*==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==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	plGeometrySpan Class Functions											//
//																			//
//// Version History /////////////////////////////////////////////////////////
//																			//
//	Created 3.8.2001 mcn													//
//																			//
//////////////////////////////////////////////////////////////////////////////

#include "hsWindows.h"
#include "hsTypes.h"
#include "plGeometrySpan.h"
#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayerInterface.h"
#include "hsBitVector.h"


//// Static Data /////////////////////////////////////////////////////////////

hsBitVector		plGeometrySpan::fInstanceGroupIDFlags;
UInt32			plGeometrySpan::fHighestReadInstanceGroup = 0;

hsTArray<hsTArray<plGeometrySpan *> *>	plGeometrySpan::fInstanceGroups;


//// Constructor and Destructor //////////////////////////////////////////////

plGeometrySpan::plGeometrySpan()
{
	IClearMembers();
}

plGeometrySpan::plGeometrySpan( const plGeometrySpan *instance )
{
	IClearMembers();
	MakeInstanceOf( instance ); 
}

plGeometrySpan::~plGeometrySpan()
{
	ClearBuffers();
}

void	plGeometrySpan::IClearMembers( void )
{
	fVertexData = nil; 
	fIndexData = nil; 
	fMaterial = nil; 
	fNumVerts = fNumIndices = 0; 
	fBaseMatrix = fNumMatrices = 0;
	fLocalUVWChans = 0;
	fMaxBoneIdx = 0;
	fPenBoneIdx = 0;
	fCreating = false;
	fFogEnviron = nil;
	fProps = 0;

	fMinDist = fMaxDist = -1.f;

	fWaterHeight = 0;

	fMultColor = nil;
	fAddColor = nil;

	fDiffuseRGBA = nil;
	fSpecularRGBA = nil;
	fInstanceRefs = nil;
	fInstanceGroupID = kNoGroupID;
	fSpanRefIndex = (UInt32)-1;

	fLocalToOBB.Reset();
	fOBBToLocal.Reset();

	fDecalLevel = 0;

	fMaxOwner = nil;
}

//// ClearBuffers ////////////////////////////////////////////////////////////

void	plGeometrySpan::ClearBuffers( void )
{
	// If UserOwned, the actual buffer data belongs to someone else (like a BufferGroup).
	// Just erase our knowledge of it and move on.
	if( fProps & kUserOwned )
	{
		IClearMembers();
		return;
	}

	bool	removeData = true;


	// If we have an instanceRefs array, remove ourselves from
	// the array. If we are the last in the array, remove the array itself
	if( fInstanceRefs != nil )
	{
		if( fInstanceRefs->GetCount() == 1 )
		{
			delete fInstanceRefs;

			// Remove the group ID flag as well
			IClearGroupID( fInstanceGroupID );
		}
		else
		{
			int idx = fInstanceRefs->Find( this );
			hsAssert( idx != fInstanceRefs->kMissingIndex, "Invalid instance ref data in plGeometrySpan::ClearBuffers()" );

			fInstanceRefs->Remove( idx );
			removeData = false;	// Don't remove data until we're the last one
		}
		fInstanceRefs = nil;
		fInstanceGroupID = kNoGroupID;
	}

	if( removeData )
	{
		delete [] fVertexData;
		fVertexData = nil;

		delete [] fMultColor;
		delete [] fAddColor;
		fMultColor = nil;
		fAddColor = nil;
	}

	delete [] fIndexData;
	delete [] fDiffuseRGBA;
	delete [] fSpecularRGBA;
	fIndexData = nil;
	fDiffuseRGBA = fSpecularRGBA = nil;
}

//// MakeInstanceOf //////////////////////////////////////////////////////////
//	Note: instancing copies the index buffer but just copies the POINTERS
//	for the vertex buffers and source colors. This is because the indices
//	will eventually change but the vertices won't.

void	plGeometrySpan::MakeInstanceOf( const plGeometrySpan *instance )
{
	hsTArray<plGeometrySpan *> *array;


	ClearBuffers();

	/// Adjust the instanceRefs array
	array = instance->fInstanceRefs;
	if( array == nil )
	{
		// Go find a new groupID
		instance->fInstanceGroupID = IAllocateNewGroupID();

		instance->fInstanceRefs = array = TRACKED_NEW hsTArray<plGeometrySpan *>;
		// Go figure, it won't append the const version to the array...this is a cheat,
		// but then, so is making fInstanceRefs mutable :)
		array->Append( (plGeometrySpan *)instance );
	}

	fInstanceGroupID = instance->fInstanceGroupID;
	array->Append( this );
	fInstanceRefs = array;

	/// Copy over the data
	IDuplicateUniqueData( instance );
	fVertexData = instance->fVertexData;
	fMultColor = instance->fMultColor;
	fAddColor = instance->fAddColor;

	/// All done!
}

void plGeometrySpan::IUnShareData()
{
	if( fVertexData )
	{
		UInt8* oldVtxData = fVertexData;

		UInt32 size = GetVertexSize( fFormat );

		fVertexData = TRACKED_NEW UInt8[ size * fNumVerts ];
		memcpy( fVertexData, oldVtxData, size * fNumVerts );
	}

	if( fMultColor )
	{
		hsColorRGBA* oldMult = fMultColor;

		fMultColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		memcpy( fMultColor, oldMult, sizeof(hsColorRGBA) * fNumVerts );
	}

	if( fAddColor )
	{
		hsColorRGBA* oldAdd = fAddColor;

		fAddColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		memcpy( fAddColor, oldAdd, sizeof(hsColorRGBA) * fNumVerts );
	}
}

void plGeometrySpan::BreakInstance()
{
	hsAssert(fInstanceRefs, "Breaking instancing when I'm not instanced");
	int idx = fInstanceRefs->Find(this);
	hsAssert(idx != fInstanceRefs->kMissingIndex, "I'm not in my own instance refs list");
	fInstanceRefs->Remove(idx);
	hsAssert(fInstanceRefs->GetCount(), "Don't BreakInstance if I'm the last one, use UnInstance instead");

	fInstanceGroupID = IAllocateNewGroupID();
	fInstanceRefs = TRACKED_NEW hsTArray<plGeometrySpan*>;
	fInstanceRefs->Append(this);

	IUnShareData();

	fProps |= plGeometrySpan::kInstanced;
}

void plGeometrySpan::ChangeInstance(plGeometrySpan* newInstance)
{
	hsAssert(fInstanceRefs, "Changing instancing when I'm not instanced");
	int idx = fInstanceRefs->Find(this);
	hsAssert(idx != fInstanceRefs->kMissingIndex, "I'm not in my own instance refs list");
	fInstanceRefs->Remove(idx);

	fInstanceGroupID = newInstance->fInstanceGroupID;
	fInstanceRefs = newInstance->fInstanceRefs;
	fInstanceRefs->Append(this);

	fVertexData = newInstance->fVertexData;
	fMultColor = newInstance->fMultColor;
	fAddColor = newInstance->fAddColor;

	fProps |= plGeometrySpan::kInstanced;
}

void plGeometrySpan::UnInstance()
{
	hsAssert(fInstanceRefs, "UnInstancing a non-instance");

	int idx = fInstanceRefs->Find(this);
	hsAssert(idx != fInstanceRefs->kMissingIndex, "I'm not in my own instance refs list");
	fInstanceRefs->Remove(idx);

	// If we're the last one, we just take ownership of the shared data,
	// else we make our own copy of it.
	if( !fInstanceRefs->GetCount() )
	{
		delete fInstanceRefs;
	}
	else
	{
		IUnShareData();
	}
	fInstanceRefs = nil;
	fInstanceGroupID = kNoGroupID;
	fProps &= ~plGeometrySpan::kInstanced;
}

//// IAllocateNewGroupID /////////////////////////////////////////////////////
//	Static function that allocates a new groupID by finding an empty slot in
//	the bitVector, then marking it as used and returning that bit #

UInt32	plGeometrySpan::IAllocateNewGroupID( void )
{
	UInt32			id;


	for( id = 0; id < fInstanceGroupIDFlags.GetSize(); id++ )
	{
		if( !fInstanceGroupIDFlags.IsBitSet( id ) )
			break;
	}

	fInstanceGroupIDFlags.SetBit( id, true );
	return id + 1;
}

//// IClearGroupID ///////////////////////////////////////////////////////////
//	Done with this groupID, so clear the entry in the bit table.

void	plGeometrySpan::IClearGroupID( UInt32 groupID )
{
	fInstanceGroupIDFlags.ClearBit( groupID - 1 );
}

//// IGetInstanceGroup ///////////////////////////////////////////////////////
//	This does the whole hash table thing lookup during read. If:
//	- The group ID does not yet exist:
//		- Allocates a new hsTArray, puts it into the hash table if expectedCount > 1,
//		  sets the groupID flag, and returns a pointer to the array.
//	- The group ID does exist:
//		- If the array count is less than expectedCount - 1, returns the array
//		- else sets the hash entry to nil and returns the array. 
//	Since we want to clear the hash table as soon as possible, but don't want
//	to search the entire hash table every time to make sure its empty, we
//	keep an ID of the highest element in the hash table that's set; every time
//	we remove an entry, we decrement this ID until we hit a used pointer again;
//	if we don't find one, we reset the array.

hsTArray<plGeometrySpan *>	*plGeometrySpan::IGetInstanceGroup( UInt32 groupID, UInt32 expectedCount )
{
	hsTArray<plGeometrySpan *>	*array;


	groupID--;		// Make it our array index

	if( fInstanceGroups.GetCount() <= groupID || fInstanceGroups[ groupID ] == nil )
	{
		// Not yet in the list--make a new hsTArray
		array = TRACKED_NEW hsTArray<plGeometrySpan *>;
		fInstanceGroupIDFlags.SetBit( groupID, true );
		
		if( expectedCount > 1 )
		{
			if( fInstanceGroups.GetCount() <= groupID )
				fInstanceGroups.ExpandAndZero( groupID + 1 );

			fInstanceGroups[ groupID ] = array;
			if( fHighestReadInstanceGroup < groupID + 1 )
				fHighestReadInstanceGroup = groupID + 1;
		}

		return array;
	}
	else 
	{
		// In the list...get it, but are we done with it?
		array = fInstanceGroups[ groupID ];
		if( expectedCount == array->GetCount() + 1 )	// I.E. next Append() will make it ==
		{
			// Done with it, remove from hash table
			fInstanceGroups[ groupID ] = nil;
			
			// Find new fHighestReadInstanceGroup
			for( ; fHighestReadInstanceGroup > 0 && fInstanceGroups[ fHighestReadInstanceGroup - 1 ] == nil; 
				   fHighestReadInstanceGroup-- );

			if( fHighestReadInstanceGroup == 0 )
				fInstanceGroups.Reset();
		}

		// Either way, return the array
		return array;
	}
}

//// IDuplicateUniqueData ////////////////////////////////////////////////////
//	Does the copy on all unique data--i.e. data copied for both clones and
//	instances.

void	plGeometrySpan::IDuplicateUniqueData( const plGeometrySpan *source )
{
	fCreating = source->fCreating;
	fVertAccum = source->fVertAccum;
	fIndexAccum = source->fIndexAccum;
	
	fMaterial = source->fMaterial;
	fLocalToWorld = source->fLocalToWorld;
	fWorldToLocal = source->fWorldToLocal;
	fLocalBounds = source->fLocalBounds;
	fWorldBounds = source->fWorldBounds;
	fFogEnviron = source->fFogEnviron;

	fBaseMatrix = source->fBaseMatrix;
	fNumMatrices = source->fNumMatrices;
	fLocalUVWChans = source->fLocalUVWChans;

	fFormat = source->fFormat;
	fProps = source->fProps;
	fNumVerts = source->fNumVerts;
	fNumIndices = source->fNumIndices;
	fDecalLevel = source->fDecalLevel;

	if( source->fIndexData != nil )
	{
		fIndexData = TRACKED_NEW UInt16[ fNumIndices ];
		memcpy( fIndexData, source->fIndexData, sizeof( UInt16 ) * fNumIndices );
	}
	else
		fIndexData = nil;

	if( source->fDiffuseRGBA )
	{
		fDiffuseRGBA = TRACKED_NEW UInt32[ fNumVerts ];
		memcpy( fDiffuseRGBA, source->fDiffuseRGBA, sizeof( UInt32 ) * fNumVerts );
	}
	else 
		fDiffuseRGBA = nil;

	if( source->fSpecularRGBA )
	{
		fSpecularRGBA = TRACKED_NEW UInt32[ fNumVerts ];
		memcpy( fSpecularRGBA, source->fSpecularRGBA, sizeof( UInt32 ) * fNumVerts );
	}
	else 
		fSpecularRGBA = nil;

	fLocalToOBB = source->fLocalToOBB;
	fOBBToLocal = source->fOBBToLocal;
}

//// CopyFrom ////////////////////////////////////////////////////////////////
//	Duplicate this span from a given span.

void	plGeometrySpan::CopyFrom( const plGeometrySpan *source )
{
	UInt32		size;


	// Just to make sure
	ClearBuffers();

	IDuplicateUniqueData( source );

	fInstanceRefs = nil;
	fInstanceGroupID = kNoGroupID;

	if( source->fVertexData != nil )
	{
		size = GetVertexSize( fFormat );

		fVertexData = TRACKED_NEW UInt8[ size * fNumVerts ];
		memcpy( fVertexData, source->fVertexData, size * fNumVerts );
	}
	else
		fVertexData = nil;

	if( source->fMultColor )
	{
		fMultColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		memcpy( fMultColor, source->fMultColor, sizeof(hsColorRGBA) * fNumVerts );
	}
	else
	{
		fMultColor = nil;
	}

	if( source->fAddColor )
	{
		fAddColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		memcpy( fAddColor, source->fAddColor, sizeof(hsColorRGBA) * fNumVerts );
	}
	else
	{
		fAddColor = nil;
	}
}

//// Read ////////////////////////////////////////////////////////////////////

void	plGeometrySpan::Read( hsStream *stream )
{
	UInt32		size, i;


	hsAssert( !fCreating, "Cannot read geometry span while creating" );

	// Just to make sure
	ClearBuffers();

	fCreating = false;

	// WARNING: can't read in the material here, so hopefully the owner will set it for us...
	// Same with the fog environ

	fLocalToWorld.Read( stream );
	fWorldToLocal.Read( stream );
	fLocalBounds.Read( stream );
	fWorldBounds = fLocalBounds;
	fWorldBounds.Transform(&fLocalToWorld);

	fOBBToLocal.Read(stream);
	fLocalToOBB.Read(stream);

	fBaseMatrix = stream->ReadSwap32();
	fNumMatrices = stream->ReadByte();
	fLocalUVWChans = stream->ReadSwap16();
	fMaxBoneIdx = stream->ReadSwap16();
	fPenBoneIdx = stream->ReadSwap16();

	fMinDist = stream->ReadSwapScalar();
	fMaxDist = stream->ReadSwapScalar();

	fFormat = stream->ReadByte();
	fProps = stream->ReadSwap32();
	fNumVerts = stream->ReadSwap32();
	fNumIndices = stream->ReadSwap32();

	// FIXME MAJOR VERSION
	// remove these two lines. No more patches.
	stream->ReadSwap32();
	stream->ReadByte();

	fDecalLevel = stream->ReadSwap32();

	if( fProps & kWaterHeight )
		fWaterHeight = stream->ReadSwapScalar();

	if( fNumVerts > 0 )
	{
		size = GetVertexSize( fFormat );

		fVertexData = TRACKED_NEW UInt8[ size * fNumVerts ];
		stream->Read( size * fNumVerts, fVertexData );

		fMultColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		fAddColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];
		for( i = 0; i < fNumVerts; i++ )
		{
			fMultColor[ i ].Read( stream );
			fAddColor[ i ].Read( stream );
		}

		fDiffuseRGBA = TRACKED_NEW UInt32[ fNumVerts ];
		fSpecularRGBA = TRACKED_NEW UInt32[ fNumVerts ];
		stream->ReadSwap32( fNumVerts, fDiffuseRGBA );
		stream->ReadSwap32( fNumVerts, fSpecularRGBA );
	}
	else
	{
		fVertexData = nil;
		fMultColor = nil;
		fAddColor = nil;
		fDiffuseRGBA = nil;
		fSpecularRGBA = nil;
	}

	if( fNumIndices > 0 )
	{
		fIndexData = TRACKED_NEW UInt16[ fNumIndices ];
		stream->ReadSwap16( fNumIndices, fIndexData );
	}
	else
		fIndexData = nil;

	// Read the group ID, then look up our instanceRef array from it
	fInstanceGroupID = stream->ReadSwap32();
	if( fInstanceGroupID != kNoGroupID )
	{
		UInt32	count = stream->ReadSwap32();

		fInstanceRefs = IGetInstanceGroup( fInstanceGroupID, count );
		fInstanceRefs->Append( this );
		hsAssert( fInstanceRefs != nil, "Cannot locate fInstanceRefs on plGeometrySpan::Read()" );
	}
}

//// Write ///////////////////////////////////////////////////////////////////

void	plGeometrySpan::Write( hsStream *stream )
{
	UInt32		size, i;


	hsAssert( !fCreating, "Cannot write geometry span while creating" );

	// WARNING: can't write out the material here, so hopefully the owner will do it for us...
	// Same with the fog environ

	fLocalToWorld.Write( stream );
	fWorldToLocal.Write( stream );
	fLocalBounds.Write( stream );

	fOBBToLocal.Write(stream);
	fLocalToOBB.Write(stream);

	stream->WriteSwap32( fBaseMatrix );
	stream->WriteByte( fNumMatrices );
	stream->WriteSwap16(fLocalUVWChans);
	stream->WriteSwap16(fMaxBoneIdx);
	stream->WriteSwap16((UInt16)fPenBoneIdx);

	stream->WriteSwapScalar(fMinDist);
	stream->WriteSwapScalar(fMaxDist);

	stream->WriteByte( fFormat );
	stream->WriteSwap32( fProps );
	stream->WriteSwap32( fNumVerts );
	stream->WriteSwap32( fNumIndices );

	// FIXME MAJOR VERSION
	// Remove these two lines.
	stream->WriteSwap32(0);
	stream->WriteByte(0);

	stream->WriteSwap32( fDecalLevel );

	if( fProps & kWaterHeight )
		stream->WriteSwapScalar(fWaterHeight);

	if( fNumVerts > 0 )
	{
		size = GetVertexSize( fFormat );

		stream->Write( size * fNumVerts, fVertexData );

		for( i = 0; i < fNumVerts; i++ )
		{
			fMultColor[ i ].Write( stream );
			fAddColor[ i ].Write( stream );
		}
		stream->WriteSwap32( fNumVerts, fDiffuseRGBA );
		stream->WriteSwap32( fNumVerts, fSpecularRGBA );
	}

	if( fNumIndices > 0 )
	{
		stream->WriteSwap16( fNumIndices, fIndexData );
	}

	// Write the groupID as well as the count for instanceRefs. This way
	stream->WriteSwap32( fInstanceGroupID );
	if( fInstanceGroupID != kNoGroupID )
		stream->WriteSwap32( fInstanceRefs->GetCount() );
	else
	{
		hsAssert( fInstanceRefs == nil, "Nil instanceRefs array but no group ID, non sequitur" );
	}
}

//// GetVertexSize ///////////////////////////////////////////////////////////

UInt32	plGeometrySpan::GetVertexSize( UInt8 format )
{
	UInt32	size;


	size = sizeof( float ) * ( 3 + 3 );	// pos + normal
	// Taken out 8.6.2001 mcn - Diffuse and specular are now separate arrays
//	size += sizeof( DWORD ) * 2;			// diffuse + specular

	size += sizeof( float ) * 3 * CalcNumUVs( format );

	switch( format & kSkinWeightMask )
	{
		case kSkinNoWeights: break;
		case kSkin1Weight:  size += sizeof( float ) * 1; break;
		case kSkin2Weights: size += sizeof( float ) * 2; break;
		case kSkin3Weights: size += sizeof( float ) * 3; break;
		default: hsAssert( false, "Bad weight count in GetVertexSize()" );
	}
	if( format & kSkinIndices )
		size += sizeof(UInt32);

	return size;
}

//// BeginCreate //////////////////////////////////////////////////////////////

void	plGeometrySpan::BeginCreate( hsGMaterial *material, const hsMatrix44 &l2wMatrix, UInt8 format )
{
	fCreating = true;

	fMaterial = material;
	fLocalToWorld = l2wMatrix;
	fLocalToWorld.GetInverse( &fWorldToLocal );
	fFormat = format;
}

//// AddVertex ////////////////////////////////////////////////////////////////
//	Note: uvPtrArray is an array of pointers to hsPoint3s. If a pointer is nil,
//	that UV channel (and all above them) are not used. The array of pointers 
//	MUST be of size kMaxNumUVChannels.

UInt16	plGeometrySpan::AddVertex( hsPoint3 *position, hsPoint3 *normal, hsColorRGBA& multColor, hsColorRGBA& addColor, 
									hsPoint3 **uvPtrArray, float weight1, float weight2, float weight3, UInt32 indices )
{
	AddVertex( position, normal, 0, 0, uvPtrArray, weight1, weight2, weight3, indices );

	int idx = fVertAccum.GetCount() - 1;

	TempVertex& vert = fVertAccum[idx];
	vert.fMultColor = multColor;
	vert.fAddColor = addColor;
	

	return idx;
}

UInt16	plGeometrySpan::AddVertex( hsPoint3 *position, hsPoint3 *normal, UInt32 hexColor, UInt32 specularColor, 
									hsPoint3 **uvPtrArray, float weight1, float weight2, float weight3, UInt32 indices )
{
	TempVertex		vert;
	int				i, numWeights;


	hsAssert( fCreating, "Calling AddVertex() on a non-creating plGeometrySpan!" );

	// UV channels
	if( uvPtrArray != nil )
	{
		for( i = 0; i < kMaxNumUVChannels; i++ )
		{
			if( uvPtrArray[ i ] == nil )
				break;
			vert.fUVs[ i ] = *(uvPtrArray[ i ]);
		}
	}
	else
		i = 0;
	hsAssert( GetNumUVs() == i, "Incorrect number of UVs passed to AddVertex()" );

	switch( fFormat & kSkinWeightMask )
	{
	case kSkin3Weights:
		numWeights = 3;
		vert.fWeights[ 0 ] = weight1;
		vert.fWeights[ 1 ] = weight2;
		vert.fWeights[ 2 ] = weight3;
		vert.fIndices = indices;
		break;
	case kSkin2Weights:
		numWeights = 2;
		vert.fWeights[ 0 ] = weight1;
		vert.fWeights[ 1 ] = weight2;
		vert.fIndices = indices;
		break;
	case kSkin1Weight:
		numWeights = 1;
		vert.fWeights[ 0 ] = weight1;
		vert.fIndices = indices;
		break;
	default:
	case kSkinNoWeights:
		numWeights = 0;
		break;
	}

	vert.fPosition = *position;
	vert.fNormal = *normal;
	vert.fColor = hexColor;
	vert.fSpecularColor = specularColor;
	vert.fMultColor.Set( 1.f, 1.f, 1.f, 1.f );
	vert.fAddColor.Set( 0, 0, 0, 1.f );

	fVertAccum.Append( vert );
	return fVertAccum.GetCount() - 1;
}

//// AddIndex Variations //////////////////////////////////////////////////////

void	plGeometrySpan::AddIndex( UInt16 index )
{
	hsAssert( fCreating, "Calling AddIndex() on a non-creating plGeometrySpan!" );

	fIndexAccum.Append( index );
}

void	plGeometrySpan::AddTriIndices( UInt16 index1, UInt16 index2, UInt16 index3 )
{
	hsAssert( fCreating, "Calling AddTriIndices() on a non-creating plGeometrySpan!" );

	fIndexAccum.Append( index1 );
	fIndexAccum.Append( index2 );
	fIndexAccum.Append( index3 );
}

//// AddTriangle //////////////////////////////////////////////////////////////

void	plGeometrySpan::AddTriangle( hsPoint3 *vert1, hsPoint3 *vert2, hsPoint3 *vert3, UInt32 color )
{
	hsVector3		twoTo1, twoTo3, normal;
	hsPoint3		normalPt;


	hsAssert( fCreating, "Calling AddTriangle() on a non-creating plGeometrySpan!" );

	twoTo1.Set( vert1, vert2 );
	twoTo3.Set( vert3, vert2 );

	normal = twoTo1 % twoTo3;
	normalPt.fX = normal.fX;
	normalPt.fY = normal.fY;
	normalPt.fZ = normal.fZ;

	AddIndex( AddVertex( vert1, &normalPt, color, 0 ) );
	AddIndex( AddVertex( vert2, &normalPt, color, 0 ) );
	AddIndex( AddVertex( vert3, &normalPt, color, 0 ) );
}

//// AddVertexArray ///////////////////////////////////////////////////////////

void	plGeometrySpan::AddVertexArray( UInt32 count, hsPoint3 *positions, hsVector3 *normals, UInt32 *colors, hsPoint3* uvws, int uvwsPerVtx )
{
	hsAssert( fCreating, "Calling AddTriIndices() on a non-creating plGeometrySpan!" );


	UInt32		i, dest;

	// This test actually does work, even if it's bad form...
	hsAssert( GetNumUVs() == uvwsPerVtx, "Calling wrong AddVertex() for plGeometrySpan format" );


	dest = fVertAccum.GetCount();
	fVertAccum.SetCount( dest + count );
	for( i = 0; i < count; i++, dest++ )
	{
		fVertAccum[ dest ].fPosition = positions[ i ];
		if( normals != nil )
		{
			// Stupid hsPoint3...I COULD change it, but why?
			fVertAccum[ dest ].fNormal.fX = normals[ i ].fX;
			fVertAccum[ dest ].fNormal.fY = normals[ i ].fY;
			fVertAccum[ dest ].fNormal.fZ = normals[ i ].fZ;
		}
		else
			fVertAccum[ dest ].fNormal.Set( 0, 0, 0 );

		if( colors != nil )
			fVertAccum[ dest ].fColor = colors[ i ];
		else
			fVertAccum[ dest ].fColor = 0xffffffff;

		if( uvws && uvwsPerVtx )
		{
			int j;
			for( j = 0; j < uvwsPerVtx; j++ )
				fVertAccum[ dest ].fUVs[ j ] = uvws[j];
			uvws += uvwsPerVtx;
		}
	}
}

//// AddIndexArray ////////////////////////////////////////////////////////////

void	plGeometrySpan::AddIndexArray( UInt32 count, UInt16 *indices )
{
	hsAssert( fCreating, "Calling AddTriIndices() on a non-creating plGeometrySpan!" );


	UInt32		i, dest;


	dest = fIndexAccum.GetCount();
	fIndexAccum.SetCount( dest + count );
	for( i = 0; i < count; i++, dest++ )
		fIndexAccum[ dest ] = indices[ i ];
}

//// EndCreate ////////////////////////////////////////////////////////////////

void	plGeometrySpan::EndCreate( void )
{
	hsBounds3Ext	bounds;
	UInt32			i, size;
	UInt8			*tempPtr;


	hsAssert( fCreating, "Calling EndCreate() on a non-creating plGeometrySpan!" );

	/// If we're empty, just clean up and return
	if( fVertAccum.GetCount() <= 0 )
	{
		delete [] fVertexData;
		fVertexData = nil;
		fNumVerts = 0;

		delete [] fIndexData;
		fIndexData = nil;
		fNumIndices = 0;
		fVertAccum.Reset();
		fIndexAccum.Reset();

		fCreating = false;
		return;
	}

	/// Convert vertices
	bounds.MakeEmpty();
	size = GetVertexSize( fFormat );

	if( fVertexData == nil || fNumVerts < fVertAccum.GetCount() )
	{
		if( fVertexData != nil )
			delete [] fVertexData;

		fNumVerts = fVertAccum.GetCount();
		fVertexData = TRACKED_NEW UInt8[ size * fNumVerts ];

		delete [] fMultColor;
		fMultColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];

		delete [] fAddColor;
		fAddColor = TRACKED_NEW hsColorRGBA[ fNumVerts ];

		delete [] fDiffuseRGBA;
		delete [] fSpecularRGBA;
		fDiffuseRGBA = TRACKED_NEW UInt32[ fNumVerts ];
		fSpecularRGBA = TRACKED_NEW UInt32[ fNumVerts ];
	}
	else
		fNumVerts = fVertAccum.GetCount();

	for( i = 0, tempPtr = fVertexData; i < fNumVerts; i++ )
	{
		// Get position, normal, color
		memcpy( tempPtr, &fVertAccum[ i ], 6 * sizeof(float) );
		tempPtr += 6 * sizeof(float);

		// Get Uvs
		int numUvs = GetNumUVs();
		if( numUvs > 0 )
		{
			memcpy( tempPtr, &fVertAccum[ i ].fUVs[ 0 ], numUvs * 3 * sizeof(float) );
			tempPtr += numUvs * 3 * sizeof(float);
		}

		// Get Weights
		if( fFormat & kSkinWeightMask )
		{
			int numWeights = 0;
			switch( fFormat & kSkinWeightMask )
			{
			case kSkin1Weight: numWeights = 1; break;
			case kSkin2Weights: numWeights = 2; break;
			case kSkin3Weights: numWeights = 3; break;
			default: hsAssert(false, "Garbage for weight format"); break;
			}
			memcpy( tempPtr, &fVertAccum[ i ].fWeights[ 0 ], numWeights * sizeof(float) );
			tempPtr += numWeights * sizeof(float);
			if( fFormat & kSkinIndices )
			{
				memcpy( tempPtr, &fVertAccum[ i ].fIndices, sizeof(UInt32) );
				tempPtr += sizeof(UInt32);
			}
		}

		fMultColor[i] = fVertAccum[i].fMultColor;
		fAddColor[i] = fVertAccum[i].fAddColor;
		fDiffuseRGBA[ i ] = fVertAccum[ i ].fColor;
		fSpecularRGBA[ i ] = fVertAccum[ i ].fSpecularColor;

		hsPoint3 pBnd = fLocalToOBB * fVertAccum[i].fPosition;
		bounds.Union(&pBnd);
	}
	bounds.Transform(&fOBBToLocal);
	
	if( fProps & kWaterHeight )
	{
		AdjustBounds(bounds);
	}
	
	fLocalBounds = bounds;
	fWorldBounds = fLocalBounds;
	fWorldBounds.Transform(&fLocalToWorld);

	/// Convert indices
	if( fIndexAccum.GetCount() == 0 )		// Allowed for patches
	{
		delete [] fIndexData;
		fIndexData = nil;
		fNumIndices = 0;
	}
	else if( fIndexData == nil || fNumIndices < fIndexAccum.GetCount() )
	{
		if( fIndexData != nil )
			delete [] fIndexData;

		fNumIndices = fIndexAccum.GetCount();
		fIndexData = TRACKED_NEW UInt16[ fNumIndices ];
	}
	else
		fNumIndices = fIndexAccum.GetCount();

	for( i = 0; i < fNumIndices; i++ )
		fIndexData[ i ] = fIndexAccum[ i ];

	/// Cleanup
	fVertAccum.Reset();
	fIndexAccum.Reset();
	fCreating = false;
}

void plGeometrySpan::AdjustBounds(hsBounds3Ext& bnd) const
{
	hsBounds3Ext wBnd = bnd;
	wBnd.Transform(&fLocalToWorld);

	const hsScalar kMaxWaveHeight(5.f);
	hsBounds3Ext rebound;
	rebound.MakeEmpty();
	hsPoint3 pos = wBnd.GetMins();
	pos.fZ = fWaterHeight - kMaxWaveHeight;
	rebound.Union(&pos);
	pos = wBnd.GetMaxs();
	pos.fZ = fWaterHeight + kMaxWaveHeight;
	rebound.Union(&pos);
	bnd = rebound;
	bnd.Transform(&fWorldToLocal);
}

//// ExtractVertex ////////////////////////////////////////////////////////////
void	plGeometrySpan::ExtractInitColor( UInt32 index, hsColorRGBA *multColor, hsColorRGBA *addColor) const
{
	if( multColor )
		*multColor = fMultColor[index];
	if( addColor )
		*addColor = fAddColor[index];
}

//	Extracts the given vertex out of the vertex buffer and into the pointers
//	given.

void	plGeometrySpan::ExtractVertex( UInt32 index, hsPoint3 *pos, hsVector3 *normal, hsColorRGBA *color, hsColorRGBA *specColor )
{
	UInt32		hex, spec;


	ExtractVertex( index, pos, normal, &hex, &spec );
	color->a = ( ( hex >> 24 ) & 0xff ) / 255.0f;
	color->r = ( ( hex >> 16 ) & 0xff ) / 255.0f;
	color->g = ( ( hex >>  8 ) & 0xff ) / 255.0f;
	color->b = ( ( hex >>  0 ) & 0xff ) / 255.0f;

	if( specColor != nil )
	{
		specColor->a = ( ( spec >> 24 ) & 0xff ) / 255.0f;
		specColor->r = ( ( spec >> 16 ) & 0xff ) / 255.0f;
		specColor->g = ( ( spec >>  8 ) & 0xff ) / 255.0f;
		specColor->b = ( ( spec >>  0 ) & 0xff ) / 255.0f;
	}
}

//// ExtractVertex ////////////////////////////////////////////////////////////
//	Hex-color version of ExtractVertex.

void	plGeometrySpan::ExtractVertex( UInt32 index, hsPoint3 *pos, hsVector3 *normal, UInt32 *color, UInt32 *specColor )
{
	UInt8		*basePtr;
	float		*fPtr;


	/// Where?
	hsAssert( index < fNumVerts, "Invalid index passed to ExtractVertex()" );
	basePtr = fVertexData + index * GetVertexSize( fFormat );

	/// Copy over point and normal
	fPtr = (float *)basePtr;
	pos->fX = fPtr[ 0 ];
	pos->fY = fPtr[ 1 ];
	pos->fZ = fPtr[ 2 ];
	normal->fX = fPtr[ 3 ];
	normal->fY = fPtr[ 4 ];
	normal->fZ = fPtr[ 5 ];
	fPtr += 6;

	/// Diffuse color
	*color = fDiffuseRGBA[ index ];
	if( specColor != nil )
		*specColor = fSpecularRGBA[ index ];
}

//// ExtractUv ////////////////////////////////////////////////////////////////

void	plGeometrySpan::ExtractUv( UInt32 vIdx, UInt8 uvIdx, hsPoint3 *uv )
{
	UInt8		*basePtr;
	float		*fPtr;


	/// Where?
	hsAssert( vIdx < fNumVerts, "Invalid index passed to ExtractVertex()" );
	hsAssert( uvIdx < GetNumUVs(), "Invalid UV index passed to ExtractVertex()" );
	basePtr = fVertexData + vIdx * GetVertexSize( fFormat );

	/// Skip over point, normal, and color and specular color
	basePtr += 12 + 12;

	fPtr = (float *)basePtr;
	fPtr += 3 * uvIdx;
	uv->fX = *fPtr++;
	uv->fY = *fPtr++;
	uv->fZ = *fPtr;
}

//// ExtractWeights ///////////////////////////////////////////////////////////
//	Gets the weights out of the vertex data.

void	plGeometrySpan::ExtractWeights( UInt32 vIdx, float *weightArray, UInt32 *indices )
{
	UInt8		*basePtr;
	float		*fPtr;
	UInt32		*dPtr;
	int			numWeights;


	/// Where?
	hsAssert( vIdx < fNumVerts, "Invalid index passed to ExtractVertex()" );
	basePtr = fVertexData + vIdx * GetVertexSize( fFormat );

	/// Copy over weights
	basePtr += sizeof( float ) * ( 6 + 3 * GetNumUVs() );
	fPtr = (float *)basePtr;
	switch( fFormat & kSkinWeightMask )
	{
		case kSkinNoWeights: hsAssert( false, "ExtractWeights() called on a span with no weights" ); break;
		case kSkin1Weight: numWeights = 1; break;
		case kSkin2Weights: numWeights = 2; break;
		case kSkin3Weights: numWeights = 3; break;
		default: hsAssert( false, "Bad number of weights in ExtractWeights()" );
	}

	memcpy( weightArray, fPtr, sizeof( float ) * numWeights );

	if( fFormat & kSkinIndices )
	{
		fPtr += numWeights;

		dPtr = (UInt32 *)fPtr;
		*indices = *dPtr;
	}
}

//// StuffVertex //////////////////////////////////////////////////////////////
//	Stuffs the given vertex data into the vertex buffer. Vertex must already
//	exist!

void	plGeometrySpan::StuffVertex( UInt32 index, hsPoint3 *pos, hsPoint3 *normal, hsColorRGBA *color, hsColorRGBA *specColor )
{
	UInt8		*basePtr;
	float		*fPtr;


	/// Where?
	hsAssert( index < fNumVerts, "Invalid index passed to StuffVertex()" );
	basePtr = fVertexData + index * GetVertexSize( fFormat );

	/// Copy over point and normal
	fPtr = (float *)basePtr;
	fPtr[ 0 ] = pos->fX;
	fPtr[ 1 ] = pos->fY;
	fPtr[ 2 ] = pos->fZ;

	fPtr[ 3 ] = normal->fX;
	fPtr[ 4 ] = normal->fY;
	fPtr[ 5 ] = normal->fZ;
	fPtr += 6;

	/// Diffuse color
	StuffVertex( index, color, specColor );
}

void	plGeometrySpan::StuffVertex( UInt32 index, hsColorRGBA *color, hsColorRGBA *specColor )
{
	UInt8		r, g, b, a;


	/// Where?
	hsAssert( index < fNumVerts, "Invalid index passed to StuffVertex()" );

	a = (UInt8)( color->a >= 1 ? 255 : color->a <= 0 ? 0 : color->a * 255.0 );
	r = (UInt8)( color->r >= 1 ? 255 : color->r <= 0 ? 0 : color->r * 255.0 );
	g = (UInt8)( color->g >= 1 ? 255 : color->g <= 0 ? 0 : color->g * 255.0 );
	b = (UInt8)( color->b >= 1 ? 255 : color->b <= 0 ? 0 : color->b * 255.0 );
	
	fDiffuseRGBA[ index ] = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | ( b );

	if( specColor != nil )
	{
		a = (UInt8)( specColor->a >= 1 ? 255 : specColor->a <= 0 ? 0 : specColor->a * 255.0 );
		r = (UInt8)( specColor->r >= 1 ? 255 : specColor->r <= 0 ? 0 : specColor->r * 255.0 );
		g = (UInt8)( specColor->g >= 1 ? 255 : specColor->g <= 0 ? 0 : specColor->g * 255.0 );
		b = (UInt8)( specColor->b >= 1 ? 255 : specColor->b <= 0 ? 0 : specColor->b * 255.0 );
		
		fSpecularRGBA[ index ] = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | ( b );
	}
}