csgo/cstrike15_src/movieobjects/dmemesh.cpp

//====== Copyright � 1996-2004, Valve Corporation, All rights reserved. =======
//
// Purpose: 
//
//=============================================================================

// Standard includes
#include <limits.h>

// Valve includes
#include "movieobjects/dmemesh.h"
#include "movieobjects/dmevertexdata.h"
#include "movieobjects/dmefaceset.h"
#include "movieobjects/dmematerial.h"
#include "movieobjects/dmetransform.h"
#include "movieobjects/dmemodel.h"
#include "movieobjects_interfaces.h"
#include "movieobjects/dmecombinationoperator.h"
#include "movieobjects/dmeselection.h"
#include "movieobjects/dmedrawsettings.h"
#include "movieobjects/dmmeshcomp.h"
#include "tier3/tier3.h"
#include "tier1/keyvalues.h"
#include "tier0/dbg.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imorph.h"
#include "materialsystem/imesh.h"
#include "materialsystem/imaterialvar.h"
#include "istudiorender.h"
#include "studio.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


//-----------------------------------------------------------------------------
// Normal rendering materials
//-----------------------------------------------------------------------------
bool CDmeMesh::s_bNormalMaterialInitialized;
CMaterialReference CDmeMesh::s_NormalMaterial;


//-----------------------------------------------------------------------------
// Wireframe rendering materials
//-----------------------------------------------------------------------------
bool CDmeMesh::s_bWireframeMaterialInitialized;
CMaterialReference CDmeMesh::s_WireframeMaterial;


//-----------------------------------------------------------------------------
// Computes a skin matrix 
//-----------------------------------------------------------------------------
static const matrix3x4_t *ComputeSkinMatrix( int nBoneCount, const float *pJointWeight, const int *pJointIndices, const matrix3x4_t *pPoseToWorld, matrix3x4_t &result )
{
	float flWeight0, flWeight1, flWeight2, flWeight3;

	switch( nBoneCount )
	{
	default:
	case 1:
		return &pPoseToWorld[pJointIndices[0]];

	case 2:
		{
			const matrix3x4_t &boneMat0 = pPoseToWorld[pJointIndices[0]];
			const matrix3x4_t &boneMat1 = pPoseToWorld[pJointIndices[1]];
			flWeight0 = pJointWeight[0];
			flWeight1 = pJointWeight[1];

			// NOTE: Inlining here seems to make a fair amount of difference
			result[0][0] = boneMat0[0][0] * flWeight0 + boneMat1[0][0] * flWeight1;
			result[0][1] = boneMat0[0][1] * flWeight0 + boneMat1[0][1] * flWeight1;
			result[0][2] = boneMat0[0][2] * flWeight0 + boneMat1[0][2] * flWeight1;
			result[0][3] = boneMat0[0][3] * flWeight0 + boneMat1[0][3] * flWeight1;
			result[1][0] = boneMat0[1][0] * flWeight0 + boneMat1[1][0] * flWeight1;
			result[1][1] = boneMat0[1][1] * flWeight0 + boneMat1[1][1] * flWeight1;
			result[1][2] = boneMat0[1][2] * flWeight0 + boneMat1[1][2] * flWeight1;
			result[1][3] = boneMat0[1][3] * flWeight0 + boneMat1[1][3] * flWeight1;
			result[2][0] = boneMat0[2][0] * flWeight0 + boneMat1[2][0] * flWeight1;
			result[2][1] = boneMat0[2][1] * flWeight0 + boneMat1[2][1] * flWeight1;
			result[2][2] = boneMat0[2][2] * flWeight0 + boneMat1[2][2] * flWeight1;
			result[2][3] = boneMat0[2][3] * flWeight0 + boneMat1[2][3] * flWeight1;
		}
		return &result;

	case 3:
		{
			const matrix3x4_t &boneMat0 = pPoseToWorld[pJointIndices[0]];
			const matrix3x4_t &boneMat1 = pPoseToWorld[pJointIndices[1]];
			const matrix3x4_t &boneMat2 = pPoseToWorld[pJointIndices[2]];
			flWeight0 = pJointWeight[0];
			flWeight1 = pJointWeight[1];
			flWeight2 = pJointWeight[2];

			result[0][0] = boneMat0[0][0] * flWeight0 + boneMat1[0][0] * flWeight1 + boneMat2[0][0] * flWeight2;
			result[0][1] = boneMat0[0][1] * flWeight0 + boneMat1[0][1] * flWeight1 + boneMat2[0][1] * flWeight2;
			result[0][2] = boneMat0[0][2] * flWeight0 + boneMat1[0][2] * flWeight1 + boneMat2[0][2] * flWeight2;
			result[0][3] = boneMat0[0][3] * flWeight0 + boneMat1[0][3] * flWeight1 + boneMat2[0][3] * flWeight2;
			result[1][0] = boneMat0[1][0] * flWeight0 + boneMat1[1][0] * flWeight1 + boneMat2[1][0] * flWeight2;
			result[1][1] = boneMat0[1][1] * flWeight0 + boneMat1[1][1] * flWeight1 + boneMat2[1][1] * flWeight2;
			result[1][2] = boneMat0[1][2] * flWeight0 + boneMat1[1][2] * flWeight1 + boneMat2[1][2] * flWeight2;
			result[1][3] = boneMat0[1][3] * flWeight0 + boneMat1[1][3] * flWeight1 + boneMat2[1][3] * flWeight2;
			result[2][0] = boneMat0[2][0] * flWeight0 + boneMat1[2][0] * flWeight1 + boneMat2[2][0] * flWeight2;
			result[2][1] = boneMat0[2][1] * flWeight0 + boneMat1[2][1] * flWeight1 + boneMat2[2][1] * flWeight2;
			result[2][2] = boneMat0[2][2] * flWeight0 + boneMat1[2][2] * flWeight1 + boneMat2[2][2] * flWeight2;
			result[2][3] = boneMat0[2][3] * flWeight0 + boneMat1[2][3] * flWeight1 + boneMat2[2][3] * flWeight2;
		}
		return &result;

	case 4:
		{
			const matrix3x4_t &boneMat0 = pPoseToWorld[pJointIndices[0]];
			const matrix3x4_t &boneMat1 = pPoseToWorld[pJointIndices[1]];
			const matrix3x4_t &boneMat2 = pPoseToWorld[pJointIndices[2]];
			const matrix3x4_t &boneMat3 = pPoseToWorld[pJointIndices[3]];
			flWeight0 = pJointWeight[0];
			flWeight1 = pJointWeight[1];
			flWeight2 = pJointWeight[2];
			flWeight3 = pJointWeight[3];

			result[0][0] = boneMat0[0][0] * flWeight0 + boneMat1[0][0] * flWeight1 + boneMat2[0][0] * flWeight2 + boneMat3[0][0] * flWeight3;
			result[0][1] = boneMat0[0][1] * flWeight0 + boneMat1[0][1] * flWeight1 + boneMat2[0][1] * flWeight2 + boneMat3[0][1] * flWeight3;
			result[0][2] = boneMat0[0][2] * flWeight0 + boneMat1[0][2] * flWeight1 + boneMat2[0][2] * flWeight2 + boneMat3[0][2] * flWeight3;
			result[0][3] = boneMat0[0][3] * flWeight0 + boneMat1[0][3] * flWeight1 + boneMat2[0][3] * flWeight2 + boneMat3[0][3] * flWeight3;
			result[1][0] = boneMat0[1][0] * flWeight0 + boneMat1[1][0] * flWeight1 + boneMat2[1][0] * flWeight2 + boneMat3[1][0] * flWeight3;
			result[1][1] = boneMat0[1][1] * flWeight0 + boneMat1[1][1] * flWeight1 + boneMat2[1][1] * flWeight2 + boneMat3[1][1] * flWeight3;
			result[1][2] = boneMat0[1][2] * flWeight0 + boneMat1[1][2] * flWeight1 + boneMat2[1][2] * flWeight2 + boneMat3[1][2] * flWeight3;
			result[1][3] = boneMat0[1][3] * flWeight0 + boneMat1[1][3] * flWeight1 + boneMat2[1][3] * flWeight2 + boneMat3[1][3] * flWeight3;
			result[2][0] = boneMat0[2][0] * flWeight0 + boneMat1[2][0] * flWeight1 + boneMat2[2][0] * flWeight2 + boneMat3[2][0] * flWeight3;
			result[2][1] = boneMat0[2][1] * flWeight0 + boneMat1[2][1] * flWeight1 + boneMat2[2][1] * flWeight2 + boneMat3[2][1] * flWeight3;
			result[2][2] = boneMat0[2][2] * flWeight0 + boneMat1[2][2] * flWeight1 + boneMat2[2][2] * flWeight2 + boneMat3[2][2] * flWeight3;
			result[2][3] = boneMat0[2][3] * flWeight0 + boneMat1[2][3] * flWeight1 + boneMat2[2][3] * flWeight2 + boneMat3[2][3] * flWeight3;
		}
		return &result;
	}

	Assert(0);
	return NULL;
}


//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CDmeMeshRenderInfo::CDmeMeshRenderInfo( CDmeVertexData *pBaseState ) :
	m_PositionIndices( pBaseState->GetVertexIndexData( CDmeVertexData::FIELD_POSITION ) ),
	m_PositionData( pBaseState->GetPositionData() ),
	m_NormalIndices( pBaseState->GetVertexIndexData( CDmeVertexData::FIELD_NORMAL ) ),
	m_NormalData( pBaseState->GetNormalData() ),
	m_TangentIndices( pBaseState->GetVertexIndexData( CDmeVertexData::FIELD_TANGENT ) ),
	m_TangentData( pBaseState->GetTangentData() )
{
	m_pBaseState = pBaseState;
	m_bHasPositionData = m_PositionIndices.Count() > 0;
	m_bHasNormalData = m_NormalIndices.Count() > 0;
	m_bHasTangentData = m_TangentIndices.Count() > 0;
	m_nJointCount = pBaseState->JointCount();
	m_bHasSkinningData = pBaseState->HasSkinningData() && m_nJointCount > 0;
}
	

//-----------------------------------------------------------------------------
// Computes where a vertex is
//-----------------------------------------------------------------------------
void CDmeMeshRenderInfo::ComputePosition( int nPosIndex, const matrix3x4_t *pPoseToWorld, Vector *pDeltaPosition, Vector *pPosition )
{
	matrix3x4_t result;
	Vector vecMorphPosition;
	const matrix3x4_t *pSkinMatrix = pPoseToWorld;

	if ( m_bHasSkinningData )
	{
		const FieldIndex_t nJointWeightsFieldIndex = m_pBaseState->FindFieldIndex( CDmeVertexData::FIELD_JOINT_WEIGHTS );
		if ( nJointWeightsFieldIndex >= 0 )
		{
			const FieldIndex_t nJointIndicesFieldIndex = m_pBaseState->FindFieldIndex( CDmeVertexData::FIELD_JOINT_INDICES );
			if ( nJointIndicesFieldIndex >= 0 )
			{
				const CDmrArrayConst< float > jointWeights( m_pBaseState->GetVertexData( nJointWeightsFieldIndex ) );
				const float *pJointWeight = &jointWeights[ nPosIndex * m_pBaseState->JointCount() ];

				const CDmrArrayConst< int > jointIndices( m_pBaseState->GetVertexData( nJointIndicesFieldIndex ) );
				const int *pJointIndices = &jointIndices[ nPosIndex * m_pBaseState->JointCount() ];

				pSkinMatrix = ComputeSkinMatrix( m_nJointCount, pJointWeight, pJointIndices, pPoseToWorld, result );
			}
		}
	}

	const Vector *pPositionData = &m_PositionData[ nPosIndex ];

	if ( pDeltaPosition )
	{
		VectorAdd( *pPositionData, *( pDeltaPosition + nPosIndex ), vecMorphPosition );
		pPositionData = &vecMorphPosition;
	}

	VectorTransform( *pPositionData, *pSkinMatrix, *( pPosition + nPosIndex ) );
}


//-----------------------------------------------------------------------------
// Computes where a vertex is
//-----------------------------------------------------------------------------
void CDmeMeshRenderInfo::ComputePosition(
	int nPosIndex,
	const matrix3x4_t *pPoseToWorld,
	CDmeMesh::RenderVertexDelta_t *pDelta,
	Vector *pPosition )
{
	matrix3x4_t result;
	Vector vecMorphPosition, vecMorphNormal;
	const matrix3x4_t *pSkinMatrix = pPoseToWorld;

	if ( m_bHasSkinningData )
	{
		const FieldIndex_t nJointWeightsFieldIndex = m_pBaseState->FindFieldIndex( CDmeVertexData::FIELD_JOINT_WEIGHTS );
		if ( nJointWeightsFieldIndex >= 0 )
		{
			const FieldIndex_t nJointIndicesFieldIndex = m_pBaseState->FindFieldIndex( CDmeVertexData::FIELD_JOINT_INDICES );
			if ( nJointIndicesFieldIndex >= 0 )
			{
				const CDmrArrayConst< float > jointWeights( m_pBaseState->GetVertexData( nJointWeightsFieldIndex ) );
				const float *pJointWeight = &jointWeights[ nPosIndex * m_pBaseState->JointCount() ];

				const CUtlVector< int > &jointIndices = m_pBaseState->GetVertexIndexData( nJointIndicesFieldIndex );
				const int *pJointIndices = &jointIndices[ nPosIndex * m_pBaseState->JointCount() ];

				pSkinMatrix = ComputeSkinMatrix( m_nJointCount, pJointWeight, pJointIndices, pPoseToWorld, result );
			}
		}
	}

	const Vector *pPositionData = &m_PositionData[ nPosIndex ];

	if ( pDelta )
	{
		VectorAdd( *pPositionData, pDelta[ nPosIndex ].m_vecDeltaPosition, vecMorphPosition );
		pPositionData = &vecMorphPosition;
	}

	VectorTransform( *pPositionData, *pSkinMatrix, *pPosition );
}


//-----------------------------------------------------------------------------
// Computes where a vertex is
//-----------------------------------------------------------------------------
void CDmeMeshRenderInfo::ComputeVertex(
	int vi,
	const matrix3x4_t *pPoseToWorld,
	CDmeMesh::RenderVertexDelta_t *pDelta,
	Vector *pPosition, Vector *pNormal, Vector4D *pTangent )
{
	matrix3x4_t result;
	Vector vecMorphPosition, vecMorphNormal;
	const matrix3x4_t *pSkinMatrix = pPoseToWorld;

	if ( m_bHasSkinningData )
	{
		const float *pJointWeight = m_pBaseState->GetJointWeights( vi );
		const int *pJointIndices = m_pBaseState->GetJointIndices( vi );
		pSkinMatrix = ComputeSkinMatrix( m_nJointCount, pJointWeight, pJointIndices, pPoseToWorld, result );
	}

	int pi = m_PositionIndices[ vi ];
	const Vector *pPositionData = &m_PositionData[ pi ];
	if ( pDelta )
	{
		VectorAdd( *pPositionData, pDelta[ pi ].m_vecDeltaPosition, vecMorphPosition );
		pPositionData = &vecMorphPosition;
	}
	VectorTransform( *pPositionData, *pSkinMatrix, *pPosition );

	if ( m_bHasNormalData )
	{
		int ni = m_NormalIndices[ vi ];
		const Vector *pNormalData = &m_NormalData[ ni ];
		if ( pDelta )
		{
			VectorAdd( *pNormalData, pDelta[ni].m_vecDeltaNormal, vecMorphNormal );
			pNormalData = &vecMorphNormal;
		}
		VectorRotate( *pNormalData, *pSkinMatrix, *pNormal );
		VectorNormalize( *pNormal );
	}
	else
	{
		pNormal->Init( 0.0f, 0.0f, 1.0f );
	}

	if ( m_bHasTangentData )
	{
		const Vector4D &tangentData = m_TangentData[ m_TangentIndices[ vi ] ];
		VectorRotate( tangentData.AsVector3D(), *pSkinMatrix, pTangent->AsVector3D() );
		VectorNormalize( pTangent->AsVector3D() );
		pTangent->w = tangentData.w;
	}
	else
	{
		pTangent->Init( 1.0f, 0.0f, 0.0f, 1.0f );
	}
}


//-----------------------------------------------------------------------------
// Expose this class to the scene database 
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeMesh, CDmeMesh );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeMesh::OnConstruction()
{
	m_BindBaseState.Init( this, "bindState" );
	m_CurrentBaseState.Init( this, "currentState" );
	m_BaseStates.Init( this, "baseStates", FATTRIB_MUSTCOPY );
	m_DeltaStates.Init( this, "deltaStates", FATTRIB_MUSTCOPY | FATTRIB_HAS_CALLBACK );
	m_FaceSets.Init( this, "faceSets", FATTRIB_MUSTCOPY );
	m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL].Init( this, "deltaStateWeights" );
	m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED].Init( this, "deltaStateWeightsLagged" );
}

void CDmeMesh::OnDestruction()
{
	if ( g_pMaterialSystem )
	{
		CleanupHWMesh();
	}
	m_hwFaceSets.RemoveAll();

	DeleteAttributeVarElementArray( m_BaseStates );
	DeleteAttributeVarElementArray( m_DeltaStates );
	DeleteAttributeVarElementArray( m_FaceSets );
}


//-----------------------------------------------------------------------------
// Cleans up the HW mesh in case of destruction or rebuild necessary
//-----------------------------------------------------------------------------
void CDmeMesh::CleanupHWMesh()
{
	if ( !g_pMaterialSystem )
		return;

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	int nCount = m_hwFaceSets.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !m_hwFaceSets[i].m_bBuilt )
			continue;

		if ( m_hwFaceSets[i].m_pMesh )
		{
			pRenderContext->DestroyStaticMesh( m_hwFaceSets[i].m_pMesh );
			m_hwFaceSets[i].m_pMesh = NULL;
		}
		m_hwFaceSets[i].m_bBuilt = false;
	}
}


//-----------------------------------------------------------------------------
// Initializes the normal material
//-----------------------------------------------------------------------------
void CDmeMesh::InitializeNormalMaterial()
{
	if ( !s_bNormalMaterialInitialized )
	{
		s_bNormalMaterialInitialized = true;

		KeyValues *pVMTKeyValues = new KeyValues( "wireframe" );
		pVMTKeyValues->SetInt( "$vertexcolor", 1 );
		pVMTKeyValues->SetInt( "$decal", 1 );
		s_NormalMaterial.Init( "__DmeMeshNormalMaterial", pVMTKeyValues );
	}
}


//-----------------------------------------------------------------------------
// Initializes the normal material
//-----------------------------------------------------------------------------
void CDmeMesh::InitializeWireframeMaterial()
{
	if ( !s_bWireframeMaterialInitialized )
	{
		s_bWireframeMaterialInitialized = true;

		KeyValues *pVMTKeyValues = new KeyValues( "wireframe" );
		pVMTKeyValues->SetInt( "$vertexcolor", 1 );
		s_WireframeMaterial.Init( "__DmeMeshWireframeMaterial", pVMTKeyValues );
	}
}


//-----------------------------------------------------------------------------
// resolve internal data from changed attributes
//-----------------------------------------------------------------------------
void CDmeMesh::OnAttributeChanged( CDmAttribute *pAttribute )
{
	BaseClass::OnAttributeChanged( pAttribute );

	if ( pAttribute == m_DeltaStates.GetAttribute() )
	{
		int nDeltaStateCount = m_DeltaStates.Count();
		for ( int i = 0; i < MESH_DELTA_WEIGHT_TYPE_COUNT; ++i )
		{
			// Make sure we have the correct number of weights
			int nWeightCount = m_DeltaStateWeights[i].Count();
			if ( nWeightCount < nDeltaStateCount )
			{
				for ( int j = nWeightCount; j < nDeltaStateCount; ++j )
				{
					m_DeltaStateWeights[i].AddToTail( Vector2D( 0.0f, 0.0f ) );
				}
			}
			else if ( nDeltaStateCount > nWeightCount )
			{
				m_DeltaStateWeights[i].RemoveMultiple( nWeightCount, nWeightCount - nDeltaStateCount );
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Adds deltas into a delta mesh
//-----------------------------------------------------------------------------
template< class T > bool CDmeMesh::AddVertexDelta(
	CDmeVertexData *pBaseState,
	void *pVertexData, int nStride, CDmeVertexDataBase::StandardFields_t fieldId, int nIndex, bool bDoLag )
{
	CDmeVertexDeltaData *pDeltaState = GetDeltaState( nIndex );

	if ( !pBaseState || !pDeltaState )
		return false;

	const FieldIndex_t nBaseFieldIndex = pBaseState->FindFieldIndex( fieldId == CDmeVertexData::FIELD_WRINKLE ? CDmeVertexData::FIELD_TEXCOORD : fieldId );
	const FieldIndex_t nDeltaFieldIndex = pDeltaState->FindFieldIndex( fieldId );
	if ( nBaseFieldIndex < 0 || nDeltaFieldIndex < 0 )
		return false;

	const CDmrArray<int> indices = pDeltaState->GetIndexData( nDeltaFieldIndex );
	const CDmrArray<T> delta = pDeltaState->GetVertexData( nDeltaFieldIndex );
	const int nDeltaCount = indices.Count();

	const float flWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][nIndex].x;

	const FieldIndex_t nSpeedFieldIndex = pBaseState->FindFieldIndex( CDmeVertexData::FIELD_MORPH_SPEED );

	const int nVertexCount = pBaseState->VertexCount();

	if ( !bDoLag || nSpeedFieldIndex < 0 )
	{
		for ( int j = 0; j < nDeltaCount; ++j )
		{
			int nDataIndex = indices.Get( j );
			if ( nDataIndex < 0 || nDataIndex >= nVertexCount )
			{
				Assert( nDataIndex >= 0 && nDataIndex < nVertexCount );
				continue;
			}

			T* pDeltaData = (T*)( (char*)pVertexData + nStride * nDataIndex );
			*pDeltaData += delta.Get( j ) * flWeight;
		}

		return true;
	}

	const float flLaggedWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][nIndex].x;

	const CDmrArrayConst<int> speedIndices = pBaseState->GetIndexData( nSpeedFieldIndex );
	const CDmrArrayConst<float> speedDelta = pBaseState->GetVertexData( nSpeedFieldIndex );
	for ( int j = 0; j < nDeltaCount; ++j )
	{
		int nDataIndex = indices.Get( j );
		const CUtlVector<int> &list = pBaseState->FindVertexIndicesFromDataIndex( nBaseFieldIndex, nDataIndex );
		Assert( list.Count() > 0 );
		// FIXME: Average everything in the list.. shouldn't be necessary though
		float flSpeed = speedDelta.Get( speedIndices.Get( list[0] ) );
		float flActualWeight = Lerp( flSpeed, flLaggedWeight, flWeight );

		T* pDeltaData = (T*)( (char*)pVertexData + nStride * nDataIndex );
		*pDeltaData += delta.Get( j ) * flActualWeight;
	}
	return true;
}
	

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::AddTexCoordDelta( RenderVertexDelta_t *pRenderDelta, float flWeight, CDmeVertexDeltaData *pDeltaState )
{
	if ( !pDeltaState )
		return;

	FieldIndex_t nFieldIndex = pDeltaState->FindFieldIndex( CDmeVertexDeltaData::FIELD_TEXCOORD );
	if ( nFieldIndex < 0 )
		return;

	bool bIsVCoordinateFlipped = pDeltaState->IsVCoordinateFlipped();
	const CDmrArray<int> indices = pDeltaState->GetIndexData( nFieldIndex );
	const CDmrArray<Vector2D> delta = pDeltaState->GetVertexData( nFieldIndex );
	int nDeltaCount = indices.Count();
	for ( int j = 0; j < nDeltaCount; ++j )
	{
		Vector2D uvDelta = delta.Get( j );
		if ( bIsVCoordinateFlipped )
		{
			uvDelta.y = -uvDelta.y;
		}
		Vector2D &vec2D = pRenderDelta[ indices.Get( j ) ].m_vecDeltaUV;
		Vector2DMA( vec2D, flWeight, uvDelta, vec2D );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::AddColorDelta( RenderVertexDelta_t *pRenderDelta, float flWeight, CDmeVertexDeltaData *pDeltaState )
{
	if ( !pDeltaState )
		return;

	FieldIndex_t nFieldIndex = pDeltaState->FindFieldIndex( CDmeVertexDeltaData::FIELD_COLOR );
	if ( nFieldIndex < 0 )
		return;

	const CDmrArray<int> indices = pDeltaState->GetIndexData( nFieldIndex );
	const CDmrArray<Color> delta = pDeltaState->GetVertexData( nFieldIndex );
	int nDeltaCount = indices.Count();
	for ( int j = 0; j < nDeltaCount; ++j )
	{
		const Color &srcDeltaColor = delta[ j ];
		Vector4D &vecDelta	= pRenderDelta[ indices[ j ] ].m_vecDeltaColor;
		vecDelta[0] += flWeight * srcDeltaColor.r();
		vecDelta[1] += flWeight * srcDeltaColor.g();
		vecDelta[2] += flWeight * srcDeltaColor.b();
		vecDelta[3] += flWeight * srcDeltaColor.a();
	}
}

template< class T > bool CDmeMesh::AddStereoVertexDelta(
	CDmeVertexData *pBaseState,
	void *pVertexData, int nStride, CDmeVertexDataBase::StandardFields_t fieldId, int nIndex, bool bDoLag )
{
	CDmeVertexDeltaData *pDeltaState = GetDeltaState( nIndex );
	if ( !pBaseState || !pDeltaState )
		return false;

	const FieldIndex_t nBaseFieldIndex = pBaseState->FindFieldIndex( fieldId == CDmeVertexData::FIELD_WRINKLE ? CDmeVertexData::FIELD_TEXCOORD : fieldId );
	const FieldIndex_t nDeltaFieldIndex = pDeltaState->FindFieldIndex( fieldId );
	if ( nBaseFieldIndex < 0 || nDeltaFieldIndex < 0 )
		return false;

	float flLeftWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][nIndex].x;
	float flRightWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][nIndex].y;

	const CDmrArray<int> indices = pDeltaState->GetIndexData( nDeltaFieldIndex );
	const CDmrArray<T> delta = pDeltaState->GetVertexData( nDeltaFieldIndex );
	const CUtlVector<int>& balanceIndices = pBaseState->GetVertexIndexData( CDmeVertexData::FIELD_BALANCE );
	const CUtlVector<float> &balanceDelta = pBaseState->GetBalanceData();
	const int nDeltaCount = indices.Count();

	const FieldIndex_t nSpeedFieldIndex = pBaseState->FindFieldIndex( CDmeVertexData::FIELD_MORPH_SPEED );

	if ( !bDoLag || nSpeedFieldIndex < 0 )
	{
		for ( int j = 0; j < nDeltaCount; ++j )
		{
			int nDataIndex = indices.Get( j );
			const CUtlVector<int> &list = pBaseState->FindVertexIndicesFromDataIndex( nBaseFieldIndex, nDataIndex );
			Assert( list.Count() > 0 );
			// FIXME: Average everything in the list.. shouldn't be necessary though
			float flRightAmount = balanceDelta[ balanceIndices[ list[0] ] ];
			float flWeight = Lerp( flRightAmount, flLeftWeight, flRightWeight );	

			T* pDeltaData = (T*)( (char*)pVertexData + nStride * nDataIndex );
			*pDeltaData += delta.Get( j ) * flWeight;
		}

		return true;
	}

	float flLeftWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][nIndex].x;
	float flRightWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][nIndex].y;

	const CDmrArray<int> pSpeedIndices = pBaseState->GetIndexData( nSpeedFieldIndex );
	const CDmrArray<float> pSpeedDelta = pBaseState->GetVertexData( nSpeedFieldIndex );
	for ( int j = 0; j < nDeltaCount; ++j )
	{   
		int nDataIndex = indices.Get( j );
		const CUtlVector<int> &list = pBaseState->FindVertexIndicesFromDataIndex( nBaseFieldIndex, nDataIndex );
		Assert( list.Count() > 0 );
		// FIXME: Average everything in the list.. shouldn't be necessary though
		float flRightAmount = balanceDelta[ balanceIndices[ list[0] ] ];
		float flWeight = Lerp( flRightAmount, flLeftWeight, flRightWeight );	
		float flLaggedWeight = Lerp( flRightAmount, flLeftWeightLagged, flRightWeightLagged );	
		float flSpeed = pSpeedDelta.Get( pSpeedIndices.Get( list[0] ) );
		float flActualWeight = Lerp( flSpeed, flLaggedWeight, flWeight );

		T* pDeltaData = (T*)( (char*)pVertexData + nStride * nDataIndex );
		*pDeltaData += delta.Get( j ) * flActualWeight;
	}
	return true;
}


//-----------------------------------------------------------------------------
// Build a color map of one value for each position data value.  The color
// is the length of the delta normalized by the maximum delta length
// if delta state is tagged to be highlighted
//-----------------------------------------------------------------------------
Color *BuildDeltaColorMap( CUtlVector< Color > &colorMapDelta, CDmeMesh *pDmeMesh, const Color &cHighlight )
{
	CDmeVertexData *pDmeBind = pDmeMesh->GetBindBaseState();
	if ( !pDmeBind )
		return NULL;

	const FieldIndex_t nBasePosField = pDmeBind->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	if ( nBasePosField < 0 )
		return NULL;

	const CUtlVector< Vector > &basePosData = CDmrArrayConst< Vector >( pDmeBind->GetVertexData( nBasePosField ) ).Get();

	const int nBasePosCount = basePosData.Count();
	if ( nBasePosCount <= 0 )
		return NULL;

	float *pflDeltaLengths = reinterpret_cast< float * >( stackalloc( nBasePosCount * sizeof( float ) ) );
	Q_memset( pflDeltaLengths, 0, nBasePosCount * sizeof( float ) );

	float flMaxDeltaLen = 0.0f;

	const int nDeltaCount = pDmeMesh->DeltaStateCount();
	for ( int i = 0; i < nDeltaCount; ++i )
	{
		CDmeVertexDeltaData *pDmeDelta = pDmeMesh->GetDeltaState( i );
		if ( !pDmeDelta || !pDmeDelta->m_bRenderVerts )
			continue;

		const FieldIndex_t nDeltaPosField = pDmeDelta->FindFieldIndex( CDmeVertexDeltaData::FIELD_POSITION );
		if ( nDeltaPosField < 0 )
			continue;

		const CUtlVector< Vector > &posData = CDmrArrayConst< Vector >( pDmeDelta->GetVertexData( nDeltaPosField ) ).Get();
		const CUtlVector< int > &posIndices = pDmeDelta->GetVertexIndexData( CDmeVertexDeltaData::FIELD_POSITION );

		const int nDeltaPosCount = MIN( posData.Count(), posIndices.Count() );
		for ( int j = 0; j < nDeltaPosCount; ++j )
		{
			const float flDeltaLen = posData[j].Length();
			if ( flDeltaLen > flMaxDeltaLen )
			{
				flMaxDeltaLen = flDeltaLen;
			}
			pflDeltaLengths[posIndices[j]] = MAX( pflDeltaLengths[posIndices[j]], flDeltaLen );
		}
	}

	if ( flMaxDeltaLen <= 0.0f )
		return NULL;

	flMaxDeltaLen = 1.0f / flMaxDeltaLen;

	colorMapDelta.SetCount( nBasePosCount );

	color32 c32;
	c32.a = 0xff;
	const color32 cHighlight32 = cHighlight.ToColor32();
	float flLerp = 0.0f;

	for ( int i = 0; i < nBasePosCount; ++i )
	{
		flLerp = pflDeltaLengths[i] * flMaxDeltaLen;
		c32.r = Lerp< byte >( flLerp, 0xff, cHighlight32.r );
		c32.g = Lerp< byte >( flLerp, 0xff, cHighlight32.g );
		c32.b = Lerp< byte >( flLerp, 0xff, cHighlight32.b );
		colorMapDelta[i] = c32;
	}

	return colorMapDelta.Base();
}


//-----------------------------------------------------------------------------
// Draws the mesh when it uses too many bones
//-----------------------------------------------------------------------------
bool CDmeMesh::BuildDeltaMesh( int nVertices, RenderVertexDelta_t *pRenderDelta )
{
	bool bHasWrinkleDelta = false;

	memset( pRenderDelta, 0, nVertices * sizeof( RenderVertexDelta_t ) );
	int nCount = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL].Count();
	Assert( m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL].Count() == m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED].Count() );

	CDmeVertexData *pBindState = GetBindBaseState();

	const FieldIndex_t nBalanceFieldIndex = pBindState->FindFieldIndex( CDmeVertexDeltaData::FIELD_BALANCE );
	const FieldIndex_t nSpeedFieldIndex = pBindState->FindFieldIndex( CDmeVertexDeltaData::FIELD_MORPH_SPEED );
	const bool bDoLag = nSpeedFieldIndex >= 0;
	if ( nBalanceFieldIndex < 0 )
	{
		for ( int i = 0; i < nCount; ++i )
		{
			float flWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].x;
			float flLaggedWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].x;
			if ( flWeight <= 0.0f && flLaggedWeight <= 0.0f )
				continue;

			// prepare vertices
			CDmeVertexDeltaData *pDeltaState = GetDeltaState(i);
			AddVertexDelta<Vector>( pBindState, &pRenderDelta->m_vecDeltaPosition, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_POSITION, i, bDoLag );
			AddVertexDelta<Vector>( pBindState, &pRenderDelta->m_vecDeltaNormal, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_NORMAL, i, bDoLag );
			AddTexCoordDelta( pRenderDelta, flWeight, pDeltaState );
			AddColorDelta( pRenderDelta, flWeight, pDeltaState );
			bool bWrinkle = AddVertexDelta<float>( pBindState, &pRenderDelta->m_flDeltaWrinkle, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_WRINKLE, i, bDoLag );
			bHasWrinkleDelta = bHasWrinkleDelta || bWrinkle;
		}

		return bHasWrinkleDelta;
	}

	for ( int i = 0; i < nCount; ++i )
	{
		float flLeftWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].x;
		float flRightWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].y;
		float flLeftWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].x;
		float flRightWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].y;
		if ( flLeftWeight <= 0.0f && flRightWeight <= 0.0f && flLeftWeightLagged <= 0.0f && flRightWeightLagged <= 0.0f )
			continue;

		// FIXME: Need to make balanced versions of texcoord + color
		bool bWrinkle;
		CDmeVertexDeltaData *pDeltaState = GetDeltaState(i);
		AddStereoVertexDelta<Vector>( pBindState, &pRenderDelta->m_vecDeltaPosition, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_POSITION, i, bDoLag );
		AddStereoVertexDelta<Vector>( pBindState, &pRenderDelta->m_vecDeltaNormal, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_NORMAL, i, bDoLag );
		bWrinkle = AddStereoVertexDelta<float>( pBindState, &pRenderDelta->m_flDeltaWrinkle, sizeof(RenderVertexDelta_t), CDmeVertexDeltaData::FIELD_WRINKLE, i, bDoLag);
		bHasWrinkleDelta = bHasWrinkleDelta || bWrinkle;
		AddTexCoordDelta( pRenderDelta, flLeftWeight, pDeltaState );
		AddColorDelta( pRenderDelta, flLeftWeight, pDeltaState );
	}

	return bHasWrinkleDelta;
}


//-----------------------------------------------------------------------------
// Writes triangulated indices for a face set into a meshbuilder
//-----------------------------------------------------------------------------
void CDmeMesh::WriteTriangluatedIndices( const CDmeVertexData *pBaseState, CDmeFaceSet *pFaceSet, CMeshBuilder &meshBuilder )
{
	int indices[ 256 ];

	// prepare indices
	int nFirstIndex = 0;
	int nIndexCount = pFaceSet->NumIndices();
	while ( nFirstIndex < nIndexCount )
	{
		int nVertexCount = pFaceSet->GetNextPolygonVertexCount( nFirstIndex );
		if ( nVertexCount >= 3 )
		{
			int nOutCount = ( nVertexCount-2 ) * 3;
			int *pIndices = ( nOutCount > ARRAYSIZE( indices ) ) ? new int[ nOutCount ] : indices;
			ComputeTriangulatedIndices( pBaseState, pFaceSet, nFirstIndex, pIndices, nOutCount );
			for ( int ii = 0; ii < nOutCount; ++ii )
			{
				meshBuilder.FastIndex( pIndices[ii] );
			}
			if ( pIndices != indices )
			{
				delete[] pIndices;
			}
		}
		nFirstIndex += nVertexCount + 1;
	}
}


//-----------------------------------------------------------------------------
// Draws the mesh when it uses too many bones
//-----------------------------------------------------------------------------
void CDmeMesh::DrawDynamicMesh( CDmeFaceSet *pFaceSet, matrix3x4_t *pPoseToWorld, bool bHasActiveDeltaStates, CDmeDrawSettings *pDrawSettings /* = NULL */ )
{
	CDmeVertexData *pBindBase = GetCurrentBaseState();
	if ( !pBindBase )
		return;

	// NOTE: This is inherently inefficient; we re-skin the *entire* mesh,
	// even if it's not being used by the entire model. This is because we can't
	// guarantee the various materials from the various face sets use the 
	// same vertex format (even though they should), and we don't want to
	// spend the work to detemine the sub-part of the mesh used by this face set.

	// Compute vertex deltas for rendering
	const int nVertices = pBindBase->VertexCount();

	// NOTE: The Delta Data is actually indexed by the pPositionIndices, pNormalIndices, etc.
	// The fact that we're storing one delta per final vertex nVertices
	// is a waste of memory and simply implementational convenience.

	CUtlVector< RenderVertexDelta_t > vertexDelta( 0, nVertices );
	CUtlVector< Color > deltaColorMap;
	Color *pDeltaColorMap = NULL;
	if ( pDrawSettings && pDrawSettings->GetDeltaHighlight() )
	{
		pDeltaColorMap = BuildDeltaColorMap( deltaColorMap, this, pDrawSettings->m_cHighlightColor );
	}

	bool bHasActiveWrinkle = false;
	RenderVertexDelta_t *pVertexDelta = vertexDelta.Base();
	if ( bHasActiveDeltaStates )
	{
		bHasActiveWrinkle = BuildDeltaMesh( nVertices, pVertexDelta );
	}
	else
	{
		pVertexDelta = NULL;
	}

	CDmeMeshRenderInfo renderInfo( pBindBase );
	Assert( renderInfo.HasPositionData() );

	// prepare vertices
	FieldIndex_t uvField = pBindBase->FindFieldIndex( CDmeVertexData::FIELD_TEXCOORD );
	FieldIndex_t colorField = pBindBase->FindFieldIndex( CDmeVertexData::FIELD_COLOR );

	bool bHasTexCoords = ( uvField >= 0 );
	bool bHasColors = ( colorField >= 0 );

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	IMesh *pMesh = pRenderContext->GetDynamicMesh( );

	const CDmrArrayConst<int> pUVIndices = bHasTexCoords ? pBindBase->GetIndexData( uvField ) : NULL;

	if ( bHasActiveWrinkle && bHasTexCoords )
	{
		// Create the wrinkle flex mesh
		IMesh *pFlexDelta = pRenderContext->GetFlexMesh();
		int nFlexVertexOffset = 0;

		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pFlexDelta, MATERIAL_HETEROGENOUS, nVertices, 0, &nFlexVertexOffset );
		for ( int j=0; j < nVertices; j++ )
		{
			// NOTE: The UV indices are also used to index into wrinkle data
			int nUVIndex = pUVIndices.Get( j );
			meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
			meshBuilder.NormalDelta3f( 0.0f, 0.0f, 0.0f );
			meshBuilder.Wrinkle1f( pVertexDelta[nUVIndex].m_flDeltaWrinkle );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVENORMAL, 0>();
		}
		meshBuilder.End( false, false );
		pMesh->SetFlexMesh( pFlexDelta, nFlexVertexOffset );
	}

	// build the mesh
	int nIndices = pFaceSet->GetTriangulatedIndexCount();
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nVertices, nIndices );

	const CDmrArrayConst<Vector2D> pUVData = bHasTexCoords ? pBindBase->GetVertexData( uvField ) : NULL;
	const CDmrArrayConst<int> pColorIndices = bHasColors ? pBindBase->GetIndexData( colorField ) : NULL;
	const CDmrArrayConst<Color> pColorData = bHasColors ? pBindBase->GetVertexData( colorField ) : NULL;
	const CUtlVector< int > &basePosIndices = pBindBase->GetVertexIndexData( CDmeVertexData::FIELD_POSITION );

	Vector vecPosition, vecNormal;
	Vector4D vecTangent;
	for ( int vi = 0; vi < nVertices; ++vi )
	{
		renderInfo.ComputeVertex( vi, pPoseToWorld, pVertexDelta, &vecPosition, &vecNormal, &vecTangent );
		meshBuilder.Position3fv( vecPosition.Base() );
		meshBuilder.Normal3fv( vecNormal.Base() );
		meshBuilder.UserData( vecTangent.Base() );

		if ( pUVData.IsValid() )
		{
			int uvi = pUVIndices.Get( vi );
			Vector2D uv = pUVData.Get( uvi );
			if ( pBindBase->IsVCoordinateFlipped() )
			{
				uv.y = 1.0f - uv.y;
			}

			if ( bHasActiveDeltaStates )
			{
				uv += pVertexDelta[uvi].m_vecDeltaUV;
			}
			meshBuilder.TexCoord2fv( 0, uv.Base() );
		}
		else
		{
			meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
		}

		if ( pDeltaColorMap )
		{
			int cColor = pDeltaColorMap[ basePosIndices[ vi ] ].GetRawColor();
			meshBuilder.Color4ubv( (unsigned char*)&cColor );
		}
		else
		{
			if ( pColorIndices.IsValid() )
			{
				int ci = pColorIndices.Get( vi );
				int color = pColorData.Get( ci ).GetRawColor();
				meshBuilder.Color4ubv( (unsigned char*)&color );
			}
			else
			{
				meshBuilder.Color4ub( 255, 255, 255, 255 );
			}
		}

		meshBuilder.AdvanceVertexF<VTX_HAVEALL, 1>();
	}

	WriteTriangluatedIndices( pBindBase, pFaceSet, meshBuilder );

	meshBuilder.End();

	pMesh->Draw();

	if ( pDrawSettings && pDrawSettings->GetNormals() )
	{
		RenderNormals( pPoseToWorld, bHasActiveDeltaStates ? pVertexDelta : NULL );
	}

//	CacheHighlightVerts( pPoseToWorld, bHasActiveDeltaStates ? pVertexDelta : NULL, pDrawSettings );
}


//-----------------------------------------------------------------------------
// Renders normals 
//-----------------------------------------------------------------------------
#define NORMAL_LINE_SIZE 0.25f

void CDmeMesh::RenderNormals( matrix3x4_t *pPoseToWorld, RenderVertexDelta_t *pDelta )
{
	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return;

	CDmeMeshRenderInfo renderInfo( pBind );

	Assert( renderInfo.HasPositionData() );
	if ( !renderInfo.HasNormalData() )
		return;
	bool bHasTangents = renderInfo.HasTangentData();

	// build the mesh
	InitializeNormalMaterial();
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->Bind( s_NormalMaterial );
	IMesh *pMesh = pRenderContext->GetDynamicMesh( );

	int nMaxIndices, nMaxVertices;
	pRenderContext->GetMaxToRender( pMesh, false, &nMaxVertices, &nMaxIndices );
	int nFirstVertex = 0;
	int nVerticesRemaining = pBind->VertexCount();;
	int nFactor = bHasTangents ? 6 : 2;

	while ( nVerticesRemaining > 0 )
	{
		int nVertices = nVerticesRemaining;
		if ( nVertices > nMaxVertices / nFactor )
		{
			nVertices = nMaxVertices / nFactor;
		}
		if ( nVertices > nMaxIndices / nFactor )
		{
			nVertices = nMaxIndices / nFactor;
		}
		nVerticesRemaining -= nVertices;

		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_LINES, bHasTangents ? nVertices * 3 : nVertices );

		Vector vecPosition, vecNormal, vecEndPoint, vecTangentS, vecTangentT;
		Vector4D vecTangent;
		for ( int vi = nFirstVertex; vi < nVertices; ++vi )
		{
			renderInfo.ComputeVertex( vi, pPoseToWorld, pDelta, &vecPosition, &vecNormal, &vecTangent );

			meshBuilder.Position3fv( vecPosition.Base() );
			meshBuilder.Color4ub( 0, 0, 255, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			VectorMA( vecPosition, NORMAL_LINE_SIZE, vecNormal, vecEndPoint );
			meshBuilder.Position3fv( vecEndPoint.Base() );
			meshBuilder.Color4ub( 0, 0, 255, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			continue;

			if ( !bHasTangents )
				continue;

			CrossProduct( vecNormal, vecTangent.AsVector3D(), vecTangentT );
			VectorNormalize( vecTangentT );
			// NOTE: This is the new, desired tangentS morphing behavior
			//		CrossProduct( vecTangentT, vecNormal, vecTangentS );
			VectorCopy( vecTangent.AsVector3D(), vecTangentS );
			vecTangentT *= vecTangent.w;

			meshBuilder.Position3fv( vecPosition.Base() );
			meshBuilder.Color4ub( 255, 0, 0, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			VectorMA( vecPosition, NORMAL_LINE_SIZE, vecTangentS, vecEndPoint );
			meshBuilder.Position3fv( vecEndPoint.Base() );
			meshBuilder.Color4ub( 255, 0, 0, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			meshBuilder.Position3fv( vecPosition.Base() );
			meshBuilder.Color4ub( 0, 255, 0, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			VectorMA( vecPosition, NORMAL_LINE_SIZE, vecTangentT, vecEndPoint );
			meshBuilder.Position3fv( vecEndPoint.Base() );
			meshBuilder.Color4ub( 0, 255, 0, 255 );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();
		}

		meshBuilder.End();
		pMesh->Draw();

		nFirstVertex += nVertices;
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::CacheHighlightVerts( matrix3x4_t *pPoseToWorld, RenderVertexDelta_t *pDelta, CDmeDrawSettings *pDmeDrawSettings )
{
	if ( !pDmeDrawSettings )
		return;

	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return;

	const CUtlVector< Vector > &posData = pBind->GetPositionData();
	const int nPosCount = posData.Count();
	bool *pbHighlight = reinterpret_cast< bool * >( stackalloc( nPosCount * sizeof( bool ) ) );
	Q_memset( pbHighlight, 0, nPosCount * sizeof( bool ) );

	for ( int i = 0; i < m_DeltaStates.Count(); ++i )
	{
		CDmeVertexDeltaData *pDmeDelta = m_DeltaStates[i];
		if ( !pDmeDelta || !pDmeDelta->m_bRenderVerts )
			continue;

		const CUtlVector< int > &deltaIndices = pDmeDelta->GetVertexIndexData( CDmeVertexDeltaData::FIELD_POSITION );
		for ( int j = 0; j < deltaIndices.Count(); ++j )
		{
			pbHighlight[deltaIndices[j]] = true;
		}
	}

	CDmeMeshRenderInfo renderInfo( pBind );
	Assert( renderInfo.HasPositionData() );

	CUtlVector< Vector > &highlightPoints = pDmeDrawSettings->GetHighlightPoints();
	Vector vPosition;

	for ( int i = 0; i < nPosCount; ++i )
	{
		if ( !pbHighlight[i] )
			continue;

		renderInfo.ComputePosition( i, pPoseToWorld, pDelta, &vPosition );
		highlightPoints.AddToTail( vPosition );
	}
}


//-----------------------------------------------------------------------------
// Draws the passed DmeFaceSet in wireframe mode
//-----------------------------------------------------------------------------
void CDmeMesh::DrawWireframeFaceSet(
	CDmeFaceSet *pDmeFaceSet,
	matrix3x4_t *pPoseToWorld,
	bool bHasActiveDeltaStates,
	CDmeDrawSettings *pDmeDrawSettings )
{ 
	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return;

	const FieldIndex_t posField = pBind->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	if ( posField < 0 )
		return;

	const CUtlVector< Vector > &posData( CDmrArrayConst< Vector >( pBind->GetVertexData( posField ) ).Get() );
	const int nPosCount = posData.Count();

	const CUtlVector< int > &posIndices( CDmrArrayConst< int >( pBind->GetIndexData( posField ) ).Get() );

	Vector *pDeltaVertices = bHasActiveDeltaStates ? pDeltaVertices = reinterpret_cast< Vector * >( alloca( nPosCount * sizeof( Vector ) ) ) : NULL;

	if ( bHasActiveDeltaStates )
	{
		memset( pDeltaVertices, 0, sizeof( Vector ) * nPosCount );
		const int nCount = m_DeltaStateWeights[ MESH_DELTA_WEIGHT_NORMAL ].Count();

		const FieldIndex_t nBalanceFieldIndex = pBind->FindFieldIndex( CDmeVertexDeltaData::FIELD_BALANCE );
		const FieldIndex_t nSpeedFieldIndex = pBind->FindFieldIndex( CDmeVertexDeltaData::FIELD_MORPH_SPEED );
		const bool bDoLag = ( nSpeedFieldIndex >= 0 );

		if ( nBalanceFieldIndex < 0 )
		{
			for ( int i = 0; i < nCount; ++i )
			{
				float flWeight = m_DeltaStateWeights[ MESH_DELTA_WEIGHT_NORMAL ][ i ].x;
				float flLaggedWeight = m_DeltaStateWeights[ MESH_DELTA_WEIGHT_LAGGED ][ i ].x;
				if ( flWeight <= 0.0f && ( !bDoLag || flLaggedWeight <= 0.0f ) )
					continue;

				AddVertexDelta< Vector >( pBind, pDeltaVertices, sizeof( Vector ), CDmeVertexDeltaData::FIELD_POSITION, i, bDoLag );
			}
		}
		else
		{
			for ( int i = 0; i < nCount; ++i )
			{
				float flLeftWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].x;
				float flRightWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].y;
				float flLeftWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].x;
				float flRightWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].y;
				if ( flLeftWeight <= 0.0f && flRightWeight <= 0.0f && ( !bDoLag || ( flLeftWeightLagged <= 0.0f && flRightWeightLagged <= 0.0f ) ) )
					continue;

				AddStereoVertexDelta< Vector >( pBind, pDeltaVertices, sizeof( Vector ), CDmeVertexDeltaData::FIELD_POSITION, i, bDoLag );
			}
		}
	}

	Vector *pVertices = reinterpret_cast< Vector * >( alloca( nPosCount * sizeof( Vector ) ) );
	bool *pbHighlight = reinterpret_cast< bool * >( stackalloc( nPosCount * sizeof( bool ) ) );
	Q_memset( pbHighlight, 0, nPosCount * sizeof( bool ) );

	for ( int i = 0; i < m_DeltaStates.Count(); ++i )
	{
		CDmeVertexDeltaData *pDmeDelta = m_DeltaStates[i];
		if ( !pDmeDelta || !pDmeDelta->m_bRenderVerts )
			continue;

		const CUtlVector< int > &deltaIndices = pDmeDelta->GetVertexIndexData( CDmeVertexDeltaData::FIELD_POSITION );
		for ( int j = 0; j < deltaIndices.Count(); ++j )
		{
			pbHighlight[deltaIndices[j]] = true;
		}
	}

	CDmeMeshRenderInfo renderInfo( pBind );
	Assert( renderInfo.HasPositionData() );

	if ( false && pDmeDrawSettings )
	{
		CUtlVector< Vector > &highlightPoints = pDmeDrawSettings->GetHighlightPoints();
		for ( int pi = 0; pi < nPosCount; ++pi )
		{
			renderInfo.ComputePosition( pi, pPoseToWorld, pDeltaVertices, pVertices );

			if ( !pbHighlight[pi] )
				continue;

			highlightPoints.AddToTail( pVertices[pi] );
		}
	}
	else
	{
		for ( int pi = 0; pi < nPosCount; ++pi )
		{
			renderInfo.ComputePosition( pi, pPoseToWorld, pDeltaVertices, pVertices );
		}
	}

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );

	if ( !pDmeDrawSettings || !pDmeDrawSettings->IsAMaterialBound() )
	{
		InitializeWireframeMaterial();
		pRenderContext->Bind( s_WireframeMaterial );
	}

	IMesh *pMesh = pRenderContext->GetDynamicMesh();

	// build the mesh
	CMeshBuilder meshBuilder;

	// Draw the polygons in the face set
	const int nFaceSetIndices = pDmeFaceSet->NumIndices();
	const int *pFaceSetIndices = pDmeFaceSet->GetIndices();

	int vR = 0;
	int vG = 0;
	int vB = 0;

	if ( pDmeDrawSettings )
	{
		const Color &vColor = pDmeDrawSettings->GetColor();
		vR = vColor.r();
		vG = vColor.g();
		vB = vColor.b();
	}

	int nFaceIndices;
	for ( int i = 0; i < nFaceSetIndices; )
	{
		nFaceIndices = pDmeFaceSet->GetNextPolygonVertexCount( i );
		meshBuilder.Begin( pMesh, MATERIAL_LINES, nFaceIndices );

		for ( int j = 0; j < nFaceIndices; ++j )
		{
			Assert( i < nFaceSetIndices );

			int vIndex0 = posIndices[ pFaceSetIndices[ i + j ] ];
			Assert( vIndex0 < nPosCount );
			meshBuilder.Position3fv( reinterpret_cast< float * >( pVertices + vIndex0 ) );
			meshBuilder.Color3ub( vR, vG, vB );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

			int vIndex1 = posIndices[ pFaceSetIndices[ i + ( ( j + 1 ) % nFaceIndices ) ] ];
			Assert( vIndex1 < nPosCount );
			meshBuilder.Position3fv( reinterpret_cast< float * >( pVertices + vIndex1) );
			meshBuilder.Color3ub( vR, vG, vB );
			meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();
		}

		meshBuilder.End();

		i += nFaceIndices + 1;
	}

	pMesh->Draw();
}


//-----------------------------------------------------------------------------
// Do we have active delta state data?
//-----------------------------------------------------------------------------
bool CDmeMesh::HasActiveDeltaStates() const
{
	for ( int t = 0; t < MESH_DELTA_WEIGHT_TYPE_COUNT; ++t )
	{
		int nCount = m_DeltaStateWeights[t].Count();
		for ( int i = 0; i < nCount; ++i )
		{
			if ( m_DeltaStateWeights[t][i].x != 0.0f || m_DeltaStateWeights[t][i].y != 0.0f )
				return true;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Draws the mesh
//-----------------------------------------------------------------------------
void CDmeMesh::Draw( const matrix3x4_t &shapeToWorld, CDmeDrawSettings *pDrawSettings /* = NULL */ )
{
	CDmeVertexData *pBind = GetBindBaseState();

	if ( !pBind || !g_pMaterialSystem || !g_pMDLCache || !g_pStudioRender )
		return;

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );

	const bool bHasActiveDeltaStates = HasActiveDeltaStates();
	const bool bDrawNormals = pDrawSettings ? pDrawSettings->GetNormals() : false;
	const CDmeDrawSettings::DrawType_t drawType = pDrawSettings ? pDrawSettings->GetDrawType() : CDmeDrawSettings::DRAW_SMOOTH;

	const bool bShaded = ( drawType == CDmeDrawSettings::DRAW_SMOOTH || drawType == CDmeDrawSettings::DRAW_FLAT );
	const bool bWireframe = ( drawType == CDmeDrawSettings::DRAW_WIREFRAME );
//	const bool bBoundingBox = ( drawType == CDmeDrawSettings::DRAW_BOUNDINGBOX );

	const bool bDeltaHighlight = pDrawSettings ? pDrawSettings->GetDeltaHighlight() : false;
	const bool bSoftwareSkinning = bHasActiveDeltaStates | bDrawNormals | bWireframe | bDeltaHighlight;

	matrix3x4_t *pPoseToWorld = CDmeModel::SetupModelRenderState( shapeToWorld, pBind->HasSkinningData(), bSoftwareSkinning );

	pRenderContext->SetNumBoneWeights( pPoseToWorld ? 0 : pBind->JointCount() );

	int nFaceSets = FaceSetCount();
	m_hwFaceSets.EnsureCount( nFaceSets );

	const bool bindMaterial = pDrawSettings ? !pDrawSettings->IsAMaterialBound() : true;

	for ( int fi = 0; fi < nFaceSets; ++fi )
	{
		CDmeFaceSet *pFaceSet = GetFaceSet( fi );

		if ( bWireframe )
		{
			DrawWireframeFaceSet( pFaceSet, pPoseToWorld, bHasActiveDeltaStates, pDrawSettings );
			continue;
		}

		if ( bindMaterial )
		{
			pRenderContext->Bind( pFaceSet->GetMaterial()->GetCachedMTL() );
		}

		if ( pPoseToWorld || ( bShaded && bSoftwareSkinning ) )
		{
			DrawDynamicMesh( pFaceSet, pPoseToWorld, bHasActiveDeltaStates, pDrawSettings );
			continue;
		}

		// TODO: figure out how to tell the mesh when the faceset's indices change
		if ( !m_hwFaceSets[fi].m_bBuilt )
		{
			m_hwFaceSets[fi].m_pMesh = CreateHwMesh( pFaceSet );
			m_hwFaceSets[fi].m_bBuilt = true;
		}

		if ( m_hwFaceSets[fi].m_pMesh )
		{
			m_hwFaceSets[fi].m_pMesh->Draw();
		}
	}

	pRenderContext->SetNumBoneWeights( 0 );
	CDmeModel::CleanupModelRenderState();
}


//-----------------------------------------------------------------------------
// Face sets
//-----------------------------------------------------------------------------
int CDmeMesh::FaceSetCount() const
{
	return m_FaceSets.Count();
}

CDmeFaceSet *CDmeMesh::GetFaceSet( int faceSetIndex )
{
	return m_FaceSets[ faceSetIndex ];
}

const CDmeFaceSet *CDmeMesh::GetFaceSet( int faceSetIndex ) const
{
	return m_FaceSets[ faceSetIndex ];
}

void CDmeMesh::AddFaceSet( CDmeFaceSet *faceSet )
{
	m_FaceSets.AddToTail( faceSet );
}

void CDmeMesh::RemoveFaceSet( int faceSetIndex )
{
	m_FaceSets.Remove( faceSetIndex );
}


//-----------------------------------------------------------------------------
// Find a base state by name
//-----------------------------------------------------------------------------
CDmeVertexData *CDmeMesh::FindBaseState( const char *pStateName ) const
{
	const int nBaseStateCount = BaseStateCount();
	for ( int i = 0; i < nBaseStateCount; ++i )
	{
		CDmeVertexData *pBaseState = GetBaseState( i );
		if ( !Q_stricmp( pStateName, pBaseState->GetName() ) )
			return pBaseState;
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Find a base state by name, add a new one if not found
//-----------------------------------------------------------------------------
CDmeVertexData *CDmeMesh::FindOrCreateBaseState( const char *pStateName )
{
	CDmeVertexData *pBaseState = FindBaseState( pStateName );
	if ( pBaseState )
		return pBaseState;

	pBaseState = CreateElement< CDmeVertexData >( pStateName, GetFileId() );
	m_BaseStates.AddToTail( pBaseState );

	return pBaseState;
}


//-----------------------------------------------------------------------------
// Remove a base state by name
//-----------------------------------------------------------------------------
bool CDmeMesh::DeleteBaseState( const char *pStateName )
{
	const int nBaseStateCount = BaseStateCount();
	for ( int i = 0; i < nBaseStateCount; ++i )
	{
		const CDmeVertexData *pBaseState = GetBaseState( i );
		if ( !Q_stricmp( pStateName, pBaseState->GetName() ) )
		{
			m_BaseStates.Remove( i );
			g_pDataModel->DestroyElement( pBaseState->GetHandle() );

			// TODO: Fix up all dependent states
			return true;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Selects a particular base state to be current state
//-----------------------------------------------------------------------------
void CDmeMesh::SetCurrentBaseState( const char *pStateName )
{
	m_CurrentBaseState = FindBaseState( pStateName );
}


//-----------------------------------------------------------------------------
// Selects a particular base state to be current state
//-----------------------------------------------------------------------------
CDmeVertexData *CDmeMesh::GetCurrentBaseState()
{
	return m_CurrentBaseState;
}


//-----------------------------------------------------------------------------
// Selects a particular base state to be current state
//-----------------------------------------------------------------------------
const CDmeVertexData *CDmeMesh::GetCurrentBaseState() const
{
	return m_CurrentBaseState;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeMesh::SetBindBaseState( CDmeVertexData *pBaseState )
{
	if ( !pBaseState )
		return false;

	CDmeVertexData *pCheckState = FindBaseState( pBaseState->GetName() );
	if ( pCheckState != pBaseState )
		return false;

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmeVertexData *CDmeMesh::GetBindBaseState()
{
	if ( m_BindBaseState.GetElement() )
		return m_BindBaseState;

	// Backwards compatibility
	return FindBaseState( "bind" );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const CDmeVertexData *CDmeMesh::GetBindBaseState() const
{
	if ( m_BindBaseState.GetElement() )
		return m_BindBaseState;

	// Backwards compatibility
	return FindBaseState( "bind" );
}


//-----------------------------------------------------------------------------
// Delta states
//-----------------------------------------------------------------------------
int CDmeMesh::DeltaStateCount() const
{
	return m_DeltaStates.Count();
}


//-----------------------------------------------------------------------------
// Returns the delta 
//-----------------------------------------------------------------------------
CDmeVertexDeltaData *CDmeMesh::GetDeltaState( int nDeltaIndex ) const
{
	if ( nDeltaIndex < 0 || nDeltaIndex >= m_DeltaStates.Count() )
		return NULL;

	return m_DeltaStates[ nDeltaIndex ];
}


//-----------------------------------------------------------------------------
// Finds a delta state by name.  If it isn't found, return NULL
//-----------------------------------------------------------------------------
CDmeVertexDeltaData *CDmeMesh::FindDeltaState( const char *pDeltaName, bool bSortDeltaName /* = true */ ) const
{
	return GetDeltaState( FindDeltaStateIndex( pDeltaName, bSortDeltaName ) );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int SortDeltaNameFunc( const void *a, const void *b )
{
	return Q_strcmp( *( const char ** )( a ), *( const char ** )( b ) );
}


//-----------------------------------------------------------------------------
// If the name doe
//-----------------------------------------------------------------------------
static const char *SortDeltaName( CUtlString &sDeltaName, const char *pszInDeltaName )
{
	if ( !pszInDeltaName || !strchr( pszInDeltaName, '_' ) )
		return pszInDeltaName;

	CUtlVector< char *, CUtlMemory< char *, int > > nameComponents;
	V_SplitString( pszInDeltaName, "\\", nameComponents );

	if ( nameComponents.Count() > 0 )
	{
		CUtlVector< char * > deltaNames;
		for ( int i = 0; i < nameComponents.Count(); ++i )
		{
			deltaNames.AddToTail( nameComponents[ i ] );
		}

		qsort( deltaNames.Base(), deltaNames.Count(), sizeof( char * ), SortDeltaNameFunc );

		sDeltaName.Clear();

		for ( int i = 0; i < deltaNames.Count(); ++i )
		{
			if ( V_strlen( deltaNames[i] ) <= 0 )
				continue;

			if ( sDeltaName.Length() > 0 )
			{
				sDeltaName += "_";
			}

			sDeltaName += deltaNames[i];
		}
	}

	nameComponents.PurgeAndDeleteElements();

	return sDeltaName.Get();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmeVertexDeltaData *CDmeMesh::FindOrCreateDeltaState( const char *pInDeltaName, bool bSortDeltaName /* = true */ )
{
	CDmeVertexDeltaData *pDeltaState = FindDeltaState( pInDeltaName, bSortDeltaName );
	if ( pDeltaState )
		return pDeltaState;

	CUtlString sDeltaName( pInDeltaName );
	if ( bSortDeltaName )
	{
		SortDeltaName( sDeltaName, pInDeltaName );
	}

	pDeltaState = CreateElement< CDmeVertexDeltaData >( sDeltaName.Get(), GetFileId() );
	if ( pDeltaState )
	{
		m_DeltaStates.AddToTail( pDeltaState );
	}

	return pDeltaState;
}


//-----------------------------------------------------------------------------
// Finds a delta state index by comparing names, if it can't be found
// searches for all permutations of the delta name
//-----------------------------------------------------------------------------
int CDmeMesh::FindDeltaStateIndex( const char *pInDeltaName, bool bSortDeltaName /* = true */ ) const
{
	CUtlString sDeltaName( pInDeltaName );

	const int nDeltaStateCount = DeltaStateCount();
	for ( int i = 0; i < nDeltaStateCount; ++i )
	{
		CDmeVertexDeltaData *pDeltaState = GetDeltaState( i );
		if ( !V_stricmp( sDeltaName.Get(), pDeltaState->GetName() ) )
			return i;
	}

	if ( bSortDeltaName && strchr( sDeltaName.Get(), '_' ) )
	{
		SortDeltaName( sDeltaName, pInDeltaName );
	}

	for ( int i = 0; i < nDeltaStateCount; ++i )
	{
		CDmeVertexDeltaData *pDeltaState = GetDeltaState( i );
		if ( !V_stricmp( sDeltaName.Get(), pDeltaState->GetName() ) )
			return i;
	}

	return -1;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::SetDeltaStateWeight( int nDeltaIndex, MeshDeltaWeightType_t type, float flMorphWeight )
{
	if ( nDeltaIndex < m_DeltaStateWeights[type].Count() )
	{
		m_DeltaStateWeights[type].Set( nDeltaIndex, Vector2D( flMorphWeight, flMorphWeight ) );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::SetDeltaStateWeight( int nDeltaIndex, MeshDeltaWeightType_t type, float flLeftWeight, float flRightWeight )
{
	if ( nDeltaIndex < m_DeltaStateWeights[type].Count() )
	{
		m_DeltaStateWeights[type].Set( nDeltaIndex, Vector2D( flLeftWeight, flRightWeight ) );
	}
}

//-----------------------------------------------------------------------------
// Determines the appropriate vertex format for hardware meshes
//-----------------------------------------------------------------------------
VertexFormat_t CDmeMesh::ComputeHwMeshVertexFormat( void )
{
	VertexFormat_t vertexFormat = VERTEX_POSITION | VERTEX_COLOR | VERTEX_NORMAL | VERTEX_TEXCOORD_SIZE(0,2) | VERTEX_BONEWEIGHT(2) | VERTEX_BONE_INDEX
									| VERTEX_USERDATA_SIZE(4);

	// FIXME: set VERTEX_FORMAT_COMPRESSED if there are no artifacts and if it saves enough memory (use 'mem_dumpvballocs')
	// vertexFormat |= VERTEX_FORMAT_COMPRESSED;
	// FIXME: check for and strip unused vertex elements (see 'bHasNormals', etc, in CreateHwMesh below)

	return vertexFormat;
}

//-----------------------------------------------------------------------------
// Builds a hardware mesh
//-----------------------------------------------------------------------------
IMesh *CDmeMesh::CreateHwMesh( CDmeFaceSet *pFaceSet )
{
	const CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return NULL;

	// NOTE: This is memory inefficient. We create a copy of all vertices
	// for each face set, even if those vertices aren't used by the face set
	// Mostly chose to do this for code simplicity, although it also is faster to generate meshes
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	VertexFormat_t vertexFormat = ComputeHwMeshVertexFormat( );
	IMesh *pMesh = pRenderContext->CreateStaticMesh( vertexFormat, "dmemesh" );

	CMeshBuilder meshBuilder;

	// prepare vertices
	FieldIndex_t posField = pBind->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	FieldIndex_t normalField = pBind->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	FieldIndex_t tangentField = pBind->FindFieldIndex( CDmeVertexData::FIELD_TANGENT );
	FieldIndex_t uvField = pBind->FindFieldIndex( CDmeVertexData::FIELD_TEXCOORD );
	FieldIndex_t colorField = pBind->FindFieldIndex( CDmeVertexData::FIELD_COLOR );

	Assert( posField >= 0 );
	bool bHasNormals = ( normalField >= 0 );
	bool bHasTangent = ( tangentField >= 0 );
	bool bHasTexCoords = ( uvField >= 0 );
	bool bHasColors = ( colorField >= 0 );

	// build the mesh
	int nIndices = pFaceSet->GetTriangulatedIndexCount();
	int nVertices = pBind->VertexCount();
	int nJointCount = pBind->JointCount();
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nVertices, nIndices );

	const CDmrArrayConst<int> pPositionIndices = pBind->GetIndexData( posField );
	const CDmrArrayConst<Vector> pPositionData = pBind->GetVertexData( posField );
	const CDmrArrayConst<int> pNormalIndices = bHasNormals ? pBind->GetIndexData( normalField ) : NULL;
	const CDmrArrayConst<Vector> pNormalData = bHasNormals ? pBind->GetVertexData( normalField ) : NULL;
	const CDmrArrayConst<int> pTangentIndices = bHasTangent ? pBind->GetIndexData( tangentField ) : NULL;
	const CDmrArrayConst<Vector4D> pTangentData = bHasTangent ? pBind->GetVertexData( tangentField ) : NULL;
	const CDmrArrayConst<int> pUVIndices = bHasTexCoords ? pBind->GetIndexData( uvField ) : NULL;
	const CDmrArrayConst<Vector2D> pUVData = bHasTexCoords ? pBind->GetVertexData( uvField ) : NULL;
	const CDmrArrayConst<int> pColorIndices = bHasColors ? pBind->GetIndexData( colorField ) : NULL;
	const CDmrArrayConst<Color> pColorData = bHasColors ? pBind->GetVertexData( colorField ) : NULL;

	Vector4D defaultTangentS( 1.0f, 0.0f, 0.0f, 1.0f );
	for ( int vi = 0; vi < nVertices; ++vi )
	{
		meshBuilder.Position3fv( pPositionData.Get( pPositionIndices.Get( vi ) ).Base() );
		if ( pNormalData.IsValid() )
		{
			meshBuilder.Normal3fv( pNormalData.Get( pNormalIndices.Get( vi ) ).Base() );
		}
		else
		{
			meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
		}
		if ( pTangentData.IsValid() )
		{
			meshBuilder.UserData( pTangentData.Get( pTangentIndices.Get( vi ) ).Base() );
		}
		else
		{
			meshBuilder.UserData( defaultTangentS.Base() );
		}
		if ( pUVData.IsValid() )
		{
			const Vector2D &uv = pUVData.Get( pUVIndices.Get( vi ) );
			if ( !pBind->IsVCoordinateFlipped() )
			{
				meshBuilder.TexCoord2fv( 0, uv.Base() );
			}
			else
			{
				meshBuilder.TexCoord2f( 0, uv.x, 1.0f - uv.y );
			}
		}
		else
		{
			meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
		}
		if ( pColorIndices.IsValid() )
		{
			int color = pColorData.Get( pColorIndices.Get( vi ) ).GetRawColor();
			meshBuilder.Color4ubv( (unsigned char*)&color );
		}
		else
		{
			meshBuilder.Color4ub( 255, 255, 255, 255 );
		}

		// FIXME: Note that this will break once we exceeed the max joint count
		// that the hardware can handle
		const float *pJointWeight = pBind->GetJointWeights( vi );
		const int *pJointIndices = pBind->GetJointIndices( vi );
		for ( int i = 0; i < nJointCount; ++i )
		{
			meshBuilder.BoneWeight( i, pJointWeight[i] );
			meshBuilder.BoneMatrix( i, pJointIndices[i] );
		}

		for ( int i = nJointCount; i < 4; ++i )
		{
			meshBuilder.BoneWeight( i, ( i == 0 ) ? 1.0f : 0.0f );
			meshBuilder.BoneMatrix( i, 0 );
		}

		meshBuilder.AdvanceVertexF<VTX_HAVEALL, 1>();
	}

	WriteTriangluatedIndices( pBind, pFaceSet, meshBuilder );

	meshBuilder.End();

	return pMesh;
}


//-----------------------------------------------------------------------------
// Compute triangulated indices
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeTriangulatedIndices( const CDmeVertexData *pBaseState, const CDmeFaceSet *pFaceSet, int nFirstIndex, int *pIndices, int nOutCount ) const
{
	// FIXME: Come up with a more efficient way of computing this
	// This involves a bunch of recomputation of distances
	float flMinDistance = FLT_MAX;
	int nMinIndex = 0;
	int nVertexCount = pFaceSet->GetNextPolygonVertexCount( nFirstIndex );

	// Optimization for quads + triangles.. it's totally symmetric
	int nLoopCount = nVertexCount;
	if ( nVertexCount <= 3 )
	{
		nLoopCount = 0;
	}
	else if ( nVertexCount == 4 )
	{
		nLoopCount = 2;
	}

	for ( int i = 0; i < nLoopCount; ++i )
	{
		float flDistance = 0.0f;
		const Vector &vecCenter = pBaseState->GetPosition( pFaceSet->GetIndex( nFirstIndex+i ) );
		for ( int j = 2; j < nVertexCount-1; ++j )
		{
			int vi = ( i + j ) % nVertexCount;
			const Vector &vecEdge = pBaseState->GetPosition( pFaceSet->GetIndex( nFirstIndex+vi ) );
			flDistance += vecEdge.DistTo( vecCenter );
		}

		if ( flDistance < flMinDistance )
		{
			nMinIndex = i;
			flMinDistance = flDistance;
		}
	}
	 
	// Compute the triangulation indices
	Assert( nOutCount == ( nVertexCount - 2 ) * 3 );
	int nOutIndex = 0;
	for ( int i = 1; i < nVertexCount - 1; ++i )
	{
		pIndices[nOutIndex++] = pFaceSet->GetIndex( nFirstIndex + nMinIndex );
		pIndices[nOutIndex++] = pFaceSet->GetIndex( nFirstIndex + ((nMinIndex + i) % nVertexCount) );
		pIndices[nOutIndex++] = pFaceSet->GetIndex( nFirstIndex + ((nMinIndex + i + 1) % nVertexCount) );
	}
}


//-----------------------------------------------------------------------------
// Build a map from vertex index to a list of triangles that share the vert.
//-----------------------------------------------------------------------------
void CDmeMesh::BuildTriangleMap( const CDmeVertexData *pBaseState, CDmeFaceSet* pFaceSet, CUtlVector<Triangle_t>& triangles, CUtlVector< CUtlVector<int> >* pVertToTriMap )
{
	int indices[ 256 ];

	// prepare indices
	int nFirstIndex = 0;
	int nIndexCount = pFaceSet->NumIndices();
	while ( nFirstIndex < nIndexCount )
	{
		int nVertexCount = pFaceSet->GetNextPolygonVertexCount( nFirstIndex );
		if ( nVertexCount >= 3 )
		{
			int nOutCount = ( nVertexCount-2 ) * 3;
			int *pIndices = ( nOutCount > ARRAYSIZE( indices ) ) ? new int[ nOutCount ] : indices;
			ComputeTriangulatedIndices( pBaseState, pFaceSet, nFirstIndex, pIndices, nOutCount );
			for ( int ii = 0; ii < nOutCount; ii += 3 )
			{
				int t = triangles.AddToTail();
				Triangle_t& triangle = triangles[t];

				triangle.m_nIndex[0] = pIndices[ii];
				triangle.m_nIndex[1] = pIndices[ii+1];
				triangle.m_nIndex[2] = pIndices[ii+2];

				if ( pVertToTriMap )
				{
					(*pVertToTriMap)[ pIndices[ii] ].AddToTail( t );
					(*pVertToTriMap)[ pIndices[ii+1] ].AddToTail( t );
					(*pVertToTriMap)[ pIndices[ii+2] ].AddToTail( t );
				}
			}
			if ( pIndices != indices )
			{
				delete[] pIndices;
			}
		}
		nFirstIndex += nVertexCount + 1;
	}
}


//-----------------------------------------------------------------------------
// Computes tangent space data for triangles
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeTriangleTangets( const CDmeVertexData *pVertexData, CUtlVector<Triangle_t>& triangles )
{
	// Calculate the tangent space for each triangle.
	int nTriangleCount = triangles.Count();
	for ( int triID = 0; triID < nTriangleCount; triID++ )
	{
		Triangle_t &triangle = triangles[triID];

		const Vector &p0 = pVertexData->GetPosition( triangle.m_nIndex[0] );
		const Vector &p1 = pVertexData->GetPosition( triangle.m_nIndex[1] );
		const Vector &p2 = pVertexData->GetPosition( triangle.m_nIndex[2] );
		const Vector2D &t0 = pVertexData->GetTexCoord( triangle.m_nIndex[0] );
		const Vector2D &t1 = pVertexData->GetTexCoord( triangle.m_nIndex[1] );
		const Vector2D &t2 = pVertexData->GetTexCoord( triangle.m_nIndex[2] );
		CalcTriangleTangentSpace( p0, p1, p2, t0, t1, t2, triangle.m_vecTangentS, triangle.m_vecTangentT );
	}	
}


//-----------------------------------------------------------------------------
// Build a map from vertex index to a list of triangles that share the vert.
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeAverageTangent( CDmeVertexData *pVertexData, bool bSmoothTangents, CUtlVector< CUtlVector<int> >& vertToTriMap, CUtlVector<Triangle_t>& triangles )
{
	FieldIndex_t posField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	FieldIndex_t normalField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	FieldIndex_t tangentField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_TANGENT );

	const CDmrArray<int> pPositionIndices = pVertexData->GetIndexData( posField );
	const CDmrArray<Vector> pPositionData = pVertexData->GetVertexData( posField );
	const CDmrArray<int> pNormalIndices = pVertexData->GetIndexData( normalField );
	const CDmrArray<Vector> pNormalData = pVertexData->GetVertexData( normalField );

	// calculate an average tangent space for each vertex.
	int nVertexCount = pVertexData->VertexCount();
	Vector4D finalSVect;
	for( int vertID = 0; vertID < nVertexCount; vertID++ )
	{
		CUtlVector<int> &triangleList = vertToTriMap[vertID];

		Vector sVect, tVect;
		sVect.Init( 0.0f, 0.0f, 0.0f );
		tVect.Init( 0.0f, 0.0f, 0.0f );
		int nTriangleCount = triangleList.Count();
		for ( int triID = 0; triID < nTriangleCount; triID++ )
		{
			Triangle_t &tri = triangles[ triangleList[triID] ];
			sVect += tri.m_vecTangentS;
			tVect += tri.m_vecTangentT;
		}

		// In the case of zbrush, everything needs to be treated as smooth.
		if ( bSmoothTangents )
		{
			const Vector &vertPos1 = pPositionData.Get( pPositionIndices.Get( vertID ) );
			for( int vertID2 = 0; vertID2 < nVertexCount; vertID2++ )
			{
				if ( vertID2 == vertID )
					continue;

				const Vector &vertPos2 = pPositionData.Get( pPositionIndices.Get( vertID2 ) );
				if ( vertPos1 != vertPos2 )
					continue;

				CUtlVector<int> &triangleList2 = vertToTriMap[vertID2];
				int nTriangleCount2 = triangleList2.Count();
				for ( int triID2 = 0; triID2 < nTriangleCount2; triID2++ )
				{
					Triangle_t &tri2 = triangles[ triangleList2[triID2] ];
					sVect += tri2.m_vecTangentS;
					tVect += tri2.m_vecTangentT;
				}
			}
		}

		// make an orthonormal system.
		// need to check if we are left or right handed.
		Vector tmpVect;
		CrossProduct( sVect, tVect, tmpVect );
		const Vector &normal = pNormalData.Get( pNormalIndices.Get( vertID ) );
		bool bLeftHanded = DotProduct( tmpVect, normal ) < 0.0f;
		if ( !bLeftHanded )
		{
			CrossProduct( normal, sVect, tVect );
			CrossProduct( tVect, normal, sVect );
			VectorNormalize( sVect );
			VectorNormalize( tVect );
			finalSVect[0] = sVect[0];
			finalSVect[1] = sVect[1];
			finalSVect[2] = sVect[2];
			finalSVect[3] = 1.0f;
		}
		else
		{
			CrossProduct( sVect, normal, tVect );
			CrossProduct( normal, tVect, sVect );
			VectorNormalize( sVect );
			VectorNormalize( tVect );
			finalSVect[0] = sVect[0];
			finalSVect[1] = sVect[1];
			finalSVect[2] = sVect[2];
			finalSVect[3] = -1.0f;
		}

		pVertexData->SetVertexData( tangentField, vertID, 1, AT_VECTOR4, &finalSVect );
		pVertexData->SetVertexIndices( tangentField, vertID, 1, &vertID );
	}
}


//-----------------------------------------------------------------------------
// Builds a map from vertex index to all triangles that use it
//-----------------------------------------------------------------------------
void CDmeMesh::BuildVertToTriMap( const CDmeVertexData *pVertexData, CUtlVector<Triangle_t> &triangles, CUtlVector< CUtlVector<int> > &vertToTriMap )
{
	vertToTriMap.AddMultipleToTail( pVertexData->VertexCount() );

	int nCount = FaceSetCount();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeFaceSet *pFaceSet = GetFaceSet( i );
		BuildTriangleMap( pVertexData, pFaceSet, triangles, &vertToTriMap );
	}
}


//-----------------------------------------------------------------------------
// Compute a default per-vertex tangent given normal data + uv data
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeDefaultTangentData( CDmeVertexData *pVertexData, bool bSmoothTangents )
{
	if ( !pVertexData )
		return;

	// Need to have valid pos, uv, and normal to perform this operation
	FieldIndex_t posField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	FieldIndex_t normalField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	FieldIndex_t uvField = pVertexData->FindFieldIndex( CDmeVertexData::FIELD_TEXCOORD );
	if ( posField < 0 || uvField < 0 || normalField < 0 )
		return;

	// FIXME: Need to do a pass to make sure no vertex is referenced by 
	// multiple facesets that have different materials in them.
	// In that case, we need to add extra copies of that vertex and modify
	// the face set data to refer to the new vertices

	// Build a map from vertex to a list of triangles that share the vert.
	CUtlVector<Triangle_t> triangles( 0, 1024 );
	CUtlVector< CUtlVector<int> > vertToTriMap;
	vertToTriMap.AddMultipleToTail( pVertexData->VertexCount() );

	int nCount = FaceSetCount();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeFaceSet *pFaceSet = GetFaceSet( i );
		BuildTriangleMap( pVertexData, pFaceSet, triangles, &vertToTriMap );
	}

	ComputeTriangleTangets( pVertexData, triangles );

	// FIXME: We could do a pass to determine the unique combinations of 
	// position + tangent indices in the vertex data. We only need to have
	// a unique tangent for each of these unique vertices. For simplicity
	// (and speed), I'll assume all tangents are unique per vertex.
	FieldIndex_t tangent = pVertexData->CreateField<Vector4D>( "tangents" );
	pVertexData->RemoveAllVertexData( tangent );
	pVertexData->AddVertexData( tangent, pVertexData->VertexCount() );

	ComputeAverageTangent( pVertexData, bSmoothTangents, vertToTriMap, triangles );
}


//-----------------------------------------------------------------------------
// Compute a default per-vertex tangent given normal data + uv data for all vertex data referenced by this mesh
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeDefaultTangentData( bool bSmoothTangents )
{
	const int nBaseStateCount = m_BaseStates.Count();
	for ( int i = 0; i < nBaseStateCount; ++i )
	{
		if ( m_BaseStates[i] && m_BaseStates[i]->NeedsTangentData() )
		{
			ComputeDefaultTangentData( m_BaseStates[i], bSmoothTangents );
		}
	}
}


//-----------------------------------------------------------------------------
// Utility method to compute default tangent data on all meshes in the sub-dag hierarchy
//-----------------------------------------------------------------------------
void ComputeDefaultTangentData( CDmeDag *pDag, bool bSmoothTangents )
{
	if ( !pDag )
		return;

	CDmeMesh *pMesh = CastElement< CDmeMesh >( pDag->GetShape() );
	if ( pMesh )
	{
		pMesh->ComputeDefaultTangentData( bSmoothTangents );
	}

	int nChildCount = pDag->GetChildCount();
	for ( int i = 0; i < nChildCount; ++i )
	{
		ComputeDefaultTangentData( pDag->GetChild( i ), bSmoothTangents );
	}
}


//-----------------------------------------------------------------------------
// Compute the dimensionality of the delta state (how many inputs affect it)
//-----------------------------------------------------------------------------
int CDmeMesh::ComputeDeltaStateDimensionality( int nDeltaIndex )
{
	CDmeVertexDeltaData *pDeltaState = GetDeltaState( nDeltaIndex );
	const char *pDeltaStateName = pDeltaState->GetName();

	const char *pUnderBar = pDeltaStateName;
	int nDimensions = 0;
	while ( pUnderBar )
	{
		++nDimensions;
		pUnderBar = strchr( pUnderBar, '_' );
		if ( pUnderBar )
		{
			++pUnderBar;
		}
	}

	return nDimensions;
}


//-----------------------------------------------------------------------------
// Computes the aggregate position for all vertices after applying a set of delta states
//-----------------------------------------------------------------------------
void CDmeMesh::AddDelta( CDmeVertexData *pBaseState, Vector *pDeltaPosition, int nDeltaStateIndex, CDmeVertexData::StandardFields_t fieldId )
{
	CDmeVertexDeltaData *pDeltaState = GetDeltaState( nDeltaStateIndex );
	FieldIndex_t nFieldIndex = pDeltaState->FindFieldIndex( fieldId );
	if ( nFieldIndex < 0 )
		return;

	if ( pBaseState->FindFieldIndex( CDmeVertexData::FIELD_BALANCE ) != -1 )
	{
		AddStereoVertexDelta<Vector>( pBaseState, pDeltaPosition, sizeof(Vector), fieldId, nDeltaStateIndex, true );
	}
	else
	{
		AddVertexDelta<Vector>( pBaseState, pDeltaPosition, sizeof(Vector), fieldId, nDeltaStateIndex, true );
	}
}


//-----------------------------------------------------------------------------
// Computes correctly averaged vertex normals from position data
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeNormalsFromPositions(
	CDmeVertexData *pBase,
	const Vector *pPosition,
	const CUtlVector<Triangle_t> &triangles,
	int nNormalCount,
	Vector *pNormals )
{
	Assert( nNormalCount == pBase->GetNormalData().Count() );
	int *pNormalsAdded = (int*)_alloca( nNormalCount * sizeof(int) );
	memset( pNormalsAdded, 0, nNormalCount * sizeof(int) );
	memset( pNormals, 0, nNormalCount * sizeof(Vector) );

	const CUtlVector<int> &positionIndices = pBase->GetVertexIndexData( CDmeVertexData::FIELD_POSITION );
	const CUtlVector<int> &normalIndices = pBase->GetVertexIndexData( CDmeVertexData::FIELD_NORMAL );

	int nTriangleCount = triangles.Count();
	for ( int i = 0; i < nTriangleCount; ++i )
	{
		const Triangle_t &tri = triangles[i];
		int p1 = positionIndices[ tri.m_nIndex[0] ];
		int p2 = positionIndices[ tri.m_nIndex[1] ];
		int p3 = positionIndices[ tri.m_nIndex[2] ];

		int n1 = normalIndices[ tri.m_nIndex[0] ];
		int n2 = normalIndices[ tri.m_nIndex[1] ];
		int n3 = normalIndices[ tri.m_nIndex[2] ];

		Vector vecDelta, vecDelta2, vecNormal;
		VectorSubtract( pPosition[p2], pPosition[p1], vecDelta );
		VectorSubtract( pPosition[p3], pPosition[p1], vecDelta2 );
		CrossProduct( vecDelta, vecDelta2, vecNormal );
		VectorNormalize( vecNormal );

		pNormals[n1] += vecNormal;
		pNormals[n2] += vecNormal;
		pNormals[n3] += vecNormal;

		++pNormalsAdded[n1]; ++pNormalsAdded[n2]; ++pNormalsAdded[n3];
	}

	for ( int i = 0; i < nNormalCount; ++i )
	{
		if ( pNormalsAdded[i] > 0 )
		{
			pNormals[i] /= pNormalsAdded[i];
			VectorNormalize( pNormals[i] );
		}
		else
		{
			pNormals[i].Init( 0, 1, 0 );
		}
	}
}


//-----------------------------------------------------------------------------
// Converts pose-space normals into deltas appropriate for correction delta states
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeCorrectedNormalsFromActualNormals( const CUtlVector<int> &deltaStateList, int nNormalCount, Vector *pNormals )
{
	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return;

	Assert( nNormalCount == pBind->GetNormalData().Count() );

	// Subtract out all other normal contributions
	Vector *pUncorrectedNormals = (Vector*)_alloca( nNormalCount * sizeof(Vector) );
	memcpy( pUncorrectedNormals, pBind->GetNormalData().Base(), nNormalCount * sizeof( Vector ) );
	int nDeltaStateCount = deltaStateList.Count();
	for ( int i = 0; i < nDeltaStateCount; ++i )
	{
		AddDelta( pBind, pUncorrectedNormals, deltaStateList[i], CDmeVertexData::FIELD_NORMAL );
	}

	for ( int i = 0; i < nNormalCount; ++i )
	{
		pNormals[i] -= pUncorrectedNormals[i];
	}
}


//-----------------------------------------------------------------------------
// Copies the corrected normal data into a delta state
//-----------------------------------------------------------------------------
void CDmeMesh::SetDeltaNormalData( int nDeltaIndex, int nNormalCount, Vector *pNormals )
{
	// pNormals represents the correct normal delta state for this combination
	// Copy it into the delta state for this combination. 
	// Use tolerance to deal with precision errors introduced by the various computations
	CDmeVertexDeltaData *pDeltaState = GetDeltaState( nDeltaIndex );
	FieldIndex_t nNormalField = pDeltaState->FindFieldIndex( CDmeVertexDeltaData::FIELD_NORMAL );
	if ( nNormalField >= 0 )
	{
		pDeltaState->RemoveAllVertexData( nNormalField );
	}
	else
	{
		nNormalField = pDeltaState->CreateField( CDmeVertexDeltaData::FIELD_NORMAL );
	}

	for ( int i = 0; i < nNormalCount; ++i )
	{
		if ( pNormals[i].LengthSqr() < 1e-4 )
			continue;

		int nNormalIndex = pDeltaState->AddVertexData( nNormalField, 1 );
		pDeltaState->SetVertexData( nNormalField, nNormalIndex, 1, AT_VECTOR3, &pNormals[i] );
		pDeltaState->SetVertexIndices( nNormalField, nNormalIndex, 1, &i );
	}
}


//-----------------------------------------------------------------------------
// Discovers the atomic controls used by the various delta states 
//-----------------------------------------------------------------------------
static int DeltaStateUsageLessFunc( const int * lhs, const int * rhs )
{
	return *lhs - *rhs;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::BuildAtomicControlLists( int nCount, DeltaComputation_t *pInfo, CUtlVector< CUtlVector< int > > &deltaStateUsage )
{
	CUtlVector< CUtlString > atomicControls;
	deltaStateUsage.SetCount( nCount );

	// Build a list of atomic controls
	int nCurrentDelta;
	for ( nCurrentDelta = 0; nCurrentDelta < nCount; ++nCurrentDelta ) 
	{
		if ( pInfo[nCurrentDelta].m_nDimensionality != 1 )
			break;
		int j = atomicControls.AddToTail( GetDeltaState( pInfo[nCurrentDelta].m_nDeltaIndex )->GetName() );
		deltaStateUsage[ nCurrentDelta ].AddToTail( j );
	}

	char tempBuf[ 256 ];

	for ( ; nCurrentDelta < nCount; ++nCurrentDelta )
	{
		CDmeVertexDeltaData *pDeltaState = GetDeltaState( pInfo[nCurrentDelta].m_nDeltaIndex );
		int nLen = Q_strlen( pDeltaState->GetName() ) + 1;
		char *pTempBuf = ( nLen > ARRAYSIZE( tempBuf ) ) ? new char[ nLen ] : tempBuf;
		memcpy( pTempBuf, pDeltaState->GetName(), nLen );
		char *pNext;
		for ( char *pUnderBar = pTempBuf; pUnderBar; pUnderBar = pNext )
		{
			pNext = strchr( pUnderBar, '_' );
			if ( pNext )
			{
				*pNext = 0;
				++pNext;
			}

			// Find this name in the list of strings
			int j;
			int nControlCount = atomicControls.Count();
			for ( j = 0; j < nControlCount; ++j )
			{
				if ( !Q_stricmp( pUnderBar, atomicControls[j] ) )
					break;
			}
			if ( j == nControlCount )
			{
				j = atomicControls.AddToTail( pUnderBar );
			}
			deltaStateUsage[ nCurrentDelta ].AddToTail( j );
		}
		deltaStateUsage[ nCurrentDelta ].Sort( DeltaStateUsageLessFunc );

		if ( pTempBuf != tempBuf )
		{
			delete[] pTempBuf;
		}
	}
}


//-----------------------------------------------------------------------------
// Construct list of all n-1 -> 1 dimensional delta states 
// that will be active when this delta state is active
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeDependentDeltaStateList( CUtlVector< DeltaComputation_t > &compList )
{
	if ( compList.Count() == 0 )
	{
		ComputeDeltaStateComputationList( compList );
	}

	CUtlVector< CUtlVector< int > > deltaStateUsage;
	const int nCount( compList.Count() );
	BuildAtomicControlLists( nCount, compList.Base(), deltaStateUsage );

	// Now build up a list of dependent delta states based on usage
	// NOTE: Usage is sorted in ascending order.
	for ( int i = 1; i < nCount; ++i )
	{
		int nUsageCount1 = deltaStateUsage[i].Count();
		for ( int j = 0; j < i; ++j )
		{
			// At the point they have the same dimensionality, no more need to check
			if ( compList[j].m_nDimensionality == compList[i].m_nDimensionality )
				break;

			int ii = 0;
			bool bSubsetFound = true;
			int nUsageCount2 = deltaStateUsage[j].Count();
			for ( int ji = 0; ji < nUsageCount2; ++ji )
			{
				for ( bSubsetFound = false; ii < nUsageCount1; ++ii )
				{
					if ( deltaStateUsage[j][ji] == deltaStateUsage[i][ii] )
					{
						++ii;
						bSubsetFound = true;
						break;
					}

					if ( deltaStateUsage[j][ji] < deltaStateUsage[i][ii] )
						break;
				}

				if ( !bSubsetFound )
					break;
			}

			if ( bSubsetFound )
			{
				compList[i].m_DependentDeltas.AddToTail( compList[j].m_nDeltaIndex );
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Sorts DeltaComputation_t's by dimensionality
//-----------------------------------------------------------------------------
int CDmeMesh::DeltaStateLessFunc( const void * lhs, const void * rhs )
{
	DeltaComputation_t &info1 = *(DeltaComputation_t*)lhs;
	DeltaComputation_t &info2 = *(DeltaComputation_t*)rhs;
	return info1.m_nDimensionality - info2.m_nDimensionality;
}


//-----------------------------------------------------------------------------
// Generates a sorted list in order of dimensionality of the delta states
// NOTE: This assumes a naming scheme where delta state names have _ that separate control names
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeDeltaStateComputationList( CUtlVector< DeltaComputation_t > &compList )
{
	// Do all combinations in order of dimensionality, lowest dimension first
	const int nCount = DeltaStateCount();
	compList.EnsureCount( nCount );	// Resets the CUtlVector
	for ( int i = 0; i < nCount; ++i )
	{
		compList[i].m_nDeltaIndex = i;
		compList[i].m_nDimensionality = ComputeDeltaStateDimensionality( i );
	}
	qsort( compList.Base(), nCount, sizeof(DeltaComputation_t), DeltaStateLessFunc );
}


//-----------------------------------------------------------------------------
// Computes normal deltas for all delta states based on position deltas
// NOTE: This assumes a naming scheme where delta state names have _ that separate control names
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeDeltaStateNormals()
{
	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return;

	const FieldIndex_t nBindNormalIndex = pBind->CreateField( CDmeVertexData::FIELD_NORMAL );

	const CUtlVector< Vector > &basePosData = pBind->GetPositionData();
	const int nPosCount = basePosData.Count();

	// Build a map from vertex to a list of triangles that share the vert.
	CUtlVector< Triangle_t > triangles( 0, 1024 );
	CUtlVector< CUtlVector<int> > vertToTriMap;
	vertToTriMap.AddMultipleToTail( pBind->VertexCount() );

	const int nFaceSetCount = FaceSetCount();
	for ( int i = 0; i < nFaceSetCount; ++i )
	{
		CDmeFaceSet *pFaceSet = GetFaceSet( i );
		BuildTriangleMap( pBind, pFaceSet, triangles, &vertToTriMap );
	}

	// Temporary storage for normals
	Vector *pNormals = reinterpret_cast< Vector * >( alloca( nPosCount * sizeof( Vector ) ) );

	// Make all of the normals in the bind pose smooth
	{
		const CUtlVector< int > &basePosIndices = pBind->GetVertexIndexData( CDmeVertexData::FIELD_POSITION );

		pBind->SetVertexIndices( nBindNormalIndex, 0, basePosIndices.Count(), basePosIndices.Base() );
		pBind->RemoveAllVertexData( nBindNormalIndex );
		pBind->AddVertexData( nBindNormalIndex, nPosCount );

		ComputeNormalsFromPositions( pBind, basePosData.Base(), triangles, nPosCount, pNormals );
		pBind->SetVertexData( nBindNormalIndex, 0, nPosCount, AT_VECTOR3, pNormals );

		// Fix up the current state to have smooth normals if current is not bind
		CDmeVertexData *pCurrent = GetCurrentBaseState();
		if ( pCurrent != pBind )
		{
			const FieldIndex_t nCurrentNormalIndex = pCurrent->CreateField( CDmeVertexData::FIELD_NORMAL );
			pCurrent->SetVertexIndices( nCurrentNormalIndex, 0, basePosIndices.Count(), basePosIndices.Base() );
			pCurrent->RemoveAllVertexData( nCurrentNormalIndex );
			pCurrent->AddVertexData( nCurrentNormalIndex, nPosCount );

			const CUtlVector< Vector > &currPosData = pCurrent->GetPositionData();
			ComputeNormalsFromPositions( pCurrent, currPosData.Base(), triangles, nPosCount, pNormals );
			pCurrent->SetVertexData( nCurrentNormalIndex, 0, nPosCount, AT_VECTOR3, pNormals );
		}
	}

	// Temporary storage for the positions
	Vector *pPosData = reinterpret_cast< Vector * >( alloca( nPosCount * sizeof( Vector ) ) );

	// Compute the dependent delta state list like thing
	CUtlVector< DeltaComputation_t > computationOrder;
	ComputeDependentDeltaStateList( computationOrder );

	const int nDeltaStateCount = computationOrder.Count();
	for ( int i = 0; i < nDeltaStateCount; ++i )
	{
		const DeltaComputation_t &deltaComputation = computationOrder[ i ];

		memcpy( pPosData, basePosData.Base(), nPosCount * sizeof( Vector ) );

		const CUtlVector< int > &depDeltas = deltaComputation.m_DependentDeltas;
		const int nDepStateCount = depDeltas.Count();
		for ( int j = 0; j < nDepStateCount; ++j )
		{
			AddDelta( GetDeltaState( depDeltas[ j ] ), pPosData, nPosCount, CDmeVertexData::FIELD_POSITION );
		}

		AddDelta( GetDeltaState( deltaComputation.m_nDeltaIndex ), pPosData, nPosCount, CDmeVertexData::FIELD_POSITION );

		ComputeNormalsFromPositions( pBind, pPosData, triangles, nPosCount, pNormals );

		SetDeltaNormalDataFromActualNormals( computationOrder[ i ].m_nDeltaIndex, depDeltas, nPosCount, pNormals );
	}
}


//-----------------------------------------------------------------------------
// Computes normal deltas for all delta states based on position deltas
// NOTE: This assumes a naming scheme where delta state names have _ that separate control names
//-----------------------------------------------------------------------------
void CDmeMesh::SetDeltaNormalDataFromActualNormals( int nDeltaIndex, const CUtlVector<int> &deltaStateList, int nNormalCount, Vector *pNormals )
{
	// Store off the current state values
	CUtlVector< Vector2D > deltaStateWeights[MESH_DELTA_WEIGHT_TYPE_COUNT];
	for ( int i = 0; i < MESH_DELTA_WEIGHT_TYPE_COUNT; ++i )
	{
		deltaStateWeights[i] = m_DeltaStateWeights[i].Get();

		// Turn on the current weights to all be 1 to get max effect of morphs
		int nCount = m_DeltaStateWeights[i].Count();
		for ( int j = 0; j < nCount; ++j )
		{
			m_DeltaStateWeights[i].Set( j, Vector2D( 1.0f, 1.0f ) );
		}
	}

	ComputeCorrectedNormalsFromActualNormals( deltaStateList, nNormalCount, pNormals );

	// Finally, store the corrected normals into the delta state
	SetDeltaNormalData( nDeltaIndex, nNormalCount, pNormals );

	// Restore weights to their current value
	for ( int i = 0; i < MESH_DELTA_WEIGHT_TYPE_COUNT; ++i )
	{
		m_DeltaStateWeights[i] = deltaStateWeights[i];
	}
}


//-----------------------------------------------------------------------------
// A recursive algorithm to compute nCk, i.e. the number of order independent
// Combinations without any repeats of k items taking n at a time 
// The size of the returned array is:
//
//       n!
// -------------
// k! ( n - r )!
//
// e.g. 4C4 = { 0 1 2 3 }
// e.g. 3C4 = { 0 1 2 }, { 0 1 3 }, { 0 2 3 }, { 1 2 3 }
// e.g. 2C4 = { 0 1 }, { 0 2 }, { 0 3 }, { 1 2 }, { 1 3 }, { 2 3 }
// e.g. 1C4 = { 0 }, { 1 }, { 2 }, { 3 }
//
// It's recursive and meant to be called by the user with just n, k and combos
// the other default arguments are for the recursive steps
//-----------------------------------------------------------------------------
void CDmeMesh::Combinations(
	int n,
	int k,
	CUtlVector< CUtlVector< int > > &combos,
	int *pTmpArray,
	int start,
	int currentK )
{
	if ( !pTmpArray )
	{
		pTmpArray = reinterpret_cast< int * >( alloca( k * sizeof( int ) ) );
		memset( pTmpArray, 0, k * sizeof( int ) );
	}

	if ( currentK >= k )
	{
		combos[ combos.AddToTail() ].CopyArray( pTmpArray, k );
		return;
	}

	for ( int i( start ); i < n; ++i )
	{
		pTmpArray[ currentK ] = i;

		Combinations( n, k, combos, pTmpArray, i + 1, currentK + 1 );
	}
}


//-----------------------------------------------------------------------------
// Takes an incoming Delta state, splits it's name '_' and then finds the
// control delta (a state without a '_' in its name) and adds the index
// of that control delta to the referenced array
//
// Returns true if all of the control states exist, false otherwise
//-----------------------------------------------------------------------------
bool CDmeMesh::GetControlDeltaIndices(
	CDmeVertexDeltaData *pDeltaState,
	CUtlVector< int > &controlDeltaIndices ) const
{
	Assert( pDeltaState );
	return GetControlDeltaIndices( pDeltaState->GetName(), controlDeltaIndices );
}


//-----------------------------------------------------------------------------
// Same as above but just uses the name of a delta
//-----------------------------------------------------------------------------
bool CDmeMesh::GetControlDeltaIndices(
	const char *pDeltaStateName,
	CUtlVector< int > &controlDeltaIndices ) const
{
	Assert( pDeltaStateName );
	controlDeltaIndices.RemoveAll();

	const int nDeltaStateName( Q_strlen( pDeltaStateName ) );
	char *pTmpBuf( reinterpret_cast< char * >( alloca( nDeltaStateName + 1 ) ) );
	Q_strncpy( pTmpBuf, pDeltaStateName, nDeltaStateName + 1 );
	char *pNext;
	for ( char *pCurr = pTmpBuf; pCurr; pCurr = pNext )
	{
		pNext = strchr( pCurr, '_' );
		if ( pNext )
		{
			*pNext = '\0';
			++pNext;
		}

		if ( Q_strlen( pCurr ) )
		{
			const int controlDeltaIndex( FindDeltaStateIndex( pCurr ) );
			if ( controlDeltaIndex >= 0 )
			{
				controlDeltaIndices.AddToTail( controlDeltaIndex );
			}
			else
			{
				controlDeltaIndices.RemoveAll();
				return false;
			}
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Builds a list of all of the underlying control delta indices for each
// delta state in the mesh
//
// e.g. Say the delta states are (in this order): A, B, C, A_C, A_B_C
//
// Will build: {
//               { 0 },
//               { 1 },
//               { 2 },
//               { 0, 2 },
//               { 0, 1, 2 }
//             }
// 
// Returns true if all of the control states exist, false otherwise
//-----------------------------------------------------------------------------
bool CDmeMesh::BuildCompleteDeltaStateControlList(
	CUtlVector< CUtlVector< int > > &deltaStateControlList ) const
{
	deltaStateControlList.RemoveAll();

	CUtlVector< int > tmpControlDeltaIndices;

	const int nDeltas( m_DeltaStates.Count() );
	for ( int i = 0; i < nDeltas; ++i )
	{
		if ( !GetControlDeltaIndices( m_DeltaStates[ i ], tmpControlDeltaIndices ) )
			return false;

		deltaStateControlList[ deltaStateControlList.AddToTail() ].CopyArray( tmpControlDeltaIndices.Base(), tmpControlDeltaIndices.Count() );
	}

	return true;
}


//-----------------------------------------------------------------------------
// Searches controlList for a sub array that has exactly the same indices as
// controlIndices.  The order of the indices do not have to match but all of
// them must be present and no extras can be present.
// It assumes that the controlList is in the same order as m_deltaStates
//-----------------------------------------------------------------------------
int CDmeMesh::FindDeltaIndexFromControlIndices(
	const CUtlVector< int > &controlIndices,
	const CUtlVector< CUtlVector< int > > &controlList ) const
{
	const int nControlIndices( controlIndices.Count() );
	const int nControlList( controlList.Count() );

	int nControlListIndices;
	int foundCount;

	for ( int i = 0; i < nControlList; ++i )
	{
		const CUtlVector< int > &controlListIndices( controlList[ i ] );
		nControlListIndices = controlListIndices.Count();
		if ( nControlListIndices == nControlIndices )
		{
			foundCount = 0;

			for ( int j( 0 ); j < nControlListIndices; ++j )
			{
				for ( int k( 0 ); k < nControlIndices; ++k )
				{
					if ( controlListIndices[ j ] == controlIndices[ k ] )
					{
						++foundCount;
						break;
					}
				}
			}

			if ( foundCount == nControlIndices )
				return i;
		}
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Builds a list of all of the required underlying deltas that make up this
// state whether that do not exist.  All of the control deltas must exist
// though (Deltas without '_' in their name).
//
// e.g. Say only Delta states A, B, C, D, A_B_C_D exist and A_B_C_D is
//      passed in.  This function will return:
//
//		A_B_C, A_B_D, A_C_D, B_C_D, A_B, A_C, A_D, B_C, B_D, C_D
//
// Returns true if all of the control states exist, false otherwise
//-----------------------------------------------------------------------------
bool CDmeMesh::BuildMissingDependentDeltaList(
	CDmeVertexDeltaData *pDeltaState,
	CUtlVector< int > &controlIndices,
	CUtlVector< CUtlVector< int > > &dependentStates ) const
{
	dependentStates.RemoveAll();

	CUtlVector< CUtlVector< int > > deltaStateControlList;
	BuildCompleteDeltaStateControlList( deltaStateControlList );

	if ( !GetControlDeltaIndices( pDeltaState, controlIndices ) )
		return false;

	const int nControlIndices( controlIndices.Count() );

	CUtlVector< int > comboControls;

	for ( int i( nControlIndices - 1 ); i > 0; --i )
	{
		CUtlVector< CUtlVector< int > > combos;
		Combinations( nControlIndices, i, combos );
		const int nCombos( combos.Count() );
		for ( int j( 0 ); j < nCombos; ++j )
		{
			const CUtlVector< int > &comboIndices( combos[ j ] );
			const int nComboIndices( comboIndices.Count() );
			if ( comboIndices.Count() )
			{
				comboControls.RemoveAll();
				comboControls.EnsureCapacity( nComboIndices );

				for ( int k( 0 ); k < nComboIndices; ++k )
				{
					comboControls.AddToTail( controlIndices[ comboIndices[ k ] ] );
				}

				if ( FindDeltaIndexFromControlIndices( comboControls, deltaStateControlList) < 0 )
				{
					dependentStates[ dependentStates.AddToTail() ].CopyArray( comboControls.Base(), comboControls.Count() );
				}
			}
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
int CDmeMesh::GenerateCompleteDataForDelta(
	const CDmeVertexDeltaData *pDelta,
	T_t *pFullData,
	int nFullData,
	CDmeVertexData::StandardFields_t standardField )
{
	memset( pFullData, 0, nFullData * sizeof( T_t ) );

	const FieldIndex_t fIndex( pDelta->FindFieldIndex( standardField ) );
	if ( fIndex >= 0 )
	{
		CDmrArrayConst< T_t > fDataArray( pDelta->GetVertexData( fIndex ) );
		const CUtlVector< T_t > &fData( fDataArray.Get() );
		const CUtlVector< int > &fIndexData( pDelta->GetVertexIndexData( fIndex ) );
		const int nIndexData( fIndexData.Count() );

		Assert( nIndexData <= nFullData );

		int index;

		int i( 0 );

		for ( int j( 0 ); j < nIndexData; ++j )
		{
			index = fIndexData[ j ];
			while ( index > i )
			{
				++i;
			}

			Assert( i < nFullData );
			pFullData[ i ] = fData[ j ];
		}

		return nIndexData;
	}

	return 0;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddDelta(
	const CDmeVertexDeltaData *pDelta,
	T_t *pFullData,
	int nFullData,
	FieldIndex_t fieldIndex,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	if ( fieldIndex >= 0 )
	{
		CDmrArrayConst< T_t > fDataArray( pDelta->GetVertexData( fieldIndex ) );
		const CUtlVector< T_t > &fData( fDataArray.Get() );
		const CUtlVector< int > &fIndexData( pDelta->GetVertexIndexData( fieldIndex ) );
		const int nIndexData( fIndexData.Count() );

		T_t t;

		Assert( nIndexData <= nFullData );

		int index;

		int i( 0 );

		if ( pMask )
		{
			float cWeight;

			for ( int j( 0 ); j < nIndexData; ++j )
			{
				index = fIndexData[ j ];

				if ( !pMask->GetWeight( index, cWeight ) )
					continue;

				while ( index > i )
				{
					++i;
				}

				Assert( i < nFullData );

				t = fData[ j ];
				t *= ( weight * cWeight );
				pFullData[ i ] += t;
			}
		}
		else
		{
			for ( int j( 0 ); j < nIndexData; ++j )
			{
				index = fIndexData[ j ];
				while ( index > i )
				{
					++i;
				}

				Assert( i < nFullData );
				t = fData[ j ];
				t *= weight;
				pFullData[ i ] += t;
			}
		}
	}
}

template void CDmeMesh::AddDelta< float >( const CDmeVertexDeltaData *, float *, int, FieldIndex_t, float, const CDmeSingleIndexedComponent * );
template void CDmeMesh::AddDelta< Vector2D >( const CDmeVertexDeltaData *, Vector2D *, int, FieldIndex_t, float, const CDmeSingleIndexedComponent * );
template void CDmeMesh::AddDelta< Vector >( const CDmeVertexDeltaData *, Vector *, int, FieldIndex_t, float, const CDmeSingleIndexedComponent * );


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddDelta(
	const CDmeVertexDeltaData *pDelta,
	T_t *pFullData,
	int nFullData,
	CDmeVertexData::StandardFields_t standardField,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	const FieldIndex_t fIndex( pDelta->FindFieldIndex( standardField ) );
	AddDelta( pDelta, pFullData, nFullData, fIndex, weight, pMask );
}

template void CDmeMesh::AddDelta< float >( const CDmeVertexDeltaData *, float *, int, CDmeVertexData::StandardFields_t, float, const CDmeSingleIndexedComponent * );
template void CDmeMesh::AddDelta< Vector2D >( const CDmeVertexDeltaData *, Vector2D *, int, CDmeVertexData::StandardFields_t, float, const CDmeSingleIndexedComponent * );
template void CDmeMesh::AddDelta< Vector >( const CDmeVertexDeltaData *, Vector *, int, CDmeVertexData::StandardFields_t, float, const CDmeSingleIndexedComponent * );

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::ComputeAllCorrectedPositionsFromActualPositions()
{
	const CDmeVertexData *pBase = GetBindBaseState();
	if ( !pBase )
		return;

	CUtlVector< DeltaComputation_t > deltaList;
	ComputeDependentDeltaStateList( deltaList );

	const int nDeltas( deltaList.Count() );

	const int nPositions( pBase->GetPositionData().Count() );

	Vector *pPositions( reinterpret_cast< Vector * >( alloca( nPositions * sizeof( Vector ) ) ) );
	int *pIndices( reinterpret_cast< int * >( alloca( nPositions * sizeof( int ) ) ) );

	int pCount;

	for ( int i = 0; i < nDeltas; ++i )
	{
		const DeltaComputation_t &deltaComputation( deltaList[ i ] );
		CDmeVertexDeltaData *pDelta( m_DeltaStates[ deltaComputation.m_nDeltaIndex ] );
		if ( !pDelta->GetValue< bool >( "corrected" ) )
		{
			const FieldIndex_t pIndex( pDelta->FindFieldIndex( CDmeVertexDeltaData::FIELD_POSITION ) );
			if ( pIndex < 0 )
				continue;

			GenerateCompleteDataForDelta( pDelta, pPositions, nPositions, CDmeVertexData::FIELD_POSITION );

			const CUtlVector< int > &dependentDeltas( deltaComputation.m_DependentDeltas );
			const int nDependentDeltas( dependentDeltas.Count() );
			for ( int j( 0 ); j < nDependentDeltas; ++j )
			{
				const CDmeVertexDeltaData *pDependentDelta( m_DeltaStates[ dependentDeltas[ j ] ] );
				const CUtlVector< Vector > &dPositions( pDependentDelta->GetPositionData() );
				const CUtlVector<int> &dIndices( pDependentDelta->GetVertexIndexData( CDmeVertexData::FIELD_POSITION ) );
				Assert( dPositions.Count() == dIndices.Count() );
				const int nIndices( dIndices.Count() );

				int index;

				int k( 0 );
				for ( int l( 0 ); l < nIndices; ++l )
				{
					index = dIndices[ l ];
					while ( index > k )
					{
						++k;
					}

					Assert( k < nPositions );
					pPositions[ k ] -= dPositions[ l ];
				}
			}

			pCount = 0;
			for ( int j( 0 ); j < nPositions; ++j )
			{
				const Vector &v( pPositions[ j ] );
				// Kind of a magic number but it's because of 16 bit compression of the delta values
				if ( fabs( v.x ) >= ( 1 / 4096.0f ) || fabs( v.y ) >= ( 1 / 4096.0f ) || fabs( v.z ) >= ( 1 / 4096.0f ) )
				{
					pPositions[ pCount ] = v;
					pIndices[ pCount ] = j;
					++pCount;
				}
			}

			pDelta->RemoveAllVertexData( pIndex );

			if ( pCount )
			{
				pDelta->AddVertexData( pIndex, pCount );
				pDelta->SetVertexData( pIndex, 0, pCount, AT_VECTOR3, pPositions );
				pDelta->SetVertexIndices( pIndex, 0, pCount, pIndices );
			}
			pDelta->SetValue( "corrected", true );
		}
	}
}


//-----------------------------------------------------------------------------
// There's no guarantee that fields are added in any order, nor that only
// standard fields exist...
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddCorrectedDelta(
	CDmrArray< T_t > &baseDataArray,
	const CUtlVector< int > &baseIndices,
	const DeltaComputation_t &deltaComputation,
	const char *pFieldName,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	const CUtlVector< T_t > &baseData( baseDataArray.Get() );
	const int nData( baseData.Count() );
	T_t *pData( reinterpret_cast< T_t * >( alloca( nData * sizeof( T_t ) ) ) );
	Q_memcpy( pData, baseData.Base(), nData * sizeof( T_t ) );

	CDmeVertexDeltaData *pDelta( GetDeltaState( deltaComputation.m_nDeltaIndex ) );

	const int deltaFieldIndex( pDelta->FindFieldIndex( pFieldName ) );
	if ( deltaFieldIndex < 0 )
		return;

	AddDelta( pDelta, pData, nData, deltaFieldIndex, weight, pMask );

	const CUtlVector< int > &depDeltas( deltaComputation.m_DependentDeltas );
	const int nDepDeltas( depDeltas.Count() );
	for ( int j( 0 ); j < nDepDeltas; ++j )
	{
		pDelta = GetDeltaState( depDeltas[ j ] );

		int depFieldIndex = pDelta->FindFieldIndex( pFieldName );
		if ( depFieldIndex < 0 )
			continue;

		AddDelta( pDelta, pData, nData, depFieldIndex, weight, pMask );
	}

	baseDataArray.CopyArray( pData, nData );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddCorrectedDelta(
	CUtlVector< T_t > &baseData,
	const CUtlVector< int > &baseIndices,
	const DeltaComputation_t &deltaComputation,
	const char *pFieldName,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	const int nData( baseData.Count() );

	CDmeVertexDeltaData *pDelta( GetDeltaState( deltaComputation.m_nDeltaIndex ) );

	const int deltaFieldIndex( pDelta->FindFieldIndex( pFieldName ) );
	if ( deltaFieldIndex < 0 )
		return;

	AddDelta( pDelta, baseData.Base(), nData, deltaFieldIndex, weight, pMask );

	const CUtlVector< int > &depDeltas( deltaComputation.m_DependentDeltas );
	const int nDepDeltas( depDeltas.Count() );
	for ( int j( 0 ); j < nDepDeltas; ++j )
	{
		pDelta = GetDeltaState( depDeltas[ j ] );

		int depFieldIndex = pDelta->FindFieldIndex( pFieldName );
		if ( depFieldIndex < 0 )
			continue;

		AddDelta( pDelta, baseData.Base(), nData, depFieldIndex, weight, pMask );
	}
}


//-----------------------------------------------------------------------------
// There's no guarantee that fields are added in any order, nor that only
// standard fields exist...
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddRawDelta(
	CDmeVertexDeltaData *pDelta,
	CDmrArray< T_t > &baseDataArray,
	FieldIndex_t nDeltaFieldIndex,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	if ( !pDelta || nDeltaFieldIndex < 0 )
		return;

	const CUtlVector< T_t > &baseData( baseDataArray.Get() );
	const int nData( baseData.Count() );
	T_t *pData( reinterpret_cast< T_t * >( alloca( nData * sizeof( T_t ) ) ) );
	Q_memcpy( pData, baseData.Base(), nData * sizeof( T_t ) );

	AddDelta( pDelta, pData, nData, nDeltaFieldIndex, weight, pMask );

	baseDataArray.CopyArray( pData, nData );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
void CDmeMesh::AddRawDelta(
	CDmeVertexDeltaData *pDelta,
	CUtlVector< T_t > &baseData,
	FieldIndex_t nDeltaFieldIndex,
	float weight,
	const CDmeSingleIndexedComponent *pMask )
{
	if ( !pDelta || nDeltaFieldIndex < 0 )
		return;

	const int nData( baseData.Count() );

	AddDelta( pDelta, baseData.Base(), nData, nDeltaFieldIndex, weight, pMask );
}


//-----------------------------------------------------------------------------
// Sets the specified base state to the specified delta
// If no delta is specified then the current state is copied from the bind state
// If no base state is specified then the current base state is used
// The specified base state or the current base state cannot be the bind state
//-----------------------------------------------------------------------------
bool CDmeMesh::SetBaseStateToDelta( const CDmeVertexDeltaData *pDelta, CDmeVertexData *pPassedBase /* = NULL */ )
{
	CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	const CDmeVertexData *pBind = GetBindBaseState();

	if ( !pBase || !pBind || pBase == pBind )
		return false;

	pBind->CopyTo( pBase );

	if ( !pDelta )
		return true;

	// This should be cached and recomputed only when states are added
	CUtlVector< DeltaComputation_t > compList;
	ComputeDependentDeltaStateList( compList );

	const int nDeltas( compList.Count() );
	for ( int i = 0; i < nDeltas; ++i )
	{
		if ( pDelta != GetDeltaState( compList[ i ].m_nDeltaIndex ) )
			continue;

		const int nBaseField( pBase->FieldCount() );
		const int nDeltaField( pDelta->FieldCount() );

		for ( int j( 0 ); j < nBaseField; ++j )
		{
			const CUtlString &baseFieldName( pBase->FieldName( j ) );

			for ( int k( 0 ); k < nDeltaField; ++k )
			{
				const CUtlString &deltaFieldName( pDelta->FieldName( k ) );

				if ( baseFieldName != deltaFieldName )
					continue;

				const FieldIndex_t baseFieldIndex( pBase->FindFieldIndex( baseFieldName ) );
				const FieldIndex_t deltaFieldIndex( pDelta->FindFieldIndex( deltaFieldName ) );
				if ( baseFieldIndex < 0 || deltaFieldIndex < 0 )
					break;

				CDmAttribute *pBaseData( pBase->GetVertexData( baseFieldIndex ) );
				const CDmAttribute *pDeltaData( pDelta->GetVertexData( deltaFieldIndex ) );

				if ( pBaseData->GetType() != pDeltaData->GetType() )
					break;

				const CUtlVector< int > &baseIndices( pBase->GetVertexIndexData( baseFieldIndex ) );

				switch ( pBaseData->GetType() )
				{
				case AT_FLOAT_ARRAY:
					AddCorrectedDelta( CDmrArray< float >( pBaseData ), baseIndices, compList[ i ], baseFieldName );
					break;
				case AT_COLOR_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector >( pBaseData ), baseIndices, compList[ i ], baseFieldName );
					break;
				case AT_VECTOR2_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector2D >( pBaseData ), baseIndices, compList[ i ], baseFieldName );
					break;
				case AT_VECTOR3_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector >( pBaseData ), baseIndices, compList[ i ], baseFieldName );
					break;
				default:
					break;
				}
				break;
			}
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::SelectVerticesFromDelta(
	CDmeVertexDeltaData *pDelta,
	CDmeSingleIndexedComponent *pSelection )
{
	if ( !pSelection )
		return;

	pSelection->Clear();

	if ( !pDelta )
		return;

	const FieldIndex_t pField( pDelta->FindFieldIndex( CDmeVertexData::FIELD_POSITION ) );
	if ( pField < 0 )
		return;

	const CUtlVector< int > &pIndicies( pDelta->GetVertexIndexData( CDmeVertexData::FIELD_POSITION ) );

	pSelection->AddComponents( pIndicies );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::SelectAllVertices( CDmeSingleIndexedComponent *pSelection, CDmeVertexData *pPassedBase /* = NULL */ )
{
	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();

	if ( !pBase )
	{
		pBase = GetBindBaseState();
	}

	if ( !pBase )
		return;

	if ( !pSelection )
		return;

	pSelection->Clear();

	const FieldIndex_t pField( pBase->FindFieldIndex( CDmeVertexData::FIELD_POSITION ) );
	if ( pField < 0 )
		return;

	CUtlVector< int > indices;
	indices.EnsureCount( CDmrArrayConst< Vector >( pBase->GetVertexData( pField ) ).Count() );
	const int nIndices = indices.Count();
	for ( int i = 0; i < nIndices; ++i )
	{
		indices[ i ] = i;
	}

	pSelection->AddComponents( indices );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::SelectHalfVertices( SelectHalfType_t selectHalfType, CDmeSingleIndexedComponent *pSelection, CDmeVertexData *pPassedBase /* = NULL */ )
{
	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();

	if ( !pBase )
	{
		pBase = GetBindBaseState();
	}

	if ( !pBase )
		return;

	if ( !pSelection )
		return;

	pSelection->Clear();

	const FieldIndex_t pField( pBase->FindFieldIndex( CDmeVertexData::FIELD_POSITION ) );
	if ( pField < 0 )
		return;

	const CDmrArrayConst< Vector > pos( pBase->GetVertexData( pField ) );
	const int nPosCount = pos.Count();

	CUtlVector< int > indices;
	indices.EnsureCapacity( nPosCount );

	if ( selectHalfType == kRight )
	{
		for ( int i = 0; i < nPosCount; ++i )
		{
			if ( pos[ i ].x <= 0.0f )
			{
				indices.AddToTail( i );
			}
		}
	}
	else
	{
		for ( int i = 0; i < nPosCount; ++i )
		{
			if ( pos[ i ].x >= 0.0f )
			{
				indices.AddToTail( i );
			}
		}
	}

	pSelection->AddComponents( indices );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeMesh::CreateDeltaFieldFromBaseField(
	CDmeVertexData::StandardFields_t nStandardFieldIndex,
	const CDmrArrayConst< float > &baseArray,
	const CDmrArrayConst< float > &bindArray,
	CDmeVertexDeltaData *pDelta )
{
	const int nData( baseArray.Count() );
	if ( nData != bindArray.Count() )
		return false;

	const float *pBaseData( baseArray.Get().Base() );
	const float *pBindData( bindArray.Get().Base() );

	float *pData( reinterpret_cast< float * >( nData * sizeof( float ) ) );
	Q_memcpy( pData, pBaseData, nData * sizeof( float ) );
	int *pIndices( reinterpret_cast< int * >( nData * sizeof( int ) ) );

	float v;

	int nDeltaCount( 0 );
	for ( int i = 0; i < nData; ++i )
	{
		v = pBaseData[ i ] - pBindData[ i ];

		// Kind of a magic number but it's because of 16 bit compression of the delta values
		if ( fabs( v ) >= ( 1 / 4096.0f ) )
		{
			pData[ nDeltaCount ] = v;
			pIndices[ nDeltaCount ] = i;
			++nDeltaCount;
		}
	}

	if ( nDeltaCount <= 0 )
		return true;

	FieldIndex_t fieldIndex( pDelta->CreateField( nStandardFieldIndex ) );
	if ( fieldIndex < 0 )
		return false;

	pDelta->AddVertexData( fieldIndex, nDeltaCount );
	pDelta->SetVertexData( fieldIndex, 0, nDeltaCount, AT_FLOAT, pData );
	pDelta->SetVertexIndices( fieldIndex, 0, nDeltaCount, pIndices );

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeMesh::CreateDeltaFieldFromBaseField(
	CDmeVertexData::StandardFields_t nStandardFieldIndex,
	const CDmrArrayConst< Vector2D > &baseArray,
	const CDmrArrayConst< Vector2D > &bindArray,
	CDmeVertexDeltaData *pDelta )
{
	const int nData( baseArray.Count() );
	if ( nData != bindArray.Count() )
		return false;

	const Vector2D *pBaseData( baseArray.Get().Base() );
	const Vector2D *pBindData( bindArray.Get().Base() );

	Vector2D *pData( reinterpret_cast< Vector2D * >( nData * sizeof( Vector2D ) ) );
	Q_memcpy( pData, pBaseData, nData * sizeof( Vector2D ) );
	int *pIndices( reinterpret_cast< int * >( nData * sizeof( int ) ) );

	Vector2D v;

	int nDeltaCount( 0 );
	for ( int i = 0; i < nData; ++i )
	{
		v = pBaseData[ i ] - pBindData[ i ];

		// Kind of a magic number but it's because of 16 bit compression of the delta values
		if ( fabs( v.x ) >= ( 1 / 4096.0f ) || fabs( v.y ) >= ( 1 / 4096.0f ) )
		{
			pData[ nDeltaCount ] = v;
			pIndices[ nDeltaCount ] = i;
			++nDeltaCount;
		}
	}

	if ( nDeltaCount <= 0 )
		return true;

	FieldIndex_t fieldIndex( pDelta->CreateField( nStandardFieldIndex ) );
	if ( fieldIndex < 0 )
		return false;

	pDelta->AddVertexData( fieldIndex, nDeltaCount );
	pDelta->SetVertexData( fieldIndex, 0, nDeltaCount, AT_VECTOR2, pData );
	pDelta->SetVertexIndices( fieldIndex, 0, nDeltaCount, pIndices );

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeMesh::CreateDeltaFieldFromBaseField(
	CDmeVertexData::StandardFields_t nStandardFieldIndex,
	const CDmrArrayConst< Vector > &baseArray,
	const CDmrArrayConst< Vector > &bindArray,
	CDmeVertexDeltaData *pDelta )
{
	const int nData( baseArray.Count() );
	if ( nData != bindArray.Count() )
		return false;

	const Vector *pBaseData( baseArray.Get().Base() );
	const Vector *pBindData( bindArray.Get().Base() );

	Vector *pData( reinterpret_cast< Vector * >( alloca( nData * sizeof( Vector ) ) ) );
	Q_memcpy( pData, pBaseData, nData * sizeof( Vector ) );
	int *pIndices( reinterpret_cast< int * >( alloca( nData * sizeof( int ) ) ) );

	Vector v;

	int nDeltaCount( 0 );
	for ( int i = 0; i < nData; ++i )
	{
		v = pBaseData[ i ] - pBindData[ i ];

		// Kind of a magic number but it's because of 16 bit compression of the delta values
		if ( fabs( v.x ) >= ( 1 / 4096.0f ) || fabs( v.y ) >= ( 1 / 4096.0f ) || fabs( v.z ) >= ( 1 / 4096.0f ) )
		{
			pData[ nDeltaCount ] = v;
			pIndices[ nDeltaCount ] = i;
			++nDeltaCount;
		}
	}

	if ( nDeltaCount <= 0 )
		return true;

	FieldIndex_t fieldIndex( pDelta->CreateField( nStandardFieldIndex ) );
	if ( fieldIndex < 0 )
		return false;

	pDelta->AddVertexData( fieldIndex, nDeltaCount );
	pDelta->SetVertexData( fieldIndex, 0, nDeltaCount, AT_VECTOR3, pData );
	pDelta->SetVertexIndices( fieldIndex, 0, nDeltaCount, pIndices );

	return true;
}

//-----------------------------------------------------------------------------
// Creates a delta from the difference between the bind base state and the
// specified base state.  If pBaseName is NULL the current base state is used
//-----------------------------------------------------------------------------
CDmeVertexDeltaData *CDmeMesh::ModifyOrCreateDeltaStateFromBaseState( const char *pDeltaName, CDmeVertexData *pPassedBase /* = NULL */, bool absolute /* = false */ )
{
	// Find All States Which Have This Guy 
	CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	if ( !pBase )
		return NULL;

	CDmeVertexData *pBind = GetBindBaseState();
	if ( !pBind )
		return NULL;

	// It's ok if pBase == pBind

	CUtlVector< int > superiorDeltaStates;
	ComputeSuperiorDeltaStateList( pDeltaName, superiorDeltaStates );
	const int nSuperior = superiorDeltaStates.Count();

	if ( nSuperior > 0 )
	{
		UniqueId_t id;
		char idBuf[ MAX_PATH ];

		CDmeVertexData *pTmpBaseState = NULL;
		do 
		{
			CreateUniqueId( &id );
			UniqueIdToString( id, idBuf, sizeof( idBuf ) );
			pTmpBaseState = FindBaseState( idBuf );
		} while( pTmpBaseState != NULL );

		pTmpBaseState = FindOrCreateBaseState( idBuf );
		if ( !pTmpBaseState )
			return NULL;

		for ( int i = 0; i < nSuperior; ++i )
		{
			Assert( superiorDeltaStates[ i ] < DeltaStateCount() );
			CDmeVertexDeltaData *pSuperiorDelta = GetDeltaState( superiorDeltaStates[ i ] );
			if ( pSuperiorDelta->GetValue< bool >( "corrected" ) )
			{
				// Only fiddle with states that are "corrected"
				if ( !SetBaseStateToDelta( pSuperiorDelta, pTmpBaseState ) )
					return NULL;

				if ( !ModifyOrCreateDeltaStateFromBaseState( CUtlString( pSuperiorDelta->GetName() ), pTmpBaseState, true ) )
					return NULL;
			}
		}

		DeleteBaseState( idBuf );
	}

	ResetDeltaState( pDeltaName );
	CDmeVertexDeltaData *pDelta = FindOrCreateDeltaState( pDeltaName );
	if ( !pDelta )
		return NULL;

	CDmeVertexData::StandardFields_t deltaFields[] =
	{
		CDmeVertexData::FIELD_POSITION,
		CDmeVertexData::FIELD_NORMAL,
		CDmeVertexData::FIELD_WRINKLE
	};

	for ( int i = 0; i < sizeof( deltaFields ) / sizeof( deltaFields[ 0 ] ); ++i )
	{
		CDmeVertexData::StandardFields_t standardFieldIndex( deltaFields[ i ] );
		const FieldIndex_t baseFieldIndex( pBase->FindFieldIndex( standardFieldIndex ) );
		const FieldIndex_t bindFieldIndex( pBind->FindFieldIndex( standardFieldIndex ) );

		if ( baseFieldIndex < 0 || bindFieldIndex < 0 )
			continue;

		CDmAttribute *pBaseData( pBase->GetVertexData( baseFieldIndex ) );
		CDmAttribute *pBindData( pBind->GetVertexData( bindFieldIndex ) );

		if ( pBaseData->GetType() != pBindData->GetType() )
			continue;

		switch ( pBaseData->GetType() )
		{
		case AT_FLOAT_ARRAY:
			CreateDeltaFieldFromBaseField( standardFieldIndex, CDmrArrayConst< float >( pBaseData ), CDmrArrayConst< float >( pBindData ), pDelta );
			break;
		case AT_COLOR_ARRAY:
			CreateDeltaFieldFromBaseField( standardFieldIndex, CDmrArrayConst< Vector >( pBaseData ), CDmrArrayConst< Vector >( pBindData ), pDelta );
			break;
		case AT_VECTOR2_ARRAY:
			CreateDeltaFieldFromBaseField( standardFieldIndex, CDmrArrayConst< Vector2D >( pBaseData ), CDmrArrayConst< Vector2D >( pBindData ), pDelta );
			break;
		case AT_VECTOR3_ARRAY:
			CreateDeltaFieldFromBaseField( standardFieldIndex, CDmrArrayConst< Vector >( pBaseData ), CDmrArrayConst< Vector >( pBindData ), pDelta );
			break;
		default:
			break;
		}
	}

	if ( !strchr( pDelta->GetName(), '_' ) )
	{
		const static CUtlSymbolLarge symTargets = g_pDataModel->GetSymbol( "targets" );
		CDmeCombinationOperator *pCombo( FindReferringElement< CDmeCombinationOperator >( this, symTargets ) );
		if ( pCombo )
		{
			pCombo->FindOrCreateControl( pDelta->GetName(), false, true );
		}
	}

	if ( !absolute )
	{
		ComputeAllCorrectedPositionsFromActualPositions();
	}

	return pDelta;
}


//-----------------------------------------------------------------------------
// TODO: Uncorrect all superior states and then correct them afterwards
//-----------------------------------------------------------------------------
bool CDmeMesh::DeleteDeltaState( const char *pDeltaName )
{
	const int nDeltaIndex = FindDeltaStateIndex( pDeltaName );
	if ( nDeltaIndex < 0 )
		return false;

	Assert( m_DeltaStates.Count() == m_DeltaStateWeights[ MESH_DELTA_WEIGHT_NORMAL ].Count() );
	Assert( m_DeltaStates.Count() == m_DeltaStateWeights[ MESH_DELTA_WEIGHT_LAGGED ].Count() );
	CDmeVertexDeltaData *pDelta( m_DeltaStates[ nDeltaIndex ] );
	if ( !pDelta )
		return false;

	m_DeltaStates.Remove( nDeltaIndex );
	m_DeltaStateWeights[ MESH_DELTA_WEIGHT_NORMAL ].Remove( nDeltaIndex );
	m_DeltaStateWeights[ MESH_DELTA_WEIGHT_LAGGED ].Remove( nDeltaIndex );
	g_pDataModel->DestroyElement( pDelta->GetHandle() );

	const static CUtlSymbolLarge symTargets = g_pDataModel->GetSymbol( "targets" );
	CDmeCombinationOperator *pCombo( FindReferringElement< CDmeCombinationOperator >( this, symTargets ) );
	if ( pCombo )
	{
		pCombo->Purge();
	}

	return true;
}


//-----------------------------------------------------------------------------
// TODO: Uncorrect all superior states and then correct them afterwards
//-----------------------------------------------------------------------------
bool CDmeMesh::ResetDeltaState( const char *pDeltaName )
{
	const int nDeltaIndex = FindDeltaStateIndex( pDeltaName );
	if ( nDeltaIndex < 0 )
		return false;

	CDmeVertexDeltaData *pOldDelta = m_DeltaStates[ nDeltaIndex ];
	CDmeVertexDeltaData *pNewDelta = CreateElement< CDmeVertexDeltaData >( pOldDelta->GetName(), GetFileId() );
	if ( !pNewDelta )
		return false;

	m_DeltaStates.Set( nDeltaIndex, pNewDelta );
	g_pDataModel->DestroyElement( pOldDelta->GetHandle() );

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------

class CSelectionHelper
{
public:
	class CVert
	{
	public:
		int m_index;
		int m_count;
		float m_weight;
	};

	void AddVert( int vIndex, float weight = 1.0f );

	int AddToSelection( CDmeSingleIndexedComponent *pSelection ) const;

	int RemoveFromSelection( CDmeSingleIndexedComponent *pSelection, bool bAllowEmpty ) const;

protected:
	CUtlVector< CVert > m_verts;

	int BinarySearch( int component ) const;
};


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CSelectionHelper::AddVert( int vIndex, float weight /* = 1.0f */ )
{
	// Find the vertex, add it if necessary
	const int index = BinarySearch( vIndex );

	if ( index == m_verts.Count() )
	{
		// New Add to end
		CVert &v( m_verts[ m_verts.AddToTail() ] );
		v.m_index = vIndex;
		v.m_count = 1;
		v.m_weight = weight;
	}
	else if ( vIndex == m_verts[ index ].m_index )
	{
		// Existing, increment
		CVert &v( m_verts[ index ] );
		Assert( v.m_index == vIndex );
		v.m_count += 1;
		v.m_weight += weight;
	}
	else
	{
		// New insert before index
		CVert &v( m_verts[ m_verts.InsertBefore( index ) ] );
		v.m_index = vIndex;
		v.m_count = 1;
		v.m_weight = weight;
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CSelectionHelper::AddToSelection( CDmeSingleIndexedComponent *pSelection ) const
{
	const int nVerts = m_verts.Count();

	for ( int i = 0; i < nVerts; ++i )
	{
		const CVert &v( m_verts[ i ] );
		Assert( !pSelection->HasComponent( v.m_index ) );
		pSelection->AddComponent( v.m_index, v.m_weight / static_cast< float >( v.m_count ) );
	}

	return nVerts;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CSelectionHelper::RemoveFromSelection( CDmeSingleIndexedComponent *pSelection, bool bAllowEmpty ) const
{
	const int nVerts = m_verts.Count();
	int nVertsRemovedCount = 0;

	for ( int i = 0; i < nVerts; ++i )
	{
		const CVert &v( m_verts[ i ] );
		if ( bAllowEmpty || pSelection->Count() > 1 )
		{
			pSelection->RemoveComponent( v.m_index );
			++nVertsRemovedCount;
		}
	}

	return nVertsRemovedCount;
}


//-----------------------------------------------------------------------------
// Searches for the component in the sorted component list and returns the
// index if it's found or if it's not found, returns the index at which it
// should be inserted to maintain the sorted order of the component list
//-----------------------------------------------------------------------------
int CSelectionHelper::BinarySearch( int vIndex ) const
{
	const int nVerts( m_verts.Count() );

	int left( 0 );
	int right( nVerts - 1 );
	int mid;

	while ( left <= right )
	{
		mid = ( left + right ) >> 1;	// floor( ( left + right ) / 2.0 )
		if ( vIndex > m_verts[ mid ].m_index )
		{
			left = mid + 1;
		}
		else if ( vIndex < m_verts[ mid ].m_index )
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}

	return left;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::GrowSelection( int nSize, CDmeSingleIndexedComponent *pSelection, CDmMeshComp *pPassedMeshComp )
{
	if ( nSize <= 0 || !pSelection )
		return;

	CUtlVector< int > sIndices;
	CUtlVector< float > sWeights;
	pSelection->GetComponents( sIndices, sWeights );
	const int nVertices = sIndices.Count();

	CDmMeshComp *pMeshComp = pPassedMeshComp ? pPassedMeshComp : new CDmMeshComp( this );

	CUtlVector< CDmMeshComp::CVert * > neighbours;

	CSelectionHelper sHelper;

	for ( int i = 0; i < nVertices; ++i )
	{
		const int nNeighbours = pMeshComp->FindNeighbouringVerts( sIndices[ i ], neighbours );
		for ( int j = 0; j < nNeighbours; ++j )
		{
			CDmMeshComp::CVert *pNeighbour = neighbours[ j ];
			Assert( pNeighbour );
			if ( pNeighbour )
			{
				const int vIndex = pNeighbour->PositionIndex();
				if ( !pSelection->HasComponent( vIndex ) )
				{
					sHelper.AddVert( vIndex, sWeights[ i ] );
				}
			}
		}
	}

	if ( sHelper.AddToSelection( pSelection ) > 0 )
	{
		GrowSelection( nSize - 1, pSelection, pMeshComp );
	}

	if ( pMeshComp != pPassedMeshComp )
	{
		delete pMeshComp;
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::ShrinkSelection( int nSize, CDmeSingleIndexedComponent *pSelection, CDmMeshComp *pPassedMeshComp )
{
	if ( nSize <= 0 || !pSelection )
		return;

	CUtlVector< int > sIndices;
	CUtlVector< float > sWeights;
	pSelection->GetComponents( sIndices, sWeights );
	const int nVertices = sIndices.Count();

	CDmMeshComp *pMeshComp = pPassedMeshComp ? pPassedMeshComp : new CDmMeshComp( this );

	CUtlVector< CDmMeshComp::CVert * > neighbours;

	CSelectionHelper sHelper;

	for ( int i = 0; i < nVertices; ++i )
	{
		bool hasSelectedNeighbour = false;
		bool hasUnselectedNeighbour = false;

		const int vIndex = sIndices[ i ];
		const int nNeighbours = pMeshComp->FindNeighbouringVerts( vIndex, neighbours );
		for ( int j = 0; j < nNeighbours; ++j )
		{
			const int nvIndex = neighbours[ j ]->PositionIndex();
			if ( pSelection->HasComponent( nvIndex ) )
			{
				hasSelectedNeighbour = true;
				if ( hasUnselectedNeighbour )
				{
					sHelper.AddVert( vIndex );
					break;
				}
			}
			else
			{
				hasUnselectedNeighbour = true;
				if ( hasSelectedNeighbour )
				{
					sHelper.AddVert( vIndex );
					break;
				}
			}
		}
	}

	if ( sHelper.RemoveFromSelection( pSelection, false ) > 0 )
	{
		ShrinkSelection( nSize - 1, pSelection, pMeshComp );
	}

	if ( pMeshComp != pPassedMeshComp )
	{
		delete pMeshComp;
	}
}


CDmeSingleIndexedComponent *CDmeMesh::FeatherSelection(
	float falloffDistance,
	Falloff_t falloffType,
	Distance_t distanceType,
	CDmeSingleIndexedComponent *pSelection,
	CDmMeshComp *pPassedMeshComp )
{
	switch ( falloffType )
	{
	case SMOOTH:
		return FeatherSelection< SMOOTH >( falloffDistance, distanceType, pSelection, pPassedMeshComp );
	case SPIKE:
		return FeatherSelection< SPIKE >( falloffDistance, distanceType, pSelection, pPassedMeshComp );
	case DOME:
		return FeatherSelection< DOME >( falloffDistance, distanceType, pSelection, pPassedMeshComp );
	default:
		return FeatherSelection< LINEAR >( falloffDistance, distanceType, pSelection, pPassedMeshComp );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < int T >
CDmeSingleIndexedComponent *CDmeMesh::FeatherSelection(
	float fDistance, Distance_t distanceType,
	CDmeSingleIndexedComponent *pSelection, CDmMeshComp *pPassedMeshComp )
{
	// TODO: Support feathering inward instead of just outward
	if ( fDistance <= 0.0f || !pSelection )
		return NULL;

	// Make a new CDmeSingleIndexedComponent to do all of the dirty work
	CDmeSingleIndexedComponent *pNewSelection = CreateElement< CDmeSingleIndexedComponent >( "feather", pSelection->GetFileId() );
	pSelection->CopyAttributesTo( pNewSelection );

	CDmMeshComp *pMeshComp = pPassedMeshComp ? pPassedMeshComp : new CDmMeshComp( this );
	CDmeVertexData *pBase = pMeshComp->BaseState();

	if ( distanceType == DIST_RELATIVE )
	{
		Vector vCenter;
		float flRadius;
		GetBoundingSphere( vCenter, flRadius, pBase, pSelection );
		fDistance *= flRadius;
	}

	const CUtlVector< Vector > &positions( pBase->GetPositionData() );
	const int nPositions = positions.Count();

	if ( !pBase )
		return NULL;

	CUtlVector< int > sIndices;

	int insideCount = 0;

	CFalloff< T > falloff;
	
	do
	{
		insideCount = 0;
		CUtlVector< CDmMeshComp::CVert * > neighbours;
		CSelectionHelper sHelper;

		pNewSelection->GetComponents( sIndices );
		int nVertices = sIndices.Count();

		for ( int i = 0; i < nVertices; ++i )
		{
			const int nNeighbours = pMeshComp->FindNeighbouringVerts( sIndices[ i ], neighbours );

			for ( int j = 0; j < nNeighbours; ++j )
			{
				const int vIndex = neighbours[ j ]->PositionIndex();

				if ( pNewSelection->HasComponent( vIndex ) )
					continue;

				const int closestVert = ClosestSelectedVertex( vIndex, pSelection, pBase );
				if ( closestVert < 0 || closestVert >= nPositions )
					continue;

				const float vDistance = positions[ vIndex ].DistTo( positions[ closestVert ] );
				if ( vDistance <= fDistance )
				{
					sHelper.AddVert( vIndex, falloff( vDistance / fDistance ) );
					++insideCount;
				}
			}
		}

		sHelper.AddToSelection( pNewSelection );

	} while ( insideCount > 0 );

	return pNewSelection;
}


//-----------------------------------------------------------------------------
// Add the specified delta, scaled by the weight value to the DmeVertexData
// base state specified.  Optionally the add can be masked by a specified
// weight map.
//
// If a DmeVertexData is not explicitly specified, the current state of the
// mesh is modified unless it's the bind state.  The bind state will never
// be modified even if it is explicitly specified.
//
// Only the delta specified is added.  No dependent states are added.
//-----------------------------------------------------------------------------
bool CDmeMesh::AddMaskedDelta(
	CDmeVertexDeltaData *pDelta,
	CDmeVertexData *pDst /* = NULL */,
	float weight /* = 1.0f */,
	const CDmeSingleIndexedComponent *pMask /* = NULL */ )
{
	CDmeVertexData *pBase = pDst ? pDst : GetCurrentBaseState();

	if ( !pBase || pBase == GetBindBaseState() )
		return false;

	bool retVal = true;

	const int nBaseField( pBase->FieldCount() );
	const int nDeltaField( pDelta->FieldCount() );

	// Try to add every field of the base state
	for ( int j( 0 ); j < nBaseField; ++j )
	{
		const CUtlString &baseFieldName( pBase->FieldName( j ) );

		// Find the corresponding field in the delta
		for ( int k( 0 ); k < nDeltaField; ++k )
		{
			const CUtlString &deltaFieldName( pDelta->FieldName( k ) );

			if ( baseFieldName != deltaFieldName )
				continue;

			const FieldIndex_t baseFieldIndex( pBase->FindFieldIndex( baseFieldName ) );
			const FieldIndex_t deltaFieldIndex( pDelta->FindFieldIndex( deltaFieldName ) );
			if ( baseFieldIndex < 0 || deltaFieldIndex < 0 )
				break;

			CDmAttribute *pBaseData( pBase->GetVertexData( baseFieldIndex ) );
			CDmAttribute *pDeltaData( pDelta->GetVertexData( deltaFieldIndex ) );

			if ( pBaseData->GetType() != pDeltaData->GetType() )
				break;

			switch ( pBaseData->GetType() )
			{
			case AT_FLOAT_ARRAY:
				AddRawDelta( pDelta, CDmrArray< float >( pBaseData ), baseFieldIndex, weight, pMask );
				break;
			case AT_COLOR_ARRAY:
				// TODO: Color is missing some algebraic operators
//				AddRawDelta( pDelta, CDmrArray< Color >( pBaseData ), baseFieldIndex, weight, pMask );
				break;
			case AT_VECTOR2_ARRAY:
				AddRawDelta( pDelta, CDmrArray< Vector2D >( pBaseData ), baseFieldIndex, weight, pMask );
				break;
			case AT_VECTOR3_ARRAY:
				AddRawDelta( pDelta, CDmrArray< Vector >( pBaseData ), baseFieldIndex, weight, pMask );
				break;
			default:
				break;
			}
			break;
		}
	}

	return retVal;
}


//-----------------------------------------------------------------------------
// Add the specified delta, scaled by the weight value to the DmeVertexData
// base state specified.  Optionally the add can be masked by a specified
// weight map.
//
// If a DmeVertexData is not explicitly specified, the current state of the
// mesh is modified unless it's the bind state.  The bind state will never
// be modified even if it is explicitly specified.
//
// Only the delta specified is added.  No dependent states are added.
//-----------------------------------------------------------------------------
bool CDmeMesh::AddCorrectedMaskedDelta(
	CDmeVertexDeltaData *pDelta,
	CDmeVertexData *pDst /* = NULL */,
	float weight /* = 1.0f */,
	const CDmeSingleIndexedComponent *pMask /* = NULL */ )
{
	CDmeVertexData *pBase = pDst ? pDst : GetCurrentBaseState();

	if ( !pBase || pBase == GetBindBaseState() )
		return false;

	bool retVal = true;

	const int nBaseField( pBase->FieldCount() );
	const int nDeltaField( pDelta->FieldCount() );

	// This should be cached and recomputed only when states are added
	CUtlVector< DeltaComputation_t > compList;
	ComputeDependentDeltaStateList( compList );

	const int nDeltas( compList.Count() );
	for ( int i = 0; i < nDeltas; ++i )
	{
		if ( pDelta != GetDeltaState( compList[ i ].m_nDeltaIndex ) )
			continue;

		// Try to add every field of the base state
		for ( int j( 0 ); j < nBaseField; ++j )
		{
			const CUtlString &baseFieldName( pBase->FieldName( j ) );

			// Find the corresponding field in the delta
			for ( int k( 0 ); k < nDeltaField; ++k )
			{
				const CUtlString &deltaFieldName( pDelta->FieldName( k ) );

				if ( baseFieldName != deltaFieldName )
					continue;

				const FieldIndex_t baseFieldIndex( pBase->FindFieldIndex( baseFieldName ) );
				const FieldIndex_t deltaFieldIndex( pDelta->FindFieldIndex( deltaFieldName ) );
				if ( baseFieldIndex < 0 || deltaFieldIndex < 0 )
					break;

				CDmAttribute *pBaseData( pBase->GetVertexData( baseFieldIndex ) );
				CDmAttribute *pDeltaData( pDelta->GetVertexData( deltaFieldIndex ) );

				if ( pBaseData->GetType() != pDeltaData->GetType() )
					break;

				const CUtlVector< int > &baseIndices( pBase->GetVertexIndexData( baseFieldIndex ) );

				switch ( pBaseData->GetType() )
				{
				case AT_FLOAT_ARRAY:
					AddCorrectedDelta( CDmrArray< float >( pBaseData ), baseIndices, compList[ i ], baseFieldName, weight, pMask );
					break;
				case AT_COLOR_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector >( pBaseData ), baseIndices, compList[ i ], baseFieldName, weight, pMask );
					break;
				case AT_VECTOR2_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector2D >( pBaseData ), baseIndices, compList[ i ], baseFieldName, weight, pMask );
					break;
				case AT_VECTOR3_ARRAY:
					AddCorrectedDelta( CDmrArray< Vector >( pBaseData ), baseIndices, compList[ i ], baseFieldName, weight, pMask );
					break;
				default:
					break;
				}
				break;
			}
		}
	}

	return retVal;
}


//-----------------------------------------------------------------------------
// Interpolates between two arrays of values and stores the result in a
// CDmrArray.
//
// result = ( ( 1 - weight ) * a ) + ( weight * b )
//
//-----------------------------------------------------------------------------
template< class T_t >
bool CDmeMesh::InterpMaskedData(
	CDmrArray< T_t > &aData,
	const CUtlVector< T_t > &bData,
	float weight,
	const CDmeSingleIndexedComponent *pMask ) const
{
	const int nDst = aData.Count();

	if ( bData.Count() != nDst )
		return false;

	// The wacky way of writing these expression is because Vector4D is missing operators
	// And this probably works better because of fewer temporaries

	T_t a;
	T_t b;

	if ( pMask )
	{
		// With a weight mask
		float vWeight;
		for ( int i = 0; i < nDst; ++i )
		{
			if ( pMask->GetWeight( i, vWeight ) )
			{
				vWeight *= weight;	// Specifically not clamping
				a = aData.Get( i );
				a *= ( 1.0f - vWeight );
				b = bData[ i ];
				b *= vWeight;
				b += a;
				aData.Set( i, b );
			}
		}
	}
	else
	{
		// Without a weight mask
		const float oneMinusWeight( 1.0f - weight );
		for ( int i = 0; i < nDst; ++i )
		{
			a = aData.Get( i );
			a *= oneMinusWeight;
			b = bData[ i ];
			b *= weight;
			b += a;
			aData.Set( i, b );
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Interpolates between two CDmeVertexData's
//
// paData = ( ( 1 - weight ) * a ) + ( weight * b )
//-----------------------------------------------------------------------------
bool CDmeMesh::InterpMaskedData(
	CDmeVertexData *paData,
	const CDmeVertexData *pbData,
	float weight,
	const CDmeSingleIndexedComponent *pMask ) const
{
	if ( !paData || !pbData || paData == pbData )
		return false;

	const int naField = paData->FieldCount();
	const int nbField = pbData->FieldCount();

	for ( int i = 0; i < naField; ++i )
	{
		const CUtlString &aFieldName( paData->FieldName( i ) );

		for ( int j = 0; j < nbField; ++j )
		{
			const CUtlString &bFieldName( pbData->FieldName( j ) );
			if ( aFieldName != bFieldName )
				continue;

			const FieldIndex_t aFieldIndex( paData->FindFieldIndex( aFieldName ) );
			const FieldIndex_t bFieldIndex( pbData->FindFieldIndex( bFieldName ) );

			if ( aFieldIndex < 0 || bFieldIndex < 0 )
				break;

			CDmAttribute *paAttr( paData->GetVertexData( aFieldIndex ) );
			const CDmAttribute *pbAttr( pbData->GetVertexData( bFieldIndex ) );

			if ( paAttr->GetType() != pbAttr->GetType() )
				break;

			if ( paData->GetVertexIndexData( aFieldIndex ).Count() != pbData->GetVertexIndexData( bFieldIndex ).Count() )
				break;

			switch ( paAttr->GetType() )
			{
			case AT_FLOAT_ARRAY:
				InterpMaskedData( CDmrArray< float >( paAttr ), CDmrArrayConst< float >( pbAttr ).Get(), weight, pMask );
				break;
			case AT_COLOR_ARRAY:
				InterpMaskedData( CDmrArray< Vector4D >( paAttr ), CDmrArrayConst< Vector4D >( pbAttr ).Get(), weight, pMask );
				break;
			case AT_VECTOR2_ARRAY:
				InterpMaskedData( CDmrArray< Vector2D >( paAttr ), CDmrArrayConst< Vector2D >( pbAttr ).Get(), weight, pMask );
				break;
			case AT_VECTOR3_ARRAY:
				InterpMaskedData( CDmrArray< Vector >( paAttr ), CDmrArrayConst< Vector >( pbAttr ).Get(), weight, pMask );
				break;
			default:
				break;
			}
			break;
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Interpolates between the specified VertexData and the specified Delta
// If pBase is NULL it will become the current state
// If pDelta is NULL then the state to interpolate to will be the bind state
//-----------------------------------------------------------------------------
bool CDmeMesh::InterpMaskedDelta(
	CDmeVertexDeltaData *pDelta,
	CDmeVertexData *pDst /* = NULL */,
	float weight /*= 1.0f */,
	const CDmeSingleIndexedComponent *pMask /*= NULL */ )
{
	CDmeVertexData *pDstBase = pDst ? pDst : GetCurrentBaseState();
	CDmeVertexData *pBind = GetBindBaseState();

	if ( !pDstBase || !pBind || pDstBase == pBind )
		return false;

	if ( pDelta == NULL )
	{
		// Interpolate between specified state and bind state
		return InterpMaskedData( pDstBase, pBind, weight, pMask );
	}

	// This should be cached and recomputed only when states are added
	CUtlVector< DeltaComputation_t > compList;
	ComputeDependentDeltaStateList( compList );

	bool retVal = false;

	const int nDeltas( compList.Count() );
	for ( int i = 0; i < nDeltas; ++i )
	{
		if ( pDelta != GetDeltaState( compList[ i ].m_nDeltaIndex ) )
			continue;

		retVal = true;

		const int nBaseField( pDstBase->FieldCount() );
		const int nBindField( pBind->FieldCount() );
		const int nDeltaField( pDelta->FieldCount() );

		CUtlVector< float > floatData;
		CUtlVector< Vector2D > vector2DData;
		CUtlVector< Vector > vectorData;
		CUtlVector< Vector4D > vector4DData;

		for ( int j( 0 ); j < nBaseField; ++j )
		{
			const CUtlString &baseFieldName( pDstBase->FieldName( j ) );

			for ( int k = 0; k < nBindField; ++k )
			{
				const CUtlString &bindFieldName( pBind->FieldName( k ) );
				if ( baseFieldName != bindFieldName )
					continue;

				for ( int l = 0; l < nDeltaField; ++l )
				{
					const CUtlString &deltaFieldName( pDelta->FieldName( l ) );
					if ( bindFieldName != deltaFieldName )
						continue;

					const FieldIndex_t baseFieldIndex( pDstBase->FindFieldIndex( baseFieldName ) );
					const FieldIndex_t bindFieldIndex( pBind->FindFieldIndex( bindFieldName ) );
					const FieldIndex_t deltaFieldIndex( pDelta->FindFieldIndex( deltaFieldName ) );

					if ( baseFieldIndex < 0 || bindFieldIndex < 0 || deltaFieldIndex < 0 )
						break;

					CDmAttribute *pDstBaseData( pDstBase->GetVertexData( baseFieldIndex ) );
					CDmAttribute *pBindData( pBind->GetVertexData( bindFieldIndex ) );
					CDmAttribute *pDeltaData( pDelta->GetVertexData( deltaFieldIndex ) );

					if ( pDstBaseData->GetType() != pBindData->GetType() || pBindData->GetType() != pDeltaData->GetType() )
						break;

					const CUtlVector< int > &bindIndices( pBind->GetVertexIndexData( bindFieldIndex ) );

					switch ( pDstBaseData->GetType() )
					{
					case AT_FLOAT_ARRAY:
						floatData = CDmrArrayConst< float >( pBindData ).Get();
						AddCorrectedDelta( floatData, bindIndices, compList[ i ], baseFieldName );
						InterpMaskedData( CDmrArray< float >( pDstBaseData ), floatData, weight, pMask );
						break;
					case AT_COLOR_ARRAY:
						vector4DData = CDmrArrayConst< Vector4D >( pBindData ).Get();
						AddCorrectedDelta( vector4DData, bindIndices, compList[ i ], baseFieldName );
						InterpMaskedData( CDmrArray< Vector4D >( pDstBaseData ), vector4DData, weight, pMask );
						break;
					case AT_VECTOR2_ARRAY:
						vector2DData = CDmrArrayConst< Vector2D >( pBindData ).Get();
						AddCorrectedDelta( vector2DData, bindIndices, compList[ i ], baseFieldName );
						InterpMaskedData( CDmrArray< Vector2D >( pDstBaseData ), vector2DData, weight, pMask );
						break;
					case AT_VECTOR3_ARRAY:
						vectorData = CDmrArrayConst< Vector >( pBindData ).Get();
						AddCorrectedDelta( vectorData, bindIndices, compList[ i ], baseFieldName );
						InterpMaskedData( CDmrArray< Vector >( pDstBaseData ), vectorData, weight, pMask );
						break;
					default:
						break;
					}
					break;
				}
			}
		}
	}

	return retVal;
}


//-----------------------------------------------------------------------------
// Returns the index of the closest selected vertex in the mesh to vIndex
// -1 on failure
//-----------------------------------------------------------------------------
int CDmeMesh::ClosestSelectedVertex( int vIndex, CDmeSingleIndexedComponent *pSelection, const CDmeVertexData *pPassedBase /* = NULL */ ) const
{
	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	if ( !pBase )
		return -1;

	const CUtlVector< Vector > &positions( pBase->GetPositionData() );

	if ( vIndex >= positions.Count() )
		return -1;

	const Vector &p( positions[ vIndex ] );

	CUtlVector< int > verts;
	pSelection->GetComponents( verts );
	const int nVerts = verts.Count();

	if ( nVerts <= 0 )
		return -1;

	float minSqDist = p.DistToSqr( positions[ verts[ 0 ] ] );
	float tmpSqDist;

	int retVal = verts[ 0 ];
	for ( int i = 1; i < nVerts; ++i )
	{
		tmpSqDist = p.DistToSqr( positions[ verts[ i ] ] );
		if ( tmpSqDist < minSqDist )
		{
			minSqDist = tmpSqDist;
			retVal = verts[ i ];
		}
	}

	return retVal;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
float CDmeMesh::DistanceBetween( int vIndex0, int vIndex1, const CDmeVertexData *pPassedBase /*= NULL */ ) const
{
	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	if ( !pBase )
		return 0.0f;

	const CUtlVector< Vector > &positions( pBase->GetPositionData() );
	const int nPositions = positions.Count();

	if ( vIndex0 >= nPositions || vIndex1 >= nPositions )
		return 0.0f;

	return positions[ vIndex0 ].DistTo( positions[ vIndex1 ] );
}


//-----------------------------------------------------------------------------
// Sorts DeltaComputation_t's by dimensionality
//-----------------------------------------------------------------------------
int ControlIndexLessFunc( const void *lhs, const void *rhs )
{
	const int &lVal = *reinterpret_cast< const int * >( lhs );
	const int &rVal = *reinterpret_cast< const int * >( rhs );
	return lVal - rVal;
}

//-----------------------------------------------------------------------------
// This will compute a list of delta states that are superior to the passed
// delta state name (which has the form of <NAME>[_<NAME>]..., i.e. controls
// separated by underscores.  The states will be returned in order from
// most superior to least superior.  Since the deltas need to be broken down
// by the control deltas, if any control delta doesn't exist it will return false.
// 
// A superior delta state is defined as a delta which has this delta as
// a dependent (or inferior) delta.
//
// Given the network of:
//
// A, B, C
// A_B, A_C, B_C
// A_B_C
//
// A_B_C is superior to A, B, A_B, A_C & B_C
// A_B is superior to A, B & C
// A_C is superior to A, B & C
// B_C is superior to A, B & C
//
// Input	Output
// -------  --------------------
// A		A_B_C, A_B, A_C, B_C
// B		A_B_C, A_B, A_C, B_C
// C		A_B_C, A_B, A_C, B_C
// A_B		A_B_C
// A_C		A_B_C
// B_C		A_B_C
// A_B_C
//-----------------------------------------------------------------------------
bool CDmeMesh::ComputeSuperiorDeltaStateList( const char *pInferiorDeltaName, CUtlVector< int > &superiorDeltaStates )
{
	// TODO: Compute this data only when the deltas are added, removed or renamed
	CUtlVector< DeltaComputation_t > compList;
	ComputeDeltaStateComputationList( compList );

	// Typically the passed delta won't be in the list yet, but it could be, that's ok
	// Treat it like it isn't to be sure.
	CUtlVector< int > inferiorIndices;
	if ( !GetControlDeltaIndices( pInferiorDeltaName, inferiorIndices ) )
		return false;

	const int nInferiorIndices = inferiorIndices.Count();
	qsort( inferiorIndices.Base(), nInferiorIndices, sizeof( int ), ControlIndexLessFunc );

	CUtlVector< int > superiorIndices;
	int nSuperiorIndices;
	CDmeVertexDeltaData *pSuperiorDelta;

	for ( int i = compList.Count() - 1; i >= 0; --i )
	{
		const DeltaComputation_t &deltaComp = compList[ i ];

		// For a delta to be superior, it has to have more control inputs than the specified delta
		// compList is sorted in order of dimensionality, so safe to abort
		if ( nInferiorIndices >= deltaComp.m_nDimensionality )
			break;

		pSuperiorDelta = GetDeltaState( deltaComp.m_nDeltaIndex );
		if ( !pSuperiorDelta )
			continue;

		if ( !GetControlDeltaIndices( pSuperiorDelta, superiorIndices ) )
			continue;

		nSuperiorIndices = superiorIndices.Count();

		qsort( superiorIndices.Base(), nSuperiorIndices, sizeof( int ), ControlIndexLessFunc );

		int nFound = 0;
		int si = 0;
		for ( int ii = 0; ii < nInferiorIndices; ++ii )
		{
			const int &iIndex = inferiorIndices[ ii ];
			while ( si < nSuperiorIndices && iIndex != superiorIndices[ si ] )
			{
				++si;
			}

			if ( si < nSuperiorIndices )
			{
				++nFound;
			}
		}

		if ( nFound == nInferiorIndices )
		{
			superiorDeltaStates.AddToTail( deltaComp.m_nDeltaIndex );
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Removes the passed base state from the list of base states in the mesh
// if it exists in the list of base states in the mesh, but doesn't delete
// the element itself
//-----------------------------------------------------------------------------
bool CDmeMesh::RemoveBaseState( CDmeVertexData *pBase )
{
	const int nBaseStates = m_BaseStates.Count();
	for ( int i = 0; i < nBaseStates; ++i )
	{
		CDmeVertexData *pTmpBase = m_BaseStates[ i ];
		if ( pTmpBase == pBase )
		{
			m_BaseStates.Remove( i );
			return true;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Adds an existing element to the list of base states of the mesh if it
// isn't already one of the base states
//-----------------------------------------------------------------------------
CDmeVertexData *CDmeMesh::FindOrAddBaseState( CDmeVertexData *pBase )
{
	const int nBaseStates = m_BaseStates.Count();
	for ( int i = 0; i < nBaseStates; ++i )
	{
		if ( m_BaseStates[ i ] == pBase )
		{
			return pBase;
		}
	}

	return m_BaseStates[ m_BaseStates.AddToTail( pBase ) ];
}


//-----------------------------------------------------------------------------
// TODO: Current state is insufficient as long as the current state isn't
//       created from the current delta weights
//-----------------------------------------------------------------------------
void CDmeMesh::GetBoundingSphere(
	Vector &c, float &r,
	CDmeVertexData *pPassedBase /* = NULL */, CDmeSingleIndexedComponent *pPassedSelection /* = NULL */ ) const
{ 
	c.Zero();
	r = 0.0f;

	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	if ( !pBase )
		return;

	const FieldIndex_t pIndex = pBase->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	if ( pIndex < 0 )
		return;

	const CUtlVector< Vector > &pData( pBase->GetPositionData() );
	const int nPositions = pData.Count();

	if ( pPassedSelection )
	{
		const int nSelectionCount = pPassedSelection->Count();
		int nIndex;
		float fWeight;
		for ( int i = 0; i < nSelectionCount; ++i )
		{
			pPassedSelection->GetComponent( i, nIndex, fWeight );
			c += pData[ nIndex ];
		}

		c /= static_cast< float >( nSelectionCount );

		float sqDist;
		for ( int i = 0; i < nSelectionCount; ++i )
		{
			for ( int i = 0; i < nPositions; ++i )
			{
				sqDist = c.DistToSqr( pData[ i ] );
				if ( sqDist > r )
				{
					r = sqDist;
				}
			}
		}
	}
	else
	{
		for ( int i = 0; i < nPositions; ++i )
		{
			c += pData[ i ];
		}

		c /= static_cast< float >( nPositions );

		float sqDist;
		for ( int i = 0; i < nPositions; ++i )
		{
			for ( int i = 0; i < nPositions; ++i )
			{
				sqDist = c.DistToSqr( pData[ i ] );
				if ( sqDist > r )
				{
					r = sqDist;
				}
			}
		}
	}

	r = sqrt( r );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::GetBoundingBox( Vector &min, Vector &max, CDmeVertexData *pPassedBase /* = NULL */, CDmeSingleIndexedComponent *pPassedSelection /* = NULL */ ) const
{
	min.Zero();
	max.Zero();

	const CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();
	if ( !pBase )
		return;

	const FieldIndex_t pIndex = pBase->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	if ( pIndex < 0 )
		return;

	const CUtlVector< Vector > &pData( pBase->GetPositionData() );
	const int nPositions = pData.Count();

	if ( pPassedSelection )
	{
		const int nSelectionCount = pPassedSelection->Count();

		if ( nSelectionCount > 0 )
		{
			int nIndex;
			float fWeight;

			pPassedSelection->GetComponent( 0, nIndex, fWeight );
			min = pData[ nIndex ];
			max = min;

			for ( int i = 1; i < nSelectionCount; ++i )
			{
				pPassedSelection->GetComponent( i, nIndex, fWeight );

				const Vector &p = pData[ nIndex ];
				if ( p.x < min.x )
				{
					min.x = p.x;
				}
				else if ( p.x > max.x )
				{
					max.x = p.x;
				}

				if ( p.y < min.y )
				{
					min.y = p.y;
				}
				else if ( p.y > max.y )
				{
					max.y = p.y;
				}

				if ( p.z < min.z )
				{
					min.z = p.z;
				}
				else if ( p.z > max.z )
				{
					max.z = p.z;
				}
			}
		}
	}
	else
	{
		if ( nPositions > 0 )
		{
			min = pData[ 0 ];
			max = min;

			for ( int i = 1; i < nPositions; ++i )
			{
				const Vector &p = pData[ i ];
				if ( p.x < min.x )
				{
					min.x = p.x;
				}
				else if ( p.x > max.x )
				{
					max.x = p.x;
				}

				if ( p.y < min.y )
				{
					min.y = p.y;
				}
				else if ( p.y > max.y )
				{
					max.y = p.y;
				}

				if ( p.z < min.z )
				{
					min.z = p.z;
				}
				else if ( p.z > max.z )
				{
					max.z = p.z;
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T_t >
bool CDmeMesh::SetBaseDataToDeltas(
	CDmeVertexData *pBase,
	CDmeVertexData::StandardFields_t nStandardField, CDmrArrayConst< T_t > &srcData, CDmrArray< T_t > &dstData, bool bDoStereo, bool bDoLag )
{
	const int nDataCount = dstData.Count();
	if ( srcData.Count() != nDataCount )
		return false;

	// Create the temp buffer for the data
	T_t *pData = reinterpret_cast< T_t * >( alloca( nDataCount * sizeof( T_t ) ) );

	// Copy the data from the src base state
	memcpy( pData, srcData.Base(), nDataCount * sizeof( T_t ) );

	const int nCount = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL].Count();
	Assert( m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL].Count() == m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED].Count() );

	if ( bDoStereo )
	{
		for ( int i = 0; i < nCount; ++i )
		{
			float flLeftWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].x;
			float flRightWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].y;
			float flLeftWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].x;
			float flRightWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].y;
			if ( flLeftWeight <= 0.0f && flRightWeight <= 0.0f && ( !bDoLag || ( flLeftWeightLagged <= 0.0f && flRightWeightLagged <= 0.0f ) ) )
				continue;

			AddStereoVertexDelta< T_t >( pBase, pData, sizeof( T_t ), nStandardField, i, bDoLag );
		}
	}
	else
	{
		for ( int i = 0; i < nCount; ++i )
		{
			float flWeight = m_DeltaStateWeights[MESH_DELTA_WEIGHT_NORMAL][i].x;
			float flWeightLagged = m_DeltaStateWeights[MESH_DELTA_WEIGHT_LAGGED][i].x;
			if ( flWeight < 0.0f && ( !bDoLag || flWeightLagged <= 0.0f ) )
				continue;

			AddVertexDelta< T_t >( pBase, pData, sizeof( T_t ), nStandardField, i, bDoLag );
		}
	}

	dstData.SetMultiple( 0, nDataCount, pData );

	return true;
}


//-----------------------------------------------------------------------------
// Sets the specified based state to the version of the mesh specified by the
// current weighted deltas
// It's ok to modify the bind state... if you know what you're doing
//-----------------------------------------------------------------------------
bool CDmeMesh::SetBaseStateToDeltas( CDmeVertexData *pPassedBase /*= NULL */ )
{
	CDmeVertexData *pBind = GetBindBaseState();
	CDmeVertexData *pBase = pPassedBase ? pPassedBase : GetCurrentBaseState();

	if ( !pBind || !pBase )
		return false;

	CDmeVertexData::StandardFields_t deltaFields[] =
	{
		CDmeVertexData::FIELD_POSITION,
		CDmeVertexData::FIELD_NORMAL,
		CDmeVertexData::FIELD_WRINKLE
	};

	const bool bDoStereo = ( pBind->FindFieldIndex( CDmeVertexDeltaData::FIELD_BALANCE ) >= 0 );

	for ( int i = 0; i < sizeof( deltaFields ) / sizeof( deltaFields[ 0 ] ); ++i )
	{
		const CDmeVertexDeltaData::StandardFields_t nStandardField = deltaFields[ i ];
		const int nSrcField = pBind->FindFieldIndex( nStandardField );
		const int nDstField = pBase->FindFieldIndex( nStandardField );
		if ( nSrcField < 0 || nDstField < 0 )
			continue;

		const CDmAttribute *pSrcAttr = pBind->GetVertexData( nSrcField );
		CDmAttribute *pDstAttr = pBase->GetVertexData( nDstField );
		if ( !pSrcAttr || !pDstAttr || pSrcAttr->GetType() != pDstAttr->GetType() )
			continue;

		switch ( pDstAttr->GetType() )
		{
		case AT_FLOAT_ARRAY:
			SetBaseDataToDeltas( pBind, nStandardField, CDmrArrayConst< float >( pSrcAttr ), CDmrArray< float >( pDstAttr ), bDoStereo, false );
			break;
		case AT_VECTOR3_ARRAY:
			SetBaseDataToDeltas( pBind, nStandardField, CDmrArrayConst< Vector >( pSrcAttr ), CDmrArray< Vector >( pDstAttr ), bDoStereo, false );
			break;
		default:
			Assert( 0 );
			break;
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Replace all instances of a material with a different material
//-----------------------------------------------------------------------------
void CDmeMesh::ReplaceMaterial( const char *pOldMaterialName, const char *pNewMaterialName )
{
	char pOldFixedName[MAX_PATH];
	char pNewFixedName[MAX_PATH];
	char pFixedName[MAX_PATH];
	if ( pOldMaterialName )
	{
		Q_FixupPathName( pOldFixedName, sizeof(pOldFixedName), pOldMaterialName );
	}
	Q_FixupPathName( pNewFixedName, sizeof(pNewFixedName), pNewMaterialName );
	CDmeMaterial *pReplacementMaterial = NULL;

	int nCount = m_FaceSets.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeFaceSet *pFaceSet = m_FaceSets[i];
		CDmeMaterial *pMaterial = pFaceSet->GetMaterial();
		if ( pOldMaterialName )
		{
			const char *pMaterialName = pMaterial->GetMaterialName();
			Q_FixupPathName( pFixedName, sizeof(pFixedName), pMaterialName );
			if ( Q_stricmp( pFixedName, pOldFixedName ) )
				continue;
		}

		if ( !pReplacementMaterial )
		{
			pReplacementMaterial = CreateElement< CDmeMaterial >( pMaterial->GetName(), pMaterial->GetFileId() );
			pReplacementMaterial->SetMaterial( pNewFixedName );
		}
		pFaceSet->SetMaterial( pReplacementMaterial );
	}
}


//-----------------------------------------------------------------------------
// Reskins the mesh to new bones
// The joint index remap maps an initial bone index to a new bone index
//-----------------------------------------------------------------------------
void CDmeMesh::Reskin( const int *pJointTransformIndexRemap )
{
	CleanupHWMesh();

	int nCount = m_BaseStates.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		m_BaseStates[i]->Reskin( pJointTransformIndexRemap );
	}
}


//-----------------------------------------------------------------------------
// Cleans up delta data that is referring to normals which have been merged out
//-----------------------------------------------------------------------------
static void CollapseRedundantDeltaNormals( CDmeVertexDeltaData *pDmeDelta, const CUtlVector< int > &normalMap )
{
	if ( !pDmeDelta )
		return;

	FieldIndex_t nNormalFieldIndex = pDmeDelta->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	if ( nNormalFieldIndex < 0 )
		return;	// No normal deltas

	const CUtlVector< Vector > &oldNormalData = pDmeDelta->GetNormalData();
	const CUtlVector< int > &oldNormalIndices = pDmeDelta->GetVertexIndexData( nNormalFieldIndex );

	Assert( oldNormalData.Count() == oldNormalIndices.Count() );

	CUtlVector< bool > done;
	done.SetCount( normalMap.Count() );
	Q_memset( done.Base(), 0, done.Count() * sizeof( bool ) );

	CUtlVector< Vector > newNormalData;
	CUtlVector< int > newNormalIndices;

	for ( int i = 0; i < oldNormalIndices.Count(); ++i )
	{
		const int nNewIndex = normalMap[ oldNormalIndices[i] ];
		if ( nNewIndex < 0 || done[ nNewIndex ] )
			continue;

		done[ nNewIndex ] = true;
		newNormalData.AddToTail( oldNormalData[i] );
		newNormalIndices.AddToTail( nNewIndex );
	}

	pDmeDelta->RemoveAllVertexData( nNormalFieldIndex );
	nNormalFieldIndex = pDmeDelta->CreateField( CDmeVertexDeltaData::FIELD_NORMAL );
	pDmeDelta->AddVertexData( nNormalFieldIndex, newNormalData.Count() );
	pDmeDelta->SetVertexData( nNormalFieldIndex, 0, newNormalData.Count(), AT_VECTOR3, newNormalData.Base() );
	pDmeDelta->SetVertexIndices( nNormalFieldIndex, 0, newNormalIndices.Count(), newNormalIndices.Base() );
}


//-----------------------------------------------------------------------------
// Remove redundant normals from a DMX Mesh
// Looks at all of the normals around each position vertex and merges normals
// which are numerically similar (within flNormalBlend which by default in
// studiomdl is within 2 degrees) around that vertex
//
// If this would result in more normals being created, then don't do anything
// return false.
//-----------------------------------------------------------------------------
static bool CollapseRedundantBaseNormals( CDmeVertexData *pDmeVertexData, CUtlVector< int > &normalMap, float flNormalBlend )
{
	if ( !pDmeVertexData )
		return false;

	FieldIndex_t nPositionFieldIndex = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	FieldIndex_t nNormalFieldIndex = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	if ( nPositionFieldIndex < 0 || nNormalFieldIndex < 0 )
		return false;

	const CUtlVector< Vector > &oldNormalData = pDmeVertexData->GetNormalData();
	const CUtlVector< int > &oldNormalIndices = pDmeVertexData->GetVertexIndexData( nNormalFieldIndex );

	CUtlVector< Vector > newNormalData;
	CUtlVector< int > newNormalIndices;

	newNormalIndices.SetCount( oldNormalIndices.Count() );
	for ( int i = 0; i < newNormalIndices.Count(); ++i )
	{
		newNormalIndices[i] = -1;
	}

	const int nPositionDataCount = pDmeVertexData->GetPositionData().Count();
	for ( int i = 0; i < nPositionDataCount; ++i )
	{
		int nNewNormalDataIndex = newNormalData.Count();

		const CUtlVector< int > &vertexIndices = pDmeVertexData->FindVertexIndicesFromDataIndex( CDmeVertexData::FIELD_POSITION, i );
		for ( int j = 0; j < vertexIndices.Count(); ++j )
		{
			bool bUnique = true;
			const int nVertexIndex = vertexIndices[j];
			const Vector &vNormal = oldNormalData[ oldNormalIndices[ vertexIndices[j] ] ];

			for ( int k = nNewNormalDataIndex; k < newNormalData.Count(); ++k )
			{
				if ( DotProduct( vNormal, newNormalData[k] ) > flNormalBlend )
				{
					newNormalIndices[ nVertexIndex ] = k;
					bUnique = false;
					break;
				}
			}

			if ( !bUnique )
				continue;

			newNormalIndices[ nVertexIndex ] = newNormalData.AddToTail( vNormal );
		}
	}

	for ( int i = 0; i < newNormalIndices.Count(); ++i )
	{
		if ( newNormalIndices[i] == -1 )
		{
			newNormalIndices[i] = newNormalData.AddToTail( oldNormalData[ oldNormalIndices[i] ] );
		}
	}

	// If it's the same or more don't do anything
	if ( newNormalData.Count() >= oldNormalData.Count() )
		return false;

	normalMap.SetCount( oldNormalData.Count() );
	for ( int i = 0; i < normalMap.Count(); ++i )
	{
		normalMap[i] = -1;
	}

	Assert( newNormalIndices.Count() == oldNormalIndices.Count() );
	for ( int i = 0; i < oldNormalIndices.Count(); ++i )
	{
		if ( normalMap[ oldNormalIndices[i] ] == -1 )
		{
			normalMap[ oldNormalIndices[i] ] = newNormalIndices[i];
		}
		else
		{
			Assert( normalMap[ oldNormalIndices[i] ] == newNormalIndices[i] );
		}
	}

	pDmeVertexData->RemoveAllVertexData( nNormalFieldIndex );
	nNormalFieldIndex = pDmeVertexData->CreateField( CDmeVertexDeltaData::FIELD_NORMAL );
	pDmeVertexData->AddVertexData( nNormalFieldIndex, newNormalData.Count() );
	pDmeVertexData->SetVertexData( nNormalFieldIndex, 0, newNormalData.Count(), AT_VECTOR3, newNormalData.Base() );
	pDmeVertexData->SetVertexIndices( nNormalFieldIndex, 0, newNormalIndices.Count(), newNormalIndices.Base() );

	return true;
}


//-----------------------------------------------------------------------------
// Collapse all normals with the same numerical value into the same normal
//-----------------------------------------------------------------------------
static bool CollapseRedundantBaseNormalsAggressive( CDmeVertexData *pDmeVertexData, float flNormalBlend )
{
	if ( !pDmeVertexData )
		return false;

	FieldIndex_t nNormalFieldIndex = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	if ( nNormalFieldIndex < 0 )
		return false;

	const CUtlVector< Vector > &oldNormalData = pDmeVertexData->GetNormalData();
	const CUtlVector< int > &oldNormalIndices = pDmeVertexData->GetVertexIndexData( nNormalFieldIndex );

	CUtlVector< int > normalMap;
	normalMap.SetCount( oldNormalData.Count() );

	CUtlVector< Vector > newNormalData;

	for ( int i = 0; i < oldNormalData.Count(); ++i )
	{
		bool bUnique = true;
		const Vector &vNormal = oldNormalData[ i ];

		for ( int j = 0; j < newNormalData.Count(); ++j )
		{
			if ( DotProduct( vNormal, newNormalData[j] ) > flNormalBlend )
			{
				normalMap[ i ] = j;
				bUnique = false;
				break;
			}
		}

		if ( !bUnique )
			continue;

		normalMap[ i ] = newNormalData.AddToTail( vNormal );
	}

	// If it's the same then don't do anything.
	if ( newNormalData.Count() >= oldNormalData.Count() )
		return false;

	CUtlVector< int > newNormalIndices;
	newNormalIndices.SetCount( oldNormalIndices.Count() );

	for ( int i = 0; i < oldNormalIndices.Count(); ++i )
	{
		newNormalIndices[i] = normalMap[ oldNormalIndices[i] ];
	}

	pDmeVertexData->RemoveAllVertexData( nNormalFieldIndex );
	nNormalFieldIndex = pDmeVertexData->CreateField( CDmeVertexDeltaData::FIELD_NORMAL );
	pDmeVertexData->AddVertexData( nNormalFieldIndex, newNormalData.Count() );
	pDmeVertexData->SetVertexData( nNormalFieldIndex, 0, newNormalData.Count(), AT_VECTOR3, newNormalData.Base() );
	pDmeVertexData->SetVertexIndices( nNormalFieldIndex, 0, newNormalIndices.Count(), newNormalIndices.Base() );

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::NormalizeNormals()
{
	Vector vNormal;

	for ( int i = 0; i < this->BaseStateCount(); ++i )
	{
		CDmeVertexData *pDmeVertexData = GetBaseState( i );
		if ( !pDmeVertexData )
			continue;

		FieldIndex_t nNormalIndex = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
		if ( nNormalIndex < 0 )
			continue;

		CDmAttribute *pDmNormalAttr = pDmeVertexData->GetVertexData( nNormalIndex );
		if ( !pDmNormalAttr )
			continue;

		CDmrArray< Vector > normalData( pDmNormalAttr );
		for ( int j = 0; j < normalData.Count(); ++j )
		{
			vNormal = normalData.Get( j );
			VectorNormalize( vNormal );
			normalData.Set( j, vNormal );
		}
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeMesh::CollapseRedundantNormals( float flNormalBlend )
{
	NormalizeNormals();

	CDmeVertexData *pDmeBind = GetBindBaseState();
	if ( !pDmeBind )
		return;

	CUtlVector< int > normalMap;

	const int nDeltaStateCount = DeltaStateCount();
	if ( nDeltaStateCount <= 0 )
	{
		// No deltas
		if ( CollapseRedundantBaseNormalsAggressive( pDmeBind, flNormalBlend ) )
		{
			// Collapse any other states
			for ( int i = 0; i < BaseStateCount(); ++i )
			{
				CDmeVertexData *pDmeVertexData = GetBaseState( i );
				if ( !pDmeVertexData || pDmeVertexData == pDmeBind )
					continue;

				CollapseRedundantBaseNormalsAggressive( pDmeVertexData, flNormalBlend );
			}
		}
	}
	else
	{
		// Collapse the base state
		if ( CollapseRedundantBaseNormals( pDmeBind, normalMap, flNormalBlend ) )
		{
			// Collapse any delta states using the baseState normal map
			for ( int i = 0; i < DeltaStateCount(); ++i )
			{
				CDmeVertexDeltaData *pDmeDeltaData = GetDeltaState( i );
				if ( !pDmeDeltaData )
					continue;

				CollapseRedundantDeltaNormals( pDmeDeltaData, normalMap );
			}

			// Collapse any other states
			for ( int i = 0; i < BaseStateCount(); ++i )
			{
				CDmeVertexData *pDmeVertexData = GetBaseState( i );
				if ( !pDmeVertexData || pDmeVertexData == pDmeBind )
					continue;

				CollapseRedundantBaseNormals( pDmeVertexData, normalMap, flNormalBlend );
			}
		}
	}
}