5017 lines
160 KiB
C++
5017 lines
160 KiB
C++
//========= Copyright 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;
|
|
CMaterialReference CDmeMesh::s_NormalErrorMaterial;
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper class to deal with software skinning
|
|
//-----------------------------------------------------------------------------
|
|
class CRenderInfo
|
|
{
|
|
public:
|
|
CRenderInfo( const CDmeVertexData *pBaseState );
|
|
|
|
void ComputeVertex( int vi, const matrix3x4_t *pPoseToWorld, CDmeMesh::RenderVertexDelta_t *pDelta, Vector *pPosition, Vector *pNormal, Vector4D *pTangent );
|
|
void ComputeVertex( int vi, const matrix3x4_t *pPoseToWorld, Vector *pDeltaPosition, int nStride, Vector *pPosition );
|
|
void ComputePosition( int posIndex, const matrix3x4_t *pPoseToWorld, Vector *pDeltaPosition, Vector *pPosition );
|
|
|
|
inline bool HasPositionData() const { return m_bHasPositionData; }
|
|
inline bool HasNormalData() const { return m_bHasNormalData; }
|
|
inline bool HasTangentData() const { return m_bHasTangentData; }
|
|
private:
|
|
const CUtlVector<int>& m_PositionIndices;
|
|
const CUtlVector<Vector>& m_PositionData;
|
|
const CUtlVector<int>& m_NormalIndices;
|
|
const CUtlVector<Vector>& m_NormalData;
|
|
const CUtlVector<int>& m_TangentIndices;
|
|
const CUtlVector<Vector4D>& m_TangentData;
|
|
const CDmeVertexData *m_pBaseState;
|
|
int m_nJointCount;
|
|
bool m_bHasPositionData;
|
|
bool m_bHasNormalData;
|
|
bool m_bHasTangentData;
|
|
bool m_bHasSkinningData;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CRenderInfo::CRenderInfo( const 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 CRenderInfo::ComputeVertex( int vi, const matrix3x4_t *pPoseToWorld, Vector *pDeltaPosition, int nDeltaStride, Vector *pPosition )
|
|
{
|
|
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 ( pDeltaPosition )
|
|
{
|
|
Vector *pDelta = (Vector*)( (unsigned char *)pDeltaPosition + nDeltaStride * pi );
|
|
VectorAdd( *pPositionData, *pDelta, vecMorphPosition );
|
|
pPositionData = &vecMorphPosition;
|
|
}
|
|
VectorTransform( *pPositionData, *pSkinMatrix, *pPosition );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes where a vertex is
|
|
//-----------------------------------------------------------------------------
|
|
void CRenderInfo::ComputePosition( int posIndex, const matrix3x4_t *pPoseToWorld, Vector *pDeltaPosition, Vector *pPosition )
|
|
{
|
|
matrix3x4_t result;
|
|
Vector vecMorphPosition;
|
|
const matrix3x4_t *pSkinMatrix = pPoseToWorld;
|
|
|
|
if ( m_bHasSkinningData )
|
|
{
|
|
const float *pJointWeight = m_pBaseState->GetJointPositionWeights( posIndex );
|
|
const int *pJointIndices = m_pBaseState->GetJointPositionIndices( posIndex );
|
|
pSkinMatrix = ComputeSkinMatrix( m_nJointCount, pJointWeight, pJointIndices, pPoseToWorld, result );
|
|
}
|
|
|
|
const Vector *pPositionData = &m_PositionData[ posIndex ];
|
|
|
|
if ( pDeltaPosition )
|
|
{
|
|
VectorAdd( *pPositionData, *( pDeltaPosition + posIndex ), vecMorphPosition );
|
|
pPositionData = &vecMorphPosition;
|
|
}
|
|
|
|
VectorTransform( *pPositionData, *pSkinMatrix, *( pPosition + posIndex ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes where a vertex is
|
|
//-----------------------------------------------------------------------------
|
|
void CRenderInfo::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 )
|
|
{
|
|
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.RemoveAll();
|
|
}
|
|
|
|
DeleteAttributeVarElementArray( m_BaseStates );
|
|
DeleteAttributeVarElementArray( m_DeltaStates );
|
|
DeleteAttributeVarElementArray( m_FaceSets );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
// pVMTKeyValues->SetInt( "$ignorez", 0 );
|
|
s_NormalMaterial.Init( "__DmeMeshNormalMaterial", pVMTKeyValues );
|
|
|
|
pVMTKeyValues = new KeyValues( "unlitgeneric" );
|
|
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
|
|
s_NormalErrorMaterial.Init( "__DmeMeshNormalErrorMaterial", 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 );
|
|
|
|
if ( !bDoLag || nSpeedFieldIndex < 0 )
|
|
{
|
|
for ( int j = 0; j < nDeltaCount; ++j )
|
|
{
|
|
int nDataIndex = indices.Get( j );
|
|
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 )
|
|
{
|
|
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 )
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 )
|
|
{
|
|
// 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 = (int*)_alloca( nOutCount * sizeof(int) );
|
|
ComputeTriangulatedIndices( pBaseState, pFaceSet, nFirstIndex, pIndices, nOutCount );
|
|
for ( int ii = 0; ii < nOutCount; ++ii )
|
|
{
|
|
meshBuilder.FastIndex( pIndices[ii] );
|
|
}
|
|
}
|
|
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.
|
|
bool bHasActiveWrinkle = false;
|
|
RenderVertexDelta_t *pVertexDelta = (RenderVertexDelta_t*)_alloca( nVertices * sizeof(RenderVertexDelta_t) );
|
|
if ( bHasActiveDeltaStates )
|
|
{
|
|
bHasActiveWrinkle = BuildDeltaMesh( nVertices, pVertexDelta );
|
|
}
|
|
else
|
|
{
|
|
pVertexDelta = NULL;
|
|
}
|
|
|
|
CRenderInfo 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.AdvanceVertex();
|
|
}
|
|
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;
|
|
|
|
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 ( 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.AdvanceVertex();
|
|
}
|
|
|
|
WriteTriangluatedIndices( pBindBase, pFaceSet, meshBuilder );
|
|
|
|
meshBuilder.End();
|
|
|
|
pMesh->Draw();
|
|
|
|
if ( pDrawSettings && pDrawSettings->GetNormals() )
|
|
{
|
|
RenderNormals( pPoseToWorld, bHasActiveDeltaStates ? pVertexDelta : NULL );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders normals
|
|
//-----------------------------------------------------------------------------
|
|
#define NORMAL_LINE_SIZE 0.25f
|
|
|
|
void CDmeMesh::RenderNormals( matrix3x4_t *pPoseToWorld, RenderVertexDelta_t *pDelta )
|
|
{
|
|
CDmeVertexData *pBind = GetBindBaseState();
|
|
if ( !pBind )
|
|
return;
|
|
|
|
CRenderInfo 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.AdvanceVertex();
|
|
|
|
VectorMA( vecPosition, NORMAL_LINE_SIZE, vecNormal, vecEndPoint );
|
|
meshBuilder.Position3fv( vecEndPoint.Base() );
|
|
meshBuilder.Color4ub( 0, 0, 255, 255 );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
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.AdvanceVertex();
|
|
|
|
VectorMA( vecPosition, NORMAL_LINE_SIZE, vecTangentS, vecEndPoint );
|
|
meshBuilder.Position3fv( vecEndPoint.Base() );
|
|
meshBuilder.Color4ub( 255, 0, 0, 255 );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( vecPosition.Base() );
|
|
meshBuilder.Color4ub( 0, 255, 0, 255 );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
VectorMA( vecPosition, NORMAL_LINE_SIZE, vecTangentT, vecEndPoint );
|
|
meshBuilder.Position3fv( vecEndPoint.Base() );
|
|
meshBuilder.Color4ub( 0, 255, 0, 255 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
nFirstVertex += nVertices;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draws the passed DmeFaceSet in wireframe mode
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeMesh::DrawWireframeFaceSet( CDmeFaceSet *pFaceSet, matrix3x4_t *pPoseToWorld, bool bHasActiveDeltaStates, CDmeDrawSettings *pDrawSettings )
|
|
{
|
|
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 nVertices = posData.Count();
|
|
|
|
const CUtlVector< int > &posIndices( CDmrArrayConst< int >( pBind->GetIndexData( posField ) ).Get() );
|
|
|
|
Vector *pDeltaVertices = bHasActiveDeltaStates ? pDeltaVertices = reinterpret_cast< Vector * >( alloca( nVertices * sizeof( Vector ) ) ) : NULL;
|
|
|
|
if ( bHasActiveDeltaStates )
|
|
{
|
|
memset( pDeltaVertices, 0, sizeof( Vector ) * nVertices );
|
|
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( nVertices * sizeof( Vector ) ) );
|
|
|
|
CRenderInfo renderInfo( pBind );
|
|
Assert( renderInfo.HasPositionData() );
|
|
|
|
for ( int pi = 0; pi < nVertices; ++pi )
|
|
{
|
|
renderInfo.ComputePosition( pi, pPoseToWorld, pDeltaVertices, pVertices );
|
|
}
|
|
|
|
InitializeNormalMaterial();
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
pRenderContext->Bind( s_NormalMaterial );
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh();
|
|
|
|
// build the mesh
|
|
CMeshBuilder meshBuilder;
|
|
|
|
// Draw the polygons in the face set
|
|
const int nFaceSetIndices = pFaceSet->NumIndices();
|
|
const int *pFaceSetIndices = pFaceSet->GetIndices();
|
|
|
|
int vR = 0;
|
|
int vG = 0;
|
|
int vB = 0;
|
|
|
|
if ( pDrawSettings )
|
|
{
|
|
const Color &vColor = pDrawSettings->GetColor();
|
|
vR = vColor.r();
|
|
vG = vColor.g();
|
|
vB = vColor.b();
|
|
}
|
|
|
|
int nFaceIndices;
|
|
for ( int i = 0; i < nFaceSetIndices; )
|
|
{
|
|
nFaceIndices = pFaceSet->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 < nVertices );
|
|
meshBuilder.Position3fv( reinterpret_cast< float * >( pVertices + vIndex0 ) );
|
|
meshBuilder.Color3ub( vR, vG, vB );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
int vIndex1 = posIndices[ pFaceSetIndices[ i + ( ( j + 1 ) % nFaceIndices ) ] ];
|
|
Assert( vIndex1 < nVertices );
|
|
meshBuilder.Position3fv( reinterpret_cast< float * >( pVertices + vIndex1) );
|
|
meshBuilder.Color3ub( vR, vG, vB );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
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 */ )
|
|
{
|
|
const 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 bSoftwareSkinning = bHasActiveDeltaStates | bDrawNormals | bWireframe;
|
|
|
|
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 ) const
|
|
{
|
|
return GetDeltaState( FindDeltaStateIndex( pDeltaName ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
int SortDeltaNameFunc( const void *a, const void *b )
|
|
{
|
|
return Q_strcmp( *( const char ** )( a ), *( const char ** )( b ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// If the name doe
|
|
//-----------------------------------------------------------------------------
|
|
const char *SortDeltaName( const char *pInDeltaName, char *pOutDeltaName, int nOutDeltaNameBufLen )
|
|
{
|
|
if ( !pInDeltaName || !strchr( pInDeltaName, '_' ) )
|
|
return pInDeltaName;
|
|
|
|
char **ppDeltaNames = reinterpret_cast< char ** >( stackalloc( nOutDeltaNameBufLen * sizeof( char * ) ) );
|
|
memset( ppDeltaNames, 0, nOutDeltaNameBufLen * sizeof( char * ) );
|
|
|
|
const char *pStart = pInDeltaName;
|
|
int nDimensionCount = 0;
|
|
while ( pStart )
|
|
{
|
|
const char *pUnderBar = strchr( pStart, '_' );
|
|
const int nControlNameBufLen = ( pUnderBar ? pUnderBar - pStart : Q_strlen( pStart ) ) + 1;
|
|
|
|
if ( nControlNameBufLen )
|
|
{
|
|
ppDeltaNames[ nDimensionCount ] = reinterpret_cast< char * >( stackalloc( nControlNameBufLen * sizeof( char ) ) );
|
|
Q_strncpy( ppDeltaNames[ nDimensionCount ], pStart, nControlNameBufLen );
|
|
++nDimensionCount;
|
|
}
|
|
|
|
pStart = pUnderBar;
|
|
if ( pStart )
|
|
{
|
|
++pStart;
|
|
}
|
|
}
|
|
|
|
// This should only happen if the input name is all _'s
|
|
if ( nDimensionCount <= 0 )
|
|
return pInDeltaName;
|
|
|
|
qsort( ppDeltaNames, nDimensionCount, sizeof( char * ), SortDeltaNameFunc );
|
|
|
|
char *pDst = pOutDeltaName;
|
|
for ( int i = 0; i < nDimensionCount; ++i )
|
|
{
|
|
if ( i != 0 )
|
|
{
|
|
Q_strncpy( pDst, "_", nOutDeltaNameBufLen );
|
|
++pDst;
|
|
--nOutDeltaNameBufLen;
|
|
}
|
|
|
|
const int nControlNameLen = Q_strlen( ppDeltaNames[ i ] );
|
|
Q_strncpy( pDst, ppDeltaNames[ i ], nOutDeltaNameBufLen );
|
|
pDst += nControlNameLen;
|
|
nOutDeltaNameBufLen -= nControlNameLen;
|
|
}
|
|
|
|
return pOutDeltaName;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmeVertexDeltaData *CDmeMesh::FindOrCreateDeltaState( const char *pInDeltaName )
|
|
{
|
|
CDmeVertexDeltaData *pDeltaState = FindDeltaState( pInDeltaName );
|
|
if ( pDeltaState )
|
|
return pDeltaState;
|
|
|
|
const int nDeltaNameBufLen = Q_strlen( pInDeltaName ) + 1;
|
|
char *pDeltaNameBuf = reinterpret_cast< char * >( stackalloc( nDeltaNameBufLen * sizeof( char ) ) );
|
|
const char *pDeltaName = SortDeltaName( pInDeltaName, pDeltaNameBuf, nDeltaNameBufLen );
|
|
|
|
pDeltaState = CreateElement< CDmeVertexDeltaData >( pDeltaName, 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 ) const
|
|
{
|
|
const char *pDeltaName = pInDeltaName;
|
|
|
|
if ( strchr( pInDeltaName, '_' ) )
|
|
{
|
|
const int nDeltaNameBufLen = Q_strlen( pInDeltaName ) + 1;
|
|
char *pDeltaNameBuf = reinterpret_cast< char * >( stackalloc( nDeltaNameBufLen * sizeof( char ) ) );
|
|
pDeltaName = SortDeltaName( pInDeltaName, pDeltaNameBuf, nDeltaNameBufLen );
|
|
}
|
|
|
|
int dn = DeltaStateCount();
|
|
for ( int di = 0; di < dn; ++di )
|
|
{
|
|
CDmeVertexDeltaData *pDeltaState = GetDeltaState( di );
|
|
if ( !Q_stricmp( pDeltaName, pDeltaState->GetName() ) )
|
|
return di;
|
|
}
|
|
|
|
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 )
|
|
{
|
|
bool bIsDX7 = !g_pMaterialSystemHardwareConfig->SupportsVertexAndPixelShaders();
|
|
VertexFormat_t vertexFormat = VERTEX_POSITION | VERTEX_COLOR | VERTEX_NORMAL | VERTEX_TEXCOORD_SIZE(0,2) | VERTEX_BONEWEIGHT(2) | VERTEX_BONE_INDEX
|
|
| ( bIsDX7 ? 0 : 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.AdvanceVertex();
|
|
}
|
|
|
|
// 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 = (int*)_alloca( nOutCount * sizeof(int) );
|
|
ComputeTriangulatedIndices( pBind, pFaceSet, nFirstIndex, pIndices, nOutCount );
|
|
for ( int ii = 0; ii < nOutCount; ++ii )
|
|
{
|
|
meshBuilder.FastIndex( pIndices[ii] );
|
|
}
|
|
}
|
|
nFirstIndex += nVertexCount + 1;
|
|
}
|
|
|
|
meshBuilder.End();
|
|
|
|
return pMesh;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute triangulated indices
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeMesh::ComputeTriangulatedIndices( const CDmeVertexData *pBaseState, CDmeFaceSet *pFaceSet, int nFirstIndex, int *pIndices, int nOutCount )
|
|
{
|
|
// 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 )
|
|
{
|
|
// 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 = (int*)_alloca( nOutCount * sizeof(int) );
|
|
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 );
|
|
}
|
|
}
|
|
}
|
|
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 );
|
|
}
|
|
|
|
for ( ; nCurrentDelta < nCount; ++nCurrentDelta )
|
|
{
|
|
CDmeVertexDeltaData *pDeltaState = GetDeltaState( pInfo[nCurrentDelta].m_nDeltaIndex );
|
|
int nLen = Q_strlen( pDeltaState->GetName() );
|
|
char *pTempBuf = (char*)_alloca( nLen + 1 );
|
|
memcpy( pTempBuf, pDeltaState->GetName(), nLen+1 );
|
|
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 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 UtlSymId_t 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 UtlSymId_t 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 )
|
|
{
|
|
if ( m_BaseStates[ i ] == pBase )
|
|
{
|
|
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 iPos = 0; iPos < nPositions; ++iPos )
|
|
{
|
|
sqDist = c.DistToSqr( pData[ iPos ] );
|
|
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 iPos = 0; iPos < nPositions; ++iPos )
|
|
{
|
|
sqDist = c.DistToSqr( pData[iPos] );
|
|
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 )
|
|
{
|
|
V_FixupPathName( pOldFixedName, sizeof(pOldFixedName), pOldMaterialName );
|
|
}
|
|
V_FixupPathName( pNewFixedName, sizeof(pNewFixedName), pNewMaterialName );
|
|
V_FixSlashes( pNewFixedName, '/' );
|
|
|
|
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();
|
|
V_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 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
}
|
|
}
|
|
}
|
|
} |