//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
# ifndef IMESH_H
# define IMESH_H
# ifdef _WIN32
# pragma once
# endif
# include "tier1/interface.h"
# include "materialsystem/imaterial.h"
# include <float.h>
# include <string.h>
# include "tier0/dbg.h"
# include "tier2/meshutils.h"
# include "mathlib/mathlib.h"
# if defined( DX_TO_GL_ABSTRACTION )
// Swap these so that we do color swapping on 10.6.2, which doesn't have EXT_vertex_array_bgra
# define OPENGL_SWAP_COLORS
# endif
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
class IMaterial ;
class CMeshBuilder ;
class IMaterialVar ;
typedef uint64 VertexFormat_t ;
//-----------------------------------------------------------------------------
// Define this to find write-combine problems
//-----------------------------------------------------------------------------
# ifdef _DEBUG
//#ifndef DEBUG_WRITE_COMBINE
//#define DEBUG_WRITE_COMBINE 1
//#endif
# endif
//-----------------------------------------------------------------------------
// The Vertex Buffer interface
//-----------------------------------------------------------------------------
enum
{
VERTEX_MAX_TEXTURE_COORDINATES = 8 ,
BONE_MATRIX_INDEX_INVALID = 255
} ;
// Internal maximums for sizes. Don't use directly, use IMaterialSystem::GetMaxToRender()
enum
{
INDEX_BUFFER_SIZE = 32768 ,
DYNAMIC_VERTEX_BUFFER_MEMORY = ( 1024 + 512 ) * 1024 ,
DYNAMIC_VERTEX_BUFFER_MEMORY_SMALL = 384 * 1024 , // Only allocate this much during map transitions
} ;
// Vertex fields must be written in well-defined order to achieve write combining,
// which is a perf booster
enum WriteCombineOrdering_t
{
MB_FIELD_NONE = - 1 ,
MB_FIELD_POSITION = 0 ,
MB_FIELD_BONE_WEIGHTS ,
MB_FIELD_BONE_INDEX ,
MB_FIELD_NORMAL ,
MB_FIELD_COLOR ,
MB_FIELD_SPECULAR ,
MB_FIELD_TEXCOORD_FIRST ,
MB_FIELD_TEXCOORD_LAST = MB_FIELD_TEXCOORD_FIRST + VERTEX_MAX_TEXTURE_COORDINATES - 1 ,
MB_FIELD_TANGENT_S ,
MB_FIELD_TANGENT_T ,
MB_FIELD_USERDATA ,
} ;
# define MB_FIELD_TEXCOORD( nStage ) ( MB_FIELD_TEXCOORD_FIRST + ( nStage ) )
struct VertexDesc_t
{
// These can be set to zero if there are pointers to dummy buffers, when the
// actual buffer format doesn't contain the data but it needs to be safe to
// use all the CMeshBuilder functions.
int m_VertexSize_Position ;
int m_VertexSize_BoneWeight ;
int m_VertexSize_BoneMatrixIndex ;
int m_VertexSize_Normal ;
int m_VertexSize_Color ;
int m_VertexSize_Specular ;
int m_VertexSize_TexCoord [ VERTEX_MAX_TEXTURE_COORDINATES ] ;
int m_VertexSize_TangentS ;
int m_VertexSize_TangentT ;
int m_VertexSize_Wrinkle ;
int m_VertexSize_UserData ;
int m_ActualVertexSize ; // Size of the vertices.. Some of the m_VertexSize_ elements above
// are set to this value and some are set to zero depending on which
// fields exist in a buffer's vertex format.
// The type of compression applied to this vertex data
VertexCompressionType_t m_CompressionType ;
// Number of bone weights per vertex...
int m_NumBoneWeights ;
// Pointers to our current vertex data
float * m_pPosition ;
float * m_pBoneWeight ;
# ifndef NEW_SKINNING
unsigned char * m_pBoneMatrixIndex ;
# else
float * m_pBoneMatrixIndex ;
# endif
float * m_pNormal ;
unsigned char * m_pColor ;
unsigned char * m_pSpecular ;
float * m_pTexCoord [ VERTEX_MAX_TEXTURE_COORDINATES ] ;
// Tangent space *associated with one particular set of texcoords*
float * m_pTangentS ;
float * m_pTangentT ;
float * m_pWrinkle ;
// user data
float * m_pUserData ;
// The first vertex index (used for buffered vertex buffers, or cards that don't support stream offset)
int m_nFirstVertex ;
// The offset in bytes of the memory we're writing into
// from the start of the D3D buffer (will be 0 for static meshes)
unsigned int m_nOffset ;
# ifdef DEBUG_WRITE_COMBINE
int m_nLastWrittenField ;
unsigned char * m_pLastWrittenAddress ;
# endif
} ;
struct IndexDesc_t
{
// Pointers to the index data
unsigned short * m_pIndices ;
// The offset in bytes of the memory we're writing into
// from the start of the D3D buffer (will be 0 for static meshes)
unsigned int m_nOffset ;
// The first index (used for buffered index buffers, or cards that don't support stream offset)
unsigned int m_nFirstIndex ;
// 1 if the device is active, 0 if the device isn't active.
// Faster than doing if checks for null m_pIndices if someone is
// trying to write the m_pIndices while the device is inactive.
unsigned char m_nIndexSize ;
} ;
//-----------------------------------------------------------------------------
// The Mesh memory descriptor
//-----------------------------------------------------------------------------
struct MeshDesc_t : public VertexDesc_t , public IndexDesc_t
{
} ;
//-----------------------------------------------------------------------------
// Standard vertex formats for models
//-----------------------------------------------------------------------------
struct ModelVertexDX7_t
{
Vector m_vecPosition ;
Vector2D m_flBoneWeights ;
unsigned int m_nBoneIndices ;
Vector m_vecNormal ;
unsigned int m_nColor ; // ARGB
Vector2D m_vecTexCoord ;
} ;
struct ModelVertexDX8_t : public ModelVertexDX7_t
{
Vector4D m_vecUserData ;
} ;
//-----------------------------------------------------------------------------
// Utility methods for buffer builders
//-----------------------------------------------------------------------------
inline float * OffsetFloatPointer ( float * pBufferPointer , int nVertexCount , int vertexSize )
{
return reinterpret_cast < float * > (
reinterpret_cast < unsigned char * > ( pBufferPointer ) +
nVertexCount * vertexSize ) ;
}
inline const float * OffsetFloatPointer ( const float * pBufferPointer , int nVertexCount , int vertexSize )
{
return reinterpret_cast < const float * > (
reinterpret_cast < unsigned char const * > ( pBufferPointer ) +
nVertexCount * vertexSize ) ;
}
inline void IncrementFloatPointer ( float * & pBufferPointer , int vertexSize )
{
pBufferPointer = reinterpret_cast < float * > ( reinterpret_cast < unsigned char * > ( pBufferPointer ) + vertexSize ) ;
}
//-----------------------------------------------------------------------------
// Used in lists of indexed primitives.
//-----------------------------------------------------------------------------
class CPrimList
{
public :
CPrimList ( ) ;
CPrimList ( int nFirstIndex , int nIndexCount ) ;
int m_FirstIndex ;
int m_NumIndices ;
} ;
inline CPrimList : : CPrimList ( )
{
}
inline CPrimList : : CPrimList ( int nFirstIndex , int nIndexCount )
{
m_FirstIndex = nFirstIndex ;
m_NumIndices = nIndexCount ;
}
abstract_class IVertexBuffer
{
public :
// Add a virtual destructor to silence the clang warning.
// This is harmless but not important since the only derived class
// doesn't have a destructor.
virtual ~ IVertexBuffer ( ) { }
// NOTE: The following two methods are only valid for static vertex buffers
// Returns the number of vertices and the format of the vertex buffer
virtual int VertexCount ( ) const = 0 ;
virtual VertexFormat_t GetVertexFormat ( ) const = 0 ;
// Is this vertex buffer dynamic?
virtual bool IsDynamic ( ) const = 0 ;
// NOTE: For dynamic vertex buffers only!
// Casts the memory of the dynamic vertex buffer to the appropriate type
virtual void BeginCastBuffer ( VertexFormat_t format ) = 0 ;
virtual void EndCastBuffer ( ) = 0 ;
// Returns the number of vertices that can still be written into the buffer
virtual int GetRoomRemaining ( ) const = 0 ;
virtual bool Lock ( int nVertexCount , bool bAppend , VertexDesc_t & desc ) = 0 ;
virtual void Unlock ( int nVertexCount , VertexDesc_t & desc ) = 0 ;
// Spews the mesh data
virtual void Spew ( int nVertexCount , const VertexDesc_t & desc ) = 0 ;
// Call this in debug mode to make sure our data is good.
virtual void ValidateData ( int nVertexCount , const VertexDesc_t & desc ) = 0 ;
} ;
abstract_class IIndexBuffer
{
public :
// Add a virtual destructor to silence the clang warning.
// This is harmless but not important since the only derived class
// doesn't have a destructor.
virtual ~ IIndexBuffer ( ) { }
// NOTE: The following two methods are only valid for static index buffers
// Returns the number of indices and the format of the index buffer
virtual int IndexCount ( ) const = 0 ;
virtual MaterialIndexFormat_t IndexFormat ( ) const = 0 ;
// Is this index buffer dynamic?
virtual bool IsDynamic ( ) const = 0 ;
// NOTE: For dynamic index buffers only!
// Casts the memory of the dynamic index buffer to the appropriate type
virtual void BeginCastBuffer ( MaterialIndexFormat_t format ) = 0 ;
virtual void EndCastBuffer ( ) = 0 ;
// Returns the number of indices that can still be written into the buffer
virtual int GetRoomRemaining ( ) const = 0 ;
// Locks, unlocks the index buffer
virtual bool Lock ( int nMaxIndexCount , bool bAppend , IndexDesc_t & desc ) = 0 ;
virtual void Unlock ( int nWrittenIndexCount , IndexDesc_t & desc ) = 0 ;
// FIXME: Remove this!!
// Locks, unlocks the index buffer for modify
virtual void ModifyBegin ( bool bReadOnly , int nFirstIndex , int nIndexCount , IndexDesc_t & desc ) = 0 ;
virtual void ModifyEnd ( IndexDesc_t & desc ) = 0 ;
// Spews the mesh data
virtual void Spew ( int nIndexCount , const IndexDesc_t & desc ) = 0 ;
// Ensures the data in the index buffer is valid
virtual void ValidateData ( int nIndexCount , const IndexDesc_t & desc ) = 0 ;
} ;
//-----------------------------------------------------------------------------
// Interface to the mesh - needs to contain an IVertexBuffer and an IIndexBuffer to emulate old mesh behavior
//-----------------------------------------------------------------------------
abstract_class IMesh : public IVertexBuffer , public IIndexBuffer
{
public :
// -----------------------------------
// Sets/gets the primitive type
virtual void SetPrimitiveType ( MaterialPrimitiveType_t type ) = 0 ;
// Draws the mesh
virtual void Draw ( int nFirstIndex = - 1 , int nIndexCount = 0 ) = 0 ;
virtual void SetColorMesh ( IMesh * pColorMesh , int nVertexOffset ) = 0 ;
// Draw a list of (lists of) primitives. Batching your lists together that use
// the same lightmap, material, vertex and index buffers with multipass shaders
// can drastically reduce state-switching overhead.
// NOTE: this only works with STATIC meshes.
virtual void Draw ( CPrimList * pLists , int nLists ) = 0 ;
// Copy verts and/or indices to a mesh builder. This only works for temp meshes!
virtual void CopyToMeshBuilder (
int iStartVert , // Which vertices to copy.
int nVerts ,
int iStartIndex , // Which indices to copy.
int nIndices ,
int indexOffset , // This is added to each index.
CMeshBuilder & builder ) = 0 ;
// Spews the mesh data
virtual void Spew ( int nVertexCount , int nIndexCount , const MeshDesc_t & desc ) = 0 ;
// Call this in debug mode to make sure our data is good.
virtual void ValidateData ( int nVertexCount , int nIndexCount , const MeshDesc_t & desc ) = 0 ;
// New version
// Locks/unlocks the mesh, providing space for nVertexCount and nIndexCount.
// nIndexCount of -1 means don't lock the index buffer...
virtual void LockMesh ( int nVertexCount , int nIndexCount , MeshDesc_t & desc ) = 0 ;
virtual void ModifyBegin ( int nFirstVertex , int nVertexCount , int nFirstIndex , int nIndexCount , MeshDesc_t & desc ) = 0 ;
virtual void ModifyEnd ( MeshDesc_t & desc ) = 0 ;
virtual void UnlockMesh ( int nVertexCount , int nIndexCount , MeshDesc_t & desc ) = 0 ;
virtual void ModifyBeginEx ( bool bReadOnly , int nFirstVertex , int nVertexCount , int nFirstIndex , int nIndexCount , MeshDesc_t & desc ) = 0 ;
virtual void SetFlexMesh ( IMesh * pMesh , int nVertexOffset ) = 0 ;
virtual void DisableFlexMesh ( ) = 0 ;
virtual void MarkAsDrawn ( ) = 0 ;
virtual unsigned ComputeMemoryUsed ( ) = 0 ;
} ;
# include "meshreader.h"
# define INVALID_BUFFER_OFFSET 0xFFFFFFFFUL
// flags for advancevertex optimization
# define VTX_HAVEPOS 1
# define VTX_HAVENORMAL 2
# define VTX_HAVECOLOR 4
# define VTX_HAVEALL ( VTX_HAVEPOS | VTX_HAVENORMAL | VTX_HAVECOLOR )
//-----------------------------------------------------------------------------
//
// Helper class used to define vertex buffers
//
//-----------------------------------------------------------------------------
class CVertexBuilder : private VertexDesc_t
{
public :
CVertexBuilder ( ) ;
CVertexBuilder ( IVertexBuffer * pVertexBuffer , VertexFormat_t fmt = 0 ) ;
~ CVertexBuilder ( ) ;
// Begins, ends modification of the index buffer (returns true if the lock succeeded)
// A lock may not succeed if append is set to true and there isn't enough room
// NOTE: Append is only used with dynamic index buffers; it's ignored for static buffers
bool Lock ( int nMaxIndexCount , bool bAppend = false ) ;
void Unlock ( ) ;
// Spews the current data
// NOTE: Can only be called during a lock/unlock block
void SpewData ( ) ;
// Returns the number of indices we can fit into the buffer without needing to discard
int GetRoomRemaining ( ) const ;
// Binds this vertex buffer
void Bind ( IMatRenderContext * pContext , int nStreamID , VertexFormat_t usage = 0 ) ;
// Returns the byte offset
int Offset ( ) const ;
// This must be called before Begin, if a vertex buffer with a compressed format is to be used
void SetCompressionType ( VertexCompressionType_t compressionType ) ;
void ValidateCompressionType ( ) ;
void Begin ( IVertexBuffer * pVertexBuffer , int nVertexCount , int * nFirstVertex ) ;
void Begin ( IVertexBuffer * pVertexBuffer , int nVertexCount ) ;
// Use this when you're done writing
// Set bDraw to true to call m_pMesh->Draw automatically.
void End ( bool bSpewData = false ) ;
// Locks the vertex buffer to modify existing data
// Passing nVertexCount == -1 says to lock all the vertices for modification.
void BeginModify ( IVertexBuffer * pVertexBuffer , int nFirstVertex = 0 , int nVertexCount = - 1 ) ;
void EndModify ( bool bSpewData = false ) ;
// returns the number of vertices
int VertexCount ( ) const ;
// Returns the total number of vertices across all Locks()
int TotalVertexCount ( ) const ;
// Resets the mesh builder so it points to the start of everything again
void Reset ( ) ;
// Returns the size of the vertex
int VertexSize ( ) { return m_ActualVertexSize ; }
// returns the data size of a given texture coordinate
int TextureCoordinateSize ( int nTexCoordNumber ) { return m_VertexSize_TexCoord [ nTexCoordNumber ] ; }
// Returns the base vertex memory pointer
void * BaseVertexData ( ) ;
// Selects the nth Vertex and Index
void SelectVertex ( int idx ) ;
// Advances the current vertex and index by one
void AdvanceVertex ( void ) ;
template < int nFlags , int nNumTexCoords > void AdvanceVertexF ( void ) ;
void AdvanceVertices ( int nVerts ) ;
int GetCurrentVertex ( ) const ;
int GetFirstVertex ( ) const ;
// Data retrieval...
const float * Position ( ) const ;
const float * Normal ( ) const ;
unsigned int Color ( ) const ;
unsigned char * Specular ( ) const ;
const float * TexCoord ( int stage ) const ;
const float * TangentS ( ) const ;
const float * TangentT ( ) const ;
const float * BoneWeight ( ) const ;
float Wrinkle ( ) const ;
int NumBoneWeights ( ) const ;
# ifndef NEW_SKINNING
unsigned char * BoneMatrix ( ) const ;
# else
float * BoneMatrix ( ) const ;
# endif
// position setting
void Position3f ( float x , float y , float z ) ;
void Position3fv ( const float * v ) ;
// normal setting
void Normal3f ( float nx , float ny , float nz ) ;
void Normal3fv ( const float * n ) ;
void NormalDelta3fv ( const float * n ) ;
void NormalDelta3f ( float nx , float ny , float nz ) ;
// normal setting (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedNormal3f ( float nx , float ny , float nz ) ;
template < VertexCompressionType_t T > void CompressedNormal3fv ( const float * n ) ;
// color setting
void Color3f ( float r , float g , float b ) ;
void Color3fv ( const float * rgb ) ;
void Color4f ( float r , float g , float b , float a ) ;
void Color4fv ( const float * rgba ) ;
// Faster versions of color
void Color3ub ( unsigned char r , unsigned char g , unsigned char b ) ;
void Color3ubv ( unsigned char const * rgb ) ;
void Color4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a ) ;
void Color4ubv ( unsigned char const * rgba ) ;
// specular color setting
void Specular3f ( float r , float g , float b ) ;
void Specular3fv ( const float * rgb ) ;
void Specular4f ( float r , float g , float b , float a ) ;
void Specular4fv ( const float * rgba ) ;
// Faster version of specular
void Specular3ub ( unsigned char r , unsigned char g , unsigned char b ) ;
void Specular3ubv ( unsigned char const * c ) ;
void Specular4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a ) ;
void Specular4ubv ( unsigned char const * c ) ;
// texture coordinate setting
void TexCoord1f ( int stage , float s ) ;
void TexCoord2f ( int stage , float s , float t ) ;
void TexCoord2fv ( int stage , const float * st ) ;
void TexCoord3f ( int stage , float s , float t , float u ) ;
void TexCoord3fv ( int stage , const float * stu ) ;
void TexCoord4f ( int stage , float s , float t , float u , float w ) ;
void TexCoord4fv ( int stage , const float * stuv ) ;
void TexCoordSubRect2f ( int stage , float s , float t , float offsetS , float offsetT , float scaleS , float scaleT ) ;
void TexCoordSubRect2fv ( int stage , const float * st , const float * offset , const float * scale ) ;
// tangent space
void TangentS3f ( float sx , float sy , float sz ) ;
void TangentS3fv ( const float * s ) ;
void TangentT3f ( float tx , float ty , float tz ) ;
void TangentT3fv ( const float * t ) ;
// Wrinkle
void Wrinkle1f ( float flWrinkle ) ;
// bone weights
void BoneWeight ( int idx , float weight ) ;
// bone weights (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedBoneWeight3fv ( const float * pWeights ) ;
// bone matrix index
void BoneMatrix ( int idx , int matrixIndex ) ;
// Generic per-vertex data
void UserData ( const float * pData ) ;
// Generic per-vertex data (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedUserData ( const float * pData ) ;
// Fast Vertex! No need to call advance vertex, and no random access allowed.
// WARNING - these are low level functions that are intended only for use
// in the software vertex skinner.
void FastVertex ( const ModelVertexDX7_t & vertex ) ;
void FastVertexSSE ( const ModelVertexDX7_t & vertex ) ;
// store 4 dx7 vertices fast. for special sse dx7 pipeline
void Fast4VerticesSSE (
ModelVertexDX7_t const * vtx_a ,
ModelVertexDX7_t const * vtx_b ,
ModelVertexDX7_t const * vtx_c ,
ModelVertexDX7_t const * vtx_d ) ;
void FastVertex ( const ModelVertexDX8_t & vertex ) ;
void FastVertexSSE ( const ModelVertexDX8_t & vertex ) ;
// Add number of verts and current vert since FastVertex routines do not update.
void FastAdvanceNVertices ( int n ) ;
# if defined( _X360 )
void VertexDX8ToX360 ( const ModelVertexDX8_t & vertex ) ;
# endif
// FIXME: Remove! Backward compat so we can use this from a CMeshBuilder.
void AttachBegin ( IMesh * pMesh , int nMaxVertexCount , const MeshDesc_t & desc ) ;
void AttachEnd ( ) ;
void AttachBeginModify ( IMesh * pMesh , int nFirstVertex , int nVertexCount , const MeshDesc_t & desc ) ;
void AttachEndModify ( ) ;
private :
// The vertex buffer we're modifying
IVertexBuffer * m_pVertexBuffer ;
// Used to make sure Begin/End calls and BeginModify/EndModify calls match.
bool m_bModify ;
// Max number of indices and vertices
int m_nMaxVertexCount ;
// Number of indices and vertices
int m_nVertexCount ;
// The current vertex and index
mutable int m_nCurrentVertex ;
// Optimization: Pointer to the current pos, norm, texcoord, and color
mutable float * m_pCurrPosition ;
mutable float * m_pCurrNormal ;
mutable float * m_pCurrTexCoord [ VERTEX_MAX_TEXTURE_COORDINATES ] ;
mutable unsigned char * m_pCurrColor ;
// Total number of vertices appended
int m_nTotalVertexCount ;
// First vertex buffer offset + index
unsigned int m_nBufferOffset ;
unsigned int m_nBufferFirstVertex ;
# if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
// Debug checks to make sure we write userdata4/tangents AFTER normals
bool m_bWrittenNormal : 1 ;
bool m_bWrittenUserData : 1 ;
# endif
friend class CMeshBuilder ;
} ;
//-----------------------------------------------------------------------------
//
// Inline methods of CVertexBuilder
//
//-----------------------------------------------------------------------------
inline CVertexBuilder : : CVertexBuilder ( )
{
m_pVertexBuffer = NULL ;
m_nBufferOffset = INVALID_BUFFER_OFFSET ;
m_nBufferFirstVertex = 0 ;
m_nVertexCount = 0 ;
m_nCurrentVertex = 0 ;
m_nMaxVertexCount = 0 ;
m_nTotalVertexCount = 0 ;
m_CompressionType = VERTEX_COMPRESSION_INVALID ;
# ifdef _DEBUG
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
m_bModify = false ;
# endif
}
inline CVertexBuilder : : CVertexBuilder ( IVertexBuffer * pVertexBuffer , VertexFormat_t fmt )
{
m_pVertexBuffer = pVertexBuffer ;
m_nBufferOffset = INVALID_BUFFER_OFFSET ;
m_nBufferFirstVertex = 0 ;
m_nVertexCount = 0 ;
m_nCurrentVertex = 0 ;
m_nMaxVertexCount = 0 ;
m_nTotalVertexCount = 0 ;
m_CompressionType = VERTEX_COMPRESSION_INVALID ;
if ( m_pVertexBuffer - > IsDynamic ( ) )
{
m_pVertexBuffer - > BeginCastBuffer ( fmt ) ;
}
else
{
Assert ( m_pVertexBuffer - > GetVertexFormat ( ) = = fmt ) ;
}
# ifdef _DEBUG
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
m_bModify = false ;
# endif
}
inline CVertexBuilder : : ~ CVertexBuilder ( )
{
if ( m_pVertexBuffer & & m_pVertexBuffer - > IsDynamic ( ) )
{
m_pVertexBuffer - > EndCastBuffer ( ) ;
}
}
//-----------------------------------------------------------------------------
// Begins, ends modification of the index buffer
//-----------------------------------------------------------------------------
inline bool CVertexBuilder : : Lock ( int nMaxVertexCount , bool bAppend )
{
Assert ( m_pVertexBuffer ) ;
m_bModify = false ;
m_nMaxVertexCount = nMaxVertexCount ;
bool bFirstLock = ( m_nBufferOffset = = INVALID_BUFFER_OFFSET ) ;
if ( bFirstLock )
{
bAppend = false ;
}
if ( ! bAppend )
{
m_nTotalVertexCount = 0 ;
}
// Lock the vertex buffer
if ( ! m_pVertexBuffer - > Lock ( m_nMaxVertexCount , bAppend , * this ) )
{
m_nMaxVertexCount = 0 ;
return false ;
}
Reset ( ) ;
if ( bFirstLock )
{
m_nBufferOffset = m_nOffset ;
m_nBufferFirstVertex = m_nFirstVertex ;
}
return true ;
}
inline void CVertexBuilder : : Unlock ( )
{
Assert ( ! m_bModify & & m_pVertexBuffer ) ;
# ifdef _DEBUG
m_pVertexBuffer - > ValidateData ( m_nVertexCount , * this ) ;
# endif
m_pVertexBuffer - > Unlock ( m_nVertexCount , * this ) ;
m_nTotalVertexCount + = m_nVertexCount ;
m_nMaxVertexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
memset ( static_cast < VertexDesc_t * > ( this ) , 0 , sizeof ( VertexDesc_t ) ) ;
# endif
}
inline void CVertexBuilder : : SpewData ( )
{
m_pVertexBuffer - > Spew ( m_nVertexCount , * this ) ;
}
//-----------------------------------------------------------------------------
// Binds this vertex buffer
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Bind ( IMatRenderContext * pContext , int nStreamID , VertexFormat_t usage )
{
if ( m_pVertexBuffer & & ( m_nBufferOffset ! = INVALID_BUFFER_OFFSET ) )
{
pContext - > BindVertexBuffer ( nStreamID , m_pVertexBuffer , m_nBufferOffset ,
m_nFirstVertex , m_nTotalVertexCount , usage ? usage : m_pVertexBuffer - > GetVertexFormat ( ) ) ;
}
else
{
pContext - > BindVertexBuffer ( nStreamID , NULL , 0 , 0 , 0 , 0 ) ;
}
}
//-----------------------------------------------------------------------------
// Returns the byte offset
//-----------------------------------------------------------------------------
inline int CVertexBuilder : : Offset ( ) const
{
return m_nBufferOffset ;
}
inline int CVertexBuilder : : GetFirstVertex ( ) const
{
return m_nBufferFirstVertex ;
}
//-----------------------------------------------------------------------------
// Specify the type of vertex compression that this CMeshBuilder will perform
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : SetCompressionType ( VertexCompressionType_t compressionType )
{
// The real purpose of this method is to allow us to emit a Warning in Begin()
m_CompressionType = compressionType ;
}
inline void CVertexBuilder : : ValidateCompressionType ( )
{
# ifdef _DEBUG
VertexCompressionType_t vbCompressionType = CompressionType ( m_pVertexBuffer - > GetVertexFormat ( ) ) ;
if ( vbCompressionType ! = VERTEX_COMPRESSION_NONE )
{
Assert ( m_CompressionType = = vbCompressionType ) ;
if ( m_CompressionType ! = vbCompressionType )
{
Warning ( " ERROR: CVertexBuilder::SetCompressionType() must be called to specify the same vertex compression type (%s) as the vertex buffer being modified. "
" Junk vertices will be rendered, or there will be a crash in CVertexBuilder! \n " ,
vbCompressionType = = VERTEX_COMPRESSION_ON ? " VERTEX_COMPRESSION_ON " : " VERTEX_COMPRESSION_NONE " ) ;
}
// Never use vertex compression for dynamic VBs (the conversions can really hurt perf)
Assert ( ! m_pVertexBuffer - > IsDynamic ( ) ) ;
}
# endif
}
inline void CVertexBuilder : : Begin ( IVertexBuffer * pVertexBuffer , int nVertexCount )
{
Assert ( pVertexBuffer & & ( ! m_pVertexBuffer ) ) ;
m_pVertexBuffer = pVertexBuffer ;
m_bModify = false ;
m_nMaxVertexCount = nVertexCount ;
m_nVertexCount = 0 ;
// Make sure SetCompressionType was called correctly, if this VB is compressed
ValidateCompressionType ( ) ;
// Lock the vertex and index buffer
m_pVertexBuffer - > Lock ( m_nMaxVertexCount , false , * this ) ;
// Point to the start of the buffers..
Reset ( ) ;
}
//-----------------------------------------------------------------------------
// Use this when you're done modifying the mesh
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : End ( bool bSpewData )
{
// Make sure they called Begin()
Assert ( ! m_bModify ) ;
if ( bSpewData )
{
m_pVertexBuffer - > Spew ( m_nVertexCount , * this ) ;
}
# ifdef _DEBUG
m_pVertexBuffer - > ValidateData ( m_nVertexCount , * this ) ;
# endif
// Unlock our buffers
m_pVertexBuffer - > Unlock ( m_nVertexCount , * this ) ;
m_pVertexBuffer = 0 ;
m_nMaxVertexCount = 0 ;
m_CompressionType = VERTEX_COMPRESSION_INVALID ;
# ifdef _DEBUG
// Null out our pointers...
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
memset ( static_cast < VertexDesc_t * > ( this ) , 0 , sizeof ( VertexDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// FIXME: Remove! Backward compat so we can use this from a CMeshBuilder.
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : AttachBegin ( IMesh * pMesh , int nMaxVertexCount , const MeshDesc_t & desc )
{
VertexCompressionType_t compressionType = m_CompressionType ;
m_pVertexBuffer = pMesh ;
memcpy ( static_cast < VertexDesc_t * > ( this ) , static_cast < const VertexDesc_t * > ( & desc ) , sizeof ( VertexDesc_t ) ) ;
m_nMaxVertexCount = nMaxVertexCount ;
m_NumBoneWeights = m_NumBoneWeights = = 0 ? 0 : 2 ; // Two weights if any
m_nVertexCount = 0 ;
m_bModify = false ;
if ( compressionType ! = VERTEX_COMPRESSION_INVALID )
m_CompressionType = compressionType ;
// Make sure SetCompressionType was called correctly, if this VB is compressed
ValidateCompressionType ( ) ;
if ( m_nBufferOffset = = INVALID_BUFFER_OFFSET )
{
m_nTotalVertexCount = 0 ;
m_nBufferOffset = static_cast < const VertexDesc_t * > ( & desc ) - > m_nOffset ;
m_nBufferFirstVertex = desc . m_nFirstVertex ;
}
}
inline void CVertexBuilder : : AttachEnd ( )
{
// Make sure they called Begin()
Assert ( ! m_bModify ) ;
m_nMaxVertexCount = 0 ;
m_pVertexBuffer = NULL ;
m_CompressionType = VERTEX_COMPRESSION_INVALID ;
# ifdef _DEBUG
// Null out our pointers...
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
memset ( static_cast < VertexDesc_t * > ( this ) , 0 , sizeof ( VertexDesc_t ) ) ;
# endif
}
inline void CVertexBuilder : : AttachBeginModify ( IMesh * pMesh , int nFirstVertex , int nVertexCount , const MeshDesc_t & desc )
{
Assert ( pMesh & & ( ! m_pVertexBuffer ) ) ;
m_pVertexBuffer = pMesh ;
memcpy ( static_cast < VertexDesc_t * > ( this ) , static_cast < const VertexDesc_t * > ( & desc ) , sizeof ( VertexDesc_t ) ) ;
m_nMaxVertexCount = m_nVertexCount = nVertexCount ;
m_NumBoneWeights = m_NumBoneWeights = = 0 ? 0 : 2 ; // Two weights if any
m_bModify = true ;
// Make sure SetCompressionType was called correctly, if this VB is compressed
ValidateCompressionType ( ) ;
}
inline void CVertexBuilder : : AttachEndModify ( )
{
Assert ( m_pVertexBuffer ) ;
Assert ( m_bModify ) ; // Make sure they called BeginModify.
m_pVertexBuffer = 0 ;
m_nMaxVertexCount = 0 ;
m_CompressionType = VERTEX_COMPRESSION_INVALID ;
# ifdef _DEBUG
// Null out our pointers...
m_pCurrPosition = NULL ;
m_pCurrNormal = NULL ;
m_pCurrColor = NULL ;
memset ( m_pCurrTexCoord , 0 , sizeof ( m_pCurrTexCoord ) ) ;
memset ( static_cast < VertexDesc_t * > ( this ) , 0 , sizeof ( VertexDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// Computes the first min non-null address
//-----------------------------------------------------------------------------
inline unsigned char * FindMinAddress ( void * pAddress1 , void * pAddress2 , int nAddress2Size )
{
if ( nAddress2Size = = 0 )
return ( unsigned char * ) pAddress1 ;
if ( ! pAddress1 )
return ( unsigned char * ) pAddress2 ;
return ( pAddress1 < pAddress2 ) ? ( unsigned char * ) pAddress1 : ( unsigned char * ) pAddress2 ;
}
//-----------------------------------------------------------------------------
// Resets the vertex buffer builder so it points to the start of everything again
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Reset ( )
{
m_nCurrentVertex = 0 ;
m_pCurrPosition = m_pPosition ;
m_pCurrNormal = m_pNormal ;
for ( int i = 0 ; i < NELEMS ( m_pCurrTexCoord ) ; i + + )
{
m_pCurrTexCoord [ i ] = m_pTexCoord [ i ] ;
}
m_pCurrColor = m_pColor ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
# ifdef DEBUG_WRITE_COMBINE
// Logic for m_pLastWrittenAddress is tricky. It really wants the min of the
// non-null address pointers.
m_nLastWrittenField = MB_FIELD_NONE ;
m_pLastWrittenAddress = NULL ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pPosition , m_VertexSize_Position ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pBoneWeight , m_VertexSize_BoneWeight ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pBoneMatrixIndex , m_VertexSize_BoneMatrixIndex ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pNormal , m_VertexSize_Normal ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pColor , m_VertexSize_Color ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pSpecular , m_VertexSize_Specular ) ;
for ( int i = 0 ; i < VERTEX_MAX_TEXTURE_COORDINATES ; + + i )
{
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pTexCoord [ i ] , m_VertexSize_TexCoord [ i ] ) ;
}
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pTangentS , m_VertexSize_TangentS ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pTangentT , m_VertexSize_TangentT ) ;
m_pLastWrittenAddress = FindMinAddress ( m_pLastWrittenAddress , m_pUserData , m_VertexSize_UserData ) ;
# endif
}
//-----------------------------------------------------------------------------
// returns the number of vertices
//-----------------------------------------------------------------------------
inline int CVertexBuilder : : VertexCount ( ) const
{
return m_nVertexCount ;
}
//-----------------------------------------------------------------------------
// Returns the total number of vertices across all Locks()
//-----------------------------------------------------------------------------
inline int CVertexBuilder : : TotalVertexCount ( ) const
{
return m_nTotalVertexCount ;
}
//-----------------------------------------------------------------------------
// Returns the base vertex memory pointer
//-----------------------------------------------------------------------------
inline void * CVertexBuilder : : BaseVertexData ( )
{
// FIXME: If there's no position specified, we need to find
// the base address
Assert ( m_pPosition ) ;
return m_pPosition ;
}
//-----------------------------------------------------------------------------
// Selects the current vertex
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : SelectVertex ( int nIndex )
{
// NOTE: This index is expected to be relative
Assert ( ( nIndex > = 0 ) & & ( nIndex < m_nMaxVertexCount ) ) ;
m_nCurrentVertex = nIndex ;
m_pCurrPosition = OffsetFloatPointer ( m_pPosition , m_nCurrentVertex , m_VertexSize_Position ) ;
m_pCurrNormal = OffsetFloatPointer ( m_pNormal , m_nCurrentVertex , m_VertexSize_Normal ) ;
COMPILE_TIME_ASSERT ( VERTEX_MAX_TEXTURE_COORDINATES = = 8 ) ;
m_pCurrTexCoord [ 0 ] = OffsetFloatPointer ( m_pTexCoord [ 0 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 0 ] ) ;
m_pCurrTexCoord [ 1 ] = OffsetFloatPointer ( m_pTexCoord [ 1 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 1 ] ) ;
m_pCurrTexCoord [ 2 ] = OffsetFloatPointer ( m_pTexCoord [ 2 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 2 ] ) ;
m_pCurrTexCoord [ 3 ] = OffsetFloatPointer ( m_pTexCoord [ 3 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 3 ] ) ;
m_pCurrTexCoord [ 4 ] = OffsetFloatPointer ( m_pTexCoord [ 4 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 4 ] ) ;
m_pCurrTexCoord [ 5 ] = OffsetFloatPointer ( m_pTexCoord [ 5 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 5 ] ) ;
m_pCurrTexCoord [ 6 ] = OffsetFloatPointer ( m_pTexCoord [ 6 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 6 ] ) ;
m_pCurrTexCoord [ 7 ] = OffsetFloatPointer ( m_pTexCoord [ 7 ] , m_nCurrentVertex , m_VertexSize_TexCoord [ 7 ] ) ;
m_pCurrColor = m_pColor + m_nCurrentVertex * m_VertexSize_Color ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
//-----------------------------------------------------------------------------
// Advances vertex after you're done writing to it.
//-----------------------------------------------------------------------------
template < int nFlags , int nNumTexCoords > FORCEINLINE void CVertexBuilder : : AdvanceVertexF ( )
{
if ( + + m_nCurrentVertex > m_nVertexCount )
{
m_nVertexCount = m_nCurrentVertex ;
}
if ( nFlags & VTX_HAVEPOS )
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
if ( nFlags & VTX_HAVENORMAL )
IncrementFloatPointer ( m_pCurrNormal , m_VertexSize_Normal ) ;
if ( nFlags & VTX_HAVECOLOR )
m_pCurrColor + = m_VertexSize_Color ;
COMPILE_TIME_ASSERT ( VERTEX_MAX_TEXTURE_COORDINATES = = 8 ) ;
if ( nNumTexCoords > 0 )
IncrementFloatPointer ( m_pCurrTexCoord [ 0 ] , m_VertexSize_TexCoord [ 0 ] ) ;
if ( nNumTexCoords > 1 )
IncrementFloatPointer ( m_pCurrTexCoord [ 1 ] , m_VertexSize_TexCoord [ 1 ] ) ;
if ( nNumTexCoords > 2 )
IncrementFloatPointer ( m_pCurrTexCoord [ 2 ] , m_VertexSize_TexCoord [ 2 ] ) ;
if ( nNumTexCoords > 3 )
IncrementFloatPointer ( m_pCurrTexCoord [ 3 ] , m_VertexSize_TexCoord [ 3 ] ) ;
if ( nNumTexCoords > 4 )
IncrementFloatPointer ( m_pCurrTexCoord [ 4 ] , m_VertexSize_TexCoord [ 4 ] ) ;
if ( nNumTexCoords > 5 )
IncrementFloatPointer ( m_pCurrTexCoord [ 5 ] , m_VertexSize_TexCoord [ 5 ] ) ;
if ( nNumTexCoords > 6 )
IncrementFloatPointer ( m_pCurrTexCoord [ 6 ] , m_VertexSize_TexCoord [ 6 ] ) ;
if ( nNumTexCoords > 7 )
IncrementFloatPointer ( m_pCurrTexCoord [ 7 ] , m_VertexSize_TexCoord [ 7 ] ) ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
inline void CVertexBuilder : : AdvanceVertex ( )
{
AdvanceVertexF < VTX_HAVEALL , 8 > ( ) ;
}
inline void CVertexBuilder : : AdvanceVertices ( int nVerts )
{
m_nCurrentVertex + = nVerts ;
if ( m_nCurrentVertex > m_nVertexCount )
{
m_nVertexCount = m_nCurrentVertex ;
}
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position * nVerts ) ;
IncrementFloatPointer ( m_pCurrNormal , m_VertexSize_Normal * nVerts ) ;
COMPILE_TIME_ASSERT ( VERTEX_MAX_TEXTURE_COORDINATES = = 8 ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 0 ] , m_VertexSize_TexCoord [ 0 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 1 ] , m_VertexSize_TexCoord [ 1 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 2 ] , m_VertexSize_TexCoord [ 2 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 3 ] , m_VertexSize_TexCoord [ 3 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 4 ] , m_VertexSize_TexCoord [ 4 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 5 ] , m_VertexSize_TexCoord [ 5 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 6 ] , m_VertexSize_TexCoord [ 6 ] * nVerts ) ;
IncrementFloatPointer ( m_pCurrTexCoord [ 7 ] , m_VertexSize_TexCoord [ 7 ] * nVerts ) ;
m_pCurrColor + = m_VertexSize_Color * nVerts ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
//-----------------------------------------------------------------------------
// For use with the FastVertex methods, advances the current vertex by N
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : FastAdvanceNVertices ( int n )
{
m_nCurrentVertex + = n ;
m_nVertexCount = m_nCurrentVertex ;
}
# ifndef COMPILER_MSVC64
// Implement for 64-bit Windows if needed.
//-----------------------------------------------------------------------------
// Fast Vertex! No need to call advance vertex, and no random access allowed
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : FastVertex ( const ModelVertexDX7_t & vertex )
{
# ifdef __arm__
FastVertexSSE ( vertex ) ;
# else
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
# if defined( _WIN32 ) && !defined( _X360 )
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm
{
mov esi , pRead
mov edi , pCurrPos
movq mm0 , [ esi + 0 ]
movq mm1 , [ esi + 8 ]
movq mm2 , [ esi + 16 ]
movq mm3 , [ esi + 24 ]
movq mm4 , [ esi + 32 ]
movq mm5 , [ esi + 40 ]
movntq [ edi + 0 ] , mm0
movntq [ edi + 8 ] , mm1
movntq [ edi + 16 ] , mm2
movntq [ edi + 24 ] , mm3
movntq [ edi + 32 ] , mm4
movntq [ edi + 40 ] , mm5
emms
}
# elif defined(GNUC)
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm__ __volatile__ (
" movq (%0), %%mm0 \n "
" movq 8(%0), %%mm1 \n "
" movq 16(%0), %%mm2 \n "
" movq 24(%0), %%mm3 \n "
" movq 32(%0), %%mm4 \n "
" movq 40(%0), %%mm5 \n "
" movntq %%mm0, (%1) \n "
" movntq %%mm1, 8(%1) \n "
" movntq %%mm2, 16(%1) \n "
" movntq %%mm3, 24(%1) \n "
" movntq %%mm4, 32(%1) \n "
" movntq %%mm5, 40(%1) \n "
" emms \n "
: : " r " ( pRead ) , " r " ( pCurrPos ) : " memory " ) ;
# else
Error ( " Implement CMeshBuilder::FastVertex(dx7) " ) ;
# endif
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
//m_nVertexCount = ++m_nCurrentVertex;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
# endif
}
inline void CVertexBuilder : : FastVertexSSE ( const ModelVertexDX7_t & vertex )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
# if defined( _WIN32 ) && !defined( _X360 )
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm
{
mov esi , pRead
mov edi , pCurrPos
movaps xmm0 , [ esi + 0 ]
movaps xmm1 , [ esi + 16 ]
movaps xmm2 , [ esi + 32 ]
movntps [ edi + 0 ] , xmm0
movntps [ edi + 16 ] , xmm1
movntps [ edi + 32 ] , xmm2
}
# elif defined(GNUC)
const char * pRead = ( char * ) & vertex ;
char * pCurrPos = ( char * ) m_pCurrPosition ;
__m128 m1 = _mm_load_ps ( ( float * ) pRead ) ;
__m128 m2 = _mm_load_ps ( ( float * ) ( pRead + 16 ) ) ;
__m128 m3 = _mm_load_ps ( ( float * ) ( pRead + 32 ) ) ;
_mm_stream_ps ( ( float * ) pCurrPos , m1 ) ;
_mm_stream_ps ( ( float * ) ( pCurrPos + 16 ) , m2 ) ;
_mm_stream_ps ( ( float * ) ( pCurrPos + 32 ) , m3 ) ;
# else
Error ( " Implement CMeshBuilder::FastVertexSSE(dx7) " ) ;
# endif
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
//m_nVertexCount = ++m_nCurrentVertex;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
inline void CVertexBuilder : : Fast4VerticesSSE (
ModelVertexDX7_t const * vtx_a ,
ModelVertexDX7_t const * vtx_b ,
ModelVertexDX7_t const * vtx_c ,
ModelVertexDX7_t const * vtx_d )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount - 3 ) ;
# if defined( _WIN32 ) && !defined( _X360 )
void * pCurrPos = m_pCurrPosition ;
__asm
{
mov esi , vtx_a
mov ecx , vtx_b
mov edi , pCurrPos
nop
movaps xmm0 , [ esi + 0 ]
movaps xmm1 , [ esi + 16 ]
movaps xmm2 , [ esi + 32 ]
movaps xmm3 , [ ecx + 0 ]
movaps xmm4 , [ ecx + 16 ]
movaps xmm5 , [ ecx + 32 ]
mov esi , vtx_c
mov ecx , vtx_d
movntps [ edi + 0 ] , xmm0
movntps [ edi + 16 ] , xmm1
movntps [ edi + 32 ] , xmm2
movntps [ edi + 48 ] , xmm3
movntps [ edi + 64 ] , xmm4
movntps [ edi + 80 ] , xmm5
movaps xmm0 , [ esi + 0 ]
movaps xmm1 , [ esi + 16 ]
movaps xmm2 , [ esi + 32 ]
movaps xmm3 , [ ecx + 0 ]
movaps xmm4 , [ ecx + 16 ]
movaps xmm5 , [ ecx + 32 ]
movntps [ edi + 0 + 96 ] , xmm0
movntps [ edi + 16 + 96 ] , xmm1
movntps [ edi + 32 + 96 ] , xmm2
movntps [ edi + 48 + 96 ] , xmm3
movntps [ edi + 64 + 96 ] , xmm4
movntps [ edi + 80 + 96 ] , xmm5
}
# else
Error ( " Implement CMeshBuilder::Fast4VerticesSSE \n " ) ;
# endif
IncrementFloatPointer ( m_pCurrPosition , 4 * m_VertexSize_Position ) ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
inline void CVertexBuilder : : FastVertex ( const ModelVertexDX8_t & vertex )
{
# ifdef __arm__
FastVertexSSE ( vertex ) ;
# else
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
# if defined( _WIN32 ) && !defined( _X360 )
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm
{
mov esi , pRead
mov edi , pCurrPos
movq mm0 , [ esi + 0 ]
movq mm1 , [ esi + 8 ]
movq mm2 , [ esi + 16 ]
movq mm3 , [ esi + 24 ]
movq mm4 , [ esi + 32 ]
movq mm5 , [ esi + 40 ]
movq mm6 , [ esi + 48 ]
movq mm7 , [ esi + 56 ]
movntq [ edi + 0 ] , mm0
movntq [ edi + 8 ] , mm1
movntq [ edi + 16 ] , mm2
movntq [ edi + 24 ] , mm3
movntq [ edi + 32 ] , mm4
movntq [ edi + 40 ] , mm5
movntq [ edi + 48 ] , mm6
movntq [ edi + 56 ] , mm7
emms
}
# elif defined(GNUC)
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm__ __volatile__ (
" movq (%0), %%mm0 \n "
" movq 8(%0), %%mm1 \n "
" movq 16(%0), %%mm2 \n "
" movq 24(%0), %%mm3 \n "
" movq 32(%0), %%mm4 \n "
" movq 40(%0), %%mm5 \n "
" movq 48(%0), %%mm6 \n "
" movq 56(%0), %%mm7 \n "
" movntq %%mm0, (%1) \n "
" movntq %%mm1, 8(%1) \n "
" movntq %%mm2, 16(%1) \n "
" movntq %%mm3, 24(%1) \n "
" movntq %%mm4, 32(%1) \n "
" movntq %%mm5, 40(%1) \n "
" movntq %%mm6, 48(%1) \n "
" movntq %%mm7, 56(%1) \n "
" emms \n "
: : " r " ( pRead ) , " r " ( pCurrPos ) : " memory " ) ;
# else
Error ( " Implement CMeshBuilder::FastVertex(dx8) " ) ;
# endif
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
// m_nVertexCount = ++m_nCurrentVertex;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
# endif
}
inline void CVertexBuilder : : FastVertexSSE ( const ModelVertexDX8_t & vertex )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
# if defined( _WIN32 ) && !defined( _X360 )
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
__asm
{
mov esi , pRead
mov edi , pCurrPos
movaps xmm0 , [ esi + 0 ]
movaps xmm1 , [ esi + 16 ]
movaps xmm2 , [ esi + 32 ]
movaps xmm3 , [ esi + 48 ]
movntps [ edi + 0 ] , xmm0
movntps [ edi + 16 ] , xmm1
movntps [ edi + 32 ] , xmm2
movntps [ edi + 48 ] , xmm3
}
# elif defined(GNUC)
const void * pRead = & vertex ;
void * pCurrPos = m_pCurrPosition ;
/* __asm__ __volatile__ (
" movaps (%0), %%xmm0 \n "
" movaps 16(%0), %%xmm1 \n "
" movaps 32(%0), %%xmm2 \n "
" movaps 48(%0), %%xmm3 \n "
" movntps %%xmm0, (%1) \n "
" movntps %%xmm1, 16(%1) \n "
" movntps %%xmm2, 32(%1) \n "
" movntps %%xmm3, 48(%1) \n "
: : " r " ( pRead ) , " r " ( pCurrPos ) : " memory " ) ; */
__m128 m1 = _mm_load_ps ( ( float * ) pRead ) ;
__m128 m2 = _mm_load_ps ( ( float * ) ( pRead + 16 ) ) ;
__m128 m3 = _mm_load_ps ( ( float * ) ( pRead + 32 ) ) ;
__m128 m4 = _mm_load_ps ( ( float * ) ( pRead + 48 ) ) ;
_mm_stream_ps ( ( float * ) pCurrPos , m1 ) ;
_mm_stream_ps ( ( float * ) ( pCurrPos + 16 ) , m2 ) ;
_mm_stream_ps ( ( float * ) ( pCurrPos + 32 ) , m3 ) ;
_mm_stream_ps ( ( float * ) ( pCurrPos + 48 ) , m4 ) ;
# else
Error ( " Implement CMeshBuilder::FastVertexSSE((dx8) " ) ;
# endif
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
// m_nVertexCount = ++m_nCurrentVertex;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
# endif // COMPILER_MSVC64
//-----------------------------------------------------------------------------
// Returns the current vertex
//-----------------------------------------------------------------------------
inline int CVertexBuilder : : GetCurrentVertex ( ) const
{
return m_nCurrentVertex ;
}
//-----------------------------------------------------------------------------
// Copies a vertex into the x360 format
//-----------------------------------------------------------------------------
# if defined( _X360 )
inline void CVertexBuilder : : VertexDX8ToX360 ( const ModelVertexDX8_t & vertex )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // FIXME: support compressed verts if needed
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
// get the start of the data
unsigned char * pDst = ( unsigned char * ) m_pCurrPosition ;
Assert ( m_VertexSize_Position > 0 ) ; // Assume position is always present
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_POSITION , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_vecPosition ) ) ;
memcpy ( pDst , vertex . m_vecPosition . Base ( ) , sizeof ( vertex . m_vecPosition ) ) ;
pDst + = sizeof ( vertex . m_vecPosition ) ;
if ( m_VertexSize_BoneWeight )
{
Assert ( vertex . m_flBoneWeights [ 0 ] > = 0 & & vertex . m_flBoneWeights [ 0 ] < = 1.0f ) ;
Assert ( vertex . m_flBoneWeights [ 1 ] > = 0 & & vertex . m_flBoneWeights [ 1 ] < = 1.0f ) ;
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_BONEWEIGHTS2 , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_flBoneWeights ) ) ;
memcpy ( pDst , vertex . m_flBoneWeights . Base ( ) , sizeof ( vertex . m_flBoneWeights ) ) ;
pDst + = sizeof ( vertex . m_flBoneWeights ) ;
if ( m_VertexSize_BoneMatrixIndex )
{
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_BONEINDEX , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_nBoneIndices ) ) ;
* ( unsigned int * ) pDst = vertex . m_nBoneIndices ;
pDst + = sizeof ( vertex . m_nBoneIndices ) ;
}
}
if ( m_VertexSize_Normal )
{
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_NORMAL , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_vecNormal ) ) ;
memcpy ( pDst , vertex . m_vecNormal . Base ( ) , sizeof ( vertex . m_vecNormal ) ) ;
pDst + = sizeof ( vertex . m_vecNormal ) ;
}
if ( m_VertexSize_Color )
{
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_COLOR , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_nColor ) ) ;
* ( unsigned int * ) pDst = vertex . m_nColor ;
pDst + = sizeof ( vertex . m_nColor ) ;
}
if ( m_VertexSize_TexCoord [ 0 ] )
{
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_TEXCOORD2D_0 , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_vecTexCoord ) ) ;
memcpy ( pDst , vertex . m_vecTexCoord . Base ( ) , sizeof ( vertex . m_vecTexCoord ) ) ;
pDst + = sizeof ( vertex . m_vecTexCoord ) ;
}
if ( m_VertexSize_UserData )
{
Assert ( GetVertexElementSize ( VERTEX_ELEMENT_USERDATA4 , VERTEX_COMPRESSION_NONE ) = = sizeof ( vertex . m_vecUserData ) ) ;
memcpy ( pDst , vertex . m_vecUserData . Base ( ) , sizeof ( vertex . m_vecUserData ) ) ;
pDst + = sizeof ( vertex . m_vecUserData ) ;
}
// ensure code is synced with the mesh builder that established the offsets
Assert ( pDst - ( unsigned char * ) m_pCurrPosition = = m_VertexSize_Position ) ;
IncrementFloatPointer ( m_pCurrPosition , m_VertexSize_Position ) ;
# if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
m_bWrittenNormal = false ;
m_bWrittenUserData = false ;
# endif
}
# endif
//-----------------------------------------------------------------------------
// Data retrieval...
//-----------------------------------------------------------------------------
inline const float * CVertexBuilder : : Position ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pCurrPosition ;
}
inline const float * CVertexBuilder : : Normal ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pCurrNormal ;
}
inline unsigned int CVertexBuilder : : Color ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
// Swizzle it so it returns the same format as accepted by Color4ubv - rgba
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
unsigned int color ;
if ( IsPC ( ) | | ! IsX360 ( ) )
{
color = ( m_pCurrColor [ 3 ] < < 24 ) | ( m_pCurrColor [ 0 ] < < 16 ) | ( m_pCurrColor [ 1 ] < < 8 ) | ( m_pCurrColor [ 2 ] ) ;
}
else
{
// in memory as argb, back to rgba
color = ( m_pCurrColor [ 1 ] < < 24 ) | ( m_pCurrColor [ 2 ] < < 16 ) | ( m_pCurrColor [ 3 ] < < 8 ) | ( m_pCurrColor [ 0 ] ) ;
}
return color ;
}
inline unsigned char * CVertexBuilder : : Specular ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pSpecular + m_nCurrentVertex * m_VertexSize_Specular ;
}
inline const float * CVertexBuilder : : TexCoord ( int stage ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pCurrTexCoord [ stage ] ;
}
inline const float * CVertexBuilder : : TangentS ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return OffsetFloatPointer ( m_pTangentS , m_nCurrentVertex , m_VertexSize_TangentS ) ;
}
inline const float * CVertexBuilder : : TangentT ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return OffsetFloatPointer ( m_pTangentT , m_nCurrentVertex , m_VertexSize_TangentT ) ;
}
inline float CVertexBuilder : : Wrinkle ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return * OffsetFloatPointer ( m_pWrinkle , m_nCurrentVertex , m_VertexSize_Wrinkle ) ;
}
inline const float * CVertexBuilder : : BoneWeight ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return OffsetFloatPointer ( m_pBoneWeight , m_nCurrentVertex , m_VertexSize_BoneWeight ) ;
}
inline int CVertexBuilder : : NumBoneWeights ( ) const
{
return m_NumBoneWeights ;
}
# ifndef NEW_SKINNING
inline unsigned char * CVertexBuilder : : BoneMatrix ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pBoneMatrixIndex + m_nCurrentVertex * m_VertexSize_BoneMatrixIndex ;
}
# else
inline float * CVertexBuilder : : BoneMatrix ( ) const
{
// FIXME: add a templatized accessor (return type varies to ensure calling code is updated appropriately)
// for code that needs to access compressed data (and/or a return-by-value templatized accessor)
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ;
Assert ( m_nCurrentVertex < m_nMaxVertexCount ) ;
return m_pBoneMatrixIndex + m_nCurrentVertex * m_VertexSize_BoneMatrixIndex ;
}
# endif
//-----------------------------------------------------------------------------
// Position setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Position3f ( float x , float y , float z )
{
Assert ( m_pPosition & & m_pCurrPosition ) ;
Assert ( IsFinite ( x ) & & IsFinite ( y ) & & IsFinite ( z ) ) ;
float * pDst = m_pCurrPosition ;
* pDst + + = x ;
* pDst + + = y ;
* pDst = z ;
}
inline void CVertexBuilder : : Position3fv ( const float * v )
{
Assert ( v ) ;
Assert ( m_pPosition & & m_pCurrPosition ) ;
float * pDst = m_pCurrPosition ;
* pDst + + = * v + + ;
* pDst + + = * v + + ;
* pDst = * v ;
}
//-----------------------------------------------------------------------------
// Normal setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Normal3f ( float nx , float ny , float nz )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // Use the templatized version if you want to support compression
Assert ( m_pNormal ) ;
Assert ( IsFinite ( nx ) & & IsFinite ( ny ) & & IsFinite ( nz ) ) ;
Assert ( nx > = - 1.05f & & nx < = 1.05f ) ;
Assert ( ny > = - 1.05f & & ny < = 1.05f ) ;
Assert ( nz > = - 1.05f & & nz < = 1.05f ) ;
float * pDst = m_pCurrNormal ;
* pDst + + = nx ;
* pDst + + = ny ;
* pDst = nz ;
}
inline void CVertexBuilder : : Normal3fv ( const float * n )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // Use the templatized version if you want to support compression
Assert ( n ) ;
Assert ( m_pNormal & & m_pCurrNormal ) ;
Assert ( IsFinite ( n [ 0 ] ) & & IsFinite ( n [ 1 ] ) & & IsFinite ( n [ 2 ] ) ) ;
Assert ( n [ 0 ] > = - 1.05f & & n [ 0 ] < = 1.05f ) ;
Assert ( n [ 1 ] > = - 1.05f & & n [ 1 ] < = 1.05f ) ;
Assert ( n [ 2 ] > = - 1.05f & & n [ 2 ] < = 1.05f ) ;
float * pDst = m_pCurrNormal ;
* pDst + + = * n + + ;
* pDst + + = * n + + ;
* pDst = * n ;
}
inline void CVertexBuilder : : NormalDelta3f ( float nx , float ny , float nz )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // Use the templatized version if you want to support compression
Assert ( m_pNormal ) ;
Assert ( IsFinite ( nx ) & & IsFinite ( ny ) & & IsFinite ( nz ) ) ;
float * pDst = m_pCurrNormal ;
* pDst + + = nx ;
* pDst + + = ny ;
* pDst = nz ;
}
inline void CVertexBuilder : : NormalDelta3fv ( const float * n )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // Use the templatized version if you want to support compression
Assert ( n ) ;
Assert ( m_pNormal & & m_pCurrNormal ) ;
Assert ( IsFinite ( n [ 0 ] ) & & IsFinite ( n [ 1 ] ) & & IsFinite ( n [ 2 ] ) ) ;
float * pDst = m_pCurrNormal ;
* pDst + + = * n + + ;
* pDst + + = * n + + ;
* pDst = * n ;
}
//-----------------------------------------------------------------------------
// Templatized normal setting methods which support compressed vertices
//-----------------------------------------------------------------------------
template < VertexCompressionType_t T > inline void CVertexBuilder : : CompressedNormal3f ( float nx , float ny , float nz )
{
Assert ( T = = m_CompressionType ) ;
Assert ( m_pNormal & & m_pCurrNormal ) ;
Assert ( IsFinite ( nx ) & & IsFinite ( ny ) & & IsFinite ( nz ) ) ;
Assert ( nx > = - 1.05f & & nx < = 1.05f ) ;
Assert ( ny > = - 1.05f & & ny < = 1.05f ) ;
Assert ( nz > = - 1.05f & & nz < = 1.05f ) ;
// FIXME: studiorender is passing in non-unit normals
//float lengthSqd = nx*nx + ny*ny + nz*nz;
//Assert( lengthSqd >= 0.95f && lengthSqd <= 1.05f );
if ( T = = VERTEX_COMPRESSION_ON )
{
# if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
PackNormal_SHORT2 ( nx , ny , nz , ( unsigned int * ) m_pCurrNormal ) ;
# else //( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
// NOTE: write the normal into the lower 16 bits of a word, clearing the top 16 bits - a userdata4
// tangent must be written into the upper 16 bits by CompressedUserData() *AFTER* this.
# ifdef _DEBUG
Assert ( m_bWrittenUserData = = false ) ;
m_bWrittenNormal = true ;
# endif
PackNormal_UBYTE4 ( nx , ny , nz , ( unsigned int * ) m_pCurrNormal ) ;
# endif
}
else
{
float * pDst = m_pCurrNormal ;
* pDst + + = nx ;
* pDst + + = ny ;
* pDst = nz ;
}
}
template < VertexCompressionType_t T > inline void CVertexBuilder : : CompressedNormal3fv ( const float * n )
{
Assert ( n ) ;
CompressedNormal3f < T > ( n [ 0 ] , n [ 1 ] , n [ 2 ] ) ;
}
//-----------------------------------------------------------------------------
// Color setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Color3f ( float r , float g , float b )
{
Assert ( m_pColor & & m_pCurrColor ) ;
Assert ( IsFinite ( r ) & & IsFinite ( g ) & & IsFinite ( b ) ) ;
Assert ( ( r > = 0.0 ) & & ( g > = 0.0 ) & & ( b > = 0.0 ) ) ;
Assert ( ( r < = 1.0 ) & & ( g < = 1.0 ) & & ( b < = 1.0 ) ) ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( r ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( b ) < < 16 ) | 0xFF000000 ;
# else
int col = ( FastFToC ( b ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( r ) < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color3fv ( const float * rgb )
{
Assert ( rgb ) ;
Assert ( m_pColor & & m_pCurrColor ) ;
Assert ( IsFinite ( rgb [ 0 ] ) & & IsFinite ( rgb [ 1 ] ) & & IsFinite ( rgb [ 2 ] ) ) ;
Assert ( ( rgb [ 0 ] > = 0.0 ) & & ( rgb [ 1 ] > = 0.0 ) & & ( rgb [ 2 ] > = 0.0 ) ) ;
Assert ( ( rgb [ 0 ] < = 1.0 ) & & ( rgb [ 1 ] < = 1.0 ) & & ( rgb [ 2 ] < = 1.0 ) ) ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( rgb [ 0 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 2 ] ) < < 16 ) | 0xFF000000 ;
# else
int col = ( FastFToC ( rgb [ 2 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 0 ] ) < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color4f ( float r , float g , float b , float a )
{
Assert ( m_pColor & & m_pCurrColor ) ;
Assert ( IsFinite ( r ) & & IsFinite ( g ) & & IsFinite ( b ) & & IsFinite ( a ) ) ;
Assert ( ( r > = 0.0 ) & & ( g > = 0.0 ) & & ( b > = 0.0 ) & & ( a > = 0.0 ) ) ;
Assert ( ( r < = 1.0 ) & & ( g < = 1.0 ) & & ( b < = 1.0 ) & & ( a < = 1.0 ) ) ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( r ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( b ) < < 16 ) | ( FastFToC ( a ) < < 24 ) ;
# else
int col = ( FastFToC ( b ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( r ) < < 16 ) | ( FastFToC ( a ) < < 24 ) ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color4fv ( const float * rgba )
{
Assert ( rgba ) ;
Assert ( m_pColor & & m_pCurrColor ) ;
Assert ( IsFinite ( rgba [ 0 ] ) & & IsFinite ( rgba [ 1 ] ) & & IsFinite ( rgba [ 2 ] ) & & IsFinite ( rgba [ 3 ] ) ) ;
Assert ( ( rgba [ 0 ] > = 0.0 ) & & ( rgba [ 1 ] > = 0.0 ) & & ( rgba [ 2 ] > = 0.0 ) & & ( rgba [ 3 ] > = 0.0 ) ) ;
Assert ( ( rgba [ 0 ] < = 1.0 ) & & ( rgba [ 1 ] < = 1.0 ) & & ( rgba [ 2 ] < = 1.0 ) & & ( rgba [ 3 ] < = 1.0 ) ) ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( rgba [ 0 ] ) ) | ( FastFToC ( rgba [ 1 ] ) < < 8 ) | ( FastFToC ( rgba [ 2 ] ) < < 16 ) | ( FastFToC ( rgba [ 3 ] ) < < 24 ) ;
# else
int col = ( FastFToC ( rgba [ 2 ] ) ) | ( FastFToC ( rgba [ 1 ] ) < < 8 ) | ( FastFToC ( rgba [ 0 ] ) < < 16 ) | ( FastFToC ( rgba [ 3 ] ) < < 24 ) ;
# endif
* ( int * ) m_pCurrColor = col ;
}
//-----------------------------------------------------------------------------
// Faster versions of color
//-----------------------------------------------------------------------------
// note that on the OSX target (OpenGL) whenever there is vertex data being written as bytes - they need to be written in R,G,B,A memory order
inline void CVertexBuilder : : Color3ub ( unsigned char r , unsigned char g , unsigned char b )
{
Assert ( m_pColor & & m_pCurrColor ) ;
# ifdef OPENGL_SWAP_COLORS
int col = r | ( g < < 8 ) | ( b < < 16 ) | 0xFF000000 ; // r, g, b, a in memory
# else
int col = b | ( g < < 8 ) | ( r < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color3ubv ( unsigned char const * rgb )
{
Assert ( rgb ) ;
Assert ( m_pColor & & m_pCurrColor ) ;
# ifdef OPENGL_SWAP_COLORS
int col = rgb [ 0 ] | ( rgb [ 1 ] < < 8 ) | ( rgb [ 2 ] < < 16 ) | 0xFF000000 ; // r, g, b, a in memory
# else
int col = rgb [ 2 ] | ( rgb [ 1 ] < < 8 ) | ( rgb [ 0 ] < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a )
{
Assert ( m_pColor & & m_pCurrColor ) ;
# ifdef OPENGL_SWAP_COLORS
int col = r | ( g < < 8 ) | ( b < < 16 ) | ( a < < 24 ) ; // r, g, b, a in memory
# else
int col = b | ( g < < 8 ) | ( r < < 16 ) | ( a < < 24 ) ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Color4ubv ( unsigned char const * rgba )
{
Assert ( rgba ) ;
Assert ( m_pColor & & m_pCurrColor ) ;
# ifdef OPENGL_SWAP_COLORS
int col = rgba [ 0 ] | ( rgba [ 1 ] < < 8 ) | ( rgba [ 2 ] < < 16 ) | ( rgba [ 3 ] < < 24 ) ; // r, g, b, a in memory
# else
int col = rgba [ 2 ] | ( rgba [ 1 ] < < 8 ) | ( rgba [ 0 ] < < 16 ) | ( rgba [ 3 ] < < 24 ) ;
# endif
* ( int * ) m_pCurrColor = col ;
}
inline void CVertexBuilder : : Specular3f ( float r , float g , float b )
{
Assert ( m_pSpecular ) ;
Assert ( IsFinite ( r ) & & IsFinite ( g ) & & IsFinite ( b ) ) ;
Assert ( ( r > = 0.0 ) & & ( g > = 0.0 ) & & ( b > = 0.0 ) ) ;
Assert ( ( r < = 1.0 ) & & ( g < = 1.0 ) & & ( b < = 1.0 ) ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( r ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( b ) < < 16 ) | 0xFF000000 ;
# else
int col = ( FastFToC ( b ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( r ) < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular3fv ( const float * rgb )
{
Assert ( rgb ) ;
Assert ( m_pSpecular ) ;
Assert ( IsFinite ( rgb [ 0 ] ) & & IsFinite ( rgb [ 1 ] ) & & IsFinite ( rgb [ 2 ] ) ) ;
Assert ( ( rgb [ 0 ] > = 0.0 ) & & ( rgb [ 1 ] > = 0.0 ) & & ( rgb [ 2 ] > = 0.0 ) ) ;
Assert ( ( rgb [ 0 ] < = 1.0 ) & & ( rgb [ 1 ] < = 1.0 ) & & ( rgb [ 2 ] < = 1.0 ) ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( rgb [ 0 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 2 ] ) < < 16 ) | 0xFF000000 ;
# else
int col = ( FastFToC ( rgb [ 2 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 0 ] ) < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular4f ( float r , float g , float b , float a )
{
Assert ( m_pSpecular ) ;
Assert ( IsFinite ( r ) & & IsFinite ( g ) & & IsFinite ( b ) & & IsFinite ( a ) ) ;
Assert ( ( r > = 0.0 ) & & ( g > = 0.0 ) & & ( b > = 0.0 ) & & ( a > = 0.0 ) ) ;
Assert ( ( r < = 1.0 ) & & ( g < = 1.0 ) & & ( b < = 1.0 ) & & ( a < = 1.0f ) ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( r ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( b ) < < 16 ) | ( FastFToC ( a ) < < 24 ) ;
# else
int col = ( FastFToC ( b ) ) | ( FastFToC ( g ) < < 8 ) | ( FastFToC ( r ) < < 16 ) | ( FastFToC ( a ) < < 24 ) ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular4fv ( const float * rgb )
{
Assert ( rgb ) ;
Assert ( m_pSpecular ) ;
Assert ( IsFinite ( rgb [ 0 ] ) & & IsFinite ( rgb [ 1 ] ) & & IsFinite ( rgb [ 2 ] ) & & IsFinite ( rgb [ 3 ] ) ) ;
Assert ( ( rgb [ 0 ] > = 0.0 ) & & ( rgb [ 1 ] > = 0.0 ) & & ( rgb [ 2 ] > = 0.0 ) & & ( rgb [ 3 ] > = 0.0 ) ) ;
Assert ( ( rgb [ 0 ] < = 1.0 ) & & ( rgb [ 1 ] < = 1.0 ) & & ( rgb [ 2 ] < = 1.0 ) & & ( rgb [ 3 ] < = 1.0 ) ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = ( FastFToC ( rgb [ 0 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 2 ] ) < < 16 ) | ( FastFToC ( rgb [ 3 ] ) < < 24 ) ;
# else
int col = ( FastFToC ( rgb [ 2 ] ) ) | ( FastFToC ( rgb [ 1 ] ) < < 8 ) | ( FastFToC ( rgb [ 0 ] ) < < 16 ) | ( FastFToC ( rgb [ 3 ] ) < < 24 ) ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular3ub ( unsigned char r , unsigned char g , unsigned char b )
{
Assert ( m_pSpecular ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = r | ( g < < 8 ) | ( b < < 16 ) | 0xFF000000 ; // r, g, b, a in memory
# else
int col = b | ( g < < 8 ) | ( r < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular3ubv ( unsigned char const * c )
{
Assert ( m_pSpecular ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = c [ 0 ] | ( c [ 1 ] < < 8 ) | ( c [ 2 ] < < 16 ) | 0xFF000000 ; // r, g, b, a in memory
# else
int col = c [ 2 ] | ( c [ 1 ] < < 8 ) | ( c [ 0 ] < < 16 ) | 0xFF000000 ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a )
{
Assert ( m_pSpecular ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = r | ( g < < 8 ) | ( b < < 16 ) | ( a < < 24 ) ; // r, g, b, a in memory
# else
int col = b | ( g < < 8 ) | ( r < < 16 ) | ( a < < 24 ) ;
# endif
* ( int * ) pSpecular = col ;
}
inline void CVertexBuilder : : Specular4ubv ( unsigned char const * c )
{
Assert ( m_pSpecular ) ;
unsigned char * pSpecular = & m_pSpecular [ m_nCurrentVertex * m_VertexSize_Specular ] ;
# ifdef OPENGL_SWAP_COLORS
int col = c [ 0 ] | ( c [ 1 ] < < 8 ) | ( c [ 2 ] < < 16 ) | ( c [ 3 ] < < 24 ) ;
# else
int col = c [ 2 ] | ( c [ 1 ] < < 8 ) | ( c [ 0 ] < < 16 ) | ( c [ 3 ] < < 24 ) ;
# endif
* ( int * ) pSpecular = col ;
}
//-----------------------------------------------------------------------------
// Texture coordinate setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : TexCoord1f ( int nStage , float s )
{
Assert ( m_pTexCoord [ nStage ] & & m_pCurrTexCoord [ nStage ] ) ;
Assert ( IsFinite ( s ) ) ;
float * pDst = m_pCurrTexCoord [ nStage ] ;
* pDst = s ;
}
inline void CVertexBuilder : : TexCoord2f ( int nStage , float s , float t )
{
Assert ( m_pTexCoord [ nStage ] & & m_pCurrTexCoord [ nStage ] ) ;
Assert ( IsFinite ( s ) & & IsFinite ( t ) ) ;
float * pDst = m_pCurrTexCoord [ nStage ] ;
* pDst + + = s ;
* pDst = t ;
}
inline void CVertexBuilder : : TexCoord2fv ( int nStage , const float * st )
{
Assert ( st ) ;
Assert ( m_pTexCoord [ nStage ] & & m_pCurrTexCoord [ nStage ] ) ;
Assert ( IsFinite ( st [ 0 ] ) & & IsFinite ( st [ 1 ] ) ) ;
float * pDst = m_pCurrTexCoord [ nStage ] ;
* pDst + + = * st + + ;
* pDst = * st ;
}
inline void CVertexBuilder : : TexCoord3f ( int stage , float s , float t , float u )
{
// Tried to add too much!
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( s ) & & IsFinite ( t ) & & IsFinite ( u ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = s ;
* pDst + + = t ;
* pDst = u ;
}
inline void CVertexBuilder : : TexCoord3fv ( int stage , const float * stu )
{
Assert ( stu ) ;
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( stu [ 0 ] ) & & IsFinite ( stu [ 1 ] ) & & IsFinite ( stu [ 2 ] ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = * stu + + ;
* pDst + + = * stu + + ;
* pDst = * stu ;
}
inline void CVertexBuilder : : TexCoord4f ( int stage , float s , float t , float u , float v )
{
// Tried to add too much!
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( s ) & & IsFinite ( t ) & & IsFinite ( u ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = s ;
* pDst + + = t ;
* pDst + + = u ;
* pDst = v ;
}
inline void CVertexBuilder : : TexCoord4fv ( int stage , const float * stuv )
{
Assert ( stuv ) ;
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( stuv [ 0 ] ) & & IsFinite ( stuv [ 1 ] ) & & IsFinite ( stuv [ 2 ] ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = * stuv + + ;
* pDst + + = * stuv + + ;
* pDst + + = * stuv + + ;
* pDst = * stuv ;
}
inline void CVertexBuilder : : TexCoordSubRect2f ( int stage , float s , float t , float offsetS , float offsetT , float scaleS , float scaleT )
{
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( s ) & & IsFinite ( t ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = ( s * scaleS ) + offsetS ;
* pDst = ( t * scaleT ) + offsetT ;
}
inline void CVertexBuilder : : TexCoordSubRect2fv ( int stage , const float * st , const float * offset , const float * scale )
{
Assert ( st ) ;
Assert ( m_pTexCoord [ stage ] & & m_pCurrTexCoord [ stage ] ) ;
Assert ( IsFinite ( st [ 0 ] ) & & IsFinite ( st [ 1 ] ) ) ;
float * pDst = m_pCurrTexCoord [ stage ] ;
* pDst + + = ( * st + + * * scale + + ) + * offset + + ;
* pDst = ( * st * * scale ) + * offset ;
}
//-----------------------------------------------------------------------------
// Tangent space setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : TangentS3f ( float sx , float sy , float sz )
{
Assert ( m_pTangentS ) ;
Assert ( IsFinite ( sx ) & & IsFinite ( sy ) & & IsFinite ( sz ) ) ;
float * pTangentS = OffsetFloatPointer ( m_pTangentS , m_nCurrentVertex , m_VertexSize_TangentS ) ;
* pTangentS + + = sx ;
* pTangentS + + = sy ;
* pTangentS = sz ;
}
inline void CVertexBuilder : : TangentS3fv ( const float * s )
{
Assert ( s ) ;
Assert ( m_pTangentS ) ;
Assert ( IsFinite ( s [ 0 ] ) & & IsFinite ( s [ 1 ] ) & & IsFinite ( s [ 2 ] ) ) ;
float * pTangentS = OffsetFloatPointer ( m_pTangentS , m_nCurrentVertex , m_VertexSize_TangentS ) ;
* pTangentS + + = * s + + ;
* pTangentS + + = * s + + ;
* pTangentS = * s ;
}
inline void CVertexBuilder : : TangentT3f ( float tx , float ty , float tz )
{
Assert ( m_pTangentT ) ;
Assert ( IsFinite ( tx ) & & IsFinite ( ty ) & & IsFinite ( tz ) ) ;
float * pTangentT = OffsetFloatPointer ( m_pTangentT , m_nCurrentVertex , m_VertexSize_TangentT ) ;
* pTangentT + + = tx ;
* pTangentT + + = ty ;
* pTangentT = tz ;
}
inline void CVertexBuilder : : TangentT3fv ( const float * t )
{
Assert ( t ) ;
Assert ( m_pTangentT ) ;
Assert ( IsFinite ( t [ 0 ] ) & & IsFinite ( t [ 1 ] ) & & IsFinite ( t [ 2 ] ) ) ;
float * pTangentT = OffsetFloatPointer ( m_pTangentT , m_nCurrentVertex , m_VertexSize_TangentT ) ;
* pTangentT + + = * t + + ;
* pTangentT + + = * t + + ;
* pTangentT = * t ;
}
//-----------------------------------------------------------------------------
// Wrinkle setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : Wrinkle1f ( float flWrinkle )
{
Assert ( m_pWrinkle ) ;
Assert ( IsFinite ( flWrinkle ) ) ;
float * pWrinkle = OffsetFloatPointer ( m_pWrinkle , m_nCurrentVertex , m_VertexSize_Wrinkle ) ;
* pWrinkle = flWrinkle ;
}
//-----------------------------------------------------------------------------
// Bone weight setting methods
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : BoneWeight ( int idx , float weight )
{
Assert ( m_pBoneWeight ) ;
Assert ( IsFinite ( weight ) ) ;
Assert ( idx > = 0 ) ;
AssertOnce ( m_NumBoneWeights = = 2 ) ;
// This test is here because we store N-1 bone weights (the Nth is computed in
// the vertex shader as "1 - C", where C is the sum of the (N-1) other weights)
if ( idx < m_NumBoneWeights )
{
float * pBoneWeight = OffsetFloatPointer ( m_pBoneWeight , m_nCurrentVertex , m_VertexSize_BoneWeight ) ;
pBoneWeight [ idx ] = weight ;
}
}
static int sg_IndexSwap [ 4 ] = { 2 , 1 , 0 , 3 } ;
inline void CVertexBuilder : : BoneMatrix ( int idx , int matrixIdx )
{
Assert ( m_pBoneMatrixIndex ) ;
Assert ( idx > = 0 ) ;
Assert ( idx < 4 ) ;
// garymcthack
if ( matrixIdx = = BONE_MATRIX_INDEX_INVALID )
{
matrixIdx = 0 ;
}
Assert ( ( matrixIdx > = 0 ) & & ( matrixIdx < 53 ) ) ;
# ifdef OPENGL_SWAP_COLORS
idx = sg_IndexSwap [ idx ] ;
# endif
# ifndef NEW_SKINNING
unsigned char * pBoneMatrix = & m_pBoneMatrixIndex [ m_nCurrentVertex * m_VertexSize_BoneMatrixIndex ] ;
if ( IsX360 ( ) )
{
// store sequentially as wzyx order, gpu delivers as xyzw
idx = 3 - idx ;
}
pBoneMatrix [ idx ] = ( unsigned char ) matrixIdx ;
# else
float * pBoneMatrix = & m_pBoneMatrixIndex [ m_nCurrentVertex * m_VertexSize_BoneMatrixIndex ] ;
pBoneMatrix [ idx ] = matrixIdx ;
# endif
}
//-----------------------------------------------------------------------------
// Templatized bone weight setting methods which support compressed vertices
//-----------------------------------------------------------------------------
template < VertexCompressionType_t T > inline void CVertexBuilder : : CompressedBoneWeight3fv ( const float * pWeights )
{
Assert ( T = = m_CompressionType ) ;
Assert ( m_pBoneWeight ) ;
Assert ( pWeights ) ;
float * pDestWeights = OffsetFloatPointer ( m_pBoneWeight , m_nCurrentVertex , m_VertexSize_BoneWeight ) ;
if ( T = = VERTEX_COMPRESSION_ON )
{
// Quantize to 15 bits per weight (we use D3DDECLTYPE_SHORT2)
// NOTE: we perform careful normalization (weights sum to 1.0f in the vertex shader), so
// as to avoid cracking at boundaries between meshes with different numbers of weights
// per vertex. For example, (1) needs to yield the same normalized weights as (1,0),
// and (0.5,0.49) needs to normalize the same normalized weights as (0.5,0.49,0).
// The key is that values which are *computed* in the shader (e.g. the second weight
// in a 2-weight mesh) must exactly equal values which are *read* from the vertex
// stream (e.g. the second weight in a 3-weight mesh).
// Only 1 or 2 weights (SHORT2N) supported for compressed verts so far
Assert ( m_NumBoneWeights < = 2 ) ;
const int WEIGHT0_SHIFT = IsX360 ( ) ? 16 : 0 ;
const int WEIGHT1_SHIFT = IsX360 ( ) ? 0 : 16 ;
unsigned int * weights = ( unsigned int * ) pDestWeights ;
// We scale our weights so that they sum to 32768, then subtract 1 (which gets added
// back in the shader), because dividing by 32767 introduces nasty rounding issues.
Assert ( IsFinite ( pWeights [ 0 ] ) & & ( pWeights [ 0 ] > = 0.0f ) & & ( pWeights [ 0 ] < = 1.0f ) ) ;
unsigned int weight0 = Float2Int ( pWeights [ 0 ] * 32768.0f ) ;
* weights = ( 0x0000FFFF & ( weight0 - 1 ) ) < < WEIGHT0_SHIFT ;
# ifdef DEBUG
if ( m_NumBoneWeights = = 1 )
{
// Double-check the validity of the values that were passed in
Assert ( IsFinite ( pWeights [ 1 ] ) & & ( pWeights [ 1 ] > = 0.0f ) & & ( pWeights [ 1 ] < = 1.0f ) ) ;
unsigned int weight1 = Float2Int ( pWeights [ 1 ] * 32768.0f ) ;
Assert ( ( weight0 + weight1 ) < = 32768 ) ;
}
# endif
if ( m_NumBoneWeights > 1 )
{
// This path for 3 weights per vert (2 are stored and the 3rd is computed
// in the shader - we do post-quantization normalization here in such a
// way as to avoid mesh-boundary cracking)
Assert ( m_NumBoneWeights = = 2 ) ;
Assert ( IsFinite ( pWeights [ 1 ] ) & & ( pWeights [ 1 ] > = 0.0f ) & & ( pWeights [ 1 ] < = 1.0f ) ) ;
Assert ( IsFinite ( pWeights [ 2 ] ) & & ( pWeights [ 2 ] > = 0.0f ) & & ( pWeights [ 2 ] < = 1.0f ) ) ;
unsigned int weight1 = Float2Int ( pWeights [ 1 ] * 32768.0f ) ;
unsigned int weight2 = Float2Int ( pWeights [ 2 ] * 32768.0f ) ;
Assert ( ( weight0 + weight1 + weight2 ) < = 32768 ) ;
unsigned int residual = 32768 - ( weight0 + weight1 + weight2 ) ;
weight1 + = residual ; // Normalize
* weights | = ( 0x0000FFFF & ( weight1 - 1 ) ) < < WEIGHT1_SHIFT ;
}
}
else // Uncompressed path
{
pDestWeights [ 0 ] = pWeights [ 0 ] ;
pDestWeights [ 1 ] = pWeights [ 1 ] ;
}
}
//-----------------------------------------------------------------------------
// Generic per-vertex data setting method
//-----------------------------------------------------------------------------
inline void CVertexBuilder : : UserData ( const float * pData )
{
Assert ( m_CompressionType = = VERTEX_COMPRESSION_NONE ) ; // Use the templatized version if you want to support compression
Assert ( pData ) ;
int userDataSize = 4 ; // garymcthack
float * pUserData = OffsetFloatPointer ( m_pUserData , m_nCurrentVertex , m_VertexSize_UserData ) ;
memcpy ( pUserData , pData , sizeof ( float ) * userDataSize ) ;
}
//-----------------------------------------------------------------------------
// Templatized generic per-vertex data setting method which supports compressed vertices
//-----------------------------------------------------------------------------
template < VertexCompressionType_t T > inline void CVertexBuilder : : CompressedUserData ( const float * pData )
{
Assert ( T = = m_CompressionType ) ;
Assert ( pData ) ;
// This is always in fact a tangent vector, not generic 'userdata'
Assert ( IsFinite ( pData [ 0 ] ) & & IsFinite ( pData [ 1 ] ) & & IsFinite ( pData [ 2 ] ) ) ;
Assert ( pData [ 0 ] > = - 1.05f & & pData [ 0 ] < = 1.05f ) ;
Assert ( pData [ 1 ] > = - 1.05f & & pData [ 1 ] < = 1.05f ) ;
Assert ( pData [ 2 ] > = - 1.05f & & pData [ 2 ] < = 1.05f ) ;
Assert ( pData [ 3 ] = = + 1.0f | | pData [ 3 ] = = - 1.0f ) ;
// FIXME: studiorender is passing in non-unit normals
//float lengthSqd = pData[0]*pData[0] + pData[1]*pData[1] + pData[2]*pData[2];
//Assert( lengthSqd >= 0.95f && lengthSqd <= 1.05f );
if ( T = = VERTEX_COMPRESSION_ON )
{
float binormalSign = pData [ 3 ] ;
# if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
float * pUserData = OffsetFloatPointer ( m_pUserData , m_nCurrentVertex , m_VertexSize_UserData ) ;
PackNormal_SHORT2 ( pData , ( unsigned int * ) pUserData , binormalSign ) ;
# else //( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
// FIXME: add a combined CompressedNormalAndTangent() accessor, to avoid reading back from write-combined memory here
// The normal should have already been written into the lower 16
// bits - here, we OR in the tangent into the upper 16 bits
unsigned int existingNormalData = * ( unsigned int * ) m_pCurrNormal ;
Assert ( ( existingNormalData & 0xFFFF0000 ) = = 0 ) ;
# ifdef _DEBUG
Assert ( m_bWrittenNormal = = true ) ;
m_bWrittenUserData = true ;
# endif
bool bIsTangent = true ;
unsigned int tangentData = 0 ;
PackNormal_UBYTE4 ( pData , & tangentData , bIsTangent , binormalSign ) ;
* ( unsigned int * ) m_pCurrNormal = existingNormalData | tangentData ;
# endif
}
else
{
int userDataSize = 4 ; // garymcthack
float * pUserData = OffsetFloatPointer ( m_pUserData , m_nCurrentVertex , m_VertexSize_UserData ) ;
memcpy ( pUserData , pData , sizeof ( float ) * userDataSize ) ;
}
}
//-----------------------------------------------------------------------------
//
// Helper class used to define index buffers
//
//-----------------------------------------------------------------------------
class CIndexBuilder : private IndexDesc_t
{
public :
CIndexBuilder ( ) ;
CIndexBuilder ( IIndexBuffer * pIndexBuffer , MaterialIndexFormat_t fmt = MATERIAL_INDEX_FORMAT_UNKNOWN ) ;
~ CIndexBuilder ( ) ;
// Begins, ends modification of the index buffer (returns true if the lock succeeded)
// A lock may not succeed if append is set to true and there isn't enough room
// NOTE: Append is only used with dynamic index buffers; it's ignored for static buffers
bool Lock ( int nMaxIndexCount , int nIndexOffset , bool bAppend = false ) ;
void Unlock ( ) ;
// Spews the current data
// NOTE: Can only be called during a lock/unlock block
void SpewData ( ) ;
// Returns the number of indices we can fit into the buffer without needing to discard
int GetRoomRemaining ( ) const ;
// Binds this index buffer
void Bind ( IMatRenderContext * pContext ) ;
// Returns the byte offset
int Offset ( ) const ;
// Begins, ends modification of the index buffer
// NOTE: IndexOffset is the number to add to all indices written into the buffer;
// useful when using dynamic vertex buffers.
void Begin ( IIndexBuffer * pIndexBuffer , int nMaxIndexCount , int nIndexOffset = 0 ) ;
void End ( bool bSpewData = false ) ;
// Locks the index buffer to modify existing data
// Passing nVertexCount == -1 says to lock all the vertices for modification.
// Pass 0 for nIndexCount to not lock the index buffer.
void BeginModify ( IIndexBuffer * pIndexBuffer , int nFirstIndex = 0 , int nIndexCount = 0 , int nIndexOffset = 0 ) ;
void EndModify ( bool bSpewData = false ) ;
// returns the number of indices
int IndexCount ( ) const ;
// Returns the total number of indices across all Locks()
int TotalIndexCount ( ) const ;
// Resets the mesh builder so it points to the start of everything again
void Reset ( ) ;
// Selects the nth Index
void SelectIndex ( int nBufferIndex ) ;
// Advances the current index by one
void AdvanceIndex ( ) ;
void AdvanceIndices ( int nIndexCount ) ;
int GetCurrentIndex ( ) ;
int GetFirstIndex ( ) const ;
unsigned short const * Index ( ) const ;
// Used to define the indices (only used if you aren't using primitives)
void Index ( unsigned short nIndex ) ;
// Fast Index! No need to call advance index, and no random access allowed
void FastIndex ( unsigned short nIndex ) ;
// NOTE: This version is the one you really want to achieve write-combining;
// Write combining only works if you write in 4 bytes chunks.
void FastIndex2 ( unsigned short nIndex1 , unsigned short nIndex2 ) ;
// Generates indices for a particular primitive type
void GenerateIndices ( MaterialPrimitiveType_t primitiveType , int nIndexCount ) ;
// FIXME: Remove! Backward compat so we can use this from a CMeshBuilder.
void AttachBegin ( IMesh * pMesh , int nMaxIndexCount , const MeshDesc_t & desc ) ;
void AttachEnd ( ) ;
void AttachBeginModify ( IMesh * pMesh , int nFirstIndex , int nIndexCount , const MeshDesc_t & desc ) ;
void AttachEndModify ( ) ;
void FastTriangle ( int startVert ) ;
void FastQuad ( int startVert ) ;
void FastPolygon ( int startVert , int numTriangles ) ;
void FastPolygonList ( int startVert , int * pVertexCount , int polygonCount ) ;
void FastIndexList ( const unsigned short * pIndexList , int startVert , int indexCount ) ;
private :
// The mesh we're modifying
IIndexBuffer * m_pIndexBuffer ;
// Max number of indices
int m_nMaxIndexCount ;
// Number of indices
int m_nIndexCount ;
// Offset to add to each index as it's written into the buffer
int m_nIndexOffset ;
// The current index
mutable int m_nCurrentIndex ;
// Total number of indices appended
int m_nTotalIndexCount ;
// First index buffer offset + first index
unsigned int m_nBufferOffset ;
unsigned int m_nBufferFirstIndex ;
// Used to make sure Begin/End calls and BeginModify/EndModify calls match.
bool m_bModify ;
} ;
//-----------------------------------------------------------------------------
//
// Inline methods related to CIndexBuilder
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
inline CIndexBuilder : : CIndexBuilder ( ) : m_pIndexBuffer ( 0 ) , m_nIndexCount ( 0 ) ,
m_nCurrentIndex ( 0 ) , m_nMaxIndexCount ( 0 )
{
m_nTotalIndexCount = 0 ;
m_nBufferOffset = INVALID_BUFFER_OFFSET ;
m_nBufferFirstIndex = 0 ;
# ifdef _DEBUG
m_bModify = false ;
# endif
}
inline CIndexBuilder : : CIndexBuilder ( IIndexBuffer * pIndexBuffer , MaterialIndexFormat_t fmt )
{
m_pIndexBuffer = pIndexBuffer ;
m_nBufferOffset = INVALID_BUFFER_OFFSET ;
m_nBufferFirstIndex = 0 ;
m_nIndexCount = 0 ;
m_nCurrentIndex = 0 ;
m_nMaxIndexCount = 0 ;
m_nTotalIndexCount = 0 ;
if ( m_pIndexBuffer - > IsDynamic ( ) )
{
m_pIndexBuffer - > BeginCastBuffer ( fmt ) ;
}
else
{
Assert ( m_pIndexBuffer - > IndexFormat ( ) = = fmt ) ;
}
# ifdef _DEBUG
m_bModify = false ;
# endif
}
inline CIndexBuilder : : ~ CIndexBuilder ( )
{
if ( m_pIndexBuffer & & m_pIndexBuffer - > IsDynamic ( ) )
{
m_pIndexBuffer - > EndCastBuffer ( ) ;
}
}
//-----------------------------------------------------------------------------
// Begins, ends modification of the index buffer
//-----------------------------------------------------------------------------
inline bool CIndexBuilder : : Lock ( int nMaxIndexCount , int nIndexOffset , bool bAppend )
{
Assert ( m_pIndexBuffer ) ;
m_bModify = false ;
m_nIndexOffset = nIndexOffset ;
m_nMaxIndexCount = nMaxIndexCount ;
bool bFirstLock = ( m_nBufferOffset = = INVALID_BUFFER_OFFSET ) ;
if ( bFirstLock )
{
bAppend = false ;
}
if ( ! bAppend )
{
m_nTotalIndexCount = 0 ;
}
Reset ( ) ;
// Lock the index buffer
if ( ! m_pIndexBuffer - > Lock ( m_nMaxIndexCount , bAppend , * this ) )
{
m_nMaxIndexCount = 0 ;
return false ;
}
if ( bFirstLock )
{
m_nBufferOffset = m_nOffset ;
m_nBufferFirstIndex = m_nFirstIndex ;
}
return true ;
}
inline void CIndexBuilder : : Unlock ( )
{
Assert ( ! m_bModify & & m_pIndexBuffer ) ;
m_pIndexBuffer - > Unlock ( m_nIndexCount , * this ) ;
m_nTotalIndexCount + = m_nIndexCount ;
m_nMaxIndexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
memset ( ( IndexDesc_t * ) this , 0 , sizeof ( IndexDesc_t ) ) ;
# endif
}
inline void CIndexBuilder : : SpewData ( )
{
m_pIndexBuffer - > Spew ( m_nIndexCount , * this ) ;
}
//-----------------------------------------------------------------------------
// Binds this index buffer
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : Bind ( IMatRenderContext * pContext )
{
if ( m_pIndexBuffer & & ( m_nBufferOffset ! = INVALID_BUFFER_OFFSET ) )
{
pContext - > BindIndexBuffer ( m_pIndexBuffer , m_nBufferOffset ) ;
}
else
{
pContext - > BindIndexBuffer ( NULL , 0 ) ;
}
}
//-----------------------------------------------------------------------------
// Returns the byte offset
//-----------------------------------------------------------------------------
inline int CIndexBuilder : : Offset ( ) const
{
return m_nBufferOffset ;
}
inline int CIndexBuilder : : GetFirstIndex ( ) const
{
return m_nBufferFirstIndex ;
}
//-----------------------------------------------------------------------------
// Begins, ends modification of the index buffer
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : Begin ( IIndexBuffer * pIndexBuffer , int nMaxIndexCount , int nIndexOffset )
{
Assert ( pIndexBuffer & & ( ! m_pIndexBuffer ) ) ;
m_pIndexBuffer = pIndexBuffer ;
m_nIndexCount = 0 ;
m_nMaxIndexCount = nMaxIndexCount ;
m_nIndexOffset = nIndexOffset ;
m_bModify = false ;
// Lock the index buffer
m_pIndexBuffer - > Lock ( m_nMaxIndexCount , false , * this ) ;
// Point to the start of the buffers..
Reset ( ) ;
}
inline void CIndexBuilder : : End ( bool bSpewData )
{
// Make sure they called Begin()
Assert ( ! m_bModify ) ;
if ( bSpewData )
{
m_pIndexBuffer - > Spew ( m_nIndexCount , * this ) ;
}
// Unlock our buffers
m_pIndexBuffer - > Unlock ( m_nIndexCount , * this ) ;
m_pIndexBuffer = 0 ;
m_nMaxIndexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
memset ( ( IndexDesc_t * ) this , 0 , sizeof ( IndexDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// Begins, ends modification of an existing index buffer which has already been filled out
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : BeginModify ( IIndexBuffer * pIndexBuffer , int nFirstIndex , int nIndexCount , int nIndexOffset )
{
m_pIndexBuffer = pIndexBuffer ;
m_nIndexCount = nIndexCount ;
m_nMaxIndexCount = nIndexCount ;
m_nIndexOffset = nIndexOffset ;
m_bModify = true ;
// Lock the vertex and index buffer
m_pIndexBuffer - > ModifyBegin ( false , nFirstIndex , nIndexCount , * this ) ;
// Point to the start of the buffers..
Reset ( ) ;
}
inline void CIndexBuilder : : EndModify ( bool bSpewData )
{
Assert ( m_pIndexBuffer ) ;
Assert ( m_bModify ) ; // Make sure they called BeginModify.
if ( bSpewData )
{
m_pIndexBuffer - > Spew ( m_nIndexCount , * this ) ;
}
// Unlock our buffers
m_pIndexBuffer - > ModifyEnd ( * this ) ;
m_pIndexBuffer = 0 ;
m_nMaxIndexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
memset ( ( IndexDesc_t * ) this , 0 , sizeof ( IndexDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// FIXME: Remove! Backward compat so we can use this from a CMeshBuilder.
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : AttachBegin ( IMesh * pMesh , int nMaxIndexCount , const MeshDesc_t & desc )
{
m_pIndexBuffer = pMesh ;
m_nIndexCount = 0 ;
m_nMaxIndexCount = nMaxIndexCount ;
m_bModify = false ;
// Copy relevant data from the mesh desc
m_nIndexOffset = desc . m_nFirstVertex ;
m_pIndices = desc . m_pIndices ;
m_nIndexSize = desc . m_nIndexSize ;
// Point to the start of the buffers..
Reset ( ) ;
}
inline void CIndexBuilder : : AttachEnd ( )
{
Assert ( m_pIndexBuffer ) ;
Assert ( ! m_bModify ) ; // Make sure they called AttachBegin.
m_pIndexBuffer = 0 ;
m_nMaxIndexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
memset ( ( IndexDesc_t * ) this , 0 , sizeof ( IndexDesc_t ) ) ;
# endif
}
inline void CIndexBuilder : : AttachBeginModify ( IMesh * pMesh , int nFirstIndex , int nIndexCount , const MeshDesc_t & desc )
{
m_pIndexBuffer = pMesh ;
m_nIndexCount = nIndexCount ;
m_nMaxIndexCount = nIndexCount ;
m_bModify = true ;
// Copy relevant data from the mesh desc
m_nIndexOffset = desc . m_nFirstVertex ;
m_pIndices = desc . m_pIndices ;
m_nIndexSize = desc . m_nIndexSize ;
// Point to the start of the buffers..
Reset ( ) ;
}
inline void CIndexBuilder : : AttachEndModify ( )
{
Assert ( m_pIndexBuffer ) ;
Assert ( m_bModify ) ; // Make sure they called AttachBeginModify.
m_pIndexBuffer = 0 ;
m_nMaxIndexCount = 0 ;
# ifdef _DEBUG
// Null out our data...
memset ( ( IndexDesc_t * ) this , 0 , sizeof ( IndexDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// Resets the index buffer builder so it points to the start of everything again
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : Reset ( )
{
m_nCurrentIndex = 0 ;
}
//-----------------------------------------------------------------------------
// returns the number of indices
//-----------------------------------------------------------------------------
inline int CIndexBuilder : : IndexCount ( ) const
{
return m_nIndexCount ;
}
//-----------------------------------------------------------------------------
// Returns the total number of indices across all Locks()
//-----------------------------------------------------------------------------
inline int CIndexBuilder : : TotalIndexCount ( ) const
{
return m_nTotalIndexCount ;
}
//-----------------------------------------------------------------------------
// Advances the current index
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : AdvanceIndex ( )
{
m_nCurrentIndex + = m_nIndexSize ;
if ( m_nCurrentIndex > m_nIndexCount )
{
m_nIndexCount = m_nCurrentIndex ;
}
}
inline void CIndexBuilder : : AdvanceIndices ( int nIndices )
{
m_nCurrentIndex + = nIndices * m_nIndexSize ;
if ( m_nCurrentIndex > m_nIndexCount )
{
m_nIndexCount = m_nCurrentIndex ;
}
}
//-----------------------------------------------------------------------------
// Returns the current index
//-----------------------------------------------------------------------------
inline int CIndexBuilder : : GetCurrentIndex ( )
{
return m_nCurrentIndex ;
}
inline unsigned short const * CIndexBuilder : : Index ( ) const
{
Assert ( m_nCurrentIndex < m_nMaxIndexCount ) ;
return & m_pIndices [ m_nCurrentIndex ] ;
}
inline void CIndexBuilder : : SelectIndex ( int nIndex )
{
Assert ( ( nIndex > = 0 ) & & ( nIndex < m_nIndexCount ) ) ;
m_nCurrentIndex = nIndex * m_nIndexSize ;
}
//-----------------------------------------------------------------------------
// Used to write data into the index buffer
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : Index ( unsigned short nIndex )
{
Assert ( m_pIndices ) ;
Assert ( m_nCurrentIndex < m_nMaxIndexCount ) ;
m_pIndices [ m_nCurrentIndex ] = ( unsigned short ) ( m_nIndexOffset + nIndex ) ;
}
// Fast Index! No need to call advance index
inline void CIndexBuilder : : FastIndex ( unsigned short nIndex )
{
Assert ( m_pIndices ) ;
Assert ( m_nCurrentIndex < m_nMaxIndexCount ) ;
m_pIndices [ m_nCurrentIndex ] = ( unsigned short ) ( m_nIndexOffset + nIndex ) ;
m_nCurrentIndex + = m_nIndexSize ;
m_nIndexCount = m_nCurrentIndex ;
}
inline void CIndexBuilder : : FastTriangle ( int startVert )
{
startVert + = m_nIndexOffset ;
m_pIndices [ m_nCurrentIndex + 0 ] = startVert ;
m_pIndices [ m_nCurrentIndex + 1 ] = startVert + 1 ;
m_pIndices [ m_nCurrentIndex + 2 ] = startVert + 2 ;
AdvanceIndices ( 3 ) ;
}
inline void CIndexBuilder : : FastQuad ( int startVert )
{
startVert + = m_nIndexOffset ;
m_pIndices [ m_nCurrentIndex + 0 ] = startVert ;
m_pIndices [ m_nCurrentIndex + 1 ] = startVert + 1 ;
m_pIndices [ m_nCurrentIndex + 2 ] = startVert + 2 ;
m_pIndices [ m_nCurrentIndex + 3 ] = startVert ;
m_pIndices [ m_nCurrentIndex + 4 ] = startVert + 2 ;
m_pIndices [ m_nCurrentIndex + 5 ] = startVert + 3 ;
AdvanceIndices ( 6 ) ;
}
inline void CIndexBuilder : : FastPolygon ( int startVert , int triangleCount )
{
unsigned short * pIndex = & m_pIndices [ m_nCurrentIndex ] ;
startVert + = m_nIndexOffset ;
if ( ! IsX360 ( ) )
{
// NOTE: IndexSize is 1 or 0 (0 for alt-tab)
// This prevents us from writing into bogus memory
Assert ( m_nIndexSize = = 0 | | m_nIndexSize = = 1 ) ;
triangleCount * = m_nIndexSize ;
}
for ( int v = 0 ; v < triangleCount ; + + v )
{
* pIndex + + = startVert ;
* pIndex + + = startVert + v + 1 ;
* pIndex + + = startVert + v + 2 ;
}
AdvanceIndices ( triangleCount * 3 ) ;
}
inline void CIndexBuilder : : FastPolygonList ( int startVert , int * pVertexCount , int polygonCount )
{
unsigned short * pIndex = & m_pIndices [ m_nCurrentIndex ] ;
startVert + = m_nIndexOffset ;
int indexOut = 0 ;
if ( ! IsX360 ( ) )
{
// NOTE: IndexSize is 1 or 0 (0 for alt-tab)
// This prevents us from writing into bogus memory
Assert ( m_nIndexSize = = 0 | | m_nIndexSize = = 1 ) ;
polygonCount * = m_nIndexSize ;
}
for ( int i = 0 ; i < polygonCount ; i + + )
{
int vertexCount = pVertexCount [ i ] ;
int triangleCount = vertexCount - 2 ;
for ( int v = 0 ; v < triangleCount ; + + v )
{
* pIndex + + = startVert ;
* pIndex + + = startVert + v + 1 ;
* pIndex + + = startVert + v + 2 ;
}
startVert + = vertexCount ;
indexOut + = triangleCount * 3 ;
}
AdvanceIndices ( indexOut ) ;
}
inline void CIndexBuilder : : FastIndexList ( const unsigned short * pIndexList , int startVert , int indexCount )
{
unsigned short * pIndexOut = & m_pIndices [ m_nCurrentIndex ] ;
startVert + = m_nIndexOffset ;
if ( ! IsX360 ( ) )
{
// NOTE: IndexSize is 1 or 0 (0 for alt-tab)
// This prevents us from writing into bogus memory
Assert ( m_nIndexSize = = 0 | | m_nIndexSize = = 1 ) ;
indexCount * = m_nIndexSize ;
}
for ( int i = 0 ; i < indexCount ; + + i )
{
pIndexOut [ i ] = startVert + pIndexList [ i ] ;
}
AdvanceIndices ( indexCount ) ;
}
//-----------------------------------------------------------------------------
// NOTE: This version is the one you really want to achieve write-combining;
// Write combining only works if you write in 4 bytes chunks.
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : FastIndex2 ( unsigned short nIndex1 , unsigned short nIndex2 )
{
Assert ( m_pIndices ) ;
Assert ( m_nCurrentIndex < m_nMaxIndexCount - 1 ) ;
// Assert( ( (int)( &m_pIndices[m_nCurrentIndex] ) & 0x3 ) == 0 );
# ifndef _X360
unsigned int nIndices = ( ( unsigned int ) nIndex1 + m_nIndexOffset ) | ( ( ( unsigned int ) nIndex2 + m_nIndexOffset ) < < 16 ) ;
# else
unsigned int nIndices = ( ( unsigned int ) nIndex2 + m_nIndexOffset ) | ( ( ( unsigned int ) nIndex1 + m_nIndexOffset ) < < 16 ) ;
# endif
* ( int * ) ( & m_pIndices [ m_nCurrentIndex ] ) = nIndices ;
m_nCurrentIndex + = m_nIndexSize + m_nIndexSize ;
m_nIndexCount = m_nCurrentIndex ;
}
//-----------------------------------------------------------------------------
// Generates indices for a particular primitive type
//-----------------------------------------------------------------------------
inline void CIndexBuilder : : GenerateIndices ( MaterialPrimitiveType_t primitiveType , int nIndexCount )
{
// FIXME: How to make this work with short vs int sized indices?
// Don't generate indices if we've got an empty buffer
if ( m_nIndexSize = = 0 )
return ;
int nMaxIndices = m_nMaxIndexCount - m_nCurrentIndex ;
nIndexCount = Min ( nMaxIndices , nIndexCount ) ;
if ( nIndexCount = = 0 )
return ;
unsigned short * pIndices = & m_pIndices [ m_nCurrentIndex ] ;
switch ( primitiveType )
{
case MATERIAL_INSTANCED_QUADS :
Assert ( 0 ) ; // Shouldn't get here (this primtype is unindexed)
break ;
case MATERIAL_QUADS :
GenerateQuadIndexBuffer ( pIndices , nIndexCount , m_nIndexOffset ) ;
break ;
case MATERIAL_POLYGON :
GeneratePolygonIndexBuffer ( pIndices , nIndexCount , m_nIndexOffset ) ;
break ;
case MATERIAL_LINE_STRIP :
GenerateLineStripIndexBuffer ( pIndices , nIndexCount , m_nIndexOffset ) ;
break ;
case MATERIAL_LINE_LOOP :
GenerateLineLoopIndexBuffer ( pIndices , nIndexCount , m_nIndexOffset ) ;
break ;
case MATERIAL_POINTS :
Assert ( 0 ) ; // Shouldn't get here (this primtype is unindexed)
break ;
default :
GenerateSequentialIndexBuffer ( pIndices , nIndexCount , m_nIndexOffset ) ;
break ;
}
AdvanceIndices ( nIndexCount ) ;
}
//-----------------------------------------------------------------------------
//
// Helper class used to define meshes
//
//-----------------------------------------------------------------------------
//class CMeshBuilder : private MeshDesc_t
// hack fixme
class CMeshBuilder : public MeshDesc_t
{
public :
CMeshBuilder ( ) ;
~ CMeshBuilder ( ) { Assert ( ! m_pMesh ) ; } // if this fires you did a Begin() without an End()
operator CIndexBuilder & ( ) { return m_IndexBuilder ; }
// This must be called before Begin, if a vertex buffer with a compressed format is to be used
void SetCompressionType ( VertexCompressionType_t compressionType ) ;
// Locks the vertex buffer
// (*cannot* use the Index() call below)
void Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int numPrimitives ) ;
// Locks the vertex buffer, can specify arbitrary index lists
// (must use the Index() call below)
void Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount , int * nFirstVertex ) ;
void Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount ) ;
// forward compat
void Begin ( IVertexBuffer * pVertexBuffer , MaterialPrimitiveType_t type , int numPrimitives ) ;
void Begin ( IVertexBuffer * pVertexBuffer , IIndexBuffer * pIndexBuffer , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount , int * nFirstVertex ) ;
void Begin ( IVertexBuffer * pVertexBuffer , IIndexBuffer * pIndexBuffer , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount ) ;
// Use this when you're done writing
// Set bDraw to true to call m_pMesh->Draw automatically.
void End ( bool bSpewData = false , bool bDraw = false ) ;
// Locks the vertex buffer to modify existing data
// Passing nVertexCount == -1 says to lock all the vertices for modification.
// Pass 0 for nIndexCount to not lock the index buffer.
void BeginModify ( IMesh * pMesh , int nFirstVertex = 0 , int nVertexCount = - 1 , int nFirstIndex = 0 , int nIndexCount = 0 ) ;
void EndModify ( bool bSpewData = false ) ;
// A helper method since this seems to be done a whole bunch.
void DrawQuad ( IMesh * pMesh , const float * v1 , const float * v2 ,
const float * v3 , const float * v4 , unsigned char const * pColor , bool wireframe = false ) ;
// returns the number of indices and vertices
int VertexCount ( ) const ;
int IndexCount ( ) const ;
// Resets the mesh builder so it points to the start of everything again
void Reset ( ) ;
// Returns the size of the vertex
int VertexSize ( ) { return m_ActualVertexSize ; }
// returns the data size of a given texture coordinate
int TextureCoordinateSize ( int nTexCoordNumber ) { return m_VertexSize_TexCoord [ nTexCoordNumber ] ; }
// Returns the base vertex memory pointer
void * BaseVertexData ( ) ;
// Selects the nth Vertex and Index
void SelectVertex ( int idx ) ;
void SelectIndex ( int idx ) ;
// Given an index, point to the associated vertex
void SelectVertexFromIndex ( int idx ) ;
// Advances the current vertex and index by one
void AdvanceVertex ( ) ;
template < int nFlags , int nNumTexCoords > void AdvanceVertexF ( ) ;
void AdvanceVertices ( int nVerts ) ;
void AdvanceIndex ( ) ;
void AdvanceIndices ( int nIndices ) ;
int GetCurrentVertex ( ) ;
int GetCurrentIndex ( ) ;
// Data retrieval...
const float * Position ( ) const ;
const float * Normal ( ) const ;
unsigned int Color ( ) const ;
unsigned char * Specular ( ) const ;
const float * TexCoord ( int stage ) const ;
const float * TangentS ( ) const ;
const float * TangentT ( ) const ;
const float * BoneWeight ( ) const ;
float Wrinkle ( ) const ;
int NumBoneWeights ( ) const ;
# ifndef NEW_SKINNING
unsigned char * BoneMatrix ( ) const ;
# else
float * BoneMatrix ( ) const ;
# endif
unsigned short const * Index ( ) const ;
// position setting
void Position3f ( float x , float y , float z ) ;
void Position3fv ( const float * v ) ;
// normal setting
void Normal3f ( float nx , float ny , float nz ) ;
void Normal3fv ( const float * n ) ;
void NormalDelta3fv ( const float * n ) ;
void NormalDelta3f ( float nx , float ny , float nz ) ;
// normal setting (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedNormal3f ( float nx , float ny , float nz ) ;
template < VertexCompressionType_t T > void CompressedNormal3fv ( const float * n ) ;
// color setting
void Color3f ( float r , float g , float b ) ;
void Color3fv ( const float * rgb ) ;
void Color4f ( float r , float g , float b , float a ) ;
void Color4fv ( const float * rgba ) ;
// Faster versions of color
void Color3ub ( unsigned char r , unsigned char g , unsigned char b ) ;
void Color3ubv ( unsigned char const * rgb ) ;
void Color4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a ) ;
void Color4ubv ( unsigned char const * rgba ) ;
// specular color setting
void Specular3f ( float r , float g , float b ) ;
void Specular3fv ( const float * rgb ) ;
void Specular4f ( float r , float g , float b , float a ) ;
void Specular4fv ( const float * rgba ) ;
// Faster version of specular
void Specular3ub ( unsigned char r , unsigned char g , unsigned char b ) ;
void Specular3ubv ( unsigned char const * c ) ;
void Specular4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a ) ;
void Specular4ubv ( unsigned char const * c ) ;
// texture coordinate setting
void TexCoord1f ( int stage , float s ) ;
void TexCoord2f ( int stage , float s , float t ) ;
void TexCoord2fv ( int stage , const float * st ) ;
void TexCoord3f ( int stage , float s , float t , float u ) ;
void TexCoord3fv ( int stage , const float * stu ) ;
void TexCoord4f ( int stage , float s , float t , float u , float w ) ;
void TexCoord4fv ( int stage , const float * stuv ) ;
void TexCoordSubRect2f ( int stage , float s , float t , float offsetS , float offsetT , float scaleS , float scaleT ) ;
void TexCoordSubRect2fv ( int stage , const float * st , const float * offset , const float * scale ) ;
// tangent space
void TangentS3f ( float sx , float sy , float sz ) ;
void TangentS3fv ( const float * s ) ;
void TangentT3f ( float tx , float ty , float tz ) ;
void TangentT3fv ( const float * t ) ;
// Wrinkle
void Wrinkle1f ( float flWrinkle ) ;
// bone weights
void BoneWeight ( int idx , float weight ) ;
// bone weights (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedBoneWeight3fv ( const float * pWeights ) ;
// bone matrix index
void BoneMatrix ( int idx , int matrixIndex ) ;
// Generic per-vertex data
void UserData ( const float * pData ) ;
// Generic per-vertex data (templatized for code which needs to support compressed vertices)
template < VertexCompressionType_t T > void CompressedUserData ( const float * pData ) ;
// Used to define the indices (only used if you aren't using primitives)
void Index ( unsigned short index ) ;
// NOTE: Use this one to get write combining! Much faster than the other version of FastIndex
// Fast Index! No need to call advance index, and no random access allowed
void FastIndex2 ( unsigned short nIndex1 , unsigned short nIndex2 ) ;
// Fast Index! No need to call advance index, and no random access allowed
void FastIndex ( unsigned short index ) ;
// Fast Vertex! No need to call advance vertex, and no random access allowed.
// WARNING - these are low level functions that are intended only for use
// in the software vertex skinner.
void FastVertex ( const ModelVertexDX7_t & vertex ) ;
void FastVertexSSE ( const ModelVertexDX7_t & vertex ) ;
// store 4 dx7 vertices fast. for special sse dx7 pipeline
void Fast4VerticesSSE (
ModelVertexDX7_t const * vtx_a ,
ModelVertexDX7_t const * vtx_b ,
ModelVertexDX7_t const * vtx_c ,
ModelVertexDX7_t const * vtx_d ) ;
void FastVertex ( const ModelVertexDX8_t & vertex ) ;
void FastVertexSSE ( const ModelVertexDX8_t & vertex ) ;
// Add number of verts and current vert since FastVertexxx routines do not update.
void FastAdvanceNVertices ( int n ) ;
# if defined( _X360 )
void VertexDX8ToX360 ( const ModelVertexDX8_t & vertex ) ;
# endif
private :
// Computes number of verts and indices
void ComputeNumVertsAndIndices ( int * pMaxVertices , int * pMaxIndices ,
MaterialPrimitiveType_t type , int nPrimitiveCount ) ;
int IndicesFromVertices ( MaterialPrimitiveType_t type , int nVertexCount ) ;
// The mesh we're modifying
IMesh * m_pMesh ;
MaterialPrimitiveType_t m_Type ;
// Generate indices?
bool m_bGenerateIndices ;
CIndexBuilder m_IndexBuilder ;
CVertexBuilder m_VertexBuilder ;
} ;
//-----------------------------------------------------------------------------
// Forward compat
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : Begin ( IVertexBuffer * pVertexBuffer , MaterialPrimitiveType_t type , int numPrimitives )
{
Assert ( 0 ) ;
// Begin( pVertexBuffer->GetMesh(), type, numPrimitives );
}
inline void CMeshBuilder : : Begin ( IVertexBuffer * pVertexBuffer , IIndexBuffer * pIndexBuffer , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount , int * nFirstVertex )
{
Assert ( 0 ) ;
// Begin( pVertexBuffer->GetMesh(), type, nVertexCount, nIndexCount, nFirstVertex );
}
inline void CMeshBuilder : : Begin ( IVertexBuffer * pVertexBuffer , IIndexBuffer * pIndexBuffer , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount )
{
Assert ( 0 ) ;
// Begin( pVertexBuffer->GetMesh(), type, nVertexCount, nIndexCount );
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
inline CMeshBuilder : : CMeshBuilder ( ) : m_pMesh ( 0 ) , m_bGenerateIndices ( false )
{
}
//-----------------------------------------------------------------------------
// Computes the number of verts and indices based on primitive type and count
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : ComputeNumVertsAndIndices ( int * pMaxVertices , int * pMaxIndices ,
MaterialPrimitiveType_t type , int nPrimitiveCount )
{
switch ( type )
{
case MATERIAL_POINTS :
* pMaxVertices = * pMaxIndices = nPrimitiveCount ;
break ;
case MATERIAL_LINES :
* pMaxVertices = * pMaxIndices = nPrimitiveCount * 2 ;
break ;
case MATERIAL_LINE_STRIP :
* pMaxVertices = nPrimitiveCount + 1 ;
* pMaxIndices = nPrimitiveCount * 2 ;
break ;
case MATERIAL_LINE_LOOP :
* pMaxVertices = nPrimitiveCount ;
* pMaxIndices = nPrimitiveCount * 2 ;
break ;
case MATERIAL_TRIANGLES :
* pMaxVertices = * pMaxIndices = nPrimitiveCount * 3 ;
break ;
case MATERIAL_TRIANGLE_STRIP :
* pMaxVertices = * pMaxIndices = nPrimitiveCount + 2 ;
break ;
case MATERIAL_QUADS :
* pMaxVertices = nPrimitiveCount * 4 ;
* pMaxIndices = nPrimitiveCount * 6 ;
break ;
case MATERIAL_INSTANCED_QUADS :
* pMaxVertices = nPrimitiveCount ;
* pMaxIndices = 0 ; // This primtype is unindexed
break ;
case MATERIAL_POLYGON :
* pMaxVertices = nPrimitiveCount ;
* pMaxIndices = ( nPrimitiveCount - 2 ) * 3 ;
break ;
default :
* pMaxVertices = 0 ;
* pMaxIndices = 0 ;
Assert ( 0 ) ;
}
// FIXME: need to get this from meshdx8.cpp, or move it to somewhere common
Assert ( * pMaxVertices < = 32768 ) ;
Assert ( * pMaxIndices < = 32768 ) ;
}
inline int CMeshBuilder : : IndicesFromVertices ( MaterialPrimitiveType_t type , int nVertexCount )
{
switch ( type )
{
case MATERIAL_QUADS :
Assert ( ( nVertexCount & 0x3 ) = = 0 ) ;
return ( nVertexCount * 6 ) / 4 ;
case MATERIAL_INSTANCED_QUADS :
// This primtype is unindexed
return 0 ;
case MATERIAL_POLYGON :
Assert ( nVertexCount > = 3 ) ;
return ( nVertexCount - 2 ) * 3 ;
case MATERIAL_LINE_STRIP :
Assert ( nVertexCount > = 2 ) ;
return ( nVertexCount - 1 ) * 2 ;
case MATERIAL_LINE_LOOP :
Assert ( nVertexCount > = 3 ) ;
return nVertexCount * 2 ;
default :
return nVertexCount ;
}
}
//-----------------------------------------------------------------------------
// Specify the type of vertex compression that this CMeshBuilder will perform
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : SetCompressionType ( VertexCompressionType_t vertexCompressionType )
{
m_VertexBuilder . SetCompressionType ( vertexCompressionType ) ;
}
//-----------------------------------------------------------------------------
// Begins modifying the mesh
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int numPrimitives )
{
Assert ( pMesh & & ( ! m_pMesh ) ) ;
Assert ( type ! = MATERIAL_HETEROGENOUS ) ;
m_pMesh = pMesh ;
m_bGenerateIndices = true ;
m_Type = type ;
int nMaxVertexCount , nMaxIndexCount ;
ComputeNumVertsAndIndices ( & nMaxVertexCount , & nMaxIndexCount , type , numPrimitives ) ;
switch ( type )
{
case MATERIAL_INSTANCED_QUADS :
m_pMesh - > SetPrimitiveType ( MATERIAL_INSTANCED_QUADS ) ;
break ;
case MATERIAL_QUADS :
case MATERIAL_POLYGON :
m_pMesh - > SetPrimitiveType ( MATERIAL_TRIANGLES ) ;
break ;
case MATERIAL_LINE_STRIP :
case MATERIAL_LINE_LOOP :
m_pMesh - > SetPrimitiveType ( MATERIAL_LINES ) ;
break ;
default :
m_pMesh - > SetPrimitiveType ( type ) ;
}
// Lock the mesh
m_pMesh - > LockMesh ( nMaxVertexCount , nMaxIndexCount , * this ) ;
m_IndexBuilder . AttachBegin ( pMesh , nMaxIndexCount , * this ) ;
m_VertexBuilder . AttachBegin ( pMesh , nMaxVertexCount , * this ) ;
// Point to the start of the index and vertex buffers
Reset ( ) ;
}
inline void CMeshBuilder : : Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount , int * nFirstVertex )
{
Begin ( pMesh , type , nVertexCount , nIndexCount ) ;
* nFirstVertex = m_VertexBuilder . m_nFirstVertex * m_VertexBuilder . VertexSize ( ) ;
}
inline void CMeshBuilder : : Begin ( IMesh * pMesh , MaterialPrimitiveType_t type , int nVertexCount , int nIndexCount )
{
Assert ( pMesh & & ( ! m_pMesh ) ) ;
// NOTE: We can't specify the indices when we use quads, polygons, or
// linestrips; they aren't actually directly supported by
// the material system
Assert ( ( type ! = MATERIAL_QUADS ) & & ( type ! = MATERIAL_INSTANCED_QUADS ) & & ( type ! = MATERIAL_POLYGON ) & &
( type ! = MATERIAL_LINE_STRIP ) & & ( type ! = MATERIAL_LINE_LOOP ) ) ;
// Dx8 doesn't support indexed points...
Assert ( type ! = MATERIAL_POINTS ) ;
m_pMesh = pMesh ;
m_bGenerateIndices = false ;
m_Type = type ;
// Set the primitive type
m_pMesh - > SetPrimitiveType ( type ) ;
// Lock the vertex and index buffer
m_pMesh - > LockMesh ( nVertexCount , nIndexCount , * this ) ;
m_IndexBuilder . AttachBegin ( pMesh , nIndexCount , * this ) ;
m_VertexBuilder . AttachBegin ( pMesh , nVertexCount , * this ) ;
// Point to the start of the buffers..
Reset ( ) ;
}
//-----------------------------------------------------------------------------
// Use this when you're done modifying the mesh
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : End ( bool bSpewData , bool bDraw )
{
if ( m_bGenerateIndices )
{
int nIndexCount = IndicesFromVertices ( m_Type , m_VertexBuilder . VertexCount ( ) ) ;
m_IndexBuilder . GenerateIndices ( m_Type , nIndexCount ) ;
}
if ( bSpewData )
{
m_pMesh - > Spew ( m_VertexBuilder . VertexCount ( ) , m_IndexBuilder . IndexCount ( ) , * this ) ;
}
# ifdef _DEBUG
m_pMesh - > ValidateData ( m_VertexBuilder . VertexCount ( ) , m_IndexBuilder . IndexCount ( ) , * this ) ;
# endif
// Unlock our buffers
m_pMesh - > UnlockMesh ( m_VertexBuilder . VertexCount ( ) , m_IndexBuilder . IndexCount ( ) , * this ) ;
m_IndexBuilder . AttachEnd ( ) ;
m_VertexBuilder . AttachEnd ( ) ;
if ( bDraw )
{
m_pMesh - > Draw ( ) ;
}
m_pMesh = 0 ;
# ifdef _DEBUG
memset ( ( MeshDesc_t * ) this , 0 , sizeof ( MeshDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// Locks the vertex buffer to modify existing data
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : BeginModify ( IMesh * pMesh , int nFirstVertex , int nVertexCount , int nFirstIndex , int nIndexCount )
{
Assert ( pMesh & & ( ! m_pMesh ) ) ;
if ( nVertexCount < 0 )
{
nVertexCount = pMesh - > VertexCount ( ) ;
}
m_pMesh = pMesh ;
m_bGenerateIndices = false ;
// Locks mesh for modifying
pMesh - > ModifyBeginEx ( false , nFirstVertex , nVertexCount , nFirstIndex , nIndexCount , * this ) ;
m_IndexBuilder . AttachBeginModify ( pMesh , nFirstIndex , nIndexCount , * this ) ;
m_VertexBuilder . AttachBeginModify ( pMesh , nFirstVertex , nVertexCount , * this ) ;
// Point to the start of the buffers..
Reset ( ) ;
}
inline void CMeshBuilder : : EndModify ( bool bSpewData )
{
Assert ( m_pMesh ) ;
if ( bSpewData )
{
m_pMesh - > Spew ( m_VertexBuilder . VertexCount ( ) , m_IndexBuilder . IndexCount ( ) , * this ) ;
}
# ifdef _DEBUG
m_pMesh - > ValidateData ( m_VertexBuilder . VertexCount ( ) , m_IndexBuilder . IndexCount ( ) , * this ) ;
# endif
// Unlocks mesh
m_pMesh - > ModifyEnd ( * this ) ;
m_pMesh = 0 ;
m_IndexBuilder . AttachEndModify ( ) ;
m_VertexBuilder . AttachEndModify ( ) ;
# ifdef _DEBUG
// Null out our pointers...
memset ( ( MeshDesc_t * ) this , 0 , sizeof ( MeshDesc_t ) ) ;
# endif
}
//-----------------------------------------------------------------------------
// Resets the mesh builder so it points to the start of everything again
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : Reset ( )
{
m_IndexBuilder . Reset ( ) ;
m_VertexBuilder . Reset ( ) ;
}
//-----------------------------------------------------------------------------
// Selects the current Vertex and Index
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : SelectVertex ( int nIndex )
{
m_VertexBuilder . SelectVertex ( nIndex ) ;
}
inline void CMeshBuilder : : SelectVertexFromIndex ( int idx )
{
// NOTE: This index is expected to be relative
int vertIdx = idx - m_nFirstVertex ;
SelectVertex ( vertIdx ) ;
}
FORCEINLINE void CMeshBuilder : : SelectIndex ( int idx )
{
m_IndexBuilder . SelectIndex ( idx ) ;
}
//-----------------------------------------------------------------------------
// Advances the current vertex and index by one
//-----------------------------------------------------------------------------
template < int nFlags , int nNumTexCoords > FORCEINLINE void CMeshBuilder : : AdvanceVertexF ( )
{
m_VertexBuilder . AdvanceVertexF < nFlags , nNumTexCoords > ( ) ;
}
FORCEINLINE void CMeshBuilder : : AdvanceVertex ( )
{
m_VertexBuilder . AdvanceVertex ( ) ;
}
FORCEINLINE void CMeshBuilder : : AdvanceVertices ( int nVertexCount )
{
m_VertexBuilder . AdvanceVertices ( nVertexCount ) ;
}
FORCEINLINE void CMeshBuilder : : AdvanceIndex ( )
{
m_IndexBuilder . AdvanceIndex ( ) ;
}
FORCEINLINE void CMeshBuilder : : AdvanceIndices ( int nIndices )
{
m_IndexBuilder . AdvanceIndices ( nIndices ) ;
}
FORCEINLINE int CMeshBuilder : : GetCurrentVertex ( )
{
return m_VertexBuilder . GetCurrentVertex ( ) ;
}
FORCEINLINE int CMeshBuilder : : GetCurrentIndex ( )
{
return m_IndexBuilder . GetCurrentIndex ( ) ;
}
//-----------------------------------------------------------------------------
// A helper method since this seems to be done a whole bunch.
//-----------------------------------------------------------------------------
inline void CMeshBuilder : : DrawQuad ( IMesh * pMesh , const float * v1 , const float * v2 ,
const float * v3 , const float * v4 , unsigned char const * pColor , bool wireframe )
{
if ( ! wireframe )
{
Begin ( pMesh , MATERIAL_TRIANGLE_STRIP , 2 ) ;
Position3fv ( v1 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v2 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v4 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v3 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
}
else
{
Begin ( pMesh , MATERIAL_LINE_LOOP , 4 ) ;
Position3fv ( v1 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v2 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v3 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
Position3fv ( v4 ) ;
Color4ubv ( pColor ) ;
AdvanceVertexF < VTX_HAVEPOS | VTX_HAVECOLOR , 0 > ( ) ;
}
End ( ) ;
pMesh - > Draw ( ) ;
}
//-----------------------------------------------------------------------------
// returns the number of indices and vertices
//-----------------------------------------------------------------------------
FORCEINLINE int CMeshBuilder : : VertexCount ( ) const
{
return m_VertexBuilder . VertexCount ( ) ;
}
FORCEINLINE int CMeshBuilder : : IndexCount ( ) const
{
return m_IndexBuilder . IndexCount ( ) ;
}
//-----------------------------------------------------------------------------
// Returns the base vertex memory pointer
//-----------------------------------------------------------------------------
FORCEINLINE void * CMeshBuilder : : BaseVertexData ( )
{
return m_VertexBuilder . BaseVertexData ( ) ;
}
//-----------------------------------------------------------------------------
// Data retrieval...
//-----------------------------------------------------------------------------
FORCEINLINE const float * CMeshBuilder : : Position ( ) const
{
return m_VertexBuilder . Position ( ) ;
}
FORCEINLINE const float * CMeshBuilder : : Normal ( ) const
{
return m_VertexBuilder . Normal ( ) ;
}
FORCEINLINE unsigned int CMeshBuilder : : Color ( ) const
{
return m_VertexBuilder . Color ( ) ;
}
FORCEINLINE unsigned char * CMeshBuilder : : Specular ( ) const
{
return m_VertexBuilder . Specular ( ) ;
}
FORCEINLINE const float * CMeshBuilder : : TexCoord ( int nStage ) const
{
return m_VertexBuilder . TexCoord ( nStage ) ;
}
FORCEINLINE const float * CMeshBuilder : : TangentS ( ) const
{
return m_VertexBuilder . TangentS ( ) ;
}
FORCEINLINE const float * CMeshBuilder : : TangentT ( ) const
{
return m_VertexBuilder . TangentT ( ) ;
}
FORCEINLINE float CMeshBuilder : : Wrinkle ( ) const
{
return m_VertexBuilder . Wrinkle ( ) ;
}
FORCEINLINE const float * CMeshBuilder : : BoneWeight ( ) const
{
return m_VertexBuilder . BoneWeight ( ) ;
}
FORCEINLINE int CMeshBuilder : : NumBoneWeights ( ) const
{
return m_VertexBuilder . NumBoneWeights ( ) ;
}
FORCEINLINE unsigned short const * CMeshBuilder : : Index ( ) const
{
return m_IndexBuilder . Index ( ) ;
}
//-----------------------------------------------------------------------------
// Index
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : Index ( unsigned short idx )
{
m_IndexBuilder . Index ( idx ) ;
}
//-----------------------------------------------------------------------------
// Fast Index! No need to call advance index
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : FastIndex ( unsigned short idx )
{
m_IndexBuilder . FastIndex ( idx ) ;
}
// NOTE: Use this one to get write combining! Much faster than the other version of FastIndex
// Fast Index! No need to call advance index, and no random access allowed
FORCEINLINE void CMeshBuilder : : FastIndex2 ( unsigned short nIndex1 , unsigned short nIndex2 )
{
m_IndexBuilder . FastIndex2 ( nIndex1 , nIndex2 ) ;
}
//-----------------------------------------------------------------------------
// For use with the FastVertex methods, advances the current vertex by N
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : FastAdvanceNVertices ( int nVertexCount )
{
m_VertexBuilder . FastAdvanceNVertices ( nVertexCount ) ;
}
//-----------------------------------------------------------------------------
// Fast Vertex! No need to call advance vertex, and no random access allowed
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : FastVertex ( const ModelVertexDX7_t & vertex )
{
m_VertexBuilder . FastVertex ( vertex ) ;
}
FORCEINLINE void CMeshBuilder : : FastVertexSSE ( const ModelVertexDX7_t & vertex )
{
m_VertexBuilder . FastVertexSSE ( vertex ) ;
}
FORCEINLINE void CMeshBuilder : : Fast4VerticesSSE (
const ModelVertexDX7_t * vtx_a , const ModelVertexDX7_t * vtx_b ,
const ModelVertexDX7_t * vtx_c , const ModelVertexDX7_t * vtx_d )
{
m_VertexBuilder . Fast4VerticesSSE ( vtx_a , vtx_b , vtx_c , vtx_d ) ;
}
FORCEINLINE void CMeshBuilder : : FastVertex ( const ModelVertexDX8_t & vertex )
{
m_VertexBuilder . FastVertex ( vertex ) ;
}
FORCEINLINE void CMeshBuilder : : FastVertexSSE ( const ModelVertexDX8_t & vertex )
{
m_VertexBuilder . FastVertexSSE ( vertex ) ;
}
//-----------------------------------------------------------------------------
// Copies a vertex into the x360 format
//-----------------------------------------------------------------------------
# if defined( _X360 )
inline void CMeshBuilder : : VertexDX8ToX360 ( const ModelVertexDX8_t & vertex )
{
m_VertexBuilder . VertexDX8ToX360 ( vertex ) ;
}
# endif
//-----------------------------------------------------------------------------
// Vertex field setting methods
//-----------------------------------------------------------------------------
FORCEINLINE void CMeshBuilder : : Position3f ( float x , float y , float z )
{
m_VertexBuilder . Position3f ( x , y , z ) ;
}
FORCEINLINE void CMeshBuilder : : Position3fv ( const float * v )
{
m_VertexBuilder . Position3fv ( v ) ;
}
FORCEINLINE void CMeshBuilder : : Normal3f ( float nx , float ny , float nz )
{
m_VertexBuilder . Normal3f ( nx , ny , nz ) ;
}
FORCEINLINE void CMeshBuilder : : Normal3fv ( const float * n )
{
m_VertexBuilder . Normal3fv ( n ) ;
}
FORCEINLINE void CMeshBuilder : : NormalDelta3f ( float nx , float ny , float nz )
{
m_VertexBuilder . NormalDelta3f ( nx , ny , nz ) ;
}
FORCEINLINE void CMeshBuilder : : NormalDelta3fv ( const float * n )
{
m_VertexBuilder . NormalDelta3fv ( n ) ;
}
FORCEINLINE void CMeshBuilder : : Color3f ( float r , float g , float b )
{
m_VertexBuilder . Color3f ( r , g , b ) ;
}
FORCEINLINE void CMeshBuilder : : Color3fv ( const float * rgb )
{
m_VertexBuilder . Color3fv ( rgb ) ;
}
FORCEINLINE void CMeshBuilder : : Color4f ( float r , float g , float b , float a )
{
m_VertexBuilder . Color4f ( r , g , b , a ) ;
}
FORCEINLINE void CMeshBuilder : : Color4fv ( const float * rgba )
{
m_VertexBuilder . Color4fv ( rgba ) ;
}
FORCEINLINE void CMeshBuilder : : Color3ub ( unsigned char r , unsigned char g , unsigned char b )
{
m_VertexBuilder . Color3ub ( r , g , b ) ;
}
FORCEINLINE void CMeshBuilder : : Color3ubv ( unsigned char const * rgb )
{
m_VertexBuilder . Color3ubv ( rgb ) ;
}
FORCEINLINE void CMeshBuilder : : Color4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a )
{
m_VertexBuilder . Color4ub ( r , g , b , a ) ;
}
FORCEINLINE void CMeshBuilder : : Color4ubv ( unsigned char const * rgba )
{
m_VertexBuilder . Color4ubv ( rgba ) ;
}
FORCEINLINE void CMeshBuilder : : Specular3f ( float r , float g , float b )
{
m_VertexBuilder . Specular3f ( r , g , b ) ;
}
FORCEINLINE void CMeshBuilder : : Specular3fv ( const float * rgb )
{
m_VertexBuilder . Specular3fv ( rgb ) ;
}
FORCEINLINE void CMeshBuilder : : Specular4f ( float r , float g , float b , float a )
{
m_VertexBuilder . Specular4f ( r , g , b , a ) ;
}
FORCEINLINE void CMeshBuilder : : Specular4fv ( const float * rgba )
{
m_VertexBuilder . Specular4fv ( rgba ) ;
}
FORCEINLINE void CMeshBuilder : : Specular3ub ( unsigned char r , unsigned char g , unsigned char b )
{
m_VertexBuilder . Specular3ub ( r , g , b ) ;
}
FORCEINLINE void CMeshBuilder : : Specular3ubv ( unsigned char const * c )
{
m_VertexBuilder . Specular3ubv ( c ) ;
}
FORCEINLINE void CMeshBuilder : : Specular4ub ( unsigned char r , unsigned char g , unsigned char b , unsigned char a )
{
m_VertexBuilder . Specular4ub ( r , g , b , a ) ;
}
FORCEINLINE void CMeshBuilder : : Specular4ubv ( unsigned char const * c )
{
m_VertexBuilder . Specular4ubv ( c ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord1f ( int nStage , float s )
{
m_VertexBuilder . TexCoord1f ( nStage , s ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord2f ( int nStage , float s , float t )
{
m_VertexBuilder . TexCoord2f ( nStage , s , t ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord2fv ( int nStage , const float * st )
{
m_VertexBuilder . TexCoord2fv ( nStage , st ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord3f ( int nStage , float s , float t , float u )
{
m_VertexBuilder . TexCoord3f ( nStage , s , t , u ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord3fv ( int nStage , const float * stu )
{
m_VertexBuilder . TexCoord3fv ( nStage , stu ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord4f ( int nStage , float s , float t , float u , float v )
{
m_VertexBuilder . TexCoord4f ( nStage , s , t , u , v ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoord4fv ( int nStage , const float * stuv )
{
m_VertexBuilder . TexCoord4fv ( nStage , stuv ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoordSubRect2f ( int nStage , float s , float t , float offsetS , float offsetT , float scaleS , float scaleT )
{
m_VertexBuilder . TexCoordSubRect2f ( nStage , s , t , offsetS , offsetT , scaleS , scaleT ) ;
}
FORCEINLINE void CMeshBuilder : : TexCoordSubRect2fv ( int nStage , const float * st , const float * offset , const float * scale )
{
m_VertexBuilder . TexCoordSubRect2fv ( nStage , st , offset , scale ) ;
}
FORCEINLINE void CMeshBuilder : : TangentS3f ( float sx , float sy , float sz )
{
m_VertexBuilder . TangentS3f ( sx , sy , sz ) ;
}
FORCEINLINE void CMeshBuilder : : TangentS3fv ( const float * s )
{
m_VertexBuilder . TangentS3fv ( s ) ;
}
FORCEINLINE void CMeshBuilder : : TangentT3f ( float tx , float ty , float tz )
{
m_VertexBuilder . TangentT3f ( tx , ty , tz ) ;
}
FORCEINLINE void CMeshBuilder : : TangentT3fv ( const float * t )
{
m_VertexBuilder . TangentT3fv ( t ) ;
}
FORCEINLINE void CMeshBuilder : : Wrinkle1f ( float flWrinkle )
{
m_VertexBuilder . Wrinkle1f ( flWrinkle ) ;
}
FORCEINLINE void CMeshBuilder : : BoneWeight ( int nIndex , float flWeight )
{
m_VertexBuilder . BoneWeight ( nIndex , flWeight ) ;
}
template < VertexCompressionType_t T > FORCEINLINE void CMeshBuilder : : CompressedBoneWeight3fv ( const float * pWeights )
{
m_VertexBuilder . CompressedBoneWeight3fv < T > ( pWeights ) ;
}
FORCEINLINE void CMeshBuilder : : BoneMatrix ( int nIndex , int nMatrixIdx )
{
m_VertexBuilder . BoneMatrix ( nIndex , nMatrixIdx ) ;
}
FORCEINLINE void CMeshBuilder : : UserData ( const float * pData )
{
m_VertexBuilder . UserData ( pData ) ;
}
template < VertexCompressionType_t T > FORCEINLINE void CMeshBuilder : : CompressedUserData ( const float * pData )
{
m_VertexBuilder . CompressedUserData < T > ( pData ) ;
}
//-----------------------------------------------------------------------------
// Templatized vertex field setting methods which support compression
//-----------------------------------------------------------------------------
template < VertexCompressionType_t T > FORCEINLINE void CMeshBuilder : : CompressedNormal3f ( float nx , float ny , float nz )
{
m_VertexBuilder . CompressedNormal3f < T > ( nx , ny , nz ) ;
}
template < VertexCompressionType_t T > FORCEINLINE void CMeshBuilder : : CompressedNormal3fv ( const float * n )
{
m_VertexBuilder . CompressedNormal3fv < T > ( n ) ;
}
# endif // IMESH_H