diff options
Diffstat (limited to 'sp/src/public/materialsystem/imesh.h')
| -rw-r--r-- | sp/src/public/materialsystem/imesh.h | 8094 |
1 files changed, 4047 insertions, 4047 deletions
diff --git a/sp/src/public/materialsystem/imesh.h b/sp/src/public/materialsystem/imesh.h index 7ee35de9..b71be4d9 100644 --- a/sp/src/public/materialsystem/imesh.h +++ b/sp/src/public/materialsystem/imesh.h @@ -1,4047 +1,4047 @@ -//========= 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 )
-{
- 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
-}
-
-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 )
-{
- 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
-}
-
-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");
-#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:
- 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
+//========= 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 ) +{ + 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 +} + +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 ) +{ + 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 +} + +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"); +#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: + 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 |