110401(DTXMania089)/SlimDXc_Jun2010(VC++2008)/external/Effects11/EffectReflection.cpp

   1 //////////////////////////////////////////////////////////////////////////////\r
   2 //\r
   3 //  Copyright (C) Microsoft Corporation.  All Rights Reserved.\r
   4 //\r
   5 //  File:       EffectReflection.cpp\r
   6 //  Content:    D3DX11 Effects public reflection APIs\r
   7 //\r
   8 //////////////////////////////////////////////////////////////////////////////\r
   9 \r
  10 #include "pchfx.h"\r
  11 \r
  12 namespace D3DX11Effects\r
  13 {\r
  14 \r
  15 SEffectInvalidType g_InvalidType;\r
  16 \r
  17 SEffectInvalidScalarVariable g_InvalidScalarVariable;\r
  18 SEffectInvalidVectorVariable g_InvalidVectorVariable;\r
  19 SEffectInvalidMatrixVariable g_InvalidMatrixVariable;\r
  20 SEffectInvalidStringVariable g_InvalidStringVariable;\r
  21 SEffectInvalidClassInstanceVariable g_InvalidClassInstanceVariable;\r
  22 SEffectInvalidInterfaceVariable g_InvalidInterfaceVariable;\r
  23 SEffectInvalidShaderResourceVariable g_InvalidShaderResourceVariable;\r
  24 SEffectInvalidUnorderedAccessViewVariable g_InvalidUnorderedAccessViewVariable;\r
  25 SEffectInvalidRenderTargetViewVariable g_InvalidRenderTargetViewVariable;\r
  26 SEffectInvalidDepthStencilViewVariable g_InvalidDepthStencilViewVariable;\r
  27 SEffectInvalidConstantBuffer g_InvalidConstantBuffer;\r
  28 SEffectInvalidShaderVariable g_InvalidShaderVariable;\r
  29 SEffectInvalidBlendVariable g_InvalidBlendVariable;\r
  30 SEffectInvalidDepthStencilVariable g_InvalidDepthStencilVariable;\r
  31 SEffectInvalidRasterizerVariable g_InvalidRasterizerVariable;\r
  32 SEffectInvalidSamplerVariable g_InvalidSamplerVariable;\r
  33 \r
  34 SEffectInvalidPass g_InvalidPass;\r
  35 SEffectInvalidTechnique g_InvalidTechnique;\r
  36 SEffectInvalidGroup g_InvalidGroup;\r
  37 \r
  38 \r
  39 //////////////////////////////////////////////////////////////////////////\r
  40 // Helper routine implementations\r
  41 //////////////////////////////////////////////////////////////////////////\r
  42 \r
  43 ID3DX11EffectConstantBuffer * NoParentCB()\r
  44 {\r
  45     DPF(0, "ID3DX11EffectVariable::GetParentConstantBuffer: Variable does not have a parent constant buffer");\r
  46     // have to typecast because the type of g_InvalidScalarVariable has not been declared yet\r
  47     return &g_InvalidConstantBuffer;\r
  48 }\r
  49 \r
  50 ID3DX11EffectVariable * GetAnnotationByIndexHelper(const char *pClassName, UINT  Index, UINT  AnnotationCount, SAnnotation *pAnnotations)\r
  51 {\r
  52     if (Index >= AnnotationCount)\r
  53     {\r
  54         DPF(0, "%s::GetAnnotationByIndex: Invalid index (%d, total: %d)", pClassName, Index, AnnotationCount);\r
  55         return &g_InvalidScalarVariable;\r
  56     }\r
  57 \r
  58     return pAnnotations + Index;\r
  59 }\r
  60 \r
  61 ID3DX11EffectVariable * GetAnnotationByNameHelper(const char *pClassName, LPCSTR Name, UINT  AnnotationCount, SAnnotation *pAnnotations)\r
  62 {\r
  63     UINT  i;\r
  64     for (i = 0; i < AnnotationCount; ++ i)\r
  65     {\r
  66         if (strcmp(pAnnotations[i].pName, Name) == 0)\r
  67         {\r
  68             return pAnnotations + i;\r
  69         }\r
  70     }\r
  71 \r
  72     DPF(0, "%s::GetAnnotationByName: Annotation [%s] not found", pClassName, Name);\r
  73     return &g_InvalidScalarVariable;\r
  74 }\r
  75 \r
  76 //////////////////////////////////////////////////////////////////////////\r
  77 // Effect routines to pool interfaces\r
  78 //////////////////////////////////////////////////////////////////////////\r
  79 \r
  80 ID3DX11EffectType * CEffect::CreatePooledSingleElementTypeInterface(SType *pType)\r
  81 {\r
  82     UINT  i;\r
  83 \r
  84     if (IsOptimized())\r
  85     {\r
  86         DPF(0, "ID3DX11Effect: Cannot create new type interfaces since the effect has been Optimize()'ed");\r
  87         return &g_InvalidType;\r
  88     }\r
  89 \r
  90     for (i = 0; i < m_pTypeInterfaces.GetSize(); ++ i)\r
  91     {\r
  92         if (m_pTypeInterfaces[i]->pType == pType)\r
  93         {\r
  94             return (SSingleElementType*)m_pTypeInterfaces[i];\r
  95         }\r
  96     }\r
  97     SSingleElementType *pNewType;\r
  98     if (NULL == (pNewType = NEW SSingleElementType))\r
  99     {\r
 100         DPF(0, "ID3DX11Effect: Out of memory while trying to create new type interface");\r
 101         return &g_InvalidType;\r
 102     }\r
 103 \r
 104     pNewType->pType = pType;\r
 105     m_pTypeInterfaces.Add(pNewType);\r
 106 \r
 107     return pNewType;\r
 108 }\r
 109 \r
 110 // Create a member variable (via GetMemberBy* or GetElement)\r
 111 ID3DX11EffectVariable * CEffect::CreatePooledVariableMemberInterface(TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity, SVariable *pMember, UDataPointer Data, BOOL IsSingleElement, UINT Index)\r
 112 {\r
 113     BOOL IsAnnotation;\r
 114     UINT  i;\r
 115 \r
 116     if (IsOptimized())\r
 117     {\r
 118         DPF(0, "ID3DX11Effect: Cannot create new variable interfaces since the effect has been Optimize()'ed");\r
 119         return &g_InvalidScalarVariable;\r
 120     }\r
 121 \r
 122     for (i = 0; i < m_pMemberInterfaces.GetSize(); ++ i)\r
 123     {\r
 124         if (m_pMemberInterfaces[i]->pType == pMember->pType && \r
 125             m_pMemberInterfaces[i]->pName == pMember->pName &&\r
 126             m_pMemberInterfaces[i]->pSemantic == pMember->pSemantic &&\r
 127             m_pMemberInterfaces[i]->Data.pGeneric == Data.pGeneric &&\r
 128             m_pMemberInterfaces[i]->IsSingleElement == IsSingleElement &&\r
 129             ((SMember*)m_pMemberInterfaces[i])->pTopLevelEntity == pTopLevelEntity)\r
 130         {\r
 131             return (ID3DX11EffectVariable *) m_pMemberInterfaces[i];\r
 132         }\r
 133     }\r
 134 \r
 135     // is this annotation or runtime data?\r
 136     if( pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity) )\r
 137     {\r
 138         D3DXASSERT( pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric) );\r
 139         IsAnnotation = TRUE;\r
 140     }\r
 141     else\r
 142     {\r
 143         // if the heap is empty, we are still loading the Effect, and thus creating a member for a variable initializer\r
 144         // ex. Interface myInt = myClassArray[2];\r
 145         if( pTopLevelEntity->pEffect->m_Heap.GetSize() > 0 )\r
 146         {\r
 147             D3DXASSERT( pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity) );\r
 148             if (!pTopLevelEntity->pType->IsObjectType(EOT_String))\r
 149             {\r
 150                 // strings are funny; their data is reflection data, so ignore those\r
 151                 D3DXASSERT( pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric) );\r
 152             }\r
 153         }\r
 154         IsAnnotation = FALSE;\r
 155     }\r
 156 \r
 157     SMember *pNewMember;\r
 158 \r
 159     if (NULL == (pNewMember = CreateNewMember((SType*)pMember->pType, IsAnnotation)))\r
 160     {\r
 161         DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");\r
 162         return &g_InvalidScalarVariable;\r
 163     }\r
 164     \r
 165     pNewMember->pType = pMember->pType;\r
 166     pNewMember->pName = pMember->pName;\r
 167     pNewMember->pSemantic = pMember->pSemantic;\r
 168     pNewMember->Data.pGeneric = Data.pGeneric;\r
 169     pNewMember->IsSingleElement = IsSingleElement;\r
 170     pNewMember->pTopLevelEntity = pTopLevelEntity;\r
 171 \r
 172     if( IsSingleElement && pMember->pMemberData )\r
 173     {\r
 174         D3DXASSERT( !IsAnnotation );\r
 175         // This is an element of a global variable array\r
 176         pNewMember->pMemberData = pMember->pMemberData + Index;\r
 177     }\r
 178 \r
 179     if (FAILED(m_pMemberInterfaces.Add(pNewMember)))\r
 180     {\r
 181         SAFE_DELETE(pNewMember);\r
 182         DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");\r
 183         return &g_InvalidScalarVariable;\r
 184     }\r
 185 \r
 186     return (ID3DX11EffectVariable *) pNewMember;\r
 187 }\r
 188 \r
 189 //////////////////////////////////////////////////////////////////////////\r
 190 // ID3DX11EffectType (SType, SSingleElementType implementations)\r
 191 //////////////////////////////////////////////////////////////////////////\r
 192 \r
 193 static ID3DX11EffectType * GetTypeByIndexHelper(UINT Index, UINT  VariableCount, \r
 194                                                SVariable *pVariables, UINT  SizeOfVariableType)\r
 195 {\r
 196     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByIndex";\r
 197 \r
 198     if (Index >= VariableCount)\r
 199     {\r
 200         DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);\r
 201         return &g_InvalidType;\r
 202     }\r
 203 \r
 204     SVariable *pVariable = (SVariable *)((BYTE *)pVariables + Index * SizeOfVariableType);\r
 205     if (NULL == pVariable->pName)\r
 206     {\r
 207         DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);\r
 208         return &g_InvalidType;\r
 209     }\r
 210 \r
 211     return (ID3DX11EffectType *) pVariable->pType;\r
 212 }\r
 213 \r
 214 static ID3DX11EffectType * GetTypeByNameHelper(LPCSTR Name, UINT  VariableCount, \r
 215                                               SVariable *pVariables, UINT  SizeOfVariableType)\r
 216 {\r
 217     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByName";\r
 218 \r
 219     if (NULL == Name)\r
 220     {\r
 221         DPF(0, "%s: Parameter Name was NULL.", pFuncName);\r
 222         return &g_InvalidType;\r
 223     }\r
 224 \r
 225     UINT  i;\r
 226     SVariable *pVariable;\r
 227 \r
 228     for (i = 0; i < VariableCount; ++ i)\r
 229     {\r
 230         pVariable = (SVariable *)((BYTE *)pVariables + i * SizeOfVariableType);\r
 231         if (NULL == pVariable->pName)\r
 232         {\r
 233             DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);\r
 234             return &g_InvalidType;\r
 235         }\r
 236         if (strcmp(pVariable->pName, Name) == 0)\r
 237         {\r
 238             return (ID3DX11EffectType *) pVariable->pType;\r
 239         }\r
 240     }\r
 241 \r
 242     DPF(0, "%s: Member type [%s] not found", pFuncName, Name);\r
 243     return &g_InvalidType;\r
 244 }\r
 245 \r
 246 \r
 247 static ID3DX11EffectType * GetTypeBySemanticHelper(LPCSTR Semantic, UINT  VariableCount, \r
 248                                                   SVariable *pVariables, UINT  SizeOfVariableType)\r
 249 {\r
 250     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeBySemantic";\r
 251 \r
 252     if (NULL == Semantic)\r
 253     {\r
 254         DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);\r
 255         return &g_InvalidType;\r
 256     }\r
 257 \r
 258     UINT  i;\r
 259     SVariable *pVariable;\r
 260 \r
 261     for (i = 0; i < VariableCount; ++ i)\r
 262     {\r
 263         pVariable = (SVariable *)((BYTE *)pVariables + i * SizeOfVariableType);\r
 264         if (NULL == pVariable->pName)\r
 265         {\r
 266             DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);\r
 267             return &g_InvalidType;\r
 268         }\r
 269         if (NULL != pVariable->pSemantic &&\r
 270             _stricmp(pVariable->pSemantic, Semantic) == 0)\r
 271         {\r
 272             return (ID3DX11EffectType *) pVariable->pType;\r
 273         }\r
 274     }\r
 275 \r
 276     DPF(0, "%s: Member type with semantic [%s] not found", pFuncName, Semantic);\r
 277     return &g_InvalidType;\r
 278 }\r
 279 \r
 280 ID3DX11EffectType * SType::GetMemberTypeByIndex(UINT Index)\r
 281 {\r
 282     if (VarType != EVT_Struct)\r
 283     {\r
 284         DPF(0, "ID3DX11EffectType::GetMemberTypeByIndex: This interface does not refer to a structure");\r
 285         return &g_InvalidType;\r
 286     }\r
 287 \r
 288     return GetTypeByIndexHelper(Index, StructType.Members, StructType.pMembers, sizeof(SVariable));\r
 289 }\r
 290 \r
 291 ID3DX11EffectType * SType::GetMemberTypeByName(LPCSTR Name)\r
 292 {\r
 293     if (VarType != EVT_Struct)\r
 294     {\r
 295         DPF(0, "ID3DX11EffectType::GetMemberTypeByName: This interface does not refer to a structure");\r
 296         return &g_InvalidType;\r
 297     }\r
 298 \r
 299     return GetTypeByNameHelper(Name, StructType.Members, StructType.pMembers, sizeof(SVariable));\r
 300 }\r
 301 \r
 302 ID3DX11EffectType * SType::GetMemberTypeBySemantic(LPCSTR Semantic)\r
 303 {\r
 304     if (VarType != EVT_Struct)\r
 305     {\r
 306         DPF(0, "ID3DX11EffectType::GetMemberTypeBySemantic: This interface does not refer to a structure");\r
 307         return &g_InvalidType;\r
 308     }\r
 309 \r
 310     return GetTypeBySemanticHelper(Semantic, StructType.Members, StructType.pMembers, sizeof(SVariable));\r
 311 }\r
 312 \r
 313 LPCSTR SType::GetMemberName(UINT Index)\r
 314 {\r
 315     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";\r
 316 \r
 317     if (VarType != EVT_Struct)\r
 318     {\r
 319         DPF(0, "%s: This interface does not refer to a structure", pFuncName);\r
 320         return NULL;\r
 321     }\r
 322 \r
 323     if (Index >= StructType.Members)\r
 324     {\r
 325         DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, StructType.Members);\r
 326         return NULL;\r
 327     }\r
 328 \r
 329     SVariable *pVariable = StructType.pMembers + Index;\r
 330 \r
 331     if (NULL == pVariable->pName)\r
 332     {\r
 333         DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);\r
 334         return NULL;\r
 335     }\r
 336 \r
 337     return pVariable->pName;\r
 338 }\r
 339 \r
 340 LPCSTR SType::GetMemberSemantic(UINT Index)\r
 341 {\r
 342     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";\r
 343 \r
 344     if (VarType != EVT_Struct)\r
 345     {\r
 346         DPF(0, "%s: This interface does not refer to a structure", pFuncName);\r
 347         return NULL;\r
 348     }\r
 349 \r
 350     if (Index >= StructType.Members)\r
 351     {\r
 352         DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, StructType.Members);\r
 353         return NULL;\r
 354     }\r
 355 \r
 356     SVariable *pVariable = StructType.pMembers + Index;\r
 357 \r
 358     if (NULL == pVariable->pName)\r
 359     {\r
 360         DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);\r
 361         return NULL;\r
 362     }\r
 363 \r
 364     return pVariable->pSemantic;\r
 365 }\r
 366 \r
 367 HRESULT SType::GetDescHelper(D3DX11_EFFECT_TYPE_DESC *pDesc, BOOL IsSingleElement) const\r
 368 {\r
 369     HRESULT hr = S_OK;\r
 370     LPCSTR pFuncName = "ID3DX11EffectType::GetDesc";\r
 371 \r
 372     VERIFYPARAMETER(pDesc);\r
 373     \r
 374     pDesc->TypeName = pTypeName;\r
 375 \r
 376     // intentionally return 0 so they know it's not a single element array\r
 377     pDesc->Elements = IsSingleElement ? 0 : Elements;\r
 378     pDesc->PackedSize = GetTotalPackedSize(IsSingleElement);\r
 379     pDesc->UnpackedSize = GetTotalUnpackedSize(IsSingleElement);\r
 380     pDesc->Stride = Stride;\r
 381 \r
 382     switch (VarType)\r
 383     {\r
 384     case EVT_Numeric:\r
 385         switch (NumericType.NumericLayout)\r
 386         {\r
 387         case ENL_Matrix:\r
 388             if (NumericType.IsColumnMajor)\r
 389             {\r
 390                 pDesc->Class = D3D10_SVC_MATRIX_COLUMNS;\r
 391             }\r
 392             else\r
 393             {\r
 394                 pDesc->Class = D3D10_SVC_MATRIX_ROWS;\r
 395             }\r
 396             break;\r
 397         case ENL_Vector:\r
 398             pDesc->Class = D3D10_SVC_VECTOR;\r
 399             break;\r
 400         case ENL_Scalar:\r
 401             pDesc->Class = D3D10_SVC_SCALAR;\r
 402             break;\r
 403         default:\r
 404             D3DXASSERT(0);\r
 405         }\r
 406 \r
 407         switch (NumericType.ScalarType)\r
 408         {\r
 409         case EST_Bool:\r
 410             pDesc->Type = D3D10_SVT_BOOL;\r
 411             break;\r
 412         case EST_Int:\r
 413             pDesc->Type = D3D10_SVT_INT;\r
 414             break;\r
 415         case EST_UInt:\r
 416             pDesc->Type = D3D10_SVT_UINT;\r
 417             break;\r
 418         case EST_Float:\r
 419             pDesc->Type = D3D10_SVT_FLOAT;\r
 420             break;\r
 421         default:\r
 422             D3DXASSERT(0);\r
 423         }\r
 424 \r
 425         pDesc->Rows = NumericType.Rows;\r
 426         pDesc->Columns = NumericType.Columns;\r
 427         pDesc->Members = 0;\r
 428 \r
 429         break;\r
 430 \r
 431     case EVT_Struct:\r
 432         pDesc->Rows = 0;\r
 433         pDesc->Columns = 0;\r
 434         pDesc->Members = StructType.Members;\r
 435         if( StructType.ImplementsInterface )\r
 436         {\r
 437             pDesc->Class = D3D11_SVC_INTERFACE_CLASS;\r
 438         }\r
 439         else\r
 440         {\r
 441             pDesc->Class = D3D10_SVC_STRUCT;\r
 442         }\r
 443         pDesc->Type = D3D10_SVT_VOID;\r
 444         break;\r
 445 \r
 446     case EVT_Interface:\r
 447         pDesc->Rows = 0;\r
 448         pDesc->Columns = 0;\r
 449         pDesc->Members = 0;\r
 450         pDesc->Class = D3D11_SVC_INTERFACE_POINTER;\r
 451         pDesc->Type = D3D11_SVT_INTERFACE_POINTER;\r
 452         break;\r
 453 \r
 454     case EVT_Object:\r
 455         pDesc->Rows = 0;\r
 456         pDesc->Columns = 0;\r
 457         pDesc->Members = 0;\r
 458         pDesc->Class = D3D10_SVC_OBJECT;            \r
 459 \r
 460         switch (ObjectType)\r
 461         {\r
 462         case EOT_String:\r
 463             pDesc->Type = D3D10_SVT_STRING;\r
 464             break;\r
 465         case EOT_Blend:\r
 466             pDesc->Type = D3D10_SVT_BLEND; \r
 467             break;\r
 468         case EOT_DepthStencil:\r
 469             pDesc->Type = D3D10_SVT_DEPTHSTENCIL;\r
 470             break;\r
 471         case EOT_Rasterizer:\r
 472             pDesc->Type = D3D10_SVT_RASTERIZER;\r
 473             break;\r
 474         case EOT_PixelShader:\r
 475         case EOT_PixelShader5:\r
 476             pDesc->Type = D3D10_SVT_PIXELSHADER;\r
 477             break;\r
 478         case EOT_VertexShader:\r
 479         case EOT_VertexShader5:\r
 480             pDesc->Type = D3D10_SVT_VERTEXSHADER;\r
 481             break;\r
 482         case EOT_GeometryShader:\r
 483         case EOT_GeometryShaderSO:\r
 484         case EOT_GeometryShader5:\r
 485             pDesc->Type = D3D10_SVT_GEOMETRYSHADER;\r
 486             break;\r
 487         case EOT_HullShader5:\r
 488             pDesc->Type = D3D11_SVT_HULLSHADER;\r
 489             break;\r
 490         case EOT_DomainShader5:\r
 491             pDesc->Type = D3D11_SVT_DOMAINSHADER;\r
 492             break;\r
 493         case EOT_ComputeShader5:\r
 494             pDesc->Type = D3D11_SVT_COMPUTESHADER;\r
 495             break;\r
 496         case EOT_Texture:\r
 497             pDesc->Type = D3D10_SVT_TEXTURE;\r
 498             break;\r
 499         case EOT_Texture1D:\r
 500             pDesc->Type = D3D10_SVT_TEXTURE1D;\r
 501             break;\r
 502         case EOT_Texture1DArray:\r
 503             pDesc->Type = D3D10_SVT_TEXTURE1DARRAY;\r
 504             break;\r
 505         case EOT_Texture2D:\r
 506             pDesc->Type = D3D10_SVT_TEXTURE2D;\r
 507             break;\r
 508         case EOT_Texture2DArray:\r
 509             pDesc->Type = D3D10_SVT_TEXTURE2DARRAY;\r
 510             break;\r
 511         case EOT_Texture2DMS:\r
 512             pDesc->Type = D3D10_SVT_TEXTURE2DMS;\r
 513             break;\r
 514         case EOT_Texture2DMSArray:\r
 515             pDesc->Type = D3D10_SVT_TEXTURE2DMSARRAY;\r
 516             break;\r
 517         case EOT_Texture3D:\r
 518             pDesc->Type = D3D10_SVT_TEXTURE3D;\r
 519             break;\r
 520         case EOT_TextureCube:\r
 521             pDesc->Type = D3D10_SVT_TEXTURECUBE;\r
 522             break;\r
 523         case EOT_TextureCubeArray:\r
 524             pDesc->Type = D3D10_SVT_TEXTURECUBEARRAY;\r
 525             break;\r
 526         case EOT_Buffer:\r
 527             pDesc->Type = D3D10_SVT_BUFFER;\r
 528             break;\r
 529         case EOT_Sampler:\r
 530             pDesc->Type = D3D10_SVT_SAMPLER;\r
 531             break;\r
 532         case EOT_RenderTargetView:\r
 533             pDesc->Type = D3D10_SVT_RENDERTARGETVIEW;\r
 534             break;\r
 535         case EOT_DepthStencilView:\r
 536             pDesc->Type = D3D10_SVT_DEPTHSTENCILVIEW;\r
 537             break;\r
 538         case EOT_RWTexture1D:\r
 539             pDesc->Type = D3D11_SVT_RWTEXTURE1D;\r
 540             break;\r
 541         case EOT_RWTexture1DArray:\r
 542             pDesc->Type = D3D11_SVT_RWTEXTURE1DARRAY;\r
 543             break;\r
 544         case EOT_RWTexture2D:\r
 545             pDesc->Type = D3D11_SVT_RWTEXTURE2D;\r
 546             break;\r
 547         case EOT_RWTexture2DArray:\r
 548             pDesc->Type = D3D11_SVT_RWTEXTURE2DARRAY;\r
 549             break;\r
 550         case EOT_RWTexture3D:\r
 551             pDesc->Type = D3D11_SVT_RWTEXTURE3D;\r
 552             break;\r
 553         case EOT_RWBuffer:\r
 554             pDesc->Type = D3D11_SVT_RWBUFFER;\r
 555             break;\r
 556         case EOT_ByteAddressBuffer:\r
 557             pDesc->Type = D3D11_SVT_BYTEADDRESS_BUFFER;\r
 558             break;\r
 559         case EOT_RWByteAddressBuffer:\r
 560             pDesc->Type = D3D11_SVT_RWBYTEADDRESS_BUFFER;\r
 561             break;\r
 562         case EOT_StructuredBuffer:\r
 563             pDesc->Type = D3D11_SVT_STRUCTURED_BUFFER;\r
 564             break;\r
 565         case EOT_RWStructuredBuffer:\r
 566         case EOT_RWStructuredBufferAlloc:\r
 567         case EOT_RWStructuredBufferConsume:\r
 568             pDesc->Type = D3D11_SVT_RWSTRUCTURED_BUFFER;\r
 569             break;\r
 570         case EOT_AppendStructuredBuffer:\r
 571             pDesc->Type = D3D11_SVT_APPEND_STRUCTURED_BUFFER;\r
 572             break;\r
 573         case EOT_ConsumeStructuredBuffer:\r
 574             pDesc->Type = D3D11_SVT_CONSUME_STRUCTURED_BUFFER;\r
 575             break;\r
 576 \r
 577         default:\r
 578             D3DXASSERT(0);\r
 579         }\r
 580         break;\r
 581 \r
 582     default:\r
 583         D3DXASSERT(0);\r
 584     }\r
 585 \r
 586 lExit:\r
 587     return hr;\r
 588 \r
 589 }\r
 590 \r
 591 ////////////////////////////////////////////////////////////////////////////////\r
 592 // ID3DX11EffectShaderVariable (SAnonymousShader implementation)\r
 593 ////////////////////////////////////////////////////////////////////////////////\r
 594 \r
 595 SAnonymousShader::SAnonymousShader(SShaderBlock *pBlock)\r
 596 {\r
 597     pShaderBlock = pBlock;\r
 598 }\r
 599 \r
 600 BOOL SAnonymousShader::IsValid()\r
 601 {\r
 602     return pShaderBlock && pShaderBlock->IsValid;\r
 603 }\r
 604 \r
 605 ID3DX11EffectType * SAnonymousShader::GetType()\r
 606 {\r
 607     return (ID3DX11EffectType *) this;\r
 608 }\r
 609 \r
 610 HRESULT SAnonymousShader::GetDesc(D3DX11_EFFECT_VARIABLE_DESC *pDesc)\r
 611 {\r
 612     pDesc->Annotations = 0;\r
 613     pDesc->Flags = 0;\r
 614 \r
 615     pDesc->Name = "$Anonymous";\r
 616     pDesc->Semantic = NULL;\r
 617     pDesc->BufferOffset = 0;\r
 618 \r
 619     return S_OK;\r
 620 }\r
 621 \r
 622 ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByIndex(UINT Index)\r
 623 {\r
 624     DPF(0, "ID3DX11EffectVariable::GetAnnotationByIndex: Anonymous shaders cannot have annotations");\r
 625     return &g_InvalidScalarVariable;\r
 626 }\r
 627 \r
 628 ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByName(LPCSTR Name)\r
 629 {\r
 630     DPF(0, "ID3DX11EffectVariable::GetAnnotationByName: Anonymous shaders cannot have annotations");\r
 631     return &g_InvalidScalarVariable;\r
 632 }\r
 633 \r
 634 ID3DX11EffectVariable * SAnonymousShader::GetMemberByIndex(UINT  Index)\r
 635 {\r
 636     DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");\r
 637     return &g_InvalidScalarVariable;\r
 638 }\r
 639 \r
 640 ID3DX11EffectVariable * SAnonymousShader::GetMemberByName(LPCSTR Name)\r
 641 {\r
 642     DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");\r
 643     return &g_InvalidScalarVariable;\r
 644 }\r
 645 \r
 646 ID3DX11EffectVariable * SAnonymousShader::GetMemberBySemantic(LPCSTR Semantic)\r
 647 {\r
 648     DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");\r
 649     return &g_InvalidScalarVariable;\r
 650 }\r
 651 \r
 652 ID3DX11EffectVariable * SAnonymousShader::GetElement(UINT Index)\r
 653 {\r
 654     DPF(0, "ID3DX11EffectVariable::GetElement: Anonymous shaders cannot have elements");\r
 655     return &g_InvalidScalarVariable;\r
 656 }\r
 657 \r
 658 ID3DX11EffectConstantBuffer * SAnonymousShader::GetParentConstantBuffer()\r
 659 {\r
 660     return NoParentCB();\r
 661 }\r
 662 \r
 663 ID3DX11EffectShaderVariable * SAnonymousShader::AsShader()\r
 664 {\r
 665     return (ID3DX11EffectShaderVariable *) this;\r
 666 }\r
 667 \r
 668 HRESULT SAnonymousShader::SetRawValue(CONST void *pData, UINT Offset, UINT Count) \r
 669 { \r
 670     return ObjectSetRawValue(); \r
 671 }\r
 672 \r
 673 HRESULT SAnonymousShader::GetRawValue(__out_bcount(Count) void *pData, UINT Offset, UINT Count) \r
 674 { \r
 675     return ObjectGetRawValue(); \r
 676 }\r
 677 \r
 678 #define ANONYMOUS_SHADER_INDEX_CHECK() \\r
 679     HRESULT hr = S_OK; \\r
 680     if (0 != ShaderIndex) \\r
 681     { \\r
 682         DPF(0, "%s: Invalid index specified", pFuncName); \\r
 683         VH(E_INVALIDARG); \\r
 684     } \\r
 685 \r
 686 HRESULT SAnonymousShader::GetShaderDesc(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)\r
 687 {\r
 688     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";\r
 689 \r
 690     ANONYMOUS_SHADER_INDEX_CHECK();\r
 691 \r
 692     pShaderBlock->GetShaderDesc(pDesc, TRUE);\r
 693 \r
 694 lExit:\r
 695     return hr;\r
 696 }\r
 697 \r
 698 HRESULT SAnonymousShader::GetVertexShader(UINT ShaderIndex, ID3D11VertexShader **ppVS)\r
 699 {\r
 700     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";\r
 701 \r
 702     ANONYMOUS_SHADER_INDEX_CHECK();\r
 703 \r
 704     VH( pShaderBlock->GetVertexShader(ppVS) );\r
 705 \r
 706 lExit:\r
 707     return hr;\r
 708 }\r
 709 \r
 710 HRESULT SAnonymousShader::GetGeometryShader(UINT ShaderIndex, ID3D11GeometryShader **ppGS)\r
 711 {\r
 712     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";\r
 713 \r
 714     ANONYMOUS_SHADER_INDEX_CHECK();\r
 715 \r
 716     VH( pShaderBlock->GetGeometryShader(ppGS) );\r
 717 \r
 718 lExit:\r
 719     return hr;\r
 720 }\r
 721 \r
 722 HRESULT SAnonymousShader::GetPixelShader(UINT ShaderIndex, ID3D11PixelShader **ppPS)\r
 723 {\r
 724     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";\r
 725 \r
 726     ANONYMOUS_SHADER_INDEX_CHECK();\r
 727 \r
 728     VH( pShaderBlock->GetPixelShader(ppPS) );\r
 729 \r
 730 lExit:\r
 731     return hr;\r
 732 }\r
 733 \r
 734 HRESULT SAnonymousShader::GetHullShader(UINT ShaderIndex, ID3D11HullShader **ppHS)\r
 735 {\r
 736     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";\r
 737 \r
 738     ANONYMOUS_SHADER_INDEX_CHECK();\r
 739 \r
 740     VH( pShaderBlock->GetHullShader(ppHS) );\r
 741 \r
 742 lExit:\r
 743     return hr;\r
 744 }\r
 745 \r
 746 HRESULT SAnonymousShader::GetDomainShader(UINT ShaderIndex, ID3D11DomainShader **ppCS)\r
 747 {\r
 748     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";\r
 749 \r
 750     ANONYMOUS_SHADER_INDEX_CHECK();\r
 751 \r
 752     VH( pShaderBlock->GetDomainShader(ppCS) );\r
 753 \r
 754 lExit:\r
 755     return hr;\r
 756 }\r
 757 \r
 758 HRESULT SAnonymousShader::GetComputeShader(UINT ShaderIndex, ID3D11ComputeShader **ppCS)\r
 759 {\r
 760     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";\r
 761 \r
 762     ANONYMOUS_SHADER_INDEX_CHECK();\r
 763 \r
 764     VH( pShaderBlock->GetComputeShader(ppCS) );\r
 765 \r
 766 lExit:\r
 767     return hr;\r
 768 }\r
 769 \r
 770 HRESULT SAnonymousShader::GetInputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)\r
 771 {\r
 772     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";\r
 773 \r
 774     ANONYMOUS_SHADER_INDEX_CHECK();\r
 775 \r
 776     VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );\r
 777 \r
 778 lExit:\r
 779     return hr;\r
 780 }\r
 781 \r
 782 HRESULT SAnonymousShader::GetOutputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)\r
 783 {\r
 784     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";\r
 785 \r
 786     ANONYMOUS_SHADER_INDEX_CHECK();\r
 787 \r
 788     VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );\r
 789 \r
 790 lExit:\r
 791     return hr;\r
 792 }\r
 793 \r
 794 HRESULT SAnonymousShader::GetPatchConstantSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)\r
 795 {\r
 796     LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";\r
 797 \r
 798     ANONYMOUS_SHADER_INDEX_CHECK();\r
 799 \r
 800     VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );\r
 801 \r
 802 lExit:\r
 803     return hr;\r
 804 }\r
 805 \r
 806 HRESULT SAnonymousShader::GetDesc(D3DX11_EFFECT_TYPE_DESC *pDesc)\r
 807 {\r
 808     pDesc->Class = D3D10_SVC_OBJECT;\r
 809 \r
 810     switch (pShaderBlock->GetShaderType())\r
 811     {\r
 812     case EOT_VertexShader:\r
 813     case EOT_VertexShader5:\r
 814         pDesc->TypeName = "vertexshader";\r
 815         pDesc->Type = D3D10_SVT_VERTEXSHADER;\r
 816         break;\r
 817     case EOT_GeometryShader:\r
 818     case EOT_GeometryShader5:\r
 819         pDesc->TypeName = "geometryshader";\r
 820         pDesc->Type = D3D10_SVT_GEOMETRYSHADER;\r
 821         break;\r
 822     case EOT_PixelShader:\r
 823     case EOT_PixelShader5:\r
 824         pDesc->TypeName = "pixelshader";\r
 825         pDesc->Type = D3D10_SVT_PIXELSHADER;\r
 826         break;\r
 827     case EOT_HullShader5:\r
 828         pDesc->TypeName = "Hullshader";\r
 829         pDesc->Type = D3D11_SVT_HULLSHADER;\r
 830         break;\r
 831     case EOT_DomainShader5:\r
 832         pDesc->TypeName = "Domainshader";\r
 833         pDesc->Type = D3D11_SVT_DOMAINSHADER;\r
 834         break;\r
 835     case EOT_ComputeShader5:\r
 836         pDesc->TypeName = "Computeshader";\r
 837         pDesc->Type = D3D11_SVT_COMPUTESHADER;\r
 838         break;\r
 839     }\r
 840 \r
 841     pDesc->Elements = 0;\r
 842     pDesc->Members = 0;\r
 843     pDesc->Rows = 0;\r
 844     pDesc->Columns = 0;\r
 845     pDesc->PackedSize = 0;\r
 846     pDesc->UnpackedSize = 0;\r
 847     pDesc->Stride = 0;\r
 848 \r
 849     return S_OK;\r
 850 }\r
 851 \r
 852 ID3DX11EffectType * SAnonymousShader::GetMemberTypeByIndex(UINT  Index)\r
 853 {\r
 854     DPF(0, "ID3DX11EffectType::GetMemberTypeByIndex: This interface does not refer to a structure");\r
 855     return &g_InvalidType;\r
 856 }\r
 857 \r
 858 ID3DX11EffectType * SAnonymousShader::GetMemberTypeByName(LPCSTR Name)\r
 859 {\r
 860     DPF(0, "ID3DX11EffectType::GetMemberTypeByName: This interface does not refer to a structure");\r
 861     return &g_InvalidType;\r
 862 }\r
 863 \r
 864 ID3DX11EffectType * SAnonymousShader::GetMemberTypeBySemantic(LPCSTR Semantic)\r
 865 {\r
 866     DPF(0, "ID3DX11EffectType::GetMemberTypeBySemantic: This interface does not refer to a structure");\r
 867     return &g_InvalidType;\r
 868 }\r
 869 \r
 870 LPCSTR SAnonymousShader::GetMemberName(UINT Index)\r
 871 {\r
 872     DPF(0, "ID3DX11EffectType::GetMemberName: This interface does not refer to a structure");\r
 873     return NULL;\r
 874 }\r
 875 \r
 876 LPCSTR SAnonymousShader::GetMemberSemantic(UINT Index)\r
 877 {\r
 878     DPF(0, "ID3DX11EffectType::GetMemberSemantic: This interface does not refer to a structure");\r
 879     return NULL;\r
 880 }\r
 881 \r
 882 //////////////////////////////////////////////////////////////////////////\r
 883 // ID3DX11EffectConstantBuffer (SConstantBuffer implementation)\r
 884 //////////////////////////////////////////////////////////////////////////\r
 885 \r
 886 BOOL SConstantBuffer::IsValid()\r
 887 {\r
 888     return TRUE;\r
 889 }\r
 890 \r
 891 ID3DX11EffectType * SConstantBuffer::GetType()\r
 892 {\r
 893     return (ID3DX11EffectType *) this;\r
 894 }\r
 895 \r
 896 HRESULT SConstantBuffer::GetDesc(D3DX11_EFFECT_VARIABLE_DESC *pDesc)\r
 897 {\r
 898     pDesc->Annotations = AnnotationCount;\r
 899     pDesc->Flags = 0;\r
 900 \r
 901     pDesc->Name = pName;\r
 902     pDesc->Semantic = NULL;\r
 903     pDesc->BufferOffset = 0;\r
 904 \r
 905     if (ExplicitBindPoint != -1)\r
 906     {\r
 907         pDesc->ExplicitBindPoint = ExplicitBindPoint;\r
 908         pDesc->Flags |= D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;\r
 909     }\r
 910     else\r
 911     {\r
 912         pDesc->ExplicitBindPoint = 0;\r
 913     }\r
 914 \r
 915     return S_OK;\r
 916 }\r
 917 \r
 918 ID3DX11EffectVariable * SConstantBuffer::GetAnnotationByIndex(UINT  Index)\r
 919 {\r
 920     return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);\r
 921 }\r
 922 \r
 923 ID3DX11EffectVariable * SConstantBuffer::GetAnnotationByName(LPCSTR Name)\r
 924 {\r
 925     return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);\r
 926 }\r
 927 \r
 928 ID3DX11EffectVariable * SConstantBuffer::GetMemberByIndex(UINT  Index)\r
 929 {\r
 930     SGlobalVariable *pMember;\r
 931     UDataPointer dataPtr;\r
 932 \r
 933     if (IsEffectOptimized)\r
 934     {\r
 935         DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Cannot get members; effect has been Optimize()'ed");\r
 936         return &g_InvalidScalarVariable;\r
 937     }\r
 938 \r
 939     if (!GetVariableByIndexHelper<SGlobalVariable>(Index, VariableCount, (SGlobalVariable*)pVariables, \r
 940         NULL, &pMember, &dataPtr.pGeneric))\r
 941     {\r
 942         return &g_InvalidScalarVariable;\r
 943     }\r
 944 \r
 945     return (ID3DX11EffectVariable *) pMember;\r
 946 }\r
 947 \r
 948 ID3DX11EffectVariable * SConstantBuffer::GetMemberByName(LPCSTR Name)\r
 949 {\r
 950     SGlobalVariable *pMember;\r
 951     UDataPointer dataPtr;\r
 952     UINT index;\r
 953 \r
 954     if (IsEffectOptimized)\r
 955     {\r
 956         DPF(0, "ID3DX11EffectVariable::GetMemberByName: Cannot get members; effect has been Optimize()'ed");\r
 957         return &g_InvalidScalarVariable;\r
 958     }\r
 959 \r
 960     if (!GetVariableByNameHelper<SGlobalVariable>(Name, VariableCount, (SGlobalVariable*)pVariables, \r
 961         NULL, &pMember, &dataPtr.pGeneric, &index))\r
 962     {\r
 963         return &g_InvalidScalarVariable;\r
 964     }\r
 965 \r
 966     return (ID3DX11EffectVariable *) pMember;\r
 967 }\r
 968 \r
 969 ID3DX11EffectVariable * SConstantBuffer::GetMemberBySemantic(LPCSTR Semantic)\r
 970 {\r
 971     SGlobalVariable *pMember;\r
 972     UDataPointer dataPtr;\r
 973     UINT index;\r
 974 \r
 975     if (IsEffectOptimized)\r
 976     {\r
 977         DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Cannot get members; effect has been Optimize()'ed");\r
 978         return &g_InvalidScalarVariable;\r
 979     }\r
 980 \r
 981     if (!GetVariableBySemanticHelper<SGlobalVariable>(Semantic, VariableCount, (SGlobalVariable*)pVariables, \r
 982         NULL, &pMember, &dataPtr.pGeneric, &index))\r
 983     {\r
 984         return &g_InvalidScalarVariable;\r
 985     }\r
 986 \r
 987     return (ID3DX11EffectVariable *) pMember;\r
 988 }\r
 989 \r
 990 ID3DX11EffectVariable * SConstantBuffer::GetElement(UINT  Index)\r
 991 {\r
 992     LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";\r
 993     DPF(0, "%s: This interface does not refer to an array", pFuncName);\r
 994     return &g_InvalidScalarVariable;\r
 995 }\r
 996 \r
 997 ID3DX11EffectConstantBuffer * SConstantBuffer::GetParentConstantBuffer()\r
 998 {\r
 999     LPCSTR pFuncName = "ID3DX11EffectVariable::GetParentConstantBuffer";\r
1000     DPF(0, "%s: Constant buffers do not have parent constant buffers", pFuncName);\r
1001     return &g_InvalidConstantBuffer;\r
1002 }\r
1003 \r
1004 ID3DX11EffectConstantBuffer * SConstantBuffer::AsConstantBuffer()\r
1005 {\r
1006     return (ID3DX11EffectConstantBuffer *) this;\r
1007 }\r
1008 \r
1009 HRESULT SConstantBuffer::GetDesc(D3DX11_EFFECT_TYPE_DESC *pDesc)\r
1010 {\r
1011     pDesc->TypeName = IsTBuffer ? "tbuffer" : "cbuffer";\r
1012     pDesc->Class = D3D10_SVC_OBJECT;\r
1013     pDesc->Type = IsTBuffer ? D3D10_SVT_TBUFFER : D3D10_SVT_CBUFFER;\r
1014 \r
1015     pDesc->Elements = 0;\r
1016     pDesc->Members = VariableCount;\r
1017     pDesc->Rows = 0;\r
1018     pDesc->Columns = 0;\r
1019 \r
1020     UINT  i;\r
1021     pDesc->PackedSize = 0;\r
1022     for (i = 0; i < VariableCount; ++ i)\r
1023     {\r
1024         pDesc->PackedSize += pVariables[i].pType->PackedSize;\r
1025     }\r
1026 \r
1027     pDesc->UnpackedSize = Size;\r
1028     D3DXASSERT(pDesc->UnpackedSize >= pDesc->PackedSize);\r
1029 \r
1030     pDesc->Stride = AlignToPowerOf2(pDesc->UnpackedSize, SType::c_RegisterSize);\r
1031 \r
1032     return S_OK;\r
1033 }\r
1034 \r
1035 ID3DX11EffectType * SConstantBuffer::GetMemberTypeByIndex(UINT  Index)\r
1036 {\r
1037     return GetTypeByIndexHelper(Index, VariableCount, pVariables, sizeof (SGlobalVariable));\r
1038 }\r
1039 \r
1040 ID3DX11EffectType * SConstantBuffer::GetMemberTypeByName(LPCSTR Name)\r
1041 {\r
1042     return GetTypeByNameHelper(Name, VariableCount, pVariables, sizeof (SGlobalVariable));\r
1043 }\r
1044 \r
1045 ID3DX11EffectType * SConstantBuffer::GetMemberTypeBySemantic(LPCSTR Semantic)\r
1046 {\r
1047     return GetTypeBySemanticHelper(Semantic, VariableCount, pVariables, sizeof (SGlobalVariable));\r
1048 }\r
1049 \r
1050 LPCSTR SConstantBuffer::GetMemberName(UINT Index)\r
1051 {\r
1052     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";\r
1053 \r
1054     if (IsEffectOptimized)\r
1055     {\r
1056         DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);\r
1057         return NULL;\r
1058     }\r
1059 \r
1060     if (Index >= VariableCount)\r
1061     {\r
1062         DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);\r
1063         return NULL;\r
1064     }\r
1065 \r
1066     return pVariables[Index].pName;\r
1067 }\r
1068 \r
1069 LPCSTR SConstantBuffer::GetMemberSemantic(UINT Index)\r
1070 {\r
1071     LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";\r
1072 \r
1073     if (IsEffectOptimized)\r
1074     {\r
1075         DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);\r
1076         return NULL;\r
1077     }\r
1078 \r
1079     if (Index >= VariableCount)\r
1080     {\r
1081         DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);\r
1082         return NULL;\r
1083     }\r
1084 \r
1085     return pVariables[Index].pSemantic;\r
1086 }\r
1087 \r
1088 HRESULT SConstantBuffer::SetRawValue(CONST void *pData, UINT  Offset, UINT  Count)\r
1089 {\r
1090     HRESULT hr = S_OK;    \r
1091 \r
1092 #ifdef _DEBUG\r
1093     LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";\r
1094 \r
1095     VERIFYPARAMETER(pData);\r
1096 \r
1097     if ((Offset + Count < Offset) ||\r
1098         (Count + (BYTE*)pData < (BYTE*)pData) ||\r
1099         ((Offset + Count) > Size))\r
1100     {\r
1101         // overflow of some kind\r
1102         DPF(0, "%s: Invalid range specified", pFuncName);\r
1103         VH(E_INVALIDARG);\r
1104     }\r
1105 #endif\r
1106 \r
1107     if (IsUsedByExpression)\r
1108     {\r
1109         UINT  i;\r
1110         for (i = 0; i < VariableCount; ++ i)\r
1111         {\r
1112             ((SGlobalVariable*)pVariables)[i].DirtyVariable();\r
1113         }\r
1114     }\r
1115     else\r
1116     {\r
1117         IsDirty = TRUE;\r
1118     }\r
1119 \r
1120     memcpy(pBackingStore + Offset, pData, Count);\r
1121 \r
1122 lExit:\r
1123     return hr;\r
1124 }\r
1125 \r
1126 HRESULT SConstantBuffer::GetRawValue(__out_bcount(Count) void *pData, UINT  Offset, UINT  Count)\r
1127 {\r
1128     HRESULT hr = S_OK;    \r
1129 \r
1130 #ifdef _DEBUG\r
1131     LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";\r
1132 \r
1133     VERIFYPARAMETER(pData);\r
1134 \r
1135     if ((Offset + Count < Offset) ||\r
1136         (Count + (BYTE*)pData < (BYTE*)pData) ||\r
1137         ((Offset + Count) > Size))\r
1138     {\r
1139         // overflow of some kind\r
1140         DPF(0, "%s: Invalid range specified", pFuncName);\r
1141         VH(E_INVALIDARG);\r
1142     }\r
1143 #endif\r
1144 \r
1145     memcpy(pData, pBackingStore + Offset, Count);\r
1146 \r
1147 lExit:\r
1148     return hr;\r
1149 }\r
1150 \r
1151 bool SConstantBuffer::ClonedSingle() const\r
1152 {\r
1153     return IsSingle && ( pEffect->m_Flags & D3DX11_EFFECT_CLONE );\r
1154 }\r
1155 \r
1156 HRESULT SConstantBuffer::SetConstantBuffer(ID3D11Buffer *pConstantBuffer)\r
1157 {\r
1158     HRESULT hr = S_OK;\r
1159     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::SetConstantBuffer";\r
1160 \r
1161     if (IsTBuffer)\r
1162     {\r
1163         DPF(0, "%s: This is a texture buffer; use SetTextureBuffer instead", pFuncName);\r
1164         VH(D3DERR_INVALIDCALL);\r
1165     }\r
1166 \r
1167     // Replace all references to the old shader block with this one\r
1168     pEffect->ReplaceCBReference(this, pConstantBuffer);\r
1169 \r
1170     if( !IsUserManaged )\r
1171     {\r
1172         // Save original cbuffer in case we UndoSet\r
1173         D3DXASSERT( pMemberData[0].Type == MDT_Buffer );\r
1174         VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == NULL );\r
1175         pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;\r
1176         pD3DObject = NULL;\r
1177         IsUserManaged = TRUE;\r
1178         IsNonUpdatable = TRUE;\r
1179     }\r
1180 \r
1181     SAFE_ADDREF( pConstantBuffer );\r
1182     SAFE_RELEASE( pD3DObject );\r
1183     pD3DObject = pConstantBuffer;\r
1184 \r
1185 lExit:\r
1186     return hr;\r
1187 }\r
1188 \r
1189 HRESULT SConstantBuffer::GetConstantBuffer(ID3D11Buffer **ppConstantBuffer)\r
1190 {\r
1191     HRESULT hr = S_OK;\r
1192     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetConstantBuffer";\r
1193 \r
1194     VERIFYPARAMETER(ppConstantBuffer);\r
1195 \r
1196     if (IsTBuffer)\r
1197     {\r
1198         DPF(0, "%s: This is a texture buffer; use GetTextureBuffer instead", pFuncName);\r
1199         VH(D3DERR_INVALIDCALL);\r
1200     }\r
1201 \r
1202     *ppConstantBuffer = pD3DObject;\r
1203     SAFE_ADDREF(*ppConstantBuffer);\r
1204 \r
1205 lExit:\r
1206     return hr;\r
1207 }\r
1208 \r
1209 HRESULT SConstantBuffer::UndoSetConstantBuffer() \r
1210 {\r
1211     HRESULT hr = S_OK;\r
1212     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::UndoSetConstantBuffer";\r
1213 \r
1214     if (IsTBuffer)\r
1215     {\r
1216         DPF(0, "%s: This is a texture buffer; use UndoSetTextureBuffer instead", pFuncName);\r
1217         VH(D3DERR_INVALIDCALL);\r
1218     }\r
1219 \r
1220     if( !IsUserManaged )\r
1221     {\r
1222         return S_FALSE;\r
1223     }\r
1224 \r
1225     // Replace all references to the old shader block with this one\r
1226     pEffect->ReplaceCBReference(this, pMemberData[0].Data.pD3DEffectsManagedConstantBuffer);\r
1227 \r
1228     // Revert to original cbuffer\r
1229     SAFE_RELEASE( pD3DObject );\r
1230     pD3DObject = pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;\r
1231     pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = NULL;\r
1232     IsUserManaged = FALSE;\r
1233     IsNonUpdatable = ClonedSingle();\r
1234 \r
1235 lExit:\r
1236     return hr;\r
1237 }\r
1238 \r
1239 HRESULT SConstantBuffer::SetTextureBuffer(ID3D11ShaderResourceView *pTextureBuffer)\r
1240 {\r
1241     HRESULT hr = S_OK;\r
1242     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::SetTextureBuffer";\r
1243 \r
1244     if (!IsTBuffer)\r
1245     {\r
1246         DPF(0, "%s: This is a constant buffer; use SetConstantBuffer instead", pFuncName);\r
1247         VH(D3DERR_INVALIDCALL);\r
1248     }\r
1249 \r
1250     if( !IsUserManaged )\r
1251     {\r
1252         // Save original cbuffer and tbuffer in case we UndoSet\r
1253         D3DXASSERT( pMemberData[0].Type == MDT_Buffer );\r
1254         VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == NULL );\r
1255         pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;\r
1256         pD3DObject = NULL;\r
1257         D3DXASSERT( pMemberData[1].Type == MDT_ShaderResourceView );\r
1258         VB( pMemberData[1].Data.pD3DEffectsManagedTextureBuffer == NULL );\r
1259         pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = TBuffer.pShaderResource;\r
1260         TBuffer.pShaderResource = NULL;\r
1261         IsUserManaged = TRUE;\r
1262         IsNonUpdatable = TRUE;\r
1263     }\r
1264 \r
1265     SAFE_ADDREF( pTextureBuffer );\r
1266     SAFE_RELEASE(pD3DObject); // won't be needing this anymore...\r
1267     SAFE_RELEASE( TBuffer.pShaderResource );\r
1268     TBuffer.pShaderResource = pTextureBuffer;\r
1269 \r
1270 lExit:\r
1271     return hr;\r
1272 }\r
1273 \r
1274 HRESULT SConstantBuffer::GetTextureBuffer(ID3D11ShaderResourceView **ppTextureBuffer)\r
1275 {\r
1276     HRESULT hr = S_OK;\r
1277     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetTextureBuffer";\r
1278 \r
1279     VERIFYPARAMETER(ppTextureBuffer);\r
1280 \r
1281     if (!IsTBuffer)\r
1282     {\r
1283         DPF(0, "%s: This is a constant buffer; use GetConstantBuffer instead", pFuncName);\r
1284         VH(D3DERR_INVALIDCALL);\r
1285     }\r
1286 \r
1287     *ppTextureBuffer = TBuffer.pShaderResource;\r
1288     SAFE_ADDREF(*ppTextureBuffer);\r
1289 \r
1290 lExit:\r
1291     return hr;\r
1292 }\r
1293 \r
1294 HRESULT SConstantBuffer::UndoSetTextureBuffer()\r
1295 {\r
1296     HRESULT hr = S_OK;\r
1297     LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::UndoSetTextureBuffer";\r
1298 \r
1299     if (!IsTBuffer)\r
1300     {\r
1301         DPF(0, "%s: This is a texture buffer; use UndoSetConstantBuffer instead", pFuncName);\r
1302         VH(D3DERR_INVALIDCALL);\r
1303     }\r
1304 \r
1305     if( !IsUserManaged )\r
1306     {\r
1307         return S_FALSE;\r
1308     }\r
1309 \r
1310     // Revert to original cbuffer\r
1311     SAFE_RELEASE( pD3DObject );\r
1312     pD3DObject = pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;\r
1313     pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = NULL;\r
1314     SAFE_RELEASE( TBuffer.pShaderResource );\r
1315     TBuffer.pShaderResource = pMemberData[1].Data.pD3DEffectsManagedTextureBuffer;\r
1316     pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = NULL;\r
1317     IsUserManaged = FALSE;\r
1318     IsNonUpdatable = ClonedSingle();\r
1319 \r
1320 lExit:\r
1321     return hr;\r
1322 }\r
1323 \r
1324 //////////////////////////////////////////////////////////////////////////\r
1325 // ID3DX11EffectPass (CEffectPass implementation)\r
1326 //////////////////////////////////////////////////////////////////////////\r
1327 \r
1328 BOOL SPassBlock::IsValid()\r
1329 {\r
1330     if( HasDependencies )\r
1331         return pEffect->ValidatePassBlock( this );\r
1332     return InitiallyValid;\r
1333 }\r
1334 \r
1335 HRESULT SPassBlock::GetDesc(D3DX11_PASS_DESC *pDesc)\r
1336 {\r
1337     HRESULT hr = S_OK;\r
1338     LPCSTR pFuncName = "ID3DX11EffectPass::GetDesc";\r
1339 \r
1340     VERIFYPARAMETER(pDesc);\r
1341 \r
1342     ZeroMemory(pDesc, sizeof(*pDesc));\r
1343 \r
1344     pDesc->Name = pName;\r
1345     pDesc->Annotations = AnnotationCount;\r
1346     \r
1347     SAssignment *pAssignment;\r
1348     SAssignment *pLastAssn;\r
1349 \r
1350     pEffect->IncrementTimer();\r
1351 \r
1352     pAssignment = pAssignments;\r
1353     pLastAssn = pAssignments + AssignmentCount;\r
1354 \r
1355     for(; pAssignment < pLastAssn; pAssignment++)\r
1356     {\r
1357         pEffect->EvaluateAssignment(pAssignment);\r
1358     }\r
1359 \r
1360     if( BackingStore.pVertexShaderBlock && BackingStore.pVertexShaderBlock->pInputSignatureBlob )\r
1361     {\r
1362         // pInputSignatureBlob can be null if we're setting a NULL VS "SetVertexShader( NULL )"\r
1363         pDesc->pIAInputSignature = (BYTE*)BackingStore.pVertexShaderBlock->pInputSignatureBlob->GetBufferPointer();\r
1364         pDesc->IAInputSignatureSize = BackingStore.pVertexShaderBlock->pInputSignatureBlob->GetBufferSize();\r
1365     }\r
1366 \r
1367     pDesc->StencilRef = BackingStore.StencilRef;\r
1368     pDesc->SampleMask = BackingStore.SampleMask;\r
1369     pDesc->BlendFactor[0] = BackingStore.BlendFactor[0];\r
1370     pDesc->BlendFactor[1] = BackingStore.BlendFactor[1];\r
1371     pDesc->BlendFactor[2] = BackingStore.BlendFactor[2];\r
1372     pDesc->BlendFactor[3] = BackingStore.BlendFactor[3];\r
1373 \r
1374 lExit:\r
1375     return hr;\r
1376 }\r
1377 \r
1378 extern SShaderBlock g_NullVS;\r
1379 extern SShaderBlock g_NullGS;\r
1380 extern SShaderBlock g_NullPS;\r
1381 extern SShaderBlock g_NullHS;\r
1382 extern SShaderBlock g_NullDS;\r
1383 extern SShaderBlock g_NullCS;\r
1384 \r
1385 SAnonymousShader g_AnonymousNullVS(&g_NullVS);\r
1386 SAnonymousShader g_AnonymousNullGS(&g_NullGS);\r
1387 SAnonymousShader g_AnonymousNullPS(&g_NullPS);\r
1388 SAnonymousShader g_AnonymousNullHS(&g_NullHS);\r
1389 SAnonymousShader g_AnonymousNullDS(&g_NullDS);\r
1390 SAnonymousShader g_AnonymousNullCS(&g_NullCS);\r
1391 \r
1392 template<EObjectType EShaderType>\r
1393 HRESULT SPassBlock::GetShaderDescHelper(D3DX11_PASS_SHADER_DESC *pDesc)\r
1394 {\r
1395     HRESULT hr = S_OK;\r
1396     UINT  i;\r
1397     LPCSTR pFuncName = NULL;\r
1398     SShaderBlock *pShaderBlock = NULL;\r
1399 \r
1400     ApplyPassAssignments();\r
1401 \r
1402     switch (EShaderType)\r
1403     {\r
1404     case EOT_VertexShader:\r
1405     case EOT_VertexShader5:\r
1406 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1407         pFuncName = "ID3DX11EffectPass::GetVertexShaderDesc";\r
1408         pShaderBlock = BackingStore.pVertexShaderBlock;\r
1409         break;\r
1410     case EOT_PixelShader:\r
1411     case EOT_PixelShader5:\r
1412 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1413         pFuncName = "ID3DX11EffectPass::GetPixelShaderDesc";\r
1414         pShaderBlock = BackingStore.pPixelShaderBlock;\r
1415         break;\r
1416     case EOT_GeometryShader:\r
1417     case EOT_GeometryShader5:\r
1418 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1419         pFuncName = "ID3DX11EffectPass::GetGeometryShaderDesc";\r
1420         pShaderBlock = BackingStore.pGeometryShaderBlock;\r
1421         break;\r
1422     case EOT_HullShader5:\r
1423 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1424         pFuncName = "ID3DX11EffectPass::GetHullShaderDesc";\r
1425         pShaderBlock = BackingStore.pHullShaderBlock;\r
1426         break;\r
1427     case EOT_DomainShader5:\r
1428 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1429         pFuncName = "ID3DX11EffectPass::GetDomainShaderDesc";\r
1430         pShaderBlock = BackingStore.pDomainShaderBlock;\r
1431         break;\r
1432     case EOT_ComputeShader5:\r
1433 #pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")\r
1434         pFuncName = "ID3DX11EffectPass::GetComputeShaderDesc";\r
1435         pShaderBlock = BackingStore.pComputeShaderBlock;\r
1436         break;\r
1437     default:\r
1438         D3DXASSERT(0);\r
1439     }\r
1440 \r
1441     VERIFYPARAMETER(pDesc);\r
1442 \r
1443     // in case of error (or in case the assignment doesn't exist), return something reasonable\r
1444     pDesc->pShaderVariable = &g_InvalidShaderVariable;\r
1445     pDesc->ShaderIndex = 0;\r
1446 \r
1447     if (NULL != pShaderBlock)\r
1448     {\r
1449         UINT elements, varCount, anonymousShaderCount;\r
1450         SGlobalVariable *pVariables;\r
1451         SAnonymousShader *pAnonymousShaders;\r
1452 \r
1453         if (pShaderBlock == &g_NullVS)\r
1454         {\r
1455             pDesc->pShaderVariable = &g_AnonymousNullVS;\r
1456             pDesc->ShaderIndex = 0;\r
1457             // we're done\r
1458             goto lExit;\r
1459         }\r
1460         else if (pShaderBlock == &g_NullGS)\r
1461         {\r
1462             pDesc->pShaderVariable = &g_AnonymousNullGS;\r
1463             pDesc->ShaderIndex = 0;\r
1464             // we're done\r
1465             goto lExit;\r
1466         }\r
1467         else if (pShaderBlock == &g_NullPS)\r
1468         {\r
1469             pDesc->pShaderVariable = &g_AnonymousNullPS;\r
1470             pDesc->ShaderIndex = 0;\r
1471             // we're done\r
1472             goto lExit;\r
1473         }\r
1474         else if (pShaderBlock == &g_NullHS)\r
1475         {\r
1476             pDesc->pShaderVariable = &g_AnonymousNullHS;\r
1477             pDesc->ShaderIndex = 0;\r
1478             // we're done\r
1479             goto lExit;\r
1480         }\r
1481         else if (pShaderBlock == &g_NullDS)\r
1482         {\r
1483             pDesc->pShaderVariable = &g_AnonymousNullDS;\r
1484             pDesc->ShaderIndex = 0;\r
1485             // we're done\r
1486             goto lExit;\r
1487         }\r
1488         else if (pShaderBlock == &g_NullCS)\r
1489         {\r
1490             pDesc->pShaderVariable = &g_AnonymousNullCS;\r
1491             pDesc->ShaderIndex = 0;\r
1492             // we're done\r
1493             goto lExit;\r
1494         }\r
1495         else \r
1496         {\r
1497             VB( pEffect->IsRuntimeData(pShaderBlock) );\r
1498             varCount = pEffect->m_VariableCount;\r
1499             pVariables = pEffect->m_pVariables;\r
1500             anonymousShaderCount = pEffect->m_AnonymousShaderCount;\r
1501             pAnonymousShaders = pEffect->m_pAnonymousShaders;\r
1502         }\r
1503 \r
1504         for (i = 0; i < varCount; ++ i)\r
1505         {\r
1506             elements = max(1, pVariables[i].pType->Elements);\r
1507             // make sure the variable type matches, and don't forget about GeometryShaderSO's\r
1508             if (pVariables[i].pType->IsShader())\r
1509             {\r
1510                 if (pShaderBlock >= pVariables[i].Data.pShader && pShaderBlock < pVariables[i].Data.pShader + elements)\r
1511                 {\r
1512                     pDesc->pShaderVariable = (ID3DX11EffectShaderVariable *)(pVariables + i);\r
1513                     pDesc->ShaderIndex = (UINT)(UINT_PTR)(pShaderBlock - pVariables[i].Data.pShader);\r
1514                     // we're done\r
1515                     goto lExit;\r
1516                 }\r
1517             }\r
1518         }\r
1519 \r
1520         for (i = 0; i < anonymousShaderCount; ++ i)\r
1521         {\r
1522             if (pShaderBlock == pAnonymousShaders[i].pShaderBlock)\r
1523             {\r
1524                 VB(EShaderType == pAnonymousShaders[i].pShaderBlock->GetShaderType())\r
1525                 pDesc->pShaderVariable = (pAnonymousShaders + i);\r
1526                 pDesc->ShaderIndex = 0;\r
1527                 // we're done\r
1528                 goto lExit;\r
1529             }\r
1530         }\r
1531 \r
1532         DPF(0, "%s: Internal error; shader not found", pFuncName);\r
1533         VH( E_FAIL );\r
1534     }\r
1535 \r
1536 lExit:\r
1537     return hr;\r
1538 }\r
1539 \r
1540 HRESULT SPassBlock::GetVertexShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1541 {\r
1542     return GetShaderDescHelper<EOT_VertexShader>(pDesc);\r
1543 }\r
1544 \r
1545 HRESULT SPassBlock::GetPixelShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1546 {\r
1547     return GetShaderDescHelper<EOT_PixelShader>(pDesc);\r
1548 }\r
1549 \r
1550 HRESULT SPassBlock::GetGeometryShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1551 {\r
1552     return GetShaderDescHelper<EOT_GeometryShader>(pDesc);\r
1553 }\r
1554 \r
1555 HRESULT SPassBlock::GetHullShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1556 {\r
1557     return GetShaderDescHelper<EOT_HullShader5>(pDesc);\r
1558 }\r
1559 \r
1560 HRESULT SPassBlock::GetDomainShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1561 {\r
1562     return GetShaderDescHelper<EOT_DomainShader5>(pDesc);\r
1563 }\r
1564 \r
1565 HRESULT SPassBlock::GetComputeShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)\r
1566 {\r
1567     return GetShaderDescHelper<EOT_ComputeShader5>(pDesc);\r
1568 }\r
1569 \r
1570 ID3DX11EffectVariable * SPassBlock::GetAnnotationByIndex(UINT  Index)\r
1571 {\r
1572     return GetAnnotationByIndexHelper("ID3DX11EffectPass", Index, AnnotationCount, pAnnotations);\r
1573 }\r
1574 \r
1575 ID3DX11EffectVariable * SPassBlock::GetAnnotationByName(LPCSTR Name)\r
1576 {\r
1577     return GetAnnotationByNameHelper("ID3DX11EffectPass", Name, AnnotationCount, pAnnotations);\r
1578 }\r
1579 \r
1580 HRESULT SPassBlock::Apply(UINT  Flags, ID3D11DeviceContext* pContext)\r
1581 {\r
1582     HRESULT hr = S_OK;\r
1583 \r
1584     // TODO: Flags are not yet implemented    \r
1585 \r
1586     D3DXASSERT( pEffect->m_pContext == NULL );\r
1587     pEffect->m_pContext = pContext;\r
1588     pEffect->ApplyPassBlock(this);\r
1589     pEffect->m_pContext = NULL;\r
1590 \r
1591 lExit:\r
1592     return hr;\r
1593 }\r
1594 \r
1595 HRESULT SPassBlock::ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)\r
1596 {\r
1597     HRESULT hr = S_OK;\r
1598     UINT i, j;\r
1599     \r
1600     // flags indicating whether the following shader types were caught by assignment checks or not\r
1601     BOOL bVS = FALSE, bGS = FALSE, bPS = FALSE, bHS = FALSE, bDS = FALSE, bCS = FALSE;\r
1602 \r
1603     for (i = 0; i < AssignmentCount; ++ i)\r
1604     {\r
1605         BOOL bShader = FALSE;\r
1606         \r
1607         switch (pAssignments[i].LhsType)\r
1608         {\r
1609         case ELHS_VertexShaderBlock:\r
1610             bVS = TRUE;\r
1611             bShader = TRUE;\r
1612             break;\r
1613         case ELHS_GeometryShaderBlock:\r
1614             bGS = TRUE;\r
1615             bShader = TRUE;\r
1616             break;\r
1617         case ELHS_PixelShaderBlock:\r
1618             bPS = TRUE;\r
1619             bShader = TRUE;\r
1620             break;\r
1621         case ELHS_HullShaderBlock:\r
1622             bHS = TRUE;\r
1623             bShader = TRUE;\r
1624             break;\r
1625         case ELHS_DomainShaderBlock:\r
1626             bDS = TRUE;\r
1627             bShader = TRUE;\r
1628             break;\r
1629         case ELHS_ComputeShaderBlock:\r
1630             bCS = TRUE;\r
1631             bShader = TRUE;\r
1632             break;\r
1633 \r
1634         case ELHS_RasterizerBlock:\r
1635             pStateBlockMask->RSRasterizerState = 1;\r
1636             break;\r
1637         case ELHS_BlendBlock:\r
1638             pStateBlockMask->OMBlendState = 1;\r
1639             break;\r
1640         case ELHS_DepthStencilBlock:\r
1641             pStateBlockMask->OMDepthStencilState = 1;\r
1642             break;\r
1643 \r
1644         default:            \r
1645             // ignore this assignment (must be a scalar/vector assignment associated with a state object)\r
1646             break;\r
1647         }\r
1648 \r
1649         if (bShader)\r
1650         {\r
1651             for (j = 0; j < pAssignments[i].MaxElements; ++ j)\r
1652             {\r
1653                 // compute state block mask for the union of ALL shaders\r
1654                 VH( pAssignments[i].Source.pShader[j].ComputeStateBlockMask(pStateBlockMask) );\r
1655             }\r
1656         }\r
1657     }\r
1658 \r
1659     // go over the state block objects in case there was no corresponding assignment\r
1660     if (NULL != BackingStore.pRasterizerBlock)\r
1661     {\r
1662         pStateBlockMask->RSRasterizerState = 1;\r
1663     }\r
1664     if (NULL != BackingStore.pBlendBlock)\r
1665     {\r
1666         pStateBlockMask->OMBlendState = 1;\r
1667     }\r
1668     if (NULL != BackingStore.pDepthStencilBlock)\r
1669     {\r
1670         pStateBlockMask->OMDepthStencilState = 1;\r
1671     }\r
1672 \r
1673     // go over the shaders only if an assignment didn't already catch them\r
1674     if (FALSE == bVS && NULL != BackingStore.pVertexShaderBlock)\r
1675     {\r
1676         VH( BackingStore.pVertexShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1677     }\r
1678     if (FALSE == bGS && NULL != BackingStore.pGeometryShaderBlock)\r
1679     {\r
1680         VH( BackingStore.pGeometryShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1681     }\r
1682     if (FALSE == bPS && NULL != BackingStore.pPixelShaderBlock)\r
1683     {\r
1684         VH( BackingStore.pPixelShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1685     }\r
1686     if (FALSE == bHS && NULL != BackingStore.pHullShaderBlock)\r
1687     {\r
1688         VH( BackingStore.pHullShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1689     }\r
1690     if (FALSE == bDS && NULL != BackingStore.pDomainShaderBlock)\r
1691     {\r
1692         VH( BackingStore.pDomainShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1693     }\r
1694     if (FALSE == bCS && NULL != BackingStore.pComputeShaderBlock)\r
1695     {\r
1696         VH( BackingStore.pComputeShaderBlock->ComputeStateBlockMask(pStateBlockMask) );\r
1697     }\r
1698     \r
1699 lExit:\r
1700     return hr;\r
1701 }\r
1702 \r
1703 //////////////////////////////////////////////////////////////////////////\r
1704 // ID3DX11EffectTechnique (STechnique implementation)\r
1705 //////////////////////////////////////////////////////////////////////////\r
1706 \r
1707 BOOL STechnique::IsValid()\r
1708 { \r
1709     if( HasDependencies )\r
1710     {\r
1711         for( UINT i = 0; i < PassCount; i++ )\r
1712         {\r
1713             if( !((SPassBlock*)pPasses)[i].IsValid() )\r
1714                 return FALSE;\r
1715         }\r
1716         return TRUE;\r
1717     }\r
1718     return InitiallyValid;\r
1719 }\r
1720 \r
1721 HRESULT STechnique::GetDesc(D3DX11_TECHNIQUE_DESC *pDesc)\r
1722 {\r
1723     HRESULT hr = S_OK;\r
1724 \r
1725     LPCSTR pFuncName = "ID3DX11EffectTechnique::GetDesc";\r
1726 \r
1727     VERIFYPARAMETER(pDesc);\r
1728 \r
1729     pDesc->Name = pName;\r
1730     pDesc->Annotations = AnnotationCount;\r
1731     pDesc->Passes = PassCount;\r
1732 \r
1733 lExit:\r
1734     return hr;\r
1735 }\r
1736 \r
1737 ID3DX11EffectVariable * STechnique::GetAnnotationByIndex(UINT  Index)\r
1738 {\r
1739     return GetAnnotationByIndexHelper("ID3DX11EffectTechnique", Index, AnnotationCount, pAnnotations);\r
1740 }\r
1741 \r
1742 ID3DX11EffectVariable * STechnique::GetAnnotationByName(LPCSTR Name)\r
1743 {\r
1744     return GetAnnotationByNameHelper("ID3DX11EffectTechnique", Name, AnnotationCount, pAnnotations);\r
1745 }\r
1746 \r
1747 ID3DX11EffectPass * STechnique::GetPassByIndex(UINT  Index)\r
1748 {\r
1749     LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByIndex";\r
1750 \r
1751     if (Index >= PassCount)\r
1752     {\r
1753         DPF(0, "%s: Invalid pass index (%d, total: %d)", pFuncName, Index, PassCount);\r
1754         return &g_InvalidPass;\r
1755     }\r
1756 \r
1757     return (ID3DX11EffectPass *)(pPasses + Index);\r
1758 }\r
1759 \r
1760 ID3DX11EffectPass * STechnique::GetPassByName(LPCSTR Name)\r
1761 {\r
1762     LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByName";\r
1763 \r
1764     UINT  i;\r
1765 \r
1766     for (i = 0; i < PassCount; ++ i)\r
1767     {\r
1768         if (NULL != pPasses[i].pName &&\r
1769             strcmp(pPasses[i].pName, Name) == 0)\r
1770         {\r
1771             break;\r
1772         }\r
1773     }\r
1774 \r
1775     if (i == PassCount)\r
1776     {\r
1777         DPF(0, "%s: Pass [%s] not found", pFuncName, Name);\r
1778         return &g_InvalidPass;\r
1779     }\r
1780 \r
1781     return (ID3DX11EffectPass *)(pPasses + i);\r
1782 }\r
1783 \r
1784 HRESULT STechnique::ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)\r
1785 {\r
1786     HRESULT hr = S_OK;\r
1787     UINT i;\r
1788 \r
1789     for (i = 0; i < PassCount; ++ i)\r
1790     {\r
1791         VH( ((SPassBlock*)pPasses)[i].ComputeStateBlockMask(pStateBlockMask) );\r
1792     }\r
1793 \r
1794 lExit:\r
1795     return hr;\r
1796 }\r
1797 \r
1798 //////////////////////////////////////////////////////////////////////////\r
1799 // ID3DX11EffectGroup (SGroup implementation)\r
1800 //////////////////////////////////////////////////////////////////////////\r
1801 \r
1802 BOOL SGroup::IsValid()\r
1803 { \r
1804     if( HasDependencies )\r
1805     {\r
1806         for( UINT i = 0; i < TechniqueCount; i++ )\r
1807         {\r
1808             if( !((STechnique*)pTechniques)[i].IsValid() )\r
1809                 return FALSE;\r
1810         }\r
1811         return TRUE;\r
1812     }\r
1813     return InitiallyValid;\r
1814 }\r
1815 \r
1816 HRESULT SGroup::GetDesc(D3DX11_GROUP_DESC *pDesc)\r
1817 {\r
1818     HRESULT hr = S_OK;\r
1819 \r
1820     LPCSTR pFuncName = "ID3DX11EffectGroup::GetDesc";\r
1821 \r
1822     VERIFYPARAMETER(pDesc);\r
1823 \r
1824     pDesc->Name = pName;\r
1825     pDesc->Annotations = AnnotationCount;\r
1826     pDesc->Techniques = TechniqueCount;\r
1827 \r
1828 lExit:\r
1829     return hr;\r
1830 }\r
1831 \r
1832 ID3DX11EffectVariable * SGroup::GetAnnotationByIndex(UINT  Index)\r
1833 {\r
1834     return GetAnnotationByIndexHelper("ID3DX11EffectGroup", Index, AnnotationCount, pAnnotations);\r
1835 }\r
1836 \r
1837 ID3DX11EffectVariable * SGroup::GetAnnotationByName(LPCSTR Name)\r
1838 {\r
1839     return GetAnnotationByNameHelper("ID3DX11EffectGroup", Name, AnnotationCount, pAnnotations);\r
1840 }\r
1841 \r
1842 ID3DX11EffectTechnique * SGroup::GetTechniqueByIndex(UINT  Index)\r
1843 {\r
1844     LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByIndex";\r
1845 \r
1846     if (Index >= TechniqueCount)\r
1847     {\r
1848         DPF(0, "%s: Invalid pass index (%d, total: %d)", pFuncName, Index, TechniqueCount);\r
1849         return &g_InvalidTechnique;\r
1850     }\r
1851 \r
1852     return (ID3DX11EffectTechnique *)(pTechniques + Index);\r
1853 }\r
1854 \r
1855 ID3DX11EffectTechnique * SGroup::GetTechniqueByName(LPCSTR Name)\r
1856 {\r
1857     LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByName";\r
1858 \r
1859     UINT  i;\r
1860 \r
1861     for (i = 0; i < TechniqueCount; ++ i)\r
1862     {\r
1863         if (NULL != pTechniques[i].pName &&\r
1864             strcmp(pTechniques[i].pName, Name) == 0)\r
1865         {\r
1866             break;\r
1867         }\r
1868     }\r
1869 \r
1870     if (i == TechniqueCount)\r
1871     {\r
1872         DPF(0, "%s: Technique [%s] not found", pFuncName, Name);\r
1873         return &g_InvalidTechnique;\r
1874     }\r
1875 \r
1876     return (ID3DX11EffectTechnique *)(pTechniques + i);\r
1877 }\r
1878 \r
1879 //////////////////////////////////////////////////////////////////////////\r
1880 // ID3DX11Effect Public Reflection APIs (CEffect)\r
1881 //////////////////////////////////////////////////////////////////////////\r
1882 \r
1883 HRESULT CEffect::GetDevice(ID3D11Device **ppDevice)\r
1884 {\r
1885     HRESULT hr = S_OK;\r
1886     LPCSTR pFuncName = "ID3DX11Effect::GetDevice";\r
1887     VERIFYPARAMETER(ppDevice);\r
1888 \r
1889     m_pDevice->AddRef();\r
1890     *ppDevice = m_pDevice;\r
1891 \r
1892 lExit:\r
1893     return hr;\r
1894 }\r
1895 \r
1896 HRESULT CEffect::GetDesc(D3DX11_EFFECT_DESC *pDesc)\r
1897 {\r
1898     HRESULT hr = S_OK;\r
1899 \r
1900     LPCSTR pFuncName = "ID3DX11Effect::GetDesc";\r
1901 \r
1902     VERIFYPARAMETER(pDesc);\r
1903 \r
1904     pDesc->ConstantBuffers = m_CBCount;\r
1905     pDesc->GlobalVariables = m_VariableCount;\r
1906     pDesc->Techniques = m_TechniqueCount;\r
1907     pDesc->Groups = m_GroupCount;\r
1908     pDesc->InterfaceVariables = m_InterfaceCount;\r
1909 \r
1910 lExit:\r
1911     return hr;    \r
1912 }\r
1913 \r
1914 ID3DX11EffectConstantBuffer * CEffect::GetConstantBufferByIndex(UINT  Index)\r
1915 {\r
1916     LPCSTR pFuncName = "ID3DX11Effect::GetConstantBufferByIndex";\r
1917 \r
1918     if (Index < m_CBCount)\r
1919     {\r
1920         return m_pCBs + Index;\r
1921     }\r
1922 \r
1923     DPF(0, "%s: Invalid constant buffer index", pFuncName);\r
1924     return &g_InvalidConstantBuffer;\r
1925 }\r
1926 \r
1927 ID3DX11EffectConstantBuffer * CEffect::GetConstantBufferByName(LPCSTR Name)\r
1928 {\r
1929     HRESULT hr = S_OK;\r
1930     LPCSTR pFuncName = "ID3DX11Effect::GetConstantBufferByName";\r
1931 \r
1932     if (IsOptimized())\r
1933     {\r
1934         DPF(0, "%s: Cannot get constant buffer interfaces by name since the effect has been Optimize()'ed", pFuncName);\r
1935         return &g_InvalidConstantBuffer;\r
1936     }\r
1937 \r
1938     if (NULL == Name)\r
1939     {\r
1940         DPF(0, "%s: Parameter Name was NULL.", pFuncName);\r
1941         return &g_InvalidConstantBuffer;\r
1942     }\r
1943 \r
1944     UINT  i;\r
1945 \r
1946     for (i = 0; i < m_CBCount; ++ i)\r
1947     {\r
1948         if (strcmp(m_pCBs[i].pName, Name) == 0)\r
1949         {\r
1950             return m_pCBs + i;\r
1951         }\r
1952     }\r
1953 \r
1954     DPF(0, "%s: Constant Buffer [%s] not found", pFuncName, Name);\r
1955     return &g_InvalidConstantBuffer;\r
1956 }\r
1957 \r
1958 ID3DX11EffectVariable * CEffect::GetVariableByIndex(UINT  Index)\r
1959 {\r
1960     LPCSTR pFuncName = "ID3DX11Effect::GetVariableByIndex";\r
1961 \r
1962     if (Index < m_VariableCount)\r
1963     {\r
1964         return m_pVariables + Index;\r
1965     }\r
1966 \r
1967     DPF(0, "%s: Invalid variable index", pFuncName);\r
1968     return &g_InvalidScalarVariable;\r
1969 }\r
1970 \r
1971 ID3DX11EffectVariable * CEffect::GetVariableByName(LPCSTR Name)\r
1972 {\r
1973     HRESULT hr = S_OK;\r
1974     LPCSTR pFuncName = "ID3DX11Effect::GetVariableByName";\r
1975 \r
1976     if (IsOptimized())\r
1977     {\r
1978         DPF(0, "%s: Cannot get variable interfaces by name since the effect has been Optimize()'ed", pFuncName);\r
1979         return &g_InvalidScalarVariable;\r
1980     }\r
1981 \r
1982     if (NULL == Name)\r
1983     {\r
1984         DPF(0, "%s: Parameter Name was NULL.", pFuncName);\r
1985         return &g_InvalidScalarVariable;\r
1986     }\r
1987 \r
1988     UINT  i;\r
1989 \r
1990     for (i = 0; i < m_VariableCount; ++ i)\r
1991     {\r
1992         if (strcmp(m_pVariables[i].pName, Name) == 0)\r
1993         {\r
1994             return m_pVariables + i;\r
1995         }\r
1996     }\r
1997 \r
1998     DPF(0, "%s: Variable [%s] not found", pFuncName, Name);\r
1999     return &g_InvalidScalarVariable;\r
2000 }\r
2001 \r
2002 ID3DX11EffectVariable * CEffect::GetVariableBySemantic(LPCSTR Semantic)\r
2003 {    \r
2004     LPCSTR pFuncName = "ID3DX11Effect::GetVariableBySemantic";\r
2005 \r
2006     if (IsOptimized())\r
2007     {\r
2008         DPF(0, "%s: Cannot get variable interfaces by semantic since the effect has been Optimize()'ed", pFuncName);\r
2009         return &g_InvalidScalarVariable;\r
2010     }\r
2011 \r
2012     if (NULL == Semantic)\r
2013     {\r
2014         DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);\r
2015         return &g_InvalidScalarVariable;\r
2016     }\r
2017 \r
2018     UINT  i;\r
2019 \r
2020     for (i = 0; i < m_VariableCount; ++ i)\r
2021     {\r
2022         if (NULL != m_pVariables[i].pSemantic && \r
2023             _stricmp(m_pVariables[i].pSemantic, Semantic) == 0)\r
2024         {\r
2025             return (ID3DX11EffectVariable *)(m_pVariables + i);\r
2026         }\r
2027     }\r
2028 \r
2029     DPF(0, "%s: Variable with semantic [%s] not found", pFuncName, Semantic);\r
2030     return &g_InvalidScalarVariable;\r
2031 }\r
2032 \r
2033 ID3DX11EffectTechnique * CEffect::GetTechniqueByIndex(UINT  Index)\r
2034 {\r
2035     LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByIndex";\r
2036 \r
2037     if( Index < m_TechniqueCount )\r
2038     {\r
2039         UINT i;\r
2040         for( i=0; i < m_GroupCount; i++ )\r
2041         {\r
2042             if( Index < m_pGroups[i].TechniqueCount )\r
2043             {\r
2044                 return (ID3DX11EffectTechnique *)(m_pGroups[i].pTechniques + Index);\r
2045             }\r
2046             Index -= m_pGroups[i].TechniqueCount;\r
2047         }\r
2048         D3DXASSERT( FALSE );\r
2049     }\r
2050     DPF(0, "%s: Invalid technique index (%d)", pFuncName, Index);\r
2051     return &g_InvalidTechnique;\r
2052 }\r
2053 \r
2054 ID3DX11EffectTechnique * CEffect::GetTechniqueByName(LPCSTR Name)\r
2055 {\r
2056     HRESULT hr = S_OK;\r
2057     LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByName";\r
2058     const UINT MAX_GROUP_TECHNIQUE_SIZE = 256;\r
2059     char NameCopy[MAX_GROUP_TECHNIQUE_SIZE];\r
2060 \r
2061     if (IsOptimized())\r
2062     {\r
2063         DPF(0, "ID3DX11Effect::GetTechniqueByName: Cannot get technique interfaces by name since the effect has been Optimize()'ed");\r
2064         return &g_InvalidTechnique;\r
2065     }\r
2066 \r
2067     if (NULL == Name)\r
2068     {\r
2069         DPF(0, "%s: Parameter Name was NULL.", pFuncName);\r
2070         return &g_InvalidTechnique;\r
2071     }\r
2072 \r
2073     if( FAILED( StringCchCopyA( NameCopy, MAX_GROUP_TECHNIQUE_SIZE, Name ) ) )\r
2074     {\r
2075         DPF( 0, "Group|Technique name has a length greater than %d.", MAX_GROUP_TECHNIQUE_SIZE );\r
2076         return &g_InvalidTechnique;\r
2077     }\r
2078 \r
2079     char* pDelimiter = strchr( NameCopy, '|' );\r
2080     if( pDelimiter == NULL )\r
2081     {\r
2082         if ( m_pNullGroup == NULL )\r
2083         {\r
2084             DPF( 0, "The effect contains no default group." );\r
2085             return &g_InvalidTechnique;\r
2086         }\r
2087 \r
2088         return m_pNullGroup->GetTechniqueByName( Name );\r
2089     }\r
2090 \r
2091     // separate group name and technique name\r
2092     *pDelimiter = 0; \r
2093 \r
2094     return GetGroupByName( NameCopy )->GetTechniqueByName( pDelimiter + 1 );\r
2095 }\r
2096 \r
2097 ID3D11ClassLinkage * CEffect::GetClassLinkage()\r
2098 {\r
2099     SAFE_ADDREF( m_pClassLinkage );\r
2100     return m_pClassLinkage;\r
2101 }\r
2102 \r
2103 ID3DX11EffectGroup * CEffect::GetGroupByIndex(UINT  Index)\r
2104 {\r
2105     LPCSTR pFuncName = "ID3DX11Effect::GetGroupByIndex";\r
2106 \r
2107     if( Index < m_GroupCount )\r
2108     {\r
2109         return (ID3DX11EffectGroup *)(m_pGroups + Index);\r
2110     }\r
2111     DPF(0, "%s: Invalid group index (%d)", pFuncName, Index);\r
2112     return &g_InvalidGroup;\r
2113 }\r
2114 \r
2115 ID3DX11EffectGroup * CEffect::GetGroupByName(LPCSTR Name)\r
2116 {\r
2117     HRESULT hr = S_OK;\r
2118     LPCSTR pFuncName = "ID3DX11Effect::GetGroupByName";\r
2119 \r
2120     if (IsOptimized())\r
2121     {\r
2122         DPF(0, "ID3DX11Effect::GetGroupByName: Cannot get group interfaces by name since the effect has been Optimize()'ed");\r
2123         return &g_InvalidGroup;\r
2124     }\r
2125 \r
2126     if (NULL == Name || Name[0] == 0 )\r
2127     {\r
2128         return m_pNullGroup ? (ID3DX11EffectGroup *)m_pNullGroup : &g_InvalidGroup;\r
2129     }\r
2130 \r
2131     UINT  i;\r
2132 \r
2133     for (i = 0; i < m_GroupCount; ++ i)\r
2134     {\r
2135         if (NULL != m_pGroups[i].pName && \r
2136             strcmp(m_pGroups[i].pName, Name) == 0)\r
2137         {\r
2138             break;\r
2139         }\r
2140     }\r
2141 \r
2142     if (i == m_GroupCount)\r
2143     {\r
2144         DPF(0, "%s: Group [%s] not found", pFuncName, Name);\r
2145         return &g_InvalidGroup;\r
2146     }\r
2147 \r
2148     return (ID3DX11EffectGroup *)(m_pGroups + i);\r
2149 }\r
2150 \r
2151 }\r