+++ /dev/null
-//////////////////////////////////////////////////////////////////////////////\r
-//\r
-// Copyright (C) Microsoft Corporation. All Rights Reserved.\r
-//\r
-// File: EffectLoad.cpp\r
-// Content: D3DX11 Effects file loading code\r
-//\r
-//////////////////////////////////////////////////////////////////////////////\r
-\r
-#include "pchfx.h"\r
-\r
-#include <EffectStates11.h>\r
-\r
-#define PRIVATENEW new(m_BulkHeap)\r
-\r
-namespace D3DX11Effects\r
-{\r
-\r
-LPCSTR g_szEffectLoadArea = "D3D11EffectLoader";\r
-\r
-SRasterizerBlock g_NullRasterizer;\r
-SDepthStencilBlock g_NullDepthStencil;\r
-SBlendBlock g_NullBlend;\r
-SShaderResource g_NullTexture;\r
-SInterface g_NullInterface;\r
-SUnorderedAccessView g_NullUnorderedAccessView;\r
-SRenderTargetView g_NullRenderTargetView;\r
-SDepthStencilView g_NullDepthStencilView;\r
-\r
-// these VTables must be setup in the proper order:\r
-// 1) SetShader\r
-// 2) SetConstantBuffers\r
-// 3) SetSamplers\r
-// 4) SetShaderResources\r
-// 5) CreateShader\r
-SD3DShaderVTable g_vtPS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::PSSetShader,\r
- &ID3D11DeviceContext::PSSetConstantBuffers,\r
- &ID3D11DeviceContext::PSSetSamplers,\r
- &ID3D11DeviceContext::PSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreatePixelShader\r
-};\r
-\r
-SD3DShaderVTable g_vtVS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::VSSetShader,\r
- &ID3D11DeviceContext::VSSetConstantBuffers,\r
- &ID3D11DeviceContext::VSSetSamplers,\r
- &ID3D11DeviceContext::VSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateVertexShader\r
-};\r
-\r
-SD3DShaderVTable g_vtGS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::GSSetShader,\r
- &ID3D11DeviceContext::GSSetConstantBuffers,\r
- &ID3D11DeviceContext::GSSetSamplers,\r
- &ID3D11DeviceContext::GSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateGeometryShader\r
-};\r
-\r
-SD3DShaderVTable g_vtHS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::HSSetShader,\r
- &ID3D11DeviceContext::HSSetConstantBuffers,\r
- &ID3D11DeviceContext::HSSetSamplers,\r
- &ID3D11DeviceContext::HSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateHullShader\r
-};\r
-\r
-SD3DShaderVTable g_vtDS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::DSSetShader,\r
- &ID3D11DeviceContext::DSSetConstantBuffers,\r
- &ID3D11DeviceContext::DSSetSamplers,\r
- &ID3D11DeviceContext::DSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateDomainShader\r
-};\r
-\r
-SD3DShaderVTable g_vtCS = {\r
- (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, UINT)) &ID3D11DeviceContext::CSSetShader,\r
- &ID3D11DeviceContext::CSSetConstantBuffers,\r
- &ID3D11DeviceContext::CSSetSamplers,\r
- &ID3D11DeviceContext::CSSetShaderResources,\r
- (HRESULT (__stdcall ID3D11Device::*)(const void *, SIZE_T, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateComputeShader\r
-};\r
-\r
-SShaderBlock g_NullVS(&g_vtVS);\r
-SShaderBlock g_NullGS(&g_vtGS);\r
-SShaderBlock g_NullPS(&g_vtPS);\r
-SShaderBlock g_NullHS(&g_vtHS);\r
-SShaderBlock g_NullDS(&g_vtDS);\r
-SShaderBlock g_NullCS(&g_vtCS);\r
-\r
-D3D10_SHADER_VARIABLE_TYPE GetSimpleParameterTypeFromObjectType(EObjectType ObjectType)\r
-{\r
- switch (ObjectType)\r
- {\r
- case EOT_String:\r
- return D3D10_SVT_STRING;\r
- case EOT_Blend:\r
- return D3D10_SVT_BLEND; \r
- case EOT_DepthStencil:\r
- return D3D10_SVT_DEPTHSTENCIL; \r
- case EOT_Rasterizer:\r
- return D3D10_SVT_RASTERIZER; \r
- case EOT_PixelShader:\r
- case EOT_PixelShader5:\r
- return D3D10_SVT_PIXELSHADER; \r
- case EOT_VertexShader:\r
- case EOT_VertexShader5:\r
- return D3D10_SVT_VERTEXSHADER; \r
- case EOT_GeometryShader:\r
- case EOT_GeometryShaderSO:\r
- case EOT_GeometryShader5:\r
- return D3D10_SVT_GEOMETRYSHADER; \r
- case EOT_HullShader5:\r
- return D3D11_SVT_HULLSHADER; \r
- case EOT_DomainShader5:\r
- return D3D11_SVT_DOMAINSHADER; \r
- case EOT_ComputeShader5:\r
- return D3D11_SVT_COMPUTESHADER; \r
- case EOT_RenderTargetView:\r
- return D3D10_SVT_RENDERTARGETVIEW;\r
- case EOT_DepthStencilView:\r
- return D3D10_SVT_DEPTHSTENCILVIEW;\r
- case EOT_Texture:\r
- case EOT_Texture1D:\r
- case EOT_Texture1DArray:\r
- case EOT_Texture2D:\r
- case EOT_Texture2DArray:\r
- case EOT_Texture2DMS:\r
- case EOT_Texture2DMSArray:\r
- case EOT_Texture3D:\r
- case EOT_TextureCube:\r
- case EOT_TextureCubeArray:\r
- return D3D10_SVT_TEXTURE;\r
- case EOT_Buffer:\r
- return D3D10_SVT_BUFFER; \r
- case EOT_Sampler:\r
- return D3D10_SVT_SAMPLER;\r
- case EOT_ByteAddressBuffer:\r
- return D3D11_SVT_BYTEADDRESS_BUFFER;\r
- case EOT_StructuredBuffer:\r
- return D3D11_SVT_STRUCTURED_BUFFER;\r
- case EOT_RWTexture1D:\r
- return D3D11_SVT_RWTEXTURE1D;\r
- case EOT_RWTexture1DArray:\r
- return D3D11_SVT_RWTEXTURE1DARRAY;\r
- case EOT_RWTexture2D:\r
- return D3D11_SVT_RWTEXTURE2D;\r
- case EOT_RWTexture2DArray:\r
- return D3D11_SVT_RWTEXTURE2DARRAY;\r
- case EOT_RWTexture3D:\r
- return D3D11_SVT_RWTEXTURE3D;\r
- case EOT_RWBuffer:\r
- return D3D11_SVT_RWBUFFER;\r
- case EOT_RWByteAddressBuffer:\r
- return D3D11_SVT_RWBYTEADDRESS_BUFFER;\r
- case EOT_RWStructuredBuffer:\r
- case EOT_RWStructuredBufferAlloc:\r
- case EOT_RWStructuredBufferConsume:\r
- return D3D11_SVT_RWSTRUCTURED_BUFFER;\r
- case EOT_AppendStructuredBuffer:\r
- return D3D11_SVT_APPEND_STRUCTURED_BUFFER;\r
- case EOT_ConsumeStructuredBuffer:\r
- return D3D11_SVT_CONSUME_STRUCTURED_BUFFER;\r
- default:\r
- D3DXASSERT(0);\r
- }\r
- return D3D10_SVT_VOID;\r
-}\r
-\r
-inline HRESULT VerifyPointer(UINT oBase, UINT dwSize, UINT dwMaxSize)\r
-{\r
- UINT dwAdd = oBase + dwSize;\r
- if (dwAdd < oBase || dwAdd > dwMaxSize)\r
- return E_FAIL;\r
- return S_OK;\r
-}\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// EffectHeap \r
-// A simple class which assists in adding data to a block of memory\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-CEffectHeap::CEffectHeap()\r
-{\r
- m_pData = NULL;\r
- m_dwSize = m_dwBufferSize = 0;\r
-}\r
-\r
-CEffectHeap::~CEffectHeap()\r
-{\r
- SAFE_DELETE_ARRAY(m_pData);\r
-}\r
-\r
-UINT CEffectHeap::GetSize()\r
-{\r
- return m_dwSize;\r
-}\r
-\r
-HRESULT CEffectHeap::ReserveMemory(UINT dwSize)\r
-{\r
- HRESULT hr = S_OK;\r
-\r
- D3DXASSERT(!m_pData);\r
- D3DXASSERT(dwSize == AlignToPowerOf2(dwSize, c_DataAlignment));\r
-\r
- m_dwBufferSize = dwSize;\r
-\r
- VN( m_pData = NEW BYTE[m_dwBufferSize] );\r
- \r
- // make sure that we have machine word alignment\r
- D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectHeap::AddString(const char *pString, __deref_out_z char **ppPointer)\r
-{\r
- size_t size = strlen(pString) + 1;\r
- D3DXASSERT( size <= 0xffffffff );\r
- return AddData(pString, (UINT)size, (void**) ppPointer);\r
-}\r
-\r
-// This data is forcibly aligned, so make sure you account for that in calculating heap size\r
-template <bool bCopyData>\r
-HRESULT CEffectHeap::AddDataInternal(const void *pData, UINT dwSize, void **ppPointer)\r
-{\r
- CCheckedDword chkFinalSize( m_dwSize );\r
- UINT finalSize;\r
- HRESULT hr = S_OK;\r
-\r
- chkFinalSize += dwSize;\r
- chkFinalSize += c_DataAlignment; // account for alignment\r
-\r
- VHD( chkFinalSize.GetValue(&finalSize), "Overflow while adding data to Effect heap." );\r
- \r
- // align original value\r
- finalSize = AlignToPowerOf2(finalSize - c_DataAlignment, c_DataAlignment);\r
- VBD( finalSize <= m_dwBufferSize, "Overflow adding data to Effect heap." );\r
-\r
- *ppPointer = m_pData + m_dwSize;\r
- D3DXASSERT(*ppPointer == AlignToPowerOf2(*ppPointer, c_DataAlignment));\r
-\r
- if( bCopyData )\r
- {\r
- memcpy(*ppPointer, pData, dwSize);\r
- }\r
- m_dwSize = finalSize;\r
-\r
-lExit:\r
- if (FAILED(hr))\r
- *ppPointer = NULL;\r
-\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectHeap::AddData(const void *pData, UINT dwSize, void **ppPointer)\r
-{\r
- return AddDataInternal<true>( pData, dwSize, ppPointer );\r
-}\r
-\r
-// Moves a string from the general heap to the private heap and modifies the pointer to\r
-// point to the new memory block.\r
-// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.\r
-// This data is forcibly aligned, so make sure you account for that in calculating heap size\r
-HRESULT CEffectHeap::MoveString(__deref_inout_z char **ppString)\r
-{\r
- HRESULT hr;\r
- char *pNewPointer;\r
-\r
- if (*ppString == NULL)\r
- return S_OK;\r
-\r
- hr = AddString(*ppString, &pNewPointer);\r
- *ppString = pNewPointer;\r
-\r
- return hr;\r
-}\r
-\r
-// Allocates space but does not move data\r
-// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.\r
-// This data is forcibly aligned, so make sure you account for that in calculating heap size\r
-HRESULT CEffectHeap::MoveEmptyDataBlock(void **ppData, UINT size)\r
-{\r
- HRESULT hr;\r
- void *pNewPointer;\r
-\r
- hr = AddDataInternal<false>(*ppData, size, &pNewPointer);\r
-\r
- *ppData = pNewPointer;\r
- if (size == 0)\r
- {\r
- // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this\r
- *ppData = NULL;\r
- }\r
-\r
- return hr;\r
-}\r
-\r
-// Moves an array of SInterfaceParameters from the general heap to the private heap and modifies the pointer to\r
-// point to the new memory block.\r
-// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.\r
-// This data is forcibly aligned, so make sure you account for that in calculating heap size\r
-HRESULT CEffectHeap::MoveInterfaceParameters(UINT InterfaceCount, __in_ecount(1) SShaderBlock::SInterfaceParameter **ppInterfaces)\r
-{\r
- HRESULT hr;\r
- SShaderBlock::SInterfaceParameter *pNewPointer;\r
-\r
- if (*ppInterfaces == NULL)\r
- return S_OK;\r
-\r
- VBD( InterfaceCount <= D3D11_SHADER_MAX_INTERFACES, "Internal loading error: InterfaceCount > D3D11_SHADER_MAX_INTERFACES." );\r
- VH( AddData(*ppInterfaces, InterfaceCount * sizeof(SShaderBlock::SInterfaceParameter), (void**)&pNewPointer) );\r
-\r
- for( UINT i=0; i < InterfaceCount; i++ )\r
- {\r
- VH( MoveString( &pNewPointer[i].pName ) );\r
- }\r
-\r
- *ppInterfaces = pNewPointer;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Moves data from the general heap to the private heap and modifies the pointer to\r
-// point to the new memory block \r
-// The general heap is freed as a whole, so we don't worry about leaking the given pointer.\r
-// This data is forcibly aligned, so make sure you account for that in calculating heap size\r
-HRESULT CEffectHeap::MoveData(void **ppData, UINT size)\r
-{\r
- HRESULT hr;\r
- void *pNewPointer;\r
-\r
- hr = AddData(*ppData, size, &pNewPointer);\r
- \r
- *ppData = pNewPointer;\r
- if (size == 0)\r
- {\r
- // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this\r
- *ppData = NULL;\r
- }\r
-\r
- return hr;\r
-}\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Load API \r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-HRESULT CEffect::LoadEffect(CONST void *pEffectBuffer, UINT cbEffectBuffer)\r
-{\r
- HRESULT hr = S_OK;\r
- CEffectLoader loader;\r
-\r
- if (!pEffectBuffer)\r
- {\r
- DPF(0, "%s: pEffectBuffer is NULL.", g_szEffectLoadArea);\r
- VH( E_INVALIDARG );\r
- }\r
- \r
- VH( loader.LoadEffect(this, pEffectBuffer, cbEffectBuffer) );\r
-\r
-lExit:\r
- if( FAILED( hr ) )\r
- {\r
- // Release here because m_pShaderBlocks may still be in loader.m_BulkHeap if loading failed before we reallocated the memory\r
- ReleaseShaderRefection();\r
- }\r
- return hr;\r
-}\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// CEffectLoader\r
-// A helper class which loads an effect\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-HRESULT CEffectLoader::GetUnstructuredDataBlock(UINT offset, UINT *pdwSize, void **ppData)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT *pBlockSize;\r
-\r
- VH( m_msUnstructured.ReadAtOffset(offset, sizeof(*pBlockSize), (void**) &pBlockSize ) );\r
- *pdwSize = *pBlockSize;\r
-\r
- VH( m_msUnstructured.Read(ppData, *pdwSize) );\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// position in buffer is lost on error\r
-//\r
-// This function should be used in 1:1 conjunction with CEffectHeap::MoveString;\r
-// that is, any string added to the reflection heap with this function\r
-// must be relocated with MoveString at some point later on.\r
-HRESULT CEffectLoader::GetStringAndAddToReflection(UINT offset, __out_ecount_full(1) char **ppString)\r
-{\r
- HRESULT hr = S_OK;\r
- LPCSTR pName;\r
- SIZE_T oldPos;\r
- \r
- if (offset == 0)\r
- {\r
- *ppString = NULL;\r
- goto lExit;\r
- }\r
-\r
- oldPos = m_msUnstructured.GetPosition();\r
-\r
- VH( m_msUnstructured.ReadAtOffset(offset, &pName) );\r
- m_ReflectionMemory += AlignToPowerOf2( (UINT)strlen(pName) + 1, c_DataAlignment);\r
- *ppString = const_cast<char*>(pName);\r
- \r
- m_msUnstructured.Seek(oldPos);\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// position in buffer is lost on error\r
-//\r
-// This function should be used in 1:1 conjunction with CEffectHeap::MoveInterfaceParameters;\r
-// that is, any array of parameters added to the reflection heap with this function\r
-// must be relocated with MoveInterfaceParameters at some point later on.\r
-HRESULT CEffectLoader::GetInterfaceParametersAndAddToReflection( UINT InterfaceCount, UINT offset, __out_ecount_full(1) SShaderBlock::SInterfaceParameter **ppInterfaces )\r
-{\r
- HRESULT hr = S_OK;\r
- SBinaryInterfaceInitializer* pInterfaceInitializer;\r
- SIZE_T oldPos;\r
-\r
- if (offset == 0)\r
- {\r
- *ppInterfaces = NULL;\r
- goto lExit;\r
- }\r
-\r
- oldPos = m_msUnstructured.GetPosition();\r
-\r
- VBD( InterfaceCount <= D3D11_SHADER_MAX_INTERFACES, "Internal loading error: InterfaceCount > D3D11_SHADER_MAX_INTERFACES." );\r
- m_ReflectionMemory += AlignToPowerOf2(InterfaceCount * sizeof(SShaderBlock::SInterfaceParameter), c_DataAlignment);\r
- D3DXASSERT( ppInterfaces );\r
- (*ppInterfaces) = PRIVATENEW SShaderBlock::SInterfaceParameter[InterfaceCount];\r
- VN( *ppInterfaces );\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(offset, sizeof(SBinaryInterfaceInitializer) * InterfaceCount, (void**)&pInterfaceInitializer),\r
- "Invalid pEffectBuffer: cannot read interface initializer." );\r
-\r
- for( UINT i=0; i < InterfaceCount; i++ )\r
- {\r
- (*ppInterfaces)[i].Index = pInterfaceInitializer[i].ArrayIndex;\r
- VHD( m_msUnstructured.ReadAtOffset(pInterfaceInitializer[i].oInstanceName, const_cast<LPCSTR*>(&(*ppInterfaces)[i].pName)),\r
- "Invalid pEffectBuffer: cannot read interface initializer." );\r
- m_ReflectionMemory += AlignToPowerOf2( (UINT)strlen((*ppInterfaces)[i].pName) + 1, c_DataAlignment);\r
- }\r
-\r
- m_msUnstructured.Seek(oldPos);\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupCBPointer(SConstantBuffer **ppCB)\r
-{\r
- HRESULT hr = S_OK;\r
- \r
- SIZE_T index = (SConstantBuffer*)*ppCB - m_pOldCBs;\r
- D3DXASSERT( index * sizeof(SConstantBuffer) == ((size_t)(SConstantBuffer*)*ppCB - (size_t)m_pOldCBs) );\r
- VBD( index < m_pEffect->m_CBCount, "Internal loading error: invalid constant buffer index." );\r
- *ppCB = (SConstantBuffer*)(m_pEffect->m_pCBs + index);\r
- \r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupShaderPointer(SShaderBlock **ppShaderBlock)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppShaderBlock != &g_NullVS && *ppShaderBlock != &g_NullGS && *ppShaderBlock != &g_NullPS &&\r
- *ppShaderBlock != &g_NullHS && *ppShaderBlock != &g_NullDS && *ppShaderBlock != &g_NullCS && \r
- *ppShaderBlock != NULL)\r
- {\r
- SIZE_T index = *ppShaderBlock - m_pOldShaders;\r
- D3DXASSERT( index * sizeof(SShaderBlock) == ((size_t)*ppShaderBlock - (size_t)m_pOldShaders) );\r
- VBD( index < m_pEffect->m_ShaderBlockCount, "Internal loading error: invalid shader index." );\r
- *ppShaderBlock = m_pEffect->m_pShaderBlocks + index;\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupDSPointer(SDepthStencilBlock **ppDSBlock)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppDSBlock != &g_NullDepthStencil && *ppDSBlock != NULL)\r
- {\r
- SIZE_T index = *ppDSBlock - m_pOldDS;\r
- D3DXASSERT( index * sizeof(SDepthStencilBlock) == ((size_t)*ppDSBlock - (size_t)m_pOldDS) );\r
- VBD( index < m_pEffect->m_DepthStencilBlockCount, "Internal loading error: invalid depth-stencil state index." );\r
- *ppDSBlock = m_pEffect->m_pDepthStencilBlocks + index;\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupABPointer(SBlendBlock **ppABBlock)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppABBlock != &g_NullBlend && *ppABBlock != NULL)\r
- {\r
- SIZE_T index = *ppABBlock - m_pOldAB;\r
- D3DXASSERT( index * sizeof(SBlendBlock) == ((size_t)*ppABBlock - (size_t)m_pOldAB) );\r
- VBD( index < m_pEffect->m_BlendBlockCount, "Internal loading error: invalid blend state index." );\r
- *ppABBlock = m_pEffect->m_pBlendBlocks + index;\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupRSPointer(SRasterizerBlock **ppRSBlock)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppRSBlock != &g_NullRasterizer && *ppRSBlock != NULL)\r
- {\r
- SIZE_T index = *ppRSBlock - m_pOldRS;\r
- D3DXASSERT( index * sizeof(SRasterizerBlock) == ((size_t)*ppRSBlock - (size_t)m_pOldRS) );\r
- VBD( index < m_pEffect->m_RasterizerBlockCount, "Internal loading error: invalid rasterizer state index." );\r
- *ppRSBlock = m_pEffect->m_pRasterizerBlocks + index;\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupSamplerPointer(SSamplerBlock **ppSampler)\r
-{\r
- HRESULT hr = S_OK;\r
- SIZE_T index = *ppSampler - m_pOldSamplers;\r
- D3DXASSERT( index * sizeof(SSamplerBlock) == ((size_t)*ppSampler - (size_t)m_pOldSamplers) );\r
- VBD( index < m_pEffect->m_SamplerBlockCount, "Internal loading error: invalid sampler index." );\r
- *ppSampler = m_pEffect->m_pSamplerBlocks + index;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupInterfacePointer(SInterface **ppInterface, bool CheckBackgroundInterfaces)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppInterface != &g_NullInterface && *ppInterface != NULL)\r
- {\r
- SIZE_T index = *ppInterface - m_pOldInterfaces;\r
- if(index < m_OldInterfaceCount)\r
- {\r
- D3DXASSERT( index * sizeof(SInterface) == ((size_t)*ppInterface - (size_t)m_pOldInterfaces) );\r
- *ppInterface = m_pEffect->m_pInterfaces + index;\r
- }\r
- else\r
- {\r
- VBD( CheckBackgroundInterfaces, "Internal loading error: invalid interface pointer." );\r
- for( index=0; index < m_BackgroundInterfaces.GetSize(); index++ )\r
- {\r
- if( *ppInterface == m_BackgroundInterfaces[ (UINT)index ] )\r
- {\r
- // The interfaces m_BackgroundInterfaces were concatenated to the original ones in m_pEffect->m_pInterfaces\r
- *ppInterface = m_pEffect->m_pInterfaces + (m_OldInterfaceCount + index);\r
- break;\r
- }\r
- }\r
- VBD( index < m_BackgroundInterfaces.GetSize(), "Internal loading error: invalid interface pointer." );\r
- }\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupShaderResourcePointer(SShaderResource **ppResource)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppResource != &g_NullTexture && *ppResource != NULL)\r
- {\r
- SIZE_T index = *ppResource - m_pOldShaderResources;\r
- D3DXASSERT( index * sizeof(SShaderResource) == ((size_t)*ppResource - (size_t)m_pOldShaderResources) );\r
- \r
- // could be a TBuffer or a texture; better check first\r
- if (index < m_pEffect->m_ShaderResourceCount)\r
- {\r
- *ppResource = m_pEffect->m_pShaderResources + index;\r
- }\r
- else\r
- {\r
- // if this is a TBuffer, then the shader resource pointer\r
- // actually points into a SConstantBuffer's TBuffer field\r
- index = (SConstantBuffer*)*ppResource - (SConstantBuffer*)&m_pOldCBs->TBuffer;\r
- D3DXASSERT( index * sizeof(SConstantBuffer) == ((size_t)(SConstantBuffer*)*ppResource - (size_t)(SConstantBuffer*)&m_pOldCBs->TBuffer) );\r
- VBD( index < m_pEffect->m_CBCount, "Internal loading error: invalid SRV index." );\r
- *ppResource = &m_pEffect->m_pCBs[index].TBuffer;\r
- }\r
- }\r
- \r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupUnorderedAccessViewPointer(SUnorderedAccessView **ppUnorderedAccessView)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppUnorderedAccessView != &g_NullUnorderedAccessView && *ppUnorderedAccessView != NULL)\r
- {\r
- SIZE_T index = *ppUnorderedAccessView - m_pOldUnorderedAccessViews;\r
- D3DXASSERT( index * sizeof(SUnorderedAccessView) == ((size_t)*ppUnorderedAccessView - (size_t)m_pOldUnorderedAccessViews) );\r
-\r
- VBD( index < m_pEffect->m_UnorderedAccessViewCount, "Internal loading error: invalid UAV index." );\r
- *ppUnorderedAccessView = m_pEffect->m_pUnorderedAccessViews + index;\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupRenderTargetViewPointer(SRenderTargetView **ppRenderTargetView)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppRenderTargetView != &g_NullRenderTargetView && *ppRenderTargetView != NULL)\r
- {\r
- SIZE_T index = *ppRenderTargetView - m_pOldRenderTargetViews;\r
- D3DXASSERT( index * sizeof(SRenderTargetView) == ((size_t)*ppRenderTargetView - (size_t)m_pOldRenderTargetViews) );\r
- VBD( index < m_pEffect->m_RenderTargetViewCount, "Internal loading error: invalid RTV index." );\r
- *ppRenderTargetView = m_pEffect->m_pRenderTargetViews + index;\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupDepthStencilViewPointer(SDepthStencilView **ppDepthStencilView)\r
-{\r
- HRESULT hr = S_OK;\r
- if (*ppDepthStencilView != &g_NullDepthStencilView && *ppDepthStencilView != NULL)\r
- {\r
- SIZE_T index = *ppDepthStencilView - m_pOldDepthStencilViews;\r
- D3DXASSERT( index * sizeof(SDepthStencilView) == ((size_t)*ppDepthStencilView - (size_t)m_pOldDepthStencilViews) );\r
- VBD( index < m_pEffect->m_DepthStencilViewCount, "Internal loading error: invalid DSV index." );\r
- *ppDepthStencilView = m_pEffect->m_pDepthStencilViews + index;\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupStringPointer(SString **ppString)\r
-{\r
- HRESULT hr = S_OK;\r
- SIZE_T index = *ppString - m_pOldStrings;\r
- D3DXASSERT( index * sizeof(SString) == ((size_t)*ppString - (size_t)m_pOldStrings) );\r
- VBD(index < m_pEffect->m_StringCount, "Internal loading error: invalid string index." );\r
- *ppString = m_pEffect->m_pStrings + index;\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupMemberDataPointer(SMemberDataPointer **ppMemberData)\r
-{\r
- HRESULT hr = S_OK;\r
- SIZE_T index = *ppMemberData - m_pOldMemberDataBlocks;\r
- D3DXASSERT( index * sizeof(SMemberDataPointer) == ((size_t)*ppMemberData - (size_t)m_pOldMemberDataBlocks) );\r
- VBD( index < m_pEffect->m_MemberDataCount, "Internal loading error: invalid member block index." );\r
- *ppMemberData = m_pEffect->m_pMemberDataBlocks + index;\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupVariablePointer(SGlobalVariable **ppVar)\r
-{\r
- HRESULT hr = S_OK;\r
- SIZE_T index = *ppVar - m_pOldVars;\r
-\r
- if( index < m_pEffect->m_VariableCount )\r
- {\r
- D3DXASSERT( index * sizeof(SGlobalVariable) == ((size_t)*ppVar - (size_t)m_pOldVars) );\r
- *ppVar = m_pEffect->m_pVariables + index;\r
- }\r
- else if( m_pvOldMemberInterfaces )\r
- {\r
- // When cloning, m_pvOldMemberInterfaces may be non-NULL, and *ppVar may point to a variable in it.\r
- const SIZE_T Members = m_pvOldMemberInterfaces->GetSize();\r
- for( index=0; index < Members; index++ )\r
- {\r
- if( (ID3DX11EffectVariable*)(*m_pvOldMemberInterfaces)[ (UINT)index] == (ID3DX11EffectVariable*)*ppVar )\r
- {\r
- break;\r
- }\r
- }\r
- VBD( index < Members, "Internal loading error: invalid member pointer." );\r
- *ppVar = (SGlobalVariable*)m_pEffect->m_pMemberInterfaces[ (UINT)index];\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::FixupGroupPointer(SGroup **ppGroup)\r
-{\r
- HRESULT hr = S_OK;\r
- if( *ppGroup != NULL )\r
- {\r
- SIZE_T index = *ppGroup - m_pOldGroups;\r
- D3DXASSERT( index * sizeof(SGroup) == ((size_t)*ppGroup - (size_t)m_pOldGroups) );\r
- VBD( index < m_pEffect->m_GroupCount, "Internal loading error: invalid group index." );\r
- *ppGroup = m_pEffect->m_pGroups + index;\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT GetEffectVersion( UINT effectFileTag, DWORD* pVersion )\r
-{\r
- D3DXASSERT( pVersion != NULL );\r
- if( !pVersion )\r
- return E_FAIL;\r
-\r
- for( UINT i = 0; i < NUM_EFFECT10_VERSIONS; i++ )\r
- {\r
- if( g_EffectVersions[i].m_Tag == effectFileTag )\r
- {\r
- *pVersion = g_EffectVersions[i].m_Version;\r
- return S_OK;\r
- }\r
- }\r
-\r
- return E_FAIL;\r
-}\r
-\r
-HRESULT CEffectLoader::LoadEffect(CEffect *pEffect, CONST void *pEffectBuffer, UINT cbEffectBuffer)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, varSize, cMemberDataBlocks;\r
- CCheckedDword chkVariables = 0;\r
-\r
- // Used for cloning\r
- m_pvOldMemberInterfaces = NULL;\r
-\r
- m_BulkHeap.EnableAlignment();\r
-\r
- D3DXASSERT(pEffect && pEffectBuffer);\r
- m_pEffect = pEffect;\r
- m_EffectMemory = m_ReflectionMemory = 0;\r
-\r
- VN( m_pEffect->m_pReflection = NEW CEffectReflection() );\r
- m_pReflection = m_pEffect->m_pReflection;\r
-\r
- // Begin effect load\r
- VN( m_pEffect->m_pTypePool = NEW CEffect::CTypeHashTable );\r
- VN( m_pEffect->m_pStringPool = NEW CEffect::CStringHashTable );\r
- VN( m_pEffect->m_pPooledHeap = NEW CDataBlockStore );\r
- m_pEffect->m_pPooledHeap->EnableAlignment();\r
- m_pEffect->m_pTypePool->SetPrivateHeap(m_pEffect->m_pPooledHeap);\r
- m_pEffect->m_pStringPool->SetPrivateHeap(m_pEffect->m_pPooledHeap);\r
-\r
- VH( m_pEffect->m_pTypePool->AutoGrow() );\r
- VH( m_pEffect->m_pStringPool->AutoGrow() );\r
-\r
- // Load from blob\r
- m_pData = (BYTE*)pEffectBuffer;\r
- m_dwBufferSize = cbEffectBuffer;\r
-\r
- VH( m_msStructured.SetData(m_pData, m_dwBufferSize) );\r
-\r
- // At this point, we assume that the blob is valid\r
- VHD( m_msStructured.Read((void**) &m_pHeader, sizeof(*m_pHeader)), "pEffectBuffer is too small." );\r
-\r
- // Verify the version\r
- if( FAILED( hr = GetEffectVersion( m_pHeader->Tag, &m_Version ) ) )\r
- {\r
- DPF(0, "Effect version is unrecognized. This runtime supports fx_5_0 to %s.", g_EffectVersions[NUM_EFFECT10_VERSIONS-1].m_pName );\r
- VH( hr );\r
- }\r
-\r
- if( m_pHeader->RequiresPool() || m_pHeader->Pool.cObjectVariables > 0 || m_pHeader->Pool.cNumericVariables > 0 )\r
- {\r
- DPF(0, "Effect11 does not support EffectPools." );\r
- VH( E_FAIL );\r
- }\r
-\r
- // Get shader block count\r
- VBD( m_pHeader->cInlineShaders <= m_pHeader->cTotalShaders, "Invalid Effect header: cInlineShaders > cTotalShaders." );\r
-\r
- // Make sure the counts for the Effect don't overflow\r
- chkVariables = m_pHeader->Effect.cObjectVariables;\r
- chkVariables += m_pHeader->Effect.cNumericVariables;\r
- chkVariables += m_pHeader->cInterfaceVariables;\r
- chkVariables *= sizeof(SGlobalVariable);\r
- VH( chkVariables.GetValue(&varSize) );\r
-\r
- // Make sure the counts for the SMemberDataPointers don't overflow\r
- chkVariables = m_pHeader->cClassInstanceElements;\r
- chkVariables += m_pHeader->cBlendStateBlocks;\r
- chkVariables += m_pHeader->cRasterizerStateBlocks;\r
- chkVariables += m_pHeader->cDepthStencilBlocks;\r
- chkVariables += m_pHeader->cSamplers;\r
- chkVariables += m_pHeader->Effect.cCBs; // Buffer (for CBuffers and TBuffers)\r
- chkVariables += m_pHeader->Effect.cCBs; // SRV (for TBuffers)\r
- VHD( chkVariables.GetValue(&cMemberDataBlocks), "Overflow: too many Effect variables." );\r
-\r
- // Allocate effect resources\r
- VN( m_pEffect->m_pCBs = PRIVATENEW SConstantBuffer[m_pHeader->Effect.cCBs] );\r
- VN( m_pEffect->m_pDepthStencilBlocks = PRIVATENEW SDepthStencilBlock[m_pHeader->cDepthStencilBlocks] );\r
- VN( m_pEffect->m_pRasterizerBlocks = PRIVATENEW SRasterizerBlock[m_pHeader->cRasterizerStateBlocks] );\r
- VN( m_pEffect->m_pBlendBlocks = PRIVATENEW SBlendBlock[m_pHeader->cBlendStateBlocks] );\r
- VN( m_pEffect->m_pSamplerBlocks = PRIVATENEW SSamplerBlock[m_pHeader->cSamplers] );\r
- \r
- // we allocate raw bytes for variables because they are polymorphic types that need to be placement new'ed\r
- VN( m_pEffect->m_pVariables = (SGlobalVariable *)PRIVATENEW BYTE[varSize] );\r
- VN( m_pEffect->m_pAnonymousShaders = PRIVATENEW SAnonymousShader[m_pHeader->cInlineShaders] );\r
-\r
- VN( m_pEffect->m_pGroups = PRIVATENEW SGroup[m_pHeader->cGroups] );\r
- VN( m_pEffect->m_pShaderBlocks = PRIVATENEW SShaderBlock[m_pHeader->cTotalShaders] );\r
- VN( m_pEffect->m_pStrings = PRIVATENEW SString[m_pHeader->cStrings] );\r
- VN( m_pEffect->m_pShaderResources = PRIVATENEW SShaderResource[m_pHeader->cShaderResources] );\r
- VN( m_pEffect->m_pUnorderedAccessViews = PRIVATENEW SUnorderedAccessView[m_pHeader->cUnorderedAccessViews] );\r
- VN( m_pEffect->m_pInterfaces = PRIVATENEW SInterface[m_pHeader->cInterfaceVariableElements] );\r
- VN( m_pEffect->m_pMemberDataBlocks = PRIVATENEW SMemberDataPointer[cMemberDataBlocks] );\r
- VN( m_pEffect->m_pRenderTargetViews = PRIVATENEW SRenderTargetView[m_pHeader->cRenderTargetViews] );\r
- VN( m_pEffect->m_pDepthStencilViews = PRIVATENEW SDepthStencilView[m_pHeader->cDepthStencilViews] );\r
-\r
- UINT oStructured = m_pHeader->cbUnstructured + sizeof(SBinaryHeader5);\r
- VHD( m_msStructured.Seek(oStructured), "Invalid pEffectBuffer: Missing structured data block." );\r
- VH( m_msUnstructured.SetData(m_pData + sizeof(SBinaryHeader5), oStructured - sizeof(SBinaryHeader5)) );\r
-\r
- VH( LoadCBs() );\r
- VH( LoadObjectVariables() );\r
- VH( LoadInterfaceVariables() );\r
- VH( LoadGroups() );\r
-\r
- // Build shader dependencies\r
- for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)\r
- {\r
- VH( BuildShaderBlock(&m_pEffect->m_pShaderBlocks[i]) );\r
- }\r
- \r
- for( UINT iGroup=0; iGroup<m_pHeader->cGroups; iGroup++ )\r
- {\r
- SGroup *pGroup = &m_pEffect->m_pGroups[iGroup];\r
- pGroup->HasDependencies = FALSE;\r
-\r
- for( UINT iTechnique=0; iTechnique < pGroup->TechniqueCount; iTechnique++ )\r
- {\r
- STechnique* pTech = &pGroup->pTechniques[iTechnique];\r
- pTech->HasDependencies = FALSE;\r
-\r
- for( UINT iPass=0; iPass < pTech->PassCount; iPass++ )\r
- {\r
- SPassBlock *pPass = &pTech->pPasses[iPass];\r
-\r
- pTech->HasDependencies |= pPass->CheckDependencies();\r
- }\r
- pGroup->HasDependencies |= pTech->HasDependencies;\r
- }\r
- }\r
-\r
- VH( InitializeReflectionDataAndMoveStrings() );\r
- VH( ReallocateReflectionData() );\r
- VH( ReallocateEffectData() );\r
-\r
- VB( m_pReflection->m_Heap.GetSize() == m_ReflectionMemory );\r
- \r
- // Verify that all of the various block/variable types were loaded\r
- VBD( m_pEffect->m_VariableCount == (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables), "Internal loading error: mismatched variable count." );\r
- VBD( m_pEffect->m_ShaderBlockCount == m_pHeader->cTotalShaders, "Internal loading error: mismatched shader block count." );\r
- VBD( m_pEffect->m_AnonymousShaderCount == m_pHeader->cInlineShaders, "Internal loading error: mismatched anonymous variable count." );\r
- VBD( m_pEffect->m_ShaderResourceCount == m_pHeader->cShaderResources, "Internal loading error: mismatched SRV count." );\r
- VBD( m_pEffect->m_InterfaceCount == m_pHeader->cInterfaceVariableElements + m_BackgroundInterfaces.GetSize(), "Internal loading error: mismatched interface count." );\r
- VBD( m_pEffect->m_UnorderedAccessViewCount == m_pHeader->cUnorderedAccessViews, "Internal loading error: mismatched UAV count." );\r
- VBD( m_pEffect->m_MemberDataCount == cMemberDataBlocks, "Internal loading error: mismatched member data block count." );\r
- VBD( m_pEffect->m_RenderTargetViewCount == m_pHeader->cRenderTargetViews, "Internal loading error: mismatched RTV count." );\r
- VBD( m_pEffect->m_DepthStencilViewCount == m_pHeader->cDepthStencilViews, "Internal loading error: mismatched DSV count." );\r
- VBD( m_pEffect->m_DepthStencilBlockCount == m_pHeader->cDepthStencilBlocks, "Internal loading error: mismatched depth-stencil state count." );\r
- VBD( m_pEffect->m_BlendBlockCount == m_pHeader->cBlendStateBlocks, "Internal loading error: mismatched blend state count." );\r
- VBD( m_pEffect->m_RasterizerBlockCount == m_pHeader->cRasterizerStateBlocks, "Internal loading error: mismatched rasterizer state count." );\r
- VBD( m_pEffect->m_SamplerBlockCount == m_pHeader->cSamplers, "Internal loading error: mismatched sampler count." );\r
- VBD( m_pEffect->m_StringCount == m_pHeader->cStrings, "Internal loading error: mismatched string count." );\r
-\r
- // Uncomment if you really need this information\r
- // DPF(0, "Effect heap size: %d, reflection heap size: %d, allocations avoided: %d", m_EffectMemory, m_ReflectionMemory, m_BulkHeap.m_cAllocations);\r
- \r
-lExit:\r
- return hr;\r
-}\r
-\r
-// position in buffer is lost on error\r
-HRESULT CEffectLoader::LoadStringAndAddToPool(__out_ecount_full(1) char **ppString, UINT dwOffset)\r
-{\r
- HRESULT hr = S_OK;\r
- char *pName;\r
- UINT hash;\r
- SIZE_T oldPos;\r
- CEffect::CStringHashTable::CIterator iter;\r
- UINT len;\r
-\r
- if (dwOffset == 0)\r
- {\r
- *ppString = NULL;\r
- goto lExit;\r
- }\r
-\r
- oldPos = m_msUnstructured.GetPosition();\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(dwOffset, (LPCSTR *) &pName), "Invalid pEffectBuffer: cannot read string." );\r
- len = (UINT)strlen(pName);\r
- hash = ComputeHash((BYTE *)pName, len);\r
- if (FAILED(m_pEffect->m_pStringPool->FindValueWithHash(pName, hash, &iter)))\r
- {\r
- D3DXASSERT( m_pEffect->m_pPooledHeap != NULL );\r
- VN( (*ppString) = new(*m_pEffect->m_pPooledHeap) char[len + 1] );\r
- memcpy(*ppString, pName, len + 1);\r
- VHD( m_pEffect->m_pStringPool->AddValueWithHash(*ppString, hash), "Internal loading error: failed to add string to pool." );\r
- }\r
- else\r
- {\r
- *ppString = const_cast<LPSTR>(iter.GetData());\r
- }\r
-\r
- m_msUnstructured.Seek(oldPos);\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::LoadTypeAndAddToPool(SType **ppType, UINT dwOffset)\r
-{\r
- HRESULT hr = S_OK;\r
- SBinaryType *psType;\r
- SBinaryNumericType *pNumericType;\r
- EObjectType *pObjectType;\r
- UINT cMembers, iMember, cInterfaces;\r
- UINT oBaseClassType;\r
- SType temporaryType;\r
- CEffect::CTypeHashTable::CIterator iter;\r
- BYTE *pHashBuffer;\r
- UINT hash;\r
- SVariable *pTempMembers = NULL;\r
- \r
- m_HashBuffer.Empty();\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(dwOffset, sizeof(SBinaryType), (void**) &psType), "Invalid pEffectBuffer: cannot read type." );\r
- VHD( LoadStringAndAddToPool(&temporaryType.pTypeName, psType->oTypeName), "Invalid pEffectBuffer: cannot read type name." );\r
- temporaryType.VarType = psType->VarType;\r
- temporaryType.Elements = psType->Elements;\r
- temporaryType.TotalSize = psType->TotalSize;\r
- temporaryType.Stride = psType->Stride;\r
- temporaryType.PackedSize = psType->PackedSize;\r
-\r
- // sanity check elements, size, stride, etc.\r
- UINT cElements = max(1, temporaryType.Elements);\r
- VBD( cElements * temporaryType.Stride == AlignToPowerOf2(temporaryType.TotalSize, SType::c_RegisterSize), "Invalid pEffectBuffer: invalid type size." );\r
- VBD( temporaryType.Stride % SType::c_RegisterSize == 0, "Invalid pEffectBuffer: invalid type stride." );\r
- VBD( temporaryType.PackedSize <= temporaryType.TotalSize && temporaryType.PackedSize % cElements == 0, "Invalid pEffectBuffer: invalid type packed size." );\r
-\r
- switch(temporaryType.VarType)\r
- {\r
- case EVT_Object:\r
- VHD( m_msUnstructured.Read((void**) &pObjectType, sizeof(UINT)), "Invalid pEffectBuffer: cannot read object type." );\r
- temporaryType.ObjectType = *pObjectType;\r
- VBD( temporaryType.VarType > EOT_Invalid && temporaryType.VarType < EOT_Count, "Invalid pEffectBuffer: invalid object type." );\r
- \r
- VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) + \r
- sizeof(temporaryType.pTypeName) + sizeof(temporaryType.ObjectType)) );\r
- memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType)); \r
- pHashBuffer += sizeof(temporaryType.VarType);\r
- memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements)); \r
- pHashBuffer += sizeof(temporaryType.Elements);\r
- memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName)); \r
- pHashBuffer += sizeof(temporaryType.pTypeName);\r
- memcpy(pHashBuffer, &temporaryType.ObjectType, sizeof(temporaryType.ObjectType)); \r
- break;\r
-\r
- case EVT_Interface:\r
- temporaryType.InterfaceType = NULL; \r
-\r
- VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) + \r
- sizeof(temporaryType.pTypeName) + sizeof(temporaryType.ObjectType)) );\r
- memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType)); \r
- pHashBuffer += sizeof(temporaryType.VarType);\r
- memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements)); \r
- pHashBuffer += sizeof(temporaryType.Elements);\r
- memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName)); \r
- pHashBuffer += sizeof(temporaryType.pTypeName);\r
- memcpy(pHashBuffer, &temporaryType.ObjectType, sizeof(temporaryType.ObjectType)); \r
- break;\r
-\r
- case EVT_Numeric:\r
- VHD( m_msUnstructured.Read((void**) &pNumericType, sizeof(SBinaryNumericType)), "Invalid pEffectBuffer: cannot read numeric type." );\r
- temporaryType.NumericType = *pNumericType;\r
- VBD( temporaryType.NumericType.Rows >= 1 && temporaryType.NumericType.Rows <= 4 &&\r
- temporaryType.NumericType.Columns >= 1 && temporaryType.NumericType.Columns <= 4 &&\r
- temporaryType.NumericType.NumericLayout != ENL_Invalid && temporaryType.NumericType.NumericLayout < ENL_Count &&\r
- temporaryType.NumericType.ScalarType > EST_Invalid && temporaryType.NumericType.ScalarType < EST_Count,\r
- "Invalid pEffectBuffer: invalid numeric type.");\r
-\r
- if (temporaryType.NumericType.NumericLayout != ENL_Matrix)\r
- {\r
- VBD( temporaryType.NumericType.IsColumnMajor == FALSE, "Invalid pEffectBuffer: only matricies can be column major." );\r
- }\r
-\r
- VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) + \r
- sizeof(temporaryType.pTypeName) + sizeof(temporaryType.NumericType)) );\r
- memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType)); \r
- pHashBuffer += sizeof(temporaryType.VarType);\r
- memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements)); \r
- pHashBuffer += sizeof(temporaryType.Elements);\r
- memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName)); \r
- pHashBuffer += sizeof(temporaryType.pTypeName);\r
- memcpy(pHashBuffer, &temporaryType.NumericType, sizeof(temporaryType.NumericType)); \r
- break;\r
-\r
- case EVT_Struct:\r
- VHD( m_msUnstructured.Read(&cMembers), "Invalid pEffectBuffer: cannot read struct." );\r
-\r
- temporaryType.StructType.Members = cMembers;\r
-\r
- VN( pTempMembers = NEW SVariable[cMembers] );\r
- temporaryType.StructType.pMembers = pTempMembers;\r
- \r
- // read up all of the member descriptors at once\r
- SBinaryType::SBinaryMember *psMember;\r
- VHD( m_msUnstructured.Read((void**) &psMember, cMembers * sizeof(*psMember)), "Invalid pEffectBuffer: cannot read struct members." );\r
-\r
- {\r
- // Determine if this type implements an interface\r
- VHD( m_msUnstructured.Read(&oBaseClassType), "Invalid pEffectBuffer: cannot read base class type." );\r
- VHD( m_msUnstructured.Read(&cInterfaces), "Invalid pEffectBuffer: cannot read interfaces." );\r
- if( cInterfaces > 0 )\r
- {\r
- temporaryType.StructType.ImplementsInterface = 1;\r
- temporaryType.StructType.HasSuperClass = ( oBaseClassType > 0 ) ? 1 : 0;\r
- }\r
- else if( oBaseClassType > 0 )\r
- {\r
- // Get parent type and copy its ImplementsInterface\r
- SType* pBaseClassType;\r
- VH( LoadTypeAndAddToPool(&pBaseClassType, oBaseClassType) );\r
- temporaryType.StructType.ImplementsInterface = pBaseClassType->StructType.ImplementsInterface;\r
- temporaryType.StructType.HasSuperClass = 1;\r
- }\r
- // Read (and ignore) the interface types\r
- UINT *poInterface;\r
- VHD( m_msUnstructured.Read((void**) &poInterface, cInterfaces * sizeof(poInterface)), "Invalid pEffectBuffer: cannot read interface types." );\r
- }\r
-\r
- UINT totalSize;\r
- totalSize = 0;\r
- for (iMember=0; iMember<cMembers; iMember++)\r
- { \r
- SVariable *pMember;\r
- \r
- pMember = temporaryType.StructType.pMembers + iMember;\r
-\r
- VBD( psMember[iMember].Offset == totalSize || \r
- psMember[iMember].Offset == AlignToPowerOf2(totalSize, SType::c_RegisterSize),\r
- "Internal loading error: invalid member offset." );\r
-\r
- pMember->Data.Offset = psMember[iMember].Offset;\r
-\r
- VH( LoadTypeAndAddToPool(&pMember->pType, psMember[iMember].oType) );\r
- VH( LoadStringAndAddToPool(&pMember->pName, psMember[iMember].oName) );\r
- VH( LoadStringAndAddToPool(&pMember->pSemantic, psMember[iMember].oSemantic) );\r
- \r
- totalSize = psMember[iMember].Offset + pMember->pType->TotalSize;\r
- }\r
- VBD( AlignToPowerOf2(totalSize, SType::c_RegisterSize) == temporaryType.Stride, "Internal loading error: invlid type size." );\r
-\r
- VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) + \r
- sizeof(temporaryType.pTypeName) + sizeof(temporaryType.StructType.Members) + cMembers * sizeof(SVariable)) );\r
-\r
- memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType)); \r
- pHashBuffer += sizeof(temporaryType.VarType);\r
- memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements)); \r
- pHashBuffer += sizeof(temporaryType.Elements);\r
- memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName)); \r
- pHashBuffer += sizeof(temporaryType.pTypeName);\r
- memcpy(pHashBuffer, &temporaryType.StructType.Members, sizeof(temporaryType.StructType.Members)); \r
- pHashBuffer += sizeof(temporaryType.StructType.Members);\r
- memcpy(pHashBuffer, temporaryType.StructType.pMembers, cMembers * sizeof(SVariable));\r
- break;\r
-\r
- default:\r
- D3DXASSERT(0);\r
- VHD( E_FAIL, "Internal loading error: invalid variable type." );\r
- }\r
-\r
- hash = ComputeHash(&m_HashBuffer[0], m_HashBuffer.GetSize());\r
- if (FAILED(m_pEffect->m_pTypePool->FindValueWithHash(&temporaryType, hash, &iter)))\r
- {\r
- D3DXASSERT( m_pEffect->m_pPooledHeap != NULL );\r
-\r
- // allocate real member array, if necessary\r
- if (temporaryType.VarType == EVT_Struct)\r
- {\r
- VN( temporaryType.StructType.pMembers = new(*m_pEffect->m_pPooledHeap) SVariable[temporaryType.StructType.Members] );\r
- memcpy(temporaryType.StructType.pMembers, pTempMembers, temporaryType.StructType.Members * sizeof(SVariable));\r
- }\r
-\r
- // allocate real type\r
- VN( (*ppType) = new(*m_pEffect->m_pPooledHeap) SType );\r
- memcpy(*ppType, &temporaryType, sizeof(temporaryType));\r
- ZeroMemory(&temporaryType, sizeof(temporaryType));\r
- VH( m_pEffect->m_pTypePool->AddValueWithHash(*ppType, hash) );\r
- }\r
- else\r
- {\r
- *ppType = iter.GetData();\r
- }\r
-\r
-lExit:\r
- SAFE_DELETE_ARRAY(pTempMembers);\r
- return hr;\r
-}\r
-\r
-// Numeric data in annotations are tightly packed (unlike in CBs which follow D3D11 packing rules). This unpacks them.\r
-UINT CEffectLoader::UnpackData(BYTE *pDestData, BYTE *pSrcData, UINT PackedDataSize, SType *pType, UINT *pBytesRead)\r
-{\r
- UINT bytesRead = 0;\r
- UINT i, j, k;\r
- UINT registers, entries;\r
- HRESULT hr = S_OK;\r
- UINT elementsToCopy = max(pType->Elements, 1);\r
-\r
- switch (pType->VarType)\r
- {\r
- case EVT_Struct:\r
- for (i = 0; i < elementsToCopy; ++ i)\r
- {\r
- for (j = 0; j < pType->StructType.Members; ++ j)\r
- {\r
- UINT br;\r
- D3DXASSERT((UINT_PTR)pType->StructType.pMembers[j].pType == (UINT)(UINT_PTR)pType->StructType.pMembers[j].pType);\r
- D3DXASSERT(PackedDataSize > bytesRead); \r
-\r
- VH( UnpackData(pDestData + pType->StructType.pMembers[j].Data.Offset, \r
- pSrcData + bytesRead, PackedDataSize - bytesRead, \r
- pType->StructType.pMembers[j].pType, &br) );\r
- \r
- bytesRead += br;\r
- }\r
- pDestData += pType->Stride;\r
- }\r
- break;\r
-\r
- case EVT_Numeric:\r
- if (pType->NumericType.IsPackedArray)\r
- {\r
- // No support for packed arrays\r
- D3DXASSERT(0);\r
- VHD(E_FAIL, "Internal loading error: packed arrays are not supported." );\r
- }\r
- else\r
- {\r
- UINT bytesToCopy;\r
-\r
- if (pType->NumericType.IsColumnMajor)\r
- {\r
- registers = pType->NumericType.Columns;\r
- entries = pType->NumericType.Rows;\r
- bytesToCopy = entries * registers * SType::c_ScalarSize;\r
-\r
- for (i = 0; i < elementsToCopy; ++ i)\r
- {\r
- for (j = 0; j < registers; ++ j)\r
- {\r
- for (k = 0; k < entries; ++ k)\r
- {\r
- // type cast to an arbitrary scalar\r
- ((UINT*)pDestData)[k] = ((UINT*)pSrcData)[k * registers + j];\r
- }\r
- pDestData += SType::c_RegisterSize; // advance to next register\r
- }\r
- pSrcData += bytesToCopy;\r
- bytesRead += bytesToCopy;\r
- }\r
- }\r
- else\r
- {\r
- registers = pType->NumericType.Rows;\r
- entries = pType->NumericType.Columns;\r
- bytesToCopy = entries * SType::c_ScalarSize;\r
-\r
- for (i = 0; i < elementsToCopy; ++ i)\r
- {\r
- for (j = 0; j < registers; ++ j)\r
- {\r
- memcpy(pDestData, pSrcData, bytesToCopy);\r
-\r
- pDestData += SType::c_RegisterSize; // advance to next register\r
- pSrcData += bytesToCopy;\r
- bytesRead += bytesToCopy;\r
- }\r
- }\r
- }\r
- }\r
- break;\r
-\r
- default:\r
- // shouldn't be called on non-struct/numeric types\r
- D3DXASSERT(0);\r
- VHD(E_FAIL, "Internal loading error: UnpackData should not be called on non-struct, non-numeric types." );\r
- } \r
-\r
-lExit:\r
- *pBytesRead = bytesRead;\r
- return hr;\r
-}\r
-\r
-// Read info from the compiled blob and initialize a numeric variable\r
-HRESULT CEffectLoader::LoadNumericVariable(SConstantBuffer *pParentCB)\r
-{\r
- HRESULT hr = S_OK;\r
- SBinaryNumericVariable *psVar;\r
- SGlobalVariable *pVar;\r
- SType *pType;\r
- void *pDefaultValue;\r
-\r
- // Read variable info\r
- VHD( m_msStructured.Read((void**) &psVar, sizeof(*psVar)), "Invalid pEffectBuffer: cannot read numeric variable." );\r
- VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),\r
- "Internal loading error: invalid variable counts.");\r
- pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];\r
- \r
- // Get type\r
- VH( LoadTypeAndAddToPool(&pType, psVar->oType) );\r
- \r
- // Make sure the right polymorphic type is created\r
- VH( PlacementNewVariable(pVar, pType, FALSE) );\r
-\r
- if (psVar->Flags & D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)\r
- {\r
- pVar->ExplicitBindPoint = psVar->Offset;\r
- }\r
- else\r
- {\r
- pVar->ExplicitBindPoint = -1;\r
- }\r
-\r
- pVar->pEffect = m_pEffect;\r
- pVar->pType = pType;\r
- pVar->pCB = pParentCB;\r
- pVar->Data.pGeneric = pParentCB->pBackingStore + psVar->Offset;\r
- VBD( psVar->Offset + pVar->pType->TotalSize <= pVar->pCB->Size, "Invalid pEffectBuffer: invalid variable offset." );\r
-\r
- if (pType->VarType == EVT_Struct && pType->StructType.ImplementsInterface && !pParentCB->IsTBuffer)\r
- {\r
- pVar->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;\r
- m_pEffect->m_MemberDataCount += max(pType->Elements,1);\r
- }\r
-\r
- // Get name & semantic\r
- VHD( GetStringAndAddToReflection(psVar->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read variable name." );\r
- VHD( GetStringAndAddToReflection(psVar->oSemantic, &pVar->pSemantic), "Invalid pEffectBuffer: cannot read variable semantic." );\r
-\r
- // Ensure the variable fits in the CBuffer and doesn't overflow\r
- VBD( pType->TotalSize + psVar->Offset <= pParentCB->Size &&\r
- pType->TotalSize + psVar->Offset >= pType->TotalSize, "Invalid pEffectBuffer: variable does not fit in CB." );\r
-\r
- ZeroMemory(pVar->Data.pGeneric, pType->TotalSize);\r
-\r
- // Get default value\r
- if (0 != psVar->oDefaultValue)\r
- {\r
- UINT bytesUnpacked;\r
- VHD( m_msUnstructured.ReadAtOffset(psVar->oDefaultValue, pType->PackedSize, &pDefaultValue), "Invalid pEffectBuffer: cannot read default value." );\r
- VH( UnpackData((BYTE*) pVar->Data.pGeneric, (BYTE*) pDefaultValue, pType->PackedSize, pType, &bytesUnpacked) );\r
- VBD( bytesUnpacked == pType->PackedSize, "Invalid pEffectBuffer: invalid type packed size.");\r
- }\r
- \r
- // We need to use offsets until we fixup\r
- pVar->Data.Offset = psVar->Offset;\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );\r
-\r
- m_pEffect->m_VariableCount++;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// Read info from the compiled blob and initialize a constant buffer\r
-HRESULT CEffectLoader::LoadCBs()\r
-{\r
- HRESULT hr = S_OK;\r
- UINT iCB, iVar;\r
-\r
- for (iCB=0; iCB<m_pHeader->Effect.cCBs; iCB++)\r
- {\r
- SBinaryConstantBuffer *psCB;\r
- SConstantBuffer *pCB;\r
-\r
- VHD( m_msStructured.Read((void**) &psCB, sizeof(*psCB)), "Invalid pEffectBuffer: cannot read CB." );\r
- pCB = &m_pEffect->m_pCBs[iCB];\r
-\r
- VHD( GetStringAndAddToReflection(psCB->oName, &pCB->pName), "Invalid pEffectBuffer: cannot read CB name." );\r
-\r
- pCB->IsTBuffer = (psCB->Flags & SBinaryConstantBuffer::c_IsTBuffer) != 0 ? TRUE : FALSE;\r
- pCB->IsSingle = (psCB->Flags & SBinaryConstantBuffer::c_IsSingle) != 0 ? TRUE : FALSE;\r
- pCB->Size = psCB->Size;\r
- pCB->ExplicitBindPoint = psCB->ExplicitBindPoint;\r
- VBD( pCB->Size == AlignToPowerOf2(pCB->Size, SType::c_RegisterSize), "Invalid pEffectBuffer: CB size not a power of 2." );\r
- VN( pCB->pBackingStore = PRIVATENEW BYTE[pCB->Size] );\r
- \r
- pCB->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;\r
- m_pEffect->m_MemberDataCount += 2;\r
-\r
- // point this CB to variables that it owns\r
- pCB->VariableCount = psCB->cVariables;\r
- if (pCB->VariableCount > 0)\r
- {\r
- pCB->pVariables = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];\r
- }\r
- else\r
- {\r
- pCB->pVariables = NULL;\r
- }\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pCB->AnnotationCount, &pCB->pAnnotations) );\r
-\r
- for (iVar=0; iVar<psCB->cVariables; iVar++)\r
- {\r
- VH( LoadNumericVariable(pCB) );\r
- }\r
- }\r
-\r
- m_pEffect->m_CBCount = m_pHeader->Effect.cCBs;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// Used by LoadAssignment to initialize members on load\r
-HRESULT CEffectLoader::ExecuteConstantAssignment(SBinaryConstant *pConstant, void *pLHS, D3D10_SHADER_VARIABLE_TYPE lhsType)\r
-{\r
- HRESULT hr = S_OK;\r
-\r
- switch(pConstant->Type)\r
- {\r
- case EST_UInt:\r
- case EST_Int:\r
- case EST_Bool:\r
- switch(lhsType)\r
- {\r
- case D3D10_SVT_BOOL:\r
- case D3D10_SVT_INT:\r
- case D3D10_SVT_UINT:\r
- *(UINT*) pLHS = pConstant->iValue;\r
- break;\r
-\r
- case D3D10_SVT_UINT8:\r
- *(BYTE*) pLHS = (BYTE) pConstant->iValue;\r
- break;\r
-\r
- case D3D10_SVT_FLOAT:\r
- *(float*) pLHS = (float) pConstant->iValue;\r
- break;\r
-\r
- default:\r
- VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );\r
- }\r
- break;\r
-\r
- case EST_Float:\r
- switch(lhsType)\r
- {\r
- case D3D10_SVT_BOOL:\r
- case D3D10_SVT_INT:\r
- case D3D10_SVT_UINT:\r
- *(UINT*) pLHS = (UINT) pConstant->fValue;\r
- break;\r
-\r
- case D3D10_SVT_UINT8:\r
- *(BYTE*) pLHS = (BYTE) pConstant->fValue;\r
- break;\r
-\r
- case D3D10_SVT_FLOAT:\r
- *(float*) pLHS = pConstant->fValue;\r
- break;\r
-\r
- default:\r
- VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );\r
- }\r
- break;\r
-\r
- default:\r
- VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize a set of assignments\r
-HRESULT CEffectLoader::LoadAssignments( UINT Assignments, SAssignment **ppAssignments, BYTE *pBackingStore, UINT *pRTVAssignments, UINT *pFinalAssignments )\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j;\r
-\r
- SBinaryAssignment *psAssignments;\r
- UINT finalAssignments = 0; // the number of assignments worth keeping \r
- UINT renderTargetViewAssns = 0; // Number of render target view assns, used by passes since SetRTV is a vararg call\r
-\r
- *pFinalAssignments = 0;\r
- if (pRTVAssignments)\r
- *pRTVAssignments = 0;\r
-\r
- VHD( m_msStructured.Read((void**) &psAssignments, sizeof(*psAssignments) * Assignments), "Invalid pEffectBuffer: cannot read assignments." );\r
-\r
- // allocate enough room to store all of the assignments (even though some may go unused)\r
- VN( (*ppAssignments) = PRIVATENEW SAssignment[Assignments] )\r
- \r
- //\r
- // In this loop, we read assignments 1-by-1, keeping some and discarding others.\r
- // We write to the "next" assignment which is given by &(*ppAssignments)[finalAssignments];\r
- // if an assignment is worth keeping, we increment finalAssignments.\r
- // This means that if you want to keep an assignment, you must be careful to initialize\r
- // all members of SAssignment because old values from preceding discarded assignments might remain.\r
- //\r
- for (i = 0; i < Assignments; ++ i)\r
- {\r
- SGlobalVariable *pVarArray, *pVarIndex, *pVar;\r
- const char *pGlobalVarName;\r
- SAssignment *pAssignment = &(*ppAssignments)[finalAssignments];\r
- BYTE *pLHS;\r
-\r
- VBD( psAssignments[i].iState < NUM_STATES, "Invalid pEffectBuffer: invalid assignment state." );\r
- VBD( psAssignments[i].Index < g_lvGeneral[psAssignments[i].iState].m_Indices, "Invalid pEffectBuffer: invalid assignment index." );\r
-\r
- pAssignment->LhsType = g_lvGeneral[psAssignments[i].iState].m_LhsType;\r
-\r
- // Count RenderTargetView assignments\r
- if (pAssignment->LhsType == ELHS_RenderTargetView)\r
- renderTargetViewAssns++;\r
-\r
- switch (g_lvGeneral[psAssignments[i].iState].m_Type)\r
- {\r
- case D3D10_SVT_UINT8:\r
- D3DXASSERT(g_lvGeneral[psAssignments[i].iState].m_Cols == 1); // BYTE arrays not supported\r
- pAssignment->DataSize = sizeof(BYTE);\r
- // Store an offset for destination instead of a pointer so that it's easy to relocate it later\r
- \r
- break;\r
-\r
- case D3D10_SVT_BOOL:\r
- case D3D10_SVT_INT:\r
- case D3D10_SVT_UINT:\r
- case D3D10_SVT_FLOAT:\r
- pAssignment->DataSize = SType::c_ScalarSize * g_lvGeneral[psAssignments[i].iState].m_Cols;\r
- break;\r
-\r
- case D3D10_SVT_RASTERIZER:\r
- pAssignment->DataSize = sizeof(SRasterizerBlock);\r
- break;\r
-\r
- case D3D10_SVT_DEPTHSTENCIL:\r
- pAssignment->DataSize = sizeof(SDepthStencilBlock);\r
- break;\r
-\r
- case D3D10_SVT_BLEND:\r
- pAssignment->DataSize = sizeof(SBlendBlock);\r
- break;\r
-\r
- case D3D10_SVT_VERTEXSHADER:\r
- case D3D10_SVT_GEOMETRYSHADER:\r
- case D3D10_SVT_PIXELSHADER:\r
- case D3D11_SVT_HULLSHADER:\r
- case D3D11_SVT_DOMAINSHADER:\r
- case D3D11_SVT_COMPUTESHADER:\r
- pAssignment->DataSize = sizeof(SShaderBlock);\r
- break;\r
-\r
- case D3D10_SVT_TEXTURE:\r
- case D3D10_SVT_TEXTURE1D:\r
- case D3D10_SVT_TEXTURE2D:\r
- case D3D10_SVT_TEXTURE2DMS:\r
- case D3D10_SVT_TEXTURE3D:\r
- case D3D10_SVT_TEXTURECUBE:\r
- case D3D10_SVT_TEXTURECUBEARRAY:\r
- case D3D11_SVT_BYTEADDRESS_BUFFER:\r
- case D3D11_SVT_STRUCTURED_BUFFER:\r
- pAssignment->DataSize = sizeof(SShaderResource);\r
- break;\r
-\r
- case D3D10_SVT_RENDERTARGETVIEW:\r
- pAssignment->DataSize = sizeof(SRenderTargetView);\r
- break;\r
-\r
- case D3D10_SVT_DEPTHSTENCILVIEW:\r
- pAssignment->DataSize = sizeof(SDepthStencilView);\r
- break;\r
-\r
- case D3D11_SVT_RWTEXTURE1D:\r
- case D3D11_SVT_RWTEXTURE1DARRAY:\r
- case D3D11_SVT_RWTEXTURE2D:\r
- case D3D11_SVT_RWTEXTURE2DARRAY:\r
- case D3D11_SVT_RWTEXTURE3D:\r
- case D3D11_SVT_RWBUFFER:\r
- case D3D11_SVT_RWBYTEADDRESS_BUFFER:\r
- case D3D11_SVT_RWSTRUCTURED_BUFFER:\r
- case D3D11_SVT_APPEND_STRUCTURED_BUFFER:\r
- case D3D11_SVT_CONSUME_STRUCTURED_BUFFER:\r
- pAssignment->DataSize = sizeof(SUnorderedAccessView);\r
- break;\r
-\r
- case D3D11_SVT_INTERFACE_POINTER:\r
- pAssignment->DataSize = sizeof(SInterface);\r
- break;\r
-\r
- default:\r
- D3DXASSERT(0);\r
- VHD( E_FAIL, "Internal loading error: invalid assignment type.");\r
- }\r
-\r
- UINT lhsStride;\r
- if( g_lvGeneral[psAssignments[i].iState].m_Stride > 0 )\r
- lhsStride = g_lvGeneral[psAssignments[i].iState].m_Stride;\r
- else\r
- lhsStride = pAssignment->DataSize;\r
-\r
- // Store only the destination offset so that the backing store pointers can be easily fixed up later\r
- pAssignment->Destination.Offset = g_lvGeneral[psAssignments[i].iState].m_Offset + lhsStride * psAssignments[i].Index;\r
-\r
- // As a result, you should use pLHS in this function instead of the destination pointer\r
- pLHS = pBackingStore + pAssignment->Destination.Offset;\r
-\r
- switch (psAssignments[i].AssignmentType)\r
- {\r
- case ECAT_Constant: // e.g. LHS = 1; or LHS = NULL;\r
- UINT *pNumConstants;\r
- SBinaryConstant *pConstants;\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(UINT), (void**) &pNumConstants), "Invalid pEffectBuffer: cannot read NumConstants." );\r
- VHD( m_msUnstructured.Read((void **)&pConstants, sizeof(SBinaryConstant) * (*pNumConstants)), "Invalid pEffectBuffer: cannot read constants." );\r
-\r
- if(pAssignment->IsObjectAssignment())\r
- {\r
- // make sure this is a NULL assignment\r
- VBD( *pNumConstants == 1 && (pConstants[0].Type == EST_Int || pConstants[0].Type == EST_UInt) && pConstants[0].iValue == 0,\r
- "Invalid pEffectBuffer: non-NULL constant assignment to object.");\r
-\r
- switch (pAssignment->LhsType)\r
- {\r
- case ELHS_DepthStencilBlock:\r
- *((void **)pLHS) = &g_NullDepthStencil;\r
- break;\r
- case ELHS_BlendBlock:\r
- *((void **)pLHS) = &g_NullBlend;\r
- break;\r
- case ELHS_RasterizerBlock:\r
- *((void **)pLHS) = &g_NullRasterizer;\r
- break;\r
- case ELHS_VertexShaderBlock:\r
- *((void **)pLHS) = &g_NullVS;\r
- break;\r
- case ELHS_PixelShaderBlock:\r
- *((void **)pLHS) = &g_NullPS;\r
- break;\r
- case ELHS_GeometryShaderBlock:\r
- *((void **)pLHS) = &g_NullGS;\r
- break;\r
- case ELHS_HullShaderBlock:\r
- *((void **)pLHS) = &g_NullHS;\r
- break;\r
- case ELHS_DomainShaderBlock:\r
- *((void **)pLHS) = &g_NullDS;\r
- break;\r
- case ELHS_ComputeShaderBlock:\r
- *((void **)pLHS) = &g_NullCS;\r
- break;\r
- case ELHS_Texture:\r
- *((void **)pLHS) = &g_NullTexture;\r
- break;\r
- case ELHS_DepthStencilView:\r
- *((void **)pLHS) = &g_NullDepthStencilView;\r
- break;\r
- case ELHS_RenderTargetView:\r
- *((void **)pLHS) = &g_NullRenderTargetView;\r
- break;\r
- default:\r
- D3DXASSERT(0);\r
- }\r
- }\r
- else\r
- {\r
- VBD( *pNumConstants == g_lvGeneral[psAssignments[i].iState].m_Cols, "Internal loading error: mismatch constant count." );\r
- for (j = 0; j < *pNumConstants; ++ j)\r
- {\r
- VH( ExecuteConstantAssignment(pConstants + j, pLHS, g_lvGeneral[psAssignments[i].iState].m_Type) );\r
- pLHS += SType::c_ScalarSize; // arrays of constants will always be regular scalar sized, never byte-sized\r
- }\r
- }\r
-\r
- // Can get rid of this assignment\r
- break;\r
-\r
- case ECAT_Variable: // e.g. LHS = myVar;\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, &pGlobalVarName), "Invalid pEffectBuffer: cannot read variable name." );\r
-\r
- VBD( pVar = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find variable name." );\r
-\r
- if (pAssignment->IsObjectAssignment())\r
- {\r
- VBD( pVar->pType->VarType == EVT_Object && \r
- GetSimpleParameterTypeFromObjectType(pVar->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,\r
- "Loading error: invalid variable type or object type." );\r
-\r
- // Write directly into the state block's backing store\r
- *((void **)pLHS) = pVar->Data.pGeneric;\r
-\r
- // Now we can get rid of this assignment\r
- }\r
- else\r
- {\r
- VBD( pVar->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );\r
-\r
- pAssignment->DependencyCount = 1;\r
- VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );\r
- pAssignment->pDependencies->pVariable = pVar;\r
-\r
- // Store an offset for numeric values instead of a pointer so that it's easy to relocate it later\r
- pAssignment->Source.Offset = pVar->Data.Offset;\r
- pAssignment->AssignmentType = ERAT_NumericVariable;\r
-\r
- // Can't get rid of this assignment\r
- ++ finalAssignments;\r
- }\r
- break;\r
-\r
- case ECAT_ConstIndex: // e.g. LHS = myGS[1]\r
- SBinaryAssignment::SConstantIndex *psConstIndex;\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psConstIndex), (void**) &psConstIndex),\r
- "Invalid pEffectBuffer: cannot read assignment initializer." );\r
- VHD( m_msUnstructured.ReadAtOffset(psConstIndex->oArrayName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read array name." );\r
-\r
- VBD( pVarArray = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find array name." );\r
-\r
- if (pAssignment->IsObjectAssignment())\r
- {\r
- VBD( psConstIndex->Index < pVarArray->pType->Elements, "Invalid pEffectBuffer: out of bounds array index." );\r
- VBD( pVarArray->pType->VarType == EVT_Object && \r
- GetSimpleParameterTypeFromObjectType(pVarArray->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,\r
- "Loading error: invalid variable type or object type." );\r
-\r
- // Write directly into the state block's backing store\r
- *((void **)pLHS) = GetBlockByIndex(pVarArray->pType->VarType, pVarArray->pType->ObjectType, pVarArray->Data.pGeneric, psConstIndex->Index);\r
- VBD( NULL != *((void **)pLHS), "Internal loading error: invalid block." );\r
-\r
- // Now we can get rid of this assignment\r
- }\r
- else\r
- {\r
- VBD( pVarArray->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );\r
-\r
- pAssignment->DependencyCount = 1;\r
- VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );\r
- pAssignment->pDependencies->pVariable = pVarArray;\r
-\r
- CCheckedDword chkDataLen = psConstIndex->Index;\r
- UINT dataLen;\r
- chkDataLen *= SType::c_ScalarSize;\r
- chkDataLen += pAssignment->DataSize;\r
- VHD( chkDataLen.GetValue(&dataLen), "Overflow: assignment size." );\r
- VBD( dataLen <= pVarArray->pType->TotalSize, "Internal loading error: assignment size mismatch" );\r
-\r
- pAssignment->Source.Offset = pVarArray->Data.Offset + psConstIndex->Index * SType::c_ScalarSize;\r
-\r
- // _NumericConstIndex is not used here because _NumericVariable \r
- // does the same stuff in a more general fashion with no perf hit. \r
- pAssignment->AssignmentType = ERAT_NumericVariable;\r
-\r
- // Can't get rid of this assignment\r
- ++ finalAssignments;\r
- }\r
- break;\r
-\r
- case ECAT_VariableIndex: // e.g. LHS = myVar[numLights];\r
- SBinaryAssignment::SVariableIndex *psVarIndex;\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psVarIndex), (void**) &psVarIndex),\r
- "Invalid pEffectBuffer: cannot read assignment initializer." );\r
- VHD( m_msUnstructured.ReadAtOffset(psVarIndex->oArrayName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read variable name." );\r
- VBD( pVarArray = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find variable name." );\r
-\r
- VHD( m_msUnstructured.ReadAtOffset(psVarIndex->oIndexVarName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read index variable name." );\r
- VBD( pVarIndex = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find index variable name." );\r
-\r
- // Only support integer indices\r
- VBD( pVarIndex->pType->VarType == EVT_Numeric && (pVarIndex->pType->NumericType.ScalarType == EST_Int || pVarIndex->pType->NumericType.ScalarType == EST_UInt),\r
- "Invalid pEffectBuffer: invalid index variable type.");\r
- VBD( pVarArray->pType->Elements > 0, "Invalid pEffectBuffer: array variable is not an array." );\r
-\r
- pVarIndex->pCB->IsUsedByExpression = TRUE;\r
-\r
- if (pAssignment->IsObjectAssignment())\r
- {\r
- VBD( pVarArray->pType->VarType == EVT_Object && \r
- GetSimpleParameterTypeFromObjectType(pVarArray->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,\r
- "Loading error: invalid variable type or object type." );\r
-\r
- // MaxElements is only 16-bits wide\r
- VBD( pVarArray->pType->Elements <= 0xFFFF, "Internal error: array size is too large." ); \r
- pAssignment->MaxElements = pVarArray->pType->Elements;\r
-\r
- pAssignment->DependencyCount = 1;\r
- VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );\r
- pAssignment->pDependencies[0].pVariable = pVarIndex;\r
-\r
- // Point this assignment to the start of the variable's object array.\r
- // When this assignment is dirty, we write the value of this pointer plus\r
- // the index given by its one dependency directly into the destination\r
- pAssignment->Source = pVarArray->Data;\r
- pAssignment->AssignmentType = ERAT_ObjectVariableIndex;\r
- }\r
- else\r
- {\r
- VBD( pVarArray->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );\r
-\r
- pAssignment->DependencyCount = 2;\r
- VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );\r
- pAssignment->pDependencies[0].pVariable = pVarIndex;\r
- pAssignment->pDependencies[1].pVariable = pVarArray;\r
-\r
- // When pVarIndex is updated, we update the source pointer.\r
- // When pVarArray is updated, we copy data from the source to the destination.\r
- pAssignment->Source.pGeneric = NULL;\r
- pAssignment->AssignmentType = ERAT_NumericVariableIndex;\r
- }\r
-\r
- // Can't get rid of this assignment\r
- ++ finalAssignments;\r
-\r
- break;\r
-\r
- case ECAT_ExpressionIndex:// e.g. LHS = myVar[a + b * c];\r
- case ECAT_Expression: // e.g. LHS = a + b * c;\r
- // we do not support FXLVM\r
- VHD( E_NOTIMPL, "FXLVM Expressions (complex assignments like myVar[i*2]) are not supported in Effects11." );\r
- break;\r
-\r
- case ECAT_InlineShader:\r
- case ECAT_InlineShader5:\r
- UINT cbShaderBin;\r
- BYTE *pShaderBin;\r
- SShaderBlock *pShaderBlock;\r
- SAnonymousShader *pAnonShader;\r
- union\r
- {\r
- SBinaryAssignment::SInlineShader *psInlineShader;\r
- SBinaryShaderData5 *psInlineShader5;\r
- };\r
-\r
- // Inline shader assignments must be object types\r
- D3DXASSERT(pAssignment->IsObjectAssignment());\r
-\r
- C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oShader) == offsetof(SBinaryShaderData5,oShader) );\r
- C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oSODecl) == offsetof(SBinaryShaderData5,oSODecls) );\r
- if( psAssignments[i].AssignmentType == ECAT_InlineShader )\r
- {\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psInlineShader), (void**) &psInlineShader),\r
- "Invalid pEffectBuffer: cannot read inline shader." );\r
- }\r
- else\r
- {\r
- VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psInlineShader5), (void**) &psInlineShader5),\r
- "Invalid pEffectBuffer: cannot read inline shader." );\r
- }\r
- \r
- VBD( m_pEffect->m_ShaderBlockCount < m_pHeader->cTotalShaders, "Internal loading error: shader count is out incorrect." );\r
- VBD( m_pEffect->m_AnonymousShaderCount < m_pHeader->cInlineShaders, "Internal loading error: anonymous shader count is out incorrect." );\r
-\r
- pShaderBlock = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];\r
- pAnonShader = &m_pEffect->m_pAnonymousShaders[m_pEffect->m_AnonymousShaderCount];\r
- pAnonShader->pShaderBlock = pShaderBlock;\r
-\r
- ++ m_pEffect->m_ShaderBlockCount;\r
- ++ m_pEffect->m_AnonymousShaderCount;\r
-\r
- // Write directly into the state block's backing store\r
- *((void **)pLHS) = pShaderBlock;\r
-\r
- VHD( GetUnstructuredDataBlock(psInlineShader->oShader, &cbShaderBin, (void **) &pShaderBin), "Invalid pEffectBuffer: cannot read inline shader block." );\r
-\r
- if (cbShaderBin > 0)\r
- {\r
- VN( pShaderBlock->pReflectionData = PRIVATENEW SShaderBlock::SReflectionData );\r
-\r
- pShaderBlock->pReflectionData->BytecodeLength = cbShaderBin;\r
- pShaderBlock->pReflectionData->pBytecode = (BYTE*) pShaderBin;\r
- pShaderBlock->pReflectionData->pStreamOutDecls[0] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[1] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[2] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[3] = NULL;\r
- pShaderBlock->pReflectionData->RasterizedStream = 0;\r
- pShaderBlock->pReflectionData->IsNullGS = FALSE;\r
- pShaderBlock->pReflectionData->pReflection = NULL;\r
- pShaderBlock->pReflectionData->InterfaceParameterCount = 0;\r
- pShaderBlock->pReflectionData->pInterfaceParameters = NULL;\r
- }\r
-\r
- switch (pAssignment->LhsType)\r
- {\r
- case ELHS_PixelShaderBlock:\r
- pShaderBlock->pVT = &g_vtPS;\r
- VBD( psInlineShader->oSODecl == NULL, "Internal loading error: pixel shaders cannot have stream out decls." );\r
- break;\r
- \r
- case ELHS_GeometryShaderBlock:\r
- pShaderBlock->pVT = &g_vtGS;\r
- if( psAssignments[i].AssignmentType == ECAT_InlineShader )\r
- {\r
- if (psInlineShader->oSODecl)\r
- {\r
- // This is a GS with SO\r
- VHD( GetStringAndAddToReflection(psInlineShader->oSODecl, &pShaderBlock->pReflectionData->pStreamOutDecls[0]),\r
- "Invalid pEffectBuffer: cannot read SO decl." );\r
- }\r
- }\r
- else\r
- {\r
- // This is a GS with addressable stream out\r
- for( UINT iDecl=0; iDecl < psInlineShader5->cSODecls; ++iDecl )\r
- {\r
- if (psInlineShader5->oSODecls[iDecl])\r
- {\r
- VHD( GetStringAndAddToReflection(psInlineShader5->oSODecls[iDecl], &pShaderBlock->pReflectionData->pStreamOutDecls[iDecl]),\r
- "Invalid pEffectBuffer: cannot read SO decl." );\r
- }\r
- }\r
- pShaderBlock->pReflectionData->RasterizedStream = psInlineShader5->RasterizedStream;\r
- }\r
- break;\r
-\r
- case ELHS_VertexShaderBlock:\r
- pShaderBlock->pVT = &g_vtVS;\r
- VBD( psInlineShader->oSODecl == NULL, "Internal loading error: vertex shaders cannot have stream out decls." );\r
- break;\r
-\r
- case ELHS_HullShaderBlock:\r
- pShaderBlock->pVT = &g_vtHS;\r
- VBD( psInlineShader->oSODecl == NULL, "Internal loading error: hull shaders cannot have stream out decls." );\r
- break;\r
-\r
- case ELHS_DomainShaderBlock:\r
- pShaderBlock->pVT = &g_vtDS;\r
- VBD( psInlineShader->oSODecl == NULL, "Internal loading error: domain shaders cannot have stream out decls." );\r
- break;\r
-\r
- case ELHS_ComputeShaderBlock:\r
- pShaderBlock->pVT = &g_vtCS;\r
- VBD( psInlineShader->oSODecl == NULL, "Internal loading error: compute shaders cannot have stream out decls." );\r
- break;\r
-\r
- case ELHS_GeometryShaderSO:\r
- D3DXASSERT(0); // Should never happen\r
-\r
- default:\r
- VHD( E_FAIL, "Internal loading error: invalid shader type." );\r
- }\r
-\r
- if( psAssignments[i].AssignmentType == ECAT_InlineShader5 )\r
- {\r
- pShaderBlock->pReflectionData->InterfaceParameterCount = psInlineShader5->cInterfaceBindings;\r
- VH( GetInterfaceParametersAndAddToReflection( psInlineShader5->cInterfaceBindings, psInlineShader5->oInterfaceBindings, &pShaderBlock->pReflectionData->pInterfaceParameters ) );\r
- }\r
-\r
- // Now we can get rid of this assignment\r
- break;\r
-\r
- default:\r
- D3DXASSERT(0);\r
-\r
- }\r
- }\r
-\r
- *pFinalAssignments = finalAssignments;\r
- if (pRTVAssignments)\r
- *pRTVAssignments = renderTargetViewAssns;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize an object variable\r
-HRESULT CEffectLoader::LoadObjectVariables()\r
-{\r
- HRESULT hr = S_OK;\r
- UINT iBlock;\r
- UINT cBlocks;\r
-\r
- cBlocks = m_pHeader->Effect.cObjectVariables;\r
-\r
- for (iBlock=0; iBlock<cBlocks; iBlock++)\r
- {\r
- SBinaryObjectVariable *psBlock;\r
- SGlobalVariable *pVar;\r
- SType *pType;\r
- UINT iElement;\r
- UINT elementsToRead;\r
- CCheckedDword chkElementsTotal;\r
- UINT elementsTotal;\r
-\r
- // Read variable info\r
- VHD( m_msStructured.Read((void**) &psBlock, sizeof(*psBlock)), "Invalid pEffectBuffer: cannot read object variable." );\r
- VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),\r
- "Internal loading error: variable count mismatch." );\r
- pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];\r
- \r
- // Get type\r
- VH( LoadTypeAndAddToPool(&pType, psBlock->oType) );\r
-\r
- // Make sure the right polymorphic type is created\r
- VH( PlacementNewVariable(pVar, pType, FALSE) );\r
-\r
- pVar->pEffect = m_pEffect;\r
- pVar->pType = pType;\r
- pVar->pCB = NULL;\r
- pVar->ExplicitBindPoint = psBlock->ExplicitBindPoint;\r
-\r
- if( pType->IsStateBlockObject() )\r
- {\r
- pVar->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;\r
- m_pEffect->m_MemberDataCount += max(pType->Elements,1);\r
- }\r
-\r
- // Get name\r
- VHD( GetStringAndAddToReflection(psBlock->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read object variable name." );\r
- VHD( GetStringAndAddToReflection(psBlock->oSemantic, &pVar->pSemantic), "Invalid pEffectBuffer: cannot read object variable semantic." );\r
-\r
- m_pEffect->m_VariableCount++;\r
- elementsToRead = max(1, pType->Elements);\r
- chkElementsTotal = elementsToRead;\r
-\r
- if (pType->IsStateBlockObject())\r
- {\r
- // State blocks\r
- EBlockType blockType;\r
- UINT *maxBlockCount;\r
- UINT *currentBlockCount;\r
-\r
- switch (pType->ObjectType)\r
- {\r
- case EOT_Blend:\r
- pVar->Data.pBlock = &m_pEffect->m_pBlendBlocks[m_pEffect->m_BlendBlockCount];\r
- maxBlockCount = &m_pHeader->cBlendStateBlocks;\r
- currentBlockCount = &m_pEffect->m_BlendBlockCount;\r
- blockType = EBT_Blend;\r
- break;\r
-\r
- case EOT_DepthStencil:\r
- pVar->Data.pBlock = &m_pEffect->m_pDepthStencilBlocks[m_pEffect->m_DepthStencilBlockCount];\r
- maxBlockCount = &m_pHeader->cDepthStencilBlocks;\r
- currentBlockCount = &m_pEffect->m_DepthStencilBlockCount;\r
- blockType = EBT_DepthStencil;\r
- break;\r
-\r
- case EOT_Rasterizer:\r
- pVar->Data.pBlock = &m_pEffect->m_pRasterizerBlocks[m_pEffect->m_RasterizerBlockCount];\r
- maxBlockCount = &m_pHeader->cRasterizerStateBlocks;\r
- currentBlockCount = &m_pEffect->m_RasterizerBlockCount;\r
- blockType = EBT_Rasterizer;\r
- break;\r
-\r
- default:\r
- VB(pType->IsSampler());\r
- pVar->Data.pBlock = &m_pEffect->m_pSamplerBlocks[m_pEffect->m_SamplerBlockCount];\r
- maxBlockCount = &m_pHeader->cSamplers;\r
- currentBlockCount = &m_pEffect->m_SamplerBlockCount;\r
- blockType = EBT_Sampler;\r
- }\r
-\r
- chkElementsTotal += *currentBlockCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: vaiable elements." );\r
- VBD( elementsTotal <= *maxBlockCount, "Internal loading error: element count overflow." );\r
- \r
- *currentBlockCount += elementsToRead;\r
-\r
- for (iElement = 0; iElement < elementsToRead; ++ iElement)\r
- {\r
- SBaseBlock *pCurrentBlock;\r
- UINT cAssignments;\r
- \r
- pCurrentBlock = (SBaseBlock *) GetBlockByIndex(pVar->pType->VarType, pVar->pType->ObjectType, pVar->Data.pGeneric, iElement);\r
- VBD( NULL != pCurrentBlock, "Internal loading error: find state block." );\r
-\r
- pCurrentBlock->BlockType = blockType;\r
-\r
- VHD( m_msStructured.Read(&cAssignments), "Invalid pEffectBuffer: cannot read state block assignments." );\r
-\r
- VH( LoadAssignments( cAssignments, &pCurrentBlock->pAssignments, (BYTE*)pCurrentBlock, NULL, &pCurrentBlock->AssignmentCount ) );\r
- }\r
- }\r
- else if (pType->IsShader())\r
- {\r
- // Shaders\r
-\r
- chkElementsTotal += m_pEffect->m_ShaderBlockCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: shader block count." );\r
- VBD( elementsTotal <= m_pHeader->cTotalShaders, "Invalid pEffectBuffer: shader count mismatch." );\r
-\r
- pVar->Data.pShader = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];\r
-\r
- for (iElement=0; iElement<elementsToRead; iElement++)\r
- {\r
- UINT cbShaderBin;\r
- void *pShaderBin;\r
- SShaderBlock *pShaderBlock;\r
-\r
- union\r
- {\r
- UINT *pOffset;\r
- SBinaryGSSOInitializer *psInlineGSSO4;\r
- SBinaryShaderData5 *psInlineShader5;\r
- };\r
-\r
- C_ASSERT( offsetof(SBinaryGSSOInitializer,oShader) == 0 );\r
- C_ASSERT( offsetof(SBinaryShaderData5,oShader) == 0 );\r
-\r
-\r
- pShaderBlock = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];\r
- m_pEffect->m_ShaderBlockCount++;\r
-\r
- // Get shader binary\r
- switch (pType->ObjectType)\r
- {\r
- case EOT_VertexShader:\r
- case EOT_GeometryShader:\r
- case EOT_PixelShader:\r
- VHD( m_msStructured.Read((void**)&pOffset, sizeof(*pOffset)), "Invalid pEffectBuffer: cannot read shader block." );\r
- break;\r
-\r
- case EOT_GeometryShaderSO:\r
- VHD( m_msStructured.Read((void**)&psInlineGSSO4, sizeof(*psInlineGSSO4)), "Invalid pEffectBuffer: cannot read inline GS with SO." );\r
- break;\r
-\r
- case EOT_VertexShader5:\r
- case EOT_GeometryShader5:\r
- case EOT_HullShader5:\r
- case EOT_DomainShader5:\r
- case EOT_PixelShader5:\r
- case EOT_ComputeShader5:\r
- VHD( m_msStructured.Read((void**)&psInlineShader5, sizeof(*psInlineShader5)), "Invalid pEffectBuffer: cannot read inline shader." );\r
- break;\r
-\r
- default:\r
- VH( E_FAIL );\r
- }\r
-\r
- VHD( GetUnstructuredDataBlock(*pOffset, &cbShaderBin, &pShaderBin), "Invalid pEffectBuffer: cannot read shader byte code." );\r
-\r
- if (cbShaderBin > 0)\r
- {\r
- VN( pShaderBlock->pReflectionData = PRIVATENEW SShaderBlock::SReflectionData );\r
-\r
- pShaderBlock->pReflectionData->BytecodeLength = cbShaderBin;\r
- pShaderBlock->pReflectionData->pBytecode = (BYTE*) pShaderBin;\r
- pShaderBlock->pReflectionData->pStreamOutDecls[0] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[1] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[2] =\r
- pShaderBlock->pReflectionData->pStreamOutDecls[3] = NULL;\r
- pShaderBlock->pReflectionData->RasterizedStream = 0;\r
- pShaderBlock->pReflectionData->IsNullGS = FALSE;\r
- pShaderBlock->pReflectionData->pReflection = NULL;\r
- pShaderBlock->pReflectionData->InterfaceParameterCount = 0;\r
- pShaderBlock->pReflectionData->pInterfaceParameters = NULL;\r
- }\r
-\r
- switch (pType->ObjectType)\r
- {\r
- case EOT_PixelShader:\r
- pShaderBlock->pVT = &g_vtPS;\r
- break;\r
-\r
- case EOT_GeometryShaderSO:\r
- // Get StreamOut decl\r
- //VH( m_msStructured.Read(&dwOffset) );\r
- if (cbShaderBin > 0)\r
- {\r
- VHD( GetStringAndAddToReflection(psInlineGSSO4->oSODecl, &pShaderBlock->pReflectionData->pStreamOutDecls[0]),\r
- "Invalid pEffectBuffer: cannot read stream out decl." );\r
- }\r
- pShaderBlock->pVT = &g_vtGS;\r
- break;\r
-\r
- case EOT_VertexShader5:\r
- case EOT_GeometryShader5:\r
- case EOT_HullShader5:\r
- case EOT_DomainShader5:\r
- case EOT_PixelShader5:\r
- case EOT_ComputeShader5:\r
- // Get StreamOut decls\r
- if (cbShaderBin > 0)\r
- {\r
- for( UINT iDecl=0; iDecl < psInlineShader5->cSODecls; ++iDecl )\r
- {\r
- VHD( GetStringAndAddToReflection(psInlineShader5->oSODecls[iDecl], &pShaderBlock->pReflectionData->pStreamOutDecls[iDecl]),\r
- "Invalid pEffectBuffer: cannot read stream out decls." );\r
- }\r
- pShaderBlock->pReflectionData->RasterizedStream = psInlineShader5->RasterizedStream;\r
- pShaderBlock->pReflectionData->InterfaceParameterCount = psInlineShader5->cInterfaceBindings;\r
- VH( GetInterfaceParametersAndAddToReflection( psInlineShader5->cInterfaceBindings, psInlineShader5->oInterfaceBindings, &pShaderBlock->pReflectionData->pInterfaceParameters ) );\r
- }\r
- switch (pType->ObjectType)\r
- {\r
- case EOT_VertexShader5:\r
- pShaderBlock->pVT = &g_vtVS;\r
- break;\r
- case EOT_GeometryShader5:\r
- pShaderBlock->pVT = &g_vtGS;\r
- break;\r
- case EOT_HullShader5:\r
- pShaderBlock->pVT = &g_vtHS;\r
- break;\r
- case EOT_DomainShader5:\r
- pShaderBlock->pVT = &g_vtDS;\r
- break;\r
- case EOT_PixelShader5:\r
- pShaderBlock->pVT = &g_vtPS;\r
- break;\r
- case EOT_ComputeShader5:\r
- pShaderBlock->pVT = &g_vtCS;\r
- break;\r
- default:\r
- VH( E_FAIL );\r
- }\r
- break;\r
-\r
- case EOT_GeometryShader:\r
- pShaderBlock->pVT = &g_vtGS;\r
- break;\r
-\r
- case EOT_VertexShader:\r
- pShaderBlock->pVT = &g_vtVS;\r
- break;\r
-\r
- default:\r
- VHD( E_FAIL, "Invalid pEffectBuffer: invalid shader type." );\r
- }\r
- }\r
- }\r
- else if (pType->IsObjectType(EOT_String))\r
- {\r
- // Strings\r
- \r
- chkElementsTotal += m_pEffect->m_StringCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: string object count." );\r
- VBD( elementsTotal <= m_pHeader->cStrings, "Invalid pEffectBuffer: string count mismatch." );\r
-\r
- pVar->Data.pString = &m_pEffect->m_pStrings[m_pEffect->m_StringCount];\r
-\r
- for (iElement=0; iElement<elementsToRead; iElement++)\r
- {\r
- UINT dwOffset;\r
- SString *pString;\r
-\r
- pString = &m_pEffect->m_pStrings[m_pEffect->m_StringCount];\r
- m_pEffect->m_StringCount++;\r
-\r
- // Get string\r
- VHD( m_msStructured.Read(&dwOffset), "Invalid pEffectBuffer: cannot read string offset." );\r
- VHD( GetStringAndAddToReflection(dwOffset, &pString->pString), "Invalid pEffectBuffer: cannot read string." );\r
- }\r
- }\r
- else if (pType->IsShaderResource())\r
- { \r
- // Textures/buffers\r
- \r
- chkElementsTotal += m_pEffect->m_ShaderResourceCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: SRV object count." );\r
- VBD( elementsTotal <= m_pHeader->cShaderResources, "Invalid pEffectBuffer: SRV count mismatch." );\r
-\r
- pVar->Data.pShaderResource = &m_pEffect->m_pShaderResources[m_pEffect->m_ShaderResourceCount];\r
- m_pEffect->m_ShaderResourceCount += elementsToRead;\r
- }\r
- else if (pType->IsUnorderedAccessView())\r
- { \r
- // UnorderedAccessViews\r
-\r
- chkElementsTotal += m_pEffect->m_UnorderedAccessViewCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: UAV object count." );\r
- VBD( elementsTotal <= m_pHeader->cUnorderedAccessViews, "Invalid pEffectBuffer: UAV count mismatch." );\r
-\r
- pVar->Data.pUnorderedAccessView = &m_pEffect->m_pUnorderedAccessViews[m_pEffect->m_UnorderedAccessViewCount];\r
- m_pEffect->m_UnorderedAccessViewCount += elementsToRead;\r
- }\r
- else if (pType->IsRenderTargetView())\r
- { \r
- // RenderTargets\r
-\r
- chkElementsTotal += m_pEffect->m_RenderTargetViewCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: RTV object count." );\r
- VBD( elementsTotal <= m_pHeader->cRenderTargetViews, "Invalid pEffectBuffer: RTV count mismatch." );\r
-\r
- pVar->Data.pRenderTargetView = &m_pEffect->m_pRenderTargetViews[m_pEffect->m_RenderTargetViewCount];\r
- m_pEffect->m_RenderTargetViewCount += elementsToRead;\r
- }\r
- else if (pType->IsDepthStencilView())\r
- { \r
- // DepthStencilViews\r
-\r
- chkElementsTotal += m_pEffect->m_DepthStencilViewCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: DSV object count." );\r
- VBD( elementsTotal <= m_pHeader->cDepthStencilViews, "Invalid pEffectBuffer: DSV count mismatch." );\r
-\r
- pVar->Data.pDepthStencilView = &m_pEffect->m_pDepthStencilViews[m_pEffect->m_DepthStencilViewCount];\r
- m_pEffect->m_DepthStencilViewCount += elementsToRead;\r
- }\r
- else\r
- {\r
- VHD( E_FAIL, "Invalid pEffectBuffer: DSV count mismatch." );\r
- }\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize an interface variable\r
-HRESULT CEffectLoader::LoadInterfaceVariables()\r
-{\r
- HRESULT hr = S_OK;\r
- UINT iBlock;\r
- UINT cBlocks;\r
-\r
- cBlocks = m_pHeader->cInterfaceVariables;\r
-\r
- for (iBlock=0; iBlock<cBlocks; iBlock++)\r
- {\r
- SBinaryInterfaceVariable *psBlock;\r
- SGlobalVariable *pVar;\r
- SType *pType;\r
- UINT elementsToRead;\r
- CCheckedDword chkElementsTotal;\r
- UINT elementsTotal;\r
- void *pDefaultValue;\r
-\r
- // Read variable info\r
- VHD( m_msStructured.Read((void**) &psBlock, sizeof(*psBlock)), "Invalid pEffectBuffer: cannot read interface block." );\r
- VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),\r
- "Internal loading error: variable count mismatch." );\r
- pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];\r
-\r
- // Get type\r
- VH( LoadTypeAndAddToPool(&pType, psBlock->oType) );\r
-\r
- // Make sure the right polymorphic type is created\r
- VH( PlacementNewVariable(pVar, pType, FALSE) );\r
-\r
- pVar->pEffect = m_pEffect;\r
- pVar->pType = pType;\r
- pVar->pCB = NULL;\r
- pVar->ExplicitBindPoint = (UINT)-1;\r
- pVar->pSemantic = NULL;\r
-\r
- // Get name\r
- VHD( GetStringAndAddToReflection(psBlock->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read interface name." );\r
-\r
- m_pEffect->m_VariableCount++;\r
- elementsToRead = max(1, pType->Elements);\r
- chkElementsTotal = elementsToRead;\r
-\r
- VBD( pType->IsInterface(), "Internal loading error: invlaid type for interface." );\r
-\r
- chkElementsTotal += m_pEffect->m_InterfaceCount;\r
- VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: interface count." );\r
- VBD( elementsTotal <= m_pHeader->cInterfaceVariableElements, "Invalid pEffectBuffer: interface count mismatch." );\r
-\r
- pVar->Data.pInterface = &m_pEffect->m_pInterfaces[m_pEffect->m_InterfaceCount];\r
- m_pEffect->m_InterfaceCount += elementsToRead;\r
-\r
- // Get default value\r
- if (0 != psBlock->oDefaultValue)\r
- {\r
- VHD( m_msUnstructured.ReadAtOffset(psBlock->oDefaultValue, elementsToRead * sizeof(SBinaryInterfaceInitializer), &pDefaultValue),\r
- "Invalid pEffectBuffer: cannot read interface initializer offset." );\r
- for( UINT i=0; i < elementsToRead; i++ )\r
- {\r
- SBinaryInterfaceInitializer* pInterfaceInit = &((SBinaryInterfaceInitializer*)pDefaultValue)[i];\r
- LPCSTR pClassInstanceName;\r
- VHD( m_msUnstructured.ReadAtOffset(pInterfaceInit->oInstanceName, &pClassInstanceName), "Invalid pEffectBuffer: cannot read interface initializer." );\r
-\r
- SGlobalVariable *pCIVariable = m_pEffect->FindVariableByName(pClassInstanceName);\r
- VBD( pCIVariable != NULL, "Loading error: cannot find class instance for interface initializer." );\r
- VBD( pCIVariable->pType->IsClassInstance(), "Loading error: variable type mismatch for interface initializer." );\r
- if( pInterfaceInit->ArrayIndex == (UINT)-1 )\r
- {\r
- VBD( pCIVariable->pType->Elements == 0, "Loading error: array mismatch for interface initializer." );\r
- pVar->Data.pInterface[i].pClassInstance = (SClassInstanceGlobalVariable*)pCIVariable;\r
- }\r
- else\r
- {\r
- VBD( pCIVariable->pType->Elements > 0, "Loading error: array mismatch for interface initializer." );\r
- VBD( pInterfaceInit->ArrayIndex < pCIVariable->pType->Elements, "Loading error: array index out of range." );\r
-\r
- SMember* pMember = (SMember*)pCIVariable->GetElement( pInterfaceInit->ArrayIndex );\r
- VBD( pMember->IsValid(), "Loading error: cannot find member by name." );\r
- VBD( pMember->pType->IsClassInstance(), "Loading error: member type mismatch for interface initializer." );\r
- pVar->Data.pInterface[i].pClassInstance = (SClassInstanceGlobalVariable*)pMember;\r
- }\r
- }\r
- }\r
-\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );\r
- }\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize a group (and contained techniques and passes)\r
-HRESULT CEffectLoader::LoadGroups()\r
-{\r
- HRESULT hr = S_OK;\r
- UINT iGroup;\r
- UINT TechniquesInEffect = 0;\r
-\r
- for( iGroup=0; iGroup<m_pHeader->cGroups; iGroup++ )\r
- {\r
- SGroup *pGroup = &m_pEffect->m_pGroups[iGroup];\r
- SBinaryGroup *psGroup;\r
-\r
- // Read group info\r
- VHD( m_msStructured.Read((void**) &psGroup, sizeof(*psGroup)), "Invalid pEffectBuffer: cannot read group." );\r
- pGroup->TechniqueCount = psGroup->cTechniques;\r
- VN( pGroup->pTechniques = PRIVATENEW STechnique[pGroup->TechniqueCount] );\r
- VHD( GetStringAndAddToReflection(psGroup->oName, &pGroup->pName), "Invalid pEffectBuffer: cannot read group name." );\r
-\r
- if( pGroup->pName == NULL )\r
- {\r
- VBD( m_pEffect->m_pNullGroup == NULL, "Internal loading error: multiple NULL groups." );\r
- m_pEffect->m_pNullGroup = pGroup;\r
- }\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pGroup->AnnotationCount, &pGroup->pAnnotations) );\r
-\r
- UINT iTechnique;\r
- for( iTechnique=0; iTechnique < psGroup->cTechniques; iTechnique++ )\r
- {\r
- VH( LoadTechnique( &pGroup->pTechniques[iTechnique] ) );\r
- }\r
- TechniquesInEffect += psGroup->cTechniques;\r
- }\r
-\r
- VBD( TechniquesInEffect == m_pHeader->cTechniques, "Loading error: technique count mismatch." );\r
- m_pEffect->m_TechniqueCount = m_pHeader->cTechniques;\r
- m_pEffect->m_GroupCount = m_pHeader->cGroups;\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize a technique (and contained passes)\r
-HRESULT CEffectLoader::LoadTechnique( STechnique* pTech )\r
-{\r
- HRESULT hr = S_OK;\r
- UINT iPass;\r
-\r
- SBinaryTechnique *psTech;\r
-\r
- // Read technique info\r
- VHD( m_msStructured.Read((void**) &psTech, sizeof(*psTech)), "Invalid pEffectBuffer: cannot read technique." );\r
- pTech->PassCount = psTech->cPasses;\r
- VN( pTech->pPasses = PRIVATENEW SPassBlock[pTech->PassCount] );\r
- VHD( GetStringAndAddToReflection(psTech->oName, &pTech->pName), "Invalid pEffectBuffer: cannot read technique name." );\r
-\r
- // Read annotations\r
- VH( LoadAnnotations(&pTech->AnnotationCount, &pTech->pAnnotations) );\r
-\r
- for (iPass=0; iPass<psTech->cPasses; iPass++)\r
- {\r
- SBinaryPass *psPass;\r
- SPassBlock *pPass = &pTech->pPasses[iPass];\r
-\r
- // Read pass info\r
- VHD( m_msStructured.Read((void**) &psPass, sizeof(SBinaryPass)), "Invalid pEffectBuffer: cannot read pass." );\r
- VHD( GetStringAndAddToReflection(psPass->oName, &pPass->pName), "Invalid pEffectBuffer: cannot read pass name." );\r
- \r
- // Read annotations\r
- VH( LoadAnnotations(&pPass->AnnotationCount, &pPass->pAnnotations) );\r
-\r
- VH( LoadAssignments( psPass->cAssignments, &pPass->pAssignments, (BYTE*)pPass, &pPass->BackingStore.RenderTargetViewCount, &pPass->AssignmentCount ) );\r
- VBD( pPass->BackingStore.RenderTargetViewCount <= D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, "Invalid pEffectBuffer: too many RTVs in pass." );\r
-\r
- // Initialize other pass information\r
- pPass->pEffect = m_pEffect;\r
- pPass->BlockType = EBT_Pass;\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-// Read info from the compiled blob and initialize a set of annotations\r
-HRESULT CEffectLoader::LoadAnnotations(UINT *pcAnnotations, SAnnotation **ppAnnotations)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT cAnnotations, i, oData;\r
- SAnnotation *pAnnotations = NULL;\r
-\r
- VHD( m_msStructured.Read(&cAnnotations), "Invalid pEffectBuffer: cannot read anootation count." );\r
-\r
- if (cAnnotations)\r
- {\r
- UINT annotationsSize;\r
- CCheckedDword chkAnnotationsSize;\r
-\r
- chkAnnotationsSize = cAnnotations;\r
- chkAnnotationsSize *= sizeof(SAnnotation);\r
- VHD( chkAnnotationsSize.GetValue(&annotationsSize), "Overflow in annotations." );\r
- \r
- // we allocate raw bytes for annotations because they are polymorphic types that need to be placement new'ed\r
- VN( pAnnotations = (SAnnotation *) PRIVATENEW BYTE[annotationsSize] );\r
- \r
- for (i=0; i<cAnnotations; i++)\r
- {\r
- SBinaryAnnotation *psAnnotation;\r
- SAnnotation *pAn = &pAnnotations[i];\r
- SType *pType;\r
-\r
- VHD( m_msStructured.Read((void**) &psAnnotation, sizeof(SBinaryAnnotation)), "Invalid pEffectBuffer: cannot read annotation." );\r
-\r
- VH( LoadTypeAndAddToPool(&pType, psAnnotation->oType) );\r
-\r
- // Make sure the right polymorphic type is created\r
- VH( PlacementNewVariable(pAn, pType, TRUE) );\r
-\r
- pAn->pEffect = m_pEffect;\r
- pAn->pType = pType;\r
-\r
- VHD( GetStringAndAddToReflection(psAnnotation->oName, &pAn->pName), "Invalid pEffectBuffer: cannot read annotation name." );\r
-\r
- if (pType->IsObjectType(EOT_String))\r
- {\r
- UINT cElements = max(1, pType->Elements);\r
- UINT j;\r
- VN( pAn->Data.pString = PRIVATENEW SString[cElements] );\r
- for (j = 0; j < cElements; ++ j)\r
- {\r
- // Read initializer offset\r
- VHD( m_msStructured.Read(&oData), "Invalid pEffectBuffer: cannot read string." );\r
- VHD( GetStringAndAddToReflection(oData, &pAn->Data.pString[j].pString), "Invalid pEffectBuffer: cannot read string initializer." );\r
- }\r
- }\r
- else if (pType->BelongsInConstantBuffer())\r
- {\r
- void *pDefaultValue;\r
- UINT bytesUnpacked;\r
- \r
- // Read initializer offset\r
- VHD( m_msStructured.Read(&oData), "Invalid pEffectBuffer: cannot read annotation." );\r
-\r
- VBD( oData != 0, "Invalid pEffectBuffer: invalid anotation offset." );\r
-\r
- VN( pAn->Data.pGeneric = PRIVATENEW BYTE[pType->TotalSize] );\r
- ZeroMemory(pAn->Data.pGeneric, pType->TotalSize);\r
- VHD( m_msUnstructured.ReadAtOffset(oData, pType->PackedSize, &pDefaultValue), "Invalid pEffectBuffer: cannot read variable default value." );\r
- VH( UnpackData((BYTE*) pAn->Data.pGeneric, (BYTE*) pDefaultValue, pType->PackedSize, pType, &bytesUnpacked) );\r
- VBD( bytesUnpacked == pType->PackedSize, "Invalid pEffectBuffer: packed sizes to not match." );\r
- }\r
- else\r
- {\r
- VHD( E_FAIL, "Invalid pEffectBuffer: invalid annotation type." );\r
- }\r
- }\r
- }\r
-\r
- *pcAnnotations = cAnnotations;\r
- *ppAnnotations = pAnnotations;\r
-lExit:\r
-\r
- return hr;\r
-}\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Build shader block dependencies from shader metadata\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-//\r
-// Grabs shader resource dependency information from the bytecode of the shader\r
-// (cbuffer, tbuffer, texture, buffer, sampler, and UAV dependencies),\r
-// and sets up the given SShaderBlock to point to the dependencies within the effect\r
-//\r
-HRESULT CEffectLoader::GrabShaderData(SShaderBlock *pShaderBlock)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j;\r
- CEffectVector<SRange> vRanges[ER_Count], *pvRange;\r
- SRange *pRange = NULL;\r
- CEffectVector<SConstantBuffer*> vTBuffers;\r
- \r
- //////////////////////////////////////////////////////////////////////////\r
- // Step 1: iterate through the resource binding structures and build\r
- // an "optimized" list of all of the dependencies\r
-\r
- D3D11_SHADER_DESC ShaderDesc;\r
- pShaderBlock->pReflectionData->pReflection->GetDesc( &ShaderDesc );\r
-\r
- // Since we have the shader desc, let's find out if this is a NULL GS\r
- if( D3D11_SHVER_GET_TYPE( ShaderDesc.Version ) == D3D11_SHVER_VERTEX_SHADER && pShaderBlock->GetShaderType() == EOT_GeometryShader )\r
- {\r
- pShaderBlock->pReflectionData->IsNullGS = TRUE;\r
- }\r
-\r
- pShaderBlock->CBDepCount = pShaderBlock->ResourceDepCount = pShaderBlock->TBufferDepCount = pShaderBlock->SampDepCount = 0;\r
- pShaderBlock->UAVDepCount = pShaderBlock->InterfaceDepCount = 0;\r
-\r
- for(i = 0; i < ShaderDesc.BoundResources; i++)\r
- {\r
- LPCSTR pName;\r
- UINT bindPoint, size;\r
- ERanges eRange;\r
- SShaderResource *pShaderResource = NULL;\r
- SUnorderedAccessView *pUnorderedAccessView = NULL;\r
- SSamplerBlock *pSampler = NULL;\r
- SConstantBuffer *pCB = NULL;\r
- SVariable *pVariable = NULL;\r
- BOOL isFX9TextureLoad = FALSE;\r
- D3D11_SHADER_INPUT_BIND_DESC ResourceDesc;\r
-\r
- pShaderBlock->pReflectionData->pReflection->GetResourceBindingDesc( i, &ResourceDesc );\r
-\r
- // HUGE ASSUMPTION: the bindpoints we read in the shader metadata are sorted;\r
- // i.e. bindpoints are steadily increasing\r
- // If this assumption is not met, then we will hit an assert below\r
-\r
- pName = ResourceDesc.Name;\r
- bindPoint = ResourceDesc.BindPoint;\r
- size = ResourceDesc.BindCount;\r
-\r
- switch( ResourceDesc.Type )\r
- {\r
- case D3D10_SIT_CBUFFER:\r
- eRange = ER_CBuffer;\r
- \r
- pCB = m_pEffect->FindCB(pName);\r
- VBD( NULL != pCB, "Loading error: cannot find cbuffer." );\r
- VBD( size == 1, "Loading error: cbuffer arrays are not supported." );\r
- break;\r
-\r
- case D3D10_SIT_TBUFFER:\r
- eRange = ER_Texture;\r
- \r
- pCB = m_pEffect->FindCB(pName);\r
- VBD( NULL != pCB, "Loading error: cannot find tbuffer." );\r
- VBD( FALSE != pCB->IsTBuffer, "Loading error: cbuffer found where tbuffer is expected." );\r
- VBD( size == 1, "Loading error: tbuffer arrays are not supported." );\r
- pShaderResource = &pCB->TBuffer;\r
- break;\r
-\r
- case D3D10_SIT_TEXTURE: \r
- case D3D11_SIT_STRUCTURED:\r
- case D3D11_SIT_BYTEADDRESS:\r
- eRange = ER_Texture;\r
-\r
- pVariable = m_pEffect->FindVariableByNameWithParsing(pName);\r
- VBD( pVariable != NULL, "Loading error: cannot find SRV variable." );\r
- UINT elements;\r
- elements = max(1, pVariable->pType->Elements);\r
- VBD( size <= elements, "Loading error: SRV array size mismatch." );\r
-\r
- if (pVariable->pType->IsShaderResource())\r
- {\r
- // this is just a straight texture assignment\r
- pShaderResource = pVariable->Data.pShaderResource;\r
- }\r
- else\r
- {\r
- // This is a FX9/HLSL9-style texture load instruction that specifies only a sampler\r
- VBD( pVariable->pType->IsSampler(), "Loading error: shader dependency is neither an SRV nor sampler.");\r
- isFX9TextureLoad = TRUE;\r
- pSampler = pVariable->Data.pSampler;\r
- // validate that all samplers actually used (i.e. based on size, not elements) in this variable have a valid TEXTURE assignment\r
- for (j = 0; j < size; ++ j)\r
- {\r
- if (NULL == pSampler[j].BackingStore.pTexture)\r
- {\r
- // print spew appropriately for samplers vs sampler arrays\r
- if (0 == pVariable->pType->Elements)\r
- {\r
- DPF(0, "%s: Sampler %s does not have a texture bound to it, even though the sampler is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName);\r
- }\r
- else\r
- {\r
- DPF(0, "%s: Sampler %s[%d] does not have a texture bound to it, even though the sampler array is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName, j);\r
- }\r
- \r
- VH( E_FAIL );\r
- }\r
- }\r
- }\r
- break;\r
-\r
- case D3D11_SIT_UAV_RWTYPED:\r
- case D3D11_SIT_UAV_RWSTRUCTURED:\r
- case D3D11_SIT_UAV_RWBYTEADDRESS:\r
- case D3D11_SIT_UAV_APPEND_STRUCTURED:\r
- case D3D11_SIT_UAV_CONSUME_STRUCTURED:\r
- case D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:\r
- eRange = ER_UnorderedAccessView;\r
-\r
- pVariable = m_pEffect->FindVariableByNameWithParsing(pName);\r
- VBD( pVariable != NULL, "Loading error: cannot find UAV variable." );\r
- VBD( size <= max(1, pVariable->pType->Elements), "Loading error: UAV array index out of range." );\r
- VBD( pVariable->pType->IsUnorderedAccessView(), "Loading error: UAV variable expected." );\r
- pUnorderedAccessView = pVariable->Data.pUnorderedAccessView;\r
- break;\r
-\r
- case D3D10_SIT_SAMPLER:\r
- eRange = ER_Sampler;\r
-\r
- pVariable = m_pEffect->FindVariableByNameWithParsing(pName);\r
- VBD( pVariable != NULL, "Loading error: cannot find sampler variable." );\r
- VBD( size <= max(1, pVariable->pType->Elements), "Loading error: sampler array index out of range." );\r
- VBD( pVariable->pType->IsSampler(), "Loading error: sampler variable expected." );\r
- pSampler = pVariable->Data.pSampler;\r
- break;\r
-\r
- default:\r
- VHD( E_FAIL, "Internal loading error: unexpected shader dependency type." );\r
- };\r
-\r
- //\r
- // Here's where the "optimized" part comes in; whenever there's\r
- // a resource dependency, see if it's located contiguous to\r
- // an existing resource dependency and merge them together\r
- // if possible\r
- //\r
- UINT rangeCount;\r
- pvRange = &vRanges[eRange];\r
- rangeCount = pvRange->GetSize();\r
-\r
- if ( rangeCount > 0 )\r
- {\r
- // Can we continue an existing range?\r
- pRange = &( (*pvRange)[rangeCount - 1] );\r
-\r
- // Make sure that bind points are strictly increasing,\r
- // otherwise this algorithm breaks and we'd get worse runtime performance\r
- D3DXASSERT(pRange->last <= bindPoint);\r
-\r
- if ( pRange->last != bindPoint )\r
- {\r
- if( eRange != ER_UnorderedAccessView )\r
- {\r
- // No we can't. Begin a new range by setting rangeCount to 0 and triggering the next IF\r
- rangeCount = 0;\r
- }\r
- else\r
- {\r
- // UAVs will always be located in one range, as they are more expensive to set\r
- while(pRange->last < bindPoint)\r
- {\r
- VHD( pRange->vResources.Add(&g_NullUnorderedAccessView), "Internal loading error: cannot add UAV to range." );\r
- pRange->last++;\r
- }\r
- }\r
- }\r
- }\r
-\r
- if ( rangeCount == 0 )\r
- {\r
- VN( pRange = pvRange->Add() );\r
- pRange->start = bindPoint;\r
- }\r
-\r
- pRange->last = bindPoint + size;\r
-\r
- switch( ResourceDesc.Type )\r
- {\r
- case D3D10_SIT_CBUFFER:\r
- VHD( pRange->vResources.Add(pCB), "Internal loading error: cannot add cbuffer to range." );\r
- break;\r
- case D3D10_SIT_TBUFFER:\r
- VHD( pRange->vResources.Add(pShaderResource), "Internal loading error: cannot add tbuffer to range." );\r
- VHD( vTBuffers.Add( (SConstantBuffer*)pCB ), "Internal loading error: cannot add tbuffer to vector." );\r
- break;\r
- case D3D10_SIT_TEXTURE:\r
- case D3D11_SIT_STRUCTURED:\r
- case D3D11_SIT_BYTEADDRESS:\r
- if (isFX9TextureLoad)\r
- {\r
- // grab all of the textures from each sampler\r
- for (j = 0; j < size; ++ j)\r
- {\r
- VHD( pRange->vResources.Add(pSampler[j].BackingStore.pTexture), "Internal loading error: cannot add SRV to range." );\r
- }\r
- }\r
- else\r
- {\r
- // add the whole array\r
- for (j = 0; j < size; ++ j)\r
- {\r
- VHD( pRange->vResources.Add(pShaderResource + j), "Internal loading error: cannot add SRV to range." );\r
- }\r
- }\r
- break;\r
- case D3D11_SIT_UAV_RWTYPED:\r
- case D3D11_SIT_UAV_RWSTRUCTURED:\r
- case D3D11_SIT_UAV_RWBYTEADDRESS:\r
- case D3D11_SIT_UAV_APPEND_STRUCTURED:\r
- case D3D11_SIT_UAV_CONSUME_STRUCTURED:\r
- case D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:\r
- // add the whole array\r
- for (j = 0; j < size; ++ j)\r
- {\r
- VHD( pRange->vResources.Add(pUnorderedAccessView + j), "Internal loading error: cannot add UAV to range." );\r
- }\r
- break;\r
- case D3D10_SIT_SAMPLER:\r
- // add the whole array\r
- for (j = 0; j < size; ++ j)\r
- {\r
- VHD( pRange->vResources.Add(pSampler + j), "Internal loading error: cannot add sampler to range." );\r
- }\r
- break;\r
- default:\r
- VHD( E_FAIL, "Internal loading error: unexpected shader dependency type." );\r
- }\r
- }\r
-\r
-\r
- //////////////////////////////////////////////////////////////////////////\r
- // Step 2: iterate through the interfaces and build\r
- // an "optimized" list of all of the dependencies\r
-\r
- UINT NumInterfaces = pShaderBlock->pReflectionData->pReflection->GetNumInterfaceSlots();\r
- UINT CurInterfaceParameter = 0;\r
- if( NumInterfaces > 0 )\r
- {\r
- D3DXASSERT( ShaderDesc.ConstantBuffers > 0 );\r
-\r
- for( i=0; i < ShaderDesc.ConstantBuffers; i++ )\r
- {\r
- ID3D11ShaderReflectionConstantBuffer* pCB = pShaderBlock->pReflectionData->pReflection->GetConstantBufferByIndex(i);\r
- VN( pCB );\r
- D3D11_SHADER_BUFFER_DESC CBDesc;\r
- VHD( pCB->GetDesc( &CBDesc ), "Internal loading error: cannot get CB desc." );\r
- if( CBDesc.Type != D3D11_CT_INTERFACE_POINTERS )\r
- {\r
- continue;\r
- }\r
-\r
- for( UINT iVar=0; iVar < CBDesc.Variables; iVar++ )\r
- {\r
- ID3D11ShaderReflectionVariable* pInterfaceVar = pCB->GetVariableByIndex( iVar );\r
- VN( pInterfaceVar );\r
- D3D11_SHADER_VARIABLE_DESC InterfaceDesc;\r
- pInterfaceVar->GetDesc( &InterfaceDesc );\r
-\r
- LPCSTR pName;\r
- UINT bindPoint, size;\r
- SGlobalVariable *pVariable = NULL;\r
- SInterface *pInterface = NULL;\r
- UINT VariableElements;\r
-\r
- pName = InterfaceDesc.Name;\r
- bindPoint = InterfaceDesc.StartOffset;\r
- size = InterfaceDesc.Size;\r
-\r
- if( bindPoint == (UINT)-1 )\r
- {\r
- continue;\r
- }\r
-\r
- D3DXASSERT( InterfaceDesc.uFlags & D3D11_SVF_INTERFACE_POINTER );\r
- if( InterfaceDesc.uFlags & D3D11_SVF_INTERFACE_PARAMETER )\r
- {\r
- // This interface pointer is a parameter to the shader\r
- if( pShaderBlock->pReflectionData->InterfaceParameterCount == 0 )\r
- {\r
- // There may be no interface parameters in this shader if it was compiled but had no interfaced bound to it.\r
- // The shader cannot be set (correctly) in any pass.\r
- continue;\r
- }\r
- else\r
- {\r
- VBD( CurInterfaceParameter < pShaderBlock->pReflectionData->InterfaceParameterCount,\r
- "Internal loading error: interface count mismatch.");\r
- SShaderBlock::SInterfaceParameter* pInterfaceInfo;\r
- pInterfaceInfo = &pShaderBlock->pReflectionData->pInterfaceParameters[CurInterfaceParameter];\r
- ++CurInterfaceParameter;\r
- SGlobalVariable *pParent = m_pEffect->FindVariableByName(pInterfaceInfo->pName);\r
- VBD( pParent != NULL, "Loading error: cannot find parent type." );\r
- if( pInterfaceInfo->Index == (UINT)-1 )\r
- {\r
- pVariable = pParent;\r
- VariableElements = pVariable->pType->Elements;\r
- }\r
- else\r
- {\r
- // We want a specific index of the variable (ex. "MyVar[2]")\r
- VBD( size == 1, "Loading error: interface array type mismatch." );\r
- pVariable = (SGlobalVariable*)pParent->GetElement( pInterfaceInfo->Index );\r
- VBD( pVariable->IsValid(), "Loading error: interface array index out of range." );\r
- VariableElements = 0;\r
- }\r
- }\r
- }\r
- else\r
- {\r
- // This interface pointer is a global interface used in the shader\r
- pVariable = m_pEffect->FindVariableByName(pName);\r
- VBD( pVariable != NULL, "Loading error: cannot find interface variable." );\r
- VariableElements = pVariable->pType->Elements;\r
- }\r
- VBD( size <= max(1, VariableElements), "Loading error: interface array size mismatch." );\r
- if( pVariable->pType->IsInterface() )\r
- {\r
- pInterface = pVariable->Data.pInterface;\r
- }\r
- else if( pVariable->pType->IsClassInstance() )\r
- {\r
- // For class instances, we create background interfaces which point to the class instance. This is done so\r
- // the shader can always expect SInterface dependencies, rather than a mix of SInterfaces and class instances\r
- VN( pInterface = PRIVATENEW SInterface[size] );\r
- if( VariableElements == 0 )\r
- {\r
- D3DXASSERT( size == 1 );\r
- pInterface[0].pClassInstance = (SClassInstanceGlobalVariable*)pVariable;\r
- m_BackgroundInterfaces.Add( &pInterface[0] );\r
- }\r
- else\r
- {\r
- // Fill each element of the SInstance array individually\r
- VBD( size == VariableElements, "Loading error: class instance array size mismatch." );\r
- for( UINT iElement=0; iElement < size; iElement++ )\r
- {\r
- SGlobalVariable *pElement = (SGlobalVariable*)pVariable->GetElement( iElement );\r
- VBD( pElement->IsValid(), "Internal loading error: class instance array index out of range." );\r
- pInterface[iElement].pClassInstance = (SClassInstanceGlobalVariable*)pElement;\r
- m_BackgroundInterfaces.Add( &pInterface[iElement] );\r
- }\r
- }\r
- }\r
- else\r
- {\r
- VHD( E_FAIL, "Loading error: invalid interface initializer variable type.");\r
- }\r
-\r
- //\r
- // Here's where the "optimized" part comes in; whenever there's\r
- // a resource dependency, see if it's located contiguous to\r
- // an existing resource dependency and merge them together\r
- // if possible\r
- //\r
- UINT rangeCount;\r
- pvRange = &vRanges[ER_Interfaces];\r
- rangeCount = pvRange->GetSize();\r
-\r
- VBD( rangeCount <= 1, "Internal loading error: invalid range count." );\r
-\r
- if ( rangeCount == 0 )\r
- {\r
- VN( pRange = pvRange->Add() );\r
- pRange->start = pRange->last = 0;\r
- }\r
- else\r
- {\r
- pRange = &( (*pvRange)[0] );\r
- }\r
-\r
- if( bindPoint < pRange->last )\r
- {\r
- // add interfaces into the range that already exists\r
- VBD( bindPoint + size < pRange->last, "Internal loading error: range overlap." );\r
- for( j = 0; j < size; ++ j )\r
- {\r
- pRange->vResources[j + bindPoint] = pInterface + j;\r
- }\r
- }\r
- else\r
- {\r
- // add interfaces to the end of the range\r
-\r
- // add missing interface slots, if necessary\r
- while(pRange->last < bindPoint)\r
- {\r
- VHD( pRange->vResources.Add(&g_NullInterface), "Internal loading error: cannot add NULL interface to range." );\r
- pRange->last++;\r
- }\r
-\r
- D3DXASSERT( bindPoint == pRange->last );\r
- for( j=0; j < size; ++ j )\r
- {\r
- VHD( pRange->vResources.Add(pInterface + j), "Internal loading error: cannot at interface to range." );\r
- }\r
- pRange->last = bindPoint + size;\r
- }\r
- }\r
-\r
- // There is only one interface cbuffer\r
- break;\r
- }\r
- }\r
-\r
- //////////////////////////////////////////////////////////////////////////\r
- // Step 3: allocate room in pShaderBlock for all of the dependency \r
- // pointers and then hook them up\r
-\r
- pShaderBlock->SampDepCount = vRanges[ ER_Sampler ].GetSize();\r
- pShaderBlock->CBDepCount = vRanges[ ER_CBuffer ].GetSize();\r
- pShaderBlock->InterfaceDepCount = vRanges[ ER_Interfaces ].GetSize();\r
- pShaderBlock->ResourceDepCount = vRanges[ ER_Texture ].GetSize();\r
- pShaderBlock->UAVDepCount = vRanges[ ER_UnorderedAccessView ].GetSize();\r
- pShaderBlock->TBufferDepCount = vTBuffers.GetSize();\r
-\r
- VN( pShaderBlock->pSampDeps = PRIVATENEW SShaderSamplerDependency[pShaderBlock->SampDepCount] );\r
- VN( pShaderBlock->pCBDeps = PRIVATENEW SShaderCBDependency[pShaderBlock->CBDepCount] );\r
- VN( pShaderBlock->pInterfaceDeps = PRIVATENEW SInterfaceDependency[pShaderBlock->InterfaceDepCount] );\r
- VN( pShaderBlock->pResourceDeps = PRIVATENEW SShaderResourceDependency[pShaderBlock->ResourceDepCount] );\r
- VN( pShaderBlock->pUAVDeps = PRIVATENEW SUnorderedAccessViewDependency[pShaderBlock->UAVDepCount] );\r
- VN( pShaderBlock->ppTbufDeps = PRIVATENEW SConstantBuffer*[pShaderBlock->TBufferDepCount] );\r
-\r
- for (i=0; i<pShaderBlock->CBDepCount; ++i)\r
- {\r
- SShaderCBDependency *pDep = &pShaderBlock->pCBDeps[i];\r
-\r
- pRange = &vRanges[ER_CBuffer][i];\r
-\r
- pDep->StartIndex = pRange->start;\r
- pDep->Count = pRange->last - pDep->StartIndex;\r
- pDep->ppFXPointers = PRIVATENEW SConstantBuffer*[ pDep->Count ];\r
- pDep->ppD3DObjects = PRIVATENEW ID3D11Buffer*[ pDep->Count ];\r
-\r
- D3DXASSERT(pDep->Count == pRange->vResources.GetSize());\r
- for (j=0; j<pDep->Count; ++j)\r
- {\r
- pDep->ppFXPointers[j] = (SConstantBuffer *)pRange->vResources[j];\r
- pDep->ppD3DObjects[j] = NULL;\r
- }\r
- }\r
-\r
- for (i=0; i<pShaderBlock->SampDepCount; ++i)\r
- {\r
- SShaderSamplerDependency *pDep = &pShaderBlock->pSampDeps[i];\r
-\r
- pRange = &vRanges[ER_Sampler][i];\r
-\r
- pDep->StartIndex = pRange->start;\r
- pDep->Count = pRange->last - pDep->StartIndex;\r
- pDep->ppFXPointers = PRIVATENEW SSamplerBlock*[ pDep->Count ];\r
- pDep->ppD3DObjects = PRIVATENEW ID3D11SamplerState*[ pDep->Count ];\r
-\r
- D3DXASSERT(pDep->Count == pRange->vResources.GetSize());\r
- for (j=0; j<pDep->Count; ++j)\r
- {\r
- pDep->ppFXPointers[j] = (SSamplerBlock *) pRange->vResources[j];\r
- pDep->ppD3DObjects[j] = NULL;\r
- }\r
- }\r
-\r
- for (i=0; i<pShaderBlock->InterfaceDepCount; ++i)\r
- {\r
- SInterfaceDependency *pDep = &pShaderBlock->pInterfaceDeps[i];\r
-\r
- pRange = &vRanges[ER_Interfaces][i];\r
-\r
- pDep->StartIndex = pRange->start;\r
- pDep->Count = pRange->last - pDep->StartIndex;\r
- pDep->ppFXPointers = PRIVATENEW SInterface*[ pDep->Count ];\r
- pDep->ppD3DObjects = PRIVATENEW ID3D11ClassInstance*[ pDep->Count ];\r
-\r
- D3DXASSERT(pDep->Count == pRange->vResources.GetSize());\r
- for (j=0; j<pDep->Count; ++j)\r
- {\r
- pDep->ppFXPointers[j] = (SInterface *) pRange->vResources[j];\r
- pDep->ppD3DObjects[j] = NULL;\r
- }\r
- }\r
-\r
- for (i=0; i<pShaderBlock->ResourceDepCount; ++i)\r
- {\r
- SShaderResourceDependency *pDep = &pShaderBlock->pResourceDeps[i];\r
-\r
- pRange = &vRanges[ER_Texture][i];\r
-\r
- pDep->StartIndex = pRange->start;\r
- pDep->Count = pRange->last - pDep->StartIndex;\r
- pDep->ppFXPointers = PRIVATENEW SShaderResource*[ pDep->Count ];\r
- pDep->ppD3DObjects = PRIVATENEW ID3D11ShaderResourceView*[ pDep->Count ];\r
-\r
- D3DXASSERT(pDep->Count == pRange->vResources.GetSize());\r
- for (j=0; j<pDep->Count; ++j)\r
- {\r
- pDep->ppFXPointers[j] = (SShaderResource *) pRange->vResources[j];\r
- pDep->ppD3DObjects[j] = NULL;\r
- }\r
- }\r
-\r
- for (i=0; i<pShaderBlock->UAVDepCount; ++i)\r
- {\r
- SUnorderedAccessViewDependency *pDep = &pShaderBlock->pUAVDeps[i];\r
-\r
- pRange = &vRanges[ER_UnorderedAccessView][i];\r
-\r
- pDep->StartIndex = pRange->start;\r
- pDep->Count = pRange->last - pDep->StartIndex;\r
- pDep->ppFXPointers = PRIVATENEW SUnorderedAccessView*[ pDep->Count ];\r
- pDep->ppD3DObjects = PRIVATENEW ID3D11UnorderedAccessView*[ pDep->Count ];\r
-\r
- D3DXASSERT(pDep->Count == pRange->vResources.GetSize());\r
- for (j=0; j<pDep->Count; ++j)\r
- {\r
- pDep->ppFXPointers[j] = (SUnorderedAccessView *) pRange->vResources[j];\r
- pDep->ppD3DObjects[j] = NULL;\r
- }\r
- }\r
-\r
- if (pShaderBlock->TBufferDepCount > 0)\r
- {\r
- memcpy(pShaderBlock->ppTbufDeps, &vTBuffers[0], pShaderBlock->TBufferDepCount * sizeof(SConstantBuffer*));\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// Create shader reflection interface and grab dependency info\r
-HRESULT CEffectLoader::BuildShaderBlock(SShaderBlock *pShaderBlock)\r
-{\r
- HRESULT hr = S_OK;\r
-\r
- // unused shader block? that's not right\r
- VBD( pShaderBlock->pVT != NULL, "Internal loading error: NULL shader vtable." );\r
-\r
- D3DXASSERT(pShaderBlock->pD3DObject == NULL);\r
-\r
- if (NULL == pShaderBlock->pReflectionData)\r
- {\r
- // File contains a shader variable without an assigned shader, or this is a null assignment.\r
- // Usually, this is called by one of these guys:\r
- // SetVertexShader( NULL );\r
- // or \r
- // vertexshader g_VS = NULL;\r
- return S_OK;\r
- }\r
-\r
- // Initialize the reflection interface\r
- VHD( D3DReflect( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, IID_ID3D11ShaderReflection, (void**)&pShaderBlock->pReflectionData->pReflection ),\r
- "Internal loading error: cannot create shader reflection object." );\r
-\r
- // Get dependencies\r
- VH( GrabShaderData( pShaderBlock ) );\r
-\r
- // Grab input signatures for VS\r
- if( EOT_VertexShader == pShaderBlock->GetShaderType() )\r
- {\r
- D3DXASSERT( pShaderBlock->pInputSignatureBlob == NULL );\r
- VHD( D3DGetInputSignatureBlob( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, &pShaderBlock->pInputSignatureBlob ),\r
- "Internal loading error: cannot get input signature." );\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-#undef PRIVATENEW\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Code to relocate data to private heaps (reflection & runtime effect)\r
-//\r
-// Important note about alignment: all reasonable chunks of data are \r
-// machine word aligned (that is, any piece of data moved as a whole is \r
-// aligned as a whole. This means that when computing m_ReflectionMemory\r
-// or m_EffectMemory, each addition is aligned. This also means \r
-// that, when later relocating that same memory, you must call MoveData\r
-// or MoveString on the same chunks that were aligned. This is \r
-// because: Align(a * b) != a * Align(b).\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Reflection reallocation code\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-HRESULT CEffectLoader::CalculateAnnotationSize(UINT cAnnotations, SAnnotation *pAnnotations)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i;\r
-\r
- m_ReflectionMemory += AlignToPowerOf2(cAnnotations * sizeof(SAnnotation), c_DataAlignment);\r
- for (i=0; i<cAnnotations; i++)\r
- {\r
- if (pAnnotations[i].pType->BelongsInConstantBuffer())\r
- {\r
- m_ReflectionMemory += AlignToPowerOf2(pAnnotations[i].pType->TotalSize, c_DataAlignment);\r
- }\r
- else\r
- {\r
- VBD( pAnnotations[i].pType->IsObjectType(EOT_String), "Invalid pEffectBuffer: invalid annotation type." );\r
-\r
- UINT cElements;\r
- cElements = max(1, pAnnotations[i].pType->Elements);\r
- \r
- m_ReflectionMemory += AlignToPowerOf2(cElements * sizeof(SString), c_DataAlignment);\r
- \r
- }\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::ReallocateAnnotationData(UINT cAnnotations, SAnnotation **ppAnnotations)\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i;\r
- SAnnotation *pAnnotations;\r
-\r
- VHD( m_pReflection->m_Heap.MoveData((void**) ppAnnotations, cAnnotations * sizeof(SAnnotation)),\r
- "Internal loading error: cannot move annotation data." );\r
- pAnnotations = *ppAnnotations;\r
-\r
- for (i=0; i<cAnnotations; i++)\r
- {\r
- SAnnotation *pAn = &pAnnotations[i];\r
- pAn->pEffect = m_pEffect;\r
-\r
- VHD( m_pReflection->m_Heap.MoveString(&pAn->pName), "Internal loading error: cannot move annotation name." );\r
-\r
- // Reallocate type later\r
- if (pAn->pType->BelongsInConstantBuffer())\r
- {\r
- VHD( m_pReflection->m_Heap.MoveData( &pAn->Data.pGeneric, pAn->pType->TotalSize ), "Internal loading error: cannot move annotation data." );\r
- }\r
- else if (pAnnotations[i].pType->IsObjectType(EOT_String))\r
- {\r
- UINT j;\r
- UINT cElements = max(1, pAn->pType->Elements);\r
- \r
- VHD( m_pReflection->m_Heap.MoveData((void**) &pAn->Data.pString, cElements * sizeof(SString)), "Internal loading error: cannot move annotation string." );\r
- for (j = 0; j < cElements; ++ j)\r
- {\r
- VHD( m_pReflection->m_Heap.MoveString(&pAn->Data.pString[j].pString), "Internal loading error: cannot move annotation string element." );\r
- }\r
- }\r
- else\r
- {\r
- VHD( E_FAIL, "Invalid pEffectBuffer: invalid annotation type." );\r
- }\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-HRESULT CEffectLoader::InitializeReflectionDataAndMoveStrings( UINT KnownSize )\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j, k;\r
- UINT cbStrings;\r
- CEffectHeap *pHeap = &m_pReflection->m_Heap;\r
-\r
- // Get byte counts\r
- cbStrings = m_pEffect->m_StringCount * sizeof( SString );\r
-\r
- if( KnownSize )\r
- {\r
- m_ReflectionMemory = KnownSize;\r
- }\r
- else\r
- {\r
- m_ReflectionMemory += AlignToPowerOf2(cbStrings, c_DataAlignment);\r
-\r
- for (i=0; i<m_pEffect->m_CBCount; i++)\r
- {\r
- VH( CalculateAnnotationSize(m_pEffect->m_pCBs[i].AnnotationCount, m_pEffect->m_pCBs[i].pAnnotations) );\r
- }\r
-\r
- for (i=0; i<m_pEffect->m_VariableCount; i++)\r
- {\r
- VH( CalculateAnnotationSize(m_pEffect->m_pVariables[i].AnnotationCount, m_pEffect->m_pVariables[i].pAnnotations) );\r
- }\r
-\r
- for (i=0; i<m_pEffect->m_GroupCount; i++)\r
- {\r
- VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].AnnotationCount, m_pEffect->m_pGroups[i].pAnnotations) );\r
-\r
- for (j=0; j<m_pEffect->m_pGroups[i].TechniqueCount; j++)\r
- {\r
- VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].pTechniques[j].AnnotationCount, m_pEffect->m_pGroups[i].pTechniques[j].pAnnotations) );\r
-\r
- for (k=0; k<m_pEffect->m_pGroups[i].pTechniques[j].PassCount; k++)\r
- {\r
- VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount, m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations) );\r
- }\r
- }\r
- }\r
-\r
- // Calculate shader reflection data size\r
- for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)\r
- {\r
- if (NULL != m_pEffect->m_pShaderBlocks[i].pReflectionData)\r
- {\r
- m_ReflectionMemory += AlignToPowerOf2(sizeof(SShaderBlock::SReflectionData), c_DataAlignment);\r
- m_ReflectionMemory += AlignToPowerOf2(m_pEffect->m_pShaderBlocks[i].pReflectionData->BytecodeLength, c_DataAlignment);\r
- // stream out decl is handled as a string, and thus its size is already factored because of GetStringAndAddToReflection\r
- }\r
- }\r
- }\r
-\r
- VHD( pHeap->ReserveMemory(m_ReflectionMemory), "Internal loading error: failed to reserve reflection memory." );\r
-\r
- // Strings are handled separately because we are moving them to reflection\r
- m_pOldStrings = m_pEffect->m_pStrings;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pStrings, cbStrings), "Internal loading error: cannot move string data." );\r
- for(i=0; i<m_pEffect->m_StringCount; i++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pStrings[i].pString), "Internal loading error: cannot move string pointer." );\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-// Move all reflection data to private heap\r
-HRESULT CEffectLoader::ReallocateReflectionData( bool Cloning )\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j, k;\r
- CEffectHeap *pHeap = &m_pReflection->m_Heap;\r
-\r
- for(i=0; i<m_pEffect->m_CBCount; i++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pCBs[i].pName ), "Internal loading error: cannot move CB name." );\r
- VH( ReallocateAnnotationData(m_pEffect->m_pCBs[i].AnnotationCount, &m_pEffect->m_pCBs[i].pAnnotations) );\r
- }\r
-\r
- for(i=0; i<m_pEffect->m_VariableCount; i++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pVariables[i].pName ), "Internal loading error: cannot move variable name." );\r
- VHD( pHeap->MoveString( &m_pEffect->m_pVariables[i].pSemantic ), "Internal loading error: cannot move variable semantic." );\r
- VH( ReallocateAnnotationData(m_pEffect->m_pVariables[i].AnnotationCount, &m_pEffect->m_pVariables[i].pAnnotations) );\r
- }\r
-\r
- for(i=0; i<m_pEffect->m_GroupCount; i++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pName ), "Internal loading error: cannot move group name." );\r
- VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].AnnotationCount, &m_pEffect->m_pGroups[i].pAnnotations) );\r
-\r
- for(j=0; j<m_pEffect->m_pGroups[i].TechniqueCount; j++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pTechniques[j].pName ), "Internal loading error: cannot move technique name." );\r
- VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].pTechniques[j].AnnotationCount, &m_pEffect->m_pGroups[i].pTechniques[j].pAnnotations) );\r
- \r
- for(k=0; k<m_pEffect->m_pGroups[i].pTechniques[j].PassCount; k++)\r
- {\r
- VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pName ), "Internal loading error: cannot move pass name." );\r
- VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount, &m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations) );\r
- }\r
- }\r
- }\r
-\r
- if( !Cloning )\r
- {\r
- // When not cloning, every member in m_pMemberInterfaces is from a global variable, so we can take pName and pSemantic\r
- // from the parent variable, which were updated above\r
- for (i = 0; i < m_pEffect->m_pMemberInterfaces.GetSize(); ++ i)\r
- {\r
- SMember* pMember = m_pEffect->m_pMemberInterfaces[i];\r
- SGlobalVariable* pTopLevelEntity = (SGlobalVariable*)pMember->pTopLevelEntity;\r
- VH( FixupVariablePointer( &pTopLevelEntity ) );\r
- pMember->pName = pTopLevelEntity->pName;\r
- pMember->pSemantic = pTopLevelEntity->pSemantic;\r
- }\r
- }\r
-\r
- // Move shader bytecode\r
- for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)\r
- {\r
- if (NULL != m_pEffect->m_pShaderBlocks[i].pReflectionData)\r
- {\r
- VHD( pHeap->MoveData((void**)&m_pEffect->m_pShaderBlocks[i].pReflectionData, sizeof(SShaderBlock::SReflectionData)),\r
- "Internal loading error: cannot move shader reflection block." );\r
- VHD( pHeap->MoveData((void**)&m_pEffect->m_pShaderBlocks[i].pReflectionData->pBytecode, m_pEffect->m_pShaderBlocks[i].pReflectionData->BytecodeLength),\r
- "Internal loading error: cannot move shader bytecode.");\r
- for( UINT iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )\r
- {\r
- VHD( pHeap->MoveString(&m_pEffect->m_pShaderBlocks[i].pReflectionData->pStreamOutDecls[iDecl]), "Internal loading error: cannot move SO decl." );\r
- }\r
- VH( pHeap->MoveInterfaceParameters(m_pEffect->m_pShaderBlocks[i].pReflectionData->InterfaceParameterCount, &m_pEffect->m_pShaderBlocks[i].pReflectionData->pInterfaceParameters ) );\r
- }\r
- \r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Runtime effect reallocation code\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-template<class T> HRESULT CEffectLoader::ReallocateBlockAssignments(T* &pBlocks, UINT cBlocks, T* pOldBlocks)\r
-{\r
- HRESULT hr = S_OK;\r
- CEffectHeap *pHeap = &m_pEffect->m_Heap;\r
- UINT i, j;\r
-\r
- for(i=0; i<cBlocks; i++)\r
- {\r
- T *pBlock = &pBlocks[i];\r
- VHD( pHeap->MoveData((void**) &pBlock->pAssignments, sizeof(SAssignment)*pBlock->AssignmentCount), "Internal loading error: cannot move assignment count." );\r
-\r
- for (j=0; j<pBlock->AssignmentCount; j++)\r
- {\r
- SAssignment *pAssignment = &pBlock->pAssignments[j];\r
- UINT cbDeps;\r
-\r
- // When cloning, convert pointers back into offsets\r
- if( pOldBlocks )\r
- {\r
- T *pOldBlock = &pOldBlocks[i];\r
- pAssignment->Destination.Offset = (UINT)( (UINT_PTR)pAssignment->Destination.pGeneric - (UINT_PTR)pOldBlock ) ;\r
- }\r
-\r
- // Convert destination pointers from offset to real pointer\r
- pAssignment->Destination.pGeneric = (BYTE*) pBlock + pAssignment->Destination.Offset;\r
-\r
- // Make sure the data pointer points into the backing store\r
- VBD( pAssignment->Destination.pGeneric >= &pBlock->BackingStore && \r
- pAssignment->Destination.pGeneric < (BYTE*) &pBlock->BackingStore + sizeof(pBlock->BackingStore), \r
- "Internal loading error: assignment destination out of range." );\r
-\r
- // Fixup dependencies\r
- cbDeps = pAssignment->DependencyCount * sizeof(SAssignment::SDependency);\r
- VHD( pHeap->MoveData((void**) &pAssignment->pDependencies, cbDeps), "Internal loading error: cannot move assignment dependencies." );\r
-\r
- SGlobalVariable *pOldVariable = NULL;\r
- for(UINT iDep=0; iDep<pAssignment->DependencyCount; iDep++)\r
- {\r
- SAssignment::SDependency *pDep = &pAssignment->pDependencies[iDep];\r
- // We ignore all but the last variable because below, we only use the last dependency\r
- pOldVariable = pDep->pVariable;\r
- VH( FixupVariablePointer(&pDep->pVariable) );\r
- }\r
-\r
- // Fixup source pointers\r
- switch(pAssignment->LhsType)\r
- {\r
- case ELHS_VertexShaderBlock:\r
- case ELHS_PixelShaderBlock:\r
- case ELHS_GeometryShaderBlock:\r
- case ELHS_HullShaderBlock:\r
- case ELHS_DomainShaderBlock:\r
- case ELHS_ComputeShaderBlock:\r
- VH( FixupShaderPointer(&pAssignment->Source.pShader) );\r
- break;\r
-\r
- case ELHS_DepthStencilBlock:\r
- VH( FixupDSPointer((SDepthStencilBlock**)&pAssignment->Source.pBlock) );\r
- break;\r
- case ELHS_BlendBlock:\r
- VH( FixupABPointer((SBlendBlock**) &pAssignment->Source.pBlock) );\r
- break;\r
- case ELHS_RasterizerBlock:\r
- VH( FixupRSPointer((SRasterizerBlock**) &pAssignment->Source.pBlock) );\r
- break;\r
-\r
- case ELHS_Texture:\r
- VH( FixupShaderResourcePointer((SShaderResource**) &pAssignment->Source.pShaderResource) );\r
- break;\r
-\r
- default:\r
- // Non-object assignment (must have at least one dependency or it would have been pruned by now)\r
- D3DXASSERT( !pAssignment->IsObjectAssignment() && pAssignment->DependencyCount > 0 );\r
-\r
- // Numeric variables must be relocated before this function is called\r
- \r
- switch (pAssignment->AssignmentType)\r
- {\r
- case ERAT_NumericVariable:\r
- case ERAT_NumericVariableIndex:\r
- // the variable or variable array is always the last dependency in the chain\r
- SGlobalVariable *pVariable;\r
- pVariable = pAssignment->pDependencies[pAssignment->DependencyCount - 1].pVariable;\r
- D3DXASSERT( pVariable->pType->BelongsInConstantBuffer() && NULL != pVariable->pCB );\r
-\r
- // When cloning, convert pointers back into offsets\r
- if( pOldBlocks )\r
- {\r
- VBD( pOldVariable != NULL, "Internal loading error: pOldVariable is NULL." );\r
- pAssignment->Source.Offset = pAssignment->Source.pNumeric - pOldVariable->pCB->pBackingStore;\r
- }\r
-\r
- // Convert from offset to pointer\r
- pAssignment->Source.pNumeric = pVariable->pCB->pBackingStore + pAssignment->Source.Offset;\r
- break;\r
-\r
- default:\r
- // Shouldn't be able to get here\r
- D3DXASSERT(0);\r
- VHD( E_FAIL, "Loading error: invalid assignment type." );\r
- }\r
- break;\r
-\r
- case ELHS_Invalid:\r
- VHD( E_FAIL, "Loading error: invalid assignment type." );\r
- }\r
-\r
- D3DXASSERT(m_pEffect->m_LocalTimer > 0);\r
- m_pEffect->EvaluateAssignment(pAssignment);\r
- }\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-template<class T> UINT CEffectLoader::CalculateBlockAssignmentSize(T* &pBlocks, UINT cBlocks)\r
-{\r
- UINT dwSize = 0;\r
- UINT i, j;\r
-\r
- for(i=0; i<cBlocks; i++)\r
- {\r
- SBaseBlock *pBlock = &pBlocks[i];\r
- dwSize += AlignToPowerOf2(pBlock->AssignmentCount * sizeof(SAssignment), c_DataAlignment);\r
- \r
- for (j=0; j<pBlock->AssignmentCount; j++)\r
- {\r
- SAssignment *pAssignment = &pBlock->pAssignments[j];\r
- \r
- dwSize += AlignToPowerOf2(pAssignment->DependencyCount * sizeof(SAssignment::SDependency), c_DataAlignment);\r
- }\r
- }\r
-\r
- return dwSize;\r
-}\r
-\r
-HRESULT CEffectLoader::ReallocateShaderBlocks()\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j, k;\r
- CEffectHeap *pHeap = &m_pEffect->m_Heap;\r
- const char* pError = "Internal loading error: cannot move shader data.";\r
- \r
- for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)\r
- {\r
- SShaderBlock *pShader = &m_pEffect->m_pShaderBlocks[i];\r
-\r
- // pShader->pReflection data and all of its members (bytecode, SO decl, etc.) are handled by ReallocateReflectionData()\r
- VHD( pHeap->MoveData((void**) &pShader->pCBDeps, pShader->CBDepCount * sizeof(SShaderCBDependency)), pError );\r
- VHD( pHeap->MoveData((void**) &pShader->pSampDeps, pShader->SampDepCount * sizeof(SShaderSamplerDependency)), pError );\r
- VHD( pHeap->MoveData((void**) &pShader->pInterfaceDeps, pShader->InterfaceDepCount * sizeof(SInterfaceDependency)), pError );\r
- VHD( pHeap->MoveData((void**) &pShader->pResourceDeps, pShader->ResourceDepCount * sizeof(SShaderResourceDependency)), pError );\r
- VHD( pHeap->MoveData((void**) &pShader->pUAVDeps, pShader->UAVDepCount * sizeof(SUnorderedAccessViewDependency)), pError );\r
- VHD( pHeap->MoveData((void**) &pShader->ppTbufDeps, pShader->TBufferDepCount * sizeof(SConstantBuffer*)), pError );\r
- \r
- for (j=0; j<pShader->CBDepCount; j++)\r
- {\r
- SShaderCBDependency *pCBDeps = &pShader->pCBDeps[j];\r
- VHD( pHeap->MoveData((void**) &pCBDeps->ppD3DObjects, pCBDeps->Count * sizeof(ID3D11Buffer*)), pError );\r
- VHD( pHeap->MoveData((void**) &pCBDeps->ppFXPointers, pCBDeps->Count * sizeof(SConstantBuffer*)), pError );\r
-\r
- for (k=0; k<pCBDeps->Count; k++)\r
- {\r
- VH( FixupCBPointer( &pCBDeps->ppFXPointers[k] ) );\r
- }\r
- }\r
-\r
- for (j=0; j<pShader->SampDepCount; j++)\r
- {\r
- SShaderSamplerDependency *pSampDeps = &pShader->pSampDeps[j];\r
- VHD( pHeap->MoveData((void**) &pSampDeps->ppD3DObjects, pSampDeps->Count * sizeof(ID3D11SamplerState*)), pError );\r
- VHD( pHeap->MoveData((void**) &pSampDeps->ppFXPointers, pSampDeps->Count * sizeof(SSamplerBlock*)), pError );\r
-\r
- for (k=0; k<pSampDeps->Count; k++)\r
- {\r
- VH( FixupSamplerPointer(&pSampDeps->ppFXPointers[k]) );\r
- }\r
- }\r
-\r
- for (j=0; j<pShader->InterfaceDepCount; j++)\r
- {\r
- SInterfaceDependency *pInterfaceDeps = &pShader->pInterfaceDeps[j];\r
- VHD( pHeap->MoveData((void**) &pInterfaceDeps->ppD3DObjects, pInterfaceDeps->Count * sizeof(ID3D11ClassInstance*)), pError );\r
- VHD( pHeap->MoveData((void**) &pInterfaceDeps->ppFXPointers, pInterfaceDeps->Count * sizeof(SInterface*)), pError );\r
-\r
- for (k=0; k<pInterfaceDeps->Count; k++)\r
- {\r
- VH( FixupInterfacePointer(&pInterfaceDeps->ppFXPointers[k], true) );\r
- }\r
- }\r
-\r
- for (j=0; j<pShader->ResourceDepCount; j++)\r
- {\r
- SShaderResourceDependency *pResourceDeps = &pShader->pResourceDeps[j];\r
- VHD( pHeap->MoveData((void**) &pResourceDeps->ppD3DObjects, pResourceDeps->Count * sizeof(ID3D11ShaderResourceView*)), pError );\r
- VHD( pHeap->MoveData((void**) &pResourceDeps->ppFXPointers, pResourceDeps->Count * sizeof(SShaderResource*)), pError );\r
-\r
- for (k=0; k<pResourceDeps->Count; k++)\r
- {\r
- VH( FixupShaderResourcePointer(&pResourceDeps->ppFXPointers[k]) );\r
- }\r
- }\r
-\r
- for (j=0; j<pShader->UAVDepCount; j++)\r
- {\r
- SUnorderedAccessViewDependency *pUAVDeps = &pShader->pUAVDeps[j];\r
- VHD( pHeap->MoveData((void**) &pUAVDeps->ppD3DObjects, pUAVDeps->Count * sizeof(ID3D11UnorderedAccessView*)), pError );\r
- VHD( pHeap->MoveData((void**) &pUAVDeps->ppFXPointers, pUAVDeps->Count * sizeof(SUnorderedAccessView*)), pError );\r
-\r
- for (k=0; k<pUAVDeps->Count; k++)\r
- {\r
- VH( FixupUnorderedAccessViewPointer(&pUAVDeps->ppFXPointers[k]) );\r
- }\r
- }\r
-\r
- for (j=0; j<pShader->TBufferDepCount; j++)\r
- {\r
- VH( FixupCBPointer( &pShader->ppTbufDeps[j] ) );\r
- }\r
- }\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-\r
-UINT CEffectLoader::CalculateShaderBlockSize()\r
-{\r
- UINT dwSize = 0;\r
- UINT i, j;\r
- \r
- for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)\r
- {\r
- SShaderBlock *pShader = &m_pEffect->m_pShaderBlocks[i];\r
-\r
- dwSize += AlignToPowerOf2(pShader->CBDepCount * sizeof(SShaderCBDependency), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pShader->SampDepCount * sizeof(SShaderSamplerDependency), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pShader->InterfaceDepCount * sizeof(SInterfaceDependency), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pShader->ResourceDepCount * sizeof(SShaderResourceDependency), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pShader->UAVDepCount * sizeof(SUnorderedAccessViewDependency), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pShader->TBufferDepCount * sizeof(SConstantBuffer*), c_DataAlignment);\r
-\r
- for (j=0; j<pShader->CBDepCount; j++)\r
- {\r
- SShaderCBDependency *pCBDeps = &pShader->pCBDeps[j];\r
- dwSize += AlignToPowerOf2(pCBDeps->Count * sizeof(ID3D11Buffer*), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pCBDeps->Count * sizeof(SConstantBuffer*), c_DataAlignment);\r
- }\r
-\r
- for (j=0; j<pShader->SampDepCount; j++)\r
- {\r
- SShaderSamplerDependency *pSampDeps = &pShader->pSampDeps[j];\r
- dwSize += AlignToPowerOf2(pSampDeps->Count * sizeof(ID3D11SamplerState*), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pSampDeps->Count * sizeof(SSamplerBlock*), c_DataAlignment);\r
- }\r
-\r
- for (j=0; j<pShader->InterfaceDepCount; j++)\r
- {\r
- SInterfaceDependency *pInterfaceDeps = &pShader->pInterfaceDeps[j];\r
- dwSize += AlignToPowerOf2(pInterfaceDeps->Count * sizeof(ID3D11ClassInstance*), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pInterfaceDeps->Count * sizeof(SInterface*), c_DataAlignment);\r
- }\r
-\r
- for (j=0; j<pShader->ResourceDepCount; j++)\r
- {\r
- SShaderResourceDependency *pResourceDeps = &pShader->pResourceDeps[j];\r
- dwSize += AlignToPowerOf2(pResourceDeps->Count * sizeof(ID3D11ShaderResourceView*), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pResourceDeps->Count * sizeof(SShaderResource*), c_DataAlignment);\r
- }\r
-\r
- for (j=0; j<pShader->UAVDepCount; j++)\r
- {\r
- SUnorderedAccessViewDependency *pUAVDeps = &pShader->pUAVDeps[j];\r
- dwSize += AlignToPowerOf2(pUAVDeps->Count * sizeof(ID3D11UnorderedAccessView*), c_DataAlignment);\r
- dwSize += AlignToPowerOf2(pUAVDeps->Count * sizeof(SUnorderedAccessView*), c_DataAlignment);\r
- }\r
- }\r
-\r
- return dwSize;\r
-}\r
-\r
-// Move all (non-reflection) effect data to private heap\r
-HRESULT CEffectLoader::ReallocateEffectData( bool Cloning )\r
-{\r
- HRESULT hr = S_OK;\r
- UINT i, j;\r
- CEffectHeap *pHeap = &m_pEffect->m_Heap;\r
- UINT cbCBs = sizeof(SConstantBuffer) * m_pEffect->m_CBCount;\r
- UINT cbVariables = sizeof(SGlobalVariable) * m_pEffect->m_VariableCount;\r
- UINT cbGroups = sizeof(STechnique) * m_pEffect->m_GroupCount;\r
- UINT cbShaders = sizeof(SShaderBlock) * m_pEffect->m_ShaderBlockCount;\r
- UINT cbDS = sizeof(SDepthStencilBlock) * m_pEffect->m_DepthStencilBlockCount;\r
- UINT cbAB = sizeof(SBlendBlock) * m_pEffect->m_BlendBlockCount;\r
- UINT cbRS = sizeof(SRasterizerBlock) * m_pEffect->m_RasterizerBlockCount;\r
- UINT cbSamplers = sizeof(SSamplerBlock) * m_pEffect->m_SamplerBlockCount;\r
- UINT cbMemberDatas = sizeof(SMemberDataPointer) * m_pEffect->m_MemberDataCount;\r
- UINT cbInterfaces = sizeof(SInterface) * m_pEffect->m_InterfaceCount;\r
- UINT cbBackgroundInterfaces = sizeof(SInterface) * m_BackgroundInterfaces.GetSize();\r
- UINT cbShaderResources = sizeof(SShaderResource) * m_pEffect->m_ShaderResourceCount;\r
- UINT cbUnorderedAccessViews = sizeof(SUnorderedAccessView) * m_pEffect->m_UnorderedAccessViewCount;\r
- UINT cbRenderTargetViews = sizeof(SRenderTargetView) * m_pEffect->m_RenderTargetViewCount;\r
- UINT cbDepthStencilViews = sizeof(SDepthStencilView) * m_pEffect->m_DepthStencilViewCount;\r
- UINT cbAnonymousShaders = sizeof(SAnonymousShader) * m_pEffect->m_AnonymousShaderCount;\r
-\r
- // Calculate memory needed\r
- m_EffectMemory += AlignToPowerOf2(cbCBs, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbVariables, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbGroups, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbShaders, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbMemberDatas, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbInterfaces + cbBackgroundInterfaces, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbShaderResources, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbUnorderedAccessViews, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbRenderTargetViews, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbDepthStencilViews, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbDS, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbAB, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbRS, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbSamplers, c_DataAlignment);\r
- m_EffectMemory += AlignToPowerOf2(cbAnonymousShaders, c_DataAlignment);\r
-\r
- m_EffectMemory += CalculateShaderBlockSize();\r
-\r
- for (i=0; i<m_pEffect->m_CBCount; i++)\r
- {\r
- SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];\r
-\r
- m_EffectMemory += AlignToPowerOf2(pCB->Size, c_DataAlignment);\r
- }\r
-\r
- for (i=0; i<m_pEffect->m_GroupCount; i++)\r
- {\r
- SGroup *pGroup = &m_pEffect->m_pGroups[i];\r
-\r
- m_EffectMemory += AlignToPowerOf2(pGroup->TechniqueCount * sizeof(STechnique), c_DataAlignment);\r
-\r
- for (j=0; j<pGroup->TechniqueCount; j++)\r
- {\r
- STechnique *pTech = &pGroup->pTechniques[j];\r
-\r
- m_EffectMemory += AlignToPowerOf2(pTech->PassCount * sizeof(SPassBlock), c_DataAlignment);\r
- m_EffectMemory += CalculateBlockAssignmentSize(pTech->pPasses, pTech->PassCount);\r
- }\r
- };\r
-\r
- m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pBlendBlocks, m_pEffect->m_BlendBlockCount);\r
- m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pDepthStencilBlocks, m_pEffect->m_DepthStencilBlockCount);\r
- m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pRasterizerBlocks, m_pEffect->m_RasterizerBlockCount);\r
- m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pSamplerBlocks, m_pEffect->m_SamplerBlockCount);\r
-\r
- // Reserve memory\r
- VHD( pHeap->ReserveMemory(m_EffectMemory), "Internal loading error: cannot reserve effect memory." );\r
-\r
- // Move DataMemberPointer blocks\r
- m_pOldMemberDataBlocks = m_pEffect->m_pMemberDataBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pMemberDataBlocks, cbMemberDatas), "Internal loading error: cannot move member data blocks." );\r
-\r
- // Move CBs\r
- m_pOldCBs = m_pEffect->m_pCBs;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pCBs, cbCBs), "Internal loading error: cannot move CB count." );\r
- for (i=0; i<m_pEffect->m_CBCount; i++)\r
- {\r
- SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];\r
-\r
- VHD( pHeap->MoveData((void**) &pCB->pBackingStore, pCB->Size), "Internal loading error: cannot move CB backing store." );\r
-\r
- if( !Cloning )\r
- {\r
- // When creating the effect, MemberDataOffsetPlus4 is used, not pMemberData\r
- if( pCB->MemberDataOffsetPlus4 )\r
- {\r
- pCB->pMemberData = (SMemberDataPointer*)( (BYTE*)m_pEffect->m_pMemberDataBlocks + ( pCB->MemberDataOffsetPlus4 - 4 ) );\r
- }\r
- }\r
- else if (pCB->pMemberData)\r
- {\r
- // When cloning an effect, pMemberData points to valid data in the original effect\r
- VH( FixupMemberDataPointer( &pCB->pMemberData ) );\r
- }\r
- }\r
-\r
- // Move numeric variables; move all variable types\r
- m_pOldVars = m_pEffect->m_pVariables;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pVariables, cbVariables), "Internal loading error: cannot move variable count." );\r
- for (i=0; i<m_pEffect->m_VariableCount; i++)\r
- {\r
- SGlobalVariable *pVar = &m_pEffect->m_pVariables[i];\r
- pVar->pEffect = m_pEffect;\r
-\r
- if( Cloning && pVar->pType->BelongsInConstantBuffer())\r
- {\r
- // Convert pointer back to offset\r
- // pVar->pCB refers to the old CB\r
- pVar->Data.Offset = (UINT_PTR)pVar->Data.pGeneric - (UINT_PTR)pVar->pCB->pBackingStore;\r
- }\r
-\r
- if (pVar->pCB)\r
- {\r
- VH( FixupCBPointer( &pVar->pCB ) );\r
- }\r
-\r
- if( !Cloning )\r
- {\r
- // When creating the effect, MemberDataOffsetPlus4 is used, not pMemberData\r
- if( pVar->MemberDataOffsetPlus4 )\r
- {\r
- pVar->pMemberData = (SMemberDataPointer*)( (BYTE*)m_pEffect->m_pMemberDataBlocks + ( pVar->MemberDataOffsetPlus4 - 4 ) );\r
- }\r
- }\r
- else if (pVar->pMemberData)\r
- {\r
- // When cloning an effect, pMemberData points to valid data in the original effect\r
- VH( FixupMemberDataPointer( &pVar->pMemberData ) );\r
- }\r
-\r
- if (pVar->pType->BelongsInConstantBuffer())\r
- {\r
- // Convert from offsets to pointers\r
- pVar->Data.pGeneric = pVar->pCB->pBackingStore + pVar->Data.Offset;\r
- }\r
- }\r
-\r
- // Fixup each CB's array of child variable pointers\r
- for (i=0; i<m_pEffect->m_CBCount; i++)\r
- {\r
- SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];\r
- pCB->pEffect = m_pEffect;\r
-\r
- if (pCB->pVariables != NULL)\r
- {\r
- VH( FixupVariablePointer(&pCB->pVariables) );\r
- }\r
- }\r
-\r
- // Move shaders\r
- m_pOldShaders = m_pEffect->m_pShaderBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pShaderBlocks, cbShaders), "Internal loading error: cannot move shader count." );\r
-\r
- // Move interfaces, combining global interfaces and those that were created during shader initialization\r
- m_pOldInterfaces = m_pEffect->m_pInterfaces;\r
- m_OldInterfaceCount = m_pEffect->m_InterfaceCount;\r
- VHD( pHeap->MoveEmptyDataBlock((void**) &m_pEffect->m_pInterfaces, cbInterfaces + cbBackgroundInterfaces), "Internal loading error: cannot move shader." );\r
- memcpy( m_pEffect->m_pInterfaces, m_pOldInterfaces, cbInterfaces );\r
- for( i=0; i < m_BackgroundInterfaces.GetSize(); i++ )\r
- {\r
- D3DXASSERT( m_BackgroundInterfaces[i] != NULL );\r
- BYTE* pDst = (BYTE*)m_pEffect->m_pInterfaces + ( m_pEffect->m_InterfaceCount * sizeof(SInterface) );\r
- memcpy( pDst, m_BackgroundInterfaces[i], sizeof(SInterface) );\r
- m_pEffect->m_InterfaceCount++;\r
- }\r
-\r
- m_pOldShaderResources = m_pEffect->m_pShaderResources;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pShaderResources, cbShaderResources), "Internal loading error: cannot move SRVs." );\r
-\r
- m_pOldUnorderedAccessViews = m_pEffect->m_pUnorderedAccessViews;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pUnorderedAccessViews, cbUnorderedAccessViews), "Internal loading error: cannot move UAVS." );\r
-\r
- m_pOldRenderTargetViews = m_pEffect->m_pRenderTargetViews;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pRenderTargetViews, cbRenderTargetViews), "Internal loading error: cannot move RTVs." );\r
-\r
- m_pOldDepthStencilViews = m_pEffect->m_pDepthStencilViews;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pDepthStencilViews, cbDepthStencilViews), "Internal loading error: cannot move DSVs." );\r
-\r
- m_pOldDS = m_pEffect->m_pDepthStencilBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pDepthStencilBlocks, cbDS), "Internal loading error: cannot move depth-stencil state blocks." );\r
- VH( ReallocateBlockAssignments(m_pEffect->m_pDepthStencilBlocks, m_pEffect->m_DepthStencilBlockCount, Cloning ? m_pOldDS : NULL) );\r
- \r
- m_pOldAB = m_pEffect->m_pBlendBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pBlendBlocks, cbAB), "Internal loading error: cannot move blend state blocks." );\r
- VH( ReallocateBlockAssignments(m_pEffect->m_pBlendBlocks, m_pEffect->m_BlendBlockCount, Cloning ? m_pOldAB : NULL) );\r
-\r
- m_pOldRS = m_pEffect->m_pRasterizerBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pRasterizerBlocks, cbRS), "Internal loading error: cannot move rasterizer state blocks." );\r
- VH( ReallocateBlockAssignments(m_pEffect->m_pRasterizerBlocks, m_pEffect->m_RasterizerBlockCount, Cloning ? m_pOldRS : NULL) );\r
-\r
- m_pOldSamplers = m_pEffect->m_pSamplerBlocks;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pSamplerBlocks, cbSamplers), "Internal loading error: cannot move samplers." );\r
- VH( ReallocateBlockAssignments(m_pEffect->m_pSamplerBlocks, m_pEffect->m_SamplerBlockCount, Cloning ? m_pOldSamplers : NULL) );\r
- \r
- // Fixup sampler backing stores\r
- for (i=0; i<m_pEffect->m_SamplerBlockCount; ++i)\r
- {\r
- VH( FixupShaderResourcePointer(&m_pEffect->m_pSamplerBlocks[i].BackingStore.pTexture) );\r
- }\r
-\r
- // Fixup each interface's class instance variable pointer\r
- for (i=0; i<m_pEffect->m_InterfaceCount; i++)\r
- {\r
- SInterface *pInterface = &m_pEffect->m_pInterfaces[i];\r
-\r
- if (pInterface->pClassInstance != NULL)\r
- {\r
- VH( FixupVariablePointer( (SGlobalVariable**)&pInterface->pClassInstance ) );\r
- }\r
- }\r
-\r
- // Fixup pointers for non-numeric variables\r
- for (i=0; i<m_pEffect->m_VariableCount; i++)\r
- {\r
- SGlobalVariable *pVar = &m_pEffect->m_pVariables[i];\r
-\r
- if (pVar->pType->IsShader())\r
- {\r
- VH( FixupShaderPointer(&pVar->Data.pShader) );\r
- }\r
- else if (pVar->pType->IsShaderResource())\r
- {\r
- VH( FixupShaderResourcePointer(&pVar->Data.pShaderResource) );\r
- }\r
- else if (pVar->pType->IsUnorderedAccessView())\r
- {\r
- VH( FixupUnorderedAccessViewPointer(&pVar->Data.pUnorderedAccessView) );\r
- }\r
- else if (pVar->pType->IsInterface())\r
- {\r
- VH( FixupInterfacePointer(&pVar->Data.pInterface, false) );\r
- }\r
- else if (pVar->pType->IsObjectType(EOT_String))\r
- {\r
- if( !m_pEffect->IsOptimized() )\r
- {\r
- VH( FixupStringPointer(&pVar->Data.pString) );\r
- }\r
- }\r
- else if (pVar->pType->IsStateBlockObject())\r
- {\r
- switch(pVar->pType->ObjectType)\r
- {\r
- case EOT_DepthStencil:\r
- VH( FixupDSPointer((SDepthStencilBlock**) &pVar->Data.pBlock) );\r
- break;\r
- case EOT_Blend:\r
- VH( FixupABPointer((SBlendBlock**) &pVar->Data.pBlock) );\r
- break;\r
- case EOT_Rasterizer:\r
- VH( FixupRSPointer((SRasterizerBlock**) &pVar->Data.pBlock) );\r
- break;\r
- case EOT_Sampler:\r
- VB(pVar->pType->IsSampler());\r
- VH( FixupSamplerPointer((SSamplerBlock**) &pVar->Data.pBlock) );\r
- break;\r
- default:\r
- VH( E_FAIL );\r
- }\r
- }\r
- else if (pVar->pType->VarType == EVT_Struct || pVar->pType->VarType == EVT_Numeric)\r
- {\r
- if( pVar->pType->IsClassInstance() )\r
- {\r
- // do nothing\r
- }\r
- else\r
- {\r
- // do nothing\r
- }\r
- }\r
- else if (pVar->pType->IsRenderTargetView())\r
- {\r
- VH( FixupRenderTargetViewPointer(&pVar->Data.pRenderTargetView) );\r
- } \r
- else if (pVar->pType->IsDepthStencilView())\r
- {\r
- VH( FixupDepthStencilViewPointer(&pVar->Data.pDepthStencilView) );\r
- }\r
- else\r
- {\r
- VHD( E_FAIL, "Internal loading error: Invalid variable type." );\r
- }\r
- }\r
-\r
- // Fixup created members\r
- for (i = 0; i < m_pEffect->m_pMemberInterfaces.GetSize(); ++ i)\r
- {\r
- SMember* pMember = m_pEffect->m_pMemberInterfaces[i];\r
- SGlobalVariable** ppTopLevelEntity = (SGlobalVariable**)&pMember->pTopLevelEntity;\r
- VN( *ppTopLevelEntity );\r
-\r
- // This might be set to false later, for supporting textures inside classes\r
- const bool bGlobalMemberDataBlock = true;\r
-\r
- if( Cloning )\r
- {\r
- if( pMember->pType->BelongsInConstantBuffer() )\r
- {\r
- D3DXASSERT( pMember->Data.pGeneric == NULL || (*ppTopLevelEntity)->pEffect->m_Heap.IsInHeap(pMember->Data.pGeneric) );\r
- pMember->Data.Offset = (UINT)( (BYTE*)pMember->Data.pGeneric - (BYTE*)(*ppTopLevelEntity)->pCB->pBackingStore );\r
- }\r
- if( bGlobalMemberDataBlock && pMember->pMemberData )\r
- {\r
- pMember->MemberDataOffsetPlus4 = (UINT)( (BYTE*)pMember->pMemberData - (BYTE*)(*ppTopLevelEntity)->pEffect->m_pMemberDataBlocks ) + 4;\r
- }\r
- }\r
-\r
- VH( FixupVariablePointer( ppTopLevelEntity ) );\r
-\r
- if (pMember->pType->BelongsInConstantBuffer())\r
- {\r
- // Convert from offsets to pointers\r
- pMember->Data.pGeneric = (*ppTopLevelEntity)->pCB->pBackingStore + pMember->Data.Offset;\r
- }\r
- if( bGlobalMemberDataBlock && pMember->MemberDataOffsetPlus4 )\r
- {\r
- pMember->pMemberData = (SMemberDataPointer*)( (BYTE*)m_pEffect->m_pMemberDataBlocks + ( pMember->MemberDataOffsetPlus4 - 4 ) );\r
- }\r
- }\r
-\r
- // Fixup shader data\r
- VH( ReallocateShaderBlocks() );\r
-\r
- // Move groups, techniques, and passes\r
- m_pOldGroups = m_pEffect->m_pGroups;\r
- VHD( pHeap->MoveData((void**) &m_pEffect->m_pGroups, cbGroups), "Internal loading error: cannot move groups." );\r
- for (i=0; i<m_pEffect->m_GroupCount; i++)\r
- {\r
- SGroup *pGroup = &m_pEffect->m_pGroups[i];\r
- UINT cbTechniques;\r
-\r
- cbTechniques = pGroup->TechniqueCount * sizeof(STechnique);\r
- VHD( pHeap->MoveData((void**) &pGroup->pTechniques, cbTechniques), "Internal loading error: cannot move techniques." );\r
-\r
- for (j=0; j<pGroup->TechniqueCount; j++)\r
- {\r
- STechnique *pTech = &pGroup->pTechniques[j];\r
- UINT cbPass;\r
- UINT iPass;\r
-\r
- cbPass = pTech->PassCount * sizeof(SPassBlock);\r
- SPassBlock* pOldPasses = Cloning ? pTech->pPasses : NULL;\r
- VHD( pHeap->MoveData((void**) &pTech->pPasses, cbPass), "Internal loading error: cannot move passes." );\r
-\r
- for (iPass = 0; iPass < pTech->PassCount; ++ iPass)\r
- {\r
- pTech->pPasses[iPass].pEffect = m_pEffect;\r
-\r
- // Fixup backing store pointers in passes\r
- VH( FixupABPointer((SBlendBlock**) &pTech->pPasses[iPass].BackingStore.pBlendBlock) );\r
- VH( FixupDSPointer((SDepthStencilBlock**) &pTech->pPasses[iPass].BackingStore.pDepthStencilBlock) );\r
- VH( FixupRSPointer((SRasterizerBlock**) &pTech->pPasses[iPass].BackingStore.pRasterizerBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pVertexShaderBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pPixelShaderBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pGeometryShaderBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pHullShaderBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pDomainShaderBlock) );\r
- VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pComputeShaderBlock) );\r
- VH( FixupDepthStencilViewPointer( &pTech->pPasses[iPass].BackingStore.pDepthStencilView) );\r
- for (UINT iRT = 0; iRT < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; iRT++)\r
- {\r
- VH( FixupRenderTargetViewPointer( &pTech->pPasses[iPass].BackingStore.pRenderTargetViews[iRT] ) );\r
- }\r
- } \r
-\r
- VH( ReallocateBlockAssignments( pTech->pPasses, pTech->PassCount, pOldPasses ) );\r
- }\r
- }\r
- VH( FixupGroupPointer( &m_pEffect->m_pNullGroup ) );\r
-\r
- // Move anonymous shader variables\r
- VHD( pHeap->MoveData((void **) &m_pEffect->m_pAnonymousShaders, cbAnonymousShaders), "Internal loading error: cannot move anonymous shaders." );\r
- for (i=0; i<m_pEffect->m_AnonymousShaderCount; ++i)\r
- {\r
- SAnonymousShader *pAnonymousShader = m_pEffect->m_pAnonymousShaders + i;\r
- VH( FixupShaderPointer((SShaderBlock**) &pAnonymousShader->pShaderBlock) );\r
- }\r
-\r
- VBD( pHeap->GetSize() == m_EffectMemory, "Loading error: effect size mismatch." );\r
-\r
-lExit:\r
- return hr;\r
-}\r
-\r
-}\r
OSDN Git Service
