void* CDataBlock::Allocate(UINT bufferSize, CDataBlock **ppBlock)
{
void *pRetValue;
UINT temp = m_size + bufferSize;
if (temp < m_size)
return NULL;
*ppBlock = this;
if (m_maxSize == 0)
{
// This is a brand new DataBlock, fill it up
m_maxSize = max(8192, bufferSize);
m_pData = NEW BYTE[m_maxSize];
if (!m_pData)
return NULL;
memset(m_pData, 0xDD, m_maxSize);
}
else if (temp > m_maxSize)
{
D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
// Couldn't fit data into this block, spill over into next
m_pNext = NEW CDataBlock();
if (!m_pNext)
return NULL;
if (m_IsAligned)
{
m_pNext->EnableAlignment();
}
return m_pNext->Allocate(bufferSize, ppBlock);
}
D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
pRetValue = m_pData + m_size;
if (m_IsAligned)
{
D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
m_size = AlignToPowerOf2(temp, c_DataAlignment);
}
else
{
m_size = temp;
}
return pRetValue;
}
HRESULT CDataBlock::AddData(const void *pvNewData, UINT bufferSize, CDataBlock **ppBlock)
{
HRESULT hr = S_OK;
UINT bytesToCopy;
const BYTE *pNewData = (const BYTE*) pvNewData;
if (m_maxSize == 0)
{
// This is a brand new DataBlock, fill it up
m_maxSize = max(8192, bufferSize);
VN( m_pData = NEW BYTE[m_maxSize] );
}
D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
bytesToCopy = min(m_maxSize - m_size, bufferSize);
memcpy(m_pData + m_size, pNewData, bytesToCopy);
pNewData += bytesToCopy;
if (m_IsAligned)
{
D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
}
else
{
m_size += bytesToCopy;
}
bufferSize -= bytesToCopy;
*ppBlock = this;
if (bufferSize != 0)
{
D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
// Couldn't fit all data into this block, spill over into next
VN( m_pNext = NEW CDataBlock() );
if (m_IsAligned)
{
m_pNext->EnableAlignment();
}
VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
}
lExit:
return hr;
}
// Returns FALSE if this shader has interface dependencies which are nullptr (SetShader will fail).
D3DX11INLINE BOOL CEffect::ValidateShaderBlock( SShaderBlock* pBlock )
{
if( !pBlock->IsValid )
return FALSE;
if( pBlock->InterfaceDepCount > 0 )
{
D3DXASSERT( pBlock->InterfaceDepCount == 1 );
for( UINT i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
{
SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
D3DXASSERT( pInterfaceDep != nullptr );
if( pInterfaceDep->pClassInstance == nullptr )
{
return FALSE;
}
}
}
return TRUE;
}
// Returns TRUE if the shader uses global interfaces (since these interfaces can be updated through SetClassInstance)
D3DX11INLINE BOOL SPassBlock::CheckShaderDependencies( SShaderBlock* pBlock )
{
if( pBlock->InterfaceDepCount > 0 )
{
D3DXASSERT( pBlock->InterfaceDepCount == 1 );
for( UINT i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
{
SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
if( pInterfaceDep > pEffect->m_pInterfaces && pInterfaceDep < (pEffect->m_pInterfaces + pEffect->m_InterfaceCount) )
{
// This is a global interface pointer (as opposed to an SInterface created in a BindInterface call
return TRUE;
}
}
}
return FALSE;
}
HRESULT CDataBlockStore::AddString(LPCSTR pString, UINT *pOffset)
{
size_t strSize = strlen(pString) + 1;
D3DXASSERT( strSize <= 0xffffffff );
return AddData(pString, (UINT)strSize, pOffset);
}
// Set all state defined in the pass
void CEffect::ApplyPassBlock(SPassBlock *pBlock)
{
pBlock->ApplyPassAssignments();
if (nullptr != pBlock->BackingStore.pBlendBlock)
{
ApplyRenderStateBlock(pBlock->BackingStore.pBlendBlock);
#ifdef FXDEBUG
if( !pBlock->BackingStore.pBlendBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid BlendState." );
#endif
pBlock->BackingStore.pBlendState = pBlock->BackingStore.pBlendBlock->pBlendObject;
m_pContext->OMSetBlendState(pBlock->BackingStore.pBlendState,
pBlock->BackingStore.BlendFactor,
pBlock->BackingStore.SampleMask);
}
if (nullptr != pBlock->BackingStore.pDepthStencilBlock)
{
ApplyRenderStateBlock(pBlock->BackingStore.pDepthStencilBlock);
#ifdef FXDEBUG
if( !pBlock->BackingStore.pDepthStencilBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid DepthStencilState." );
#endif
pBlock->BackingStore.pDepthStencilState = pBlock->BackingStore.pDepthStencilBlock->pDSObject;
m_pContext->OMSetDepthStencilState(pBlock->BackingStore.pDepthStencilState,
pBlock->BackingStore.StencilRef);
}
if (nullptr != pBlock->BackingStore.pRasterizerBlock)
{
ApplyRenderStateBlock(pBlock->BackingStore.pRasterizerBlock);
#ifdef FXDEBUG
if( !pBlock->BackingStore.pRasterizerBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid RasterizerState." );
#endif
m_pContext->RSSetState(pBlock->BackingStore.pRasterizerBlock->pRasterizerObject);
}
if (nullptr != pBlock->BackingStore.pRenderTargetViews[0])
{
// Grab all render targets
ID3D11RenderTargetView *pRTV[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
D3DXASSERT(pBlock->BackingStore.RenderTargetViewCount <= D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT);
__analysis_assume(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT >= pBlock->BackingStore.RenderTargetViewCount);
for (UINT i=0; i<pBlock->BackingStore.RenderTargetViewCount; i++)
{
pRTV[i] = pBlock->BackingStore.pRenderTargetViews[i]->pRenderTargetView;
}
// This call could be combined with the call to set PS UAVs if both exist in the pass
m_pContext->OMSetRenderTargetsAndUnorderedAccessViews( pBlock->BackingStore.RenderTargetViewCount, pRTV, pBlock->BackingStore.pDepthStencilView->pDepthStencilView, 7, D3D11_KEEP_UNORDERED_ACCESS_VIEWS, nullptr, nullptr );
}
if (nullptr != pBlock->BackingStore.pVertexShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pVertexShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid vertex shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pVertexShaderBlock);
}
if (nullptr != pBlock->BackingStore.pPixelShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pPixelShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid pixel shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pPixelShaderBlock);
}
if (nullptr != pBlock->BackingStore.pGeometryShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pGeometryShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid geometry shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pGeometryShaderBlock);
}
else
{
m_pContext->GSSetShader(nullptr,nullptr,0);
}
if (nullptr != pBlock->BackingStore.pHullShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pHullShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid hull shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pHullShaderBlock);
}
else
{
m_pContext->HSSetShader(nullptr,nullptr,0);
}
if (nullptr != pBlock->BackingStore.pDomainShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pDomainShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid domain shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pDomainShaderBlock);
}
else
{
m_pContext->DSSetShader(nullptr,nullptr,0);
}
if (nullptr != pBlock->BackingStore.pComputeShaderBlock)
{
#ifdef FXDEBUG
if( !pBlock->BackingStore.pComputeShaderBlock->IsValid )
DPF( 0, "Pass::Apply - warning: applying invalid compute shader." );
#endif
ApplyShaderBlock(pBlock->BackingStore.pComputeShaderBlock);
}
else
{
m_pContext->CSSetShader(nullptr,nullptr,0);
}
}
// Returns TRUE if the assignment was changed
BOOL CEffect::EvaluateAssignment(SAssignment *pAssignment)
{
BOOL bNeedUpdate = FALSE;
SGlobalVariable *pVarDep0, *pVarDep1;
switch (pAssignment->AssignmentType)
{
case ERAT_NumericVariable:
D3DXASSERT(pAssignment->DependencyCount == 1);
if (pAssignment->pDependencies[0].pVariable->LastModifiedTime >= pAssignment->LastRecomputedTime)
{
dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
bNeedUpdate = TRUE;
}
break;
case ERAT_NumericVariableIndex:
D3DXASSERT(pAssignment->DependencyCount == 2);
pVarDep0 = pAssignment->pDependencies[0].pVariable;
pVarDep1 = pAssignment->pDependencies[1].pVariable;
if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
{
m_FXLIndex = *pVarDep0->Data.pNumericDword;
ValidateIndex(pVarDep1->pType->Elements);
// Array index variable is dirty, update the pointer
pAssignment->Source.pNumeric = pVarDep1->Data.pNumeric + pVarDep1->pType->Stride * m_FXLIndex;
// Copy the new data
dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
bNeedUpdate = TRUE;
}
else if (pVarDep1->LastModifiedTime >= pAssignment->LastRecomputedTime)
{
// Only the array variable is dirty, copy the new data
dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
bNeedUpdate = TRUE;
}
break;
case ERAT_ObjectVariableIndex:
D3DXASSERT(pAssignment->DependencyCount == 1);
pVarDep0 = pAssignment->pDependencies[0].pVariable;
if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
{
m_FXLIndex = *pVarDep0->Data.pNumericDword;
ValidateIndex(pAssignment->MaxElements);
// Array index variable is dirty, update the destination pointer
*((void **)pAssignment->Destination.pGeneric) = pAssignment->Source.pNumeric +
pAssignment->DataSize * m_FXLIndex;
bNeedUpdate = TRUE;
}
break;
default:
//case ERAT_Constant: -- These are consumed and discarded
//case ERAT_ObjectVariable: -- These are consumed and discarded
//case ERAT_ObjectConstIndex: -- These are consumed and discarded
//case ERAT_ObjectInlineShader: -- These are consumed and discarded
//case ERAT_NumericConstIndex: -- ERAT_NumericVariable should be generated instead
D3DXASSERT(0);
break;
}
// Mark the assignment as not dirty
pAssignment->LastRecomputedTime = m_LocalTimer;
return bNeedUpdate;
}
// Returns TRUE if the block D3D data was recreated
BOOL CEffect::ApplyRenderStateBlock(SBaseBlock *pBlock)
{
if( pBlock->IsUserManaged )
{
return FALSE;
}
BOOL bRecreate = pBlock->ApplyAssignments(this);
if (bRecreate)
{
switch (pBlock->BlockType)
{
case EBT_Sampler:
{
SSamplerBlock *pSBlock = pBlock->AsSampler();
D3DXASSERT(nullptr != pSBlock->pD3DObject);
pSBlock->pD3DObject->Release();
m_pDevice->CreateSamplerState( &pSBlock->BackingStore.SamplerDesc, &pSBlock->pD3DObject );
}
break;
case EBT_DepthStencil:
{
SDepthStencilBlock *pDSBlock = pBlock->AsDepthStencil();
D3DXASSERT(nullptr != pDSBlock->pDSObject);
SAFE_RELEASE( pDSBlock->pDSObject );
if( SUCCEEDED( m_pDevice->CreateDepthStencilState( &pDSBlock->BackingStore, &pDSBlock->pDSObject ) ) )
pDSBlock->IsValid = TRUE;
else
pDSBlock->IsValid = FALSE;
}
break;
case EBT_Blend:
{
SBlendBlock *pBBlock = pBlock->AsBlend();
D3DXASSERT(nullptr != pBBlock->pBlendObject);
SAFE_RELEASE( pBBlock->pBlendObject );
if( SUCCEEDED( m_pDevice->CreateBlendState( &pBBlock->BackingStore, &pBBlock->pBlendObject ) ) )
pBBlock->IsValid = TRUE;
else
pBBlock->IsValid = FALSE;
}
break;
case EBT_Rasterizer:
{
SRasterizerBlock *pRBlock = pBlock->AsRasterizer();
D3DXASSERT(nullptr != pRBlock->pRasterizerObject);
SAFE_RELEASE( pRBlock->pRasterizerObject );
if( SUCCEEDED( m_pDevice->CreateRasterizerState( &pRBlock->BackingStore, &pRBlock->pRasterizerObject ) ) )
pRBlock->IsValid = TRUE;
else
pRBlock->IsValid = FALSE;
}
break;
default:
D3DXASSERT(0);
}
}
return bRecreate;
}
// Set the shader and dependent state (SRVs, samplers, UAVs, interfaces)
void CEffect::ApplyShaderBlock(SShaderBlock *pBlock)
{
UINT i;
SD3DShaderVTable *pVT = pBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = pBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = pBlock->pCBDeps + pBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
(m_pContext->*(pVT->pSetConstantBuffers))(pCBDep->StartIndex, pCBDep->Count, pCBDep->ppD3DObjects);
}
// Next, apply samplers
SShaderSamplerDependency *pSampDep = pBlock->pSampDeps;
SShaderSamplerDependency *pLastSampDep = pBlock->pSampDeps + pBlock->SampDepCount;
for (; pSampDep<pLastSampDep; pSampDep++)
{
D3DXASSERT(pSampDep->ppFXPointers);
for (i=0; i<pSampDep->Count; i++)
{
if ( ApplyRenderStateBlock(pSampDep->ppFXPointers[i]) )
{
// If the sampler was updated, its pointer will have changed
pSampDep->ppD3DObjects[i] = pSampDep->ppFXPointers[i]->pD3DObject;
}
}
(m_pContext->*(pVT->pSetSamplers))(pSampDep->StartIndex, pSampDep->Count, pSampDep->ppD3DObjects);
}
// TBuffers are funny:
// We keep two references to them. One is in as a standard texture dep, and that gets used for all sets
// The other is as a part of the TBufferDeps array, which tells us to rebuild the matching CBs.
// These two refs could be rolled into one, but then we would have to predicate on each CB or each texture.
SConstantBuffer **ppTB = pBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + pBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = pBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = pBlock->pResourceDeps + pBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
// Set the UAVs
// UAV ranges were combined in EffectLoad. This code remains unchanged, however, so that ranges can be easily split
D3DXASSERT( pBlock->UAVDepCount < 2 );
//LOG ("Start OMSet Targets");
if( pBlock->UAVDepCount > 0 )
{
if (SUnorderedAccessViewDependency *pUAVDep = pBlock->pUAVDeps)
{
D3DXASSERT(pUAVDep->ppFXPointers);
for (i=0; i<pUAVDep->Count; i++)
{
pUAVDep->ppD3DObjects[i] = pUAVDep->ppFXPointers[i]->pUnorderedAccessView;
}
if( EOT_ComputeShader5 == pBlock->GetShaderType() )
{
//LOG ("OMSet Targets 1");
m_pContext->CSSetUnorderedAccessViews( pUAVDep->StartIndex, pUAVDep->Count, pUAVDep->ppD3DObjects, g_pNegativeOnes );
//LOG ("OMSet Targets 3");
}
else
{
// mdavidson ... change
//LOG ("OMSet Targets 2");
// This call could be combined with the call to set render targets if both exist in the pass
m_pContext->OMSetRenderTargetsAndUnorderedAccessViews( D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL, nullptr, nullptr, pUAVDep->StartIndex, pUAVDep->Count, pUAVDep->ppD3DObjects, g_pNegativeOnes );
// LOG ("OMSet Targets 4");
}
}
}
//LOG ("Finished OMSet Targets");
// Update Interface dependencies
UINT Interfaces = 0;
ID3D11ClassInstance** ppClassInstances = nullptr;
D3DXASSERT( pBlock->InterfaceDepCount < 2 );
if( pBlock->InterfaceDepCount > 0 )
{
SInterfaceDependency *pInterfaceDep = pBlock->pInterfaceDeps;
D3DXASSERT(pInterfaceDep->ppFXPointers);
ppClassInstances = pInterfaceDep->ppD3DObjects;
Interfaces = pInterfaceDep->Count;
for (i=0; i<pInterfaceDep->Count; i++)
{
SClassInstanceGlobalVariable* pCI = pInterfaceDep->ppFXPointers[i]->pClassInstance;
if( pCI )
{
D3DXASSERT( pCI->pMemberData != nullptr );
pInterfaceDep->ppD3DObjects[i] = pCI->pMemberData->Data.pD3DClassInstance;
}
else
{
pInterfaceDep->ppD3DObjects[i] = nullptr;
}
}
}
// Now set the shader
(m_pContext->*(pVT->pSetShader))(pBlock->pD3DObject, ppClassInstances, Interfaces);
}
void
CEffect::CommitChanges( SPassBlock *pBlock )
{
// update vertex shader
if (pBlock->BackingStore.pVertexShaderBlock)
{
SShaderBlock* shaderBlock = pBlock->BackingStore.pVertexShaderBlock;
UINT i;
SD3DShaderVTable *pVT = shaderBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = shaderBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = shaderBlock->pCBDeps + shaderBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
}
SConstantBuffer **ppTB = shaderBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + shaderBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = shaderBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = shaderBlock->pResourceDeps + shaderBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
}
// update pixel shader
if (pBlock->BackingStore.pPixelShaderBlock)
{
SShaderBlock* shaderBlock = pBlock->BackingStore.pPixelShaderBlock;
UINT i;
SD3DShaderVTable *pVT = shaderBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = shaderBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = shaderBlock->pCBDeps + shaderBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
}
SConstantBuffer **ppTB = shaderBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + shaderBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = shaderBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = shaderBlock->pResourceDeps + shaderBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
}
// update geometry shader
if (pBlock->BackingStore.pGeometryShaderBlock)
{
SShaderBlock* shaderBlock = pBlock->BackingStore.pGeometryShaderBlock;
UINT i;
SD3DShaderVTable *pVT = shaderBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = shaderBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = shaderBlock->pCBDeps + shaderBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
}
SConstantBuffer **ppTB = shaderBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + shaderBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = shaderBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = shaderBlock->pResourceDeps + shaderBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
}
// update hull shader
if (pBlock->BackingStore.pHullShaderBlock)
{
SShaderBlock* shaderBlock = pBlock->BackingStore.pHullShaderBlock;
UINT i;
SD3DShaderVTable *pVT = shaderBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = shaderBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = shaderBlock->pCBDeps + shaderBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
}
SConstantBuffer **ppTB = shaderBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + shaderBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = shaderBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = shaderBlock->pResourceDeps + shaderBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
}
// update domain shader
if (pBlock->BackingStore.pDomainShaderBlock)
{
SShaderBlock* shaderBlock = pBlock->BackingStore.pDomainShaderBlock;
UINT i;
SD3DShaderVTable *pVT = shaderBlock->pVT;
// Apply constant buffers first (tbuffers are done later)
SShaderCBDependency *pCBDep = shaderBlock->pCBDeps;
SShaderCBDependency *pLastCBDep = shaderBlock->pCBDeps + shaderBlock->CBDepCount;
for (; pCBDep<pLastCBDep; pCBDep++)
{
D3DXASSERT(pCBDep->ppFXPointers);
for (i = 0; i < pCBDep->Count; ++ i)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
}
}
SConstantBuffer **ppTB = shaderBlock->ppTbufDeps;
SConstantBuffer **ppLastTB = ppTB + shaderBlock->TBufferDepCount;
for (; ppTB<ppLastTB; ppTB++)
{
CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
}
// Set the textures
SShaderResourceDependency *pResourceDep = shaderBlock->pResourceDeps;
SShaderResourceDependency *pLastResourceDep = shaderBlock->pResourceDeps + shaderBlock->ResourceDepCount;
for (; pResourceDep<pLastResourceDep; pResourceDep++)
{
D3DXASSERT(pResourceDep->ppFXPointers);
for (i=0; i<pResourceDep->Count; i++)
{
pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
}
(m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
}
}
}
