source-engine/studiorender/flexrenderdata.h

336 lines
10 KiB
C
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#ifndef FLEXRENDERDATA_H
#define FLEXRENDERDATA_H
#ifdef _WIN32
#pragma once
#endif
#include "mathlib/vector.h"
#include "utlvector.h"
#include "studio.h"
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
struct mstudiomesh_t;
//-----------------------------------------------------------------------------
// Used by flex vertex data cache
//-----------------------------------------------------------------------------
struct CachedPosNormTan_t
{
Vector m_Position;
Vector m_Normal;
Vector4D m_TangentS;
CachedPosNormTan_t() {}
CachedPosNormTan_t( CachedPosNormTan_t const& src )
{
VectorCopy( src.m_Position, m_Position );
VectorCopy( src.m_Normal, m_Normal );
Vector4DCopy( src.m_TangentS, m_TangentS );
Assert( m_TangentS.w == 1.0f || m_TangentS.w == -1.0f );
}
};
//-----------------------------------------------------------------------------
// Used by world (decal) vertex data cache
//-----------------------------------------------------------------------------
struct CachedPosNorm_t
{
Vector4DAligned m_Position;
Vector4DAligned m_Normal;
CachedPosNorm_t() {}
CachedPosNorm_t( CachedPosNorm_t const& src )
{
Vector4DCopy( src.m_Position, m_Position );
Vector4DCopy( src.m_Normal, m_Normal );
}
};
//-----------------------------------------------------------------------------
// Stores flex vertex data and world (decal) vertex data for the lifetime of the model rendering
//-----------------------------------------------------------------------------
class CCachedRenderData
{
public:
// Constructor
CCachedRenderData();
// Call this when we start to render a new model
void StartModel();
// Used to hook ourselves into a particular body part, model, and mesh
void SetBodyPart( int bodypart );
void SetModel( int model );
void SetMesh( int mesh );
// For faster setup in the decal code
void SetBodyModelMesh( int body, int model, int mesh );
// Used to set up a flex computation
bool IsFlexComputationDone( ) const;
// Used to set up a computation (for world or flex data)
void SetupComputation( mstudiomesh_t *pMesh, bool flexComputation = false );
// Is a particular vertex flexed?
bool IsVertexFlexed( int vertex ) const;
bool IsThinVertexFlexed( int vertex ) const;
// Checks to see if the vertex is defined
bool IsVertexPositionCached( int vertex ) const;
// Gets a flexed vertex
CachedPosNormTan_t* GetFlexVertex( int vertex );
// Gets a flexed vertex
CachedPosNorm_t* GetThinFlexVertex( int vertex );
// Creates a new flexed vertex to be associated with a vertex
CachedPosNormTan_t* CreateFlexVertex( int vertex );
// Creates a new flexed vertex to be associated with a vertex
CachedPosNorm_t* CreateThinFlexVertex( int vertex );
// Renormalizes the normals and tangents of the flex verts
void RenormalizeFlexVertices( bool bHasTangentData );
// Gets a decal vertex
CachedPosNorm_t* GetWorldVertex( int vertex );
// Creates a new decal vertex to be associated with a vertex
CachedPosNorm_t* CreateWorldVertex( int vertex );
template< class T >
void ComputeFlexedVertex_StreamOffset( studiohdr_t *pStudioHdr, mstudioflex_t *pflex, T *pvanim, int vertCount, float w1, float w2, float w3, float w4 );
#ifdef PLATFORM_WINDOWS
void ComputeFlexedVertex_StreamOffset_Optimized( studiohdr_t *pStudioHdr, mstudioflex_t *pflex, mstudiovertanim_t *pvanim, int vertCount, float w1, float w2, float w3, float w4);
void ComputeFlexedVertexWrinkle_StreamOffset_Optimized( studiohdr_t *pStudioHdr, mstudioflex_t *pflex, mstudiovertanim_wrinkle_t *pvanim, int vertCount, float w1, float w2, float w3, float w4);
#endif // PLATFORM_WINDOWS
private:
// Used to create the flex render data. maps
struct CacheIndex_t
{
unsigned short m_Tag;
unsigned short m_VertexIndex;
};
// A dictionary for the cached data
struct CacheDict_t
{
unsigned short m_FirstIndex;
unsigned short m_IndexCount;
unsigned short m_Tag;
unsigned short m_FlexTag;
CacheDict_t() : m_Tag(0), m_FlexTag(0) {}
};
typedef CUtlVector< CacheDict_t > CacheMeshDict_t;
typedef CUtlVector< CacheMeshDict_t > CacheModelDict_t;
typedef CUtlVector< CacheModelDict_t > CacheBodyPartDict_t;
// Flex data, allocated for the lifespan of rendering
// Can't use UtlVector due to alignment issues
int m_FlexVertexCount;
CachedPosNormTan_t m_pFlexVerts[MAXSTUDIOFLEXVERTS+1];
// Flex data, allocated for the lifespan of rendering
// Can't use UtlVector due to alignment issues
int m_ThinFlexVertexCount;
CachedPosNorm_t m_pThinFlexVerts[MAXSTUDIOFLEXVERTS+1];
// World data, allocated for the lifespan of rendering
// Can't use UtlVector due to alignment issues
int m_WorldVertexCount;
CachedPosNorm_t m_pWorldVerts[MAXSTUDIOVERTS+1];
// Maps actual mesh vertices into flex cache + world cache indices
int m_IndexCount;
CacheIndex_t m_pFlexIndex[MAXSTUDIOVERTS+1];
CacheIndex_t m_pThinFlexIndex[MAXSTUDIOVERTS+1];
CacheIndex_t m_pWorldIndex[MAXSTUDIOVERTS+1];
CacheBodyPartDict_t m_CacheDict;
// The flex tag
unsigned short m_CurrentTag;
// the current body, model, and mesh
int m_Body;
int m_Model;
int m_Mesh;
// mapping for the current mesh to flex data
CacheIndex_t* m_pFirstFlexIndex;
CacheIndex_t* m_pFirstThinFlexIndex;
CacheIndex_t* m_pFirstWorldIndex;
friend class CStudioRender;
};
//-----------------------------------------------------------------------------
// Checks to see if the vertex is defined
//-----------------------------------------------------------------------------
inline bool CCachedRenderData::IsVertexFlexed( int vertex ) const
{
return (m_pFirstFlexIndex && (m_pFirstFlexIndex[vertex].m_Tag == m_CurrentTag));
}
inline bool CCachedRenderData::IsThinVertexFlexed( int vertex ) const
{
return (m_pFirstThinFlexIndex && (m_pFirstThinFlexIndex[vertex].m_Tag == m_CurrentTag));
}
//-----------------------------------------------------------------------------
// Gets an existing flexed vertex associated with a vertex
//-----------------------------------------------------------------------------
inline CachedPosNormTan_t* CCachedRenderData::GetFlexVertex( int vertex )
{
Assert( m_pFirstFlexIndex );
Assert( m_pFirstFlexIndex[vertex].m_Tag == m_CurrentTag );
return &m_pFlexVerts[ m_pFirstFlexIndex[vertex].m_VertexIndex ];
}
inline CachedPosNorm_t* CCachedRenderData::GetThinFlexVertex( int vertex )
{
Assert( m_pFirstThinFlexIndex );
Assert( m_pFirstThinFlexIndex[vertex].m_Tag == m_CurrentTag );
return &m_pThinFlexVerts[ m_pFirstThinFlexIndex[vertex].m_VertexIndex ];
}
//-----------------------------------------------------------------------------
// Checks to see if the vertex is defined
//-----------------------------------------------------------------------------
inline bool CCachedRenderData::IsVertexPositionCached( int vertex ) const
{
return (m_pFirstWorldIndex && (m_pFirstWorldIndex[vertex].m_Tag == m_CurrentTag));
}
//-----------------------------------------------------------------------------
// Gets an existing world vertex associated with a vertex
//-----------------------------------------------------------------------------
inline CachedPosNorm_t* CCachedRenderData::GetWorldVertex( int vertex )
{
Assert( m_pFirstWorldIndex );
Assert( m_pFirstWorldIndex[vertex].m_Tag == m_CurrentTag );
return &m_pWorldVerts[ m_pFirstWorldIndex[vertex].m_VertexIndex ];
}
//-----------------------------------------------------------------------------
// For faster setup in the decal code
//-----------------------------------------------------------------------------
inline void CCachedRenderData::SetBodyModelMesh( int body, int model, int mesh)
{
m_Body = body;
m_Model = model;
m_Mesh = mesh;
Assert((m_Model >= 0) && (m_Body >= 0));
m_CacheDict[m_Body][m_Model].EnsureCount(m_Mesh+1);
// At this point, we should have all 3 defined.
CacheDict_t& dict = m_CacheDict[m_Body][m_Model][m_Mesh];
if (dict.m_Tag == m_CurrentTag)
{
m_pFirstFlexIndex = &m_pFlexIndex[dict.m_FirstIndex];
m_pFirstThinFlexIndex = &m_pThinFlexIndex[dict.m_FirstIndex];
m_pFirstWorldIndex = &m_pWorldIndex[dict.m_FirstIndex];
}
else
{
m_pFirstFlexIndex = 0;
m_pFirstThinFlexIndex = 0;
m_pFirstWorldIndex = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//
// ** Only execute this function if device supports stream offset **
//
// Input : pmesh - pointer to a studio mesh
// lod - integer lod (0 is most detailed)
// Output : none
//-----------------------------------------------------------------------------
template< class T >
void CCachedRenderData::ComputeFlexedVertex_StreamOffset( studiohdr_t *pStudioHdr, mstudioflex_t *pflex,
T *pvanim, int vertCount, float w1, float w2, float w3, float w4 )
{
float w12 = w1 - w2;
float w34 = w3 - w4;
float flVertAnimFixedPointScale = pStudioHdr->VertAnimFixedPointScale();
CachedPosNorm_t *pFlexedVertex = NULL;
for (int j = 0; j < pflex->numverts; j++)
{
int n = pvanim[j].index;
// only flex the indices that are (still) part of this mesh at this lod
if ( n >= vertCount )
continue;
float s = pvanim[j].speed;
float b = pvanim[j].side;
Vector4DAligned vPosition, vNormal;
pvanim[j].GetDeltaFixed4DAligned( &vPosition, flVertAnimFixedPointScale );
pvanim[j].GetNDeltaFixed4DAligned( &vNormal, flVertAnimFixedPointScale );
if ( !IsThinVertexFlexed(n) )
{
// Add a new flexed vert to the flexed vertex list
pFlexedVertex = CreateThinFlexVertex(n);
Assert( pFlexedVertex != NULL);
pFlexedVertex->m_Position.InitZero();
pFlexedVertex->m_Normal.InitZero();
}
else
{
pFlexedVertex = GetThinFlexVertex(n);
}
s *= 1.0f / 255.0f;
b *= 1.0f / 255.0f;
float wa = w2 + w12 * s;
float wb = w4 + w34 * s;
float w = wa + ( wb - wa ) * b;
Vector4DWeightMAD( w, vPosition, pFlexedVertex->m_Position, vNormal, pFlexedVertex->m_Normal );
}
}
#endif // FLEXRENDERDATA_H