{

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 )

{

#ifdef __i386__

__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

}

#else

memcpy( pDest, pSrc, BYTES_PER_FULL);

#endif

}

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

{

MQM_BUFFERED = ( 1 << 0 ),

MQM_FLEX = ( 1 << 1 ),

{

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( (uintp)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

{

static ALIGN16 uint16 tempIndices[256];

// original method

int i = 0;

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 )

{

}

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];

{

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;

{

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);

{

m_Vertices.FreeAll();

m_Indices.FreeAll();

{

BaseClass::CompactMemory();

m_Vertices.FreeAll();

m_Indices.FreeAll();

{

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 );

{

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();

{

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 );

{

if ( ++m_iRenderDepth == 1 )

{

VPROF_INCREMENT_GROUP_COUNTER( "render/CMatQBeginRender", COUNTER_GROUP_TELEMETRY, 1 );

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::BeginRender );

}

{

if ( --m_iRenderDepth == 0 )

{

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::EndRender );

}

{

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();

}

{

CMatRenderContextBase::SetRenderTargetEx( nRenderTargetID, pNewTarget );

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetRenderTargetEx, nRenderTargetID, pNewTarget );

{

// 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;

}

{

CMatRenderContextBase::Viewport( x, y, width, height );

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::Viewport, x, y, width, height );

{

// FIXME: does compiler do the right thing, is envelope needed?

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetAmbientLightCube, CUtlEnvelope<Vector4D>( &cube[0], 6 ) );

{

m_nBoneCount = nBoneCount;

m_queue.QueueCall( m_pHardwareContext, &IMatRenderContext::SetNumBoneWeights, nBoneCount );