1HEADmaster

1 files changed, 1753 insertions, 0 deletions

diff --git a/materialsystem/cmatqueuedrendercontext.cpp b/materialsystem/cmatqueuedrendercontext.cpp
new file mode 100644
index 0000000..47b10d5
--- /dev/null
+++ b/materialsystem/cmatqueuedrendercontext.cpp
@@ -0,0 +1,1753 @@
+//========= 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();
+}
+