SlimDXc_Jun2010(VC++2008)/external/Effects11/EffectNonRuntime.cpp

   1 //////////////////////////////////////////////////////////////////////////////\r
   2 //\r
   3 //  Copyright (C) Microsoft Corporation.  All Rights Reserved.\r
   4 //\r
   5 //  File:       EffectNonRuntime.cpp\r
   6 //  Content:    D3DX11 Effect low-frequency utility functions\r
   7 //              These functions are not intended to be called regularly.  They\r
   8 //              are typically called when creating, cloning, or optimizing an \r
   9 //              Effect, or reflecting a variable.\r
  10 //\r
  11 //////////////////////////////////////////////////////////////////////////////\r
  12 \r
  13 #include "pchfx.h"\r
  14 #include "SOParser.h"\r
  15 \r
  16 namespace D3DX11Effects\r
  17 {\r
  18 \r
  19 extern SUnorderedAccessView g_NullUnorderedAccessView;\r
  20 \r
  21 SBaseBlock::SBaseBlock()\r
  22 : BlockType(EBT_Invalid)\r
  23 , IsUserManaged(FALSE)\r
  24 , AssignmentCount(0)\r
  25 , pAssignments(NULL)\r
  26 {\r
  27 \r
  28 }\r
  29 \r
  30 SPassBlock::SPassBlock()\r
  31 {\r
  32     pName = NULL;\r
  33     AnnotationCount = 0;\r
  34     pAnnotations = NULL;\r
  35     InitiallyValid = TRUE;\r
  36     HasDependencies = FALSE;\r
  37     ZeroMemory(&BackingStore, sizeof(BackingStore));\r
  38 }\r
  39 \r
  40 STechnique::STechnique()\r
  41 : pName(NULL)\r
  42 , PassCount(0)\r
  43 , pPasses(NULL)\r
  44 , AnnotationCount(0)\r
  45 , pAnnotations(NULL)\r
  46 , InitiallyValid( TRUE )\r
  47 , HasDependencies( FALSE )\r
  48 {\r
  49 }\r
  50 \r
  51 SGroup::SGroup()\r
  52 : pName(NULL)\r
  53 , TechniqueCount(0)\r
  54 , pTechniques(NULL)\r
  55 , AnnotationCount(0)\r
  56 , pAnnotations(NULL)\r
  57 , InitiallyValid( TRUE )\r
  58 , HasDependencies( FALSE )\r
  59 {\r
  60 }\r
  61 \r
  62 SDepthStencilBlock::SDepthStencilBlock()\r
  63 {\r
  64     pDSObject = NULL;\r
  65     ZeroMemory(&BackingStore, sizeof(BackingStore));\r
  66     IsValid = TRUE;\r
  67 \r
  68     BackingStore.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;\r
  69     BackingStore.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;\r
  70     BackingStore.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;\r
  71     BackingStore.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;\r
  72     BackingStore.DepthEnable = TRUE;\r
  73     BackingStore.DepthFunc = D3D11_COMPARISON_LESS;\r
  74     BackingStore.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;\r
  75     BackingStore.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;\r
  76     BackingStore.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;\r
  77     BackingStore.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;\r
  78     BackingStore.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;\r
  79     BackingStore.StencilEnable = FALSE;\r
  80     BackingStore.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;\r
  81     BackingStore.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;\r
  82 }\r
  83 \r
  84 SBlendBlock::SBlendBlock()\r
  85 {\r
  86     pBlendObject = NULL;\r
  87     ZeroMemory(&BackingStore, sizeof(BackingStore));\r
  88     IsValid = TRUE;\r
  89 \r
  90     BackingStore.AlphaToCoverageEnable = FALSE;\r
  91     BackingStore.IndependentBlendEnable = TRUE;\r
  92     for( UINT i=0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++ )\r
  93     {\r
  94         BackingStore.RenderTarget[i].SrcBlend = D3D11_BLEND_ONE;\r
  95         BackingStore.RenderTarget[i].DestBlend = D3D11_BLEND_ZERO;\r
  96         BackingStore.RenderTarget[i].BlendOp = D3D11_BLEND_OP_ADD;\r
  97         BackingStore.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE;\r
  98         BackingStore.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ZERO;\r
  99         BackingStore.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_ADD;\r
 100         memset(&BackingStore.RenderTarget[i].RenderTargetWriteMask, 0x0F, sizeof(BackingStore.RenderTarget[i].RenderTargetWriteMask));\r
 101     }\r
 102 }\r
 103 \r
 104 SRasterizerBlock::SRasterizerBlock()\r
 105 {\r
 106     pRasterizerObject = NULL;\r
 107     ZeroMemory(&BackingStore, sizeof(BackingStore));\r
 108     IsValid = TRUE;\r
 109 \r
 110     BackingStore.AntialiasedLineEnable = FALSE;\r
 111     BackingStore.CullMode = D3D11_CULL_BACK;\r
 112     BackingStore.DepthBias = D3D11_DEFAULT_DEPTH_BIAS;\r
 113     BackingStore.DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP;\r
 114     BackingStore.FillMode = D3D11_FILL_SOLID;\r
 115     BackingStore.FrontCounterClockwise = FALSE;\r
 116     BackingStore.MultisampleEnable = FALSE;\r
 117     BackingStore.ScissorEnable = FALSE;\r
 118     BackingStore.SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;\r
 119     BackingStore.DepthClipEnable = TRUE;\r
 120 }\r
 121 \r
 122 SSamplerBlock::SSamplerBlock()\r
 123 {\r
 124     pD3DObject = NULL;\r
 125     ZeroMemory(&BackingStore, sizeof(BackingStore));\r
 126 \r
 127     BackingStore.SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;\r
 128     BackingStore.SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;\r
 129     BackingStore.SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;\r
 130     BackingStore.SamplerDesc.BorderColor[3] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;\r
 131     BackingStore.SamplerDesc.BorderColor[2] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;\r
 132     BackingStore.SamplerDesc.BorderColor[1] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;\r
 133     BackingStore.SamplerDesc.BorderColor[0] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;\r
 134     BackingStore.SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;\r
 135     BackingStore.SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;\r
 136     BackingStore.SamplerDesc.MaxAnisotropy = (UINT32) D3D11_DEFAULT_MAX_ANISOTROPY;\r
 137     BackingStore.SamplerDesc.MipLODBias = D3D11_DEFAULT_MIP_LOD_BIAS;\r
 138     BackingStore.SamplerDesc.MinLOD = -FLT_MAX;\r
 139     BackingStore.SamplerDesc.MaxLOD = FLT_MAX;\r
 140 }\r
 141 \r
 142 SShaderBlock::SShaderBlock(SD3DShaderVTable *pVirtualTable)\r
 143 {\r
 144     IsValid = TRUE;\r
 145 \r
 146     pVT = pVirtualTable;\r
 147 \r
 148     pReflectionData = NULL;\r
 149     \r
 150     pD3DObject = NULL;\r
 151 \r
 152     CBDepCount = 0;\r
 153     pCBDeps = NULL;\r
 154 \r
 155     SampDepCount = 0;\r
 156     pSampDeps = NULL;\r
 157 \r
 158     InterfaceDepCount = 0;\r
 159     pInterfaceDeps = NULL;\r
 160 \r
 161     ResourceDepCount = 0;\r
 162     pResourceDeps = NULL;\r
 163 \r
 164     UAVDepCount = 0;\r
 165     pUAVDeps = NULL;\r
 166 \r
 167     TBufferDepCount = 0;\r
 168     ppTbufDeps = NULL;\r
 169 \r
 170     pInputSignatureBlob = NULL;\r
 171 }\r
 172 \r
 173 HRESULT SShaderBlock::OnDeviceBind()\r
 174 {\r
 175     HRESULT hr = S_OK;\r
 176     UINT  i, j;\r
 177 \r
 178     // Update all CB deps\r
 179     for (i=0; i<CBDepCount; i++)\r
 180     {\r
 181         D3DXASSERT(pCBDeps[i].Count);\r
 182 \r
 183         for (j=0; j<pCBDeps[i].Count; j++)\r
 184         {\r
 185             pCBDeps[i].ppD3DObjects[j] = pCBDeps[i].ppFXPointers[j]->pD3DObject;\r
 186 \r
 187             if ( !pCBDeps[i].ppD3DObjects[j] )\r
 188                 VH( E_FAIL );\r
 189         }\r
 190     }\r
 191 \r
 192     // Update all sampler deps\r
 193     for (i=0; i<SampDepCount; i++)\r
 194     {\r
 195         D3DXASSERT(pSampDeps[i].Count);\r
 196 \r
 197         for (j=0; j<pSampDeps[i].Count; j++)\r
 198         {\r
 199             pSampDeps[i].ppD3DObjects[j] = pSampDeps[i].ppFXPointers[j]->pD3DObject;\r
 200 \r
 201             if ( !pSampDeps[i].ppD3DObjects[j] )\r
 202                 VH( E_FAIL );\r
 203         }\r
 204     }\r
 205 \r
 206     // Texture deps will be set automatically on use since they are initially marked dirty.\r
 207 \r
 208 lExit:\r
 209     return hr;\r
 210 }\r
 211 \r
 212 extern SD3DShaderVTable g_vtVS;\r
 213 extern SD3DShaderVTable g_vtGS;\r
 214 extern SD3DShaderVTable g_vtPS;\r
 215 extern SD3DShaderVTable g_vtHS;\r
 216 extern SD3DShaderVTable g_vtDS;\r
 217 extern SD3DShaderVTable g_vtCS;\r
 218 \r
 219 EObjectType SShaderBlock::GetShaderType()\r
 220 {\r
 221     if (&g_vtVS == pVT)\r
 222         return EOT_VertexShader;\r
 223     else if (&g_vtGS == pVT)\r
 224         return EOT_GeometryShader;\r
 225     else if (&g_vtPS == pVT)\r
 226         return EOT_PixelShader;\r
 227     else if (&g_vtHS == pVT)\r
 228         return EOT_HullShader5;\r
 229     else if (&g_vtDS == pVT)\r
 230         return EOT_DomainShader5;\r
 231     else if (&g_vtCS == pVT)\r
 232         return EOT_ComputeShader5;\r
 233     \r
 234     return EOT_Invalid;\r
 235 }\r
 236 \r
 237 #define _SET_BIT(bytes, x) (bytes[x / 8] |= (1 << (x % 8)))\r
 238 \r
 239 HRESULT SShaderBlock::ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)\r
 240 {\r
 241     HRESULT hr = S_OK;\r
 242     UINT i, j;\r
 243     BYTE *pSamplerMask = NULL, *pShaderResourceMask = NULL, *pConstantBufferMask = NULL, *pUnorderedAccessViewMask = NULL, *pInterfaceMask = NULL;\r
 244 \r
 245     switch (GetShaderType())\r
 246     {\r
 247     case EOT_VertexShader:\r
 248     case EOT_VertexShader5:\r
 249         pStateBlockMask->VS = 1;\r
 250         pSamplerMask = pStateBlockMask->VSSamplers;\r
 251         pShaderResourceMask = pStateBlockMask->VSShaderResources;\r
 252         pConstantBufferMask = pStateBlockMask->VSConstantBuffers;\r
 253         pInterfaceMask = pStateBlockMask->VSInterfaces;\r
 254         pUnorderedAccessViewMask = NULL;\r
 255         break;\r
 256 \r
 257     case EOT_GeometryShader:\r
 258     case EOT_GeometryShader5:\r
 259         pStateBlockMask->GS = 1;\r
 260         pSamplerMask = pStateBlockMask->GSSamplers;\r
 261         pShaderResourceMask = pStateBlockMask->GSShaderResources;\r
 262         pConstantBufferMask = pStateBlockMask->GSConstantBuffers;\r
 263         pInterfaceMask = pStateBlockMask->GSInterfaces;\r
 264         pUnorderedAccessViewMask = NULL;\r
 265         break;\r
 266 \r
 267     case EOT_PixelShader:\r
 268     case EOT_PixelShader5:\r
 269         pStateBlockMask->PS = 1;\r
 270         pSamplerMask = pStateBlockMask->PSSamplers;\r
 271         pShaderResourceMask = pStateBlockMask->PSShaderResources;\r
 272         pConstantBufferMask = pStateBlockMask->PSConstantBuffers;\r
 273         pInterfaceMask = pStateBlockMask->PSInterfaces;\r
 274         pUnorderedAccessViewMask = &pStateBlockMask->PSUnorderedAccessViews;\r
 275         break;\r
 276 \r
 277     case EOT_HullShader5:\r
 278         pStateBlockMask->HS = 1;\r
 279         pSamplerMask = pStateBlockMask->HSSamplers;\r
 280         pShaderResourceMask = pStateBlockMask->HSShaderResources;\r
 281         pConstantBufferMask = pStateBlockMask->HSConstantBuffers;\r
 282         pInterfaceMask = pStateBlockMask->HSInterfaces;\r
 283         pUnorderedAccessViewMask = NULL;\r
 284         break;\r
 285 \r
 286     case EOT_DomainShader5:\r
 287         pStateBlockMask->DS = 1;\r
 288         pSamplerMask = pStateBlockMask->DSSamplers;\r
 289         pShaderResourceMask = pStateBlockMask->DSShaderResources;\r
 290         pConstantBufferMask = pStateBlockMask->DSConstantBuffers;\r
 291         pInterfaceMask = pStateBlockMask->DSInterfaces;\r
 292         pUnorderedAccessViewMask = NULL;\r
 293         break;\r
 294 \r
 295     case EOT_ComputeShader5:\r
 296         pStateBlockMask->CS = 1;\r
 297         pSamplerMask = pStateBlockMask->CSSamplers;\r
 298         pShaderResourceMask = pStateBlockMask->CSShaderResources;\r
 299         pConstantBufferMask = pStateBlockMask->CSConstantBuffers;\r
 300         pInterfaceMask = pStateBlockMask->CSInterfaces;\r
 301         pUnorderedAccessViewMask = &pStateBlockMask->CSUnorderedAccessViews;\r
 302         break;\r
 303 \r
 304     default:\r
 305         D3DXASSERT(0);\r
 306         VH(E_FAIL);\r
 307     }\r
 308 \r
 309     for (i = 0; i < SampDepCount; ++ i)\r
 310     {\r
 311         for (j = 0; j < pSampDeps[i].Count; ++ j)\r
 312         {\r
 313             _SET_BIT(pSamplerMask, (pSampDeps[i].StartIndex + j));\r
 314         }\r
 315     }\r
 316 \r
 317     for (i = 0; i < InterfaceDepCount; ++ i)\r
 318     {\r
 319         for (j = 0; j < pInterfaceDeps[i].Count; ++ j)\r
 320         {\r
 321             _SET_BIT(pInterfaceMask, (pInterfaceDeps[i].StartIndex + j));\r
 322         }\r
 323     }\r
 324 \r
 325     for (i = 0; i < ResourceDepCount; ++ i)\r
 326     {\r
 327         for (j = 0; j < pResourceDeps[i].Count; ++ j)\r
 328         {\r
 329             _SET_BIT(pShaderResourceMask, (pResourceDeps[i].StartIndex + j));\r
 330         }\r
 331     }\r
 332 \r
 333     for (i = 0; i < CBDepCount; ++ i)\r
 334     {\r
 335         for (j = 0; j < pCBDeps[i].Count; ++ j)\r
 336         {\r
 337             _SET_BIT(pConstantBufferMask, (pCBDeps[i].StartIndex + j));\r
 338         }\r
 339     }\r
 340 \r
 341     for (i = 0; i < UAVDepCount; ++ i)\r
 342     {\r
 343         D3DXASSERT( pUnorderedAccessViewMask != NULL );\r
 344         for (j = 0; j < pUAVDeps[i].Count; ++ j)\r
 345         {\r
 346             if( pUAVDeps[i].ppFXPointers[j] != &g_NullUnorderedAccessView )\r
 347                 _SET_BIT(pUnorderedAccessViewMask, (pUAVDeps[i].StartIndex + j));\r
 348         }\r
 349     }\r
 350 \r
 351 lExit:\r
 352     return hr;\r
 353 }\r
 354 \r
 355 #undef _SET_BIT\r
 356 \r
 357 HRESULT SShaderBlock::GetShaderDesc(D3DX11_EFFECT_SHADER_DESC *pDesc, BOOL IsInline)\r
 358 {\r
 359     HRESULT hr = S_OK;\r
 360     \r
 361     ZeroMemory(pDesc, sizeof(*pDesc));\r
 362 \r
 363     pDesc->pInputSignature = pInputSignatureBlob ? (const BYTE*)pInputSignatureBlob->GetBufferPointer() : NULL;\r
 364     pDesc->IsInline = IsInline;\r
 365 \r
 366     if (NULL != pReflectionData)\r
 367     {\r
 368         // initialize these only if present; otherwise leave them NULL or 0\r
 369         pDesc->pBytecode = pReflectionData->pBytecode;\r
 370         pDesc->BytecodeLength = pReflectionData->BytecodeLength;\r
 371         for( UINT iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )\r
 372         {\r
 373             pDesc->SODecls[iDecl] = pReflectionData->pStreamOutDecls[iDecl];\r
 374         }\r
 375         pDesc->RasterizedStream = pReflectionData->RasterizedStream;\r
 376 \r
 377         // get # of input & output signature entries\r
 378         D3DXASSERT( pReflectionData->pReflection != NULL );\r
 379 \r
 380         D3D11_SHADER_DESC ShaderDesc;\r
 381         pReflectionData->pReflection->GetDesc( &ShaderDesc );\r
 382         pDesc->NumInputSignatureEntries = ShaderDesc.InputParameters;\r
 383         pDesc->NumOutputSignatureEntries = ShaderDesc.OutputParameters;\r
 384         pDesc->NumPatchConstantSignatureEntries = ShaderDesc.PatchConstantParameters;\r
 385     }\r
 386 lExit:\r
 387     return hr;\r
 388 }\r
 389 \r
 390 HRESULT SShaderBlock::GetVertexShader(ID3D11VertexShader **ppVS)\r
 391 {\r
 392     if (EOT_VertexShader == GetShaderType() ||\r
 393         EOT_VertexShader5 == GetShaderType())\r
 394     {\r
 395         *ppVS = (ID3D11VertexShader *) pD3DObject;\r
 396         SAFE_ADDREF(*ppVS);\r
 397         return S_OK;\r
 398     }\r
 399     else\r
 400     {\r
 401         *ppVS = NULL;\r
 402         DPF(0, "ID3DX11EffectShaderVariable::GetVertexShader: This shader variable is not a vertex shader");\r
 403         return D3DERR_INVALIDCALL;\r
 404     }\r
 405 }\r
 406 \r
 407 HRESULT SShaderBlock::GetGeometryShader(ID3D11GeometryShader **ppGS)\r
 408 {\r
 409     if (EOT_GeometryShader == GetShaderType() ||\r
 410         EOT_GeometryShaderSO == GetShaderType() ||\r
 411         EOT_GeometryShader5 == GetShaderType())\r
 412     {\r
 413         *ppGS = (ID3D11GeometryShader *) pD3DObject;\r
 414         SAFE_ADDREF(*ppGS);\r
 415         return S_OK;\r
 416     }\r
 417     else\r
 418     {\r
 419         *ppGS = NULL;\r
 420         DPF(0, "ID3DX11EffectShaderVariable::GetGeometryShader: This shader variable is not a geometry shader");\r
 421         return D3DERR_INVALIDCALL;\r
 422     }\r
 423 }\r
 424 \r
 425 HRESULT SShaderBlock::GetPixelShader(ID3D11PixelShader **ppPS)\r
 426 {\r
 427     if (EOT_PixelShader == GetShaderType() ||\r
 428         EOT_PixelShader5 == GetShaderType())\r
 429     {\r
 430         *ppPS = (ID3D11PixelShader *) pD3DObject;\r
 431         SAFE_ADDREF(*ppPS);\r
 432         return S_OK;\r
 433     }\r
 434     else\r
 435     {\r
 436         *ppPS = NULL;\r
 437         DPF(0, "ID3DX11EffectShaderVariable::GetPixelShader: This shader variable is not a pixel shader");\r
 438         return D3DERR_INVALIDCALL;\r
 439     }\r
 440 }\r
 441 \r
 442 HRESULT SShaderBlock::GetHullShader(ID3D11HullShader **ppHS)\r
 443 {\r
 444     if (EOT_HullShader5 == GetShaderType())\r
 445     {\r
 446         *ppHS = (ID3D11HullShader *) pD3DObject;\r
 447         SAFE_ADDREF(*ppHS);\r
 448         return S_OK;\r
 449     }\r
 450     else\r
 451     {\r
 452         *ppHS = NULL;\r
 453         DPF(0, "ID3DX11EffectShaderVariable::GetHullShader: This shader variable is not a hull shader");\r
 454         return D3DERR_INVALIDCALL;\r
 455     }\r
 456 }\r
 457 \r
 458 HRESULT SShaderBlock::GetDomainShader(ID3D11DomainShader **ppDS)\r
 459 {\r
 460     if (EOT_DomainShader5 == GetShaderType())\r
 461     {\r
 462         *ppDS = (ID3D11DomainShader *) pD3DObject;\r
 463         SAFE_ADDREF(*ppDS);\r
 464         return S_OK;\r
 465     }\r
 466     else\r
 467     {\r
 468         *ppDS = NULL;\r
 469         DPF(0, "ID3DX11EffectShaderVariable::GetDomainShader: This shader variable is not a domain shader");\r
 470         return D3DERR_INVALIDCALL;\r
 471     }\r
 472 }\r
 473 \r
 474 HRESULT SShaderBlock::GetComputeShader(ID3D11ComputeShader **ppCS)\r
 475 {\r
 476     if (EOT_ComputeShader5 == GetShaderType())\r
 477     {\r
 478         *ppCS = (ID3D11ComputeShader *) pD3DObject;\r
 479         SAFE_ADDREF(*ppCS);\r
 480         return S_OK;\r
 481     }\r
 482     else\r
 483     {\r
 484         *ppCS = NULL;\r
 485         DPF(0, "ID3DX11EffectShaderVariable::GetComputeShader: This shader variable is not a compute shader");\r
 486         return D3DERR_INVALIDCALL;\r
 487     }\r
 488 }\r
 489 \r
 490 HRESULT SShaderBlock::GetSignatureElementDesc(ESigType SigType, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)\r
 491 {\r
 492     HRESULT hr = S_OK;\r
 493     LPCSTR pFuncName;\r
 494     switch( SigType )\r
 495     {\r
 496     case ST_Input:\r
 497 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
 498         pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";\r
 499         break;\r
 500     case ST_Output:\r
 501 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
 502         pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";\r
 503         break;\r
 504     case ST_PatchConstant:\r
 505 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
 506         pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";\r
 507         break;\r
 508     default:\r
 509         D3DXASSERT( false );\r
 510         return E_FAIL;\r
 511     };\r
 512 \r
 513     if (NULL != pReflectionData)\r
 514     {\r
 515         // get # of signature entries\r
 516         D3DXASSERT( pReflectionData->pReflection != NULL );\r
 517 \r
 518         D3D11_SHADER_DESC ShaderDesc;\r
 519         VH( pReflectionData->pReflection->GetDesc( &ShaderDesc ) );\r
 520 \r
 521         D3D11_SIGNATURE_PARAMETER_DESC ParamDesc;\r
 522         if( pReflectionData->IsNullGS )\r
 523         {\r
 524             switch( SigType )\r
 525             {\r
 526             case ST_Input:\r
 527                 // The input signature for a null-GS is the output signature of the previous VS\r
 528                 SigType = ST_Output;\r
 529                 break;\r
 530             case ST_PatchConstant:\r
 531                 // GeometryShaders cannot have patch constant signatures\r
 532                 return E_INVALIDARG;\r
 533             };\r
 534         }\r
 535 \r
 536         switch( SigType )\r
 537         {\r
 538         case ST_Input:\r
 539             if( Element >= ShaderDesc.InputParameters )\r
 540             {\r
 541                 DPF( 0, "%s: Invalid Element index (%d) specified", pFuncName, Element );\r
 542                 VH( E_INVALIDARG );\r
 543             }\r
 544             VH( pReflectionData->pReflection->GetInputParameterDesc( Element, &ParamDesc ) );\r
 545             break;\r
 546         case ST_Output:\r
 547             if( Element >= ShaderDesc.OutputParameters )\r
 548             {\r
 549                 DPF( 0, "%s: Invalid Element index (%d) specified", pFuncName, Element );\r
 550                 VH( E_INVALIDARG );\r
 551             }\r
 552             VH( pReflectionData->pReflection->GetOutputParameterDesc( Element, &ParamDesc ) );\r
 553             break;\r
 554         case ST_PatchConstant:\r
 555             if( Element >= ShaderDesc.PatchConstantParameters )\r
 556             {\r
 557                 DPF( 0, "%s: Invalid Element index (%d) specified", pFuncName, Element );\r
 558                 VH( E_INVALIDARG );\r
 559             }\r
 560             VH( pReflectionData->pReflection->GetPatchConstantParameterDesc( Element, &ParamDesc ) );\r
 561             break;\r
 562         };\r
 563 \r
 564         pDesc->SemanticName = ParamDesc.SemanticName;\r
 565         pDesc->SystemValueType = ParamDesc.SystemValueType;\r
 566 \r
 567         // Pixel shaders need to be special-cased as they don't technically output SVs\r
 568         if( pDesc->SystemValueType == D3D10_NAME_UNDEFINED && GetShaderType() == EOT_PixelShader )\r
 569         {\r
 570             if( _stricmp(pDesc->SemanticName, "SV_TARGET") == 0 )\r
 571             {\r
 572                 pDesc->SystemValueType = D3D10_NAME_TARGET;\r
 573             } \r
 574             else if( _stricmp(pDesc->SemanticName, "SV_DEPTH") == 0 )\r
 575             {\r
 576                 pDesc->SystemValueType = D3D10_NAME_DEPTH;\r
 577             } \r
 578             else if( _stricmp(pDesc->SemanticName, "SV_COVERAGE") == 0 )\r
 579             {\r
 580                 pDesc->SystemValueType = D3D10_NAME_COVERAGE;\r
 581             }\r
 582         }\r
 583 \r
 584         pDesc->SemanticIndex = ParamDesc.SemanticIndex;\r
 585         pDesc->Register = ParamDesc.Register;\r
 586         pDesc->Mask = ParamDesc.Mask;\r
 587         pDesc->ComponentType = ParamDesc.ComponentType;\r
 588         pDesc->ReadWriteMask = ParamDesc.ReadWriteMask;\r
 589     }\r
 590     else\r
 591     {\r
 592         DPF(0, "%s: Cannot get signatures; shader bytecode is not present", pFuncName);\r
 593         VH( D3DERR_INVALIDCALL );\r
 594     }\r
 595     \r
 596 lExit:\r
 597     return hr;\r
 598 }\r
 599 \r
 600 SString::SString()\r
 601 {\r
 602     pString = NULL;\r
 603 }\r
 604 \r
 605 SRenderTargetView::SRenderTargetView()\r
 606 {\r
 607     pRenderTargetView = NULL;\r
 608 }\r
 609 \r
 610 SDepthStencilView::SDepthStencilView()\r
 611 {\r
 612     pDepthStencilView = NULL;\r
 613 }\r
 614 \r
 615 void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, UINT  Index)\r
 616 {\r
 617     switch( VarType )\r
 618     {\r
 619     case EVT_Interface:\r
 620         return (SInterface *)pBaseBlock + Index;\r
 621     case EVT_Object:\r
 622         switch (ObjectType)\r
 623         {\r
 624         case EOT_Blend:\r
 625             return (SBlendBlock *)pBaseBlock + Index;\r
 626         case EOT_DepthStencil:\r
 627             return (SDepthStencilBlock *)pBaseBlock + Index;\r
 628         case EOT_Rasterizer:\r
 629             return (SRasterizerBlock *)pBaseBlock + Index;\r
 630         case EOT_PixelShader:\r
 631         case EOT_PixelShader5:\r
 632         case EOT_GeometryShader:\r
 633         case EOT_GeometryShaderSO:\r
 634         case EOT_GeometryShader5:\r
 635         case EOT_VertexShader:\r
 636         case EOT_VertexShader5:\r
 637         case EOT_HullShader5:\r
 638         case EOT_DomainShader5:\r
 639         case EOT_ComputeShader5:\r
 640             return (SShaderBlock *)pBaseBlock + Index;\r
 641         case EOT_String:\r
 642             return (SString *)pBaseBlock + Index;\r
 643         case EOT_Sampler:\r
 644             return (SSamplerBlock *)pBaseBlock + Index;\r
 645         case EOT_Buffer:\r
 646         case EOT_Texture:\r
 647         case EOT_Texture1D:\r
 648         case EOT_Texture1DArray:\r
 649         case EOT_Texture2D:\r
 650         case EOT_Texture2DArray:\r
 651         case EOT_Texture2DMS:\r
 652         case EOT_Texture2DMSArray:\r
 653         case EOT_Texture3D:\r
 654         case EOT_TextureCube:\r
 655         case EOT_TextureCubeArray:\r
 656         case EOT_ByteAddressBuffer:\r
 657         case EOT_StructuredBuffer:\r
 658             return (SShaderResource *)pBaseBlock + Index;\r
 659         case EOT_DepthStencilView:\r
 660             return (SDepthStencilView *)pBaseBlock + Index;\r
 661         case EOT_RenderTargetView:\r
 662             return (SRenderTargetView *)pBaseBlock + Index;\r
 663         case EOT_RWTexture1D:\r
 664         case EOT_RWTexture1DArray:\r
 665         case EOT_RWTexture2D:\r
 666         case EOT_RWTexture2DArray:\r
 667         case EOT_RWTexture3D:\r
 668         case EOT_RWBuffer:\r
 669         case EOT_RWByteAddressBuffer:\r
 670         case EOT_RWStructuredBuffer:\r
 671         case EOT_RWStructuredBufferAlloc:\r
 672         case EOT_RWStructuredBufferConsume:\r
 673         case EOT_AppendStructuredBuffer:\r
 674         case EOT_ConsumeStructuredBuffer:    \r
 675             return (SUnorderedAccessView *)pBaseBlock + Index;\r
 676         default:\r
 677             D3DXASSERT(0);\r
 678             return NULL;\r
 679         }\r
 680     default:\r
 681         D3DXASSERT(0);\r
 682         return NULL;\r
 683     }\r
 684 }\r
 685 \r
 686 CEffect::CEffect( UINT Flags )\r
 687 {\r
 688     m_RefCount = 1;\r
 689 \r
 690     m_pVariables = NULL;\r
 691     m_pAnonymousShaders = NULL;\r
 692     m_pGroups = NULL;\r
 693     m_pNullGroup = NULL;\r
 694     m_pShaderBlocks = NULL;\r
 695     m_pDepthStencilBlocks = NULL;\r
 696     m_pBlendBlocks = NULL;\r
 697     m_pRasterizerBlocks = NULL;\r
 698     m_pSamplerBlocks = NULL;\r
 699     m_pCBs = NULL;\r
 700     m_pStrings = NULL;\r
 701     m_pMemberDataBlocks = NULL;\r
 702     m_pInterfaces = NULL;\r
 703     m_pShaderResources = NULL;\r
 704     m_pUnorderedAccessViews = NULL;\r
 705     m_pRenderTargetViews = NULL;\r
 706     m_pDepthStencilViews = NULL;\r
 707     m_pDevice = NULL;\r
 708     m_pClassLinkage = NULL;\r
 709     m_pContext = NULL;\r
 710 \r
 711     m_VariableCount = 0;\r
 712     m_AnonymousShaderCount = 0;\r
 713     m_ShaderBlockCount = 0;\r
 714     m_DepthStencilBlockCount = 0;\r
 715     m_BlendBlockCount = 0;\r
 716     m_RasterizerBlockCount = 0;\r
 717     m_SamplerBlockCount = 0;\r
 718     m_StringCount = 0;\r
 719     m_MemberDataCount = 0;\r
 720     m_InterfaceCount = 0;\r
 721     m_ShaderResourceCount = 0;\r
 722     m_UnorderedAccessViewCount = 0;\r
 723     m_RenderTargetViewCount = 0;\r
 724     m_DepthStencilViewCount = 0;\r
 725     m_CBCount = 0;\r
 726     m_TechniqueCount = 0;\r
 727     m_GroupCount = 0;\r
 728 \r
 729     m_pReflection = NULL;\r
 730     m_LocalTimer = 1;\r
 731     m_Flags = Flags;\r
 732     m_FXLIndex = 0;\r
 733 \r
 734     m_pTypePool = NULL;\r
 735     m_pStringPool = NULL;\r
 736     m_pPooledHeap = NULL;\r
 737     m_pOptimizedTypeHeap = NULL;\r
 738 }\r
 739 \r
 740 void CEffect::ReleaseShaderRefection()\r
 741 {\r
 742     for( UINT i = 0; i < m_ShaderBlockCount; ++ i )\r
 743     {\r
 744         SAFE_RELEASE( m_pShaderBlocks[i].pInputSignatureBlob );\r
 745         if( m_pShaderBlocks[i].pReflectionData )\r
 746         {\r
 747             SAFE_RELEASE( m_pShaderBlocks[i].pReflectionData->pReflection );\r
 748         }\r
 749     }\r
 750 }\r
 751 \r
 752 CEffect::~CEffect()\r
 753 {\r
 754     ID3D11InfoQueue *pInfoQueue = NULL;\r
 755 \r
 756     // Mute debug spew\r
 757     if (m_pDevice)\r
 758         m_pDevice->QueryInterface(__uuidof(ID3D11InfoQueue), (void**) &pInfoQueue);\r
 759 \r
 760     if (pInfoQueue)\r
 761     {\r
 762         D3D11_INFO_QUEUE_FILTER filter;\r
 763         D3D11_MESSAGE_CATEGORY messageCategory = D3D11_MESSAGE_CATEGORY_STATE_SETTING;\r
 764         ZeroMemory(&filter, sizeof(filter));\r
 765 \r
 766         filter.DenyList.NumCategories = 1;\r
 767         filter.DenyList.pCategoryList = &messageCategory;\r
 768         pInfoQueue->PushStorageFilter(&filter);\r
 769     }\r
 770 \r
 771     UINT  i;\r
 772 \r
 773     if( NULL != m_pDevice )\r
 774     {\r
 775         // if m_pDevice == NULL, then we failed LoadEffect(), which means ReleaseShaderReflection was already called.\r
 776 \r
 777         // Release the shader reflection info, as it was not created on the private heap\r
 778         // This must be called before we delete m_pReflection\r
 779         ReleaseShaderRefection();\r
 780     }\r
 781 \r
 782     SAFE_DELETE( m_pReflection );\r
 783     SAFE_DELETE( m_pTypePool );\r
 784     SAFE_DELETE( m_pStringPool );\r
 785     SAFE_DELETE( m_pPooledHeap );\r
 786     SAFE_DELETE( m_pOptimizedTypeHeap );\r
 787 \r
 788     // this code assumes the effect has been loaded & relocated,\r
 789     // so check for that before freeing the resources\r
 790 \r
 791     if (NULL != m_pDevice)\r
 792     {\r
 793         // Keep the following in line with AddRefAllForCloning\r
 794 \r
 795         D3DXASSERT(NULL == m_pRasterizerBlocks || m_Heap.IsInHeap(m_pRasterizerBlocks));\r
 796         for (i = 0; i < m_RasterizerBlockCount; ++ i)\r
 797         {\r
 798             SAFE_RELEASE(m_pRasterizerBlocks[i].pRasterizerObject);\r
 799         }\r
 800 \r
 801         D3DXASSERT(NULL == m_pBlendBlocks || m_Heap.IsInHeap(m_pBlendBlocks));\r
 802         for (i = 0; i < m_BlendBlockCount; ++ i)\r
 803         {\r
 804             SAFE_RELEASE(m_pBlendBlocks[i].pBlendObject);\r
 805         }\r
 806 \r
 807         D3DXASSERT(NULL == m_pDepthStencilBlocks || m_Heap.IsInHeap(m_pDepthStencilBlocks));\r
 808         for (i = 0; i < m_DepthStencilBlockCount; ++ i)\r
 809         {\r
 810             SAFE_RELEASE(m_pDepthStencilBlocks[i].pDSObject);\r
 811         }\r
 812 \r
 813         D3DXASSERT(NULL == m_pSamplerBlocks || m_Heap.IsInHeap(m_pSamplerBlocks));\r
 814         for (i = 0; i < m_SamplerBlockCount; ++ i)\r
 815         {\r
 816             SAFE_RELEASE(m_pSamplerBlocks[i].pD3DObject);\r
 817         }\r
 818 \r
 819         D3DXASSERT(NULL == m_pShaderResources || m_Heap.IsInHeap(m_pShaderResources));\r
 820         for (i = 0; i < m_ShaderResourceCount; ++ i)\r
 821         {\r
 822             SAFE_RELEASE(m_pShaderResources[i].pShaderResource);\r
 823         }\r
 824 \r
 825         D3DXASSERT(NULL == m_pUnorderedAccessViews || m_Heap.IsInHeap(m_pUnorderedAccessViews));\r
 826         for (i = 0; i < m_UnorderedAccessViewCount; ++ i)\r
 827         {\r
 828             SAFE_RELEASE(m_pUnorderedAccessViews[i].pUnorderedAccessView);\r
 829         }\r
 830 \r
 831         D3DXASSERT(NULL == m_pRenderTargetViews || m_Heap.IsInHeap(m_pRenderTargetViews));\r
 832         for (i = 0; i < m_RenderTargetViewCount; ++ i)\r
 833         {\r
 834             SAFE_RELEASE(m_pRenderTargetViews[i].pRenderTargetView);\r
 835         }\r
 836 \r
 837         D3DXASSERT(NULL == m_pDepthStencilViews || m_Heap.IsInHeap(m_pDepthStencilViews));\r
 838         for (i = 0; i < m_DepthStencilViewCount; ++ i)\r
 839         {\r
 840             SAFE_RELEASE(m_pDepthStencilViews[i].pDepthStencilView);\r
 841         }\r
 842 \r
 843         D3DXASSERT(NULL == m_pMemberDataBlocks || m_Heap.IsInHeap(m_pMemberDataBlocks));\r
 844         for (i = 0; i < m_MemberDataCount; ++ i)\r
 845         {\r
 846             switch( m_pMemberDataBlocks[i].Type )\r
 847             {\r
 848             case MDT_ClassInstance:\r
 849                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DClassInstance);\r
 850                 break;\r
 851             case MDT_BlendState:\r
 852                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedBlendState);\r
 853                 break;\r
 854             case MDT_DepthStencilState:\r
 855                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedDepthStencilState);\r
 856                 break;\r
 857             case MDT_RasterizerState:\r
 858                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedRasterizerState);\r
 859                 break;\r
 860             case MDT_SamplerState:\r
 861                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedSamplerState);\r
 862                 break;\r
 863             case MDT_Buffer:\r
 864                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedConstantBuffer);\r
 865                 break;\r
 866             case MDT_ShaderResourceView:\r
 867                 SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedTextureBuffer);\r
 868                 break;\r
 869             default:\r
 870                 D3DXASSERT( false );\r
 871             }\r
 872         }\r
 873 \r
 874         D3DXASSERT(NULL == m_pCBs || m_Heap.IsInHeap(m_pCBs));\r
 875         for (i = 0; i < m_CBCount; ++ i)\r
 876         {\r
 877             SAFE_RELEASE(m_pCBs[i].TBuffer.pShaderResource);\r
 878             SAFE_RELEASE(m_pCBs[i].pD3DObject);\r
 879         }\r
 880 \r
 881         D3DXASSERT(NULL == m_pShaderBlocks || m_Heap.IsInHeap(m_pShaderBlocks));\r
 882         for (i = 0; i < m_ShaderBlockCount; ++ i)\r
 883         {\r
 884             SAFE_RELEASE(m_pShaderBlocks[i].pD3DObject);\r
 885         }\r
 886 \r
 887         SAFE_RELEASE( m_pDevice );\r
 888     }\r
 889     SAFE_RELEASE( m_pClassLinkage );\r
 890     D3DXASSERT( m_pContext == NULL );\r
 891 \r
 892     // Restore debug spew\r
 893     if (pInfoQueue)\r
 894     {\r
 895         pInfoQueue->PopStorageFilter();\r
 896         SAFE_RELEASE(pInfoQueue);\r
 897     }\r
 898 }\r
 899 \r
 900 // AddRef all D3D object when cloning\r
 901 void CEffect::AddRefAllForCloning( CEffect* pEffectSource )\r
 902 {\r
 903     UINT  i;\r
 904 \r
 905     // Keep the following in line with ~CEffect\r
 906 \r
 907     D3DXASSERT( m_pDevice != NULL );\r
 908 \r
 909     for( UINT i = 0; i < m_ShaderBlockCount; ++ i )\r
 910     {\r
 911         SAFE_ADDREF( m_pShaderBlocks[i].pInputSignatureBlob );\r
 912         if( m_pShaderBlocks[i].pReflectionData )\r
 913         {\r
 914             SAFE_ADDREF( m_pShaderBlocks[i].pReflectionData->pReflection );\r
 915         }\r
 916     }\r
 917 \r
 918     D3DXASSERT(NULL == m_pRasterizerBlocks || pEffectSource->m_Heap.IsInHeap(m_pRasterizerBlocks));\r
 919     for (i = 0; i < m_RasterizerBlockCount; ++ i)\r
 920     {\r
 921         SAFE_ADDREF(m_pRasterizerBlocks[i].pRasterizerObject);\r
 922     }\r
 923 \r
 924     D3DXASSERT(NULL == m_pBlendBlocks || pEffectSource->m_Heap.IsInHeap(m_pBlendBlocks));\r
 925     for (i = 0; i < m_BlendBlockCount; ++ i)\r
 926     {\r
 927         SAFE_ADDREF(m_pBlendBlocks[i].pBlendObject);\r
 928     }\r
 929 \r
 930     D3DXASSERT(NULL == m_pDepthStencilBlocks || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilBlocks));\r
 931     for (i = 0; i < m_DepthStencilBlockCount; ++ i)\r
 932     {\r
 933         SAFE_ADDREF(m_pDepthStencilBlocks[i].pDSObject);\r
 934     }\r
 935 \r
 936     D3DXASSERT(NULL == m_pSamplerBlocks || pEffectSource->m_Heap.IsInHeap(m_pSamplerBlocks));\r
 937     for (i = 0; i < m_SamplerBlockCount; ++ i)\r
 938     {\r
 939         SAFE_ADDREF(m_pSamplerBlocks[i].pD3DObject);\r
 940     }\r
 941 \r
 942     D3DXASSERT(NULL == m_pShaderResources || pEffectSource->m_Heap.IsInHeap(m_pShaderResources));\r
 943     for (i = 0; i < m_ShaderResourceCount; ++ i)\r
 944     {\r
 945         SAFE_ADDREF(m_pShaderResources[i].pShaderResource);\r
 946     }\r
 947 \r
 948     D3DXASSERT(NULL == m_pUnorderedAccessViews || pEffectSource->m_Heap.IsInHeap(m_pUnorderedAccessViews));\r
 949     for (i = 0; i < m_UnorderedAccessViewCount; ++ i)\r
 950     {\r
 951         SAFE_ADDREF(m_pUnorderedAccessViews[i].pUnorderedAccessView);\r
 952     }\r
 953 \r
 954     D3DXASSERT(NULL == m_pRenderTargetViews || pEffectSource->m_Heap.IsInHeap(m_pRenderTargetViews));\r
 955     for (i = 0; i < m_RenderTargetViewCount; ++ i)\r
 956     {\r
 957         SAFE_ADDREF(m_pRenderTargetViews[i].pRenderTargetView);\r
 958     }\r
 959 \r
 960     D3DXASSERT(NULL == m_pDepthStencilViews || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilViews));\r
 961     for (i = 0; i < m_DepthStencilViewCount; ++ i)\r
 962     {\r
 963         SAFE_ADDREF(m_pDepthStencilViews[i].pDepthStencilView);\r
 964     }\r
 965 \r
 966     D3DXASSERT(NULL == m_pMemberDataBlocks || pEffectSource->m_Heap.IsInHeap(m_pMemberDataBlocks));\r
 967     for (i = 0; i < m_MemberDataCount; ++ i)\r
 968     {\r
 969         switch( m_pMemberDataBlocks[i].Type )\r
 970         {\r
 971         case MDT_ClassInstance:\r
 972             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DClassInstance);\r
 973             break;\r
 974         case MDT_BlendState:\r
 975             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedBlendState);\r
 976             break;\r
 977         case MDT_DepthStencilState:\r
 978             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedDepthStencilState);\r
 979             break;\r
 980         case MDT_RasterizerState:\r
 981             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedRasterizerState);\r
 982             break;\r
 983         case MDT_SamplerState:\r
 984             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedSamplerState);\r
 985             break;\r
 986         case MDT_Buffer:\r
 987             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedConstantBuffer);\r
 988             break;\r
 989         case MDT_ShaderResourceView:\r
 990             SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedTextureBuffer);\r
 991             break;\r
 992         default:\r
 993             D3DXASSERT( false );\r
 994         }\r
 995     }\r
 996 \r
 997     // There's no need to AddRef CBs, since they are recreated\r
 998     D3DXASSERT(NULL == m_pCBs || pEffectSource->m_Heap.IsInHeap(m_pCBs));\r
 999     for (i = 0; i < m_CBCount; ++ i)\r
1000     {\r
1001         SAFE_ADDREF(m_pCBs[i].TBuffer.pShaderResource);\r
1002         SAFE_ADDREF(m_pCBs[i].pD3DObject);\r
1003     }\r
1004 \r
1005     D3DXASSERT(NULL == m_pShaderBlocks || pEffectSource->m_Heap.IsInHeap(m_pShaderBlocks));\r
1006     for (i = 0; i < m_ShaderBlockCount; ++ i)\r
1007     {\r
1008         SAFE_ADDREF(m_pShaderBlocks[i].pD3DObject);\r
1009     }\r
1010 \r
1011     SAFE_ADDREF( m_pDevice );\r
1012 \r
1013     SAFE_ADDREF( m_pClassLinkage );\r
1014     D3DXASSERT( m_pContext == NULL );\r
1015 }\r
1016 \r
1017 HRESULT CEffect::QueryInterface(REFIID iid, LPVOID *ppv)\r
1018 {\r
1019     HRESULT hr = S_OK;\r
1020 \r
1021     if(NULL == ppv)\r
1022     {\r
1023         DPF(0, "ID3DX11Effect::QueryInterface: NULL parameter");\r
1024         hr = E_INVALIDARG;\r
1025         goto EXIT;\r
1026     }\r
1027 \r
1028     *ppv = NULL;\r
1029     if(IsEqualIID(iid, IID_IUnknown))\r
1030     {\r
1031         *ppv = (IUnknown *) this;\r
1032     }\r
1033     else if(IsEqualIID(iid, IID_ID3DX11Effect))\r
1034     {\r
1035         *ppv = (ID3DX11Effect *) this;\r
1036     }\r
1037     else\r
1038     {\r
1039         return E_NOINTERFACE;\r
1040     }\r
1041 \r
1042     AddRef();\r
1043 \r
1044 EXIT:\r
1045     return hr;\r
1046 }\r
1047 \r
1048 ULONG CEffect::AddRef()\r
1049 {\r
1050     return ++ m_RefCount;\r
1051 }\r
1052 \r
1053 ULONG CEffect::Release()\r
1054 {\r
1055     if (-- m_RefCount > 0)\r
1056     {\r
1057         return m_RefCount;\r
1058     }\r
1059     else\r
1060     {\r
1061         delete this;\r
1062     }\r
1063 \r
1064     return 0;\r
1065 }\r
1066 \r
1067 // In all shaders, replace pOldBufferBlock with pNewBuffer, if pOldBufferBlock is a dependency\r
1068 void CEffect::ReplaceCBReference(SConstantBuffer *pOldBufferBlock, ID3D11Buffer *pNewBuffer)\r
1069 {\r
1070     UINT iShaderBlock;\r
1071 \r
1072     for (iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)\r
1073     {\r
1074         for (UINT iCBDep = 0; iCBDep < m_pShaderBlocks[iShaderBlock].CBDepCount; iCBDep++)\r
1075         {\r
1076             for (UINT iCB = 0; iCB < m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].Count; iCB++)\r
1077             {\r
1078                 if (m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].ppFXPointers[iCB] == pOldBufferBlock)\r
1079                     m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].ppD3DObjects[iCB] = pNewBuffer;\r
1080             }\r
1081         }\r
1082     }\r
1083 }\r
1084 \r
1085 // In all shaders, replace pOldSamplerBlock with pNewSampler, if pOldSamplerBlock is a dependency\r
1086 void CEffect::ReplaceSamplerReference(SSamplerBlock *pOldSamplerBlock, ID3D11SamplerState *pNewSampler)\r
1087 {\r
1088     UINT iShaderBlock;\r
1089 \r
1090     for (iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)\r
1091     {\r
1092         for (UINT iSamplerDep = 0; iSamplerDep < m_pShaderBlocks[iShaderBlock].SampDepCount; iSamplerDep++)\r
1093         {\r
1094             for (UINT iSampler = 0; iSampler < m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].Count; iSampler++)\r
1095             {\r
1096                 if (m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].ppFXPointers[iSampler] == pOldSamplerBlock)\r
1097                     m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].ppD3DObjects[iSampler] = pNewSampler;\r
1098             }\r
1099         }\r
1100     }\r
1101 }\r
1102 \r
1103 // Call BindToDevice after the effect has been fully loaded.\r
1104 // BindToDevice will release all D3D11 objects and create new ones on the new device\r
1105 HRESULT CEffect::BindToDevice(ID3D11Device *pDevice)\r
1106 {\r
1107     HRESULT hr = S_OK;\r
1108 \r
1109     // Set new device\r
1110     if (pDevice == NULL)\r
1111     {\r
1112         DPF(0, "ID3DX11Effect: pDevice must point to a valid D3D11 device");\r
1113         return D3DERR_INVALIDCALL;\r
1114     }\r
1115 \r
1116     if (m_pDevice != NULL)\r
1117     {\r
1118         DPF(0, "ID3DX11Effect: Internal error, rebinding effects to a new device is not supported");\r
1119         return D3DERR_INVALIDCALL;\r
1120     }\r
1121 \r
1122     bool featureLevelGE11 = ( pDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0 );\r
1123 \r
1124     pDevice->AddRef();\r
1125     SAFE_RELEASE(m_pDevice);\r
1126     m_pDevice = pDevice;\r
1127     VH( m_pDevice->CreateClassLinkage( &m_pClassLinkage ) );\r
1128 \r
1129     // Create all constant buffers\r
1130     SConstantBuffer *pCB = m_pCBs;\r
1131     SConstantBuffer *pCBLast = m_pCBs + m_CBCount;\r
1132     for(; pCB != pCBLast; pCB++)\r
1133     {\r
1134         SAFE_RELEASE(pCB->pD3DObject);\r
1135         SAFE_RELEASE(pCB->TBuffer.pShaderResource);\r
1136 \r
1137         // This is a CBuffer\r
1138         if (pCB->Size > 0)\r
1139         {\r
1140             if (pCB->IsTBuffer)\r
1141             {\r
1142                 D3D11_BUFFER_DESC bufDesc;\r
1143                 // size is always register aligned\r
1144                 bufDesc.ByteWidth = pCB->Size;\r
1145                 bufDesc.Usage = D3D11_USAGE_DEFAULT;\r
1146                 bufDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;\r
1147                 bufDesc.CPUAccessFlags = 0;\r
1148                 bufDesc.MiscFlags = 0;\r
1149 \r
1150                 VH( pDevice->CreateBuffer( &bufDesc, NULL, &pCB->pD3DObject) );\r
1151                 \r
1152                 D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;\r
1153                 viewDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;\r
1154                 viewDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;\r
1155                 viewDesc.Buffer.ElementOffset = 0;\r
1156                 viewDesc.Buffer.ElementWidth = pCB->Size / SType::c_RegisterSize;\r
1157 \r
1158                 VH( pDevice->CreateShaderResourceView( pCB->pD3DObject, &viewDesc, &pCB->TBuffer.pShaderResource) );\r
1159             }\r
1160             else\r
1161             {\r
1162                 D3D11_BUFFER_DESC bufDesc;\r
1163                 // size is always register aligned\r
1164                 bufDesc.ByteWidth = pCB->Size;\r
1165                 bufDesc.Usage = D3D11_USAGE_DEFAULT;\r
1166                 bufDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;\r
1167                 bufDesc.CPUAccessFlags = 0;\r
1168                 bufDesc.MiscFlags = 0;\r
1169 \r
1170                 VH( pDevice->CreateBuffer( &bufDesc, NULL, &pCB->pD3DObject) );\r
1171                 pCB->TBuffer.pShaderResource = NULL;\r
1172             }\r
1173 \r
1174             pCB->IsDirty = TRUE;\r
1175         }\r
1176         else\r
1177         {\r
1178             pCB->IsDirty = FALSE;\r
1179         }\r
1180     }\r
1181 \r
1182     // Create all RasterizerStates\r
1183     SRasterizerBlock *pRB = m_pRasterizerBlocks;\r
1184     SRasterizerBlock *pRBLast = m_pRasterizerBlocks + m_RasterizerBlockCount;\r
1185     for(; pRB != pRBLast; pRB++)\r
1186     {\r
1187         SAFE_RELEASE(pRB->pRasterizerObject);\r
1188         if( SUCCEEDED( m_pDevice->CreateRasterizerState( &pRB->BackingStore, &pRB->pRasterizerObject) ) )\r
1189             pRB->IsValid = TRUE;\r
1190         else\r
1191             pRB->IsValid = FALSE;\r
1192     }\r
1193 \r
1194     // Create all DepthStencils\r
1195     SDepthStencilBlock *pDS = m_pDepthStencilBlocks;\r
1196     SDepthStencilBlock *pDSLast = m_pDepthStencilBlocks + m_DepthStencilBlockCount;\r
1197     for(; pDS != pDSLast; pDS++)\r
1198     {\r
1199         SAFE_RELEASE(pDS->pDSObject);\r
1200         if( SUCCEEDED( m_pDevice->CreateDepthStencilState( &pDS->BackingStore, &pDS->pDSObject) ) )\r
1201             pDS->IsValid = TRUE;\r
1202         else\r
1203             pDS->IsValid = FALSE;\r
1204     }\r
1205 \r
1206     // Create all BlendStates\r
1207     SBlendBlock *pBlend = m_pBlendBlocks;\r
1208     SBlendBlock *pBlendLast = m_pBlendBlocks + m_BlendBlockCount;\r
1209     for(; pBlend != pBlendLast; pBlend++)\r
1210     {\r
1211         SAFE_RELEASE(pBlend->pBlendObject);\r
1212         if( SUCCEEDED( m_pDevice->CreateBlendState( &pBlend->BackingStore, &pBlend->pBlendObject ) ) )\r
1213             pBlend->IsValid = TRUE;\r
1214         else\r
1215             pBlend->IsValid = FALSE;\r
1216     }\r
1217 \r
1218     // Create all Samplers\r
1219     SSamplerBlock *pSampler = m_pSamplerBlocks;\r
1220     SSamplerBlock *pSamplerLast = m_pSamplerBlocks + m_SamplerBlockCount;\r
1221     for(; pSampler != pSamplerLast; pSampler++)\r
1222     {\r
1223         SAFE_RELEASE(pSampler->pD3DObject);\r
1224 \r
1225         VH( m_pDevice->CreateSamplerState( &pSampler->BackingStore.SamplerDesc, &pSampler->pD3DObject) );\r
1226     }\r
1227 \r
1228     // Create all shaders\r
1229     ID3D11ClassLinkage* neededClassLinkage = featureLevelGE11 ? m_pClassLinkage : NULL;\r
1230     SShaderBlock *pShader = m_pShaderBlocks;\r
1231     SShaderBlock *pShaderLast = m_pShaderBlocks + m_ShaderBlockCount;\r
1232     for(; pShader != pShaderLast; pShader++)\r
1233     {\r
1234         SAFE_RELEASE(pShader->pD3DObject);\r
1235 \r
1236         if (NULL == pShader->pReflectionData)\r
1237         {\r
1238             // NULL shader. It's one of these:\r
1239             // PixelShader ps;\r
1240             // or\r
1241             // SetPixelShader( NULL );\r
1242             continue;\r
1243         }\r
1244         \r
1245         if (pShader->pReflectionData->pStreamOutDecls[0] || pShader->pReflectionData->pStreamOutDecls[1] || \r
1246             pShader->pReflectionData->pStreamOutDecls[2] || pShader->pReflectionData->pStreamOutDecls[3] )\r
1247         {\r
1248             // This is a geometry shader, process it's data\r
1249             CSOParser soParser;\r
1250             VH( soParser.Parse(pShader->pReflectionData->pStreamOutDecls) );\r
1251             UINT strides[4];\r
1252             soParser.GetStrides( strides );\r
1253             hr = m_pDevice->CreateGeometryShaderWithStreamOutput((UINT*) pShader->pReflectionData->pBytecode,\r
1254                                                                 pShader->pReflectionData->BytecodeLength,\r
1255                                                                 soParser.GetDeclArray(),\r
1256                                                                 soParser.GetDeclCount(),\r
1257                                                                 strides,\r
1258                                                                 featureLevelGE11 ? 4 : 1,\r
1259                                                                 pShader->pReflectionData->RasterizedStream,\r
1260                                                                 neededClassLinkage,\r
1261                                                                 (ID3D11GeometryShader**) &pShader->pD3DObject);\r
1262             if (FAILED(hr))\r
1263             {\r
1264                 DPF(1, "ID3DX11Effect::Load - failed to create GeometryShader with StreamOutput decl: \"%s\"", soParser.GetErrorString() );\r
1265                 pShader->IsValid = FALSE;\r
1266                 hr = S_OK;\r
1267             }\r
1268         }\r
1269         else\r
1270         {\r
1271             // This is a regular shader\r
1272             if( pShader->pReflectionData->RasterizedStream == D3D11_SO_NO_RASTERIZED_STREAM )\r
1273                 pShader->IsValid = FALSE;\r
1274             else \r
1275             {\r
1276                 if( FAILED( (m_pDevice->*(pShader->pVT->pCreateShader))( (UINT *) pShader->pReflectionData->pBytecode, pShader->pReflectionData->BytecodeLength, neededClassLinkage, &pShader->pD3DObject) ) )\r
1277                 {\r
1278                     DPF(1, "ID3DX11Effect::Load - failed to create shader" );\r
1279                     pShader->IsValid = FALSE;\r
1280                 }\r
1281             }\r
1282         }\r
1283 \r
1284         // Update all dependency pointers\r
1285         VH( pShader->OnDeviceBind() );\r
1286     }\r
1287 \r
1288     // Initialize the member data pointers for all variables\r
1289     UINT CurMemberData = 0;\r
1290     for (UINT i = 0; i < m_VariableCount; ++ i)\r
1291     {\r
1292         if( m_pVariables[i].pMemberData )\r
1293         {\r
1294             if( m_pVariables[i].pType->IsClassInstance() )\r
1295             {\r
1296                 for (UINT j = 0; j < max(m_pVariables[i].pType->Elements,1); ++j)\r
1297                 {\r
1298                     D3DXASSERT( CurMemberData < m_MemberDataCount );\r
1299                     ID3D11ClassInstance** ppCI = &(m_pVariables[i].pMemberData + j)->Data.pD3DClassInstance;\r
1300                     (m_pVariables[i].pMemberData + j)->Type = MDT_ClassInstance;\r
1301                     (m_pVariables[i].pMemberData + j)->Data.pD3DClassInstance = NULL;\r
1302                     if( m_pVariables[i].pType->TotalSize > 0 )\r
1303                     {\r
1304                         // ignore failures in GetClassInstance;\r
1305                         m_pClassLinkage->GetClassInstance( m_pVariables[i].pName, j, ppCI );\r
1306                     }\r
1307                     else\r
1308                     {\r
1309                         // The HLSL compiler optimizes out zero-sized classes, so we have to create class instances from scratch\r
1310                         if( FAILED( m_pClassLinkage->CreateClassInstance( m_pVariables[i].pType->pTypeName, 0, 0, 0, 0, ppCI ) ) )\r
1311                         {\r
1312                             DPF(0, "ID3DX11Effect: Out of memory while trying to create new class instance interface");\r
1313                         }\r
1314                     }\r
1315                     CurMemberData++;\r
1316                 }\r
1317             }\r
1318             else if( m_pVariables[i].pType->IsStateBlockObject() )\r
1319             {\r
1320                 for (UINT j = 0; j < max(m_pVariables[i].pType->Elements,1); ++j)\r
1321                 {\r
1322                     switch( m_pVariables[i].pType->ObjectType )\r
1323                     {\r
1324                     case EOT_Blend:\r
1325                         (m_pVariables[i].pMemberData + j)->Type = MDT_BlendState;\r
1326                         (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedBlendState = NULL;\r
1327                         break;\r
1328                     case EOT_Rasterizer:\r
1329                         (m_pVariables[i].pMemberData + j)->Type = MDT_RasterizerState;\r
1330                         (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedRasterizerState = NULL;\r
1331                         break;\r
1332                     case EOT_DepthStencil:\r
1333                         (m_pVariables[i].pMemberData + j)->Type = MDT_DepthStencilState;\r
1334                         (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedDepthStencilState = NULL;\r
1335                         break;\r
1336                     case EOT_Sampler:\r
1337                         (m_pVariables[i].pMemberData + j)->Type = MDT_SamplerState;\r
1338                         (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedSamplerState = NULL;\r
1339                         break;\r
1340                     default:\r
1341                         VB( FALSE );\r
1342                     }\r
1343                     CurMemberData++;\r
1344                 }\r
1345             }\r
1346             else\r
1347             {\r
1348                 VB( FALSE );\r
1349             }\r
1350         }\r
1351     }\r
1352     for(pCB = m_pCBs; pCB != pCBLast; pCB++)\r
1353     {\r
1354         (pCB->pMemberData + 0)->Type = MDT_Buffer;\r
1355         (pCB->pMemberData + 0)->Data.pD3DEffectsManagedConstantBuffer = NULL;\r
1356         CurMemberData++;\r
1357         (pCB->pMemberData + 1)->Type = MDT_ShaderResourceView;\r
1358         (pCB->pMemberData + 1)->Data.pD3DEffectsManagedTextureBuffer = NULL;\r
1359         CurMemberData++;\r
1360     }\r
1361 \r
1362 \r
1363     // Determine which techniques and passes are known to be invalid\r
1364     for( UINT iGroup=0; iGroup < m_GroupCount; iGroup++ )\r
1365     {\r
1366         SGroup* pGroup = &m_pGroups[iGroup];\r
1367         pGroup->InitiallyValid = TRUE;\r
1368 \r
1369         for( UINT iTech=0; iTech < pGroup->TechniqueCount; iTech++ )\r
1370         {\r
1371             STechnique* pTechnique = &pGroup->pTechniques[iTech];\r
1372             pTechnique->InitiallyValid = TRUE;\r
1373            \r
1374             for( UINT iPass = 0; iPass < pTechnique->PassCount; iPass++ )\r
1375             {\r
1376                 SPassBlock* pPass = &pTechnique->pPasses[iPass];\r
1377                 pPass->InitiallyValid = TRUE;\r
1378 \r
1379                 if( pPass->BackingStore.pBlendBlock != NULL && !pPass->BackingStore.pBlendBlock->IsValid )\r
1380                     pPass->InitiallyValid = FALSE;\r
1381                 if( pPass->BackingStore.pDepthStencilBlock != NULL && !pPass->BackingStore.pDepthStencilBlock->IsValid )\r
1382                     pPass->InitiallyValid = FALSE;\r
1383                 if( pPass->BackingStore.pRasterizerBlock != NULL && !pPass->BackingStore.pRasterizerBlock->IsValid )\r
1384                     pPass->InitiallyValid = FALSE;\r
1385                 if( pPass->BackingStore.pVertexShaderBlock != NULL && !pPass->BackingStore.pVertexShaderBlock->IsValid )\r
1386                     pPass->InitiallyValid = FALSE;\r
1387                 if( pPass->BackingStore.pPixelShaderBlock != NULL && !pPass->BackingStore.pPixelShaderBlock->IsValid )\r
1388                     pPass->InitiallyValid = FALSE;\r
1389                 if( pPass->BackingStore.pGeometryShaderBlock != NULL && !pPass->BackingStore.pGeometryShaderBlock->IsValid )\r
1390                     pPass->InitiallyValid = FALSE;\r
1391                 if( pPass->BackingStore.pHullShaderBlock != NULL && !pPass->BackingStore.pHullShaderBlock->IsValid )\r
1392                     pPass->InitiallyValid = FALSE;\r
1393                 if( pPass->BackingStore.pDomainShaderBlock != NULL && !pPass->BackingStore.pDomainShaderBlock->IsValid )\r
1394                     pPass->InitiallyValid = FALSE;\r
1395                 if( pPass->BackingStore.pComputeShaderBlock != NULL && !pPass->BackingStore.pComputeShaderBlock->IsValid )\r
1396                     pPass->InitiallyValid = FALSE;\r
1397 \r
1398                 pTechnique->InitiallyValid &= pPass->InitiallyValid;\r
1399             }\r
1400             pGroup->InitiallyValid &= pTechnique->InitiallyValid;\r
1401         }\r
1402     }\r
1403 \r
1404 lExit:\r
1405     return hr;\r
1406 }\r
1407 \r
1408 // FindVariableByName, plus an understanding of literal indices\r
1409 // This code handles A[i].\r
1410 // It does not handle anything else, like A.B, A[B[i]], A[B]\r
1411 SVariable * CEffect::FindVariableByNameWithParsing(LPCSTR pName)\r
1412 {\r
1413     SGlobalVariable *pVariable;\r
1414     const UINT MAX_PARSABLE_NAME_LENGTH = 256;\r
1415     char pScratchString[MAX_PARSABLE_NAME_LENGTH];\r
1416 \r
1417     const char* pSource = pName;\r
1418     char* pDest = pScratchString;\r
1419     char* pEnd = pScratchString + MAX_PARSABLE_NAME_LENGTH;\r
1420 \r
1421     pVariable = NULL;\r
1422 \r
1423     while( *pSource != 0 )\r
1424     {\r
1425         if( pDest == pEnd )\r
1426         {\r
1427             pVariable = FindLocalVariableByName(pName);\r
1428             if( pVariable == NULL )\r
1429             {\r
1430                 DPF( 0, "Name %s is too long to parse", &pName );\r
1431             }\r
1432             return pVariable;\r
1433         }\r
1434 \r
1435         if( *pSource == '[' )\r
1436         {\r
1437             // parse previous variable name\r
1438             *pDest = 0;\r
1439             D3DXASSERT( pVariable == NULL );\r
1440             pVariable = FindLocalVariableByName(pScratchString);\r
1441             if( pVariable == NULL )\r
1442             {\r
1443                 return NULL;\r
1444             }\r
1445             pDest = pScratchString;\r
1446         }\r
1447         else if( *pSource == ']' )\r
1448         {\r
1449             // parse integer\r
1450             *pDest = 0;\r
1451             UINT index = atoi(pScratchString);\r
1452             D3DXASSERT( pVariable != NULL );\r
1453             pVariable = (SGlobalVariable*)pVariable->GetElement(index);\r
1454             if( pVariable && !pVariable->IsValid() )\r
1455             {\r
1456                 pVariable = NULL;\r
1457             }\r
1458             return pVariable;\r
1459         }\r
1460         else\r
1461         {\r
1462             // add character\r
1463             *pDest = *pSource;\r
1464             pDest++;\r
1465         }\r
1466         pSource++;\r
1467     }\r
1468 \r
1469     if( pDest != pScratchString )\r
1470     {\r
1471         // parse the variable name (there was no [i])\r
1472         *pDest = 0;\r
1473         D3DXASSERT( pVariable == NULL );\r
1474         pVariable = FindLocalVariableByName(pScratchString);\r
1475     }\r
1476 \r
1477     return pVariable;\r
1478 }\r
1479 \r
1480 SGlobalVariable * CEffect::FindVariableByName(LPCSTR pName)\r
1481 {\r
1482     SGlobalVariable *pVariable;\r
1483 \r
1484     pVariable = FindLocalVariableByName(pName);\r
1485 \r
1486     return pVariable;\r
1487 }\r
1488 \r
1489 SGlobalVariable * CEffect::FindLocalVariableByName(LPCSTR pName)\r
1490 {\r
1491     SGlobalVariable *pVariable, *pVariableEnd;\r
1492 \r
1493     pVariableEnd = m_pVariables + m_VariableCount;\r
1494     for (pVariable = m_pVariables; pVariable != pVariableEnd; pVariable++)\r
1495     {\r
1496         if (strcmp( pVariable->pName, pName) == 0)\r
1497         {\r
1498             return pVariable;\r
1499         }\r
1500     }\r
1501 \r
1502     return NULL;\r
1503 }\r
1504 \r
1505 \r
1506 //\r
1507 // Checks to see if two types are equivalent (either at runtime\r
1508 // or during the type-pooling load process)\r
1509 //\r
1510 // Major assumption: if both types are structures, then their\r
1511 // member types & names should already have been added to the pool,\r
1512 // in which case their member type & name pointers should be equal.\r
1513 //\r
1514 // This is true because complex data types (structures) have all\r
1515 // sub-types translated before the containing type is translated,\r
1516 // which means that simple sub-types (numeric types) have already\r
1517 // been pooled.\r
1518 //\r
1519 BOOL SType::IsEqual(SType *pOtherType) CONST\r
1520 {\r
1521     if (VarType != pOtherType->VarType || Elements != pOtherType->Elements\r
1522         || strcmp(pTypeName, pOtherType->pTypeName) != 0)\r
1523     {\r
1524         return FALSE;\r
1525     }\r
1526 \r
1527     switch (VarType)\r
1528     {\r
1529     case EVT_Struct:\r
1530         {\r
1531             if (StructType.Members != pOtherType->StructType.Members)\r
1532             {\r
1533                 return FALSE;\r
1534             }\r
1535             D3DXASSERT(StructType.pMembers != NULL && pOtherType->StructType.pMembers != NULL);\r
1536 \r
1537             UINT  i;\r
1538             for (i = 0; i < StructType.Members; ++ i)\r
1539             {\r
1540                 // names for types must exist (not true for semantics)\r
1541                 D3DXASSERT(StructType.pMembers[i].pName != NULL && pOtherType->StructType.pMembers[i].pName != NULL);\r
1542 \r
1543                 if (StructType.pMembers[i].pType != pOtherType->StructType.pMembers[i].pType ||\r
1544                     StructType.pMembers[i].Data.Offset != pOtherType->StructType.pMembers[i].Data.Offset ||\r
1545                     StructType.pMembers[i].pName != pOtherType->StructType.pMembers[i].pName ||\r
1546                     StructType.pMembers[i].pSemantic != pOtherType->StructType.pMembers[i].pSemantic)\r
1547                 {\r
1548                     return FALSE;\r
1549                 }\r
1550             }\r
1551         }\r
1552         break;\r
1553 \r
1554     case EVT_Object:\r
1555         {\r
1556             if (ObjectType != pOtherType->ObjectType)\r
1557             {\r
1558                 return FALSE;\r
1559             }\r
1560         }\r
1561         break;\r
1562 \r
1563     case EVT_Numeric:\r
1564         {\r
1565             if (NumericType.Rows != pOtherType->NumericType.Rows ||\r
1566                 NumericType.Columns != pOtherType->NumericType.Columns ||\r
1567                 NumericType.ScalarType != pOtherType->NumericType.ScalarType ||\r
1568                 NumericType.NumericLayout != pOtherType->NumericType.NumericLayout ||\r
1569                 NumericType.IsColumnMajor != pOtherType->NumericType.IsColumnMajor ||\r
1570                 NumericType.IsPackedArray != pOtherType->NumericType.IsPackedArray)\r
1571             {\r
1572                 return FALSE;\r
1573             }\r
1574         }\r
1575         break;\r
1576 \r
1577     case EVT_Interface:\r
1578         {\r
1579             // VarType and pTypeName handled above\r
1580         }\r
1581         break;\r
1582 \r
1583     default:\r
1584         {\r
1585             D3DXASSERT(0);\r
1586             return FALSE;\r
1587         }\r
1588         break;\r
1589     }\r
1590 \r
1591     D3DXASSERT(TotalSize == pOtherType->TotalSize && Stride == pOtherType->Stride && PackedSize == pOtherType->PackedSize);\r
1592 \r
1593     return TRUE;\r
1594 }\r
1595 \r
1596 UINT SType::GetTotalUnpackedSize(BOOL IsSingleElement) CONST\r
1597 {\r
1598     if (VarType == EVT_Object)\r
1599     {\r
1600         return 0;\r
1601     }\r
1602     else if (VarType == EVT_Interface)\r
1603     {\r
1604         return 0;\r
1605     }\r
1606     else if (Elements > 0 && IsSingleElement)\r
1607     {\r
1608         D3DXASSERT( ( TotalSize == 0 && Stride == 0 ) ||\r
1609                     ( (TotalSize > (Stride * (Elements - 1))) && (TotalSize <= (Stride * Elements)) ) );\r
1610         return TotalSize - Stride * (Elements - 1);\r
1611     }\r
1612     else\r
1613     {\r
1614         return TotalSize;\r
1615     }\r
1616 }\r
1617 \r
1618 UINT SType::GetTotalPackedSize(BOOL IsSingleElement) CONST\r
1619 {\r
1620     if (Elements > 0 && IsSingleElement)\r
1621     {\r
1622         D3DXASSERT(PackedSize % Elements == 0);\r
1623         return PackedSize / Elements;\r
1624     }\r
1625     else\r
1626     {\r
1627         return PackedSize;\r
1628     }\r
1629 }\r
1630 \r
1631 SConstantBuffer *CEffect::FindCB(LPCSTR pName)\r
1632 {\r
1633     UINT  i;\r
1634 \r
1635     for (i=0; i<m_CBCount; i++)\r
1636     {\r
1637         if (!strcmp(m_pCBs[i].pName, pName))\r
1638         {\r
1639             return &m_pCBs[i];\r
1640         }\r
1641     }\r
1642 \r
1643     return NULL;\r
1644 }\r
1645 \r
1646 inline UINT  PtrToDword(void *pPtr)\r
1647 {\r
1648     return (UINT)(UINT_PTR) pPtr;\r
1649 }\r
1650 \r
1651 BOOL CEffect::IsOptimized()\r
1652 {\r
1653     if ((m_Flags & D3DX11_EFFECT_OPTIMIZED) != 0)\r
1654     {\r
1655         D3DXASSERT(NULL == m_pReflection);\r
1656         return TRUE;\r
1657     }\r
1658     else\r
1659     {\r
1660         D3DXASSERT(NULL != m_pReflection);\r
1661         return FALSE;\r
1662     }\r
1663 }\r
1664 \r
1665 // Replace *ppType with the corresponding value in pMappingTable\r
1666 // pMappingTable table describes how to map old type pointers to new type pointers\r
1667 static HRESULT RemapType(SType **ppType, CPointerMappingTable *pMappingTable)\r
1668 {\r
1669     HRESULT hr = S_OK;\r
1670 \r
1671     SPointerMapping ptrMapping;\r
1672     CPointerMappingTable::CIterator iter;\r
1673     ptrMapping.pOld = *ppType;\r
1674     VH( pMappingTable->FindValueWithHash(ptrMapping, ptrMapping.Hash(), &iter) );\r
1675     *ppType = (SType *) iter.GetData().pNew;\r
1676 \r
1677 lExit:\r
1678     return hr;\r
1679 }\r
1680 \r
1681 // Replace *ppString with the corresponding value in pMappingTable\r
1682 // pMappingTable table describes how to map old string pointers to new string pointers\r
1683 static HRESULT RemapString(__in char **ppString, CPointerMappingTable *pMappingTable)\r
1684 {\r
1685     HRESULT hr = S_OK;\r
1686 \r
1687     SPointerMapping ptrMapping;\r
1688     CPointerMappingTable::CIterator iter;\r
1689     ptrMapping.pOld = *ppString;\r
1690     VH( pMappingTable->FindValueWithHash(ptrMapping, ptrMapping.Hash(), &iter) );\r
1691     *ppString = (char *) iter.GetData().pNew;\r
1692 \r
1693 lExit:\r
1694     return hr;\r
1695 }\r
1696 \r
1697 // Used in cloning, copy m_pMemberInterfaces from pEffectSource to this\r
1698 HRESULT CEffect::CopyMemberInterfaces( CEffect* pEffectSource )\r
1699 {\r
1700     HRESULT hr = S_OK;\r
1701     UINT i; // after a failure, this holds the failing index\r
1702 \r
1703     UINT Members = pEffectSource->m_pMemberInterfaces.GetSize();\r
1704     m_pMemberInterfaces.AddRange(Members);\r
1705     for( i=0; i < Members; i++ )\r
1706     {\r
1707         SMember* pOldMember = pEffectSource->m_pMemberInterfaces[i];\r
1708         if( pOldMember == NULL )\r
1709         {\r
1710             // During Optimization, m_pMemberInterfaces[i] was set to NULL because it was an annotation\r
1711             m_pMemberInterfaces[i] = NULL;\r
1712             continue;\r
1713         }\r
1714 \r
1715         SMember *pNewMember;\r
1716         D3DXASSERT( pOldMember->pTopLevelEntity != NULL );\r
1717 \r
1718         if (NULL == (pNewMember = CreateNewMember((SType*)pOldMember->pType, FALSE)))\r
1719         {\r
1720             DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");\r
1721             VN( pNewMember );\r
1722         }\r
1723 \r
1724         pNewMember->pType = pOldMember->pType;\r
1725         pNewMember->pName = pOldMember->pName;\r
1726         pNewMember->pSemantic = pOldMember->pSemantic;\r
1727         pNewMember->Data.pGeneric = pOldMember->Data.pGeneric;\r
1728         pNewMember->IsSingleElement = pOldMember->IsSingleElement;\r
1729         pNewMember->pTopLevelEntity = pOldMember->pTopLevelEntity;\r
1730         pNewMember->pMemberData = pOldMember->pMemberData;\r
1731 \r
1732         m_pMemberInterfaces[i] = pNewMember;\r
1733     }\r
1734 \r
1735 lExit:\r
1736     if( FAILED(hr) )\r
1737     {\r
1738         D3DXASSERT( i < Members );\r
1739         ZeroMemory( &m_pMemberInterfaces[i], sizeof(SMember) * ( Members - i ) );\r
1740     }\r
1741     return hr;\r
1742 }\r
1743 \r
1744 // Used in cloning, copy the string pool from pEffectSource to this and build mappingTable\r
1745 // for use in RemapString\r
1746 HRESULT CEffect::CopyStringPool( CEffect* pEffectSource, CPointerMappingTable& mappingTable )\r
1747 {\r
1748     HRESULT hr = S_OK;\r
1749     D3DXASSERT( m_pPooledHeap != NULL );\r
1750     VN( m_pStringPool = NEW CEffect::CStringHashTable );\r
1751     m_pStringPool->SetPrivateHeap(m_pPooledHeap);\r
1752     VH( m_pStringPool->AutoGrow() );\r
1753 \r
1754     CStringHashTable::CIterator stringIter;\r
1755 \r
1756     // move strings over, build mapping table\r
1757     for (pEffectSource->m_pStringPool->GetFirstEntry(&stringIter); !pEffectSource->m_pStringPool->PastEnd(&stringIter); pEffectSource->m_pStringPool->GetNextEntry(&stringIter))\r
1758     {\r
1759         SPointerMapping ptrMapping;\r
1760         char *pString;\r
1761 \r
1762         const char* pOldString = stringIter.GetData();\r
1763         ptrMapping.pOld = (void*)pOldString;\r
1764         UINT len = (UINT)strlen(pOldString);\r
1765         UINT hash = ptrMapping.Hash();\r
1766         VN( pString = new(*m_pPooledHeap) char[len + 1] );\r
1767         ptrMapping.pNew = (void*)pString;\r
1768         memcpy(ptrMapping.pNew, ptrMapping.pOld, len + 1);\r
1769         VH( m_pStringPool->AddValueWithHash(pString, hash) );\r
1770 \r
1771         VH( mappingTable.AddValueWithHash(ptrMapping, hash) );\r
1772     }\r
1773 \r
1774     // Uncomment to print string mapping\r
1775     /*\r
1776     CPointerMappingTable::CIterator mapIter;\r
1777     for (mappingTable.GetFirstEntry(&mapIter); !mappingTable.PastEnd(&mapIter); mappingTable.GetNextEntry(&mapIter))\r
1778     {\r
1779     SPointerMapping ptrMapping = mapIter.GetData();\r
1780     DPF(0, "string: 0x%x : 0x%x  %s", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew, (char*)ptrMapping.pNew );\r
1781     }*/\r
1782 \r
1783 lExit:\r
1784     return hr;\r
1785 }\r
1786 \r
1787 // Used in cloning, copy the unoptimized type pool from pEffectSource to this and build mappingTableTypes\r
1788 // for use in RemapType.  mappingTableStrings is the mapping table previously filled when copying strings.\r
1789 HRESULT CEffect::CopyTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes, CPointerMappingTable& mappingTableStrings )\r
1790 {\r
1791     HRESULT hr = S_OK;\r
1792     D3DXASSERT( m_pPooledHeap != NULL );\r
1793     VN( m_pTypePool = NEW CEffect::CTypeHashTable );\r
1794     m_pTypePool->SetPrivateHeap(m_pPooledHeap);\r
1795     VH( m_pTypePool->AutoGrow() );\r
1796 \r
1797     CTypeHashTable::CIterator typeIter;\r
1798     CPointerMappingTable::CIterator mapIter;\r
1799 \r
1800     // first pass: move types over, build mapping table\r
1801     for (pEffectSource->m_pTypePool->GetFirstEntry(&typeIter); !pEffectSource->m_pTypePool->PastEnd(&typeIter); pEffectSource->m_pTypePool->GetNextEntry(&typeIter))\r
1802     {\r
1803         SPointerMapping ptrMapping;\r
1804         SType *pType;\r
1805 \r
1806         ptrMapping.pOld = typeIter.GetData();\r
1807         UINT hash = ptrMapping.Hash();\r
1808         VN( (ptrMapping.pNew) = new(*m_pPooledHeap) SType );\r
1809         memcpy(ptrMapping.pNew, ptrMapping.pOld, sizeof(SType));\r
1810 \r
1811         pType = (SType *) ptrMapping.pNew;\r
1812 \r
1813         // if this is a struct, move its members to the newly allocated space\r
1814         if (EVT_Struct == pType->VarType)\r
1815         {\r
1816             SVariable* pOldMembers = pType->StructType.pMembers;\r
1817             VN( pType->StructType.pMembers = new(*m_pPooledHeap) SVariable[pType->StructType.Members] );\r
1818             memcpy(pType->StructType.pMembers, pOldMembers, pType->StructType.Members * sizeof(SVariable));\r
1819         }\r
1820 \r
1821         VH( m_pTypePool->AddValueWithHash(pType, hash) );\r
1822         VH( mappingTableTypes.AddValueWithHash(ptrMapping, hash) );\r
1823     }\r
1824 \r
1825     // second pass: fixup structure member & name pointers\r
1826     for (mappingTableTypes.GetFirstEntry(&mapIter); !mappingTableTypes.PastEnd(&mapIter); mappingTableTypes.GetNextEntry(&mapIter))\r
1827     {\r
1828         SPointerMapping ptrMapping = mapIter.GetData();\r
1829 \r
1830         // Uncomment to print type mapping\r
1831         //DPF(0, "type: 0x%x : 0x%x", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew );\r
1832 \r
1833         SType *pType = (SType *) ptrMapping.pNew;\r
1834 \r
1835         if( pType->pTypeName )\r
1836         {\r
1837             VH( RemapString(&pType->pTypeName, &mappingTableStrings) );\r
1838         }\r
1839 \r
1840         // if this is a struct, fix up its members' pointers\r
1841         if (EVT_Struct == pType->VarType)\r
1842         {\r
1843             for (UINT i = 0; i < pType->StructType.Members; ++ i)\r
1844             {\r
1845                 VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTableTypes) );\r
1846                 if( pType->StructType.pMembers[i].pName )\r
1847                 {\r
1848                     VH( RemapString(&pType->StructType.pMembers[i].pName, &mappingTableStrings) );\r
1849                 }\r
1850                 if( pType->StructType.pMembers[i].pSemantic )\r
1851                 {\r
1852                     VH( RemapString(&pType->StructType.pMembers[i].pSemantic, &mappingTableStrings) );\r
1853                 }\r
1854             }\r
1855         }\r
1856     } \r
1857 \r
1858 lExit:\r
1859     return hr;\r
1860 }\r
1861 \r
1862 // Used in cloning, copy the unoptimized type pool from pEffectSource to this and build mappingTableTypes\r
1863 // for use in RemapType.  mappingTableStrings is the mapping table previously filled when copying strings.\r
1864 HRESULT CEffect::CopyOptimizedTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes )\r
1865 {\r
1866     HRESULT hr = S_OK;\r
1867     CEffectHeap* pOptimizedTypeHeap = NULL;\r
1868 \r
1869     D3DXASSERT( pEffectSource->m_pOptimizedTypeHeap != NULL );\r
1870     D3DXASSERT( m_pTypePool == NULL );\r
1871     D3DXASSERT( m_pStringPool == NULL );\r
1872     D3DXASSERT( m_pPooledHeap == NULL );\r
1873 \r
1874     VN( pOptimizedTypeHeap = NEW CEffectHeap );\r
1875     VH( pOptimizedTypeHeap->ReserveMemory( pEffectSource->m_pOptimizedTypeHeap->GetSize() ) );\r
1876     CPointerMappingTable::CIterator mapIter;\r
1877 \r
1878     // first pass: move types over, build mapping table\r
1879     BYTE* pReadTypes = pEffectSource->m_pOptimizedTypeHeap->GetDataStart();\r
1880     while( pEffectSource->m_pOptimizedTypeHeap->IsInHeap( pReadTypes ) )\r
1881     {\r
1882         SPointerMapping ptrMapping;\r
1883         SType *pType;\r
1884         UINT moveSize;\r
1885 \r
1886         ptrMapping.pOld = ptrMapping.pNew = pReadTypes;\r
1887         moveSize = sizeof(SType);\r
1888         VH( pOptimizedTypeHeap->MoveData(&ptrMapping.pNew, moveSize) );\r
1889         pReadTypes += moveSize;\r
1890 \r
1891         pType = (SType *) ptrMapping.pNew;\r
1892 \r
1893         // if this is a struct, move its members to the newly allocated space\r
1894         if (EVT_Struct == pType->VarType)\r
1895         {\r
1896             moveSize = pType->StructType.Members * sizeof(SVariable);\r
1897             VH( pOptimizedTypeHeap->MoveData((void **)&pType->StructType.pMembers, moveSize) );\r
1898             pReadTypes += moveSize;\r
1899         }\r
1900 \r
1901         VH( mappingTableTypes.AddValueWithHash(ptrMapping, ptrMapping.Hash()) );\r
1902     }\r
1903 \r
1904     // second pass: fixup structure member & name pointers\r
1905     for (mappingTableTypes.GetFirstEntry(&mapIter); !mappingTableTypes.PastEnd(&mapIter); mappingTableTypes.GetNextEntry(&mapIter))\r
1906     {\r
1907         SPointerMapping ptrMapping = mapIter.GetData();\r
1908 \r
1909         // Uncomment to print type mapping\r
1910         //DPF(0, "type: 0x%x : 0x%x", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew );\r
1911 \r
1912         SType *pType = (SType *) ptrMapping.pNew;\r
1913 \r
1914         // if this is a struct, fix up its members' pointers\r
1915         if (EVT_Struct == pType->VarType)\r
1916         {\r
1917             for (UINT i = 0; i < pType->StructType.Members; ++ i)\r
1918             {\r
1919                 VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTableTypes) );\r
1920             }\r
1921         }\r
1922     }  \r
1923 \r
1924 lExit:\r
1925     return hr;\r
1926 }\r
1927 \r
1928 // Used in cloning, create new ID3D11ConstantBuffers for each non-single CB\r
1929 HRESULT CEffect::RecreateCBs()\r
1930 {\r
1931     HRESULT hr = S_OK;\r
1932     UINT i; // after a failure, this holds the failing index\r
1933 \r
1934     for (i = 0; i < m_CBCount; ++ i)\r
1935     {\r
1936         SConstantBuffer* pCB = &m_pCBs[i];\r
1937 \r
1938         pCB->IsNonUpdatable = pCB->IsUserManaged || pCB->ClonedSingle();\r
1939 \r
1940         if( pCB->Size > 0 && !pCB->ClonedSingle() )\r
1941         {\r
1942             ID3D11Buffer** ppOriginalBuffer;\r
1943             ID3D11ShaderResourceView** ppOriginalTBufferView;\r
1944 \r
1945             if( pCB->IsUserManaged )\r
1946             {\r
1947                 ppOriginalBuffer = &pCB->pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;\r
1948                 ppOriginalTBufferView = &pCB->pMemberData[1].Data.pD3DEffectsManagedTextureBuffer;\r
1949             }\r
1950             else\r
1951             {\r
1952                 ppOriginalBuffer = &pCB->pD3DObject;\r
1953                 ppOriginalTBufferView = &pCB->TBuffer.pShaderResource;\r
1954             }\r
1955 \r
1956             VN( *ppOriginalBuffer );\r
1957             D3D11_BUFFER_DESC bufDesc;\r
1958             (*ppOriginalBuffer)->GetDesc( &bufDesc );\r
1959             ID3D11Buffer* pNewBuffer = NULL;\r
1960             VH( m_pDevice->CreateBuffer( &bufDesc, NULL, &pNewBuffer ) );\r
1961             (*ppOriginalBuffer)->Release();\r
1962             (*ppOriginalBuffer) = pNewBuffer;\r
1963             pNewBuffer = NULL;\r
1964 \r
1965             if( pCB->IsTBuffer )\r
1966             {\r
1967                 VN( *ppOriginalTBufferView );\r
1968                 D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;\r
1969                 (*ppOriginalTBufferView)->GetDesc( &viewDesc );\r
1970                 ID3D11ShaderResourceView* pNewView = NULL;\r
1971                 VH( m_pDevice->CreateShaderResourceView( (*ppOriginalBuffer), &viewDesc, &pNewView) );\r
1972                 (*ppOriginalTBufferView)->Release();\r
1973                 (*ppOriginalTBufferView) = pNewView;\r
1974                 pNewView = NULL;\r
1975             }\r
1976             else\r
1977             {\r
1978                 D3DXASSERT( *ppOriginalTBufferView == NULL );\r
1979                 ReplaceCBReference( pCB, (*ppOriginalBuffer) );\r
1980             }\r
1981 \r
1982             pCB->IsDirty = TRUE;\r
1983         }\r
1984     }\r
1985 \r
1986 lExit:\r
1987     return hr;\r
1988 }\r
1989 \r
1990 // Move Name and Semantic strings using mappingTableStrings\r
1991 HRESULT CEffect::FixupMemberInterface( SMember* pMember, CEffect* pEffectSource, CPointerMappingTable& mappingTableStrings )\r
1992 {\r
1993     HRESULT hr = S_OK;\r
1994 \r
1995     if( pMember->pName )\r
1996     {\r
1997         if( pEffectSource->m_pReflection && pEffectSource->m_pReflection->m_Heap.IsInHeap(pMember->pName) )\r
1998         {\r
1999             pMember->pName = (char*)((UINT_PTR)pMember->pName - (UINT_PTR)pEffectSource->m_pReflection->m_Heap.GetDataStart() + (UINT_PTR)m_pReflection->m_Heap.GetDataStart());\r
2000         }\r
2001         else\r
2002         {\r
2003             VH( RemapString(&pMember->pName, &mappingTableStrings) );\r
2004         }\r
2005     }\r
2006     if( pMember->pSemantic )\r
2007     {\r
2008         if( pEffectSource->m_pReflection && pEffectSource->m_pReflection->m_Heap.IsInHeap(pMember->pSemantic) )\r
2009         {\r
2010             pMember->pSemantic = (char*)((UINT_PTR)pMember->pSemantic - (UINT_PTR)pEffectSource->m_pReflection->m_Heap.GetDataStart() + (UINT_PTR)m_pReflection->m_Heap.GetDataStart());\r
2011         }\r
2012         else\r
2013         {\r
2014             VH( RemapString(&pMember->pSemantic, &mappingTableStrings) );\r
2015         }\r
2016     }\r
2017 \r
2018 lExit:\r
2019     return hr;\r
2020 }\r
2021 \r
2022 //////////////////////////////////////////////////////////////////////////\r
2023 // Public API to create a copy of this effect\r
2024 HRESULT CEffect::CloneEffect(UINT Flags, ID3DX11Effect** ppClonedEffect )\r
2025 {\r
2026     HRESULT hr = S_OK;\r
2027     CPointerMappingTable mappingTableTypes;\r
2028     CPointerMappingTable mappingTableStrings;\r
2029 \r
2030     CEffectLoader loader;\r
2031     CEffect* pNewEffect = NULL;    \r
2032     CDataBlockStore* pTempHeap = NULL;\r
2033 \r
2034 \r
2035     VN( pNewEffect = NEW CEffect( m_Flags ) );\r
2036     if( Flags & D3DX11_EFFECT_CLONE_FORCE_NONSINGLE )\r
2037     {\r
2038         // The effect is cloned as if there was no original, so don't mark it as cloned\r
2039         pNewEffect->m_Flags &= ~(UINT)D3DX11_EFFECT_CLONE;\r
2040     }\r
2041     else\r
2042     {\r
2043         pNewEffect->m_Flags |= D3DX11_EFFECT_CLONE;\r
2044     }\r
2045 \r
2046     pNewEffect->m_VariableCount = m_VariableCount;\r
2047     pNewEffect->m_pVariables = m_pVariables;\r
2048     pNewEffect->m_AnonymousShaderCount = m_AnonymousShaderCount;\r
2049     pNewEffect->m_pAnonymousShaders = m_pAnonymousShaders;\r
2050     pNewEffect->m_TechniqueCount = m_TechniqueCount;\r
2051     pNewEffect->m_GroupCount = m_GroupCount;\r
2052     pNewEffect->m_pGroups = m_pGroups;\r
2053     pNewEffect->m_pNullGroup = m_pNullGroup;\r
2054     pNewEffect->m_ShaderBlockCount = m_ShaderBlockCount;\r
2055     pNewEffect->m_pShaderBlocks = m_pShaderBlocks;\r
2056     pNewEffect->m_DepthStencilBlockCount = m_DepthStencilBlockCount;\r
2057     pNewEffect->m_pDepthStencilBlocks = m_pDepthStencilBlocks;\r
2058     pNewEffect->m_BlendBlockCount = m_BlendBlockCount;\r
2059     pNewEffect->m_pBlendBlocks = m_pBlendBlocks;\r
2060     pNewEffect->m_RasterizerBlockCount = m_RasterizerBlockCount;\r
2061     pNewEffect->m_pRasterizerBlocks = m_pRasterizerBlocks;\r
2062     pNewEffect->m_SamplerBlockCount = m_SamplerBlockCount;\r
2063     pNewEffect->m_pSamplerBlocks = m_pSamplerBlocks;\r
2064     pNewEffect->m_MemberDataCount = m_MemberDataCount;\r
2065     pNewEffect->m_pMemberDataBlocks = m_pMemberDataBlocks;\r
2066     pNewEffect->m_InterfaceCount = m_InterfaceCount;\r
2067     pNewEffect->m_pInterfaces = m_pInterfaces;\r
2068     pNewEffect->m_CBCount = m_CBCount;\r
2069     pNewEffect->m_pCBs = m_pCBs;\r
2070     pNewEffect->m_StringCount = m_StringCount;\r
2071     pNewEffect->m_pStrings = m_pStrings;\r
2072     pNewEffect->m_ShaderResourceCount = m_ShaderResourceCount;\r
2073     pNewEffect->m_pShaderResources = m_pShaderResources;\r
2074     pNewEffect->m_UnorderedAccessViewCount = m_UnorderedAccessViewCount;\r
2075     pNewEffect->m_pUnorderedAccessViews = m_pUnorderedAccessViews;\r
2076     pNewEffect->m_RenderTargetViewCount = m_RenderTargetViewCount;\r
2077     pNewEffect->m_pRenderTargetViews = m_pRenderTargetViews;\r
2078     pNewEffect->m_DepthStencilViewCount = m_DepthStencilViewCount;\r
2079     pNewEffect->m_pDepthStencilViews = m_pDepthStencilViews; \r
2080     pNewEffect->m_LocalTimer = m_LocalTimer;\r
2081     pNewEffect->m_FXLIndex = m_FXLIndex;\r
2082     pNewEffect->m_pDevice = m_pDevice;\r
2083     pNewEffect->m_pClassLinkage = m_pClassLinkage;\r
2084 \r
2085     pNewEffect->AddRefAllForCloning( this );\r
2086 \r
2087 \r
2088     // m_pMemberInterfaces is a vector of cbuffer members that were created when the user called GetMemberBy* or GetElement\r
2089     // or during Effect loading when an interface is initialized to a global class variable elment.\r
2090     VH( pNewEffect->CopyMemberInterfaces( this ) );\r
2091 \r
2092     loader.m_pvOldMemberInterfaces = &m_pMemberInterfaces;\r
2093     loader.m_pEffect = pNewEffect;\r
2094     loader.m_EffectMemory = loader.m_ReflectionMemory = 0;\r
2095 \r
2096 \r
2097     // Move data from current effect to new effect\r
2098     if( !IsOptimized() )\r
2099     {\r
2100         VN( pNewEffect->m_pReflection = NEW CEffectReflection() );\r
2101         loader.m_pReflection = pNewEffect->m_pReflection;\r
2102 \r
2103         // make sure strings are moved before ReallocateEffectData\r
2104         VH( loader.InitializeReflectionDataAndMoveStrings( m_pReflection->m_Heap.GetSize() ) );\r
2105     }\r
2106     VH( loader.ReallocateEffectData( true ) );\r
2107     if( !IsOptimized() )\r
2108     {\r
2109         VH( loader.ReallocateReflectionData( true ) );\r
2110     }\r
2111 \r
2112 \r
2113     // Data structures for remapping type pointers and string pointers\r
2114     VN( pTempHeap = NEW CDataBlockStore );\r
2115     pTempHeap->EnableAlignment();\r
2116     mappingTableTypes.SetPrivateHeap(pTempHeap);\r
2117     mappingTableStrings.SetPrivateHeap(pTempHeap);\r
2118     VH( mappingTableTypes.AutoGrow() );\r
2119     VH( mappingTableStrings.AutoGrow() );\r
2120 \r
2121     if( !IsOptimized() )\r
2122     {\r
2123         // Let's re-create the type pool and string pool\r
2124         VN( pNewEffect->m_pPooledHeap = NEW CDataBlockStore );\r
2125         pNewEffect->m_pPooledHeap->EnableAlignment();\r
2126 \r
2127         VH( pNewEffect->CopyStringPool( this, mappingTableStrings ) );\r
2128         VH( pNewEffect->CopyTypePool( this, mappingTableTypes, mappingTableStrings ) );\r
2129     }\r
2130     else\r
2131     {\r
2132         // There's no string pool after optimizing.  Let's re-create the type pool\r
2133         VH( pNewEffect->CopyOptimizedTypePool( this, mappingTableTypes ) );\r
2134     }\r
2135 \r
2136     // fixup this effect's variable's types\r
2137     VH( pNewEffect->OptimizeTypes(&mappingTableTypes, true) );\r
2138     VH( pNewEffect->RecreateCBs() );\r
2139 \r
2140 \r
2141     for (UINT i = 0; i < pNewEffect->m_pMemberInterfaces.GetSize(); ++ i)\r
2142     {\r
2143         SMember* pMember = pNewEffect->m_pMemberInterfaces[i];\r
2144         VH( pNewEffect->FixupMemberInterface( pMember, this, mappingTableStrings ) );\r
2145     }\r
2146 \r
2147 \r
2148 lExit:\r
2149     SAFE_DELETE( pTempHeap );\r
2150     if( FAILED( hr ) )\r
2151     {\r
2152         SAFE_DELETE( pNewEffect );\r
2153     }\r
2154     *ppClonedEffect = pNewEffect;\r
2155     return hr;\r
2156 }\r
2157 \r
2158 // Move all type pointers using pMappingTable.\r
2159 // This is called after creating the optimized type pool or during cloning.\r
2160 HRESULT CEffect::OptimizeTypes(CPointerMappingTable *pMappingTable, bool Cloning)\r
2161 {\r
2162     HRESULT hr = S_OK;\r
2163     UINT  i;\r
2164 \r
2165     // find all child types, point them to the new location\r
2166     for (i = 0; i < m_VariableCount; ++ i)\r
2167     {\r
2168         VH( RemapType((SType**)&m_pVariables[i].pType, pMappingTable) );\r
2169     }\r
2170 \r
2171     UINT Members = m_pMemberInterfaces.GetSize();\r
2172     for( i=0; i < Members; i++ )\r
2173     {\r
2174         if( m_pMemberInterfaces[i] != NULL )\r
2175         {\r
2176             VH( RemapType((SType**)&m_pMemberInterfaces[i]->pType, pMappingTable) );\r
2177         }\r
2178     }\r
2179 \r
2180     // when cloning, there may be annotations\r
2181     if( Cloning )\r
2182     {\r
2183         for (UINT iVar = 0; iVar < m_VariableCount; ++ iVar)\r
2184         {\r
2185             for(i = 0; i < m_pVariables[iVar].AnnotationCount; ++ i )\r
2186             {\r
2187                 VH( RemapType((SType**)&m_pVariables[iVar].pAnnotations[i].pType, pMappingTable) );\r
2188             }\r
2189         }\r
2190         for (UINT iCB = 0; iCB < m_CBCount; ++ iCB)\r
2191         {\r
2192             for(i = 0; i < m_pCBs[iCB].AnnotationCount; ++ i )\r
2193             {\r
2194                 VH( RemapType((SType**)&m_pCBs[iCB].pAnnotations[i].pType, pMappingTable) );\r
2195             }\r
2196         }\r
2197         for (UINT iGroup = 0; iGroup < m_GroupCount; ++ iGroup)\r
2198         {\r
2199             for(i = 0; i < m_pGroups[iGroup].AnnotationCount; ++ i )\r
2200             {\r
2201                 VH( RemapType((SType**)&m_pGroups[iGroup].pAnnotations[i].pType, pMappingTable) );\r
2202             }\r
2203             for(UINT iTech = 0; iTech < m_pGroups[iGroup].TechniqueCount; ++ iTech )\r
2204             {\r
2205                 for(i = 0; i < m_pGroups[iGroup].pTechniques[iTech].AnnotationCount; ++ i )\r
2206                 {\r
2207                     VH( RemapType((SType**)&m_pGroups[iGroup].pTechniques[iTech].pAnnotations[i].pType, pMappingTable) );\r
2208                 }\r
2209                 for(UINT iPass = 0; iPass < m_pGroups[iGroup].pTechniques[iTech].PassCount; ++ iPass )\r
2210                 {\r
2211                     for(i = 0; i < m_pGroups[iGroup].pTechniques[iTech].pPasses[iPass].AnnotationCount; ++ i )\r
2212                     {\r
2213                         VH( RemapType((SType**)&m_pGroups[iGroup].pTechniques[iTech].pPasses[iPass].pAnnotations[i].pType, pMappingTable) );\r
2214                     }\r
2215                 }\r
2216             }\r
2217         }\r
2218     }\r
2219 lExit:\r
2220     return hr;\r
2221 }\r
2222 \r
2223 //////////////////////////////////////////////////////////////////////////\r
2224 // Public API to shed this effect of its reflection data\r
2225 HRESULT CEffect::Optimize()\r
2226 {\r
2227     HRESULT hr = S_OK;\r
2228     UINT  i, j, k;\r
2229     CEffectHeap *pOptimizedTypeHeap = NULL;\r
2230     \r
2231     if (IsOptimized())\r
2232     {\r
2233         DPF(0, "ID3DX11Effect::Optimize: Effect has already been Optimize()'ed");\r
2234         return S_OK;\r
2235     }\r
2236 \r
2237     // Delete annotations, names, semantics, and string data on variables\r
2238     \r
2239     for (i = 0; i < m_VariableCount; ++ i)\r
2240     {\r
2241         m_pVariables[i].AnnotationCount = 0;\r
2242         m_pVariables[i].pAnnotations = NULL;\r
2243         m_pVariables[i].pName = NULL;\r
2244         m_pVariables[i].pSemantic = NULL;\r
2245 \r
2246         // 2) Point string variables to NULL\r
2247         if (m_pVariables[i].pType->IsObjectType(EOT_String))\r
2248         {\r
2249             D3DXASSERT(NULL != m_pVariables[i].Data.pString);\r
2250             m_pVariables[i].Data.pString = NULL;\r
2251         }\r
2252     }\r
2253 \r
2254     // Delete annotations and names on CBs\r
2255 \r
2256     for (i = 0; i < m_CBCount; ++ i)\r
2257     {\r
2258         m_pCBs[i].AnnotationCount = 0;\r
2259         m_pCBs[i].pAnnotations = NULL;\r
2260         m_pCBs[i].pName = NULL;\r
2261         m_pCBs[i].IsEffectOptimized = TRUE;\r
2262     }\r
2263 \r
2264     // Delete annotations and names on techniques and passes\r
2265 \r
2266     for (i = 0; i < m_GroupCount; ++ i)\r
2267     {\r
2268         m_pGroups[i].AnnotationCount = 0;\r
2269         m_pGroups[i].pAnnotations = NULL;\r
2270         m_pGroups[i].pName = NULL;\r
2271 \r
2272         for (j = 0; j < m_pGroups[i].TechniqueCount; ++ j)\r
2273         {\r
2274             m_pGroups[i].pTechniques[j].AnnotationCount = 0;\r
2275             m_pGroups[i].pTechniques[j].pAnnotations = NULL;\r
2276             m_pGroups[i].pTechniques[j].pName = NULL;\r
2277 \r
2278             for (k = 0; k < m_pGroups[i].pTechniques[j].PassCount; ++ k)\r
2279             {\r
2280                 m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount = 0;\r
2281                 m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations = NULL;\r
2282                 m_pGroups[i].pTechniques[j].pPasses[k].pName = NULL;\r
2283             }\r
2284         }\r
2285     };\r
2286 \r
2287     // 2) Remove shader bytecode & stream out decls\r
2288     //    (all are contained within pReflectionData)\r
2289 \r
2290     for (i = 0; i < m_ShaderBlockCount; ++ i)\r
2291     {\r
2292         if( m_pShaderBlocks[i].pReflectionData )\r
2293         {\r
2294             // pReflection was not created with PRIVATENEW\r
2295             SAFE_RELEASE( m_pShaderBlocks[i].pReflectionData->pReflection );\r
2296 \r
2297             m_pShaderBlocks[i].pReflectionData = NULL;\r
2298         }\r
2299     }\r
2300 \r
2301     UINT Members = m_pMemberInterfaces.GetSize();\r
2302     for( i=0; i < Members; i++ )\r
2303     {\r
2304         D3DXASSERT( m_pMemberInterfaces[i] != NULL );\r
2305         if( IsReflectionData(m_pMemberInterfaces[i]->pTopLevelEntity) )\r
2306         {\r
2307             D3DXASSERT( IsReflectionData(m_pMemberInterfaces[i]->Data.pGeneric) );\r
2308 \r
2309             // This is checked when cloning (so we don't clone Optimized-out member variables)\r
2310             m_pMemberInterfaces[i] = NULL;\r
2311         }\r
2312         else\r
2313         {\r
2314             m_pMemberInterfaces[i]->pName = NULL;\r
2315             m_pMemberInterfaces[i]->pSemantic = NULL;\r
2316         }\r
2317     }\r
2318 \r
2319 \r
2320 \r
2321     // get rid of the name/type hash tables and string data, \r
2322     // then reallocate the type data and fix up this effect\r
2323     CPointerMappingTable mappingTable;\r
2324     CTypeHashTable::CIterator typeIter;\r
2325     CPointerMappingTable::CIterator mapIter;\r
2326     CCheckedDword chkSpaceNeeded = 0;\r
2327     UINT  spaceNeeded;\r
2328 \r
2329     // first pass: compute needed space\r
2330     for (m_pTypePool->GetFirstEntry(&typeIter); !m_pTypePool->PastEnd(&typeIter); m_pTypePool->GetNextEntry(&typeIter))\r
2331     {\r
2332         SType *pType = typeIter.GetData();\r
2333         \r
2334         chkSpaceNeeded += AlignToPowerOf2(sizeof(SType), c_DataAlignment);\r
2335 \r
2336         // if this is a struct, allocate room for its members\r
2337         if (EVT_Struct == pType->VarType)\r
2338         {\r
2339             chkSpaceNeeded += AlignToPowerOf2(pType->StructType.Members * sizeof(SVariable), c_DataAlignment);\r
2340         }\r
2341     }\r
2342 \r
2343     VH( chkSpaceNeeded.GetValue(&spaceNeeded) );\r
2344 \r
2345     D3DXASSERT(NULL == m_pOptimizedTypeHeap);\r
2346     VN( pOptimizedTypeHeap = NEW CEffectHeap );\r
2347     VH( pOptimizedTypeHeap->ReserveMemory(spaceNeeded));\r
2348 \r
2349     // use the private heap that we're about to destroy as scratch space for the mapping table\r
2350     mappingTable.SetPrivateHeap(m_pPooledHeap);\r
2351     VH( mappingTable.AutoGrow() );\r
2352 \r
2353     // second pass: move types over, build mapping table\r
2354     for (m_pTypePool->GetFirstEntry(&typeIter); !m_pTypePool->PastEnd(&typeIter); m_pTypePool->GetNextEntry(&typeIter))\r
2355     {\r
2356         SPointerMapping ptrMapping;\r
2357         SType *pType;\r
2358 \r
2359         ptrMapping.pOld = ptrMapping.pNew = typeIter.GetData();\r
2360         VH( pOptimizedTypeHeap->MoveData(&ptrMapping.pNew, sizeof(SType)) );\r
2361 \r
2362         pType = (SType *) ptrMapping.pNew;\r
2363 \r
2364         // if this is a struct, move its members to the newly allocated space\r
2365         if (EVT_Struct == pType->VarType)\r
2366         {\r
2367             VH( pOptimizedTypeHeap->MoveData((void **)&pType->StructType.pMembers, pType->StructType.Members * sizeof(SVariable)) );\r
2368         }\r
2369 \r
2370         VH( mappingTable.AddValueWithHash(ptrMapping, ptrMapping.Hash()) );\r
2371     }\r
2372     \r
2373     // third pass: fixup structure member & name pointers\r
2374     for (mappingTable.GetFirstEntry(&mapIter); !mappingTable.PastEnd(&mapIter); mappingTable.GetNextEntry(&mapIter))\r
2375     {\r
2376         SPointerMapping ptrMapping = mapIter.GetData();\r
2377         SType *pType = (SType *) ptrMapping.pNew;\r
2378 \r
2379         pType->pTypeName = NULL;\r
2380 \r
2381         // if this is a struct, fix up its members' pointers\r
2382         if (EVT_Struct == pType->VarType)\r
2383         {\r
2384             for (i = 0; i < pType->StructType.Members; ++ i)\r
2385             {\r
2386                 VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTable) );\r
2387                 pType->StructType.pMembers[i].pName = NULL;\r
2388                 pType->StructType.pMembers[i].pSemantic = NULL;\r
2389             }\r
2390         }\r
2391     }        \r
2392 \r
2393     // fixup this effect's variable's types\r
2394     VH( OptimizeTypes(&mappingTable) );\r
2395 \r
2396     m_pOptimizedTypeHeap = pOptimizedTypeHeap;\r
2397     pOptimizedTypeHeap = NULL;\r
2398 \r
2399 #ifdef D3DX11_FX_PRINT_HASH_STATS\r
2400     DPF(0, "Compiler string pool hash table statistics:");\r
2401     m_pTypePool->PrintHashTableStats();\r
2402     DPF(0, "Compiler type pool hash table statistics:");\r
2403     m_pStringPool->PrintHashTableStats();\r
2404 #endif // D3DX11_FX_PRINT_HASH_STATS\r
2405 \r
2406     SAFE_DELETE(m_pTypePool);\r
2407     SAFE_DELETE(m_pStringPool);\r
2408     SAFE_DELETE(m_pPooledHeap);\r
2409 \r
2410     DPF(0, "ID3DX11Effect::Optimize: %d bytes of reflection data freed.", m_pReflection->m_Heap.GetSize());\r
2411     SAFE_DELETE(m_pReflection);\r
2412     m_Flags |= D3DX11_EFFECT_OPTIMIZED;\r
2413 \r
2414 lExit:\r
2415     SAFE_DELETE(pOptimizedTypeHeap);\r
2416     return hr;\r
2417 }\r
2418 \r
2419 SMember * CreateNewMember(SType *pType, BOOL IsAnnotation)\r
2420 {\r
2421     switch (pType->VarType)\r
2422     {\r
2423     case EVT_Struct:\r
2424         if (IsAnnotation)\r
2425         {\r
2426             D3DXASSERT(sizeof(SNumericAnnotationMember) == sizeof(SMember));\r
2427             return (SMember*) NEW SNumericAnnotationMember;\r
2428         }\r
2429         else if (pType->StructType.ImplementsInterface)\r
2430         {\r
2431             D3DXASSERT(sizeof(SClassInstanceGlobalVariableMember) == sizeof(SMember));\r
2432             return (SMember*) NEW SClassInstanceGlobalVariableMember;\r
2433         }\r
2434         else\r
2435         {\r
2436             D3DXASSERT(sizeof(SNumericGlobalVariableMember) == sizeof(SMember));\r
2437             return (SMember*) NEW SNumericGlobalVariableMember;\r
2438         }\r
2439         break;\r
2440     case EVT_Interface:\r
2441         D3DXASSERT(sizeof(SInterfaceGlobalVariableMember) == sizeof(SMember));\r
2442         return (SMember*) NEW SInterfaceGlobalVariableMember;\r
2443         break;\r
2444     case EVT_Object:\r
2445         switch (pType->ObjectType)\r
2446         {\r
2447         case EOT_String:\r
2448             if (IsAnnotation)\r
2449             {\r
2450                 D3DXASSERT(sizeof(SStringAnnotationMember) == sizeof(SMember));\r
2451                 return (SMember*) NEW SStringAnnotationMember;\r
2452             }\r
2453             else\r
2454             {\r
2455                 D3DXASSERT(sizeof(SStringGlobalVariableMember) == sizeof(SMember));\r
2456                 return (SMember*) NEW SStringGlobalVariableMember;\r
2457             }\r
2458 \r
2459             break;\r
2460         case EOT_Texture:\r
2461         case EOT_Texture1D:\r
2462         case EOT_Texture1DArray:\r
2463         case EOT_Texture2D:\r
2464         case EOT_Texture2DArray:\r
2465         case EOT_Texture2DMS:\r
2466         case EOT_Texture2DMSArray:\r
2467         case EOT_Texture3D:\r
2468         case EOT_TextureCube:\r
2469         case EOT_TextureCubeArray:\r
2470         case EOT_Buffer:\r
2471         case EOT_ByteAddressBuffer:\r
2472         case EOT_StructuredBuffer:\r
2473             D3DXASSERT(!IsAnnotation);\r
2474             D3DXASSERT(sizeof(SShaderResourceGlobalVariableMember) == sizeof(SMember));\r
2475             return (SMember*) NEW SShaderResourceGlobalVariableMember;\r
2476             break;\r
2477         case EOT_RWTexture1D:\r
2478         case EOT_RWTexture1DArray:\r
2479         case EOT_RWTexture2D:\r
2480         case EOT_RWTexture2DArray:\r
2481         case EOT_RWTexture3D:\r
2482         case EOT_RWBuffer:\r
2483         case EOT_RWByteAddressBuffer:\r
2484         case EOT_RWStructuredBuffer:\r
2485         case EOT_RWStructuredBufferAlloc:\r
2486         case EOT_RWStructuredBufferConsume:\r
2487         case EOT_AppendStructuredBuffer:\r
2488         case EOT_ConsumeStructuredBuffer:\r
2489             D3DXASSERT(!IsAnnotation);\r
2490             D3DXASSERT(sizeof(SUnorderedAccessViewGlobalVariableMember) == sizeof(SMember));\r
2491             return (SMember*) NEW SUnorderedAccessViewGlobalVariableMember;\r
2492             break;\r
2493         case EOT_VertexShader:\r
2494         case EOT_VertexShader5:\r
2495         case EOT_GeometryShader:\r
2496         case EOT_GeometryShaderSO:\r
2497         case EOT_GeometryShader5:\r
2498         case EOT_PixelShader:\r
2499         case EOT_PixelShader5:\r
2500         case EOT_HullShader5:\r
2501         case EOT_DomainShader5:\r
2502         case EOT_ComputeShader5:\r
2503             D3DXASSERT(!IsAnnotation);\r
2504             D3DXASSERT(sizeof(SShaderGlobalVariableMember) == sizeof(SMember));\r
2505             return (SMember*) NEW SShaderGlobalVariableMember;\r
2506             break;\r
2507         case EOT_Blend:\r
2508             D3DXASSERT(!IsAnnotation);\r
2509             D3DXASSERT(sizeof(SBlendGlobalVariableMember) == sizeof(SMember));\r
2510             return (SMember*) NEW SBlendGlobalVariableMember;\r
2511             break;\r
2512         case EOT_Rasterizer:\r
2513             D3DXASSERT(!IsAnnotation);\r
2514             D3DXASSERT(sizeof(SRasterizerGlobalVariableMember) == sizeof(SMember));\r
2515             return (SMember*) NEW SRasterizerGlobalVariableMember;\r
2516             break;\r
2517         case EOT_DepthStencil:\r
2518             D3DXASSERT(!IsAnnotation);\r
2519             D3DXASSERT(sizeof(SDepthStencilGlobalVariableMember) == sizeof(SMember));\r
2520             return (SMember*) NEW SDepthStencilGlobalVariableMember;\r
2521             break;\r
2522         case EOT_Sampler:\r
2523             D3DXASSERT(!IsAnnotation);\r
2524             D3DXASSERT(sizeof(SSamplerGlobalVariableMember) == sizeof(SMember));\r
2525             return (SMember*) NEW SSamplerGlobalVariableMember;\r
2526             break;\r
2527         case EOT_DepthStencilView:\r
2528             D3DXASSERT(!IsAnnotation);\r
2529             D3DXASSERT(sizeof(SDepthStencilViewGlobalVariableMember) == sizeof(SMember));\r
2530             return (SMember*) NEW SDepthStencilViewGlobalVariableMember;\r
2531             break;\r
2532         case EOT_RenderTargetView:\r
2533             D3DXASSERT(!IsAnnotation);\r
2534             D3DXASSERT(sizeof(SRenderTargetViewGlobalVariableMember) == sizeof(SMember));\r
2535             return (SMember*) NEW SRenderTargetViewGlobalVariableMember;\r
2536             break;\r
2537         default:\r
2538             D3DXASSERT(0);\r
2539             DPF( 0, "Internal error: invalid object type." );\r
2540             return NULL;\r
2541             break;\r
2542         }\r
2543         break;\r
2544     case EVT_Numeric:\r
2545         switch (pType->NumericType.NumericLayout)\r
2546         {\r
2547         case ENL_Matrix:\r
2548             if (IsAnnotation)\r
2549             {\r
2550                 D3DXASSERT(sizeof(SMatrixAnnotationMember) == sizeof(SMember));\r
2551                 return (SMember*) NEW SMatrixAnnotationMember;\r
2552             }\r
2553             else\r
2554             {\r
2555                 D3DXASSERT(sizeof(SMatrixGlobalVariableMember) == sizeof(SMember));\r
2556                 D3DXASSERT(sizeof(SMatrix4x4ColumnMajorGlobalVariableMember) == sizeof(SMember));\r
2557                 D3DXASSERT(sizeof(SMatrix4x4RowMajorGlobalVariableMember) == sizeof(SMember));\r
2558 \r
2559                 if (pType->NumericType.Rows == 4 && pType->NumericType.Columns == 4)\r
2560                 {\r
2561                     if (pType->NumericType.IsColumnMajor)\r
2562                     {\r
2563                         return (SMember*) NEW SMatrix4x4ColumnMajorGlobalVariableMember;\r
2564                     }\r
2565                     else\r
2566                     {\r
2567                         return (SMember*) NEW SMatrix4x4RowMajorGlobalVariableMember;\r
2568                     }\r
2569                 }\r
2570                 else\r
2571                 {\r
2572                     return (SMember*) NEW SMatrixGlobalVariableMember;\r
2573                 }\r
2574             }\r
2575             break;\r
2576         case ENL_Vector:\r
2577             switch (pType->NumericType.ScalarType)\r
2578             {\r
2579             case EST_Float:\r
2580                 if (IsAnnotation)\r
2581                 {\r
2582                     D3DXASSERT(sizeof(SFloatVectorAnnotationMember) == sizeof(SMember));\r
2583                     return (SMember*) NEW SFloatVectorAnnotationMember;\r
2584                 }\r
2585                 else\r
2586                 {\r
2587                     D3DXASSERT(sizeof(SFloatVectorGlobalVariableMember) == sizeof(SMember));\r
2588                     D3DXASSERT(sizeof(SFloatVector4GlobalVariableMember) == sizeof(SMember));\r
2589 \r
2590                     if (pType->NumericType.Columns == 4)\r
2591                     {\r
2592                         return (SMember*) NEW SFloatVector4GlobalVariableMember;\r
2593                     }\r
2594                     else\r
2595                     {\r
2596                         return (SMember*) NEW SFloatVectorGlobalVariableMember;\r
2597                     }\r
2598                 }\r
2599                 break;\r
2600             case EST_Bool:\r
2601                 if (IsAnnotation)\r
2602                 {\r
2603                     D3DXASSERT(sizeof(SBoolVectorAnnotationMember) == sizeof(SMember));\r
2604                     return (SMember*) NEW SBoolVectorAnnotationMember;\r
2605                 }\r
2606                 else\r
2607                 {\r
2608                     D3DXASSERT(sizeof(SBoolVectorGlobalVariableMember) == sizeof(SMember));\r
2609                     return (SMember*) NEW SBoolVectorGlobalVariableMember;\r
2610                 }\r
2611                 break;\r
2612             case EST_UInt:\r
2613             case EST_Int:\r
2614                 if (IsAnnotation)\r
2615                 {\r
2616                     D3DXASSERT(sizeof(SIntVectorAnnotationMember) == sizeof(SMember));\r
2617                     return (SMember*) NEW SIntVectorAnnotationMember;\r
2618                 }\r
2619                 else\r
2620                 {\r
2621                     D3DXASSERT(sizeof(SIntVectorGlobalVariableMember) == sizeof(SMember));\r
2622                     return (SMember*) NEW SIntVectorGlobalVariableMember;\r
2623                 }\r
2624                 break;\r
2625             default:\r
2626                 D3DXASSERT(0);\r
2627                 DPF( 0, "Internal loading error: invalid vector type." );\r
2628                 break;\r
2629             }\r
2630             break;\r
2631         case ENL_Scalar:\r
2632             switch (pType->NumericType.ScalarType)\r
2633             {\r
2634             case EST_Float:\r
2635                 if (IsAnnotation)\r
2636                 {\r
2637                     D3DXASSERT(sizeof(SFloatScalarAnnotationMember) == sizeof(SMember));\r
2638                     return (SMember*) NEW SFloatScalarAnnotationMember;\r
2639                 }\r
2640                 else\r
2641                 {\r
2642                     D3DXASSERT(sizeof(SFloatScalarGlobalVariableMember) == sizeof(SMember));\r
2643                     return (SMember*) NEW SFloatScalarGlobalVariableMember;\r
2644                 }\r
2645                 break;\r
2646             case EST_UInt:\r
2647             case EST_Int:\r
2648                 if (IsAnnotation)\r
2649                 {\r
2650                     D3DXASSERT(sizeof(SIntScalarAnnotationMember) == sizeof(SMember));\r
2651                     return (SMember*) NEW SIntScalarAnnotationMember;\r
2652                 }\r
2653                 else\r
2654                 {\r
2655                     D3DXASSERT(sizeof(SIntScalarGlobalVariableMember) == sizeof(SMember));\r
2656                     return (SMember*) NEW SIntScalarGlobalVariableMember;\r
2657                 }\r
2658                 break;\r
2659             case EST_Bool:\r
2660                 if (IsAnnotation)\r
2661                 {\r
2662                     D3DXASSERT(sizeof(SBoolScalarAnnotationMember) == sizeof(SMember));\r
2663                     return (SMember*) NEW SBoolScalarAnnotationMember;\r
2664                 }\r
2665                 else\r
2666                 {\r
2667                     D3DXASSERT(sizeof(SBoolScalarGlobalVariableMember) == sizeof(SMember));\r
2668                     return (SMember*) NEW SBoolScalarGlobalVariableMember;\r
2669                 }\r
2670                 break;\r
2671             default:\r
2672                 DPF( 0, "Internal loading error: invalid scalar type." );\r
2673                 D3DXASSERT(0);\r
2674                 break;\r
2675             }            \r
2676             break;\r
2677         default:\r
2678             D3DXASSERT(0);\r
2679             DPF( 0, "Internal loading error: invalid numeric type." );\r
2680             break;\r
2681         }\r
2682         break;\r
2683     default:\r
2684         D3DXASSERT(0);\r
2685         DPF( 0, "Internal loading error: invalid variable type." );\r
2686         break;\r
2687     }\r
2688     return NULL;\r
2689 }\r
2690 \r
2691 // Global variables are created in place because storage for them was allocated during LoadEffect\r
2692 HRESULT PlacementNewVariable(void *pVar, SType *pType, BOOL IsAnnotation)\r
2693 {\r
2694     switch (pType->VarType)\r
2695     {\r
2696     case EVT_Struct:\r
2697         if (IsAnnotation)\r
2698         {\r
2699             D3DXASSERT(sizeof(SNumericAnnotation) == sizeof(SAnnotation));\r
2700             new(pVar) SNumericAnnotation();\r
2701         }\r
2702         else if (pType->StructType.ImplementsInterface)\r
2703         {\r
2704             D3DXASSERT(sizeof(SClassInstanceGlobalVariable) == sizeof(SGlobalVariable));\r
2705             new(pVar) SClassInstanceGlobalVariable;\r
2706         }\r
2707         else \r
2708         {\r
2709             D3DXASSERT(sizeof(SNumericGlobalVariable) == sizeof(SGlobalVariable));\r
2710             new(pVar) SNumericGlobalVariable;\r
2711         }\r
2712         break;\r
2713     case EVT_Interface:\r
2714         D3DXASSERT(sizeof(SInterfaceGlobalVariable) == sizeof(SGlobalVariable));\r
2715         new(pVar) SInterfaceGlobalVariable;\r
2716         break;\r
2717     case EVT_Object:\r
2718         switch (pType->ObjectType)\r
2719         {\r
2720         case EOT_String:\r
2721             if (IsAnnotation)\r
2722             {\r
2723                 D3DXASSERT(sizeof(SStringAnnotation) == sizeof(SAnnotation));\r
2724                 new(pVar) SStringAnnotation;\r
2725             }\r
2726             else\r
2727             {\r
2728                 D3DXASSERT(sizeof(SStringGlobalVariable) == sizeof(SGlobalVariable));\r
2729                 new(pVar) SStringGlobalVariable;\r
2730             }\r
2731             \r
2732             break;\r
2733         case EOT_Texture:\r
2734         case EOT_Texture1D:\r
2735         case EOT_Texture1DArray:\r
2736         case EOT_Texture2D:\r
2737         case EOT_Texture2DArray:\r
2738         case EOT_Texture2DMS:\r
2739         case EOT_Texture2DMSArray:\r
2740         case EOT_Texture3D:\r
2741         case EOT_TextureCube:\r
2742         case EOT_TextureCubeArray:\r
2743         case EOT_Buffer:\r
2744         case EOT_ByteAddressBuffer:\r
2745         case EOT_StructuredBuffer:\r
2746             D3DXASSERT(!IsAnnotation);\r
2747             D3DXASSERT(sizeof(SShaderResourceGlobalVariable) == sizeof(SGlobalVariable));\r
2748             new(pVar) SShaderResourceGlobalVariable;\r
2749             break;\r
2750         case EOT_RWTexture1D:\r
2751         case EOT_RWTexture1DArray:\r
2752         case EOT_RWTexture2D:\r
2753         case EOT_RWTexture2DArray:\r
2754         case EOT_RWTexture3D:\r
2755         case EOT_RWBuffer:\r
2756         case EOT_RWByteAddressBuffer:\r
2757         case EOT_RWStructuredBuffer:\r
2758         case EOT_RWStructuredBufferAlloc:\r
2759         case EOT_RWStructuredBufferConsume:\r
2760         case EOT_AppendStructuredBuffer:\r
2761         case EOT_ConsumeStructuredBuffer:\r
2762             D3DXASSERT(!IsAnnotation);\r
2763             D3DXASSERT(sizeof(SUnorderedAccessViewGlobalVariable) == sizeof(SGlobalVariable));\r
2764             new(pVar) SUnorderedAccessViewGlobalVariable;\r
2765             break;\r
2766         case EOT_VertexShader:\r
2767         case EOT_VertexShader5:\r
2768         case EOT_GeometryShader:\r
2769         case EOT_GeometryShaderSO:\r
2770         case EOT_GeometryShader5:\r
2771         case EOT_PixelShader:\r
2772         case EOT_PixelShader5:\r
2773         case EOT_HullShader5:\r
2774         case EOT_DomainShader5:\r
2775         case EOT_ComputeShader5:\r
2776             D3DXASSERT(!IsAnnotation);\r
2777             D3DXASSERT(sizeof(SShaderGlobalVariable) == sizeof(SGlobalVariable));\r
2778             new(pVar) SShaderGlobalVariable;\r
2779             break;\r
2780         case EOT_Blend:\r
2781             D3DXASSERT(!IsAnnotation);\r
2782             D3DXASSERT(sizeof(SBlendGlobalVariable) == sizeof(SGlobalVariable));\r
2783             new(pVar) SBlendGlobalVariable;\r
2784             break;\r
2785         case EOT_Rasterizer:\r
2786             D3DXASSERT(!IsAnnotation);\r
2787             D3DXASSERT(sizeof(SRasterizerGlobalVariable) == sizeof(SGlobalVariable));\r
2788             new(pVar) SRasterizerGlobalVariable;\r
2789             break;\r
2790         case EOT_DepthStencil:\r
2791             D3DXASSERT(!IsAnnotation);\r
2792             D3DXASSERT(sizeof(SDepthStencilGlobalVariable) == sizeof(SGlobalVariable));\r
2793             new(pVar) SDepthStencilGlobalVariable;\r
2794             break;\r
2795         case EOT_Sampler:\r
2796             D3DXASSERT(!IsAnnotation);\r
2797             D3DXASSERT(sizeof(SSamplerGlobalVariable) == sizeof(SGlobalVariable));\r
2798             new(pVar) SSamplerGlobalVariable;\r
2799             break;\r
2800         case EOT_RenderTargetView:\r
2801             D3DXASSERT(!IsAnnotation);\r
2802             D3DXASSERT(sizeof(SRenderTargetViewGlobalVariable) == sizeof(SGlobalVariable));\r
2803             new(pVar) SRenderTargetViewGlobalVariable;\r
2804             break;\r
2805         case EOT_DepthStencilView:\r
2806             D3DXASSERT(!IsAnnotation);\r
2807             D3DXASSERT(sizeof(SDepthStencilViewGlobalVariable) == sizeof(SGlobalVariable));\r
2808             new(pVar) SDepthStencilViewGlobalVariable;\r
2809             break;\r
2810         default:\r
2811             D3DXASSERT(0);\r
2812             DPF( 0, "Internal loading error: invalid object type." );\r
2813             return E_FAIL;\r
2814             break;\r
2815         }\r
2816         break;\r
2817     case EVT_Numeric:\r
2818         switch (pType->NumericType.NumericLayout)\r
2819         {\r
2820         case ENL_Matrix:\r
2821             if (IsAnnotation)\r
2822             {\r
2823                 D3DXASSERT(sizeof(SMatrixAnnotation) == sizeof(SAnnotation));\r
2824                 new(pVar) SMatrixAnnotation;\r
2825             }\r
2826             else\r
2827             {\r
2828                 D3DXASSERT(sizeof(SMatrixGlobalVariable) == sizeof(SGlobalVariable));\r
2829                 D3DXASSERT(sizeof(SMatrix4x4ColumnMajorGlobalVariable) == sizeof(SGlobalVariable));\r
2830                 D3DXASSERT(sizeof(SMatrix4x4RowMajorGlobalVariable) == sizeof(SGlobalVariable));\r
2831                 \r
2832                 if (pType->NumericType.Rows == 4 && pType->NumericType.Columns == 4)\r
2833                 {\r
2834                     if (pType->NumericType.IsColumnMajor)\r
2835                     {\r
2836                         new(pVar) SMatrix4x4ColumnMajorGlobalVariable;\r
2837                     }\r
2838                     else\r
2839                     {\r
2840                         new(pVar) SMatrix4x4RowMajorGlobalVariable;\r
2841                     }\r
2842                 }\r
2843                 else\r
2844                 {\r
2845                     new(pVar) SMatrixGlobalVariable;\r
2846                 }\r
2847             }\r
2848             break;\r
2849         case ENL_Vector:\r
2850             switch (pType->NumericType.ScalarType)\r
2851             {\r
2852             case EST_Float:\r
2853                 if (IsAnnotation)\r
2854                 {\r
2855                     D3DXASSERT(sizeof(SFloatVectorAnnotation) == sizeof(SAnnotation));\r
2856                     new(pVar) SFloatVectorAnnotation;\r
2857                 }\r
2858                 else\r
2859                 {\r
2860                     D3DXASSERT(sizeof(SFloatVectorGlobalVariable) == sizeof(SGlobalVariable));\r
2861                     D3DXASSERT(sizeof(SFloatVector4GlobalVariable) == sizeof(SGlobalVariable));\r
2862 \r
2863                     if (pType->NumericType.Columns == 4)\r
2864                     {\r
2865                         new(pVar) SFloatVector4GlobalVariable;\r
2866                     }\r
2867                     else\r
2868                     {\r
2869                         new(pVar) SFloatVectorGlobalVariable;\r
2870                     }\r
2871                 }\r
2872                 break;\r
2873             case EST_Bool:\r
2874                 if (IsAnnotation)\r
2875                 {\r
2876                     D3DXASSERT(sizeof(SBoolVectorAnnotation) == sizeof(SAnnotation));\r
2877                     new(pVar) SBoolVectorAnnotation;\r
2878                 }\r
2879                 else\r
2880                 {\r
2881                     D3DXASSERT(sizeof(SBoolVectorGlobalVariable) == sizeof(SGlobalVariable));\r
2882                     new(pVar) SBoolVectorGlobalVariable;\r
2883                 }\r
2884                 break;\r
2885             case EST_UInt:\r
2886             case EST_Int:\r
2887                 if (IsAnnotation)\r
2888                 {\r
2889                     D3DXASSERT(sizeof(SIntVectorAnnotation) == sizeof(SAnnotation));\r
2890                     new(pVar) SIntVectorAnnotation;\r
2891                 }\r
2892                 else\r
2893                 {\r
2894                     D3DXASSERT(sizeof(SIntVectorGlobalVariable) == sizeof(SGlobalVariable));\r
2895                     new(pVar) SIntVectorGlobalVariable;\r
2896                 }\r
2897                 break;\r
2898             }\r
2899             break;\r
2900         case ENL_Scalar:\r
2901             switch (pType->NumericType.ScalarType)\r
2902             {\r
2903             case EST_Float:\r
2904                 if (IsAnnotation)\r
2905                 {\r
2906                     D3DXASSERT(sizeof(SFloatScalarAnnotation) == sizeof(SAnnotation));\r
2907                     new(pVar) SFloatScalarAnnotation;\r
2908                 }\r
2909                 else\r
2910                 {\r
2911                     D3DXASSERT(sizeof(SFloatScalarGlobalVariable) == sizeof(SGlobalVariable));\r
2912                     new(pVar) SFloatScalarGlobalVariable;\r
2913                 }\r
2914                 break;\r
2915             case EST_UInt:\r
2916             case EST_Int:\r
2917                 if (IsAnnotation)\r
2918                 {\r
2919                     D3DXASSERT(sizeof(SIntScalarAnnotation) == sizeof(SAnnotation));\r
2920                     new(pVar) SIntScalarAnnotation;\r
2921                 }\r
2922                 else\r
2923                 {\r
2924                     D3DXASSERT(sizeof(SIntScalarGlobalVariable) == sizeof(SGlobalVariable));\r
2925                     new(pVar) SIntScalarGlobalVariable;\r
2926                 }\r
2927                 break;\r
2928             case EST_Bool:\r
2929                 if (IsAnnotation)\r
2930                 {\r
2931                     D3DXASSERT(sizeof(SBoolScalarAnnotation) == sizeof(SAnnotation));\r
2932                     new(pVar) SBoolScalarAnnotation;\r
2933                 }\r
2934                 else\r
2935                 {\r
2936                     D3DXASSERT(sizeof(SBoolScalarGlobalVariable) == sizeof(SGlobalVariable));\r
2937                     new(pVar) SBoolScalarGlobalVariable;\r
2938                 }\r
2939                 break;\r
2940             default:\r
2941                 D3DXASSERT(0);\r
2942                 DPF( 0, "Internal loading error: invalid scalar type." );\r
2943                 return E_FAIL;\r
2944                 break;\r
2945             }            \r
2946             break;\r
2947         default:\r
2948             D3DXASSERT(0);\r
2949             DPF( 0, "Internal loading error: invalid numeric type." );\r
2950             return E_FAIL;\r
2951             break;\r
2952         }\r
2953         break;\r
2954     default:\r
2955         D3DXASSERT(0);\r
2956         DPF( 0, "Internal loading error: invalid variable type." );\r
2957         return E_FAIL;\r
2958         break;\r
2959     }\r
2960     return S_OK;\r
2961 }\r
2962 \r
2963 }\r