1754 lines
52 KiB
C++
1754 lines
52 KiB
C++
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
// Purpose:
|
||
|
|
//
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
#include "pch_materialsystem.h"
|
||
|
|
|
||
|
|
#include "tier1/functors.h"
|
||
|
|
#include "itextureinternal.h"
|
||
|
|
|
||
|
|
#define MATSYS_INTERNAL
|
||
|
|
|
||
|
|
#include "cmatqueuedrendercontext.h"
|
||
|
|
#include "cmaterialsystem.h" // @HACKHACK
|
||
|
|
|
||
|
|
// NOTE: This has to be the last file included!
|
||
|
|
#include "tier0/memdbgon.h"
|
||
|
|
|
||
|
|
|
||
|
|
ConVar mat_report_queue_status( "mat_report_queue_status", "0", FCVAR_MATERIAL_SYSTEM_THREAD );
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#if defined( _WIN32 )
|
||
|
|
void FastCopy( byte *pDest, const byte *pSrc, size_t nBytes )
|
||
|
|
{
|
||
|
|
if ( !nBytes )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if !defined( _X360 )
|
||
|
|
if ( (size_t)pDest % 16 == 0 && (size_t)pSrc % 16 == 0 )
|
||
|
|
{
|
||
|
|
const int BYTES_PER_FULL = 128;
|
||
|
|
int nBytesFull = nBytes - ( nBytes % BYTES_PER_FULL );
|
||
|
|
for ( byte *pLimit = pDest + nBytesFull; pDest < pLimit; pDest += BYTES_PER_FULL, pSrc += BYTES_PER_FULL )
|
||
|
|
{
|
||
|
|
// memcpy( pDest, pSrc, BYTES_PER_FULL);
|
||
|
|
__asm
|
||
|
|
{
|
||
|
|
mov esi, pSrc
|
||
|
|
mov edi, pDest
|
||
|
|
|
||
|
|
movaps xmm0, [esi + 0]
|
||
|
|
movaps xmm1, [esi + 16]
|
||
|
|
movaps xmm2, [esi + 32]
|
||
|
|
movaps xmm3, [esi + 48]
|
||
|
|
movaps xmm4, [esi + 64]
|
||
|
|
movaps xmm5, [esi + 80]
|
||
|
|
movaps xmm6, [esi + 96]
|
||
|
|
movaps xmm7, [esi + 112]
|
||
|
|
|
||
|
|
movntps [edi + 0], xmm0
|
||
|
|
movntps [edi + 16], xmm1
|
||
|
|
movntps [edi + 32], xmm2
|
||
|
|
movntps [edi + 48], xmm3
|
||
|
|
movntps [edi + 64], xmm4
|
||
|
|
movntps [edi + 80], xmm5
|
||
|
|
movntps [edi + 96], xmm6
|
||
|
|
movntps [edi + 112], xmm7
|
||
|
|
}
|
||
|
|
}
|
||
|
|
nBytes -= nBytesFull;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( nBytes )
|
||
|
|
{
|
||
|
|
memcpy( pDest, pSrc, nBytes );
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
if ( (size_t)pDest % 4 == 0 && nBytes % 4 == 0 )
|
||
|
|
{
|
||
|
|
XMemCpyStreaming_WriteCombined( pDest, pSrc, nBytes );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// work around a bug in memcpy
|
||
|
|
if ((size_t)pDest % 2 == 0 && nBytes == 4)
|
||
|
|
{
|
||
|
|
*(reinterpret_cast<short *>(pDest)) = *(reinterpret_cast<const short *>(pSrc));
|
||
|
|
*(reinterpret_cast<short *>(pDest)+1) = *(reinterpret_cast<const short *>(pSrc)+1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
memcpy( pDest, pSrc, nBytes );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
#define FastCopy memcpy
|
||
|
|
#endif
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
enum MatQueuedMeshFlags_t
|
||
|
|
{
|
||
|
|
MQM_BUFFERED = ( 1 << 0 ),
|
||
|
|
MQM_FLEX = ( 1 << 1 ),
|
||
|
|
};
|
||
|
|
|
||
|
|
class CMatQueuedMesh : public IMesh
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CMatQueuedMesh( CMatQueuedRenderContext *pOwner, IMatRenderContextInternal *pHardwareContext )
|
||
|
|
: m_pLateBoundMesh( &m_pActualMesh ),
|
||
|
|
m_pOwner( pOwner ),
|
||
|
|
m_pCallQueue( pOwner->GetCallQueueInternal() ),
|
||
|
|
m_pHardwareContext( pHardwareContext ),
|
||
|
|
m_pVertexData( NULL ),
|
||
|
|
m_pIndexData( NULL ),
|
||
|
|
m_nVerts( 0 ),
|
||
|
|
m_nIndices( 0 ),
|
||
|
|
m_VertexSize( 0 ),
|
||
|
|
m_Type(MATERIAL_TRIANGLES),
|
||
|
|
m_pVertexOverride( NULL ),
|
||
|
|
m_pIndexOverride ( NULL ),
|
||
|
|
m_pActualMesh( NULL ),
|
||
|
|
m_nActualVertexOffsetInBytes( 0 ),
|
||
|
|
m_VertexFormat( 0 ),
|
||
|
|
m_MorphFormat( 0 )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
CLateBoundPtr<IMesh> &AccessLateBoundMesh()
|
||
|
|
{
|
||
|
|
return m_pLateBoundMesh;
|
||
|
|
}
|
||
|
|
|
||
|
|
byte *GetVertexData() { return m_pVertexData; }
|
||
|
|
uint16 *GetIndexData() { return m_pIndexData; }
|
||
|
|
IMesh *DetachActualMesh() { IMesh *p = m_pActualMesh; m_pActualMesh = NULL; return p; }
|
||
|
|
IMesh *GetActualMesh() { return m_pActualMesh; }
|
||
|
|
int GetActualVertexOffsetInBytes() { return m_nActualVertexOffsetInBytes; }
|
||
|
|
|
||
|
|
void DeferredGetDynamicMesh( VertexFormat_t vertexFormat, unsigned flags, IMesh* pVertexOverride, IMesh* pIndexOverride, IMaterialInternal *pMaterial )
|
||
|
|
{
|
||
|
|
if ( !( flags & MQM_FLEX ))
|
||
|
|
{
|
||
|
|
if ( vertexFormat == 0 )
|
||
|
|
{
|
||
|
|
m_pActualMesh = m_pHardwareContext->GetDynamicMesh( ( ( flags & MQM_BUFFERED ) != 0 ), pVertexOverride, pIndexOverride, pMaterial );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pActualMesh = m_pHardwareContext->GetDynamicMeshEx( vertexFormat, ( ( flags & MQM_BUFFERED ) != 0 ), pVertexOverride, pIndexOverride, pMaterial );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pActualMesh = m_pHardwareContext->GetFlexMesh();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool OnGetDynamicMesh( VertexFormat_t vertexFormat, unsigned flags, IMesh* pVertexOverride, IMesh* pIndexOverride, IMaterialInternal *pMaterial, int nHWSkinBoneCount )
|
||
|
|
{
|
||
|
|
if ( !m_pVertexOverride && ( m_pVertexData || m_pIndexData ) )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
if ( IsDebug() )
|
||
|
|
{
|
||
|
|
Assert( !"Getting a dynamic mesh without resolving the previous one" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Error( "Getting a dynamic mesh without resolving the previous one" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
FreeBuffers();
|
||
|
|
|
||
|
|
m_pVertexOverride = pVertexOverride;
|
||
|
|
m_pIndexOverride = pIndexOverride;
|
||
|
|
|
||
|
|
if ( !( flags & MQM_FLEX ) )
|
||
|
|
{
|
||
|
|
if ( pVertexOverride )
|
||
|
|
{
|
||
|
|
m_VertexFormat = pVertexOverride->GetVertexFormat();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Remove VERTEX_FORMAT_COMPRESSED from the material's format (dynamic meshes don't
|
||
|
|
// support compression, and all materials should support uncompressed verts too)
|
||
|
|
m_VertexFormat = ( vertexFormat == 0 ) ? ( pMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED ) : vertexFormat;
|
||
|
|
|
||
|
|
if ( vertexFormat != 0 )
|
||
|
|
{
|
||
|
|
int nVertexFormatBoneWeights = NumBoneWeights( vertexFormat );
|
||
|
|
if ( nHWSkinBoneCount < nVertexFormatBoneWeights )
|
||
|
|
{
|
||
|
|
nHWSkinBoneCount = nVertexFormatBoneWeights;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Force the requested number of bone weights
|
||
|
|
m_VertexFormat &= ~VERTEX_BONE_WEIGHT_MASK;
|
||
|
|
m_VertexFormat |= VERTEX_BONEWEIGHT( nHWSkinBoneCount );
|
||
|
|
if ( nHWSkinBoneCount > 0 )
|
||
|
|
{
|
||
|
|
m_VertexFormat |= VERTEX_BONE_INDEX;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_VertexFormat = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_FORMAT_USE_EXACT_FORMAT;
|
||
|
|
if ( g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_b() )
|
||
|
|
{
|
||
|
|
m_VertexFormat |= VERTEX_WRINKLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MeshDesc_t temp;
|
||
|
|
g_pShaderAPI->ComputeVertexDescription( 0, m_VertexFormat, temp );
|
||
|
|
m_VertexSize = temp.m_ActualVertexSize;
|
||
|
|
|
||
|
|
// queue up get of real dynamic mesh, allocate space for verts & indices
|
||
|
|
m_pCallQueue->QueueCall( this, &CMatQueuedMesh::DeferredGetDynamicMesh, vertexFormat, flags, pVertexOverride, pIndexOverride, pMaterial );
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ModifyEnd( MeshDesc_t& desc )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void GenerateSequentialIndexBuffer( unsigned short* pIndexMemory, int numIndices, int firstVertex )
|
||
|
|
{
|
||
|
|
Assert( pIndexMemory == m_pIndexData );
|
||
|
|
m_pCallQueue->QueueCall( &::GenerateSequentialIndexBuffer, pIndexMemory, numIndices, firstVertex );
|
||
|
|
}
|
||
|
|
|
||
|
|
void GenerateQuadIndexBuffer( unsigned short* pIndexMemory, int numIndices, int firstVertex )
|
||
|
|
{
|
||
|
|
Assert( pIndexMemory == m_pIndexData );
|
||
|
|
m_pCallQueue->QueueCall( &::GenerateQuadIndexBuffer, pIndexMemory, numIndices, firstVertex );
|
||
|
|
}
|
||
|
|
|
||
|
|
void GeneratePolygonIndexBuffer( unsigned short* pIndexMemory, int numIndices, int firstVertex )
|
||
|
|
{
|
||
|
|
Assert( pIndexMemory == m_pIndexData );
|
||
|
|
m_pCallQueue->QueueCall( &::GeneratePolygonIndexBuffer, pIndexMemory, numIndices, firstVertex );
|
||
|
|
}
|
||
|
|
|
||
|
|
void GenerateLineStripIndexBuffer( unsigned short* pIndexMemory, int numIndices, int firstVertex )
|
||
|
|
{
|
||
|
|
Assert( pIndexMemory == m_pIndexData );
|
||
|
|
m_pCallQueue->QueueCall( &::GenerateLineStripIndexBuffer, pIndexMemory, numIndices, firstVertex );
|
||
|
|
}
|
||
|
|
|
||
|
|
void GenerateLineLoopIndexBuffer( unsigned short* pIndexMemory, int numIndices, int firstVertex )
|
||
|
|
{
|
||
|
|
Assert( pIndexMemory == m_pIndexData );
|
||
|
|
m_pCallQueue->QueueCall( &::GenerateLineLoopIndexBuffer, pIndexMemory, numIndices, firstVertex );
|
||
|
|
}
|
||
|
|
|
||
|
|
int VertexCount() const
|
||
|
|
{
|
||
|
|
return m_VertexSize ? m_nVerts : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int IndexCount() const
|
||
|
|
{
|
||
|
|
return m_nIndices;
|
||
|
|
}
|
||
|
|
|
||
|
|
int GetVertexSize()
|
||
|
|
{
|
||
|
|
return m_VertexSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
void SetPrimitiveType( MaterialPrimitiveType_t type )
|
||
|
|
{
|
||
|
|
m_Type = type;
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, &IMesh::SetPrimitiveType, type );
|
||
|
|
}
|
||
|
|
|
||
|
|
void SetColorMesh( IMesh *pColorMesh, int nVertexOffset )
|
||
|
|
{
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, &IMesh::SetColorMesh, pColorMesh, nVertexOffset );
|
||
|
|
}
|
||
|
|
|
||
|
|
void Draw( CPrimList *pLists, int nLists )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CopyToMeshBuilder( int iStartVert, int nVerts, int iStartIndex, int nIndices, int indexOffset, CMeshBuilder &builder )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void Spew( int numVerts, int numIndices, const MeshDesc_t & desc )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void LockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
|
||
|
|
{
|
||
|
|
if ( !m_pVertexOverride )
|
||
|
|
{
|
||
|
|
m_nVerts = numVerts;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_nVerts = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !m_pIndexOverride )
|
||
|
|
{
|
||
|
|
m_nIndices = numIndices;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_nIndices = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( numVerts > 0 )
|
||
|
|
{
|
||
|
|
Assert( m_VertexSize );
|
||
|
|
Assert( !m_pVertexData );
|
||
|
|
m_pVertexData = (byte *)m_pOwner->AllocVertices( numVerts, m_VertexSize );
|
||
|
|
Assert( (unsigned)m_pVertexData % 16 == 0 );
|
||
|
|
|
||
|
|
// Compute the vertex index..
|
||
|
|
desc.m_nFirstVertex = 0;
|
||
|
|
static_cast< VertexDesc_t* >( &desc )->m_nOffset = 0;
|
||
|
|
// Set up the mesh descriptor
|
||
|
|
g_pShaderAPI->ComputeVertexDescription( m_pVertexData, m_VertexFormat, desc );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
desc.m_nFirstVertex = 0;
|
||
|
|
static_cast< VertexDesc_t* >( &desc )->m_nOffset = 0;
|
||
|
|
// Set up the mesh descriptor
|
||
|
|
g_pShaderAPI->ComputeVertexDescription( 0, 0, desc );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_Type != MATERIAL_POINTS && numIndices > 0 )
|
||
|
|
{
|
||
|
|
Assert( !m_pIndexData );
|
||
|
|
m_pIndexData = m_pOwner->AllocIndices( numIndices );
|
||
|
|
desc.m_pIndices = m_pIndexData;
|
||
|
|
desc.m_nIndexSize = 1;
|
||
|
|
desc.m_nFirstIndex = 0;
|
||
|
|
static_cast< IndexDesc_t* >( &desc )->m_nOffset = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
desc.m_pIndices = &gm_ScratchIndexBuffer[0];
|
||
|
|
desc.m_nIndexSize = 0;
|
||
|
|
desc.m_nFirstIndex = 0;
|
||
|
|
static_cast< IndexDesc_t* >( &desc )->m_nOffset = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
|
||
|
|
{
|
||
|
|
if ( m_pVertexData && numVerts < m_nVerts )
|
||
|
|
{
|
||
|
|
m_pVertexData = m_pOwner->ReallocVertices( m_pVertexData, m_nVerts, numVerts, m_VertexSize );
|
||
|
|
}
|
||
|
|
m_nVerts = numVerts;
|
||
|
|
|
||
|
|
if ( m_pIndexData && numIndices < m_nIndices )
|
||
|
|
{
|
||
|
|
m_pIndexData = m_pOwner->ReallocIndices( m_pIndexData, m_nIndices, numIndices );
|
||
|
|
}
|
||
|
|
m_nIndices = numIndices;
|
||
|
|
}
|
||
|
|
|
||
|
|
void SetFlexMesh( IMesh *pMesh, int nVertexOffset )
|
||
|
|
{
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, &IMesh::SetFlexMesh, pMesh, nVertexOffset );
|
||
|
|
}
|
||
|
|
|
||
|
|
void DisableFlexMesh()
|
||
|
|
{
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, &IMesh::DisableFlexMesh );
|
||
|
|
}
|
||
|
|
|
||
|
|
void ExecuteDefferredBuild( byte *pVertexData, int nVerts, int nBytesVerts, uint16 *pIndexData, int nIndices )
|
||
|
|
{
|
||
|
|
Assert( m_pActualMesh );
|
||
|
|
MeshDesc_t desc;
|
||
|
|
m_pActualMesh->LockMesh( nVerts, nIndices, desc );
|
||
|
|
m_nActualVertexOffsetInBytes = desc.m_nFirstVertex * desc.m_ActualVertexSize;
|
||
|
|
if ( pVertexData && desc.m_ActualVertexSize ) // if !desc.m_ActualVertexSize, device lost
|
||
|
|
{
|
||
|
|
void *pDest;
|
||
|
|
if ( desc.m_VertexSize_Position != 0 )
|
||
|
|
{
|
||
|
|
pDest = desc.m_pPosition;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#define FindMin( desc, pCurrent, tag ) ( ( desc.m_VertexSize_##tag != 0 ) ? min( pCurrent, (void *)desc.m_p##tag ) : pCurrent )
|
||
|
|
|
||
|
|
pDest = (void *)(((byte *)0) - 1);
|
||
|
|
|
||
|
|
pDest = FindMin( desc, pDest, BoneWeight );
|
||
|
|
pDest = FindMin( desc, pDest, BoneMatrixIndex );
|
||
|
|
pDest = FindMin( desc, pDest, Normal );
|
||
|
|
pDest = FindMin( desc, pDest, Color );
|
||
|
|
pDest = FindMin( desc, pDest, Specular );
|
||
|
|
pDest = FindMin( desc, pDest, TangentS );
|
||
|
|
pDest = FindMin( desc, pDest, TangentT );
|
||
|
|
pDest = FindMin( desc, pDest, Wrinkle );
|
||
|
|
|
||
|
|
for ( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
|
||
|
|
{
|
||
|
|
if ( desc.m_VertexSize_TexCoord[i] && desc.m_pTexCoord < pDest )
|
||
|
|
{
|
||
|
|
pDest = desc.m_pTexCoord;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#undef FindMin
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( pDest );
|
||
|
|
if ( pDest )
|
||
|
|
{
|
||
|
|
FastCopy( (byte *)pDest, pVertexData, nBytesVerts );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pIndexData && pIndexData != &gm_ScratchIndexBuffer[0] && desc.m_nIndexSize )
|
||
|
|
{
|
||
|
|
if ( !desc.m_nFirstVertex )
|
||
|
|
{
|
||
|
|
// AssertMsg(desc.m_pIndices & 0x03 == 0,"desc.m_pIndices is misaligned in CMatQueuedMesh::ExecuteDefferedBuild\n");
|
||
|
|
FastCopy( (byte *)desc.m_pIndices, (byte *)pIndexData, nIndices * sizeof(*pIndexData) );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ALIGN16 uint16 tempIndices[16];
|
||
|
|
|
||
|
|
int i = 0;
|
||
|
|
if ( (size_t)desc.m_pIndices % 4 == 2 )
|
||
|
|
{
|
||
|
|
desc.m_pIndices[i] = pIndexData[i] + desc.m_nFirstVertex;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
while ( i < nIndices )
|
||
|
|
{
|
||
|
|
int nToCopy = min( (int)ARRAYSIZE(tempIndices), nIndices - i );
|
||
|
|
for ( int j = 0; j < nToCopy; j++ )
|
||
|
|
{
|
||
|
|
tempIndices[j] = pIndexData[i+j] + desc.m_nFirstVertex;
|
||
|
|
}
|
||
|
|
FastCopy( (byte *)(desc.m_pIndices + i), (byte *)tempIndices, nToCopy * sizeof(uint16) );
|
||
|
|
i += nToCopy;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pActualMesh->UnlockMesh( nVerts, nIndices, desc );
|
||
|
|
|
||
|
|
if ( pIndexData && pIndexData != &gm_ScratchIndexBuffer[0])
|
||
|
|
{
|
||
|
|
m_pOwner->FreeIndices( pIndexData, nIndices );
|
||
|
|
}
|
||
|
|
if ( pVertexData )
|
||
|
|
{
|
||
|
|
m_pOwner->FreeVertices( pVertexData, nVerts, desc.m_ActualVertexSize );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void QueueBuild( bool bDetachBuffers = true )
|
||
|
|
{
|
||
|
|
m_pCallQueue->QueueCall( this, &CMatQueuedMesh::ExecuteDefferredBuild, m_pVertexData, m_nVerts, m_nVerts * m_VertexSize, m_pIndexData, m_nIndices );
|
||
|
|
if ( bDetachBuffers )
|
||
|
|
{
|
||
|
|
DetachBuffers();
|
||
|
|
m_Type = MATERIAL_TRIANGLES;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Draw( int firstIndex = -1, int numIndices = 0 )
|
||
|
|
{
|
||
|
|
if ( !m_nVerts && !m_nIndices )
|
||
|
|
{
|
||
|
|
MarkAsDrawn();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
void (IMesh::*pfnDraw)( int, int) = &IMesh::Draw; // need assignment to disambiguate overloaded function
|
||
|
|
bool bDetachBuffers;
|
||
|
|
if ( firstIndex == -1 || numIndices == 0 )
|
||
|
|
{
|
||
|
|
bDetachBuffers = true;
|
||
|
|
}
|
||
|
|
else if ( m_pIndexOverride )
|
||
|
|
{
|
||
|
|
bDetachBuffers = ( firstIndex + numIndices == m_pIndexOverride->IndexCount() );
|
||
|
|
}
|
||
|
|
else if ( !m_nIndices || firstIndex + numIndices == m_nIndices )
|
||
|
|
{
|
||
|
|
bDetachBuffers = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bDetachBuffers = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
QueueBuild( bDetachBuffers );
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, pfnDraw, firstIndex, numIndices );
|
||
|
|
}
|
||
|
|
|
||
|
|
void MarkAsDrawn()
|
||
|
|
{
|
||
|
|
FreeBuffers();
|
||
|
|
m_pCallQueue->QueueCall( m_pLateBoundMesh, &IMesh::MarkAsDrawn );
|
||
|
|
}
|
||
|
|
|
||
|
|
void FreeBuffers()
|
||
|
|
{
|
||
|
|
if ( m_pIndexData && m_pIndexData != &gm_ScratchIndexBuffer[0])
|
||
|
|
{
|
||
|
|
m_pOwner->FreeIndices( m_pIndexData, m_nIndices );
|
||
|
|
m_pIndexData = NULL;
|
||
|
|
}
|
||
|
|
if ( m_pVertexData )
|
||
|
|
{
|
||
|
|
m_pOwner->FreeVertices( m_pVertexData, m_nVerts, m_VertexSize );
|
||
|
|
m_pVertexData = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void DetachBuffers()
|
||
|
|
{
|
||
|
|
m_pVertexData = NULL;
|
||
|
|
m_pIndexData = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned ComputeMemoryUsed()
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual VertexFormat_t GetVertexFormat() const
|
||
|
|
{
|
||
|
|
return m_VertexFormat;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual IMesh *GetMesh()
|
||
|
|
{
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// FIXME: Implement!
|
||
|
|
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 )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
void ModifyEnd( IndexDesc_t& desc )
|
||
|
|
{
|
||
|
|
CannotSupport();
|
||
|
|
}
|
||
|
|
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 );
|
||
|
|
}
|
||
|
|
virtual bool IsDynamic() const
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual MaterialIndexFormat_t IndexFormat() const
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
return MATERIAL_INDEX_FORMAT_UNKNOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void BeginCastBuffer( VertexFormat_t format )
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void BeginCastBuffer( MaterialIndexFormat_t format )
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void EndCastBuffer( )
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns the number of vertices that can still be written into the buffer
|
||
|
|
virtual int GetRoomRemaining() const
|
||
|
|
{
|
||
|
|
Assert( 0 );
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
static void DoDraw( int firstIndex = -1, int numIndices = 0 )
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
|
||
|
|
IMesh *m_pActualMesh;
|
||
|
|
int m_nActualVertexOffsetInBytes;
|
||
|
|
|
||
|
|
CLateBoundPtr<IMesh> m_pLateBoundMesh;
|
||
|
|
|
||
|
|
CMatQueuedRenderContext *m_pOwner;
|
||
|
|
CMatCallQueue *m_pCallQueue;
|
||
|
|
IMatRenderContextInternal *m_pHardwareContext;
|
||
|
|
|
||
|
|
//-----------------------------------------------------
|
||
|
|
|
||
|
|
// The vertex format we're using...
|
||
|
|
VertexFormat_t m_VertexFormat;
|
||
|
|
|
||
|
|
// The morph format we're using
|
||
|
|
MorphFormat_t m_MorphFormat;
|
||
|
|
|
||
|
|
byte *m_pVertexData;
|
||
|
|
uint16 *m_pIndexData;
|
||
|
|
|
||
|
|
int m_nVerts;
|
||
|
|
int m_nIndices;
|
||
|
|
|
||
|
|
unsigned short m_VertexSize;
|
||
|
|
MaterialPrimitiveType_t m_Type;
|
||
|
|
|
||
|
|
// Used in rendering sub-parts of the mesh
|
||
|
|
//static unsigned int s_NumIndices;
|
||
|
|
//static unsigned int s_FirstIndex;
|
||
|
|
|
||
|
|
IMesh *m_pVertexOverride;
|
||
|
|
IMesh *m_pIndexOverride;
|
||
|
|
|
||
|
|
static unsigned short gm_ScratchIndexBuffer[6];
|
||
|
|
};
|
||
|
|
|
||
|
|
unsigned short CMatQueuedMesh::gm_ScratchIndexBuffer[6];
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::Init( CMaterialSystem *pMaterialSystem, CMatRenderContextBase *pHardwareContext )
|
||
|
|
{
|
||
|
|
BaseClass::Init();
|
||
|
|
|
||
|
|
m_pMaterialSystem = pMaterialSystem;
|
||
|
|
m_pHardwareContext = pHardwareContext;
|
||
|
|
|
||
|
|
m_pQueuedMesh = new CMatQueuedMesh( this, pHardwareContext );
|
||
|
|
|
||
|
|
MEM_ALLOC_CREDIT();
|
||
|
|
|
||
|
|
int nSize = 16 * 1024 * 1024;
|
||
|
|
int nCommitSize = 128 * 1024;
|
||
|
|
#if defined(DEDICATED)
|
||
|
|
Assert( !"CMatQueuedRenderContext shouldn't be initialized on dedicated servers..." );
|
||
|
|
nSize = nCommitSize = 1024;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
bool bVerticesInit = m_Vertices.Init( nSize, nCommitSize );
|
||
|
|
bool bIndicesInit = m_Indices.Init( nSize, nCommitSize );
|
||
|
|
|
||
|
|
if ( !bVerticesInit || !bIndicesInit )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::Shutdown()
|
||
|
|
{
|
||
|
|
if ( !m_pHardwareContext )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( !m_pCurrentMaterial );
|
||
|
|
|
||
|
|
delete m_pQueuedMesh;
|
||
|
|
m_pMaterialSystem = NULL;
|
||
|
|
m_pHardwareContext = NULL;
|
||
|
|
m_pQueuedMesh = NULL;
|
||
|
|
|
||
|
|
m_Vertices.Term();
|
||
|
|
m_Indices.Term();
|
||
|
|
|
||
|
|
BaseClass::Shutdown();
|
||
|
|
Assert(m_queue.Count() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::Free()
|
||
|
|
{
|
||
|
|
m_Vertices.FreeAll();
|
||
|
|
m_Indices.FreeAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::CompactMemory()
|
||
|
|
{
|
||
|
|
BaseClass::CompactMemory();
|
||
|
|
m_Vertices.FreeAll();
|
||
|
|
m_Indices.FreeAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::BeginQueue( CMatRenderContextBase *pInitialState )
|
||
|
|
{
|
||
|
|
if ( !pInitialState )
|
||
|
|
{
|
||
|
|
pInitialState = m_pHardwareContext;
|
||
|
|
}
|
||
|
|
CMatRenderContextBase::InitializeFrom( pInitialState );
|
||
|
|
g_pShaderAPI->GetBackBufferDimensions( m_WidthBackBuffer, m_HeightBackBuffer );
|
||
|
|
m_FogMode = pInitialState->GetFogMode();
|
||
|
|
m_nBoneCount = pInitialState->GetCurrentNumBones();
|
||
|
|
pInitialState->GetFogDistances( &m_flFogStart, &m_flFogEnd, &m_flFogZ );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::EndQueue( bool bCallQueued )
|
||
|
|
{
|
||
|
|
if ( bCallQueued )
|
||
|
|
{
|
||
|
|
CallQueued();
|
||
|
|
}
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if ( m_pCurrentMaterial )
|
||
|
|
{
|
||
|
|
m_pCurrentMaterial = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pUserDefinedLightmap )
|
||
|
|
{
|
||
|
|
m_pUserDefinedLightmap = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pLocalCubemapTexture )
|
||
|
|
{
|
||
|
|
m_pLocalCubemapTexture = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( i = 0; i < MAX_FB_TEXTURES; i++ )
|
||
|
|
{
|
||
|
|
if ( m_pCurrentFrameBufferCopyTexture[i] )
|
||
|
|
{
|
||
|
|
m_pCurrentFrameBufferCopyTexture[i] = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( i = 0; i < m_RenderTargetStack.Count(); i++ )
|
||
|
|
{
|
||
|
|
for ( int j = 0; j < MAX_RENDER_TARGETS; j++ )
|
||
|
|
{
|
||
|
|
if ( m_RenderTargetStack[i].m_pRenderTargets[j] )
|
||
|
|
{
|
||
|
|
m_RenderTargetStack[i].m_pRenderTargets[j] = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_RenderTargetStack.Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::Bind( IMaterial *iMaterial, void *proxyData )
|
||
|
|
{
|
||
|
|
if ( !iMaterial )
|
||
|
|
{
|
||
|
|
if( !g_pErrorMaterial )
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
iMaterial = ((IMaterialInternal *)iMaterial)->GetRealTimeVersion(); //always work with the real time versions of materials internally
|
||
|
|
}
|
||
|
|
|
||
|
|
CMatRenderContextBase::Bind( iMaterial, proxyData );
|
||
|
|
|
||
|
|
// We've always gotta call the bind proxy (assuming there is one)
|
||
|
|
// so we can copy off the material vars at this point.
|
||
|
|
IMaterialInternal* pIMaterial = GetCurrentMaterialInternal();
|
||
|
|
pIMaterial->CallBindProxy( proxyData );
|
||
|
|
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::Bind, iMaterial, proxyData );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::BeginRender()
|
||
|
|
{
|
||
|
|
if ( ++m_iRenderDepth == 1 )
|
||
|
|
{
|
||
|
|
VPROF_INCREMENT_GROUP_COUNTER( "render/CMatQBeginRender", COUNTER_GROUP_TELEMETRY, 1 );
|
||
|
|
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::BeginRender );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::EndRender()
|
||
|
|
{
|
||
|
|
if ( --m_iRenderDepth == 0 )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::EndRender );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::CallQueued( bool bTermAfterCall )
|
||
|
|
{
|
||
|
|
if ( mat_report_queue_status.GetBool() )
|
||
|
|
{
|
||
|
|
Msg( "%d calls queued for %llu bytes in parameters and overhead, %d bytes verts, %d bytes indices, %d bytes other\n", m_queue.Count(), (uint64)(m_queue.GetMemoryUsed()), m_Vertices.GetUsed(), m_Indices.GetUsed(), RenderDataSizeUsed() );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_queue.CallQueued();
|
||
|
|
|
||
|
|
m_Vertices.FreeAll( false );
|
||
|
|
m_Indices.FreeAll( false );
|
||
|
|
|
||
|
|
if ( bTermAfterCall )
|
||
|
|
{
|
||
|
|
Shutdown();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::FlushQueued()
|
||
|
|
{
|
||
|
|
m_queue.Flush();
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
ICallQueue *CMatQueuedRenderContext::GetCallQueue()
|
||
|
|
{
|
||
|
|
return &m_CallQueueExternal;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetRenderTargetEx( int nRenderTargetID, ITexture *pNewTarget )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::SetRenderTargetEx( nRenderTargetID, pNewTarget );
|
||
|
|
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetRenderTargetEx, nRenderTargetID, pNewTarget );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::GetRenderTargetDimensions( int &width, int &height) const
|
||
|
|
{
|
||
|
|
// Target at top of stack
|
||
|
|
ITexture *pTOS = NULL;
|
||
|
|
|
||
|
|
if ( m_RenderTargetStack.Count() )
|
||
|
|
{
|
||
|
|
pTOS = m_RenderTargetStack.Top().m_pRenderTargets[ 0 ];
|
||
|
|
}
|
||
|
|
|
||
|
|
// If top of stack isn't the back buffer, get dimensions from the texture
|
||
|
|
if ( pTOS != NULL )
|
||
|
|
{
|
||
|
|
width = pTOS->GetActualWidth();
|
||
|
|
height = pTOS->GetActualHeight();
|
||
|
|
}
|
||
|
|
else // otherwise, get them from the shader API
|
||
|
|
{
|
||
|
|
width = m_WidthBackBuffer;
|
||
|
|
height = m_HeightBackBuffer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::Viewport( int x, int y, int width, int height )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::Viewport( x, y, width, height );
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::Viewport, x, y, width, height );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetLight( int i, const LightDesc_t &desc )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetLight, i, RefToVal( desc ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetLightingOrigin( Vector vLightingOrigin )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetLightingOrigin, vLightingOrigin );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetAmbientLightCube( LightCube_t cube )
|
||
|
|
{
|
||
|
|
// FIXME: does compiler do the right thing, is envelope needed?
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetAmbientLightCube, CUtlEnvelope<Vector4D>( &cube[0], 6 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Bone count
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetNumBoneWeights( int nBoneCount )
|
||
|
|
{
|
||
|
|
m_nBoneCount = nBoneCount;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetNumBoneWeights, nBoneCount );
|
||
|
|
}
|
||
|
|
|
||
|
|
int CMatQueuedRenderContext::GetCurrentNumBones( ) const
|
||
|
|
{
|
||
|
|
return m_nBoneCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::FogMode( MaterialFogMode_t fogMode )
|
||
|
|
{
|
||
|
|
m_FogMode = fogMode;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::FogMode, fogMode );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogStart( float fStart )
|
||
|
|
{
|
||
|
|
m_flFogStart = fStart;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::FogStart, fStart );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogEnd( float fEnd )
|
||
|
|
{
|
||
|
|
m_flFogEnd = fEnd;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::FogEnd, fEnd );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogMaxDensity( float flMaxDensity )
|
||
|
|
{
|
||
|
|
m_flFogMaxDensity = flMaxDensity;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::FogMaxDensity, flMaxDensity );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::SetFogZ( float fogZ )
|
||
|
|
{
|
||
|
|
m_flFogZ = fogZ;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetFogZ, fogZ );
|
||
|
|
}
|
||
|
|
|
||
|
|
MaterialFogMode_t CMatQueuedRenderContext::GetFogMode( void )
|
||
|
|
{
|
||
|
|
return m_FogMode;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogColor3f( float r, float g, float b )
|
||
|
|
{
|
||
|
|
FogColor3ub( clamp( (int)(r * 255.0f), 0, 255 ), clamp( (int)(g * 255.0f), 0, 255 ), clamp( (int)(b * 255.0f), 0, 255 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogColor3fv( float const* rgb )
|
||
|
|
{
|
||
|
|
FogColor3ub( clamp( (int)(rgb[0] * 255.0f), 0, 255 ), clamp( (int)(rgb[1] * 255.0f), 0, 255 ), clamp( (int)(rgb[2] * 255.0f), 0, 255 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogColor3ub( unsigned char r, unsigned char g, unsigned char b )
|
||
|
|
{
|
||
|
|
m_FogColor.r = r;
|
||
|
|
m_FogColor.g = g;
|
||
|
|
m_FogColor.b = b;
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::FogColor3ub, r, g, b );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FogColor3ubv( unsigned char const* rgb )
|
||
|
|
{
|
||
|
|
FogColor3ub( rgb[0], rgb[1], rgb[2] );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::GetFogColor( unsigned char *rgb )
|
||
|
|
{
|
||
|
|
rgb[0] = m_FogColor.r;
|
||
|
|
rgb[1] = m_FogColor.g;
|
||
|
|
rgb[2] = m_FogColor.b;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::GetFogDistances( float *fStart, float *fEnd, float *fFogZ )
|
||
|
|
{
|
||
|
|
if( fStart )
|
||
|
|
*fStart = m_flFogStart;
|
||
|
|
|
||
|
|
if( fEnd )
|
||
|
|
*fEnd = m_flFogEnd;
|
||
|
|
|
||
|
|
if( fFogZ )
|
||
|
|
*fFogZ = m_flFogZ;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::GetViewport( int& x, int& y, int& width, int& height ) const
|
||
|
|
{
|
||
|
|
// Verify valid top of RT stack
|
||
|
|
Assert ( m_RenderTargetStack.Count() > 0 );
|
||
|
|
|
||
|
|
// Grab the top of stack
|
||
|
|
const RenderTargetStackElement_t& element = m_RenderTargetStack.Top();
|
||
|
|
|
||
|
|
// If either dimension is negative, set to full bounds of current target
|
||
|
|
if ( (element.m_nViewW < 0) || (element.m_nViewH < 0) )
|
||
|
|
{
|
||
|
|
// Viewport origin at target origin
|
||
|
|
x = y = 0;
|
||
|
|
|
||
|
|
// If target is back buffer
|
||
|
|
if ( element.m_pRenderTargets[0] == NULL )
|
||
|
|
{
|
||
|
|
width = m_WidthBackBuffer;
|
||
|
|
height = m_HeightBackBuffer;
|
||
|
|
}
|
||
|
|
else // if target is texture
|
||
|
|
{
|
||
|
|
width = element.m_pRenderTargets[0]->GetActualWidth();
|
||
|
|
height = element.m_pRenderTargets[0]->GetActualHeight();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else // use the bounds from the stack directly
|
||
|
|
{
|
||
|
|
x = element.m_nViewX;
|
||
|
|
y = element.m_nViewY;
|
||
|
|
width = element.m_nViewW;
|
||
|
|
height = element.m_nViewH;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SyncToken( const char *p )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SyncToken, CUtlEnvelope<const char *>( p ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
IMesh* CMatQueuedRenderContext::GetDynamicMesh( bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride, IMaterial *pAutoBind )
|
||
|
|
{
|
||
|
|
if( pAutoBind )
|
||
|
|
Bind( pAutoBind, NULL );
|
||
|
|
|
||
|
|
if ( pVertexOverride && pIndexOverride )
|
||
|
|
{
|
||
|
|
// Use the new batch API
|
||
|
|
DebuggerBreak();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pVertexOverride )
|
||
|
|
{
|
||
|
|
if ( CompressionType( pVertexOverride->GetVertexFormat() ) != VERTEX_COMPRESSION_NONE )
|
||
|
|
{
|
||
|
|
// UNDONE: support compressed dynamic meshes if needed (pro: less VB memory, con: time spent compressing)
|
||
|
|
DebuggerBreak();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// For anything more than 1 bone, imply the last weight from the 1 - the sum of the others.
|
||
|
|
int nCurrentBoneCount = GetCurrentNumBones();
|
||
|
|
Assert( nCurrentBoneCount <= 4 );
|
||
|
|
if ( nCurrentBoneCount > 1 )
|
||
|
|
{
|
||
|
|
--nCurrentBoneCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pQueuedMesh->OnGetDynamicMesh( 0, ( buffered ) ? MQM_BUFFERED : 0, pVertexOverride, pIndexOverride, GetCurrentMaterialInternal(), nCurrentBoneCount );
|
||
|
|
return m_pQueuedMesh;
|
||
|
|
}
|
||
|
|
|
||
|
|
IMesh* CMatQueuedRenderContext::GetDynamicMeshEx( VertexFormat_t vertexFormat, bool bBuffered, IMesh* pVertexOverride, IMesh* pIndexOverride, IMaterial *pAutoBind )
|
||
|
|
{
|
||
|
|
if( pAutoBind )
|
||
|
|
{
|
||
|
|
Bind( pAutoBind, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pVertexOverride && pIndexOverride )
|
||
|
|
{
|
||
|
|
// Use the new batch API
|
||
|
|
DebuggerBreak();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( pVertexOverride )
|
||
|
|
{
|
||
|
|
if ( CompressionType( pVertexOverride->GetVertexFormat() ) != VERTEX_COMPRESSION_NONE )
|
||
|
|
{
|
||
|
|
// UNDONE: support compressed dynamic meshes if needed (pro: less VB memory, con: time spent compressing)
|
||
|
|
DebuggerBreak();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// For anything more than 1 bone, imply the last weight from the 1 - the sum of the others.
|
||
|
|
int nCurrentBoneCount = GetCurrentNumBones();
|
||
|
|
Assert( nCurrentBoneCount <= 4 );
|
||
|
|
if ( nCurrentBoneCount > 1 )
|
||
|
|
{
|
||
|
|
--nCurrentBoneCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pQueuedMesh->OnGetDynamicMesh( vertexFormat, ( bBuffered ) ? MQM_BUFFERED : 0, pVertexOverride, pIndexOverride, GetCurrentMaterialInternal(), nCurrentBoneCount );
|
||
|
|
return m_pQueuedMesh;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CMatQueuedRenderContext::GetMaxVerticesToRender( IMaterial *pMaterial )
|
||
|
|
{
|
||
|
|
pMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion(); //always work with the real time version of materials internally.
|
||
|
|
|
||
|
|
MeshDesc_t temp;
|
||
|
|
|
||
|
|
// 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 materialFormat = pMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED;
|
||
|
|
g_pShaderAPI->ComputeVertexDescription( 0, materialFormat, temp );
|
||
|
|
|
||
|
|
int maxVerts = g_pShaderAPI->GetCurrentDynamicVBSize() / temp.m_ActualVertexSize;
|
||
|
|
if ( maxVerts > 65535 )
|
||
|
|
{
|
||
|
|
maxVerts = 65535;
|
||
|
|
}
|
||
|
|
return maxVerts;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices )
|
||
|
|
{
|
||
|
|
Assert( !bMaxUntilFlush );
|
||
|
|
*pMaxVerts = g_pShaderAPI->GetCurrentDynamicVBSize() / m_pQueuedMesh->GetVertexSize();
|
||
|
|
if ( *pMaxVerts > 65535 )
|
||
|
|
{
|
||
|
|
*pMaxVerts = 65535;
|
||
|
|
}
|
||
|
|
*pMaxIndices = INDEX_BUFFER_SIZE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
IMesh *CMatQueuedRenderContext::GetFlexMesh()
|
||
|
|
{
|
||
|
|
m_pQueuedMesh->OnGetDynamicMesh( 0, MQM_FLEX, NULL, NULL, NULL, 0 );
|
||
|
|
return m_pQueuedMesh;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
OcclusionQueryObjectHandle_t CMatQueuedRenderContext::CreateOcclusionQueryObject()
|
||
|
|
{
|
||
|
|
OcclusionQueryObjectHandle_t h = g_pOcclusionQueryMgr->CreateOcclusionQueryObject();
|
||
|
|
m_queue.QueueCall( g_pOcclusionQueryMgr, &COcclusionQueryMgr::OnCreateOcclusionQueryObject, h );
|
||
|
|
return h;
|
||
|
|
}
|
||
|
|
|
||
|
|
int CMatQueuedRenderContext::OcclusionQuery_GetNumPixelsRendered( OcclusionQueryObjectHandle_t h )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( g_pOcclusionQueryMgr, &COcclusionQueryMgr::OcclusionQuery_IssueNumPixelsRenderedQuery, h );
|
||
|
|
return g_pOcclusionQueryMgr->OcclusionQuery_GetNumPixelsRendered( h, false );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::SetFlashlightState( const FlashlightState_t &s, const VMatrix &m )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetFlashlightState, RefToVal( s ), RefToVal( m ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::EnableClipping( bool bEnable )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::EnableClipping, bEnable );
|
||
|
|
return BaseClass::EnableClipping( bEnable );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::UserClipTransform( const VMatrix &m )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::UserClipTransform, RefToVal( m ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::GetWindowSize( int &width, int &height ) const
|
||
|
|
{
|
||
|
|
width = m_WidthBackBuffer;
|
||
|
|
height = m_HeightBackBuffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::DrawScreenSpaceRectangle(
|
||
|
|
IMaterial *pMaterial,
|
||
|
|
int destx, int desty,
|
||
|
|
int width, int height,
|
||
|
|
float src_texture_x0, float src_texture_y0, // which texel you want to appear at
|
||
|
|
// destx/y
|
||
|
|
float src_texture_x1, float src_texture_y1, // which texel you want to appear at
|
||
|
|
// destx+width-1, desty+height-1
|
||
|
|
int src_texture_width, int src_texture_height, // needed for fixup
|
||
|
|
void *pClientRenderable,
|
||
|
|
int nXDice, int nYDice ) // Amount to tessellate the quad
|
||
|
|
{
|
||
|
|
IMaterial *pRealTimeVersionMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion();
|
||
|
|
pRealTimeVersionMaterial->CallBindProxy( pClientRenderable );
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::DrawScreenSpaceRectangle, pMaterial, destx, desty, width, height, src_texture_x0, src_texture_y0, src_texture_x1, src_texture_y1, src_texture_width, src_texture_height, pClientRenderable, nXDice, nYDice );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::LoadBoneMatrix( int i, const matrix3x4_t &m )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::LoadBoneMatrix, i, RefToVal( m ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::CopyRenderTargetToTextureEx( ITexture *pTexture, int i, Rect_t *pSrc, Rect_t *pDst )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::CopyRenderTargetToTextureEx, pTexture, i, CUtlEnvelope<Rect_t>(pSrc), CUtlEnvelope<Rect_t>(pDst) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::CopyTextureToRenderTargetEx( int i, ITexture *pTexture, Rect_t *pSrc, Rect_t *pDst )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::CopyTextureToRenderTargetEx, i, pTexture, CUtlEnvelope<Rect_t>(pSrc), CUtlEnvelope<Rect_t>(pDst) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::OnDrawMesh( IMesh *pMesh, int firstIndex, int numIndices )
|
||
|
|
{
|
||
|
|
void (IMesh::*pfnDraw)( int, int) = &IMesh::Draw; // need assignment to disambiguate overloaded function
|
||
|
|
m_queue.QueueCall( pMesh, pfnDraw, firstIndex, numIndices );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::OnDrawMesh( IMesh *pMesh, CPrimList *pLists, int nLists )
|
||
|
|
{
|
||
|
|
CMatRenderData< CPrimList > rdPrimList( this, nLists, pLists );
|
||
|
|
m_queue.QueueCall( this, &CMatQueuedRenderContext::DeferredDrawPrimList, pMesh, rdPrimList.Base(), nLists );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::DeferredDrawPrimList( IMesh *pMesh, CPrimList *pLists, int nLists )
|
||
|
|
{
|
||
|
|
pMesh->Draw( pLists, nLists );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CMatQueuedRenderContext::DeferredSetFlexMesh( IMesh *pStaticMesh, int nVertexOffsetInBytes )
|
||
|
|
{
|
||
|
|
pStaticMesh->SetFlexMesh( m_pQueuedMesh->GetActualMesh(), m_pQueuedMesh->GetActualVertexOffsetInBytes() );
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CMatQueuedRenderContext::OnSetFlexMesh( IMesh *pStaticMesh, IMesh *pMesh, int nVertexOffsetInBytes )
|
||
|
|
{
|
||
|
|
Assert( pMesh == m_pQueuedMesh || !pMesh );
|
||
|
|
if ( pMesh )
|
||
|
|
{
|
||
|
|
m_pQueuedMesh->QueueBuild();
|
||
|
|
m_queue.QueueCall( this, &CMatQueuedRenderContext::DeferredSetFlexMesh, pStaticMesh, nVertexOffsetInBytes );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( pStaticMesh, &IMesh::SetFlexMesh, (IMesh *)NULL, 0 );
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::OnSetColorMesh( IMesh *pStaticMesh, IMesh *pMesh, int nVertexOffsetInBytes )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( pStaticMesh, &IMesh::SetColorMesh, pMesh, nVertexOffsetInBytes );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::OnSetPrimitiveType( IMesh *pMesh, MaterialPrimitiveType_t type )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( pMesh, &IMesh::SetPrimitiveType, type );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CMatQueuedRenderContext::OnFlushBufferedPrimitives()
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( g_pShaderAPI, &IShaderAPI::FlushBufferedPrimitives );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
inline void CMatQueuedRenderContext::QueueMatrixSync()
|
||
|
|
{
|
||
|
|
void (IMatRenderContext::*pfnLoadMatrix)( const VMatrix & ) = &IMatRenderContext::LoadMatrix; // need assignment to disambiguate overloaded function
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, pfnLoadMatrix, RefToVal( AccessCurrentMatrix() ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::MatrixMode( MaterialMatrixMode_t mode )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::MatrixMode( mode );
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::MatrixMode, mode );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::PushMatrix()
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::PushMatrix();
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::PushMatrix );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::PopMatrix()
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::PopMatrix();
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::PopMatrix );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::LoadMatrix( const VMatrix& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::LoadMatrix( matrix );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::LoadMatrix( const matrix3x4_t& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::LoadMatrix( matrix );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::MultMatrix( const VMatrix& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::MultMatrix( matrix );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::MultMatrix( const matrix3x4_t& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::MultMatrix( VMatrix( matrix ) );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::MultMatrixLocal( const VMatrix& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::MultMatrixLocal( matrix );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::MultMatrixLocal( const matrix3x4_t& matrix )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::MultMatrixLocal( VMatrix( matrix ) );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::LoadIdentity()
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::LoadIdentity();
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::LoadIdentity );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::Ortho( left, top, right, bottom, zNear, zFar );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::PerspectiveX( double flFovX, double flAspect, double flZNear, double flZFar )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::PerspectiveX( flFovX, flAspect, flZNear, flZFar );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::PerspectiveOffCenterX( double flFovX, double flAspect, double flZNear, double flZFar, double bottom, double top, double left, double right )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::PerspectiveOffCenterX( flFovX, flAspect, flZNear, flZFar, bottom, top, left, right );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::PickMatrix( int x, int y, int nWidth, int nHeight )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::PickMatrix( x, y, nWidth, nHeight );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::Rotate( float flAngle, float x, float y, float z )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::Rotate( flAngle, x, y, z );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::Translate( float x, float y, float z )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::Translate( x, y, z );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::Scale( float x, float y, float z )
|
||
|
|
{
|
||
|
|
CMatRenderContextBase::Scale( x, y, z );
|
||
|
|
QueueMatrixSync();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::BeginBatch( IMesh* pIndices )
|
||
|
|
{
|
||
|
|
Assert( pIndices == (IMesh *)m_pQueuedMesh );
|
||
|
|
m_queue.QueueCall( this, &CMatQueuedRenderContext::DeferredBeginBatch, m_pQueuedMesh->GetIndexData(), m_pQueuedMesh->IndexCount() );
|
||
|
|
m_pQueuedMesh->DetachBuffers();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::BindBatch( IMesh* pVertices, IMaterial *pAutoBind )
|
||
|
|
{
|
||
|
|
Assert( pVertices != (IMesh *)m_pQueuedMesh );
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::BindBatch, pVertices, pAutoBind );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::DrawBatch(int firstIndex, int numIndices )
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::DrawBatch, firstIndex, numIndices );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::EndBatch()
|
||
|
|
{
|
||
|
|
m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::EndBatch );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::DeferredBeginBatch( uint16 *pIndexData, int nIndices )
|
||
|
|
{
|
||
|
|
m_pQueuedMesh->DeferredGetDynamicMesh( 0, false, NULL, NULL, NULL );
|
||
|
|
m_pQueuedMesh->ExecuteDefferredBuild( NULL, 0, 0, pIndexData, nIndices );
|
||
|
|
m_pHardwareContext->BeginBatch( m_pQueuedMesh->DetachActualMesh() );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Memory allocation calls for queued mesh, et. al.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
byte *CMatQueuedRenderContext::AllocVertices( int nVerts, int nVertexSize )
|
||
|
|
{
|
||
|
|
MEM_ALLOC_CREDIT();
|
||
|
|
|
||
|
|
#if defined(_WIN32) && !defined(_X360)
|
||
|
|
const byte *pNextAlloc = (const byte *)(m_Vertices.GetBase()) + m_Vertices.GetUsed() + AlignValue( nVerts * nVertexSize, 16 );
|
||
|
|
const byte *pCommitLimit = (const byte *)(m_Vertices.GetBase()) + m_Vertices.GetSize();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void *pResult = m_Vertices.Alloc( nVerts * nVertexSize, false );
|
||
|
|
#if defined(_WIN32) && !defined(_X360)
|
||
|
|
if ( !pResult )
|
||
|
|
{
|
||
|
|
// Force a crash with useful minidump info in the registers.
|
||
|
|
uint64 status = 0x31415926;
|
||
|
|
|
||
|
|
// Print some information to the console so that it's picked up in the minidump comment.
|
||
|
|
Msg( "AllocVertices( %d, %d ) on %p failed. m_Vertices is based at %p with a size of 0x%x.\n", nVerts, nVertexSize, this, m_Vertices.GetBase(), m_Vertices.GetSize() );
|
||
|
|
Msg( "%d vertices used.\n", m_Vertices.GetUsed() );
|
||
|
|
if ( pNextAlloc > pCommitLimit )
|
||
|
|
{
|
||
|
|
Msg( "VirtualAlloc would have been called. %p > %p.\n", pNextAlloc, pCommitLimit );
|
||
|
|
|
||
|
|
const byte *pNewCommitLimit = AlignValue( pNextAlloc, 128 * 1024 );
|
||
|
|
const uint32 commitSize = pNewCommitLimit - pCommitLimit;
|
||
|
|
const void *pRet = VirtualAlloc( (void *)pCommitLimit, commitSize, MEM_COMMIT, PAGE_READWRITE );
|
||
|
|
if ( !pRet )
|
||
|
|
status = GetLastError();
|
||
|
|
|
||
|
|
Msg( "VirtualAlloc( %p, %d ) returned %p on repeat. VirtualAlloc %s with code %x.\n", pCommitLimit, commitSize, pRet, (pRet != NULL) ? "succeeded" : "failed", (uint32) status );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Msg( "VirtualAlloc would not have been called. %p <= %p.\n", pNextAlloc, pCommitLimit );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now crash.
|
||
|
|
*(volatile uint64 *)0 = status << 32 | m_Vertices.GetUsed();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
return (byte *) pResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint16 *CMatQueuedRenderContext::AllocIndices( int nIndices )
|
||
|
|
{
|
||
|
|
MEM_ALLOC_CREDIT();
|
||
|
|
|
||
|
|
#if defined(_WIN32) && !defined(_X360)
|
||
|
|
const byte *pNextAlloc = (const byte *)(m_Indices.GetBase()) + m_Indices.GetUsed() + AlignValue( nIndices * sizeof(uint16), 16 );
|
||
|
|
const byte *pCommitLimit = (const byte *)(m_Indices.GetBase()) + m_Indices.GetSize();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void *pResult = m_Indices.Alloc( nIndices * sizeof(uint16), false );
|
||
|
|
#if defined(_WIN32) && !defined(_X360)
|
||
|
|
if ( !pResult )
|
||
|
|
{
|
||
|
|
// Force a crash with useful minidump info in the registers.
|
||
|
|
uint64 status = 0x31415926;
|
||
|
|
|
||
|
|
// Print some information to the console so that it's picked up in the minidump comment.
|
||
|
|
Msg( "AllocIndices( %d ) on %p failed. m_Indices is based at %p with a size of 0x%x.\n", nIndices, this, m_Indices.GetBase(), m_Indices.GetSize() );
|
||
|
|
Msg( "%d indices used.\n", m_Indices.GetUsed() );
|
||
|
|
if ( pNextAlloc > pCommitLimit )
|
||
|
|
{
|
||
|
|
Msg( "VirtualAlloc would have been called. %p > %p.\n", pNextAlloc, pCommitLimit );
|
||
|
|
|
||
|
|
const byte *pNewCommitLimit = AlignValue( pNextAlloc, 128 * 1024 );
|
||
|
|
const uint32 commitSize = pNewCommitLimit - pCommitLimit;
|
||
|
|
const void *pRet = VirtualAlloc( (void *)pCommitLimit, commitSize, MEM_COMMIT, PAGE_READWRITE );
|
||
|
|
if ( !pRet )
|
||
|
|
status = GetLastError();
|
||
|
|
|
||
|
|
Msg( "VirtualAlloc( %p, %d ) returned %p on repeat. VirtualAlloc %s with code %x.\n", pCommitLimit, commitSize, pRet, (pRet != NULL) ? "succeeded" : "failed", (uint32) status );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Msg( "VirtualAlloc would not have been called. %p <= %p.\n", pNextAlloc, pCommitLimit );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now crash.
|
||
|
|
*(volatile uint64 *)0 = status << 32 | m_Indices.GetUsed();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
return (uint16 *) pResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
byte *CMatQueuedRenderContext::ReallocVertices( byte *pVerts, int nVertsOld, int nVertsNew, int nVertexSize )
|
||
|
|
{
|
||
|
|
Assert( nVertsNew <= nVertsOld );
|
||
|
|
|
||
|
|
if ( nVertsNew < nVertsOld )
|
||
|
|
{
|
||
|
|
unsigned nBytes = ( ( nVertsOld - nVertsNew ) * nVertexSize );
|
||
|
|
m_Vertices.FreeToAllocPoint( AlignValue( m_Vertices.GetCurrentAllocPoint() - nBytes, 16), false ); // memstacks 128 bit aligned
|
||
|
|
}
|
||
|
|
return pVerts;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint16 *CMatQueuedRenderContext::ReallocIndices( uint16 *pIndices, int nIndicesOld, int nIndicesNew )
|
||
|
|
{
|
||
|
|
Assert( nIndicesNew <= nIndicesOld );
|
||
|
|
if ( nIndicesNew < nIndicesOld )
|
||
|
|
{
|
||
|
|
unsigned nBytes = ( ( nIndicesOld - nIndicesNew ) * sizeof(uint16) );
|
||
|
|
m_Indices.FreeToAllocPoint( AlignValue( m_Indices.GetCurrentAllocPoint() - nBytes, 16 ), false ); // memstacks 128 bit aligned
|
||
|
|
}
|
||
|
|
return pIndices;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FreeVertices( byte *pVerts, int nVerts, int nVertexSize )
|
||
|
|
{
|
||
|
|
// free at end of call dispatch
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::FreeIndices( uint16 *pIndices, int nIndices )
|
||
|
|
{
|
||
|
|
// free at end of call dispatch
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
// Color correction related methods
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
ColorCorrectionHandle_t CMatQueuedRenderContext::AddLookup( const char *pName )
|
||
|
|
{
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
ColorCorrectionHandle_t hCC = ColorCorrectionSystem()->AddLookup( pName );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
return hCC;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CMatQueuedRenderContext::RemoveLookup( ColorCorrectionHandle_t handle )
|
||
|
|
{
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
bool bRemoved = ColorCorrectionSystem()->RemoveLookup( handle );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
return bRemoved;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::LockLookup( ColorCorrectionHandle_t handle )
|
||
|
|
{
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
ColorCorrectionSystem()->LockLookup( handle );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::LoadLookup( ColorCorrectionHandle_t handle, const char *pLookupName )
|
||
|
|
{
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
ColorCorrectionSystem()->LoadLookup( handle, pLookupName );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::UnlockLookup( ColorCorrectionHandle_t handle )
|
||
|
|
{
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
ColorCorrectionSystem()->UnlockLookup( handle );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
}
|
||
|
|
|
||
|
|
// NOTE: These are synchronous calls! The rendering thread is stopped, the current queue is drained and the pixels are read
|
||
|
|
// NOTE: We should also have a queued read pixels in the API for doing mid frame reads (as opposed to screenshots)
|
||
|
|
void CMatQueuedRenderContext::ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat )
|
||
|
|
{
|
||
|
|
EndRender();
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
this->CallQueued(false);
|
||
|
|
g_pShaderAPI->ReadPixels( x, y, width, height, data, dstFormat );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
BeginRender();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CMatQueuedRenderContext::ReadPixelsAndStretch( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pBuffer, ImageFormat dstFormat, int nDstStride )
|
||
|
|
{
|
||
|
|
EndRender();
|
||
|
|
MaterialLock_t hLock = m_pMaterialSystem->Lock();
|
||
|
|
this->CallQueued(false);
|
||
|
|
g_pShaderAPI->ReadPixels( pSrcRect, pDstRect, pBuffer, dstFormat, nDstStride );
|
||
|
|
m_pMaterialSystem->Unlock( hLock );
|
||
|
|
BeginRender();
|
||
|
|
}
|
||
|
|
|