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