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