diff options
Diffstat (limited to 'materialsystem/shaderapidx9/meshdx8.cpp')
| -rw-r--r-- | materialsystem/shaderapidx9/meshdx8.cpp | 5980 |
1 files changed, 5980 insertions, 0 deletions
diff --git a/materialsystem/shaderapidx9/meshdx8.cpp b/materialsystem/shaderapidx9/meshdx8.cpp new file mode 100644 index 0000000..9a4af9e --- /dev/null +++ b/materialsystem/shaderapidx9/meshdx8.cpp @@ -0,0 +1,5980 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//===========================================================================// + +#define DISABLE_PROTECTED_THINGS +#include "locald3dtypes.h" +#include "imeshdx8.h" +#include "shaderapidx8_global.h" +#include "materialsystem/IShader.h" +#include "tier0/vprof.h" +#include "studio.h" +#include "tier1/fmtstr.h" + +#include "tier0/platform.h" +#include "tier0/systeminformation.h" + +// fixme - stick this in a header file. +#if defined( _DEBUG ) && !defined( _X360 ) +// define this if you want to range check all indices when drawing +#define CHECK_INDICES +#endif +#ifdef CHECK_INDICES +#define CHECK_INDICES_MAX_NUM_STREAMS 2 +#endif + +#include "dynamicib.h" +#include "dynamicvb.h" +#include "utlvector.h" +#include "shaderapi/ishaderapi.h" +#include "imaterialinternal.h" +#include "imaterialsysteminternal.h" +#include "shaderapidx8.h" +#include "shaderapi/ishaderutil.h" +#include "materialsystem/imaterialsystemhardwareconfig.h" +#include "materialsystem/materialsystem_config.h" +#include "materialsystem/ivballoctracker.h" +#include "tier1/strtools.h" +#include "convar.h" +#include "shaderdevicedx8.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +//----------------------------------------------------------------------------- +// Uncomment this to test buffered state +//----------------------------------------------------------------------------- +//#define DEBUG_BUFFERED_MESHES 1 + +#define MAX_DX8_STREAMS 16 + +#define VERTEX_FORMAT_INVALID 0xFFFFFFFFFFFFFFFFull + +// this is hooked into the engines convar +extern ConVar mat_debugalttab; + +//#define DRAW_SELECTION 1 +static bool g_bDrawSelection = true; // only used in DRAW_SELECTION +static unsigned short g_nScratchIndexBuffer[6]; // large enough for a fast quad; used when device is not active +#ifdef _DEBUG +int CVertexBuffer::s_BufferCount = 0; +int CIndexBuffer::s_BufferCount = 0; +#endif + +//----------------------------------------------------------------------------- +// Important enumerations +//----------------------------------------------------------------------------- +enum +{ + VERTEX_BUFFER_SIZE = 32768, + MAX_QUAD_INDICES = 16384, +}; + + +//----------------------------------------------------------------------------- +// +// Code related to vertex buffers start here +// +//----------------------------------------------------------------------------- +class CVertexBufferDx8 : public CVertexBufferBase +{ + typedef CVertexBufferBase BaseClass; + + // Methods of IVertexBuffer +public: + virtual int VertexCount() const; + virtual VertexFormat_t GetVertexFormat() const; + virtual bool IsDynamic() const; + virtual void BeginCastBuffer( VertexFormat_t format ); + virtual void EndCastBuffer( ); + virtual int GetRoomRemaining() const; + virtual bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ); + virtual void Unlock( int nVertexCount, VertexDesc_t &desc ); + +public: + // constructor + CVertexBufferDx8( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroupName ); + virtual ~CVertexBufferDx8(); + + // Allocates, deallocates the index buffer + bool Allocate( ); + void Free(); + + // Returns the vertex size + int VertexSize() const; + + // Only used by dynamic buffers, indicates the next lock should perform a discard. + void Flush(); + + // Returns the D3D buffer + IDirect3DVertexBuffer9* GetDx9Buffer(); + + // Used to measure how much static buffer memory is touched each frame + void HandlePerFrameTextureStats( int nFrame ); + +protected: + IDirect3DVertexBuffer9 *m_pVertexBuffer; + VertexFormat_t m_VertexFormat; + int m_nVertexCount; + int m_nBufferSize; + int m_nFirstUnwrittenOffset; // Used only for dynamic buffers, indicates where it's safe to write (nooverwrite) + + // Is it locked? + bool m_bIsLocked : 1; + bool m_bIsDynamic : 1; + bool m_bFlush : 1; // Used only for dynamic buffers, indicates to discard the next time + +#ifdef VPROF_ENABLED + int m_nVProfFrame; + int *m_pFrameCounter; + int *m_pGlobalCounter; +#endif + +#ifdef _DEBUG + static int s_nBufferCount; +#endif +}; + + +//----------------------------------------------------------------------------- +// +// Code related to index buffers start here +// +//----------------------------------------------------------------------------- +class CIndexBufferDx8 : public CIndexBufferBase +{ + typedef CIndexBufferBase BaseClass; + + // Methods of IIndexBuffer +public: + virtual int IndexCount( ) const; + virtual MaterialIndexFormat_t IndexFormat() const; + virtual int GetRoomRemaining() const; + virtual bool Lock( int nIndexCount, bool bAppend, IndexDesc_t &desc ); + virtual void Unlock( int nIndexCount, IndexDesc_t &desc ); + virtual void BeginCastBuffer( MaterialIndexFormat_t format ); + virtual void EndCastBuffer( ); + virtual bool IsDynamic() const; + virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc ) { Assert(0); } + virtual void ModifyEnd( IndexDesc_t& desc ) { Assert(0); } + +public: + // constructor + CIndexBufferDx8( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroupName ); + virtual ~CIndexBufferDx8(); + + // Allocates, deallocates the index buffer + bool Allocate( ); + void Free(); + + // Returns the index size + int IndexSize() const; + + // Only used by dynamic buffers, indicates the next lock should perform a discard. + void Flush(); + + // Returns the D3D buffer + IDirect3DIndexBuffer9* GetDx9Buffer(); + + // Used to measure how much static buffer memory is touched each frame + void HandlePerFrameTextureStats( int nFrame ); + +#ifdef CHECK_INDICES + unsigned short GetShadowIndex( int i ) const; +#endif + +private: + IDirect3DIndexBuffer9 *m_pIndexBuffer; + MaterialIndexFormat_t m_IndexFormat; + int m_nIndexCount; + int m_nBufferSize; + int m_nFirstUnwrittenOffset; // Used only for dynamic buffers, indicates where it's safe to write (nooverwrite) + + // Is it locked? + bool m_bIsLocked : 1; + bool m_bIsDynamic : 1; + bool m_bFlush : 1; // Used only for dynamic buffers, indicates to discard the next time + +#ifdef CHECK_INDICES + unsigned char *m_pShadowIndices; + void *m_pLockIndexBuffer; + int m_nLockIndexBufferSize; + int m_nLockIndexOffset; +#endif + +#ifdef VPROF_ENABLED + int m_nVProfFrame; +#endif + +#ifdef _DEBUG + static int s_nBufferCount; +#endif +}; + + +//----------------------------------------------------------------------------- +// +// Backward compat mesh code; will go away soon +// +//----------------------------------------------------------------------------- +abstract_class CBaseMeshDX8 : public CMeshBase +{ +public: + // constructor, destructor + CBaseMeshDX8(); + virtual ~CBaseMeshDX8(); + + // FIXME: Make this work! Unsupported methods of IIndexBuffer + IVertexBuffer + virtual bool Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc ) { Assert(0); return false; } + virtual void Unlock( int nWrittenIndexCount, IndexDesc_t& desc ) { Assert(0); } + virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc ) { Assert(0); } + virtual void ModifyEnd( IndexDesc_t& desc ) { Assert(0); } + virtual void Spew( int nIndexCount, const IndexDesc_t & desc ) { Assert(0); } + virtual void ValidateData( int nIndexCount, const IndexDesc_t &desc ) { Assert(0); } + virtual bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ) { Assert(0); return false; } + virtual void Unlock( int nVertexCount, VertexDesc_t &desc ) { Assert(0); } + virtual void Spew( int nVertexCount, const VertexDesc_t &desc ) { Assert(0); } + virtual void ValidateData( int nVertexCount, const VertexDesc_t & desc ) { Assert(0); } + + // Locks mesh for modifying + void ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + void ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + void ModifyEnd( MeshDesc_t& desc ); + + // Sets/gets the vertex format + virtual void SetVertexFormat( VertexFormat_t format ); + virtual VertexFormat_t GetVertexFormat() const; + + // Sets/gets the morph format + virtual void SetMorphFormat( MorphFormat_t format ); + virtual MorphFormat_t GetMorphFormat() const; + // Am I using morph data? + virtual bool IsUsingMorphData() const; + bool IsUsingVertexID() const + { + return ShaderAPI()->GetBoundMaterial()->IsUsingVertexID(); + } + + // Sets the material + virtual void SetMaterial( IMaterial* pMaterial ); + + // returns the # of vertices (static meshes only) + int VertexCount() const { return 0; } + + void SetColorMesh( IMesh *pColorMesh, int nVertexOffsetInBytes ) + { + Assert( 0 ); + } + + void SetFlexMesh( IMesh *pMesh, int nVertexOffsetInBytes ) + { + Assert( pMesh == NULL && nVertexOffsetInBytes == 0 ); + } + + void DisableFlexMesh( ) + { + Assert( 0 ); + } + + void MarkAsDrawn() {} + + bool HasColorMesh( ) const { return false; } + bool HasFlexMesh( ) const { return false; } + + // Draws the mesh + void DrawMesh( ); + + // Begins a pass + void BeginPass( ); + + // Spews the mesh data + virtual void Spew( int nVertexCount, int nIndexCount, const MeshDesc_t & desc ); + + // Call this in debug mode to make sure our data is good. + virtual void ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t & desc ); + + virtual void HandleLateCreation( ) = 0; + + void Draw( CPrimList *pLists, int nLists ); + + // 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 ); + + // returns the primitive type + virtual MaterialPrimitiveType_t GetPrimitiveType() const = 0; + + // Returns the number of indices in a mesh.. + virtual int IndexCount( ) const = 0; + + // FIXME: Make this work! + virtual MaterialIndexFormat_t IndexFormat() const { return MATERIAL_INDEX_FORMAT_16BIT; } + + // NOTE: For dynamic index buffers only! + // Casts the memory of the dynamic index buffer to the appropriate type + virtual void BeginCastBuffer( MaterialIndexFormat_t format ) { Assert(0); } + virtual void BeginCastBuffer( VertexFormat_t format ) { Assert(0); } + virtual void EndCastBuffer( ) { Assert(0); } + virtual int GetRoomRemaining() const { Assert(0); return 0; } + + // returns a static vertex buffer... + virtual CVertexBuffer *GetVertexBuffer() { return 0; } + virtual CIndexBuffer *GetIndexBuffer() { return 0; } + + // Do I need to reset the vertex format? + virtual bool NeedsVertexFormatReset( VertexFormat_t fmt ) const; + + // Do I have enough room? + virtual bool HasEnoughRoom( int nVertexCount, int nIndexCount ) const; + + // Operation to do pre-lock + virtual void PreLock() {} + + virtual unsigned ComputeMemoryUsed(); + + bool m_bMeshLocked; + +protected: + bool DebugTrace() const; + + // The vertex format we're using... + VertexFormat_t m_VertexFormat; + + // The morph format we're using + MorphFormat_t m_MorphFormat; + +#ifdef DBGFLAG_ASSERT + IMaterialInternal* m_pMaterial; + bool m_IsDrawing; +#endif +}; + +//----------------------------------------------------------------------------- +// Implementation of the mesh +//----------------------------------------------------------------------------- +class CMeshDX8 : public CBaseMeshDX8 +{ +public: + // constructor + CMeshDX8( const char *pTextureGroupName ); + virtual ~CMeshDX8(); + + // Locks/unlocks the mesh + void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + + // Locks mesh for modifying + void ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + void ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + void ModifyEnd( MeshDesc_t& desc ); + + // returns the # of vertices (static meshes only) + int VertexCount() const; + + // returns the # of indices + virtual int IndexCount( ) const; + + // Sets up the vertex and index buffers + void UseIndexBuffer( CIndexBuffer* pBuffer ); + void UseVertexBuffer( CVertexBuffer* pBuffer ); + + // returns a static vertex buffer... + CVertexBuffer *GetVertexBuffer() { return m_pVertexBuffer; } + CIndexBuffer *GetIndexBuffer() { return m_pIndexBuffer; } + + void SetColorMesh( IMesh *pColorMesh, int nVertexOffsetInBytes ); + void SetFlexMesh( IMesh *pMesh, int nVertexOffsetInBytes ); + void DisableFlexMesh(); + + virtual void HandleLateCreation( ); + + bool HasColorMesh( ) const; + bool HasFlexMesh( ) const; + + // Draws the mesh + void Draw( int nFirstIndex, int nIndexCount ); + void Draw( CPrimList *pLists, int nLists ); + void DrawInternal( CPrimList *pLists, int nLists ); + + // Draws a single pass + void RenderPass(); + + // Sets the primitive type + void SetPrimitiveType( MaterialPrimitiveType_t type ); + MaterialPrimitiveType_t GetPrimitiveType() const; + + bool IsDynamic() const { return false; } + +protected: + // Sets the render state. + bool SetRenderState( int nVertexOffsetInBytes, int nFirstVertexIdx, VertexFormat_t vertexFormat = VERTEX_FORMAT_INVALID ); + + // Is the vertex format valid? + bool IsValidVertexFormat( VertexFormat_t vertexFormat = VERTEX_FORMAT_INVALID ); + + // Locks/ unlocks the vertex buffer + bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ); + void Unlock( int nVertexCount, VertexDesc_t &desc ); + + // Locks/unlocks the index buffer + // Pass in nFirstIndex=-1 to lock wherever the index buffer is. Pass in a value + // >= 0 to specify where to lock. + int Lock( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t &pIndices ); + void Unlock( int nIndexCount, IndexDesc_t &desc ); + + // computes how many primitives we've got + int NumPrimitives( int nVertexCount, int nIndexCount ) const; + + // Debugging output... + void SpewMaterialVerts( ); + + // Stream source setting methods + void SetVertexIDStreamState( ); + void SetColorStreamState( ); + void SetVertexStreamState( int nVertOffsetInBytes ); + void SetIndexStreamState( int firstVertexIdx ); + + void CheckIndices( CPrimList *pPrim, int numPrimitives ); + + // The vertex and index buffers + CVertexBuffer* m_pVertexBuffer; + CIndexBuffer* m_pIndexBuffer; + + // The current color mesh (to be bound to stream 1) + // The vertex offset allows use of a global, shared color mesh VB + CMeshDX8 * m_pColorMesh; + int m_nColorMeshVertOffsetInBytes; + + CVertexBuffer *m_pFlexVertexBuffer; + + bool m_bHasFlexVerts; + int m_nFlexVertOffsetInBytes; + int m_flexVertCount; + + // Primitive type + MaterialPrimitiveType_t m_Type; + + // Primitive mode + D3DPRIMITIVETYPE m_Mode; + + // Number of primitives + unsigned int m_NumIndices; + unsigned short m_NumVertices; + + // Is it locked? + bool m_IsVBLocked; + bool m_IsIBLocked; + + // Used in rendering sub-parts of the mesh + static CPrimList *s_pPrims; + static int s_nPrims; + static unsigned int s_FirstVertex; // Gets reset during CMeshDX8::DrawInternal + static unsigned int s_NumVertices; + int m_FirstIndex; + +#ifdef RECORDING + int m_LockVertexBufferSize; + void *m_LockVertexBuffer; +#endif + +#if defined( RECORDING ) || defined( CHECK_INDICES ) + void *m_LockIndexBuffer; + int m_LockIndexBufferSize; +#endif + const char *m_pTextureGroupName; + + friend class CMeshMgr; // MESHFIXME +}; + + +//----------------------------------------------------------------------------- +// A little extra stuff for the dynamic version +//----------------------------------------------------------------------------- +class CDynamicMeshDX8 : public CMeshDX8 +{ +public: + // constructor, destructor + CDynamicMeshDX8(); + virtual ~CDynamicMeshDX8(); + + // Initializes the dynamic mesh + void Init( int nBufferId ); + + // Sets the vertex format + virtual void SetVertexFormat( VertexFormat_t format ); + + // Resets the state in case of a task switch + void Reset(); + + // Do I have enough room in the buffer? + bool HasEnoughRoom( int nVertexCount, int nIndexCount ) const; + + // returns the # of indices + int IndexCount( ) const; + + // Locks the mesh + void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + + // Unlocks the mesh + void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + + // Override vertex + index buffer + void OverrideVertexBuffer( CVertexBuffer *pStaticVertexBuffer ); + void OverrideIndexBuffer( CIndexBuffer *pStaticIndexBuffer ); + + // Do I need to reset the vertex format? + bool NeedsVertexFormatReset(VertexFormat_t fmt) const; + + // Draws it + void Draw( int nFirstIndex, int nIndexCount ); + void MarkAsDrawn() { m_HasDrawn = true; } + // Simply draws what's been buffered up immediately, without state change + void DrawSinglePassImmediately(); + + // Operation to do pre-lock + void PreLock(); + + bool IsDynamic() const { return true; } + +private: + // Resets buffering state + void ResetVertexAndIndexCounts(); + + // Buffer Id + int m_nBufferId; + + // total queued vertices + int m_TotalVertices; + int m_TotalIndices; + + // the first vertex and index since the last draw + int m_nFirstVertex; + int m_FirstIndex; + + // Have we drawn since the last lock? + bool m_HasDrawn; + + // Any overrides? + bool m_VertexOverride; + bool m_IndexOverride; +}; + + +//----------------------------------------------------------------------------- +// A mesh that stores temporary vertex data in the correct format (for modification) +//----------------------------------------------------------------------------- +class CTempMeshDX8 : public CBaseMeshDX8 +{ +public: + // constructor, destructor + CTempMeshDX8( bool isDynamic ); + virtual ~CTempMeshDX8(); + + // Sets the material + virtual void SetVertexFormat( VertexFormat_t format ); + + // Locks/unlocks the mesh + void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t &desc ); + void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t &desc ); + + // Locks mesh for modifying + virtual void ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + virtual void ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ); + virtual void ModifyEnd( MeshDesc_t& desc ); + + // Number of indices + vertices + int VertexCount() const; + virtual int IndexCount() const; + virtual bool IsDynamic() const; + + // Sets the primitive type + void SetPrimitiveType( MaterialPrimitiveType_t type ); + MaterialPrimitiveType_t GetPrimitiveType() const; + + // Begins a pass + void BeginPass( ); + + // Draws a single pass + void RenderPass(); + + virtual void HandleLateCreation() + { + Assert( !"TBD - CTempMeshDX8::HandleLateCreation()" ); + } + + // Draws the entire beast + void Draw( int nFirstIndex, int nIndexCount ); + + 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 ); +private: + // Selection mode + void TestSelection( ); + void ClipTriangle( D3DXVECTOR3 **ppVert, float zNear, D3DXMATRIX &proj ); + + CDynamicMeshDX8 *GetDynamicMesh(); + + CUtlVector< unsigned char, CUtlMemoryAligned< unsigned char, 32 > > m_VertexData; + CUtlVector< unsigned short > m_IndexData; + + unsigned short m_VertexSize; + MaterialPrimitiveType_t m_Type; + int m_LockedVerts; + int m_LockedIndices; + bool m_IsDynamic; + + // Used in rendering sub-parts of the mesh + static unsigned int s_NumIndices; + static unsigned int s_FirstIndex; + +#ifdef DBGFLAG_ASSERT + bool m_Locked; + bool m_InPass; +#endif +}; + +#if 0 +//----------------------------------------------------------------------------- +// A mesh that stores temporary vertex data in the correct format (for modification) +//----------------------------------------------------------------------------- +class CTempIndexBufferDX8 : public CIndexBufferBase +{ +public: + // constructor, destructor + CTempIndexBufferDX8( bool isDynamic ); + virtual ~CTempIndexBufferDX8(); + + // Locks/unlocks the mesh + void LockIndexBuffer( int nIndexCount ); + void UnlockMesh( int nIndexCount ); + + // Locks mesh for modifying + virtual void ModifyBeginEx( bool bReadOnly, int nFirstIndex, int nIndexCount ); + virtual void ModifyEnd(); + + // Number of indices + virtual int IndexCount() const; + virtual bool IsDynamic() const; + + virtual void CopyToIndexBuilder( + int iStartIndex, // Which indices to copy. + int nIndices, + int indexOffset, // This is added to each index. + CIndexBuilder &builder ); +private: + // Selection mode + void TestSelection( ); + + CDynamicMeshDX8 *GetDynamicMesh(); + + CUtlVector< unsigned short > m_IndexData; + + MaterialPrimitiveType_t m_Type; + int m_LockedIndices; + bool m_IsDynamic; + + // Used in rendering sub-parts of the mesh + static unsigned int s_NumIndices; + static unsigned int s_FirstIndex; + +#ifdef DBGFLAG_ASSERT + bool m_Locked; + bool m_InPass; +#endif +}; +#endif +//----------------------------------------------------------------------------- +// This is a version that buffers up vertex data so we can blast through it later +//----------------------------------------------------------------------------- +class CBufferedMeshDX8 : public CBaseMeshDX8 +{ +public: + // constructor, destructor + CBufferedMeshDX8(); + virtual ~CBufferedMeshDX8(); + + // checks to see if it was rendered.. + void ResetRendered(); + bool WasNotRendered() const; + + // Sets the mesh we're really going to draw into + void SetMesh( CBaseMeshDX8* pMesh ); + const CBaseMeshDX8* GetMesh() const { return m_pMesh; } + + // Spews the mesh data + virtual void Spew( int nVertexCount, int nIndexCount, const MeshDesc_t &spewDesc ); + + // Sets the vertex format + virtual void SetVertexFormat( VertexFormat_t format ); + virtual VertexFormat_t GetVertexFormat() const; + + // Sets the morph format + virtual void SetMorphFormat( MorphFormat_t format ); + + // Sets the material + void SetMaterial( IMaterial *pMaterial ); + + // returns the number of indices (should never be called!) + virtual int IndexCount() const { Assert(0); return 0; } + virtual MaterialIndexFormat_t IndexFormat() const { Assert(0); return MATERIAL_INDEX_FORMAT_16BIT; } + virtual bool IsDynamic() const { Assert(0); return true; } + virtual void BeginCastBuffer( MaterialIndexFormat_t format ) { Assert(0); } + virtual void EndCastBuffer( ) { Assert(0); } + virtual int GetRoomRemaining() const { Assert(0); return 0; } + + // Locks the mesh + void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ); + + // Sets the primitive type + void SetPrimitiveType( MaterialPrimitiveType_t type ); + MaterialPrimitiveType_t GetPrimitiveType( ) const; + + void ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t & spewDesc ); + + virtual void HandleLateCreation( ) + { + if ( m_pMesh ) + { + m_pMesh->HandleLateCreation(); + } + } + + // Draws it + void Draw( int nFirstIndex, int nIndexCount ); + + // Renders a pass + void RenderPass(); + + // Flushes queued data + void Flush( ); + + void SetFlexMesh( IMesh *pMesh, int nVertexOffsetInBytes ); + +private: + // The actual mesh we need to render.... + CBaseMeshDX8* m_pMesh; + + // The index of the last vertex (for tristrip fixup) + unsigned short m_LastIndex; + + // Extra padding indices for tristrips + unsigned short m_ExtraIndices; + + // Am I currently flushing? + bool m_IsFlushing; + + // has the dynamic mesh been rendered? + bool m_WasRendered; + + // Do I need to flush? + bool m_FlushNeeded; + +#ifdef DEBUG_BUFFERED_MESHES + // for debugging only + bool m_BufferedStateSet; + BufferedState_t m_BufferedState; +#endif +}; + + +//----------------------------------------------------------------------------- +// Implementation of the mesh manager +//----------------------------------------------------------------------------- +class CMeshMgr : public IMeshMgr +{ +public: + // constructor, destructor + CMeshMgr(); + virtual ~CMeshMgr(); + + // Initialize, shutdown + void Init(); + void Shutdown(); + + // Task switch... + void ReleaseBuffers(); + void RestoreBuffers(); + + // Releases all dynamic vertex buffers + void DestroyVertexBuffers(); + + // Flushes the dynamic mesh + void Flush(); + + // Flushes the vertex buffers + void DiscardVertexBuffers(); + + // Creates, destroys static meshes + IMesh *CreateStaticMesh( VertexFormat_t vertexFormat, const char *pTextureBudgetGroup, IMaterial *pMaterial = NULL ); + void DestroyStaticMesh( IMesh *pMesh ); + + // Gets at the dynamic mesh (spoofs it though) + IMesh *GetDynamicMesh( IMaterial *pMaterial, VertexFormat_t vertexFormat, int nHWSkinBoneCount, bool buffered, + IMesh *pVertexOverride, IMesh *pIndexOverride ); + +// ----------------------------------------------------------- +// ------------ New Vertex/Index Buffer interface ---------------------------- + // Do we need support for bForceTempMesh and bSoftwareVertexShader? + // I don't think we use bSoftwareVertexShader anymore. .need to look into bForceTempMesh. + IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup ); + IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup ); + void DestroyVertexBuffer( IVertexBuffer * ); + void DestroyIndexBuffer( IIndexBuffer * ); + // Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams? + IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered = true ); + IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered = true ); + void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions = 1 ); + void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes ); + void Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount ); +// ------------ End ---------------------------- + void RenderPassWithVertexAndIndexBuffers( void ); + + VertexFormat_t GetCurrentVertexFormat( void ) const { return m_CurrentVertexFormat; } + + // Gets at the *actual* dynamic mesh + IMesh* GetActualDynamicMesh( VertexFormat_t vertexFormat ); + IMesh *GetFlexMesh(); + + // Computes vertex format from a list of ingredients + VertexFormat_t ComputeVertexFormat( unsigned int flags, + int numTexCoords, int *pTexCoordDimensions, int numBoneWeights, + int userDataSize ) const; + + // Use fat vertices (for tools) + virtual void UseFatVertices( bool bUseFat ); + + // Returns the number of vertices we can render using the dynamic mesh + virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices ); + virtual int GetMaxVerticesToRender( IMaterial *pMaterial ); + virtual int GetMaxIndicesToRender( ); + + // Returns a vertex buffer appropriate for the flags + CVertexBuffer *FindOrCreateVertexBuffer( int nDynamicBufferId, VertexFormat_t fmt ); + CIndexBuffer *GetDynamicIndexBuffer(); + + // Is the mesh dynamic? + bool IsDynamicMesh( IMesh *pMesh ) const; + bool IsBufferedDynamicMesh( IMesh *pMesh ) const; + + // Is the vertex buffer dynamic? + bool IsDynamicVertexBuffer( IVertexBuffer *pVertexBuffer ) const; + + // Is the index buffer dynamic? + bool IsDynamicIndexBuffer( IIndexBuffer *pIndexBuffer ) const; + + // Returns the vertex size + int VertexFormatSize( VertexFormat_t vertexFormat ) const + { + return CVertexBufferBase::VertexFormatSize( vertexFormat ); + } + + // Computes the vertex buffer pointers + void ComputeVertexDescription( unsigned char *pBuffer, + VertexFormat_t vertexFormat, MeshDesc_t &desc ) const; + + // Returns the number of buffers... + int BufferCount() const + { +#ifdef _DEBUG + return CVertexBuffer::BufferCount() + CIndexBuffer::BufferCount(); +#else + return 0; +#endif + } + + CVertexBuffer *GetVertexIDBuffer(); + + IVertexBuffer *GetDynamicVertexBuffer( IMaterial *pMaterial, bool buffered = true ); + IIndexBuffer *GetDynamicIndexBuffer( IMaterial *pMaterial, bool buffered = true ); + virtual void MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords ); + + int UnusedVertexFields() const { return m_nUnusedVertexFields; } + int UnusedTextureCoords() const { return m_nUnusedTextureCoords; } + + IDirect3DVertexBuffer9 *GetZeroVertexBuffer() const { return m_pZeroVertexBuffer; } + +private: + void SetVertexIDStreamState( ); + void SetColorStreamState( ); + void SetVertexStreamState( int nVertOffsetInBytes, int nVertexStride ); + void SetIndexStreamState( int firstVertexIdx ); + bool SetRenderState( int nVertexOffsetInBytes, int nFirstVertexIdx, VertexFormat_t vertexFormat, int nVertexStride ); + + struct VertexBufferLookup_t + { + CVertexBuffer* m_pBuffer; + int m_VertexSize; + }; + + void CopyStaticMeshIndexBufferToTempMeshIndexBuffer( CTempMeshDX8 *pDstIndexMesh, CMeshDX8 *pSrcIndexMesh ); + + // Cleans up the class + void CleanUp(); + + // Creates, destroys the dynamic index + void CreateDynamicIndexBuffer(); + void DestroyDynamicIndexBuffer(); + + // Creates, destroys the vertexID buffer + void CreateVertexIDBuffer(); + void DestroyVertexIDBuffer(); + void CreateZeroVertexBuffer(); + void DestroyZeroVertexBuffer(); + + // Fills a vertexID buffer + void FillVertexIDBuffer( CVertexBuffer *pVertexIDBuffer, int nCount ); + + // The dynamic index buffer + CIndexBuffer *m_pDynamicIndexBuffer; + + // A static vertexID buffer + CVertexBuffer *m_pVertexIDBuffer; + + // The dynamic vertex buffers + CUtlVector< VertexBufferLookup_t > m_DynamicVertexBuffers; + + // The buffered mesh + CBufferedMeshDX8 m_BufferedMesh; + + // The current dynamic mesh + CDynamicMeshDX8 m_DynamicMesh; + CDynamicMeshDX8 m_DynamicFlexMesh; + + // The current dynamic vertex buffer + CVertexBufferDx8 m_DynamicVertexBuffer; + + // The current dynamic index buffer + CIndexBufferDx8 m_DynamicIndexBuffer; + + // The dynamic mesh temp version (for shaders that modify vertex data) + CTempMeshDX8 m_DynamicTempMesh; + + // Am I buffering or not? + bool m_BufferedMode; + + // Using fat vertices? + bool m_bUseFatVertices; + + CVertexBufferDx8 *m_pCurrentVertexBuffer; + VertexFormat_t m_CurrentVertexFormat; + int m_pVertexBufferOffset[MAX_DX8_STREAMS]; + int m_pCurrentVertexStride[MAX_DX8_STREAMS]; + int m_pFirstVertex[MAX_DX8_STREAMS]; + int m_pVertexCount[MAX_DX8_STREAMS]; + CIndexBufferBase *m_pCurrentIndexBuffer; + int m_nIndexBufferOffset; + MaterialPrimitiveType_t m_PrimitiveType; + int m_nFirstIndex; + int m_nNumIndices; + + unsigned int m_nUnusedVertexFields; + unsigned int m_nUnusedTextureCoords; + + // 4096 byte static VB containing all-zeros + IDirect3DVertexBuffer9 *m_pZeroVertexBuffer; +}; + +//----------------------------------------------------------------------------- +// Singleton... +//----------------------------------------------------------------------------- +static CMeshMgr g_MeshMgr; +IMeshMgr* MeshMgr() +{ + return &g_MeshMgr; +} + +//----------------------------------------------------------------------------- +// Tracks stream state and queued data +//----------------------------------------------------------------------------- +static CIndexBuffer *g_pLastIndex = NULL; +static IDirect3DIndexBuffer9 *g_pLastIndexBuffer = NULL; +static CVertexBuffer *g_pLastVertex = NULL; +static IDirect3DVertexBuffer9 *g_pLastVertexBuffer = NULL; +static int g_nLastVertOffsetInBytes = 0; +static int g_nLastVertStride = 0; +static int g_LastVertexIdx = -1; +static CMeshDX8 *g_pLastColorMesh = NULL; +static int g_nLastColorMeshVertOffsetInBytes = 0; +static bool g_bUsingVertexID = false; +static bool g_bFlexMeshStreamSet = false; +static VertexFormat_t g_LastVertexFormat = 0; + +inline void D3DSetStreamSource( unsigned int streamNumber, IDirect3DVertexBuffer9 *pStreamData, + unsigned int nVertexOffsetInBytes, unsigned int stride ) +{ + Dx9Device()->SetStreamSource( streamNumber, pStreamData, nVertexOffsetInBytes, stride ); +} + + +//----------------------------------------------------------------------------- +// Tracks stream state and queued data +//----------------------------------------------------------------------------- +void Unbind( IDirect3DIndexBuffer9 *pIndexBuffer ) +{ +#ifdef _X360 + IDirect3DIndexBuffer9 *pBoundBuffer; + Dx9Device()->GetIndices( &pBoundBuffer ); + if ( pBoundBuffer == pIndexBuffer ) + { + // xboxissue - cannot lock indexes set in a d3d device, clear possibly set indices + Dx9Device()->SetIndices( NULL ); + g_pLastIndex = NULL; + g_pLastIndexBuffer = NULL; + } + + if ( pBoundBuffer ) + { + pBoundBuffer->Release(); + } +#endif +} + +void Unbind( IDirect3DVertexBuffer9 *pVertexBuffer ) +{ +#ifdef _X360 + UINT nOffset, nStride; + IDirect3DVertexBuffer9 *pBoundBuffer; + for ( int i = 0; i < MAX_DX8_STREAMS; ++i ) + { + Dx9Device()->GetStreamSource( i, &pBoundBuffer, &nOffset, &nStride ); + if ( pBoundBuffer == pVertexBuffer ) + { + // xboxissue - cannot lock indexes set in a d3d device, clear possibly set indices + Dx9Device()->SetStreamSource( i, 0, 0, 0 ); + switch ( i ) + { + case 0: + g_pLastVertex = NULL; + g_pLastVertexBuffer = NULL; + break; + + case 1: + g_pLastColorMesh = NULL; + g_nLastColorMeshVertOffsetInBytes = 0; + break; + } + } + + if ( pBoundBuffer ) + { + pBoundBuffer->Release(); + } + } +#endif +} + + +//----------------------------------------------------------------------------- +// Helpers to count texture coordinates +//----------------------------------------------------------------------------- +static int NumTextureCoordinates( VertexFormat_t vertexFormat ) +{ + int nTexCoordCount = 0; + for ( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i ) + { + if ( TexCoordSize( i, vertexFormat ) == 0 ) + continue; + ++nTexCoordCount; + } + return nTexCoordCount; +} + + +//----------------------------------------------------------------------------- +// Makes sure that the render state is always set next time +//----------------------------------------------------------------------------- +static void ResetMeshRenderState() +{ + SafeRelease( &g_pLastIndex ); + g_pLastIndexBuffer = 0; + g_pLastVertex = 0; + g_nLastVertOffsetInBytes = 0; + g_pLastColorMesh = 0; + g_nLastColorMeshVertOffsetInBytes = 0; + g_LastVertexIdx = -1; + g_bUsingVertexID = false; + g_bFlexMeshStreamSet = false; + g_LastVertexFormat = 0; +} + +//----------------------------------------------------------------------------- +// Makes sure that the render state is always set next time +//----------------------------------------------------------------------------- +static void ResetIndexBufferRenderState() +{ + SafeRelease( &g_pLastIndex ); + g_pLastIndexBuffer = 0; + g_LastVertexIdx = -1; +} + + +//----------------------------------------------------------------------------- +// +// Index Buffer implementations begin here +// +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// Globals +//----------------------------------------------------------------------------- +#ifdef _DEBUG +int CIndexBufferDx8::s_nBufferCount = 0; +#endif + + +//----------------------------------------------------------------------------- +// Constructor, destructor +//----------------------------------------------------------------------------- +CIndexBufferDx8::CIndexBufferDx8( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroupName ) : + BaseClass( pBudgetGroupName ) +{ +// Debugger(); + + Assert( nIndexCount != 0 ); + + // NOTE: MATERIAL_INDEX_FORMAT_UNKNOWN can't be dealt with under dx9 + // because format is bound at buffer creation time. What we'll do + // is just arbitrarily choose to use a 16-bit index buffer of the same size + if ( fmt == MATERIAL_INDEX_FORMAT_UNKNOWN ) + { + fmt = MATERIAL_INDEX_FORMAT_16BIT; + nIndexCount /= 2; + } + + m_pIndexBuffer = NULL; + m_IndexFormat = fmt; + m_nBufferSize = nIndexCount * IndexSize(); + m_nIndexCount = nIndexCount; + m_nFirstUnwrittenOffset = 0; + m_bIsLocked = false; + m_bIsDynamic = IsDynamicBufferType( bufferType ); + m_bFlush = false; + +#ifdef CHECK_INDICES + m_pShadowIndices = NULL; +#endif + +#ifdef VPROF_ENABLED + m_nVProfFrame = -1; +#endif +} + +CIndexBufferDx8::~CIndexBufferDx8() +{ + Free(); +} + + +//----------------------------------------------------------------------------- +// Returns the index size +//----------------------------------------------------------------------------- +inline int CIndexBufferDx8::IndexSize() const +{ + Assert( m_IndexFormat != MATERIAL_INDEX_FORMAT_UNKNOWN ); + return ( m_IndexFormat == MATERIAL_INDEX_FORMAT_16BIT ) ? 2 : 4; +} + + +//----------------------------------------------------------------------------- +// Creates, destroys the index buffer +//----------------------------------------------------------------------------- +bool CIndexBufferDx8::Allocate() +{ +#ifdef OSX + Debugger(); +#endif + Assert( !m_pIndexBuffer ); + m_nFirstUnwrittenOffset = 0; + + // FIXME: This doesn't really work for dynamic buffers; dynamic buffers + // can't have mixed-type indices in them. Bleah. + D3DFORMAT format = ( m_IndexFormat == MATERIAL_INDEX_FORMAT_32BIT ) ? + D3DFMT_INDEX32 : D3DFMT_INDEX16; + + DWORD usage = D3DUSAGE_WRITEONLY; + if ( m_bIsDynamic ) + { + usage |= D3DUSAGE_DYNAMIC; + } + + HRESULT hr = Dx9Device()->CreateIndexBuffer( + m_nBufferSize, usage, format, D3DPOOL_DEFAULT, &m_pIndexBuffer, NULL ); + +#if !defined( _X360 ) + if ( ( hr == D3DERR_OUTOFVIDEOMEMORY ) || ( hr == E_OUTOFMEMORY ) ) + { + // Don't have the memory for this. Try flushing all managed resources + // out of vid mem and try again. + // FIXME: need to record this + Dx9Device()->EvictManagedResources(); + hr = Dx9Device()->CreateIndexBuffer( + m_nBufferSize, usage, format, D3DPOOL_DEFAULT, &m_pIndexBuffer, NULL ); + } +#endif // !X360 + + if ( FAILED(hr) || ( m_pIndexBuffer == NULL ) ) + { + Warning( "CIndexBufferDx8::Allocate: CreateIndexBuffer failed!\n" ); + return false; + } + + if ( !m_bIsDynamic ) + { + VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_global_" TEXTURE_GROUP_STATIC_INDEX_BUFFER, + COUNTER_GROUP_TEXTURE_GLOBAL, m_nBufferSize ); + } + else + { + VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_global_" TEXTURE_GROUP_DYNAMIC_INDEX_BUFFER, + COUNTER_GROUP_TEXTURE_GLOBAL, m_nBufferSize ); + } + +#ifdef CHECK_INDICES + Assert ( !m_pShadowIndices ); + m_pShadowIndices = new unsigned char[ m_nBufferSize ]; + memset( m_pShadowIndices, 0xFF, m_nBufferSize ); +#endif // CHECK_INDICES + +#ifdef _DEBUG + ++s_nBufferCount; +#endif + + return true; +} + +void CIndexBufferDx8::Free() +{ +// FIXME: Unlock(0); + if ( m_pIndexBuffer ) + { +#ifdef _DEBUG + --s_nBufferCount; +#endif + + m_pIndexBuffer->Release(); + m_pIndexBuffer = NULL; + + if ( !m_bIsDynamic ) + { + VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_global_" TEXTURE_GROUP_STATIC_INDEX_BUFFER, + COUNTER_GROUP_TEXTURE_GLOBAL, - m_nBufferSize ); + } + else + { + VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_global_" TEXTURE_GROUP_DYNAMIC_INDEX_BUFFER, + COUNTER_GROUP_TEXTURE_GLOBAL, - m_nBufferSize ); + } + } + +#ifdef CHECK_INDICES + if ( m_pShadowIndices ) + { + delete[] m_pShadowIndices; + m_pShadowIndices = NULL; + } +#endif // CHECK_INDICES +} + + +//----------------------------------------------------------------------------- +// Index buffer information +//----------------------------------------------------------------------------- +int CIndexBufferDx8::IndexCount( ) const +{ + Assert( !m_bIsDynamic ); + return m_nIndexCount; +} + +MaterialIndexFormat_t CIndexBufferDx8::IndexFormat() const +{ + Assert( !m_bIsDynamic ); + return m_IndexFormat; +} + + +//----------------------------------------------------------------------------- +// Returns true if the buffer is dynamic +//----------------------------------------------------------------------------- +bool CIndexBufferDx8::IsDynamic() const +{ + return m_bIsDynamic; +} + + +//----------------------------------------------------------------------------- +// Only used by dynamic buffers, indicates the next lock should perform a discard. +//----------------------------------------------------------------------------- +void CIndexBufferDx8::Flush() +{ + // This strange-looking line makes a flush only occur if the buffer is dynamic. + m_bFlush = m_bIsDynamic; +} + + +//----------------------------------------------------------------------------- +// Returns the D3D buffer +//----------------------------------------------------------------------------- +IDirect3DIndexBuffer9* CIndexBufferDx8::GetDx9Buffer() +{ + return m_pIndexBuffer; +} + + +//----------------------------------------------------------------------------- +// Returns a shadowed index, for validation +//----------------------------------------------------------------------------- +#ifdef CHECK_INDICES +unsigned short CIndexBufferDx8::GetShadowIndex( int i ) const +{ + Assert( i >= 0 && i < m_nIndexCount ); + Assert( m_IndexFormat == MATERIAL_INDEX_FORMAT_16BIT ); + return *(unsigned short*)( &m_pShadowIndices[ i * IndexSize() ] ); +} +#endif // CHECK_INDICES + + +//----------------------------------------------------------------------------- +// Used to measure how much static buffer memory is touched each frame +//----------------------------------------------------------------------------- +void CIndexBufferDx8::HandlePerFrameTextureStats( int nFrame ) +{ +#ifdef VPROF_ENABLED + if ( m_nVProfFrame != nFrame && !m_bIsDynamic ) + { + m_nVProfFrame = nFrame; + VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_frame_" TEXTURE_GROUP_STATIC_INDEX_BUFFER, + COUNTER_GROUP_TEXTURE_PER_FRAME, m_nBufferSize ); + } +#endif +} + + +//----------------------------------------------------------------------------- +// Casts a dynamic buffer to be a particular index type +//----------------------------------------------------------------------------- +void CIndexBufferDx8::BeginCastBuffer( MaterialIndexFormat_t format ) +{ + // NOTE: This should have no effect under Dx9, since we can't recast index buffers. + Assert( format != MATERIAL_INDEX_FORMAT_UNKNOWN ); + Assert( m_bIsDynamic && ( m_IndexFormat == format ) ); +} + +void CIndexBufferDx8::EndCastBuffer( ) +{ + // NOTE: This should have no effect under Dx9, since we can't recast index buffers. +} + +int CIndexBufferDx8::GetRoomRemaining() const +{ + return ( m_nBufferSize - m_nFirstUnwrittenOffset ) / IndexSize(); +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the index buffer +//----------------------------------------------------------------------------- +bool CIndexBufferDx8::Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t &desc ) +{ + Assert( !m_bIsLocked && ( nMaxIndexCount != 0 ) && ( nMaxIndexCount <= m_nIndexCount ) ); + Assert( m_IndexFormat != MATERIAL_INDEX_FORMAT_UNKNOWN ); + + // FIXME: Why do we need to sync matrices now? + ShaderUtil()->SyncMatrices(); + g_ShaderMutex.Lock(); + + VPROF( "CIndexBufferX8::Lock" ); + + void *pLockedData = NULL; + HRESULT hr; + int nMemoryRequired; + bool bHasEnoughMemory; + UINT nLockFlags; + + // This can happen if the buffer was locked but a type wasn't bound + if ( m_IndexFormat == MATERIAL_INDEX_FORMAT_UNKNOWN ) + goto indexBufferLockFailed; + + // Just give the app crap buffers to fill up while we're suppressed... + if ( g_pShaderDeviceDx8->IsDeactivated() || ( nMaxIndexCount == 0 ) ) + goto indexBufferLockFailed; + + // Did we ask for something too large? + if ( nMaxIndexCount > m_nIndexCount ) + { + Warning( "Too many indices for index buffer. . tell a programmer (%d>%d)\n", nMaxIndexCount, m_nIndexCount ); + goto indexBufferLockFailed; + } + + // We might not have a buffer owing to alt-tab type stuff + if ( !m_pIndexBuffer ) + { + if ( !Allocate() ) + goto indexBufferLockFailed; + } + + // Check to see if we have enough memory + nMemoryRequired = nMaxIndexCount * IndexSize(); + bHasEnoughMemory = ( m_nFirstUnwrittenOffset + nMemoryRequired <= m_nBufferSize ); + + nLockFlags = D3DLOCK_NOSYSLOCK; + if ( bAppend ) + { + // Can't have the first lock after a flush be an appending lock + Assert( !m_bFlush ); + + // If we're appending and we don't have enough room, then puke! + if ( !bHasEnoughMemory || m_bFlush ) + goto indexBufferLockFailed; + nLockFlags |= ( m_nFirstUnwrittenOffset == 0 ) ? D3DLOCK_DISCARD : D3DLOCK_NOOVERWRITE; + } + else + { + // If we're not appending, no overwrite unless we don't have enough room + // If we're a static buffer, always discard if we're not appending + if ( !m_bFlush && bHasEnoughMemory && m_bIsDynamic ) + { + nLockFlags |= ( m_nFirstUnwrittenOffset == 0 ) ? D3DLOCK_DISCARD : D3DLOCK_NOOVERWRITE; + } + else + { + if ( m_bIsDynamic ) + { + nLockFlags |= D3DLOCK_DISCARD; + } + m_nFirstUnwrittenOffset = 0; + m_bFlush = false; + } + } + +#if !defined( _X360 ) + hr = m_pIndexBuffer->Lock( m_nFirstUnwrittenOffset, nMemoryRequired, &pLockedData, nLockFlags ); +#else + hr = m_pIndexBuffer->Lock( 0, 0, &pLockedData, nLockFlags ); + pLockedData = ( ( unsigned char * )pLockedData + m_nFirstUnwrittenOffset ); +#endif + + if ( FAILED( hr ) ) + { + Warning( "Failed to lock index buffer in CIndexBufferDx8::LockIndexBuffer\n" ); + goto indexBufferLockFailed; + } + + desc.m_pIndices = (unsigned short*)( pLockedData ); + desc.m_nIndexSize = IndexSize() >> 1; + if ( g_pHardwareConfig->SupportsStreamOffset() ) + { + desc.m_nFirstIndex = 0; + desc.m_nOffset = m_nFirstUnwrittenOffset; + } + else + { + desc.m_nFirstIndex = m_nFirstUnwrittenOffset / IndexSize(); + Assert( (int)( desc.m_nFirstIndex * IndexSize() ) == m_nFirstUnwrittenOffset ); + desc.m_nOffset = 0; + } + m_bIsLocked = true; + +#ifdef CHECK_INDICES + m_nLockIndexBufferSize = nMemoryRequired; + m_pLockIndexBuffer = desc.m_pIndices; + m_nLockIndexOffset = m_nFirstUnwrittenOffset; +#endif // CHECK_INDICES + + return true; + +indexBufferLockFailed: + g_ShaderMutex.Unlock(); + + // Set up a bogus index descriptor + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + desc.m_nFirstIndex = 0; + desc.m_nOffset = 0; + return false; +} + +void CIndexBufferDx8::Unlock( int nWrittenIndexCount, IndexDesc_t &desc ) +{ + Assert( nWrittenIndexCount <= m_nIndexCount ); + + // NOTE: This can happen if another application finishes + // initializing during the construction of a mesh + if ( !m_bIsLocked ) + return; + +#ifdef CHECK_INDICES + memcpy( (unsigned char*)m_pShadowIndices + m_nLockIndexOffset, m_pLockIndexBuffer, nWrittenIndexCount * IndexSize() ); +#endif // CHECK_INDICES + + if ( m_pIndexBuffer ) + { + m_pIndexBuffer->Unlock(); + } + + m_nFirstUnwrittenOffset += nWrittenIndexCount * IndexSize(); + m_bIsLocked = false; + g_ShaderMutex.Unlock(); +} + + +//----------------------------------------------------------------------------- +// +// Vertex Buffer implementations begin here +// +//----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- +// globals +//----------------------------------------------------------------------------- +#ifdef _DEBUG +int CVertexBufferDx8::s_nBufferCount = 0; +#endif + + +//----------------------------------------------------------------------------- +// constructor +//----------------------------------------------------------------------------- +CVertexBufferDx8::CVertexBufferDx8( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroupName ) : + BaseClass( pBudgetGroupName ) +{ +// Debugger(); + Assert( nVertexCount != 0 ); + + m_pVertexBuffer = NULL; + m_VertexFormat = fmt; + m_nVertexCount = ( fmt == VERTEX_FORMAT_UNKNOWN ) ? 0 : nVertexCount; + m_nBufferSize = ( fmt == VERTEX_FORMAT_UNKNOWN ) ? nVertexCount : nVertexCount * VertexSize(); + m_nFirstUnwrittenOffset = 0; + m_bIsLocked = false; + m_bIsDynamic = ( type == SHADER_BUFFER_TYPE_DYNAMIC ) || ( type == SHADER_BUFFER_TYPE_DYNAMIC_TEMP ); + m_bFlush = false; + +#ifdef VPROF_ENABLED + if ( !m_bIsDynamic ) + { + char name[256]; + V_strcpy_safe( name, "TexGroup_global_" ); + V_strcat_safe( name, pBudgetGroupName, sizeof(name) ); + m_pGlobalCounter = g_VProfCurrentProfile.FindOrCreateCounter( name, COUNTER_GROUP_TEXTURE_GLOBAL ); + + V_strcpy_safe( name, "TexGroup_frame_" ); + V_strcat_safe( name, pBudgetGroupName, sizeof(name) ); + m_pFrameCounter = g_VProfCurrentProfile.FindOrCreateCounter( name, COUNTER_GROUP_TEXTURE_PER_FRAME ); + } + else + { + m_pGlobalCounter = g_VProfCurrentProfile.FindOrCreateCounter( "TexGroup_global_" TEXTURE_GROUP_DYNAMIC_VERTEX_BUFFER, COUNTER_GROUP_TEXTURE_GLOBAL ); + m_pFrameCounter = NULL; + } + m_nVProfFrame = -1; +#endif +} + +CVertexBufferDx8::~CVertexBufferDx8() +{ + Free(); +} + + +//----------------------------------------------------------------------------- +// Returns the vertex size +//----------------------------------------------------------------------------- +inline int CVertexBufferDx8::VertexSize() const +{ + Assert( m_VertexFormat != VERTEX_FORMAT_UNKNOWN ); + return VertexFormatSize( m_VertexFormat ); +} + +//----------------------------------------------------------------------------- +// Creates, destroys the vertex buffer +//----------------------------------------------------------------------------- +bool CVertexBufferDx8::Allocate() +{ + Assert( !m_pVertexBuffer ); + m_nFirstUnwrittenOffset = 0; + + D3DPOOL pool = D3DPOOL_MANAGED; + +#if defined(IS_WINDOWS_PC) && defined(SHADERAPIDX9) + extern bool g_ShaderDeviceUsingD3D9Ex; + if ( g_ShaderDeviceUsingD3D9Ex ) + { + pool = D3DPOOL_DEFAULT; + } +#endif + + DWORD usage = D3DUSAGE_WRITEONLY; + if ( m_bIsDynamic ) + { + usage |= D3DUSAGE_DYNAMIC; + pool = D3DPOOL_DEFAULT; + // Dynamic meshes should never be compressed (slows down writing to them) + Assert( CompressionType( GetVertexFormat() ) == VERTEX_COMPRESSION_NONE ); + } + + HRESULT hr = Dx9Device()->CreateVertexBuffer( + m_nBufferSize, usage, 0, pool, &m_pVertexBuffer, NULL ); + +#if !defined( _X360 ) + if ( ( hr == D3DERR_OUTOFVIDEOMEMORY ) || ( hr == E_OUTOFMEMORY ) ) + { + // Don't have the memory for this. Try flushing all managed resources + // out of vid mem and try again. + // FIXME: need to record this + Dx9Device()->EvictManagedResources(); + hr = Dx9Device()->CreateVertexBuffer( + m_nBufferSize, usage, 0, pool, &m_pVertexBuffer, NULL ); + } +#endif // !X360 + + if ( FAILED(hr) || ( m_pVertexBuffer == NULL ) ) + { + Warning( "CVertexBufferDx8::Allocate: CreateVertexBuffer failed!\n" ); + return false; + } + + // Track VB allocations + g_VBAllocTracker->CountVB( m_pVertexBuffer, m_bIsDynamic, m_nBufferSize, VertexSize(), GetVertexFormat() ); + +#ifdef VPROF_ENABLED + if ( IsX360() || !m_bIsDynamic ) + { + Assert( m_pGlobalCounter ); + *m_pGlobalCounter += m_nBufferSize; + } +#endif + +#ifdef _DEBUG + ++s_nBufferCount; +#endif + + return true; +} + +void CVertexBufferDx8::Free() +{ + // FIXME: Unlock(0); + if ( m_pVertexBuffer ) + { +#ifdef _DEBUG + --s_nBufferCount; +#endif + + // Track VB allocations + g_VBAllocTracker->UnCountVB( m_pVertexBuffer ); + +#ifdef VPROF_ENABLED + if ( IsX360() || !m_bIsDynamic ) + { + Assert( m_pGlobalCounter ); + *m_pGlobalCounter -= m_nBufferSize; + } +#endif + + m_pVertexBuffer->Release(); + m_pVertexBuffer = NULL; + } +} + + +//----------------------------------------------------------------------------- +// Vertex buffer information +//----------------------------------------------------------------------------- +int CVertexBufferDx8::VertexCount() const +{ + Assert( !m_bIsDynamic ); + return m_nVertexCount; +} + +VertexFormat_t CVertexBufferDx8::GetVertexFormat() const +{ + Assert( !m_bIsDynamic ); + return m_VertexFormat; +} + + +//----------------------------------------------------------------------------- +// Returns true if the buffer is dynamic +//----------------------------------------------------------------------------- +bool CVertexBufferDx8::IsDynamic() const +{ + return m_bIsDynamic; +} + + +//----------------------------------------------------------------------------- +// Only used by dynamic buffers, indicates the next lock should perform a discard. +//----------------------------------------------------------------------------- +void CVertexBufferDx8::Flush() +{ + // This strange-looking line makes a flush only occur if the buffer is dynamic. + m_bFlush = m_bIsDynamic; +} + + +//----------------------------------------------------------------------------- +// Returns the D3D buffer +//----------------------------------------------------------------------------- +IDirect3DVertexBuffer9* CVertexBufferDx8::GetDx9Buffer() +{ + return m_pVertexBuffer; +} + + +//----------------------------------------------------------------------------- +// Casts a dynamic buffer to be a particular vertex type +//----------------------------------------------------------------------------- +void CVertexBufferDx8::BeginCastBuffer( VertexFormat_t format ) +{ + Assert( format != MATERIAL_INDEX_FORMAT_UNKNOWN ); + Assert( m_bIsDynamic && ( m_VertexFormat == 0 || m_VertexFormat == format ) ); + if ( !m_bIsDynamic ) + return; + + m_VertexFormat = format; + int nVertexSize = VertexSize(); + m_nVertexCount = m_nBufferSize / nVertexSize; + + // snap current position up to the next position based on expected size + // so append can safely guarantee nooverwrite regardless of a format growth or shrinkage + if ( !g_pHardwareConfig->SupportsStreamOffset() ) + { + m_nFirstUnwrittenOffset = ( m_nFirstUnwrittenOffset + nVertexSize - 1 ) / nVertexSize; + m_nFirstUnwrittenOffset *= nVertexSize; + if ( m_nFirstUnwrittenOffset > m_nBufferSize ) + { + m_nFirstUnwrittenOffset = m_nBufferSize; + } + } +} + +void CVertexBufferDx8::EndCastBuffer( ) +{ + Assert( m_bIsDynamic && m_VertexFormat != 0 ); + if ( !m_bIsDynamic ) + return; + m_VertexFormat = 0; + m_nVertexCount = 0; +} + + +//----------------------------------------------------------------------------- +// Returns the number of vertices we can still write into the buffer +//----------------------------------------------------------------------------- +int CVertexBufferDx8::GetRoomRemaining() const +{ + return ( m_nBufferSize - m_nFirstUnwrittenOffset ) / VertexSize(); +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the vertex buffer mesh +//----------------------------------------------------------------------------- +bool CVertexBufferDx8::Lock( int nMaxVertexCount, bool bAppend, VertexDesc_t &desc ) +{ + Assert( !m_bIsLocked && ( nMaxVertexCount != 0 ) && ( nMaxVertexCount <= m_nVertexCount ) ); + Assert( m_VertexFormat != VERTEX_FORMAT_UNKNOWN ); + + // FIXME: Why do we need to sync matrices now? + ShaderUtil()->SyncMatrices(); + g_ShaderMutex.Lock(); + + VPROF( "CVertexBufferDx8::Lock" ); + + void *pLockedData = NULL; + HRESULT hr; + int nMemoryRequired; + bool bHasEnoughMemory; + UINT nLockFlags; + + // This can happen if the buffer was locked but a type wasn't bound + if ( m_VertexFormat == VERTEX_FORMAT_UNKNOWN ) + goto vertexBufferLockFailed; + + // Just give the app crap buffers to fill up while we're suppressed... + if ( g_pShaderDeviceDx8->IsDeactivated() || ( nMaxVertexCount == 0 ) ) + goto vertexBufferLockFailed; + + // Did we ask for something too large? + if ( nMaxVertexCount > m_nVertexCount ) + { + Warning( "Too many vertices for vertex buffer. . tell a programmer (%d>%d)\n", nMaxVertexCount, m_nVertexCount ); + goto vertexBufferLockFailed; + } + + // We might not have a buffer owing to alt-tab type stuff + if ( !m_pVertexBuffer ) + { + if ( !Allocate() ) + goto vertexBufferLockFailed; + } + + // Check to see if we have enough memory + nMemoryRequired = nMaxVertexCount * VertexSize(); + bHasEnoughMemory = ( m_nFirstUnwrittenOffset + nMemoryRequired <= m_nBufferSize ); + + nLockFlags = D3DLOCK_NOSYSLOCK; + if ( bAppend ) + { + // Can't have the first lock after a flush be an appending lock + Assert( !m_bFlush ); + + // If we're appending and we don't have enough room, then puke! + if ( !bHasEnoughMemory || m_bFlush ) + goto vertexBufferLockFailed; + nLockFlags |= ( m_nFirstUnwrittenOffset == 0 ) ? D3DLOCK_DISCARD : D3DLOCK_NOOVERWRITE; + } + else + { + // If we're not appending, no overwrite unless we don't have enough room + // If we're a static buffer, always discard if we're not appending + if ( !m_bFlush && bHasEnoughMemory && m_bIsDynamic ) + { + nLockFlags |= ( m_nFirstUnwrittenOffset == 0 ) ? D3DLOCK_DISCARD : D3DLOCK_NOOVERWRITE; + } + else + { + if ( m_bIsDynamic ) + { + nLockFlags |= D3DLOCK_DISCARD; + } + m_nFirstUnwrittenOffset = 0; + m_bFlush = false; + } + } + +#if !defined( _X360 ) + hr = m_pVertexBuffer->Lock( m_nFirstUnwrittenOffset, nMemoryRequired, &pLockedData, nLockFlags ); +#else + hr = m_pVertexBuffer->Lock( 0, 0, &pLockedData, nLockFlags ); + pLockedData = (unsigned char*)pLockedData + m_nFirstUnwrittenOffset; +#endif + + if ( FAILED( hr ) ) + { + // Check if paged pool is in critical state ( < 5% free ) + PAGED_POOL_INFO_t ppi; + if ( ( SYSCALL_SUCCESS == Plat_GetPagedPoolInfo( &ppi ) ) && + ( ( ppi.numPagesFree * 20 ) < ( ppi.numPagesUsed + ppi.numPagesFree ) ) ) + { + Error( "Out of OS Paged Pool Memory! For more information, please see\nhttp://support.steampowered.com/cgi-bin/steampowered.cfg/php/enduser/std_adp.php?p_faqid=150\n" ); + } + else + { + Warning( "Failed to lock vertex buffer in CVertexBufferDx8::Lock\n" ); + } + goto vertexBufferLockFailed; + } + + ComputeVertexDescription( (unsigned char*)pLockedData, m_VertexFormat, desc ); + if ( g_pHardwareConfig->SupportsStreamOffset() ) + { + desc.m_nFirstVertex = 0; + desc.m_nOffset = m_nFirstUnwrittenOffset; + } + else + { + desc.m_nFirstVertex = m_nFirstUnwrittenOffset / VertexSize(); + desc.m_nOffset = 0; + Assert( m_nFirstUnwrittenOffset == VertexSize() * desc.m_nFirstVertex ); + } + m_bIsLocked = true; + return true; + +vertexBufferLockFailed: + ComputeVertexDescription( 0, 0, desc ); + desc.m_nFirstVertex = 0; + desc.m_nOffset = 0; + return false; +} + + +void CVertexBufferDx8::Unlock( int nWrittenVertexCount, VertexDesc_t &desc ) +{ + Assert( nWrittenVertexCount <= m_nVertexCount ); + + // NOTE: This can happen if another application finishes + // initializing during the construction of a mesh + if ( !m_bIsLocked ) + return; + + if ( m_pVertexBuffer ) + { + m_pVertexBuffer->Unlock(); + } + + m_nFirstUnwrittenOffset += nWrittenVertexCount * VertexSize(); + m_bIsLocked = false; + g_ShaderMutex.Unlock(); +} + + +//----------------------------------------------------------------------------- +// Used to measure how much static buffer memory is touched each frame +//----------------------------------------------------------------------------- +void CVertexBufferDx8::HandlePerFrameTextureStats( int nFrame ) +{ +#ifdef VPROF_ENABLED + if ( m_nVProfFrame != nFrame && !m_bIsDynamic ) + { + m_nVProfFrame = nFrame; + m_pFrameCounter += m_nBufferSize; + } +#endif +} + + +//----------------------------------------------------------------------------- +// Helpers with meshdescs... +//----------------------------------------------------------------------------- +// FIXME: add compression-agnostic read-accessors (which decompress and return by value, checking desc.m_CompressionType) +inline D3DXVECTOR3 &Position( MeshDesc_t const &desc, int vert ) +{ + return *(D3DXVECTOR3*)((unsigned char*)desc.m_pPosition + vert * desc.m_VertexSize_Position ); +} + +inline float Wrinkle( MeshDesc_t const &desc, int vert ) +{ + return *(float*)((unsigned char*)desc.m_pWrinkle + vert * desc.m_VertexSize_Wrinkle ); +} + +inline D3DXVECTOR3 &BoneWeight( MeshDesc_t const &desc, int vert ) +{ + Assert( desc.m_CompressionType == VERTEX_COMPRESSION_NONE ); + return *(D3DXVECTOR3*)((unsigned char*)desc.m_pBoneWeight + vert * desc.m_VertexSize_BoneWeight ); +} + +inline unsigned char *BoneIndex( MeshDesc_t const &desc, int vert ) +{ + return desc.m_pBoneMatrixIndex + vert * desc.m_VertexSize_BoneMatrixIndex; +} + +inline D3DXVECTOR3 &Normal( MeshDesc_t const &desc, int vert ) +{ + Assert( desc.m_CompressionType == VERTEX_COMPRESSION_NONE ); + return *(D3DXVECTOR3*)((unsigned char*)desc.m_pNormal + vert * desc.m_VertexSize_Normal ); +} + +inline unsigned char *Color( MeshDesc_t const &desc, int vert ) +{ + return desc.m_pColor + vert * desc.m_VertexSize_Color; +} + +inline D3DXVECTOR2 &TexCoord( MeshDesc_t const &desc, int vert, int stage ) +{ + return *(D3DXVECTOR2*)((unsigned char*)desc.m_pTexCoord[stage] + vert * desc.m_VertexSize_TexCoord[stage] ); +} + +inline D3DXVECTOR3 &TangentS( MeshDesc_t const &desc, int vert ) +{ + return *(D3DXVECTOR3*)((unsigned char*)desc.m_pTangentS + vert * desc.m_VertexSize_TangentS ); +} + +inline D3DXVECTOR3 &TangentT( MeshDesc_t const &desc, int vert ) +{ + return *(D3DXVECTOR3*)((unsigned char*)desc.m_pTangentT + vert * desc.m_VertexSize_TangentT ); +} + + +//----------------------------------------------------------------------------- +// +// Base mesh +// +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// constructor, destructor +//----------------------------------------------------------------------------- + +CBaseMeshDX8::CBaseMeshDX8() : m_VertexFormat(0) +{ + m_bMeshLocked = false; +#ifdef DBGFLAG_ASSERT + m_IsDrawing = false; + m_pMaterial = 0; +#endif +} + +CBaseMeshDX8::~CBaseMeshDX8() +{ +} + + +//----------------------------------------------------------------------------- +// For debugging... +//----------------------------------------------------------------------------- +bool CBaseMeshDX8::DebugTrace() const +{ +#ifdef _DEBUG + if (m_pMaterial) + return m_pMaterial->PerformDebugTrace(); +#endif + + return false; +} + +void CBaseMeshDX8::SetMaterial( IMaterial *pMaterial ) +{ +#ifdef DBGFLAG_ASSERT + m_pMaterial = static_cast<IMaterialInternal *>(pMaterial); +#endif +} + + +//----------------------------------------------------------------------------- +// Sets, gets the vertex format +//----------------------------------------------------------------------------- +void CBaseMeshDX8::SetVertexFormat( VertexFormat_t format ) +{ + m_VertexFormat = format; +} + +VertexFormat_t CBaseMeshDX8::GetVertexFormat() const +{ + return m_VertexFormat; +} + + +//----------------------------------------------------------------------------- +// Sets/gets the morph format +//----------------------------------------------------------------------------- +void CBaseMeshDX8::SetMorphFormat( MorphFormat_t format ) +{ + m_MorphFormat = format; +} + +MorphFormat_t CBaseMeshDX8::GetMorphFormat() const +{ + return m_MorphFormat; +} + + +//----------------------------------------------------------------------------- +// Am I using morph data? +//----------------------------------------------------------------------------- +bool CBaseMeshDX8::IsUsingMorphData() const +{ + LOCK_SHADERAPI(); + // We're not using a morph unless the bound morph is a superset of what the rendermesh needs + MorphFormat_t morphFormat = GetMorphFormat(); + if ( !morphFormat ) + return false; + + return ( ( morphFormat & ShaderUtil()->GetBoundMorphFormat() ) == morphFormat ); +} + +//----------------------------------------------------------------------------- +// Do I need to reset the vertex format? +//----------------------------------------------------------------------------- +bool CBaseMeshDX8::NeedsVertexFormatReset( VertexFormat_t fmt ) const +{ + return m_VertexFormat != fmt; +} + + +//----------------------------------------------------------------------------- +// Do I have enough room? +//----------------------------------------------------------------------------- +bool CBaseMeshDX8::HasEnoughRoom( int nVertexCount, int nIndexCount ) const +{ + // by default, we do + return true; +} + +//----------------------------------------------------------------------------- +// Estimate the memory used +//----------------------------------------------------------------------------- +unsigned CBaseMeshDX8::ComputeMemoryUsed() +{ + unsigned size = 0; + + if ( GetVertexBuffer() ) + { + size += GetVertexBuffer()->VertexCount() * GetVertexBuffer()->VertexSize(); + } + + if ( GetIndexBuffer() ) + { + size += GetIndexBuffer()->IndexCount() * GetIndexBuffer()->IndexSize(); + } + + return size; +} + + +//----------------------------------------------------------------------------- +// Locks mesh for modifying +//----------------------------------------------------------------------------- +void CBaseMeshDX8::ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + LOCK_SHADERAPI(); + // for the time being, disallow for most cases + Assert(0); +} + +void CBaseMeshDX8::ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + LOCK_SHADERAPI(); + // for the time being, disallow for most cases + Assert(0); +} + +void CBaseMeshDX8::ModifyEnd( MeshDesc_t& desc ) +{ + LOCK_SHADERAPI(); + // for the time being, disallow for most cases + Assert(0); +} + + +//----------------------------------------------------------------------------- +// Begins a pass +//----------------------------------------------------------------------------- +void CBaseMeshDX8::BeginPass( ) +{ + LOCK_SHADERAPI(); +} + + +//----------------------------------------------------------------------------- +// Sets the render state and gets the drawing going +//----------------------------------------------------------------------------- +inline void CBaseMeshDX8::DrawMesh( ) +{ +#ifdef DBGFLAG_ASSERT + // Make sure we're not drawing... + Assert( !m_IsDrawing ); + m_IsDrawing = true; +#endif + + // This is going to cause RenderPass to get called a bunch + ShaderAPI()->DrawMesh( this ); + +#ifdef DBGFLAG_ASSERT + m_IsDrawing = false; +#endif +} + + +//----------------------------------------------------------------------------- +// Spews the mesh data +//----------------------------------------------------------------------------- +void CBaseMeshDX8::Spew( int nVertexCount, int nIndexCount, const MeshDesc_t &spewDesc ) +{ + LOCK_SHADERAPI(); + // This has regressed. + int i; + + + // FIXME: just fall back to the base class (CVertexBufferBase) version of this function! + + +#ifdef _DEBUG + if( m_pMaterial ) + { + Plat_DebugString( ( const char * )m_pMaterial->GetName() ); + Plat_DebugString( "\n" ); + } +#endif // _DEBUG + + // This is needed so buffering can just use this + VertexFormat_t fmt = m_VertexFormat; + + // Set up the vertex descriptor + MeshDesc_t desc = spewDesc; + + char tempbuf[256]; + char* temp = tempbuf; + sprintf( tempbuf,"\nVerts: (Vertex Format %llx)\n", fmt); + Plat_DebugString(tempbuf); + + CVertexBufferBase::PrintVertexFormat( fmt ); + + int numBoneWeights = NumBoneWeights( fmt ); + for ( i = 0; i < nVertexCount; ++i ) + { + temp += sprintf( temp, "[%4d] ", i + desc.m_nFirstVertex ); + if( fmt & VERTEX_POSITION ) + { + D3DXVECTOR3& pos = Position( desc, i ); + temp += sprintf(temp, "P %8.2f %8.2f %8.2f ", + pos[0], pos[1], pos[2]); + } + + if ( fmt & VERTEX_WRINKLE ) + { + float flWrinkle = Wrinkle( desc, i ); + temp += sprintf(temp, "Wr %8.2f ",flWrinkle ); + } + + if (numBoneWeights > 0) + { + temp += sprintf(temp, "BW "); + float* pWeight = BoneWeight( desc, i ); + for (int j = 0; j < numBoneWeights; ++j) + { + temp += sprintf(temp, "%1.2f ", pWeight[j]); + } + } + if ( fmt & VERTEX_BONE_INDEX ) + { + unsigned char *pIndex = BoneIndex( desc, i ); + temp += sprintf( temp, "BI %d %d %d %d ", ( int )pIndex[0], ( int )pIndex[1], ( int )pIndex[2], ( int )pIndex[3] ); + Assert( pIndex[0] < 16 ); + Assert( pIndex[1] < 16 ); + Assert( pIndex[2] < 16 ); + Assert( pIndex[3] < 16 ); + } + + if ( fmt & VERTEX_NORMAL ) + { + D3DXVECTOR3& normal = Normal( desc, i ); + temp += sprintf(temp, "N %1.2f %1.2f %1.2f ", + normal[0], normal[1], normal[2]); + } + + if (fmt & VERTEX_COLOR) + { + unsigned char* pColor = Color( desc, i ); + temp += sprintf(temp, "C b %3d g %3d r %3d a %3d ", + pColor[0], pColor[1], pColor[2], pColor[3]); + } + + for (int j = 0; j < VERTEX_MAX_TEXTURE_COORDINATES; ++j) + { + if( TexCoordSize( j, fmt ) > 0) + { + D3DXVECTOR2& texcoord = TexCoord( desc, i, j ); + temp += sprintf(temp, "T%d %.2f %.2f ", j,texcoord[0], texcoord[1]); + } + } + + if (fmt & VERTEX_TANGENT_S) + { + D3DXVECTOR3& tangentS = TangentS( desc, i ); + temp += sprintf(temp, "S %1.2f %1.2f %1.2f ", + tangentS[0], tangentS[1], tangentS[2]); + } + + if (fmt & VERTEX_TANGENT_T) + { + D3DXVECTOR3& tangentT = TangentT( desc, i ); + temp += sprintf(temp, "T %1.2f %1.2f %1.2f ", + tangentT[0], tangentT[1], tangentT[2]); + } + + sprintf(temp,"\n"); + Plat_DebugString(tempbuf); + temp = tempbuf; + } + + sprintf( tempbuf,"\nIndices: %d\n", nIndexCount ); + Plat_DebugString(tempbuf); + for ( i = 0; i < nIndexCount; ++i ) + { + temp += sprintf( temp, "%d ", ( int )desc.m_pIndices[i] ); + if ((i & 0x0F) == 0x0F) + { + sprintf( temp, "\n" ); + Plat_DebugString(tempbuf); + tempbuf[0] = '\0'; + temp = tempbuf; + } + } + sprintf(temp,"\n"); + Plat_DebugString( tempbuf ); +} + +void CBaseMeshDX8::ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t &spewDesc ) +{ + LOCK_SHADERAPI(); +#ifdef VALIDATE_DEBUG + int i; + + + // FIXME: just fall back to the base class (CVertexBufferBase) version of this function! + + + // This is needed so buffering can just use this + VertexFormat_t fmt = m_pMaterial->GetVertexUsage(); + + // Set up the vertex descriptor + MeshDesc_t desc = spewDesc; + + int numBoneWeights = NumBoneWeights( fmt ); + for ( i = 0; i < nVertexCount; ++i ) + { + if( fmt & VERTEX_POSITION ) + { + D3DXVECTOR3& pos = Position( desc, i ); + Assert( IsFinite( pos[0] ) && IsFinite( pos[1] ) && IsFinite( pos[2] ) ); + } + if( fmt & VERTEX_WRINKLE ) + { + float flWrinkle = Wrinkle( desc, i ); + Assert( IsFinite( flWrinkle ) ); + } + if (numBoneWeights > 0) + { + float* pWeight = BoneWeight( desc, i ); + for (int j = 0; j < numBoneWeights; ++j) + { + Assert( pWeight[j] >= 0.0f && pWeight[j] <= 1.0f ); + } + } + if( fmt & VERTEX_BONE_INDEX ) + { + unsigned char *pIndex = BoneIndex( desc, i ); + Assert( pIndex[0] >= 0 && pIndex[0] < 16 ); + Assert( pIndex[1] >= 0 && pIndex[1] < 16 ); + Assert( pIndex[2] >= 0 && pIndex[2] < 16 ); + Assert( pIndex[3] >= 0 && pIndex[3] < 16 ); + } + if( fmt & VERTEX_NORMAL ) + { + D3DXVECTOR3& normal = Normal( desc, i ); + Assert( normal[0] >= -1.05f && normal[0] <= 1.05f ); + Assert( normal[1] >= -1.05f && normal[1] <= 1.05f ); + Assert( normal[2] >= -1.05f && normal[2] <= 1.05f ); + } + + if (fmt & VERTEX_COLOR) + { + int* pColor = (int*)Color( desc, i ); + Assert( *pColor != FLOAT32_NAN_BITS ); + } + + for (int j = 0; j < VERTEX_MAX_TEXTURE_COORDINATES; ++j) + { + if( TexCoordSize( j, fmt ) > 0) + { + D3DXVECTOR2& texcoord = TexCoord( desc, i, j ); + Assert( IsFinite( texcoord[0] ) && IsFinite( texcoord[1] ) ); + } + } + + if (fmt & VERTEX_TANGENT_S) + { + D3DXVECTOR3& tangentS = TangentS( desc, i ); + Assert( IsFinite( tangentS[0] ) && IsFinite( tangentS[1] ) && IsFinite( tangentS[2] ) ); + } + + if (fmt & VERTEX_TANGENT_T) + { + D3DXVECTOR3& tangentT = TangentT( desc, i ); + Assert( IsFinite( tangentT[0] ) && IsFinite( tangentT[1] ) && IsFinite( tangentT[2] ) ); + } + } +#endif // _DEBUG +} + +void CBaseMeshDX8::Draw( CPrimList *pLists, int nLists ) +{ + LOCK_SHADERAPI(); + Assert( !"CBaseMeshDX8::Draw(CPrimList, int): should never get here." ); +} + + +// Copy verts and/or indices to a mesh builder. This only works for temp meshes! +void CBaseMeshDX8::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 ) +{ + LOCK_SHADERAPI(); + Assert( false ); + Warning( "CopyToMeshBuilder called on something other than a temp mesh.\n" ); +} + + +//----------------------------------------------------------------------------- +// +// static mesh +// +//----------------------------------------------------------------------------- + +CPrimList *CMeshDX8::s_pPrims; +int CMeshDX8::s_nPrims; +unsigned int CMeshDX8::s_FirstVertex; +unsigned int CMeshDX8::s_NumVertices; + + +//----------------------------------------------------------------------------- +// Computes the mode +//----------------------------------------------------------------------------- +inline D3DPRIMITIVETYPE ComputeMode( MaterialPrimitiveType_t type ) +{ + switch(type) + { +#ifdef _X360 + case MATERIAL_INSTANCED_QUADS: + return D3DPT_QUADLIST; +#endif + + case MATERIAL_POINTS: + return D3DPT_POINTLIST; + + case MATERIAL_LINES: + return D3DPT_LINELIST; + + case MATERIAL_TRIANGLES: + return D3DPT_TRIANGLELIST; + + case MATERIAL_TRIANGLE_STRIP: + return D3DPT_TRIANGLESTRIP; + + // Here, we expect to have the type set later. only works for static meshes + case MATERIAL_HETEROGENOUS: + return (D3DPRIMITIVETYPE)-1; + + default: + Assert(0); + return (D3DPRIMITIVETYPE)-1; + } +} + +//----------------------------------------------------------------------------- +// constructor +//----------------------------------------------------------------------------- +CMeshDX8::CMeshDX8( const char *pTextureGroupName ) : m_NumVertices(0), m_NumIndices(0), m_pVertexBuffer(0), + m_pColorMesh( 0 ), m_nColorMeshVertOffsetInBytes( 0 ), + m_pIndexBuffer(0), m_Type(MATERIAL_TRIANGLES), m_IsVBLocked(false), + m_IsIBLocked(false) +{ + m_pTextureGroupName = pTextureGroupName; + m_Mode = ComputeMode(m_Type); + + m_bHasFlexVerts = false; + m_pFlexVertexBuffer = NULL; + m_nFlexVertOffsetInBytes = 0; +} + +CMeshDX8::~CMeshDX8() +{ + // Don't release the vertex buffer + if (!g_MeshMgr.IsDynamicMesh(this)) + { + if (m_pVertexBuffer) + { + delete m_pVertexBuffer; + } + if (m_pIndexBuffer) + { + SafeRelease( &m_pIndexBuffer ); + } + } +} + +void CMeshDX8::SetFlexMesh( IMesh *pMesh, int nVertexOffsetInBytes ) +{ + if ( !ShaderUtil()->OnSetFlexMesh( this, pMesh, nVertexOffsetInBytes ) ) + return; + + LOCK_SHADERAPI(); + m_nFlexVertOffsetInBytes = nVertexOffsetInBytes; // Offset into dynamic mesh (in bytes) + + if ( pMesh ) + { + m_flexVertCount = pMesh->VertexCount(); + pMesh->MarkAsDrawn(); + + CBaseMeshDX8 *pBaseMesh = static_cast<CBaseMeshDX8 *>(pMesh); + m_pFlexVertexBuffer = pBaseMesh->GetVertexBuffer(); + + m_bHasFlexVerts = true; + } + else + { + m_flexVertCount = 0; + m_pFlexVertexBuffer = NULL; + m_bHasFlexVerts = false; + } +} + +void CMeshDX8::DisableFlexMesh( ) +{ + CMeshDX8::SetFlexMesh( NULL, 0 ); +} + +bool CMeshDX8::HasFlexMesh( ) const +{ + LOCK_SHADERAPI(); + return m_bHasFlexVerts; +} + +void CMeshDX8::SetColorMesh( IMesh *pColorMesh, int nVertexOffsetInBytes ) +{ + if ( !ShaderUtil()->OnSetColorMesh( this, pColorMesh, nVertexOffsetInBytes ) ) + return; + + LOCK_SHADERAPI(); + m_pColorMesh = ( CMeshDX8 * )pColorMesh; // dangerous conversion! garymcthack + m_nColorMeshVertOffsetInBytes = nVertexOffsetInBytes; + Assert( m_pColorMesh || ( nVertexOffsetInBytes == 0 ) ); + +#ifdef _DEBUG + if ( pColorMesh ) + { + int nVertexCount = VertexCount(); + int numVertsColorMesh = m_pColorMesh->VertexCount(); + Assert( numVertsColorMesh >= nVertexCount ); + } +#endif +} + + +void CMeshDX8::HandleLateCreation( ) +{ + if ( m_pVertexBuffer ) + { + m_pVertexBuffer->HandleLateCreation(); + } + if ( m_pIndexBuffer ) + { + m_pIndexBuffer->HandleLateCreation(); + } + if ( m_pFlexVertexBuffer ) + { + m_pFlexVertexBuffer->HandleLateCreation(); + } + + if ( m_pColorMesh ) + { + m_pColorMesh->HandleLateCreation(); + } +} + + +bool CMeshDX8::HasColorMesh( ) const +{ + LOCK_SHADERAPI(); + return (m_pColorMesh != NULL); +} + + +//----------------------------------------------------------------------------- +// Locks/ unlocks the vertex buffer +//----------------------------------------------------------------------------- +bool CMeshDX8::Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc ) +{ + Assert( !m_IsVBLocked ); + + // Just give the app crap buffers to fill up while we're suppressed... + if ( g_pShaderDeviceDx8->IsDeactivated() || (nVertexCount == 0)) + { + // Set up the vertex descriptor + CVertexBufferBase::ComputeVertexDescription( 0, 0, desc ); + desc.m_nFirstVertex = 0; + return false; + } + + // Static vertex buffer case + if (!m_pVertexBuffer) + { + int size = g_MeshMgr.VertexFormatSize( m_VertexFormat ); + m_pVertexBuffer = new CVertexBuffer( Dx9Device(), m_VertexFormat, 0, size, nVertexCount, m_pTextureGroupName, ShaderAPI()->UsingSoftwareVertexProcessing() ); + } + + // Lock it baby + int nMaxVerts, nMaxIndices; + g_MeshMgr.GetMaxToRender( this, false, &nMaxVerts, &nMaxIndices ); + if ( !g_pHardwareConfig->SupportsStreamOffset() ) + { + // Without stream offset, we can't use VBs greater than 65535 verts (due to our using 16-bit indices) + Assert( nVertexCount <= nMaxVerts ); + } + + unsigned char *pVertexMemory = m_pVertexBuffer->Lock( nVertexCount, desc.m_nFirstVertex ); + if ( !pVertexMemory ) + { + if ( nVertexCount > nMaxVerts ) + { + Assert( 0 ); + Error( "Too many verts for a dynamic vertex buffer (%d>%d) Tell a programmer to up VERTEX_BUFFER_SIZE.\n", + ( int )nVertexCount, ( int )nMaxVerts ); + } + else + { + // Check if paged pool is in critical state ( < 5% free ) + PAGED_POOL_INFO_t ppi; + if ( ( SYSCALL_SUCCESS == Plat_GetPagedPoolInfo( &ppi ) ) && + ( ( ppi.numPagesFree * 20 ) < ( ppi.numPagesUsed + ppi.numPagesFree ) ) ) + { + Error( "Out of OS Paged Pool Memory! For more information, please see\nhttp://support.steampowered.com/cgi-bin/steampowered.cfg/php/enduser/std_adp.php?p_faqid=150\n" ); + } + else + { + Assert( 0 ); + Error( "failed to lock vertex buffer in CMeshDX8::LockVertexBuffer: nVertexCount=%d, nFirstVertex=%d\n", nVertexCount, desc.m_nFirstVertex ); + } + } + CVertexBufferBase::ComputeVertexDescription( 0, 0, desc ); + return false; + } + + // Set up the vertex descriptor + CVertexBufferBase::ComputeVertexDescription( pVertexMemory, m_VertexFormat, desc ); + m_IsVBLocked = true; + +#ifdef RECORDING + m_LockVertexBufferSize = nVertexCount * desc.m_ActualVertexSize; + m_LockVertexBuffer = pVertexMemory; +#endif + + return true; +} + +void CMeshDX8::Unlock( int nVertexCount, VertexDesc_t& desc ) +{ + // NOTE: This can happen if another application finishes + // initializing during the construction of a mesh + if (!m_IsVBLocked) + return; + + // This is recorded for debugging. . not sent to dx. + RECORD_COMMAND( DX8_SET_VERTEX_BUFFER_FORMAT, 2 ); + RECORD_INT( m_pVertexBuffer->UID() ); + RECORD_INT( m_VertexFormat ); + + RECORD_COMMAND( DX8_VERTEX_DATA, 3 ); + RECORD_INT( m_pVertexBuffer->UID() ); + RECORD_INT( m_LockVertexBufferSize ); + RECORD_STRUCT( m_LockVertexBuffer, m_LockVertexBufferSize ); + + Assert(m_pVertexBuffer); + m_pVertexBuffer->Unlock(nVertexCount); + m_IsVBLocked = false; +} + +//----------------------------------------------------------------------------- +// Locks/unlocks the index buffer +//----------------------------------------------------------------------------- +int CMeshDX8::Lock( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t &desc ) +{ + Assert( !m_IsIBLocked ); + + // Just give the app crap buffers to fill up while we're suppressed... + if ( g_pShaderDeviceDx8->IsDeactivated() || (nIndexCount == 0)) + { + // Set up a bogus index descriptor + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + return 0; + } + + // Static vertex buffer case + if (!m_pIndexBuffer) + { + SafeAssign( &m_pIndexBuffer, new CIndexBuffer( Dx9Device(), nIndexCount, ShaderAPI()->UsingSoftwareVertexProcessing() ) ); + } + + int startIndex; + desc.m_pIndices = m_pIndexBuffer->Lock( bReadOnly, nIndexCount, startIndex, nFirstIndex ); + if( !desc.m_pIndices ) + { + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + + // Check if paged pool is in critical state ( < 5% free ) + PAGED_POOL_INFO_t ppi; + if ( ( SYSCALL_SUCCESS == Plat_GetPagedPoolInfo( &ppi ) ) && + ( ( ppi.numPagesFree * 20 ) < ( ppi.numPagesUsed + ppi.numPagesFree ) ) ) + { + Error( "Out of OS Paged Pool Memory! For more information, please see\nhttp://support.steampowered.com/cgi-bin/steampowered.cfg/php/enduser/std_adp.php?p_faqid=150\n" ); + } + else + { + Assert( 0 ); + Error( "failed to lock index buffer in CMeshDX8::LockIndexBuffer\n" ); + } + + return 0; + } + + desc.m_nIndexSize = 1; + m_IsIBLocked = true; + +#if defined( RECORDING ) || defined( CHECK_INDICES ) + m_LockIndexBufferSize = nIndexCount * 2; + m_LockIndexBuffer = desc.m_pIndices; +#endif + + return startIndex; +} + + +void CMeshDX8::Unlock( int nIndexCount, IndexDesc_t &desc ) +{ + // NOTE: This can happen if another application finishes + // initializing during the construction of a mesh + if (!m_IsIBLocked) + return; + + RECORD_COMMAND( DX8_INDEX_DATA, 3 ); + RECORD_INT( m_pIndexBuffer->UID() ); + RECORD_INT( m_LockIndexBufferSize ); + RECORD_STRUCT( m_LockIndexBuffer, m_LockIndexBufferSize ); + + Assert(m_pIndexBuffer); + +#ifdef CHECK_INDICES + m_pIndexBuffer->UpdateShadowIndices( ( unsigned short * )m_LockIndexBuffer ); +#endif // CHECK_INDICES + + // Unlock, and indicate how many vertices we actually used + m_pIndexBuffer->Unlock(nIndexCount); + m_IsIBLocked = false; +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the entire mesh +//----------------------------------------------------------------------------- +void CMeshDX8::LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + ShaderUtil()->SyncMatrices(); + + g_ShaderMutex.Lock(); + VPROF( "CMeshDX8::LockMesh" ); + Lock( nVertexCount, false, *static_cast<VertexDesc_t*>( &desc ) ); + if ( m_Type != MATERIAL_POINTS ) + { + Lock( false, -1, nIndexCount, *static_cast<IndexDesc_t*>( &desc ) ); + } + else + { + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + } + + CBaseMeshDX8::m_bMeshLocked = true; +} + + +void CMeshDX8::UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + VPROF( "CMeshDX8::UnlockMesh" ); + + Assert( CBaseMeshDX8::m_bMeshLocked ); + + Unlock( nVertexCount, *static_cast<VertexDesc_t*>( &desc ) ); + if ( m_Type != MATERIAL_POINTS ) + { + Unlock( nIndexCount, *static_cast<IndexDesc_t*>( &desc ) ); + } + + // The actual # we wrote + m_NumVertices = nVertexCount; + m_NumIndices = nIndexCount; + + CBaseMeshDX8::m_bMeshLocked = false; + g_ShaderMutex.Unlock(); +} + + +//----------------------------------------------------------------------------- +// Locks mesh for modifying +//----------------------------------------------------------------------------- +void CMeshDX8::ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + VPROF( "CMeshDX8::ModifyBegin" ); + + // Just give the app crap buffers to fill up while we're suppressed... + if ( g_pShaderDeviceDx8->IsDeactivated()) + { + // Set up a bogus descriptor + g_MeshMgr.ComputeVertexDescription( 0, 0, desc ); + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + return; + } + + Assert( m_pVertexBuffer ); + + // Lock it baby + unsigned char* pVertexMemory = m_pVertexBuffer->Modify( bReadOnly, nFirstVertex, nVertexCount ); + if ( pVertexMemory ) + { + m_IsVBLocked = true; + g_MeshMgr.ComputeVertexDescription( pVertexMemory, m_VertexFormat, desc ); + +#ifdef RECORDING + m_LockVertexBufferSize = nVertexCount * desc.m_ActualVertexSize; + m_LockVertexBuffer = pVertexMemory; +#endif + } + + desc.m_nFirstVertex = nFirstVertex; + + Lock( bReadOnly, nFirstIndex, nIndexCount, *static_cast<IndexDesc_t*>( &desc ) ); +} + +void CMeshDX8::ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + ModifyBeginEx( false, nFirstVertex, nVertexCount, nFirstIndex, nIndexCount, desc ); +} + +void CMeshDX8::ModifyEnd( MeshDesc_t& desc ) +{ + VPROF( "CMeshDX8::ModifyEnd" ); + Unlock( 0, *static_cast<IndexDesc_t*>( &desc ) ); + Unlock( 0, *static_cast<VertexDesc_t*>( &desc ) ); +} + + +//----------------------------------------------------------------------------- +// returns the # of vertices (static meshes only) +//----------------------------------------------------------------------------- +int CMeshDX8::VertexCount() const +{ + return m_pVertexBuffer ? m_pVertexBuffer->VertexCount() : 0; +} + + +//----------------------------------------------------------------------------- +// returns the # of indices +//----------------------------------------------------------------------------- +int CMeshDX8::IndexCount( ) const +{ + return m_pIndexBuffer ? m_pIndexBuffer->IndexCount() : 0; +} + + +//----------------------------------------------------------------------------- +// Sets up the vertex and index buffers +//----------------------------------------------------------------------------- +void CMeshDX8::UseIndexBuffer( CIndexBuffer* pBuffer ) +{ + SafeAssign( &m_pIndexBuffer, pBuffer ); +} + +void CMeshDX8::UseVertexBuffer( CVertexBuffer* pBuffer ) +{ + m_pVertexBuffer = pBuffer; +} + + +//----------------------------------------------------------------------------- +// Sets the primitive type +//----------------------------------------------------------------------------- +void CMeshDX8::SetPrimitiveType( MaterialPrimitiveType_t type ) +{ + Assert( IsX360() || ( type != MATERIAL_INSTANCED_QUADS ) ); + if ( !ShaderUtil()->OnSetPrimitiveType( this, type ) ) + { + return; + } + + LOCK_SHADERAPI(); + m_Type = type; + m_Mode = ComputeMode( type ); +} + +MaterialPrimitiveType_t CMeshDX8::GetPrimitiveType( ) const +{ + return m_Type; +} + + +//----------------------------------------------------------------------------- +// Computes the number of primitives we're gonna draw +//----------------------------------------------------------------------------- +int CMeshDX8::NumPrimitives( int nVertexCount, int nIndexCount ) const +{ + switch(m_Mode) + { + case D3DPT_POINTLIST: + return nVertexCount; + + case D3DPT_LINELIST: + return nIndexCount / 2; + + case D3DPT_TRIANGLELIST: + return nIndexCount / 3; + + case D3DPT_TRIANGLESTRIP: + return nIndexCount - 2; + + default: + // invalid, baby! + Assert(0); + } + + return 0; +} + + +//----------------------------------------------------------------------------- +// Checks if it's a valid format +//----------------------------------------------------------------------------- +#ifdef _DEBUG +static void OutputVertexFormat( VertexFormat_t format ) +{ + // FIXME: this is a duplicate of the function in meshdx8.cpp + VertexCompressionType_t compressionType = CompressionType( format ); + + if ( format & VERTEX_POSITION ) + { + Warning( "VERTEX_POSITION|" ); + } + if ( format & VERTEX_NORMAL ) + { + if ( compressionType == VERTEX_COMPRESSION_ON ) + Warning( "VERTEX_NORMAL[COMPRESSED]|" ); + else + Warning( "VERTEX_NORMAL|" ); + } + if ( format & VERTEX_COLOR ) + { + Warning( "VERTEX_COLOR|" ); + } + if ( format & VERTEX_SPECULAR ) + { + Warning( "VERTEX_SPECULAR|" ); + } + if ( format & VERTEX_TANGENT_S ) + { + Warning( "VERTEX_TANGENT_S|" ); + } + if ( format & VERTEX_TANGENT_T ) + { + Warning( "VERTEX_TANGENT_T|" ); + } + if ( format & VERTEX_BONE_INDEX ) + { + Warning( "VERTEX_BONE_INDEX|" ); + } + if ( format & VERTEX_FORMAT_VERTEX_SHADER ) + { + Warning( "VERTEX_FORMAT_VERTEX_SHADER|" ); + } + Warning( "\nBone weights: %d (%s)\n", NumBoneWeights( format ), + ( CompressionType( format ) == VERTEX_COMPRESSION_ON ? "compressed" : "uncompressed" ) ); + Warning( "user data size: %d (%s)\n", UserDataSize( format ), + ( CompressionType( format ) == VERTEX_COMPRESSION_ON ? "compressed" : "uncompressed" ) ); + Warning( "num tex coords: %d\n", NumTextureCoordinates( format ) ); + // NOTE: This doesn't print texcoord sizes. +} +#endif + +bool CMeshDX8::IsValidVertexFormat( VertexFormat_t vertexFormat ) +{ + // FIXME: Make this a debug-only check on say 6th July 2007 (after a week or so's testing) + // (i.e. avoid the 360 release build perf. hit for when we ship) + bool bCheckCompression = ( m_VertexFormat & VERTEX_FORMAT_COMPRESSED ) && + ( ( vertexFormat == VERTEX_FORMAT_INVALID ) || ( ( vertexFormat & VERTEX_FORMAT_COMPRESSED ) == 0 ) ); + + if ( bCheckCompression || IsPC() || IsDebug() ) + { + IMaterialInternal* pMaterial = ShaderAPI()->GetBoundMaterial(); + Assert( pMaterial ); + + // the material format should match the vertex usage, unless another format is passed in + if ( vertexFormat == VERTEX_FORMAT_INVALID ) + { + vertexFormat = pMaterial->GetVertexUsage() & ~( VERTEX_FORMAT_VERTEX_SHADER | VERTEX_FORMAT_USE_EXACT_FORMAT ); + + // Blat out unused fields + vertexFormat &= ~g_MeshMgr.UnusedVertexFields(); + int nUnusedTextureCoords = g_MeshMgr.UnusedTextureCoords(); + for ( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i ) + { + if ( nUnusedTextureCoords & ( 1 << i ) ) + { + vertexFormat &= ~VERTEX_TEXCOORD_MASK( i ); + } + } + } + else + { + vertexFormat &= ~( VERTEX_FORMAT_VERTEX_SHADER | VERTEX_FORMAT_USE_EXACT_FORMAT ); + } + + bool bIsValid = (( VERTEX_FORMAT_FIELD_MASK & vertexFormat ) & ( VERTEX_FORMAT_FIELD_MASK & ~m_VertexFormat )) == 0; + + if ( m_VertexFormat & VERTEX_FORMAT_COMPRESSED ) + { + // We shouldn't get compressed verts if this material doesn't support them! + if ( ( vertexFormat & VERTEX_FORMAT_COMPRESSED ) == 0 ) + { + static int numWarnings = 0; + if ( numWarnings++ == 0 ) + { + // NOTE: ComputeVertexFormat() will make sure no materials support VERTEX_FORMAT_COMPRESSED + // if vertex compression is disabled in the config + if ( g_pHardwareConfig->SupportsCompressedVertices() == VERTEX_COMPRESSION_NONE ) + Warning( "ERROR: Compressed vertices in use but vertex compression is disabled (or not supported on this hardware)!\n" ); + else + Warning( "ERROR: Compressed vertices in use but material does not support them!\n" ); + } + Assert( 0 ); + bIsValid = false; + } + } + + bIsValid = bIsValid && UserDataSize( m_VertexFormat ) >= UserDataSize( vertexFormat ); + + for ( int i=0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ ) + { + if ( TexCoordSize( i, m_VertexFormat ) < TexCoordSize( i, vertexFormat ) ) + { + bIsValid = false; + } + } + + // NOTE: It can totally be valid to have more weights than the current number of bones. + // The -1 here is because if we have N bones, we can have only (N-1) weights, + // since the Nth is implied (the weights sum to 1). + int nWeightCount = NumBoneWeights( m_VertexFormat ); + bIsValid = bIsValid && ( nWeightCount >= ( g_pShaderAPI->GetCurrentNumBones() - 1 ) ); + +#ifdef _DEBUG + if ( !bIsValid ) + { + Warning( "Material Format:" ); + if ( g_pShaderAPI->GetCurrentNumBones() > 0 ) + { + vertexFormat |= VERTEX_BONE_INDEX; + vertexFormat &= ~VERTEX_BONE_WEIGHT_MASK; + vertexFormat |= VERTEX_BONEWEIGHT( 2 ); + } + + OutputVertexFormat( vertexFormat ); + Warning( "Mesh Format:" ); + OutputVertexFormat( m_VertexFormat ); + } +#endif + return bIsValid; + } + + return true; +} + + +//----------------------------------------------------------------------------- +// Stream source setting methods +//----------------------------------------------------------------------------- +void CMeshDX8::SetVertexIDStreamState() +{ + // FIXME: this method duplicates the code in CMeshMgr::SetVertexIDStreamState + + if ( IsX360() ) + return; + + bool bUsingVertexID = IsUsingVertexID(); + if ( bUsingVertexID != g_bUsingVertexID ) + { + if ( bUsingVertexID ) + { + // NOTE: Morphing doesn't work with dynamic buffers!!! BLEAH + // It's because the indices (which are not 0 based for dynamic buffers) + // are accessing both the vertexID buffer + the regular vertex buffer. + // This *might* be fixable with baseVertexIndex? + + // NOTE: At the moment, vertex id is only used for hw morphing. I've got it + // set up so that a shader that supports hw morphing always says it uses vertex id. + // If we ever use vertex id for something other than hw morphing, we're going + // to have to revisit how those shaders say they want to use vertex id + // or fix this some other way + Assert( !g_pShaderAPI->IsHWMorphingEnabled() || !m_pVertexBuffer->IsDynamic() ); + + CVertexBuffer *pVertexIDBuffer = g_MeshMgr.GetVertexIDBuffer( ); + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( pVertexIDBuffer->UID() ); + RECORD_INT( 3 ); + RECORD_INT( 0 ); + RECORD_INT( pVertexIDBuffer->VertexSize() ); + + D3DSetStreamSource( 3, pVertexIDBuffer->GetInterface(), 0, pVertexIDBuffer->VertexSize() ); + pVertexIDBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + } + else + { + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); // vertex buffer id + RECORD_INT( 3 ); // stream + RECORD_INT( 0 ); // vertex offset + RECORD_INT( 0 ); // vertex size + + D3DSetStreamSource( 3, 0, 0, 0 ); + } + g_bUsingVertexID = bUsingVertexID; + } +} + +void CMeshDX8::SetColorStreamState() +{ + if ( ( m_pColorMesh != g_pLastColorMesh ) || ( m_nColorMeshVertOffsetInBytes != g_nLastColorMeshVertOffsetInBytes ) ) + { + if ( m_pColorMesh ) + { + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( m_pColorMesh->GetVertexBuffer()->UID() ); + RECORD_INT( 1 ); + RECORD_INT( m_nColorMeshVertOffsetInBytes ); + RECORD_INT( m_pColorMesh->GetVertexBuffer()->VertexSize() ); + + D3DSetStreamSource( 1, m_pColorMesh->GetVertexBuffer()->GetInterface(), + m_nColorMeshVertOffsetInBytes, m_pColorMesh->GetVertexBuffer()->VertexSize() ); + m_pColorMesh->GetVertexBuffer()->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + } + else + { + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); // vertex buffer id + RECORD_INT( 1 ); // stream + RECORD_INT( 0 ); // vertex offset + RECORD_INT( 0 ); // vertex size + + D3DSetStreamSource( 1, 0, 0, 0 ); + } + g_pLastColorMesh = m_pColorMesh; + g_nLastColorMeshVertOffsetInBytes = m_nColorMeshVertOffsetInBytes; + } +} + +void CMeshDX8::SetVertexStreamState( int nVertOffsetInBytes ) +{ + // Calls in here assume shader support... + if ( HardwareConfig()->SupportsVertexAndPixelShaders() ) + { + if ( HasFlexMesh() ) + { + // m_pFlexVertexBuffer is the flex buffer down inside the CMeshMgr singleton + D3DSetStreamSource( 2, m_pFlexVertexBuffer->GetInterface(), m_nFlexVertOffsetInBytes, m_pFlexVertexBuffer->VertexSize() ); + + if ( g_pHardwareConfig->Caps().m_SupportsVertexShaders_2_0 ) + { + float c[4] = { 1.0f, g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_b() ? 1.0f : 0.0f, 0.0f, 0.0f }; + ShaderAPI()->SetVertexShaderConstant( VERTEX_SHADER_FLEXSCALE, c, 1 ); + } + + g_bFlexMeshStreamSet = true; + } + else + { + Assert( nVertOffsetInBytes == 0 ); + Assert( m_pVertexBuffer ); + + // HACK...point stream 2 at the same VB which is bound to stream 0... + // NOTE: D3D debug DLLs will RIP if stream 0 has a smaller stride than the largest + // offset in the stream 2 vertex decl elements (which are position(12)+wrinkle(4)+normal(12)) + // If this fires, go find the material/shader which is requesting a really 'thin' + // stream 0 vertex, and fatten it up slightly (e.g. add a D3DCOLOR element) + int minimumStreamZeroStride = 4 * sizeof( float ); + Assert( m_pVertexBuffer->VertexSize() >= minimumStreamZeroStride ); + if ( m_pVertexBuffer->VertexSize() < minimumStreamZeroStride ) + { + static bool bWarned = false; + if( !bWarned ) + { + Warning( "Shader specifying too-thin vertex format, should be at least %d bytes! (Suppressing furthur warnings)\n", minimumStreamZeroStride ); + bWarned = true; + } + } + + // Set a 4kb all-zero static VB into the flex/wrinkle stream with a stride of 1 bytes, so the vertex shader always reads valid floating point values (otherwise it can get NaN's/Inf's, and under OpenGL this is bad on NVidia) + // togl requires non-zero strides, but on D3D9 we can set a stride of 0 for a little more efficiency. + D3DSetStreamSource( 2, g_MeshMgr.GetZeroVertexBuffer(), 0, IsOpenGL() ? 4 : 0 ); + + if ( g_pHardwareConfig->Caps().m_SupportsVertexShaders_2_0 ) + { + float c[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; + ShaderAPI()->SetVertexShaderConstant( VERTEX_SHADER_FLEXSCALE, c, 1 ); + } + + g_bFlexMeshStreamSet = false; + } + } + + // MESHFIXME: Make sure this jives between the mesh/ib/vb version. +#ifdef _X360 + if ( ( g_pLastVertex != m_pVertexBuffer ) || ( m_pVertexBuffer->IsDynamic() ) || ( g_nLastVertOffsetInBytes != nVertOffsetInBytes ) ) +#else + if ( ( g_pLastVertex != m_pVertexBuffer ) || ( g_nLastVertOffsetInBytes != nVertOffsetInBytes ) ) +#endif + { + Assert( m_pVertexBuffer ); + + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( m_pVertexBuffer->UID() ); + RECORD_INT( 0 ); + RECORD_INT( nVertOffsetInBytes ); + RECORD_INT( m_pVertexBuffer->VertexSize() ); + + D3DSetStreamSource( 0, m_pVertexBuffer->GetInterface(), nVertOffsetInBytes, m_pVertexBuffer->VertexSize() ); + m_pVertexBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + + g_pLastVertex = m_pVertexBuffer; + g_nLastVertOffsetInBytes = nVertOffsetInBytes; + } +} + +void CMeshDX8::SetIndexStreamState( int firstVertexIdx ) +{ +#ifdef _X360 + if ( ( g_pLastIndexBuffer != NULL ) || (g_pLastIndex != m_pIndexBuffer) || ( m_pIndexBuffer->IsDynamic() ) || ( firstVertexIdx != g_LastVertexIdx ) ) +#else + if ( ( g_pLastIndexBuffer != NULL ) || (g_pLastIndex != m_pIndexBuffer) || ( firstVertexIdx != g_LastVertexIdx ) ) +#endif + { + Assert( m_pIndexBuffer ); + + RECORD_COMMAND( DX8_SET_INDICES, 2 ); + RECORD_INT( m_pIndexBuffer->UID() ); + RECORD_INT( firstVertexIdx ); + + Dx9Device()->SetIndices( m_pIndexBuffer->GetInterface() ); + m_pIndexBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + m_FirstIndex = firstVertexIdx; + + SafeAssign( &g_pLastIndex, m_pIndexBuffer ); + g_pLastIndexBuffer = NULL; + g_LastVertexIdx = firstVertexIdx; + } +} + +bool CMeshDX8::SetRenderState( int nVertexOffsetInBytes, int nFirstVertexIdx, VertexFormat_t vertexFormat ) +{ + // Can't set the state if we're deactivated + if ( g_pShaderDeviceDx8->IsDeactivated() ) + { + ResetMeshRenderState(); + return false; + } + + g_LastVertexFormat = vertexFormat; + + SetVertexIDStreamState(); + SetColorStreamState(); + SetVertexStreamState( nVertexOffsetInBytes ); + SetIndexStreamState( nFirstVertexIdx ); + + return true; +} + + +//----------------------------------------------------------------------------- +// Draws the static mesh +//----------------------------------------------------------------------------- +void CMeshDX8::Draw( int nFirstIndex, int nIndexCount ) +{ + Assert( m_pVertexBuffer ); + if ( !m_pVertexBuffer ) + { + return; + } + + if ( !ShaderUtil()->OnDrawMesh( this, nFirstIndex, nIndexCount ) ) + { + MarkAsDrawn(); + return; + } + + CPrimList primList; + if( nFirstIndex == -1 || nIndexCount == 0 ) + { + primList.m_FirstIndex = 0; + primList.m_NumIndices = m_NumIndices; + } + else + { + primList.m_FirstIndex = nFirstIndex; + primList.m_NumIndices = nIndexCount; + } + DrawInternal( &primList, 1 ); +} + +void CMeshDX8::Draw( CPrimList *pLists, int nLists ) +{ + Assert( m_pVertexBuffer ); + if ( !m_pVertexBuffer ) + { + return; + } + + if ( !ShaderUtil()->OnDrawMesh( this, pLists, nLists ) ) + { + MarkAsDrawn(); + return; + } + + DrawInternal( pLists, nLists ); +} + + +void CMeshDX8::DrawInternal( CPrimList *pLists, int nLists ) +{ + HandleLateCreation(); + + // Make sure there's something to draw.. + int i; + for ( i=0; i < nLists; i++ ) + { + if ( pLists[i].m_NumIndices > 0 ) + break; + } + if ( i == nLists ) + return; + + // can't do these in selection mode! + Assert( !ShaderAPI()->IsInSelectionMode() ); + + if ( !SetRenderState( 0, 0 ) ) + return; + + s_pPrims = pLists; + s_nPrims = nLists; + +#ifdef _DEBUG + for ( i = 0; i < nLists; ++i) + { + Assert( pLists[i].m_NumIndices > 0 ); + } +#endif + + s_FirstVertex = 0; + s_NumVertices = m_pVertexBuffer->VertexCount(); + + DrawMesh(); +} + + +#ifdef CHECK_INDICES +void CMeshDX8::CheckIndices( CPrimList *pPrim, int numPrimitives ) +{ + // g_pLastVertex - this is the current vertex buffer + // g_pLastColorMesh - this is the current color mesh, if there is one. + // g_pLastIndex - this is the current index buffer. + // vertoffset : m_FirstIndex + if( m_Mode == D3DPT_TRIANGLELIST || m_Mode == D3DPT_TRIANGLESTRIP ) + { + Assert( pPrim->m_FirstIndex >= 0 && pPrim->m_FirstIndex < g_pLastIndex->IndexCount() ); + int i; + for( i = 0; i < 2; i++ ) + { + CVertexBuffer *pMesh; + if( i == 0 ) + { + pMesh = g_pLastVertex; + Assert( pMesh ); + } + else + { + if( !g_pLastColorMesh ) + { + continue; + } + pMesh = g_pLastColorMesh->m_pVertexBuffer; + if( !pMesh ) + { + continue; + } + } + Assert( s_FirstVertex >= 0 && + (int)( s_FirstVertex + m_FirstIndex ) < pMesh->VertexCount() ); + int nIndexCount = 0; + if( m_Mode == D3DPT_TRIANGLELIST ) + { + nIndexCount = numPrimitives * 3; + } + else if( m_Mode == D3DPT_TRIANGLESTRIP ) + { + nIndexCount = numPrimitives + 2; + } + else + { + Assert( 0 ); + } + int j; + for( j = 0; j < nIndexCount; j++ ) + { + int index = g_pLastIndex->GetShadowIndex( j + pPrim->m_FirstIndex ); + if ( ( index < (int)s_FirstVertex ) || ( index >= (int)( s_FirstVertex + s_NumVertices ) ) ) + Warning("%s invalid index: %d [%u..%u]\n", __FUNCTION__, index, s_FirstVertex, s_FirstVertex + s_NumVertices - 1 ); + Assert( index >= (int)s_FirstVertex ); + Assert( index < (int)(s_FirstVertex + s_NumVertices) ); + } + } + } +} +#endif // CHECK_INDICES + + +//----------------------------------------------------------------------------- +// Actually does the dirty deed of rendering +//----------------------------------------------------------------------------- +void CMeshDX8::RenderPass() +{ + LOCK_SHADERAPI(); + VPROF( "CMeshDX8::RenderPass" ); + + HandleLateCreation(); + + Assert( m_Type != MATERIAL_HETEROGENOUS ); + + // make sure the vertex format is a superset of the current material's + // vertex format... + if ( !IsValidVertexFormat( g_LastVertexFormat ) ) + { + Warning( "Material %s does not support vertex format used by the mesh (maybe missing fields or mismatched vertex compression?), mesh will not be rendered. Grab a programmer!\n", + ShaderAPI()->GetBoundMaterial()->GetName() ); + return; + } + + for ( int iPrim=0; iPrim < s_nPrims; iPrim++ ) + { + CPrimList *pPrim = &s_pPrims[iPrim]; + + if ( pPrim->m_NumIndices == 0 ) + continue; + + if ( ( m_Type == MATERIAL_POINTS ) || ( m_Type == MATERIAL_INSTANCED_QUADS ) ) + { + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "Dx9Device_DrawPrimitive" ); + + // (For point/instanced-quad lists, we don't actually fill in indices, but we treat it as + // though there are indices for the list up until here). + Dx9Device()->DrawPrimitive( m_Mode, s_FirstVertex, pPrim->m_NumIndices ); + } + else + { + int numPrimitives = NumPrimitives( s_NumVertices, pPrim->m_NumIndices ); + +#ifdef CHECK_INDICES + CheckIndices( pPrim, numPrimitives ); +#endif // CHECK_INDICES + { + VPROF( "Dx9Device()->DrawIndexedPrimitive" ); + VPROF_INCREMENT_COUNTER( "DrawIndexedPrimitive", 1 ); + VPROF_INCREMENT_COUNTER( "numPrimitives", numPrimitives ); + VPROF_INCREMENT_GROUP_COUNTER( "render/DrawIndexedPrimitive", COUNTER_GROUP_TELEMETRY, 1 ); + VPROF_INCREMENT_GROUP_COUNTER( "render/numPrimitives", COUNTER_GROUP_TELEMETRY, 1 ); + + Dx9Device()->DrawIndexedPrimitive( + m_Mode, // Member of the D3DPRIMITIVETYPE enumerated type, describing the type of primitive to render. D3DPT_POINTLIST is not supported with this method. + + m_FirstIndex, // Offset from the start of the vertex buffer to the first vertex index. An index of 0 in the index buffer refers to this location in the vertex buffer. + + s_FirstVertex, // Minimum vertex index for vertices used during this call. This is a zero based index relative to BaseVertexIndex. + // The first Vertex in the vertexbuffer that we are currently using for the current batch. + + s_NumVertices, // Number of vertices used during this call. The first vertex is located at index: BaseVertexIndex + MinIndex. + + pPrim->m_FirstIndex, // Index of the first index to use when accesssing the vertex buffer. Beginning at StartIndex to index vertices from the vertex buffer. + + numPrimitives );// Number of primitives to render. The number of vertices used is a function of the primitive count and the primitive type. + } + } + } + + if ( g_pLastVertex ) + { + g_pLastVertex->MarkUsedInRendering(); + } + + if( g_pLastIndex ) + { + g_pLastIndex->MarkUsedInRendering(); + } +} + +//----------------------------------------------------------------------------- +// +// Dynamic mesh implementation +// +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// constructor, destructor +//----------------------------------------------------------------------------- +CDynamicMeshDX8::CDynamicMeshDX8() : CMeshDX8( "CDynamicMeshDX8" ) +{ + m_nBufferId = 0; + ResetVertexAndIndexCounts(); +} + +CDynamicMeshDX8::~CDynamicMeshDX8() +{ +} + + +//----------------------------------------------------------------------------- +// Initializes the dynamic mesh +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::Init( int nBufferId ) +{ + m_nBufferId = nBufferId; +} + + +//----------------------------------------------------------------------------- +// Resets buffering state +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::ResetVertexAndIndexCounts() +{ + m_TotalVertices = m_TotalIndices = 0; + m_FirstIndex = m_nFirstVertex = -1; + m_HasDrawn = false; +} + + +//----------------------------------------------------------------------------- +// Resets the state in case of a task switch +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::Reset() +{ + m_VertexFormat = 0; + m_pVertexBuffer = 0; + SafeRelease( &m_pIndexBuffer ); + ResetVertexAndIndexCounts(); + + // Force the render state to be updated next time + ResetMeshRenderState(); +} + + +//----------------------------------------------------------------------------- +// Sets the vertex format associated with the dynamic mesh +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::SetVertexFormat( VertexFormat_t format ) +{ + if ( g_pShaderDeviceDx8->IsDeactivated()) + return; + + if ( CompressionType( format ) != VERTEX_COMPRESSION_NONE ) + { + // UNDONE: support compressed dynamic meshes if needed (pro: less VB memory, con: CMeshBuilder gets slower) + Warning( "ERROR: dynamic meshes cannot use compressed vertices!\n" ); + Assert( 0 ); + format &= ~VERTEX_FORMAT_COMPRESSED; + } + + if ((format != m_VertexFormat) || m_VertexOverride || m_IndexOverride) + { + m_VertexFormat = format; + UseVertexBuffer( g_MeshMgr.FindOrCreateVertexBuffer( m_nBufferId, format ) ); + + if ( m_nBufferId == 0 ) + { + UseIndexBuffer( g_MeshMgr.GetDynamicIndexBuffer() ); + } + + m_VertexOverride = m_IndexOverride = false; + } +} + +void CDynamicMeshDX8::OverrideVertexBuffer( CVertexBuffer* pVertexBuffer ) +{ + UseVertexBuffer( pVertexBuffer ); + m_VertexOverride = true; +} + +void CDynamicMeshDX8::OverrideIndexBuffer( CIndexBuffer* pIndexBuffer ) +{ + UseIndexBuffer( pIndexBuffer ); + m_IndexOverride = true; +} + + +//----------------------------------------------------------------------------- +// Do I need to reset the vertex format? +//----------------------------------------------------------------------------- +bool CDynamicMeshDX8::NeedsVertexFormatReset( VertexFormat_t fmt ) const +{ + return m_VertexOverride || m_IndexOverride || (m_VertexFormat != fmt); +} + + + +//----------------------------------------------------------------------------- +// Locks/unlocks the entire mesh +//----------------------------------------------------------------------------- +bool CDynamicMeshDX8::HasEnoughRoom( int nVertexCount, int nIndexCount ) const +{ + if ( g_pShaderDeviceDx8->IsDeactivated() ) + return false; + + Assert( m_pVertexBuffer != NULL ); + + // We need space in both the vertex and index buffer + return m_pVertexBuffer->HasEnoughRoom( nVertexCount ) && + m_pIndexBuffer->HasEnoughRoom( nIndexCount ); +} + + +//----------------------------------------------------------------------------- +// returns the number of indices in the mesh +//----------------------------------------------------------------------------- +int CDynamicMeshDX8::IndexCount( ) const +{ + return m_TotalIndices; +} + + +//----------------------------------------------------------------------------- +// Operation to do pre-lock (only called for buffered meshes) +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::PreLock() +{ + if (m_HasDrawn) + { + // Start again then + ResetVertexAndIndexCounts(); + } +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the entire mesh +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s %d %d", __FUNCTION__, nVertexCount, nIndexCount ); + + ShaderUtil()->SyncMatrices(); + + { + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "g_ShaderMutex.Lock" ); + g_ShaderMutex.Lock(); + } + + // Yes, this may well also be called from BufferedMesh but that's ok + { + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "PreLock" ); + PreLock(); + } + + if (m_VertexOverride) + { + nVertexCount = 0; + } + + if (m_IndexOverride) + { + nIndexCount = 0; + } + + { + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "Lock" ); + Lock( nVertexCount, false, *static_cast<VertexDesc_t*>( &desc ) ); + } + + if (m_nFirstVertex < 0) + { + m_nFirstVertex = desc.m_nFirstVertex; + } + + // When we're using a static index buffer or a flex mesh, the indices assume vertices start at 0 + if ( m_IndexOverride || HasFlexMesh() ) + { + desc.m_nFirstVertex -= m_nFirstVertex; + } + + // Don't add indices for points; DrawIndexedPrimitive not supported for them. + if ( m_Type != MATERIAL_POINTS ) + { + int nFirstIndex; + { + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "Lock nFirstIndex" ); + nFirstIndex = Lock( false, -1, nIndexCount, *static_cast<IndexDesc_t*>( &desc ) ); + } + if (m_FirstIndex < 0) + { + m_FirstIndex = nFirstIndex; + } + } + else + { + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + } + + CBaseMeshDX8::m_bMeshLocked = true; +} + + +//----------------------------------------------------------------------------- +// Unlocks the mesh +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + m_TotalVertices += nVertexCount; + m_TotalIndices += nIndexCount; + + if (DebugTrace()) + { + Spew( nVertexCount, nIndexCount, desc ); + } + + CMeshDX8::UnlockMesh( nVertexCount, nIndexCount, desc ); + + // This is handled in the CMeshDX8::UnlockMesh above. + //CBaseMeshDX8::m_bMeshLocked = false; +} + + +//----------------------------------------------------------------------------- +// Draws it +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::Draw( int nFirstIndex, int nIndexCount ) +{ + if ( !ShaderUtil()->OnDrawMesh( this, nFirstIndex, nIndexCount ) ) + { + MarkAsDrawn(); + return; + } + + VPROF( "CDynamicMeshDX8::Draw" ); + + m_HasDrawn = true; + + if (m_IndexOverride || m_VertexOverride || + ( ( m_TotalVertices > 0 ) && ( m_TotalIndices > 0 || m_Type == MATERIAL_POINTS || m_Type == MATERIAL_INSTANCED_QUADS ) ) ) + { + Assert( !m_IsDrawing ); + + HandleLateCreation( ); + + // only have a non-zero first vertex when we are using static indices + int nFirstVertex = m_VertexOverride ? 0 : m_nFirstVertex; + int actualFirstVertex = m_IndexOverride ? nFirstVertex : 0; + int nVertexOffsetInBytes = HasFlexMesh() ? nFirstVertex * g_MeshMgr.VertexFormatSize( GetVertexFormat() ) : 0; + int baseIndex = m_IndexOverride ? 0 : m_FirstIndex; + + // Overriding with the dynamic index buffer, preserve state! + if ( m_IndexOverride && m_pIndexBuffer == g_MeshMgr.GetDynamicIndexBuffer() ) + { + baseIndex = m_FirstIndex; + } + + VertexFormat_t fmt = m_VertexOverride ? GetVertexFormat() : VERTEX_FORMAT_INVALID; + if ( !SetRenderState( nVertexOffsetInBytes, actualFirstVertex, fmt ) ) + return; + + // Draws a portion of the mesh + int numVertices = m_VertexOverride ? m_pVertexBuffer->VertexCount() : m_TotalVertices; + if ((nFirstIndex != -1) && (nIndexCount != 0)) + { + nFirstIndex += baseIndex; + } + else + { + // by default we draw the whole thing + nFirstIndex = baseIndex; + if( m_IndexOverride ) + { + nIndexCount = m_pIndexBuffer->IndexCount(); + Assert( nIndexCount != 0 ); + } + else + { + nIndexCount = m_TotalIndices; + // Fake out the index count if we're drawing points/instanced-quads + if ( ( m_Type == MATERIAL_POINTS ) || ( m_Type == MATERIAL_INSTANCED_QUADS ) ) + { + nIndexCount = m_TotalVertices; + } + Assert( nIndexCount != 0 ); + } + } + + // Fix up nFirstVertex to indicate the first vertex used in the data + if ( !HasFlexMesh() ) + { + actualFirstVertex = nFirstVertex - actualFirstVertex; + } + + s_FirstVertex = actualFirstVertex; + s_NumVertices = numVertices; + + // Build a primlist with 1 element.. + CPrimList prim; + prim.m_FirstIndex = nFirstIndex; + prim.m_NumIndices = nIndexCount; + Assert( nIndexCount != 0 ); + s_pPrims = &prim; + s_nPrims = 1; + + DrawMesh(); + + s_pPrims = NULL; + } +} + + +//----------------------------------------------------------------------------- +// This is useful when we need to dynamically modify data; just set the +// render state and draw the pass immediately +//----------------------------------------------------------------------------- +void CDynamicMeshDX8::DrawSinglePassImmediately() +{ + if ((m_TotalVertices > 0) || (m_TotalIndices > 0)) + { + Assert( !m_IsDrawing ); + + // Set the render state + if ( SetRenderState( 0, 0 ) ) + { + s_FirstVertex = m_nFirstVertex; + s_NumVertices = m_TotalVertices; + + // Make a temporary PrimList to hold the indices. + CPrimList prim( m_FirstIndex, m_TotalIndices ); + Assert( m_TotalIndices != 0 ); + s_pPrims = &prim; + s_nPrims = 1; + + // Render it + RenderPass(); + } + + // We're done with our data + ResetVertexAndIndexCounts(); + } +} + +//----------------------------------------------------------------------------- +// +// A mesh that stores temporary vertex data in the correct format (for modification) +// +//----------------------------------------------------------------------------- +// Used in rendering sub-parts of the mesh +unsigned int CTempMeshDX8::s_NumIndices; +unsigned int CTempMeshDX8::s_FirstIndex; + +//----------------------------------------------------------------------------- +// constructor, destructor +//----------------------------------------------------------------------------- +CTempMeshDX8::CTempMeshDX8( bool isDynamic ) : m_VertexSize(0xFFFF), m_IsDynamic(isDynamic) +{ +#ifdef DBGFLAG_ASSERT + m_Locked = false; + m_InPass = false; +#endif +} + +CTempMeshDX8::~CTempMeshDX8() +{ +} + +//----------------------------------------------------------------------------- +// Is the temp mesh dynamic? +//----------------------------------------------------------------------------- +bool CTempMeshDX8::IsDynamic() const +{ + return m_IsDynamic; +} + + +//----------------------------------------------------------------------------- +// Sets the vertex format +//----------------------------------------------------------------------------- +void CTempMeshDX8::SetVertexFormat( VertexFormat_t format ) +{ + CBaseMeshDX8::SetVertexFormat(format); + m_VertexSize = g_MeshMgr.VertexFormatSize( format ); +} + +//----------------------------------------------------------------------------- +// returns the # of vertices (static meshes only) +//----------------------------------------------------------------------------- +int CTempMeshDX8::VertexCount() const +{ + return m_VertexSize ? m_VertexData.Count() / m_VertexSize : 0; +} + +//----------------------------------------------------------------------------- +// returns the # of indices +//----------------------------------------------------------------------------- +int CTempMeshDX8::IndexCount( ) const +{ + return m_IndexData.Count(); +} + +void CTempMeshDX8::ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + Assert( !m_Locked ); + + m_LockedVerts = nVertexCount; + m_LockedIndices = nIndexCount; + + if( nVertexCount > 0 ) + { + int vertexByteOffset = m_VertexSize * nFirstVertex; + + // Lock it baby + unsigned char* pVertexMemory = &m_VertexData[vertexByteOffset]; + + // Compute the vertex index.. + desc.m_nFirstVertex = vertexByteOffset / m_VertexSize; + + // Set up the mesh descriptor + g_MeshMgr.ComputeVertexDescription( pVertexMemory, m_VertexFormat, desc ); + } + else + { + desc.m_nFirstVertex = 0; + // Set up the mesh descriptor + g_MeshMgr.ComputeVertexDescription( 0, 0, desc ); + } + + if (m_Type != MATERIAL_POINTS && nIndexCount > 0 ) + { + desc.m_pIndices = &m_IndexData[nFirstIndex]; + desc.m_nIndexSize = 1; + } + else + { + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + } + +#ifdef DBGFLAG_ASSERT + m_Locked = true; +#endif +} + +void CTempMeshDX8::ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc ) +{ + ModifyBeginEx( false, nFirstVertex, nVertexCount, nFirstIndex, nIndexCount, desc ); +} + +void CTempMeshDX8::ModifyEnd( MeshDesc_t& desc ) +{ +#ifdef DBGFLAG_ASSERT + Assert( m_Locked ); + m_Locked = false; +#endif +} + +//----------------------------------------------------------------------------- +// Locks/unlocks the mesh +//----------------------------------------------------------------------------- +void CTempMeshDX8::LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + ShaderUtil()->SyncMatrices(); + + g_ShaderMutex.Lock(); + + Assert( !m_Locked ); + + m_LockedVerts = nVertexCount; + m_LockedIndices = nIndexCount; + + if( nVertexCount > 0 ) + { + int vertexByteOffset = m_VertexData.AddMultipleToTail( m_VertexSize * nVertexCount ); + + // Lock it baby + unsigned char* pVertexMemory = &m_VertexData[vertexByteOffset]; + + // Compute the vertex index.. + desc.m_nFirstVertex = vertexByteOffset / m_VertexSize; + + // Set up the mesh descriptor + g_MeshMgr.ComputeVertexDescription( pVertexMemory, m_VertexFormat, desc ); + } + else + { + desc.m_nFirstVertex = 0; + // Set up the mesh descriptor + g_MeshMgr.ComputeVertexDescription( 0, 0, desc ); + } + + if (m_Type != MATERIAL_POINTS && nIndexCount > 0 ) + { + int nFirstIndex = m_IndexData.AddMultipleToTail( nIndexCount ); + desc.m_pIndices = &m_IndexData[nFirstIndex]; + desc.m_nIndexSize = 1; + } + else + { + desc.m_pIndices = g_nScratchIndexBuffer; + desc.m_nIndexSize = 0; + } + +#ifdef DBGFLAG_ASSERT + m_Locked = true; +#endif + + CBaseMeshDX8::m_bMeshLocked = true; +} + +void CTempMeshDX8::UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + Assert( m_Locked ); + + // Remove unused vertices and indices + int verticesToRemove = m_LockedVerts - nVertexCount; + if( verticesToRemove != 0 ) + { + m_VertexData.RemoveMultiple( m_VertexData.Count() - verticesToRemove, verticesToRemove ); + } + + int indicesToRemove = m_LockedIndices - nIndexCount; + if( indicesToRemove != 0 ) + { + m_IndexData.RemoveMultiple( m_IndexData.Count() - indicesToRemove, indicesToRemove ); + } + +#ifdef DBGFLAG_ASSERT + m_Locked = false; +#endif + + CBaseMeshDX8::m_bMeshLocked = false; + + g_ShaderMutex.Unlock(); +} + +//----------------------------------------------------------------------------- +// Sets the primitive type +//----------------------------------------------------------------------------- +void CTempMeshDX8::SetPrimitiveType( MaterialPrimitiveType_t type ) +{ + // FIXME: Support MATERIAL_INSTANCED_QUADS for CTempMeshDX8 (X360 only) + Assert( ( type != MATERIAL_INSTANCED_QUADS ) /* || IsX360() */ ); + m_Type = type; +} + +MaterialPrimitiveType_t CTempMeshDX8::GetPrimitiveType( ) const +{ + return m_Type; +} + +//----------------------------------------------------------------------------- +// Gets the dynamic mesh +//----------------------------------------------------------------------------- +CDynamicMeshDX8* CTempMeshDX8::GetDynamicMesh( ) +{ + return static_cast<CDynamicMeshDX8*>(g_MeshMgr.GetActualDynamicMesh( m_VertexFormat )); +} + +//----------------------------------------------------------------------------- +// Draws the entire mesh +//----------------------------------------------------------------------------- +void CTempMeshDX8::Draw( int nFirstIndex, int nIndexCount ) +{ + if ( !ShaderUtil()->OnDrawMesh( this, nFirstIndex, nIndexCount ) ) + { + MarkAsDrawn(); + return; + } + + if (m_VertexData.Count() > 0) + { + if ( !g_pShaderDeviceDx8->IsDeactivated() ) + { +#ifdef DRAW_SELECTION + if (!g_bDrawSelection && !ShaderAPI()->IsInSelectionMode()) +#else + if (!ShaderAPI()->IsInSelectionMode()) +#endif + { + s_FirstIndex = nFirstIndex; + s_NumIndices = nIndexCount; + + DrawMesh( ); + + // This assertion fails if a BeginPass() call was not matched by + // a RenderPass() call + Assert(!m_InPass); + } + else + { + TestSelection(); + } + } + + // Clear out the data if this temp mesh is a dynamic one... + if (m_IsDynamic) + { + m_VertexData.RemoveAll(); + m_IndexData.RemoveAll(); + } + } +} + +void CTempMeshDX8::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 ) +{ + int startOffset = iStartVert * m_VertexSize; + int endOffset = (iStartVert + nVerts) * m_VertexSize; + Assert( startOffset >= 0 && startOffset <= m_VertexData.Count() ); + Assert( endOffset >= 0 && endOffset <= m_VertexData.Count() && endOffset >= startOffset ); + if ( endOffset > startOffset ) + { + // FIXME: make this a method of CMeshBuilder (so the 'Position' pointer accessor can be removed) + // make sure it takes a VertexFormat_t parameter for src/dest match validation + memcpy( (void*)builder.Position(), &m_VertexData[startOffset], endOffset - startOffset ); + builder.AdvanceVertices( nVerts ); + } + + for ( int i = 0; i < nIndices; ++i ) + { + builder.Index( m_IndexData[iStartIndex+i] + indexOffset ); + builder.AdvanceIndex(); + } +} + +//----------------------------------------------------------------------------- +// Selection mode helper functions +//----------------------------------------------------------------------------- +static void ComputeModelToView( D3DXMATRIX& modelToView ) +{ + // Get the modelview matrix... + D3DXMATRIX world, view; + ShaderAPI()->GetMatrix( MATERIAL_MODEL, (float*)&world ); + ShaderAPI()->GetMatrix( MATERIAL_VIEW, (float*)&view ); + D3DXMatrixMultiply( &modelToView, &world, &view ); +} + +static float ComputeCullFactor( ) +{ + D3DCULL cullMode = ShaderAPI()->GetCullMode(); + + float cullFactor; + switch(cullMode) + { + case D3DCULL_CCW: + cullFactor = -1.0f; + break; + + case D3DCULL_CW: + cullFactor = 1.0f; + break; + + default: + cullFactor = 0.0f; + break; + }; + + return cullFactor; +} + +//----------------------------------------------------------------------------- +// Clip to viewport +//----------------------------------------------------------------------------- +static int g_NumClipVerts; +static D3DXVECTOR3 g_ClipVerts[16]; + +static bool PointInsidePlane( D3DXVECTOR3* pVert, int normalInd, float val, bool nearClip ) +{ + if ((val > 0) || nearClip) + return (val - (*pVert)[normalInd] >= 0); + else + return ((*pVert)[normalInd] - val >= 0); +} + +static void IntersectPlane( D3DXVECTOR3* pStart, D3DXVECTOR3* pEnd, + int normalInd, float val, D3DXVECTOR3* pOutVert ) +{ + D3DXVECTOR3 dir; + D3DXVec3Subtract( &dir, pEnd, pStart ); + Assert( dir[normalInd] != 0.0f ); + float t = (val - (*pStart)[normalInd]) / dir[normalInd]; + pOutVert->x = pStart->x + dir.x * t; + pOutVert->y = pStart->y + dir.y * t; + pOutVert->z = pStart->z + dir.z * t; + + // Avoid any precision problems. + (*pOutVert)[normalInd] = val; +} + +static int ClipTriangleAgainstPlane( D3DXVECTOR3** ppVert, int nVertexCount, + D3DXVECTOR3** ppOutVert, int normalInd, float val, bool nearClip = false ) +{ + // Ye Olde Sutherland-Hodgman clipping algorithm + int numOutVerts = 0; + D3DXVECTOR3* pStart = ppVert[nVertexCount-1]; + bool startInside = PointInsidePlane( pStart, normalInd, val, nearClip ); + for (int i = 0; i < nVertexCount; ++i) + { + D3DXVECTOR3* pEnd = ppVert[i]; + bool endInside = PointInsidePlane( pEnd, normalInd, val, nearClip ); + if (endInside) + { + if (!startInside) + { + IntersectPlane( pStart, pEnd, normalInd, val, &g_ClipVerts[g_NumClipVerts] ); + ppOutVert[numOutVerts++] = &g_ClipVerts[g_NumClipVerts++]; + } + ppOutVert[numOutVerts++] = pEnd; + } + else + { + if (startInside) + { + IntersectPlane( pStart, pEnd, normalInd, val, &g_ClipVerts[g_NumClipVerts] ); + ppOutVert[numOutVerts++] = &g_ClipVerts[g_NumClipVerts++]; + } + } + pStart = pEnd; + startInside = endInside; + } + + return numOutVerts; +} + +void CTempMeshDX8::ClipTriangle( D3DXVECTOR3** ppVert, float zNear, D3DXMATRIX& projection ) +{ + int i; + int nVertexCount = 3; + D3DXVECTOR3* ppClipVert1[10]; + D3DXVECTOR3* ppClipVert2[10]; + + g_NumClipVerts = 0; + + // Clip against the near plane in view space to prevent negative w. + // Clip against each plane + nVertexCount = ClipTriangleAgainstPlane( ppVert, nVertexCount, ppClipVert1, 2, zNear, true ); + if (nVertexCount < 3) + return; + + // Sucks that I have to do this, but I have to clip near plane in view space + // Clipping in projection space is screwy when w < 0 + // Transform the clipped points into projection space + Assert( g_NumClipVerts <= 2 ); + for (i = 0; i < nVertexCount; ++i) + { + if (ppClipVert1[i] == &g_ClipVerts[0]) + { + D3DXVec3TransformCoord( &g_ClipVerts[0], ppClipVert1[i], &projection ); + } + else if (ppClipVert1[i] == &g_ClipVerts[1]) + { + D3DXVec3TransformCoord( &g_ClipVerts[1], ppClipVert1[i], &projection ); + } + else + { + D3DXVec3TransformCoord( &g_ClipVerts[g_NumClipVerts], ppClipVert1[i], &projection ); + ppClipVert1[i] = &g_ClipVerts[g_NumClipVerts]; + ++g_NumClipVerts; + } + } + + nVertexCount = ClipTriangleAgainstPlane( ppClipVert1, nVertexCount, ppClipVert2, 2, 1.0f ); + if (nVertexCount < 3) + return; + + nVertexCount = ClipTriangleAgainstPlane( ppClipVert2, nVertexCount, ppClipVert1, 0, 1.0f ); + if (nVertexCount < 3) + return; + + nVertexCount = ClipTriangleAgainstPlane( ppClipVert1, nVertexCount, ppClipVert2, 0, -1.0f ); + if (nVertexCount < 3) + return; + + nVertexCount = ClipTriangleAgainstPlane( ppClipVert2, nVertexCount, ppClipVert1, 1, 1.0f ); + if (nVertexCount < 3) + return; + + nVertexCount = ClipTriangleAgainstPlane( ppClipVert1, nVertexCount, ppClipVert2, 1, -1.0f ); + if (nVertexCount < 3) + return; + +#ifdef DRAW_SELECTION + if( 1 || g_bDrawSelection ) + { + srand( *(int*)(&ppClipVert2[0]->x) ); + unsigned char r = (unsigned char)(rand() * 191.0f / VALVE_RAND_MAX) + 64; + unsigned char g = (unsigned char)(rand() * 191.0f / VALVE_RAND_MAX) + 64; + unsigned char b = (unsigned char)(rand() * 191.0f / VALVE_RAND_MAX) + 64; + + ShaderAPI()->SetupSelectionModeVisualizationState(); + + CMeshBuilder* pMeshBuilder = ShaderAPI()->GetVertexModifyBuilder(); + IMesh* pMesh = GetDynamicMesh(); + pMeshBuilder->Begin( pMesh, MATERIAL_POLYGON, nVertexCount ); + + for ( i = 0; i < nVertexCount; ++i) + { + pMeshBuilder->Position3fv( *ppClipVert2[i] ); + pMeshBuilder->Color3ub( r, g, b ); + pMeshBuilder->AdvanceVertex(); + } + + pMeshBuilder->End(); + pMesh->Draw(); + + pMeshBuilder->Begin( pMesh, MATERIAL_LINE_LOOP, nVertexCount ); + + for ( i = 0; i < nVertexCount; ++i) + { + pMeshBuilder->Position3fv( *ppClipVert2[i] ); + pMeshBuilder->Color3ub( 255, 255, 255 ); + pMeshBuilder->AdvanceVertex(); + } + + pMeshBuilder->End(); + pMesh->Draw(); + } +#endif + + // Compute closest and furthest verts + float minz = ppClipVert2[0]->z; + float maxz = ppClipVert2[0]->z; + for ( i = 1; i < nVertexCount; ++i ) + { + if (ppClipVert2[i]->z < minz) + minz = ppClipVert2[i]->z; + else if (ppClipVert2[i]->z > maxz) + maxz = ppClipVert2[i]->z; + } + + ShaderAPI()->RegisterSelectionHit( minz, maxz ); +} + +//----------------------------------------------------------------------------- +// Selection mode +//----------------------------------------------------------------------------- +void CTempMeshDX8::TestSelection() +{ + // Note that this doesn't take into account any vertex modification + // done in a vertex shader. Also it doesn't take into account any clipping + // done in hardware + + // Blow off points and lines; they don't matter + if ((m_Type != MATERIAL_TRIANGLES) && (m_Type != MATERIAL_TRIANGLE_STRIP)) + return; + + D3DXMATRIX modelToView, projection; + ComputeModelToView( modelToView ); + ShaderAPI()->GetMatrix( MATERIAL_PROJECTION, (float*)&projection ); + float zNear = -projection.m[3][2] / projection.m[2][2]; + + D3DXVECTOR3* pPos[3]; + D3DXVECTOR3 edge[2]; + D3DXVECTOR3 normal; + + int numTriangles; + if (m_Type == MATERIAL_TRIANGLES) + numTriangles = m_IndexData.Count() / 3; + else + numTriangles = m_IndexData.Count() - 2; + + float cullFactor = ComputeCullFactor(); + + // Makes the lovely loop simpler + if (m_Type == MATERIAL_TRIANGLE_STRIP) + cullFactor *= -1.0f; + + // We'll need some temporary memory to tell us if we're transformed the vert + int nVertexCount = m_VertexData.Count() / m_VertexSize; + static CUtlVector< unsigned char > transformedVert; + int transformedVertSize = (nVertexCount + 7) >> 3; + transformedVert.RemoveAll(); + transformedVert.EnsureCapacity( transformedVertSize ); + transformedVert.AddMultipleToTail( transformedVertSize ); + memset( transformedVert.Base(), 0, transformedVertSize ); + + int indexPos; + for (int i = 0; i < numTriangles; ++i) + { + // Get the three indices + if (m_Type == MATERIAL_TRIANGLES) + { + indexPos = i * 3; + } + else + { + Assert( m_Type == MATERIAL_TRIANGLE_STRIP ); + cullFactor *= -1.0f; + indexPos = i; + } + + // BAH. Gotta clip to the near clip plane in view space to prevent + // negative w coords; negative coords throw off the projection-space clipper. + + // Get the three positions in view space + int inFrontIdx = -1; + for (int j = 0; j < 3; ++j) + { + int index = m_IndexData[indexPos]; + D3DXVECTOR3* pPosition = (D3DXVECTOR3*)&m_VertexData[index * m_VertexSize]; + if ((transformedVert[index >> 3] & (1 << (index & 0x7))) == 0) + { + D3DXVec3TransformCoord( pPosition, pPosition, &modelToView ); + transformedVert[index >> 3] |= (1 << (index & 0x7)); + } + + pPos[j] = pPosition; + if (pPos[j]->z < 0.0f) + inFrontIdx = j; + ++indexPos; + } + + // all points are behind the camera + if (inFrontIdx < 0) + continue; + + // backface cull.... + D3DXVec3Subtract( &edge[0], pPos[1], pPos[0] ); + D3DXVec3Subtract( &edge[1], pPos[2], pPos[0] ); + D3DXVec3Cross( &normal, &edge[0], &edge[1] ); + float dot = D3DXVec3Dot( &normal, pPos[inFrontIdx] ); + if (dot * cullFactor > 0.0f) + continue; + + // Clip to viewport + ClipTriangle( pPos, zNear, projection ); + } +} + +//----------------------------------------------------------------------------- +// Begins a render pass +//----------------------------------------------------------------------------- +void CTempMeshDX8::BeginPass( ) +{ + Assert( !m_InPass ); + +#ifdef DBGFLAG_ASSERT + m_InPass = true; +#endif + + CMeshBuilder* pMeshBuilder = ShaderAPI()->GetVertexModifyBuilder(); + + CDynamicMeshDX8* pMesh = GetDynamicMesh( ); + + int nIndexCount; + int nFirstIndex; + if ((s_FirstIndex == -1) && (s_NumIndices == 0)) + { + nIndexCount = m_IndexData.Count(); + nFirstIndex = 0; + } + else + { + nIndexCount = s_NumIndices; + nFirstIndex = s_FirstIndex; + } + + int i; + int nVertexCount = m_VertexData.Count() / m_VertexSize; + pMeshBuilder->Begin( pMesh, m_Type, nVertexCount, nIndexCount ); + + // Copy in the vertex data... + // Note that since we pad the vertices, it's faster for us to simply + // copy the fields we're using... + Assert( pMeshBuilder->BaseVertexData() ); + memcpy( pMeshBuilder->BaseVertexData(), m_VertexData.Base(), m_VertexData.Count() ); + pMeshBuilder->AdvanceVertices( m_VertexData.Count() / m_VertexSize ); + + for ( i = 0; i < nIndexCount; ++i ) + { + pMeshBuilder->Index( m_IndexData[nFirstIndex+i] ); + pMeshBuilder->AdvanceIndex(); + } + + // NOTE: The client is expected to modify the data after this call is made + pMeshBuilder->Reset(); +} + +//----------------------------------------------------------------------------- +// Draws a single pass +//----------------------------------------------------------------------------- +void CTempMeshDX8::RenderPass() +{ + Assert( m_InPass ); + +#ifdef DBGFLAG_ASSERT + m_InPass = false; +#endif + + // Have the shader API modify the vertex data as it needs + // This vertex data is modified based on state set by the material + ShaderAPI()->ModifyVertexData( ); + + // Done building the mesh + ShaderAPI()->GetVertexModifyBuilder()->End(); + + // Have the dynamic mesh render a single pass... + GetDynamicMesh()->DrawSinglePassImmediately(); +} + +//----------------------------------------------------------------------------- +// +// Buffered mesh implementation +// +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// constructor, destructor +//----------------------------------------------------------------------------- + +CBufferedMeshDX8::CBufferedMeshDX8() : m_IsFlushing(false), m_WasRendered(true) +{ + m_pMesh = NULL; +#ifdef DEBUG_BUFFERED_STATE + m_BufferedStateSet = false; +#endif +} + +CBufferedMeshDX8::~CBufferedMeshDX8() +{ +} + + +//----------------------------------------------------------------------------- +// Sets the mesh +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::SetMesh( CBaseMeshDX8* pMesh ) +{ + if (m_pMesh != pMesh) + { + ShaderAPI()->FlushBufferedPrimitives(); + m_pMesh = pMesh; + } +} + + +//----------------------------------------------------------------------------- +// Spews the mesh data +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::Spew( int nVertexCount, int nIndexCount, const MeshDesc_t &spewDesc ) +{ + if ( m_pMesh ) + { + m_pMesh->Spew( nVertexCount, nIndexCount, spewDesc ); + } +} + + +//----------------------------------------------------------------------------- +// Sets the material +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::SetVertexFormat( VertexFormat_t format ) +{ + Assert( m_pMesh ); + if (m_pMesh->NeedsVertexFormatReset(format)) + { + ShaderAPI()->FlushBufferedPrimitives(); + m_pMesh->SetVertexFormat( format ); + } +} + +void CBufferedMeshDX8::SetMorphFormat( MorphFormat_t format ) +{ + Assert( m_pMesh ); + m_pMesh->SetMorphFormat( format ); +} + +VertexFormat_t CBufferedMeshDX8::GetVertexFormat( ) const +{ + Assert( m_pMesh ); + return m_pMesh->GetVertexFormat(); +} + +void CBufferedMeshDX8::SetMaterial( IMaterial* pMaterial ) +{ +#if _DEBUG + Assert( m_pMesh ); + m_pMesh->SetMaterial( pMaterial ); +#endif +} + +void CBufferedMeshDX8::ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t & spewDesc ) +{ +#if _DEBUG + Assert( m_pMesh ); + m_pMesh->ValidateData( nVertexCount, nIndexCount, spewDesc ); +#endif +} + + +//----------------------------------------------------------------------------- +// Sets the flex mesh to render with this mesh +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::SetFlexMesh( IMesh *pMesh, int nVertexOffsetInBytes ) +{ + // FIXME: Probably are situations where we don't need to flush, + // but this is going to look different in a very short while, so I'm not going to bother + ShaderAPI()->FlushBufferedPrimitives(); + m_pMesh->SetFlexMesh( pMesh, nVertexOffsetInBytes ); +} + + +//----------------------------------------------------------------------------- +// checks to see if it was rendered.. +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::ResetRendered() +{ + m_WasRendered = false; +} + +bool CBufferedMeshDX8::WasNotRendered() const +{ + return !m_WasRendered; +} + + +//----------------------------------------------------------------------------- +// "Draws" it +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::Draw( int nFirstIndex, int nIndexCount ) +{ + if ( !ShaderUtil()->OnDrawMesh( this, nFirstIndex, nIndexCount ) ) + { + m_WasRendered = true; + MarkAsDrawn(); + return; + } + + Assert( !m_IsFlushing && !m_WasRendered ); + + // Gotta draw all of the buffered mesh + Assert( (nFirstIndex == -1) && (nIndexCount == 0) ); + + // No need to draw it more than once... + m_WasRendered = true; + + // We've got something to flush + m_FlushNeeded = true; + + // Less than 0 indices indicates we were using a standard buffer + if ( m_pMesh->HasFlexMesh() || !ShaderUtil()->GetConfig().bBufferPrimitives ) + { + ShaderAPI()->FlushBufferedPrimitives(); + } +} + + +//----------------------------------------------------------------------------- +// Sets the primitive mode +//----------------------------------------------------------------------------- + +void CBufferedMeshDX8::SetPrimitiveType( MaterialPrimitiveType_t type ) +{ + Assert( IsX360() || ( type != MATERIAL_INSTANCED_QUADS ) ); + Assert( type != MATERIAL_HETEROGENOUS ); + + if (type != GetPrimitiveType()) + { + ShaderAPI()->FlushBufferedPrimitives(); + m_pMesh->SetPrimitiveType(type); + } +} + +MaterialPrimitiveType_t CBufferedMeshDX8::GetPrimitiveType( ) const +{ + return m_pMesh->GetPrimitiveType(); +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the entire mesh +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + ShaderUtil()->SyncMatrices(); + + Assert( m_pMesh ); + Assert( m_WasRendered ); + + // Do some pre-lock processing + m_pMesh->PreLock(); + + // for tristrips, gotta make degenerate ones... + m_ExtraIndices = 0; + bool tristripFixup = (m_pMesh->IndexCount() != 0) && + (m_pMesh->GetPrimitiveType() == MATERIAL_TRIANGLE_STRIP); + if (tristripFixup) + { + m_ExtraIndices = (m_pMesh->IndexCount() & 0x1) != 0 ? 3 : 2; + nIndexCount += m_ExtraIndices; + } + + // Flush if we gotta + if (!m_pMesh->HasEnoughRoom(nVertexCount, nIndexCount)) + { + ShaderAPI()->FlushBufferedPrimitives(); + } + + m_pMesh->LockMesh( nVertexCount, nIndexCount, desc ); + +// This is taken care of in the function above. +// CBaseMeshDX8::m_bMeshLocked = true; + + // Deal with fixing up the tristrip.. + if ( tristripFixup && desc.m_nIndexSize ) + { + char buf[32]; + if (DebugTrace()) + { + if (m_ExtraIndices == 3) + sprintf(buf,"Link Index: %d %d\n", m_LastIndex, m_LastIndex); + else + sprintf(buf,"Link Index: %d\n", m_LastIndex); + Plat_DebugString(buf); + } + *desc.m_pIndices++ = m_LastIndex; + if (m_ExtraIndices == 3) + { + *desc.m_pIndices++ = m_LastIndex; + } + + // Leave room for the last padding index + ++desc.m_pIndices; + } + + m_WasRendered = false; + +#ifdef DEBUG_BUFFERED_MESHES + if (m_BufferedStateSet) + { + BufferedState_t compare; + ShaderAPI()->GetBufferedState( compare ); + Assert( !memcmp( &compare, &m_BufferedState, sizeof(compare) ) ); + } + else + { + ShaderAPI()->GetBufferedState( m_BufferedState ); + m_BufferedStateSet = true; + } +#endif +} + + +//----------------------------------------------------------------------------- +// Locks/unlocks the entire mesh +//----------------------------------------------------------------------------- +void CBufferedMeshDX8::UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc ) +{ + Assert( m_pMesh ); + + // Gotta fix up the first index to batch strips reasonably + if ((m_pMesh->GetPrimitiveType() == MATERIAL_TRIANGLE_STRIP) && desc.m_nIndexSize ) + { + if (m_ExtraIndices > 0) + { + *(desc.m_pIndices - 1) = *desc.m_pIndices; + + if (DebugTrace()) + { + char buf[32]; + sprintf(buf,"Link Index: %d\n", *desc.m_pIndices); + Plat_DebugString(buf); + } + } + + // Remember the last index for next time + m_LastIndex = desc.m_pIndices[nIndexCount - 1]; + + nIndexCount += m_ExtraIndices; + } + + m_pMesh->UnlockMesh( nVertexCount, nIndexCount, desc ); + +// This is taken care of in the function above. +// CBaseMeshDX8::m_bMeshLocked = false; +} + + +//----------------------------------------------------------------------------- +// Renders a pass +//----------------------------------------------------------------------------- + +void CBufferedMeshDX8::RenderPass() +{ + // this should never be called! + Assert(0); +} + +//----------------------------------------------------------------------------- +// Flushes queued data +//----------------------------------------------------------------------------- + +void CBufferedMeshDX8::Flush( ) +{ + // If you are hitting this assert you are causing a flush between a + // meshbuilder begin/end and you are more than likely losing rendering data. + AssertOnce( !CBaseMeshDX8::m_bMeshLocked ); + + if ( m_pMesh && !m_IsFlushing && m_FlushNeeded ) + { + VPROF( "CBufferedMeshDX8::Flush" ); + +#ifdef DEBUG_BUFFERED_MESHES + if( m_BufferedStateSet ) + { + BufferedState_t compare; + ShaderAPI()->GetBufferedState( compare ); + Assert( !memcmp( &compare, &m_BufferedState, sizeof(compare) ) ); + m_BufferedStateSet = false; + } +#endif + + m_IsFlushing = true; + + // Actually draws the data using the mesh's material + static_cast<IMesh*>(m_pMesh)->Draw(); + + m_IsFlushing = false; + m_FlushNeeded = false; + + m_pMesh->SetFlexMesh( NULL, 0 ); + } +} + +//----------------------------------------------------------------------------- +// +// Mesh manager implementation +// +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// Constructor, destructor +//----------------------------------------------------------------------------- +CMeshMgr::CMeshMgr() : + m_pDynamicIndexBuffer(0), + m_DynamicTempMesh(true), + m_pVertexIDBuffer(0), + m_pCurrentVertexBuffer( NULL ), + m_CurrentVertexFormat( 0 ), + m_pCurrentIndexBuffer( NULL ), + m_DynamicIndexBuffer( SHADER_BUFFER_TYPE_DYNAMIC, MATERIAL_INDEX_FORMAT_16BIT, INDEX_BUFFER_SIZE, "dynamic" ), + m_DynamicVertexBuffer( SHADER_BUFFER_TYPE_DYNAMIC, VERTEX_FORMAT_UNKNOWN, DYNAMIC_VERTEX_BUFFER_MEMORY, "dynamic" ) +{ + m_bUseFatVertices = false; + m_nIndexBufferOffset = 0; + memset( m_pVertexBufferOffset, 0, sizeof(m_pVertexBufferOffset) ); + memset( m_pCurrentVertexStride, 0, sizeof(m_pCurrentVertexStride) ); + memset( m_pFirstVertex, 0, sizeof(m_pFirstVertex) ); + memset( m_pVertexCount, 0, sizeof(m_pVertexCount) ); + m_nUnusedVertexFields = 0; + m_nUnusedTextureCoords = 0; + m_pZeroVertexBuffer = NULL; +} + +CMeshMgr::~CMeshMgr() +{ +} + + +//----------------------------------------------------------------------------- +// Initialize, shutdown +//----------------------------------------------------------------------------- +void CMeshMgr::Init() +{ + m_DynamicMesh.Init( 0 ); + m_DynamicFlexMesh.Init( 1 ); + + CreateDynamicIndexBuffer(); + + // If we're running in vs3.0, allocate a vertexID buffer + CreateVertexIDBuffer(); + + CreateZeroVertexBuffer(); + + m_BufferedMode = !IsX360(); +} + +void CMeshMgr::Shutdown() +{ + CleanUp(); +} + + +//----------------------------------------------------------------------------- +// Task switch... +//----------------------------------------------------------------------------- +void CMeshMgr::ReleaseBuffers() +{ + if ( IsPC() && mat_debugalttab.GetBool() ) + { + Warning( "mat_debugalttab: CMeshMgr::ReleaseBuffers\n" ); + } + + CleanUp(); + m_DynamicMesh.Reset( ); + m_DynamicFlexMesh.Reset( ); +} + +void CMeshMgr::RestoreBuffers() +{ + if ( IsPC() && mat_debugalttab.GetBool() ) + { + Warning( "mat_debugalttab: CMeshMgr::RestoreBuffers\n" ); + } + Init(); +} + + +//----------------------------------------------------------------------------- +// Cleans up vertex and index buffers +//----------------------------------------------------------------------------- +void CMeshMgr::CleanUp() +{ + DestroyDynamicIndexBuffer(); + + DestroyVertexBuffers(); + + // If we're running in vs3.0, allocate a vertexID buffer + DestroyVertexIDBuffer(); + DestroyZeroVertexBuffer(); +} + +//----------------------------------------------------------------------------- +// Fills a vertexID buffer +//----------------------------------------------------------------------------- +void CMeshMgr::FillVertexIDBuffer( CVertexBuffer *pVertexIDBuffer, int nCount ) +{ + if ( IsX360() ) + return; + + // Fill the buffer with the values 0->(nCount-1) + int nBaseVertexIndex = 0; + float *pBuffer = (float*)pVertexIDBuffer->Lock( nCount, nBaseVertexIndex ); + for ( int i = 0; i < nCount; ++i ) + { + *pBuffer++ = (float)i; + } + pVertexIDBuffer->Unlock( nCount ); +} + +//----------------------------------------------------------------------------- +// Creates, destroys the dynamic index buffer +//----------------------------------------------------------------------------- +void CMeshMgr::CreateDynamicIndexBuffer() +{ + DestroyDynamicIndexBuffer(); + SafeAssign( &m_pDynamicIndexBuffer, new CIndexBuffer( Dx9Device(), INDEX_BUFFER_SIZE, ShaderAPI()->UsingSoftwareVertexProcessing(), true ) ); +} + +void CMeshMgr::DestroyDynamicIndexBuffer() +{ + SafeRelease( &m_pDynamicIndexBuffer ); +} + +//----------------------------------------------------------------------------- +// Creates, destroys the vertexID buffer +//----------------------------------------------------------------------------- +void CMeshMgr::CreateVertexIDBuffer() +{ + if ( IsX360() ) + return; + + DestroyVertexIDBuffer(); + + // Track mesh allocations + g_VBAllocTracker->TrackMeshAllocations( "CreateVertexIDBuffer" ); + if ( g_pHardwareConfig->HasFastVertexTextures() ) + { + m_pVertexIDBuffer = new CVertexBuffer( Dx9Device(), 0, 0, sizeof(float), + VERTEX_BUFFER_SIZE, TEXTURE_GROUP_STATIC_VERTEX_BUFFER_OTHER, ShaderAPI()->UsingSoftwareVertexProcessing() ); + FillVertexIDBuffer( m_pVertexIDBuffer, VERTEX_BUFFER_SIZE ); + } + g_VBAllocTracker->TrackMeshAllocations( NULL ); +} + +void CMeshMgr::CreateZeroVertexBuffer() +{ + if ( !m_pZeroVertexBuffer ) + { + // In GL glVertexAttribPointer() doesn't support strides of 0, so we need to allocate a dummy vertex buffer large enough to handle 16-bit indices with a stride of 4 byte per vertex, plus a bit more for safety (in case basevertexindex is > 0). + // We could also try just disabling any vertex attribs that fetch from stream 2 and need 0's, but AMD reports this could hit a slow path in the driver. Argh. + uint nBufSize = IsOpenGL() ? ( 65536 * 2 * 4 ) : 4096; + HRESULT hr = Dx9Device()->CreateVertexBuffer( nBufSize, D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_pZeroVertexBuffer, NULL ); + if ( !FAILED( hr ) ) + { + void *pData = NULL; + m_pZeroVertexBuffer->Lock( 0, nBufSize, &pData, D3DLOCK_NOSYSLOCK ); + if ( pData ) + { + V_memset( pData, 0, nBufSize ); + m_pZeroVertexBuffer->Unlock(); + } + } + } +} + +void CMeshMgr::DestroyZeroVertexBuffer() +{ + if ( m_pZeroVertexBuffer ) + { + m_pZeroVertexBuffer->Release(); + m_pZeroVertexBuffer = NULL; + } +} + +void CMeshMgr::DestroyVertexIDBuffer() +{ + if ( m_pVertexIDBuffer ) + { + delete m_pVertexIDBuffer; + m_pVertexIDBuffer = NULL; + } +} + +CVertexBuffer *CMeshMgr::GetVertexIDBuffer( ) +{ + return m_pVertexIDBuffer; +} + + +//----------------------------------------------------------------------------- +// Unused vertex fields +//----------------------------------------------------------------------------- +void CMeshMgr::MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords ) +{ + m_nUnusedVertexFields = nFlags; + m_nUnusedTextureCoords = 0; + for ( int i = 0; i < nTexCoordCount; ++i ) + { + if ( pUnusedTexCoords[i] ) + { + m_nUnusedTextureCoords |= ( 1 << i ); + } + } +} + + +//----------------------------------------------------------------------------- +// Is the mesh dynamic? +//----------------------------------------------------------------------------- +bool CMeshMgr::IsDynamicMesh( IMesh* pMesh ) const +{ + return ( pMesh == &m_DynamicMesh ) || ( pMesh == &m_DynamicFlexMesh ); +} + +bool CMeshMgr::IsBufferedDynamicMesh( IMesh* pMesh ) const +{ + return ( pMesh == &m_BufferedMesh ); +} + +bool CMeshMgr::IsDynamicVertexBuffer( IVertexBuffer *pVertexBuffer ) const +{ + return ( pVertexBuffer == &m_DynamicVertexBuffer ); +} + +bool CMeshMgr::IsDynamicIndexBuffer( IIndexBuffer *pIndexBuffer ) const +{ + return ( pIndexBuffer == &m_DynamicIndexBuffer ); +} + +//----------------------------------------------------------------------------- +// Discards the dynamic vertex and index buffer +//----------------------------------------------------------------------------- +void CMeshMgr::DiscardVertexBuffers() +{ + VPROF_BUDGET( "CMeshMgr::DiscardVertexBuffers", VPROF_BUDGETGROUP_SWAP_BUFFERS ); + // This shouldn't be necessary, but it seems to be on GeForce 2 + // It helps when running WC and the engine simultaneously. + ResetMeshRenderState(); + + if ( !g_pShaderDeviceDx8->IsDeactivated() ) + { + for (int i = m_DynamicVertexBuffers.Count(); --i >= 0; ) + { + m_DynamicVertexBuffers[i].m_pBuffer->FlushAtFrameStart(); + } + m_pDynamicIndexBuffer->FlushAtFrameStart(); + } +} + + +//----------------------------------------------------------------------------- +// Releases all dynamic vertex buffers +//----------------------------------------------------------------------------- +void CMeshMgr::DestroyVertexBuffers() +{ + // Necessary for cleanup + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); + RECORD_INT( 0 ); + RECORD_INT( 0 ); + RECORD_INT( 0 ); + D3DSetStreamSource( 0, 0, 0, 0 ); + + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); + RECORD_INT( 1 ); + RECORD_INT( 0 ); + RECORD_INT( 0 ); + D3DSetStreamSource( 1, 0, 0, 0 ); + + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); + RECORD_INT( 2 ); + RECORD_INT( 0 ); + RECORD_INT( 0 ); + D3DSetStreamSource( 2, 0, 0, 0 ); + +#ifndef _X360 + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); + RECORD_INT( 3 ); + RECORD_INT( 0 ); + RECORD_INT( 0 ); + D3DSetStreamSource( 3, 0, 0, 0 ); +#endif + + for (int i = m_DynamicVertexBuffers.Count(); --i >= 0; ) + { + if (m_DynamicVertexBuffers[i].m_pBuffer) + { + delete m_DynamicVertexBuffers[i].m_pBuffer; + } + } + m_DynamicVertexBuffers.RemoveAll(); + m_DynamicMesh.Reset(); + m_DynamicFlexMesh.Reset(); +} + + +//----------------------------------------------------------------------------- +// Flushes the dynamic mesh +//----------------------------------------------------------------------------- +void CMeshMgr::Flush() +{ + if ( IsPC() ) + { + m_BufferedMesh.HandleLateCreation(); + m_BufferedMesh.Flush(); + } +} + + +//----------------------------------------------------------------------------- +// Creates, destroys static meshes +//----------------------------------------------------------------------------- +IMesh* CMeshMgr::CreateStaticMesh( VertexFormat_t format, const char *pTextureBudgetGroup, IMaterial * pMaterial ) +{ + // FIXME: Use a fixed-size allocator + CMeshDX8* pNewMesh = new CMeshDX8( pTextureBudgetGroup ); + pNewMesh->SetVertexFormat( format ); + if ( pMaterial != NULL ) + { + pNewMesh->SetMorphFormat( pMaterial->GetMorphFormat() ); + pNewMesh->SetMaterial( pMaterial ); + } + return pNewMesh; +} + +void CMeshMgr::DestroyStaticMesh( IMesh* pMesh ) +{ + // Don't destroy the dynamic mesh! + Assert( !IsDynamicMesh( pMesh ) ); + CBaseMeshDX8* pMeshImp = static_cast<CBaseMeshDX8*>(pMesh); + if (pMeshImp) + { + delete pMeshImp; + } +} + +//----------------------------------------------------------------------------- +// Gets at the *real* dynamic mesh +//----------------------------------------------------------------------------- +IMesh* CMeshMgr::GetActualDynamicMesh( VertexFormat_t format ) +{ + m_DynamicMesh.SetVertexFormat( format ); + return &m_DynamicMesh; +} + +//----------------------------------------------------------------------------- +// Copy a static mesh index buffer to a dynamic mesh index buffer +//----------------------------------------------------------------------------- +void CMeshMgr::CopyStaticMeshIndexBufferToTempMeshIndexBuffer( CTempMeshDX8 *pDstIndexMesh, + CMeshDX8 *pSrcIndexMesh ) +{ + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ ); + + Assert( !pSrcIndexMesh->IsDynamic() ); + int nIndexCount = pSrcIndexMesh->IndexCount(); + + CMeshBuilder dstMeshBuilder; + dstMeshBuilder.Begin( pDstIndexMesh, pSrcIndexMesh->GetPrimitiveType(), 0, nIndexCount ); + CIndexBuffer *srcIndexBuffer = pSrcIndexMesh->GetIndexBuffer(); + int dummy = 0; + unsigned short *srcIndexArray = srcIndexBuffer->Lock( false, nIndexCount, dummy, 0 ); + int i; + for( i = 0; i < nIndexCount; i++ ) + { + dstMeshBuilder.Index( srcIndexArray[i] ); + dstMeshBuilder.AdvanceIndex(); + } + srcIndexBuffer->Unlock( 0 ); + dstMeshBuilder.End(); +} + + +IMesh *CMeshMgr::GetFlexMesh() +{ + if ( g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_b() ) + { + // FIXME: Kinda ugly size.. 28 bytes + m_DynamicFlexMesh.SetVertexFormat( VERTEX_POSITION | VERTEX_NORMAL | VERTEX_WRINKLE | VERTEX_FORMAT_USE_EXACT_FORMAT ); + } + else + { + // Same size as a pair of float3s (24 bytes) + m_DynamicFlexMesh.SetVertexFormat( VERTEX_POSITION | VERTEX_NORMAL | VERTEX_FORMAT_USE_EXACT_FORMAT ); + } + return &m_DynamicFlexMesh; +} + +//----------------------------------------------------------------------------- +// Gets at the dynamic mesh +//----------------------------------------------------------------------------- +IMesh* CMeshMgr::GetDynamicMesh( IMaterial* pMaterial, VertexFormat_t vertexFormat, int nHWSkinBoneCount, + bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ) +{ + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ ); + + Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() ); + + if ( IsX360() ) + { + buffered = false; + } + + // Can't be buffered if we're overriding the buffers + if ( pVertexOverride || pIndexOverride ) + { + buffered = false; + } + + // When going from buffered to unbuffered mode, need to flush.. + if ((m_BufferedMode != buffered) && m_BufferedMode) + { + m_BufferedMesh.SetMesh(0); + } + m_BufferedMode = buffered; + + IMaterialInternal* pMatInternal = static_cast<IMaterialInternal*>(pMaterial); + + bool needTempMesh = ShaderAPI()->IsInSelectionMode(); + +#ifdef DRAW_SELECTION + if( g_bDrawSelection ) + { + needTempMesh = true; + } +#endif + + CBaseMeshDX8* pMesh; + + if ( needTempMesh ) + { + // These haven't been implemented yet for temp meshes! + // I'm not a hundred percent sure how to implement them; it would + // involve a lock and a copy at least, which would stall the entire + // rendering pipeline. + Assert( !pVertexOverride ); + + if( pIndexOverride ) + { + CopyStaticMeshIndexBufferToTempMeshIndexBuffer( &m_DynamicTempMesh, + ( CMeshDX8 * )pIndexOverride ); + } + pMesh = &m_DynamicTempMesh; + } + else + { + pMesh = &m_DynamicMesh; + } + + if ( m_BufferedMode ) + { + Assert( !m_BufferedMesh.WasNotRendered() ); + m_BufferedMesh.SetMesh( pMesh ); + pMesh = &m_BufferedMesh; + } + + if( !pVertexOverride ) + { + // Remove VERTEX_FORMAT_COMPRESSED from the material's format (dynamic meshes don't + // support compression, and all materials should support uncompressed verts too) + VertexFormat_t materialFormat = pMatInternal->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED; + VertexFormat_t fmt = ( vertexFormat != 0 ) ? vertexFormat : materialFormat; + if ( vertexFormat != 0 ) + { + int nVertexFormatBoneWeights = NumBoneWeights( vertexFormat ); + if ( nHWSkinBoneCount < nVertexFormatBoneWeights ) + { + nHWSkinBoneCount = nVertexFormatBoneWeights; + } + } + + // Force the requested number of bone weights + fmt &= ~VERTEX_BONE_WEIGHT_MASK; + if ( nHWSkinBoneCount > 0 ) + { + fmt |= VERTEX_BONEWEIGHT( 2 ); + fmt |= VERTEX_BONE_INDEX; + } + + pMesh->SetVertexFormat( fmt ); + } + else + { + CBaseMeshDX8 *pDX8Mesh = static_cast<CBaseMeshDX8*>(pVertexOverride); + pMesh->SetVertexFormat( pDX8Mesh->GetVertexFormat() ); + } + pMesh->SetMorphFormat( pMatInternal->GetMorphFormat() ); + pMesh->SetMaterial( pMatInternal ); + + // Note this works because we're guaranteed to not be using a buffered mesh + // when we have overrides on + // FIXME: Make work for temp meshes + if ( pMesh == &m_DynamicMesh ) + { + CBaseMeshDX8* pBaseVertex = static_cast<CBaseMeshDX8*>( pVertexOverride ); + if ( pBaseVertex ) + { + m_DynamicMesh.OverrideVertexBuffer( pBaseVertex->GetVertexBuffer() ); + } + + CBaseMeshDX8* pBaseIndex = static_cast<CBaseMeshDX8*>( pIndexOverride ); + if ( pBaseIndex ) + { + m_DynamicMesh.OverrideIndexBuffer( pBaseIndex->GetIndexBuffer() ); + } + } + + return pMesh; +} + + +//----------------------------------------------------------------------------- +// Used to construct vertex data +//----------------------------------------------------------------------------- +void CMeshMgr::ComputeVertexDescription( unsigned char* pBuffer, + VertexFormat_t vertexFormat, MeshDesc_t& desc ) const +{ + ComputeVertexDesc( pBuffer, vertexFormat, (VertexDesc_t &)desc ); +} + + +//----------------------------------------------------------------------------- +// Computes the vertex format +//----------------------------------------------------------------------------- +VertexFormat_t CMeshMgr::ComputeVertexFormat( unsigned int flags, + int nTexCoordArraySize, int* pTexCoordDimensions, int numBoneWeights, + int userDataSize ) const +{ + // Construct a bitfield that makes sense and is unique from the standard FVF formats + VertexFormat_t fmt = flags & ~VERTEX_FORMAT_USE_EXACT_FORMAT; + + if ( g_pHardwareConfig->SupportsCompressedVertices() == VERTEX_COMPRESSION_NONE ) + { + // Vertex compression is disabled - make sure all materials + // say "No!" to compressed verts ( tested in IsValidVertexFormat() ) + fmt &= ~VERTEX_FORMAT_COMPRESSED; + } + + // This'll take 3 bits at most + Assert( numBoneWeights <= 4 ); + + if ( numBoneWeights > 0 ) + { + fmt |= VERTEX_BONEWEIGHT( 2 ); // Always exactly two weights + } + + // Size is measured in # of floats + Assert( userDataSize <= 4 ); + fmt |= VERTEX_USERDATA_SIZE(userDataSize); + + // NOTE: If pTexCoordDimensions isn't specified, then nTexCoordArraySize + // is interpreted as meaning that we have n 2D texcoords in the first N texcoord slots + nTexCoordArraySize = min( nTexCoordArraySize, (int)VERTEX_MAX_TEXTURE_COORDINATES ); + for ( int i = 0; i < nTexCoordArraySize; ++i ) + { + if ( pTexCoordDimensions ) + { + Assert( pTexCoordDimensions[i] >= 0 && pTexCoordDimensions[i] <= 4 ); + fmt |= VERTEX_TEXCOORD_SIZE( (TextureStage_t)i, pTexCoordDimensions[i] ); + } + else + { + fmt |= VERTEX_TEXCOORD_SIZE( (TextureStage_t)i, 2 ); + } + } + + return fmt; +} + + +//----------------------------------------------------------------------------- +// Use fat vertices (for tools) +//----------------------------------------------------------------------------- +void CMeshMgr::UseFatVertices( bool bUseFat ) +{ + m_bUseFatVertices = bUseFat; +} + + +//----------------------------------------------------------------------------- +// Returns the number of vertices we can render using the dynamic mesh +//----------------------------------------------------------------------------- +void CMeshMgr::GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices ) +{ + CBaseMeshDX8 *pBaseMesh = static_cast<CBaseMeshDX8*>( pMesh ); + if ( !pBaseMesh ) + { + *pMaxVerts = 0; + *pMaxIndices = m_pDynamicIndexBuffer->IndexCount(); + return; + } + + if ( IsBufferedDynamicMesh( pMesh ) ) + { + pBaseMesh = (CBaseMeshDX8*)static_cast<CBufferedMeshDX8*>( pBaseMesh )->GetMesh(); + pMesh = pBaseMesh; + } + + // Static mesh? Max you can use is 65535 + if ( !IsDynamicMesh( pMesh ) ) + { + *pMaxVerts = 65535; + *pMaxIndices = 65535; + return; + } + + CVertexBuffer *pVertexBuffer = pBaseMesh->GetVertexBuffer(); + CIndexBuffer *pIndexBuffer = pBaseMesh->GetIndexBuffer(); + + if ( !pVertexBuffer ) + { + *pMaxVerts = 0; + *pMaxIndices = 0; + return; + } + + if ( !bMaxUntilFlush ) + { + *pMaxVerts = ShaderAPI()->GetCurrentDynamicVBSize() / pVertexBuffer->VertexSize(); + if ( *pMaxVerts > 65535 ) + { + *pMaxVerts = 65535; + } + *pMaxIndices = pIndexBuffer ? pIndexBuffer->IndexCount() : 0; + return; + } + + *pMaxVerts = pVertexBuffer->NumVerticesUntilFlush(); + *pMaxIndices = pIndexBuffer ? pIndexBuffer->IndexCount() - pIndexBuffer->IndexPosition() : 0; + if ( *pMaxVerts == 0 ) + { + *pMaxVerts = ShaderAPI()->GetCurrentDynamicVBSize() / pVertexBuffer->VertexSize(); + } + if ( *pMaxVerts > 65535 ) + { + *pMaxVerts = 65535; + } + if ( *pMaxIndices == 0 ) + { + *pMaxIndices = pIndexBuffer ? pIndexBuffer->IndexCount() : 0; + } +} + +int CMeshMgr::GetMaxVerticesToRender( IMaterial *pMaterial ) +{ + Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() ); + + // Be conservative, assume no compression (in here, we don't know if the caller will used a compressed VB or not) + // FIXME: allow the caller to specify which compression type should be used to compute size from the vertex format + // (this can vary between multiple VBs/Meshes using the same material) + VertexFormat_t fmt = pMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED; + int nVertexSize = VertexFormatSize( fmt ); + if ( nVertexSize == 0 ) + { + // unable to determine vertex format information, possibly due to device loss. + Warning( "bad vertex size for material %s\n", pMaterial->GetName() ); + return 0; + } + + int nMaxVerts = ShaderAPI()->GetCurrentDynamicVBSize() / nVertexSize; + return MIN( nMaxVerts, 65535 ); +} + +int CMeshMgr::GetMaxIndicesToRender( ) +{ + return INDEX_BUFFER_SIZE; +} + +//----------------------------------------------------------------------------- +// Returns a vertex buffer appropriate for the flags +//----------------------------------------------------------------------------- +CVertexBuffer *CMeshMgr::FindOrCreateVertexBuffer( int nDynamicBufferId, VertexFormat_t vertexFormat ) +{ + int vertexSize = VertexFormatSize( vertexFormat ); + + while ( m_DynamicVertexBuffers.Count() <= nDynamicBufferId ) + { + // Track VB allocations (override any prior allocator string set higher up on the callstack) + g_VBAllocTracker->TrackMeshAllocations( NULL ); + g_VBAllocTracker->TrackMeshAllocations( "CMeshMgr::FindOrCreateVertexBuffer (dynamic VB)" ); + + // create the single 1MB dynamic vb that will be shared amongst all consumers + // the correct thing is to use the largest expected vertex format size of max elements, but this + // creates an undesirably large buffer - instead create the buffer we want, and fix consumers that bork + // NOTE: GetCurrentDynamicVBSize returns a smaller value during level transitions + int nBufferMemory = ShaderAPI()->GetCurrentDynamicVBSize(); + int nIndex = m_DynamicVertexBuffers.AddToTail(); + m_DynamicVertexBuffers[nIndex].m_VertexSize = 0; + m_DynamicVertexBuffers[nIndex].m_pBuffer = new CVertexBuffer( Dx9Device(), 0, 0, + nBufferMemory / VERTEX_BUFFER_SIZE, VERTEX_BUFFER_SIZE, TEXTURE_GROUP_STATIC_VERTEX_BUFFER_OTHER, ShaderAPI()->UsingSoftwareVertexProcessing(), true ); + + g_VBAllocTracker->TrackMeshAllocations( NULL ); + } + + if ( m_DynamicVertexBuffers[nDynamicBufferId].m_VertexSize != vertexSize ) + { + // provide caller with dynamic vb in expected format + // NOTE: GetCurrentDynamicVBSize returns a smaller value during level transitions + int nBufferMemory = ShaderAPI()->GetCurrentDynamicVBSize(); + m_DynamicVertexBuffers[nDynamicBufferId].m_VertexSize = vertexSize; + m_DynamicVertexBuffers[nDynamicBufferId].m_pBuffer->ChangeConfiguration( vertexSize, nBufferMemory ); + + // size changed means stream stride needs update + // mark cached stream state as invalid to reset stream + if ( nDynamicBufferId == 0 ) + { + g_pLastVertex = NULL; + } + } + + return m_DynamicVertexBuffers[nDynamicBufferId].m_pBuffer; +} + +CIndexBuffer *CMeshMgr::GetDynamicIndexBuffer() +{ + return m_pDynamicIndexBuffer; +} + +IVertexBuffer *CMeshMgr::GetDynamicVertexBuffer( IMaterial *pMaterial, bool buffered ) +{ + Assert( 0 ); + return NULL; +// return ( IMeshDX8 * )GetDynamicMesh( pMaterial, buffered, NULL, NULL ); +} + +IIndexBuffer *CMeshMgr::GetDynamicIndexBuffer( IMaterial *pMaterial, bool buffered ) +{ + Assert( 0 ); + return NULL; +// return ( IMeshDX8 * )GetDynamicMesh( pMaterial, buffered, NULL, NULL ); +} + + +//----------------------------------------------------------------------------- +IVertexBuffer *CMeshMgr::CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup ) +{ + // FIXME: Use a fixed-size allocator + CVertexBufferDx8 *pNewVertexBuffer = new CVertexBufferDx8( type, fmt, nVertexCount, pBudgetGroup ); + return pNewVertexBuffer; +} + +IIndexBuffer *CMeshMgr::CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup ) +{ + switch( bufferType ) + { + case SHADER_BUFFER_TYPE_STATIC: + case SHADER_BUFFER_TYPE_DYNAMIC: + { + CIndexBufferDx8 *pIndexBuffer = new CIndexBufferDx8( bufferType, fmt, nIndexCount, pBudgetGroup ); + return pIndexBuffer; + } + case SHADER_BUFFER_TYPE_STATIC_TEMP: + case SHADER_BUFFER_TYPE_DYNAMIC_TEMP: + Assert( 0 ); + return NULL; + default: + Assert( 0 ); + return NULL; + } +} + +void CMeshMgr::DestroyVertexBuffer( IVertexBuffer *pVertexBuffer ) +{ + if ( pVertexBuffer && !IsDynamicVertexBuffer( pVertexBuffer ) ) + { + delete pVertexBuffer; + } +} + +void CMeshMgr::DestroyIndexBuffer( IIndexBuffer *pIndexBuffer ) +{ + if ( pIndexBuffer && !IsDynamicIndexBuffer( pIndexBuffer ) ) + { + delete pIndexBuffer; + } +} + +// Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams? +IVertexBuffer *CMeshMgr::GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered ) +{ + if ( IsX360() ) + { + bBuffered = false; + } + + if ( CompressionType( vertexFormat ) != VERTEX_COMPRESSION_NONE ) + { + // UNDONE: support compressed dynamic meshes if needed (pro: less VB memory, con: time spent compressing) + DebuggerBreak(); + return NULL; + } + + // MESHFIXME +#if 0 + if ( ( m_BufferedMode != bBuffered ) && m_BufferedMode ) + { + m_BufferedIndexBuffer.SetIndexBuffer( NULL ); + } +#endif + + m_BufferedMode = bBuffered; + Assert( !m_BufferedMode ); // MESHFIXME: don't deal with buffered VBs yet. + + bool needTempMesh = ShaderAPI()->IsInSelectionMode(); + +#ifdef DRAW_SELECTION + if( g_bDrawSelection ) + { + needTempMesh = true; + } +#endif + + Assert( !needTempMesh ); // MESHFIXME: don't support temp meshes here yet. + + CVertexBufferDx8 *pVertexBuffer; + + if ( needTempMesh ) + { + Assert( 0 ); // MESHFIXME: don't do this yet. +// pVertexBuffer = &m_DynamicTempVertexBuffer; + pVertexBuffer = NULL; + } + else + { + pVertexBuffer = &m_DynamicVertexBuffer; + } + + if ( m_BufferedMode ) + { + Assert( 0 ); // don't support this yet. +#if 0 + Assert( !m_BufferedMesh.WasNotRendered() ); + m_BufferedMesh.SetMesh( pMesh ); + pMesh = &m_BufferedMesh; +#endif + } + + return pVertexBuffer; +} + +IIndexBuffer *CMeshMgr::GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered ) +{ + if ( IsX360() ) + { + bBuffered = false; + } + + m_BufferedMode = bBuffered; + + Assert( !m_BufferedMode ); + +#ifdef DBGFLAG_ASSERT + bool needTempMesh = +#endif + ShaderAPI()->IsInSelectionMode(); + +#ifdef DRAW_SELECTION + if( g_bDrawSelection ) + { + needTempMesh = true; + } +#endif + + Assert( !needTempMesh ); // don't handle this yet. MESHFIXME + + CIndexBufferBase *pIndexBuffer = &m_DynamicIndexBuffer; + return pIndexBuffer; +} + +void CMeshMgr::SetVertexIDStreamState() +{ + if ( IsX360() ) + return; + + // MESHFIXME : This path is only used for the new index/vertex buffer interfaces. + // MESHFIXME : This path is only used for the new index/vertex buffer interfaces. + bool bUsingVertexID = false;//IsUsingVertexID(); +// if ( bUsingVertexID != g_bUsingVertexID ) + { + if ( bUsingVertexID ) + { + // NOTE: Morphing doesn't work with dynamic buffers!!! BLEAH + // It's because the indices (which are not 0 based for dynamic buffers) + // are accessing both the vertexID buffer + the regular vertex buffer. + // This *might* be fixable with baseVertexIndex? + Assert( !m_pCurrentVertexBuffer->IsDynamic() ); + + CVertexBuffer *pVertexIDBuffer = g_MeshMgr.GetVertexIDBuffer( ); + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( pVertexIDBuffer->UID() ); + RECORD_INT( 3 ); + RECORD_INT( 0 ); + RECORD_INT( pVertexIDBuffer->VertexSize() ); + + D3DSetStreamSource( 3, pVertexIDBuffer->GetInterface(), 0, pVertexIDBuffer->VertexSize() ); + pVertexIDBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + } + else + { + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); // vertex buffer id + RECORD_INT( 3 ); // stream + RECORD_INT( 0 ); // vertex offset + RECORD_INT( 0 ); // vertex size + + D3DSetStreamSource( 3, 0, 0, 0 ); + } + g_bUsingVertexID = bUsingVertexID; + } +} + +void CMeshMgr::SetColorStreamState() +{ + if ( g_pLastColorMesh ) + { + RECORD_COMMAND( DX8_SET_STREAM_SOURCE, 4 ); + RECORD_INT( -1 ); // vertex buffer id + RECORD_INT( 1 ); // stream + RECORD_INT( 0 ); // vertex offset + RECORD_INT( 0 ); // vertex size + + D3DSetStreamSource( 1, 0, 0, 0 ); + } + g_pLastColorMesh = NULL; + g_nLastColorMeshVertOffsetInBytes = 0; +} + +void CMeshMgr::SetVertexStreamState( int nVertOffsetInBytes, int nVertexStride ) +{ + // Calls in here assume shader support... + if ( HardwareConfig()->SupportsVertexAndPixelShaders() ) + { + // Set a 4kb all-zero static VB into the flex/wrinkle stream with a stride of 0 bytes, so the vertex shader always reads valid floating point values (otherwise it can get NaN's/Inf's, and under OpenGL this is bad on NVidia) + // togl requires non-zero strides, but on D3D9 we can set a stride of 0 for a little more efficiency. + D3DSetStreamSource( 2, g_MeshMgr.GetZeroVertexBuffer(), 0, IsOpenGL() ? 4 : 0 ); + + // cFlexScale.x masks flex in vertex shader + if ( g_pHardwareConfig->Caps().m_SupportsVertexShaders_2_0 ) + { + float c[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; + ShaderAPI()->SetVertexShaderConstant( VERTEX_SHADER_FLEXSCALE, c, 1 ); + } + + g_bFlexMeshStreamSet = false; + } + + // MESHFIXME : This path is only used for the new index/vertex buffer interfaces. + if ( g_pLastVertex || ( g_pLastVertexBuffer != m_pCurrentVertexBuffer->GetDx9Buffer() ) || + ( g_nLastVertOffsetInBytes != nVertOffsetInBytes ) || ( g_nLastVertStride != nVertexStride )) + { + Assert( m_pCurrentVertexBuffer && m_pCurrentVertexBuffer->GetDx9Buffer() ); + + D3DSetStreamSource( 0, m_pCurrentVertexBuffer->GetDx9Buffer(), nVertOffsetInBytes, nVertexStride ); + m_pCurrentVertexBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + + g_pLastVertex = NULL; + g_nLastVertStride = nVertexStride; + g_pLastVertexBuffer = m_pCurrentVertexBuffer->GetDx9Buffer(); + g_nLastVertOffsetInBytes = nVertOffsetInBytes; + } +} + +bool CMeshMgr::SetRenderState( int nVertexOffsetInBytes, int nFirstVertexIdx, VertexFormat_t vertexFormat, int nVertexStride ) +{ + // Can't set the state if we're deactivated + if ( g_pShaderDeviceDx8->IsDeactivated() ) + { + ResetMeshRenderState(); + return false; + } + + // make sure the vertex format is a superset of the current material's + // vertex format... + // MESHFIXME : This path is only used for the new index/vertex buffer interfaces. +#if 0 + // FIXME + if ( !IsValidVertexFormat( vertexFormat ) ) + { + Warning( "Material %s is being applied to a model, you need $model=1 in the .vmt file!\n", + ShaderAPI()->GetBoundMaterial()->GetName() ); + return false; + } +#endif + + SetVertexIDStreamState(); + SetColorStreamState(); + SetVertexStreamState( nVertexOffsetInBytes, nVertexStride ); + SetIndexStreamState( nFirstVertexIdx ); + + return true; +} + +void CMeshMgr::BindVertexBuffer( int nStreamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions ) +{ + // FIXME: Multiple stream support isn't implemented yet + Assert( nStreamID == 0 ); + + m_pCurrentVertexBuffer = static_cast< CVertexBufferDx8 * >( pVertexBuffer ); + m_CurrentVertexFormat = fmt; + m_pVertexBufferOffset[nStreamID] = nOffsetInBytes; + m_pCurrentVertexStride[nStreamID] = m_pCurrentVertexBuffer->VertexSize(); + m_pFirstVertex[nStreamID] = nFirstVertex; + m_pVertexCount[nStreamID] = nVertexCount, + m_pVertexIDBuffer = NULL; +} + +void CMeshMgr::BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes ) +{ + m_pCurrentIndexBuffer = static_cast< CIndexBufferBase * >( pIndexBuffer ); + m_nIndexBufferOffset = nOffsetInBytes; +} + +void CMeshMgr::Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount ) +{ + // MESHFIXME : This path is only used for the new index/vertex buffer interfaces. + // make sure we aren't using a morph stream for this path. +// Assert( !IsUsingMorphData() ); +// Assert( !m_pColorMesh ); + + SetRenderState( m_pVertexBufferOffset[0], /* nFirstVertexIdx */0, m_CurrentVertexFormat, m_pCurrentVertexStride[0] ); + + m_PrimitiveType = MATERIAL_TRIANGLES; + Assert( primitiveType == MATERIAL_TRIANGLES ); + + m_nFirstIndex = nFirstIndex; + m_nNumIndices = nIndexCount; + + ShaderAPI()->DrawWithVertexAndIndexBuffers(); +} + +void CMeshMgr::RenderPassWithVertexAndIndexBuffers( void ) +{ +// LOCK_SHADERAPI(); MESHFIXME + VPROF( "CShaderAPIDX8::RenderPassWithVertexAndIndexBuffers" ); + + Assert( m_PrimitiveType != MATERIAL_HETEROGENOUS ); + +// for ( int iPrim=0; iPrim < s_nPrims; iPrim++ ) + { +// CPrimList *pPrim = &s_pPrims[iPrim]; + +// if ( pPrim->m_NumIndices == 0 ) +// continue; + + if ( m_PrimitiveType == MATERIAL_POINTS ) + { + // (For point lists, we don't actually fill in indices, but we treat it as + // though there are indices for the list up until here). + Assert( 0 ); +// Dx9Device()->DrawPrimitive( ComputeMode( m_PrimitiveType ), s_FirstVertex, pPrim->m_NumIndices ); + } + else + { +// int numPrimitives = NumPrimitives( s_NumVertices, pPrim->m_NumIndices ); + +// Warning( "CMeshMgr::RenderPassWithVertexAndIndexBuffers: DrawIndexedPrimitive: m_nFirstIndex = %d numPrimitives = %d\n", ( int )( ( CDynamiCIndexBufferDx8 * )m_pCurrentIndexBuffer )->m_FirstIndex, ( int )( m_nNumIndices / 3 ) ); + { + VPROF( "Dx9Device()->DrawIndexedPrimitive" ); +// VPROF_INCREMENT_COUNTER( "DrawIndexedPrimitive", 1 ); +// VPROF_INCREMENT_COUNTER( "numPrimitives", numPrimitives ); + +// Dx9Device()->DrawIndexedPrimitive( +// m_Mode, +// m_FirstIndex, +// s_FirstVertex, +// s_NumVertices, +// pPrim->m_FirstIndex, +// numPrimitives ); + + Assert( m_nFirstIndex >= 0 ); + +#ifdef CHECK_INDICES + // g_pLastVertex - this is the current vertex buffer + // g_pLastColorMesh - this is the curent color mesh, if there is one. + // g_pLastIndex - this is the current index buffer. + // vertoffset : m_FirstIndex + CIndexBufferDx8 *pIndexBuffer = assert_cast< CIndexBufferDx8 * >( m_pCurrentIndexBuffer ); + if( m_PrimitiveType == MATERIAL_TRIANGLES || m_PrimitiveType == MATERIAL_TRIANGLE_STRIP ) + { + // FIXME: need to be able to deal with multiple stream here, but don't bother for now. + int j; + int numVerts = m_pVertexCount[0]; + for( j = 0; j < m_nNumIndices; j++ ) + { + int index = pIndexBuffer->GetShadowIndex( j + m_nFirstIndex ); + Assert( index >= m_pFirstVertex[0] ); + Assert( index < m_pFirstVertex[0] + numVerts ); + } + } +#endif // CHECK_INDICES + Dx9Device()->DrawIndexedPrimitive( + ComputeMode( m_PrimitiveType ), // Member of the D3DPRIMITIVETYPE enumerated type, describing the type of primitive to render. D3DPT_POINTLIST is not supported with this method. + + /*m_FirstIndex*/ 0, // Offset from the start of the vertex buffer to the first vertex index. An index of 0 in the index buffer refers to this location in the vertex buffer. + + /*s_FirstVertex*/ m_pFirstVertex[0],// Minimum vertex index for vertices used during this call. This is a zero based index relative to BaseVertexIndex. + // This is zero for now since we don't do more than one batch yet with the new mesh interface. + + /*s_NumVertices*/ m_pVertexCount[0], + // Number of vertices used during this call. The first vertex is located at index: BaseVertexIndex + MinIndex. + // This is simple the number of verts in the current vertex buffer for now since we don't do more than one batch with the new mesh interface. + + m_nFirstIndex /*pPrim->m_FirstIndex*/, // Index of the first index to use when accesssing the vertex buffer. Beginning at StartIndex to index vertices from the vertex buffer. + + m_nNumIndices / 3/*numPrimitives*/ // Number of primitives to render. The number of vertices used is a function of the primitive count and the primitive type. + ); + + Assert( CMeshDX8::s_FirstVertex == 0 ); + Assert( CMeshDX8::s_NumVertices == 0 ); + } + } + } +} + +//----------------------------------------------------------------------------- +void CMeshMgr::SetIndexStreamState( int firstVertexIdx ) +{ + CIndexBufferDx8 *pIndexBuffer = assert_cast< CIndexBufferDx8* >( m_pCurrentIndexBuffer ); + IDirect3DIndexBuffer9 *pDx9Buffer = pIndexBuffer ? pIndexBuffer->GetDx9Buffer() : NULL; + if ( g_pLastIndex || g_pLastIndexBuffer != pDx9Buffer ) + { + Dx9Device()->SetIndices( pDx9Buffer ); + pIndexBuffer->HandlePerFrameTextureStats( ShaderAPI()->GetCurrentFrameCounter() ); + + g_pLastIndexBuffer = pDx9Buffer; + SafeRelease( &g_pLastIndex ); + g_LastVertexIdx = -1; + } +} + + |