expvintl/source-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
source-engine/materialsystem/shaderapidx9/meshdx10.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

776 lines
22 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#include <d3d10.h>
#undef GetCommandLine
#include "meshdx10.h"
#include "utlvector.h"
#include "materialsystem/imaterialsystem.h"
#include "IHardwareConfigInternal.h"
#include "shaderapi_global.h"
#include "shaderapi/ishaderutil.h"
#include "shaderapi/ishaderapi.h"
#include "shaderdevicedx10.h"
#include "materialsystem/imesh.h"
#include "tier0/vprof.h"
#include "tier0/dbg.h"
#include "materialsystem/idebugtextureinfo.h"
#include "materialsystem/ivballoctracker.h"
#include "tier2/tier2.h"
//-----------------------------------------------------------------------------
//
// Dx10 implementation of a vertex buffer
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------
#ifdef _DEBUG
int CVertexBufferDx10::s_nBufferCount = 0;
#endif
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CVertexBufferDx10::CVertexBufferDx10( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroupName ) :
BaseClass( pBudgetGroupName )
{
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;
}
CVertexBufferDx10::~CVertexBufferDx10()
{
Free();
}
//-----------------------------------------------------------------------------
// Creates, destroys the vertex buffer
//-----------------------------------------------------------------------------
bool CVertexBufferDx10::Allocate( )
{
Assert( !m_pVertexBuffer );
m_nFirstUnwrittenOffset = 0;
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = m_nBufferSize;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
HRESULT hr = D3D10Device()->CreateBuffer( &bd, NULL, &m_pVertexBuffer );
bool bOk = !FAILED( hr ) && ( m_pVertexBuffer != 0 );
if ( bOk )
{
// Track VB allocations
g_VBAllocTracker->CountVB( m_pVertexBuffer, m_bIsDynamic, m_nBufferSize, VertexSize(), GetVertexFormat() );
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 );
// Dynamic meshes should never be compressed (slows down writing to them)
Assert( CompressionType( GetVertexFormat() ) == VERTEX_COMPRESSION_NONE );
}
#ifdef _DEBUG
++s_nBufferCount;
#endif
}
return bOk;
}
void CVertexBufferDx10::Free()
{
if ( m_pVertexBuffer )
{
#ifdef _DEBUG
--s_nBufferCount;
#endif
// Track VB allocations
g_VBAllocTracker->UnCountVB( m_pVertexBuffer );
m_pVertexBuffer->Release();
m_pVertexBuffer = 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 );
}
}
}
//-----------------------------------------------------------------------------
// Vertex Buffer info
//-----------------------------------------------------------------------------
int CVertexBufferDx10::VertexCount() const
{
Assert( !m_bIsDynamic );
return m_nVertexCount;
}
//-----------------------------------------------------------------------------
// Returns the buffer format (only valid for static index buffers)
//-----------------------------------------------------------------------------
VertexFormat_t CVertexBufferDx10::GetVertexFormat() const
{
Assert( !m_bIsDynamic );
return m_VertexFormat;
}
//-----------------------------------------------------------------------------
// Returns true if the buffer is dynamic
//-----------------------------------------------------------------------------
bool CVertexBufferDx10::IsDynamic() const
{
return m_bIsDynamic;
}
//-----------------------------------------------------------------------------
// Only used by dynamic buffers, indicates the next lock should perform a discard.
//-----------------------------------------------------------------------------
void CVertexBufferDx10::Flush()
{
// This strange-looking line makes a flush only occur if the buffer is dynamic.
m_bFlush = m_bIsDynamic;
}
//-----------------------------------------------------------------------------
// Casts a dynamic buffer to be a particular vertex type
//-----------------------------------------------------------------------------
void CVertexBufferDx10::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;
m_nVertexCount = m_nBufferSize / VertexSize();
}
void CVertexBufferDx10::EndCastBuffer( )
{
Assert( m_bIsDynamic && m_VertexFormat != 0 );
if ( !m_bIsDynamic )
return;
m_VertexFormat = 0;
m_nVertexCount = 0;
}
//-----------------------------------------------------------------------------
// Returns the number of indices that can be written into the buffer
//-----------------------------------------------------------------------------
int CVertexBufferDx10::GetRoomRemaining() const
{
return ( m_nBufferSize - m_nFirstUnwrittenOffset ) / VertexSize();
}
//-----------------------------------------------------------------------------
// Lock, unlock
//-----------------------------------------------------------------------------
bool CVertexBufferDx10::Lock( int nMaxVertexCount, bool bAppend, VertexDesc_t &desc )
{
Assert( !m_bIsLocked && ( nMaxVertexCount != 0 ) && ( nMaxVertexCount <= m_nVertexCount ) );
Assert( m_VertexFormat != 0 );
// FIXME: Why do we need to sync matrices now?
ShaderUtil()->SyncMatrices();
g_ShaderMutex.Lock();
void *pLockedData = NULL;
HRESULT hr;
// This can happen if the buffer was locked but a type wasn't bound
if ( m_VertexFormat == 0 )
goto vertexBufferLockFailed;
// Just give the app crap buffers to fill up while we're suppressed...
if ( g_pShaderDevice->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
int nMemoryRequired = nMaxVertexCount * VertexSize();
bool bHasEnoughMemory = ( m_nFirstUnwrittenOffset + nMemoryRequired <= m_nBufferSize );
D3D10_MAP map;
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;
map = ( m_nFirstUnwrittenOffset == 0 ) ? D3D10_MAP_WRITE_DISCARD : D3D10_MAP_WRITE_NO_OVERWRITE;
}
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 )
{
map = ( m_nFirstUnwrittenOffset == 0 ) ? D3D10_MAP_WRITE_DISCARD : D3D10_MAP_WRITE_NO_OVERWRITE;
}
else
{
map = D3D10_MAP_WRITE_DISCARD;
m_nFirstUnwrittenOffset = 0;
m_bFlush = false;
}
}
hr = m_pVertexBuffer->Map( map, 0, &pLockedData );
if ( FAILED( hr ) )
{
Warning( "Failed to lock vertex buffer in CVertexBufferDx10::Lock\n" );
goto vertexBufferLockFailed;
}
ComputeVertexDescription( (unsigned char*)pLockedData + m_nFirstUnwrittenOffset, m_VertexFormat, desc );
desc.m_nFirstVertex = 0;
desc.m_nOffset = m_nFirstUnwrittenOffset;
m_bIsLocked = true;
return true;
vertexBufferLockFailed:
g_ShaderMutex.Unlock();
// Set up a bogus index descriptor
ComputeVertexDescription( 0, 0, desc );
desc.m_nFirstVertex = 0;
desc.m_nOffset = 0;
return false;
}
void CVertexBufferDx10::Unlock( int nWrittenVertexCount, VertexDesc_t &desc )
{
Assert( nWrittenVertexCount <= m_nVertexCount );
// NOTE: This can happen if the lock occurs during alt-tab
// or if another application is initializing
if ( !m_bIsLocked )
return;
if ( m_pVertexBuffer )
{
m_pVertexBuffer->Unmap();
}
m_nFirstUnwrittenOffset += nWrittenVertexCount * VertexSize();
m_bIsLocked = false;
g_ShaderMutex.Unlock();
}
//-----------------------------------------------------------------------------
//
// Dx10 implementation of an index buffer
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------
// shove indices into this if you don't actually want indices
static unsigned int s_nScratchIndexBuffer = 0;
#ifdef _DEBUG
int CIndexBufferDx10::s_nBufferCount = 0;
#endif
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CIndexBufferDx10::CIndexBufferDx10( ShaderBufferType_t type, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroupName ) :
BaseClass( pBudgetGroupName )
{
Assert( nIndexCount != 0 );
Assert( IsDynamicBufferType( type ) || ( fmt != MATERIAL_INDEX_FORMAT_UNKNOWN ) );
m_pIndexBuffer = NULL;
m_IndexFormat = fmt;
m_nIndexCount = ( fmt == MATERIAL_INDEX_FORMAT_UNKNOWN ) ? 0 : nIndexCount;
m_nBufferSize = ( fmt == MATERIAL_INDEX_FORMAT_UNKNOWN ) ? nIndexCount : nIndexCount * IndexSize();
m_nFirstUnwrittenOffset = 0;
m_bIsLocked = false;
m_bIsDynamic = IsDynamicBufferType( type );
m_bFlush = false;
// NOTE: This has to happen at the end since m_IndexFormat must be valid for IndexSize() to work
if ( m_bIsDynamic )
{
m_IndexFormat = MATERIAL_INDEX_FORMAT_UNKNOWN;
m_nIndexCount = 0;
}
}
CIndexBufferDx10::~CIndexBufferDx10()
{
Free();
}
//-----------------------------------------------------------------------------
// Creates, destroys the index buffer
//-----------------------------------------------------------------------------
bool CIndexBufferDx10::Allocate( )
{
Assert( !m_pIndexBuffer );
m_nFirstUnwrittenOffset = 0;
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = m_nBufferSize;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
HRESULT hr = D3D10Device()->CreateBuffer( &bd, NULL, &m_pIndexBuffer );
bool bOk = !FAILED( hr ) && ( m_pIndexBuffer != NULL );
if ( bOk )
{
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 _DEBUG
++s_nBufferCount;
#endif
}
return bOk;
}
void CIndexBufferDx10::Free()
{
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 );
}
}
}
//-----------------------------------------------------------------------------
// Returns the buffer size (only valid for static index buffers)
//-----------------------------------------------------------------------------
int CIndexBufferDx10::IndexCount() const
{
Assert( !m_bIsDynamic );
return m_nIndexCount;
}
//-----------------------------------------------------------------------------
// Returns the buffer format (only valid for static index buffers)
//-----------------------------------------------------------------------------
MaterialIndexFormat_t CIndexBufferDx10::IndexFormat() const
{
Assert( !m_bIsDynamic );
return m_IndexFormat;
}
//-----------------------------------------------------------------------------
// Returns true if the buffer is dynamic
//-----------------------------------------------------------------------------
bool CIndexBufferDx10::IsDynamic() const
{
return m_bIsDynamic;
}
//-----------------------------------------------------------------------------
// Only used by dynamic buffers, indicates the next lock should perform a discard.
//-----------------------------------------------------------------------------
void CIndexBufferDx10::Flush()
{
// This strange-looking line makes a flush only occur if the buffer is dynamic.
m_bFlush = m_bIsDynamic;
}
//-----------------------------------------------------------------------------
// Casts a dynamic buffer to be a particular index type
//-----------------------------------------------------------------------------
void CIndexBufferDx10::BeginCastBuffer( MaterialIndexFormat_t format )
{
Assert( format != MATERIAL_INDEX_FORMAT_UNKNOWN );
Assert( m_bIsDynamic && ( m_IndexFormat == MATERIAL_INDEX_FORMAT_UNKNOWN || m_IndexFormat == format ) );
if ( !m_bIsDynamic )
return;
m_IndexFormat = format;
m_nIndexCount = m_nBufferSize / IndexSize();
}
void CIndexBufferDx10::EndCastBuffer( )
{
Assert( m_bIsDynamic && m_IndexFormat != MATERIAL_INDEX_FORMAT_UNKNOWN );
if ( !m_bIsDynamic )
return;
m_IndexFormat = MATERIAL_INDEX_FORMAT_UNKNOWN;
m_nIndexCount = 0;
}
//-----------------------------------------------------------------------------
// Returns the number of indices that can be written into the buffer
//-----------------------------------------------------------------------------
int CIndexBufferDx10::GetRoomRemaining() const
{
return ( m_nBufferSize - m_nFirstUnwrittenOffset ) / IndexSize();
}
//-----------------------------------------------------------------------------
// Locks, unlocks the mesh
//-----------------------------------------------------------------------------
bool CIndexBufferDx10::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();
void *pLockedData = NULL;
HRESULT hr;
// 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_pShaderDevice->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
int nMemoryRequired = nMaxIndexCount * IndexSize();
bool bHasEnoughMemory = ( m_nFirstUnwrittenOffset + nMemoryRequired <= m_nBufferSize );
D3D10_MAP map;
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;
map = ( m_nFirstUnwrittenOffset == 0 ) ? D3D10_MAP_WRITE_DISCARD : D3D10_MAP_WRITE_NO_OVERWRITE;
}
else
{
// If we're not appending, no overwrite unless we don't have enough room
if ( !m_bFlush && bHasEnoughMemory && m_bIsDynamic )
{
map = ( m_nFirstUnwrittenOffset == 0 ) ? D3D10_MAP_WRITE_DISCARD : D3D10_MAP_WRITE_NO_OVERWRITE;
}
else
{
map = D3D10_MAP_WRITE_DISCARD;
m_nFirstUnwrittenOffset = 0;
m_bFlush = false;
}
}
hr = m_pIndexBuffer->Map( map, 0, &pLockedData );
if ( FAILED( hr ) )
{
Warning( "Failed to lock index buffer in CIndexBufferDx10::Lock\n" );
goto indexBufferLockFailed;
}
desc.m_pIndices = (unsigned short*)( (unsigned char*)pLockedData + m_nFirstUnwrittenOffset );
desc.m_nIndexSize = IndexSize() >> 1;
desc.m_nFirstIndex = 0;
desc.m_nOffset = m_nFirstUnwrittenOffset;
m_bIsLocked = true;
return true;
indexBufferLockFailed:
g_ShaderMutex.Unlock();
// Set up a bogus index descriptor
desc.m_pIndices = (unsigned short*)( &s_nScratchIndexBuffer );
desc.m_nFirstIndex = 0;
desc.m_nIndexSize = 0;
desc.m_nOffset = 0;
return false;
}
void CIndexBufferDx10::Unlock( int nWrittenIndexCount, IndexDesc_t &desc )
{
Assert( nWrittenIndexCount <= m_nIndexCount );
// NOTE: This can happen if the lock occurs during alt-tab
// or if another application is initializing
if ( !m_bIsLocked )
return;
if ( m_pIndexBuffer )
{
m_pIndexBuffer->Unmap();
}
m_nFirstUnwrittenOffset += nWrittenIndexCount * IndexSize();
m_bIsLocked = false;
g_ShaderMutex.Unlock();
}
//-----------------------------------------------------------------------------
// Locks, unlocks an existing mesh
//-----------------------------------------------------------------------------
void CIndexBufferDx10::ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc )
{
Assert( 0 );
}
void CIndexBufferDx10::ModifyEnd( IndexDesc_t& desc )
{
}
//-----------------------------------------------------------------------------
//
// The empty mesh...
//
//-----------------------------------------------------------------------------
CMeshDx10::CMeshDx10()
{
m_pVertexMemory = new unsigned char[VERTEX_BUFFER_SIZE];
}
CMeshDx10::~CMeshDx10()
{
delete[] m_pVertexMemory;
}
void CMeshDx10::LockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
{
// Who cares about the data?
desc.m_pPosition = (float*)m_pVertexMemory;
desc.m_pNormal = (float*)m_pVertexMemory;
desc.m_pColor = m_pVertexMemory;
int i;
for ( i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i)
desc.m_pTexCoord[i] = (float*)m_pVertexMemory;
desc.m_pIndices = (unsigned short*)m_pVertexMemory;
desc.m_pBoneWeight = (float*)m_pVertexMemory;
desc.m_pBoneMatrixIndex = (unsigned char*)m_pVertexMemory;
desc.m_pTangentS = (float*)m_pVertexMemory;
desc.m_pTangentT = (float*)m_pVertexMemory;
desc.m_pUserData = (float*)m_pVertexMemory;
desc.m_NumBoneWeights = 2;
desc.m_VertexSize_Position = 0;
desc.m_VertexSize_BoneWeight = 0;
desc.m_VertexSize_BoneMatrixIndex = 0;
desc.m_VertexSize_Normal = 0;
desc.m_VertexSize_Color = 0;
for( i=0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
desc.m_VertexSize_TexCoord[i] = 0;
desc.m_VertexSize_TangentS = 0;
desc.m_VertexSize_TangentT = 0;
desc.m_VertexSize_UserData = 0;
desc.m_ActualVertexSize = 0; // Size of the vertices.. Some of the m_VertexSize_ elements above
desc.m_nFirstVertex = 0;
desc.m_nIndexSize = 0;
}
void CMeshDx10::UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
{
}
void CMeshDx10::ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
{
// Who cares about the data?
desc.m_pPosition = (float*)m_pVertexMemory;
desc.m_pNormal = (float*)m_pVertexMemory;
desc.m_pColor = m_pVertexMemory;
int i;
for ( i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i)
desc.m_pTexCoord[i] = (float*)m_pVertexMemory;
desc.m_pIndices = (unsigned short*)m_pVertexMemory;
desc.m_pBoneWeight = (float*)m_pVertexMemory;
desc.m_pBoneMatrixIndex = (unsigned char*)m_pVertexMemory;
desc.m_pTangentS = (float*)m_pVertexMemory;
desc.m_pTangentT = (float*)m_pVertexMemory;
desc.m_pUserData = (float*)m_pVertexMemory;
desc.m_NumBoneWeights = 2;
desc.m_VertexSize_Position = 0;
desc.m_VertexSize_BoneWeight = 0;
desc.m_VertexSize_BoneMatrixIndex = 0;
desc.m_VertexSize_Normal = 0;
desc.m_VertexSize_Color = 0;
for( i=0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
desc.m_VertexSize_TexCoord[i] = 0;
desc.m_VertexSize_TangentS = 0;
desc.m_VertexSize_TangentT = 0;
desc.m_VertexSize_UserData = 0;
desc.m_ActualVertexSize = 0; // Size of the vertices.. Some of the m_VertexSize_ elements above
desc.m_nFirstVertex = 0;
desc.m_nIndexSize = 0;
}
void CMeshDx10::ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
{
ModifyBeginEx( false, firstVertex, numVerts, firstIndex, numIndices, desc );
}
void CMeshDx10::ModifyEnd( MeshDesc_t& desc )
{
}
// returns the # of vertices (static meshes only)
int CMeshDx10::VertexCount() const
{
return 0;
}
// Sets the primitive type
void CMeshDx10::SetPrimitiveType( MaterialPrimitiveType_t type )
{
}
// Draws the entire mesh
void CMeshDx10::Draw( int firstIndex, int numIndices )
{
}
void CMeshDx10::Draw(CPrimList *pPrims, int nPrims)
{
}
// Copy verts and/or indices to a mesh builder. This only works for temp meshes!
void CMeshDx10::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 )
{
}
// Spews the mesh data
void CMeshDx10::Spew( int numVerts, int numIndices, const MeshDesc_t & desc )
{
}
void CMeshDx10::ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc )
{
}
// gets the associated material
IMaterial* CMeshDx10::GetMaterial()
{
// umm. this don't work none
Assert(0);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink