source-engine/materialsystem/shaderapidx9/meshbase.h

310 lines
9.6 KiB
C
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#ifndef MESHBASE_H
#define MESHBASE_H
#ifdef _WIN32
#pragma once
#endif
#include "materialsystem/imesh.h"
#include "materialsystem/imaterial.h"
//-----------------------------------------------------------------------------
// Base vertex buffer
//-----------------------------------------------------------------------------
abstract_class CVertexBufferBase : public IVertexBuffer
{
// Methods of IVertexBuffer
public:
virtual void Spew( int nVertexCount, const VertexDesc_t &desc );
virtual void ValidateData( int nVertexCount, const VertexDesc_t& desc );
public:
// constructor, destructor
CVertexBufferBase( const char *pBudgetGroupName );
virtual ~CVertexBufferBase();
// Displays the vertex format
static void PrintVertexFormat( VertexFormat_t vertexFormat );
// Used to construct vertex data
static void ComputeVertexDescription( unsigned char *pBuffer, VertexFormat_t vertexFormat, VertexDesc_t &desc );
// Returns the vertex format size
static int VertexFormatSize( VertexFormat_t vertexFormat );
protected:
const char *m_pBudgetGroupName;
};
//-----------------------------------------------------------------------------
// Base index buffer
//-----------------------------------------------------------------------------
abstract_class CIndexBufferBase : public IIndexBuffer
{
// Methods of IIndexBuffer
public:
virtual void Spew( int nIndexCount, const IndexDesc_t &desc );
virtual void ValidateData( int nIndexCount, const IndexDesc_t& desc );
// Other public methods
public:
// constructor, destructor
CIndexBufferBase( const char *pBudgetGroupName );
virtual ~CIndexBufferBase() {}
protected:
const char *m_pBudgetGroupName;
};
//-----------------------------------------------------------------------------
// Base mesh
//-----------------------------------------------------------------------------
class CMeshBase : public IMesh
{
// Methods of IMesh
public:
// Other public methods that need to be overridden
public:
// Begins a pass
virtual void BeginPass( ) = 0;
// Draws a single pass of the mesh
virtual void RenderPass() = 0;
// Does it have a color mesh?
virtual bool HasColorMesh() const = 0;
// Am I using morph data?
virtual bool IsUsingMorphData() const = 0;
virtual bool HasFlexMesh() const = 0;
virtual IMesh *GetMesh() { return this; }
public:
// constructor, destructor
CMeshBase();
virtual ~CMeshBase();
};
//-----------------------------------------------------------------------------
// Utility method for VertexDesc_t (don't want to expose it in public, in imesh.h)
//-----------------------------------------------------------------------------
inline void ComputeVertexDesc( unsigned char * pBuffer, VertexFormat_t vertexFormat, VertexDesc_t & desc )
{
int i;
int *pVertexSizesToSet[64];
int nVertexSizesToSet = 0;
static ALIGN32 ModelVertexDX8_t temp[4];
float *dummyData = (float*)&temp; // should be larger than any CMeshBuilder command can set.
// Determine which vertex compression type this format specifies (affects element sizes/decls):
VertexCompressionType_t compression = CompressionType( vertexFormat );
desc.m_CompressionType = compression;
// We use fvf instead of flags here because we may pad out the fvf
// vertex structure to optimize performance
int offset = 0;
// NOTE: At the moment, we assume that if you specify wrinkle, you also specify position
Assert( ( ( vertexFormat & VERTEX_WRINKLE ) == 0 ) || ( ( vertexFormat & VERTEX_POSITION ) != 0 ) );
if ( vertexFormat & VERTEX_POSITION )
{
// UNDONE: compress position+wrinkle to SHORT4N, and roll the scale into the transform matrices
desc.m_pPosition = reinterpret_cast<float*>(pBuffer);
offset += GetVertexElementSize( VERTEX_ELEMENT_POSITION, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_Position;
if ( vertexFormat & VERTEX_WRINKLE )
{
desc.m_pWrinkle = reinterpret_cast<float*>( pBuffer + offset );
offset += GetVertexElementSize( VERTEX_ELEMENT_WRINKLE, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_Wrinkle;
}
else
{
desc.m_pWrinkle = dummyData;
desc.m_VertexSize_Wrinkle = 0;
}
}
else
{
desc.m_pPosition = dummyData;
desc.m_VertexSize_Position = 0;
desc.m_pWrinkle = dummyData;
desc.m_VertexSize_Wrinkle = 0;
}
// Bone weights/matrix indices
desc.m_NumBoneWeights = NumBoneWeights( vertexFormat );
Assert( ( desc.m_NumBoneWeights == 2 ) || ( desc.m_NumBoneWeights == 0 ) );
// We assume that if you have any indices/weights, you have exactly two of them
Assert( ( ( desc.m_NumBoneWeights == 2 ) && ( ( vertexFormat & VERTEX_BONE_INDEX ) != 0 ) ) ||
( ( desc.m_NumBoneWeights == 0 ) && ( ( vertexFormat & VERTEX_BONE_INDEX ) == 0 ) ) );
if ( ( vertexFormat & VERTEX_BONE_INDEX ) != 0 )
{
if ( desc.m_NumBoneWeights > 0 )
{
Assert( desc.m_NumBoneWeights == 2 );
// Always exactly two weights
desc.m_pBoneWeight = reinterpret_cast<float*>(pBuffer + offset);
offset += GetVertexElementSize( VERTEX_ELEMENT_BONEWEIGHTS2, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_BoneWeight;
}
else
{
desc.m_pBoneWeight = dummyData;
desc.m_VertexSize_BoneWeight = 0;
}
desc.m_pBoneMatrixIndex = pBuffer + offset;
offset += GetVertexElementSize( VERTEX_ELEMENT_BONEINDEX, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_BoneMatrixIndex;
}
else
{
desc.m_pBoneWeight = dummyData;
desc.m_VertexSize_BoneWeight = 0;
desc.m_pBoneMatrixIndex = (unsigned char*)dummyData;
desc.m_VertexSize_BoneMatrixIndex = 0;
}
if ( vertexFormat & VERTEX_NORMAL )
{
desc.m_pNormal = reinterpret_cast<float*>(pBuffer + offset);
// See PackNormal_[SHORT2|UBYTE4|HEND3N] in mathlib.h for the compression algorithm
offset += GetVertexElementSize( VERTEX_ELEMENT_NORMAL, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_Normal;
}
else
{
desc.m_pNormal = dummyData;
desc.m_VertexSize_Normal = 0;
}
if ( vertexFormat & VERTEX_COLOR )
{
desc.m_pColor = pBuffer + offset;
offset += GetVertexElementSize( VERTEX_ELEMENT_COLOR, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_Color;
}
else
{
desc.m_pColor = (unsigned char*)dummyData;
desc.m_VertexSize_Color = 0;
}
if ( vertexFormat & VERTEX_SPECULAR )
{
desc.m_pSpecular = pBuffer + offset;
offset += GetVertexElementSize( VERTEX_ELEMENT_SPECULAR, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_Specular;
}
else
{
desc.m_pSpecular = (unsigned char*)dummyData;
desc.m_VertexSize_Specular = 0;
}
// Set up texture coordinates
for ( i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i )
{
// FIXME: compress texcoords to SHORT2N/SHORT4N, with a scale rolled into the texture transform
VertexElement_t texCoordElements[4] = { VERTEX_ELEMENT_TEXCOORD1D_0, VERTEX_ELEMENT_TEXCOORD2D_0, VERTEX_ELEMENT_TEXCOORD3D_0, VERTEX_ELEMENT_TEXCOORD4D_0 };
int nSize = TexCoordSize( i, vertexFormat );
if ( nSize != 0 )
{
desc.m_pTexCoord[i] = reinterpret_cast<float*>(pBuffer + offset);
VertexElement_t texCoordElement = (VertexElement_t)( texCoordElements[ nSize - 1 ] + i );
offset += GetVertexElementSize( texCoordElement, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_TexCoord[i];
}
else
{
desc.m_pTexCoord[i] = dummyData;
desc.m_VertexSize_TexCoord[i] = 0;
}
}
// Binormal + tangent...
// Note we have to put these at the end so the vertex is FVF + stuff at end
if ( vertexFormat & VERTEX_TANGENT_S )
{
// UNDONE: use normal compression here (use mem_dumpvballocs to see if this uses much memory)
desc.m_pTangentS = reinterpret_cast<float*>(pBuffer + offset);
offset += GetVertexElementSize( VERTEX_ELEMENT_TANGENT_S, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_TangentS;
}
else
{
desc.m_pTangentS = dummyData;
desc.m_VertexSize_TangentS = 0;
}
if ( vertexFormat & VERTEX_TANGENT_T )
{
// UNDONE: use normal compression here (use mem_dumpvballocs to see if this uses much memory)
desc.m_pTangentT = reinterpret_cast<float*>(pBuffer + offset);
offset += GetVertexElementSize( VERTEX_ELEMENT_TANGENT_T, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_TangentT;
}
else
{
desc.m_pTangentT = dummyData;
desc.m_VertexSize_TangentT = 0;
}
// User data..
int userDataSize = UserDataSize( vertexFormat );
if ( userDataSize > 0 )
{
desc.m_pUserData = reinterpret_cast<float*>(pBuffer + offset);
VertexElement_t userDataElement = (VertexElement_t)( VERTEX_ELEMENT_USERDATA1 + ( userDataSize - 1 ) );
// See PackNormal_[SHORT2|UBYTE4|HEND3N] in mathlib.h for the compression algorithm
offset += GetVertexElementSize( userDataElement, compression );
pVertexSizesToSet[nVertexSizesToSet++] = &desc.m_VertexSize_UserData;
}
else
{
desc.m_pUserData = dummyData;
desc.m_VertexSize_UserData = 0;
}
// We always use vertex sizes which are half-cache aligned (16 bytes)
// x360 compressed vertexes are not compatible with forced alignments
bool bCacheAlign = ( vertexFormat & VERTEX_FORMAT_USE_EXACT_FORMAT ) == 0;
if ( bCacheAlign && ( offset > 16 ) && IsPC() )
{
offset = (offset + 0xF) & (~0xF);
}
desc.m_ActualVertexSize = offset;
// Now set the m_VertexSize for all the members that were actually valid.
Assert( nVertexSizesToSet < sizeof(pVertexSizesToSet)/sizeof(pVertexSizesToSet[0]) );
for ( int iElement=0; iElement < nVertexSizesToSet; iElement++ )
{
*pVertexSizesToSet[iElement] = offset;
}
}
#endif // MESHBASE_H