--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectBinaryFormat.h
+//
+// Direct3D11 Effects Binary Format
+// This is the binary file interface shared between the Effects
+// compiler and runtime.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+namespace D3DX11Effects
+{
+
+//////////////////////////////////////////////////////////////////////////
+// Version Control
+//////////////////////////////////////////////////////////////////////////
+
+#define D3DX11_FXL_VERSION(_Major,_Minor) (('F' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))
+
+struct EVersionTag
+{
+ const char* m_pName;
+ DWORD m_Version;
+ uint32_t m_Tag;
+};
+
+// versions must be listed in ascending order
+static const EVersionTag g_EffectVersions[] =
+{
+ { "fx_4_0", D3DX11_FXL_VERSION(4,0), 0xFEFF1001 },
+ { "fx_4_1", D3DX11_FXL_VERSION(4,1), 0xFEFF1011 },
+ { "fx_5_0", D3DX11_FXL_VERSION(5,0), 0xFEFF2001 },
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// Reflection & Type structures
+//////////////////////////////////////////////////////////////////////////
+
+// Enumeration of the possible left-hand side values of an assignment,
+// divided up categorically by the type of block they may appear in
+enum ELhsType
+{
+ ELHS_Invalid,
+
+ // Pass block assignment types
+
+ ELHS_PixelShaderBlock, // SBlock *pValue points to the block to apply
+ ELHS_VertexShaderBlock,
+ ELHS_GeometryShaderBlock,
+ ELHS_RenderTargetView,
+ ELHS_DepthStencilView,
+
+ ELHS_RasterizerBlock,
+ ELHS_DepthStencilBlock,
+ ELHS_BlendBlock,
+
+ ELHS_GenerateMips, // This is really a call to D3D::GenerateMips
+
+ // Various SAssignment.Value.*
+
+ ELHS_DS_StencilRef, // SAssignment.Value.pdValue
+ ELHS_B_BlendFactor, // D3D11_BLEND_CONFIG.BlendFactor, points to a float4
+ ELHS_B_SampleMask, // D3D11_BLEND_CONFIG.SampleMask
+
+ ELHS_GeometryShaderSO, // When setting SO assignments, GeometryShaderSO precedes the actual GeometryShader assn
+
+ ELHS_ComputeShaderBlock,
+ ELHS_HullShaderBlock,
+ ELHS_DomainShaderBlock,
+
+ // Rasterizer
+
+ ELHS_FillMode = 0x20000,
+ ELHS_CullMode,
+ ELHS_FrontCC,
+ ELHS_DepthBias,
+ ELHS_DepthBiasClamp,
+ ELHS_SlopeScaledDepthBias,
+ ELHS_DepthClipEnable,
+ ELHS_ScissorEnable,
+ ELHS_MultisampleEnable,
+ ELHS_AntialiasedLineEnable,
+
+ // Sampler
+
+ ELHS_Filter = 0x30000,
+ ELHS_AddressU,
+ ELHS_AddressV,
+ ELHS_AddressW,
+ ELHS_MipLODBias,
+ ELHS_MaxAnisotropy,
+ ELHS_ComparisonFunc,
+ ELHS_BorderColor,
+ ELHS_MinLOD,
+ ELHS_MaxLOD,
+ ELHS_Texture,
+
+ // DepthStencil
+
+ ELHS_DepthEnable = 0x40000,
+ ELHS_DepthWriteMask,
+ ELHS_DepthFunc,
+ ELHS_StencilEnable,
+ ELHS_StencilReadMask,
+ ELHS_StencilWriteMask,
+ ELHS_FrontFaceStencilFailOp,
+ ELHS_FrontFaceStencilDepthFailOp,
+ ELHS_FrontFaceStencilPassOp,
+ ELHS_FrontFaceStencilFunc,
+ ELHS_BackFaceStencilFailOp,
+ ELHS_BackFaceStencilDepthFailOp,
+ ELHS_BackFaceStencilPassOp,
+ ELHS_BackFaceStencilFunc,
+
+ // BlendState
+
+ ELHS_AlphaToCoverage = 0x50000,
+ ELHS_BlendEnable,
+ ELHS_SrcBlend,
+ ELHS_DestBlend,
+ ELHS_BlendOp,
+ ELHS_SrcBlendAlpha,
+ ELHS_DestBlendAlpha,
+ ELHS_BlendOpAlpha,
+ ELHS_RenderTargetWriteMask,
+};
+
+enum EBlockType
+{
+ EBT_Invalid,
+ EBT_DepthStencil,
+ EBT_Blend,
+ EBT_Rasterizer,
+ EBT_Sampler,
+ EBT_Pass
+};
+
+enum EVarType
+{
+ EVT_Invalid,
+ EVT_Numeric,
+ EVT_Object,
+ EVT_Struct,
+ EVT_Interface,
+};
+
+enum EScalarType
+{
+ EST_Invalid,
+ EST_Float,
+ EST_Int,
+ EST_UInt,
+ EST_Bool,
+ EST_Count
+};
+
+enum ENumericLayout
+{
+ ENL_Invalid,
+ ENL_Scalar,
+ ENL_Vector,
+ ENL_Matrix,
+ ENL_Count
+};
+
+enum EObjectType
+{
+ EOT_Invalid,
+ EOT_String,
+ EOT_Blend,
+ EOT_DepthStencil,
+ EOT_Rasterizer,
+ EOT_PixelShader,
+ EOT_VertexShader,
+ EOT_GeometryShader, // Regular geometry shader
+ EOT_GeometryShaderSO, // Geometry shader with a attached StreamOut decl
+ EOT_Texture,
+ EOT_Texture1D,
+ EOT_Texture1DArray,
+ EOT_Texture2D,
+ EOT_Texture2DArray,
+ EOT_Texture2DMS,
+ EOT_Texture2DMSArray,
+ EOT_Texture3D,
+ EOT_TextureCube,
+ EOT_ConstantBuffer,
+ EOT_RenderTargetView,
+ EOT_DepthStencilView,
+ EOT_Sampler,
+ EOT_Buffer,
+ EOT_TextureCubeArray,
+ EOT_Count,
+ EOT_PixelShader5,
+ EOT_VertexShader5,
+ EOT_GeometryShader5,
+ EOT_ComputeShader5,
+ EOT_HullShader5,
+ EOT_DomainShader5,
+ EOT_RWTexture1D,
+ EOT_RWTexture1DArray,
+ EOT_RWTexture2D,
+ EOT_RWTexture2DArray,
+ EOT_RWTexture3D,
+ EOT_RWBuffer,
+ EOT_ByteAddressBuffer,
+ EOT_RWByteAddressBuffer,
+ EOT_StructuredBuffer,
+ EOT_RWStructuredBuffer,
+ EOT_RWStructuredBufferAlloc,
+ EOT_RWStructuredBufferConsume,
+ EOT_AppendStructuredBuffer,
+ EOT_ConsumeStructuredBuffer,
+};
+
+inline bool IsObjectTypeHelper(EVarType InVarType,
+ EObjectType InObjType,
+ EObjectType TargetObjType)
+{
+ return (InVarType == EVT_Object) && (InObjType == TargetObjType);
+}
+
+inline bool IsSamplerHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && (InObjType == EOT_Sampler);
+}
+
+inline bool IsStateBlockObjectHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && ((InObjType == EOT_Blend) || (InObjType == EOT_DepthStencil) || (InObjType == EOT_Rasterizer) || IsSamplerHelper(InVarType, InObjType));
+}
+
+inline bool IsShaderHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && ((InObjType == EOT_VertexShader) ||
+ (InObjType == EOT_VertexShader5) ||
+ (InObjType == EOT_HullShader5) ||
+ (InObjType == EOT_DomainShader5) ||
+ (InObjType == EOT_ComputeShader5) ||
+ (InObjType == EOT_GeometryShader) ||
+ (InObjType == EOT_GeometryShaderSO) ||
+ (InObjType == EOT_GeometryShader5) ||
+ (InObjType == EOT_PixelShader) ||
+ (InObjType == EOT_PixelShader5));
+}
+
+inline bool IsShader5Helper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && ((InObjType == EOT_VertexShader5) ||
+ (InObjType == EOT_HullShader5) ||
+ (InObjType == EOT_DomainShader5) ||
+ (InObjType == EOT_ComputeShader5) ||
+ (InObjType == EOT_GeometryShader5) ||
+ (InObjType == EOT_PixelShader5));
+}
+
+inline bool IsInterfaceHelper(EVarType InVarType, EObjectType InObjType)
+{
+ UNREFERENCED_PARAMETER(InObjType);
+ return (InVarType == EVT_Interface);
+}
+
+inline bool IsShaderResourceHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && ((InObjType == EOT_Texture) ||
+ (InObjType == EOT_Texture1D) ||
+ (InObjType == EOT_Texture1DArray) ||
+ (InObjType == EOT_Texture2D) ||
+ (InObjType == EOT_Texture2DArray) ||
+ (InObjType == EOT_Texture2DMS) ||
+ (InObjType == EOT_Texture2DMSArray) ||
+ (InObjType == EOT_Texture3D) ||
+ (InObjType == EOT_TextureCube) ||
+ (InObjType == EOT_TextureCubeArray) ||
+ (InObjType == EOT_Buffer) ||
+ (InObjType == EOT_StructuredBuffer) ||
+ (InObjType == EOT_ByteAddressBuffer));
+}
+
+inline bool IsUnorderedAccessViewHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) &&
+ ((InObjType == EOT_RWTexture1D) ||
+ (InObjType == EOT_RWTexture1DArray) ||
+ (InObjType == EOT_RWTexture2D) ||
+ (InObjType == EOT_RWTexture2DArray) ||
+ (InObjType == EOT_RWTexture3D) ||
+ (InObjType == EOT_RWBuffer) ||
+ (InObjType == EOT_RWByteAddressBuffer) ||
+ (InObjType == EOT_RWStructuredBuffer) ||
+ (InObjType == EOT_RWStructuredBufferAlloc) ||
+ (InObjType == EOT_RWStructuredBufferConsume) ||
+ (InObjType == EOT_AppendStructuredBuffer) ||
+ (InObjType == EOT_ConsumeStructuredBuffer));
+}
+
+inline bool IsRenderTargetViewHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && (InObjType == EOT_RenderTargetView);
+}
+
+inline bool IsDepthStencilViewHelper(EVarType InVarType,
+ EObjectType InObjType)
+{
+ return (InVarType == EVT_Object) && (InObjType == EOT_DepthStencilView);
+}
+
+inline bool IsObjectAssignmentHelper(ELhsType LhsType)
+{
+ switch(LhsType)
+ {
+ case ELHS_VertexShaderBlock:
+ case ELHS_HullShaderBlock:
+ case ELHS_DepthStencilView:
+ case ELHS_GeometryShaderBlock:
+ case ELHS_PixelShaderBlock:
+ case ELHS_ComputeShaderBlock:
+ case ELHS_DepthStencilBlock:
+ case ELHS_RasterizerBlock:
+ case ELHS_BlendBlock:
+ case ELHS_Texture:
+ case ELHS_RenderTargetView:
+ case ELHS_DomainShaderBlock:
+ return true;
+ }
+ return false;
+}
+
+
+
+
+// Effect file format structures /////////////////////////////////////////////
+// File format:
+// File header (SBinaryHeader Header)
+// Unstructured data block (uint8_t[Header.cbUnstructured))
+// Structured data block
+// ConstantBuffer (SBinaryConstantBuffer CB) * Header.Effect.cCBs
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Variable data (SBinaryNumericVariable Var) * (CB.cVariables)
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Object variables (SBinaryObjectVariable Var) * (Header.cObjectVariables) *this structure is variable sized
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Interface variables (SBinaryInterfaceVariable Var) * (Header.cInterfaceVariables) *this structure is variable sized
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Groups (SBinaryGroup Group) * Header.cGroups
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Techniques (SBinaryTechnique Technique) * Group.cTechniques
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Pass (SBinaryPass Pass) * Technique.cPasses
+// uint32_t NumAnnotations
+// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
+// Pass assignments (SBinaryAssignment) * Pass.cAssignments
+
+struct SBinaryHeader
+{
+ struct SVarCounts
+ {
+ uint32_t cCBs;
+ uint32_t cNumericVariables;
+ uint32_t cObjectVariables;
+ };
+
+ uint32_t Tag; // should be equal to c_EffectFileTag
+ // this is used to identify ASCII vs Binary files
+
+ SVarCounts Effect;
+ SVarCounts Pool;
+
+ uint32_t cTechniques;
+ uint32_t cbUnstructured;
+
+ uint32_t cStrings;
+ uint32_t cShaderResources;
+
+ uint32_t cDepthStencilBlocks;
+ uint32_t cBlendStateBlocks;
+ uint32_t cRasterizerStateBlocks;
+ uint32_t cSamplers;
+ uint32_t cRenderTargetViews;
+ uint32_t cDepthStencilViews;
+
+ uint32_t cTotalShaders;
+ uint32_t cInlineShaders; // of the aforementioned shaders, the number that are defined inline within pass blocks
+
+ inline bool RequiresPool() const
+ {
+ return (Pool.cCBs != 0) ||
+ (Pool.cNumericVariables != 0) ||
+ (Pool.cObjectVariables != 0);
+ }
+};
+
+struct SBinaryHeader5 : public SBinaryHeader
+{
+ uint32_t cGroups;
+ uint32_t cUnorderedAccessViews;
+ uint32_t cInterfaceVariables;
+ uint32_t cInterfaceVariableElements;
+ uint32_t cClassInstanceElements;
+};
+
+// Constant buffer definition
+struct SBinaryConstantBuffer
+{
+ // private flags
+ static const uint32_t c_IsTBuffer = (1 << 0);
+ static const uint32_t c_IsSingle = (1 << 1);
+
+ uint32_t oName; // Offset to constant buffer name
+ uint32_t Size; // Size, in bytes
+ uint32_t Flags;
+ uint32_t cVariables; // # of variables inside this buffer
+ uint32_t ExplicitBindPoint; // Defined if the effect file specifies a bind point using the register keyword
+ // otherwise, -1
+};
+
+struct SBinaryAnnotation
+{
+ uint32_t oName; // Offset to variable name
+ uint32_t oType; // Offset to type information (SBinaryType)
+
+ // For numeric annotations:
+ // uint32_t oDefaultValue; // Offset to default initializer value
+ //
+ // For string annotations:
+ // uint32_t oStringOffsets[Elements]; // Elements comes from the type data at oType
+};
+
+struct SBinaryNumericVariable
+{
+ uint32_t oName; // Offset to variable name
+ uint32_t oType; // Offset to type information (SBinaryType)
+ uint32_t oSemantic; // Offset to semantic information
+ uint32_t Offset; // Offset in parent constant buffer
+ uint32_t oDefaultValue; // Offset to default initializer value
+ uint32_t Flags; // Explicit bind point
+};
+
+struct SBinaryInterfaceVariable
+{
+ uint32_t oName; // Offset to variable name
+ uint32_t oType; // Offset to type information (SBinaryType)
+ uint32_t oDefaultValue; // Offset to default initializer array (SBinaryInterfaceInitializer[Elements])
+ uint32_t Flags;
+};
+
+struct SBinaryInterfaceInitializer
+{
+ uint32_t oInstanceName;
+ uint32_t ArrayIndex;
+};
+
+struct SBinaryObjectVariable
+{
+ uint32_t oName; // Offset to variable name
+ uint32_t oType; // Offset to type information (SBinaryType)
+ uint32_t oSemantic; // Offset to semantic information
+ uint32_t ExplicitBindPoint; // Used when a variable has been explicitly bound (register(XX)). -1 if not
+
+ // Initializer data:
+ //
+ // The type structure pointed to by oType gives you Elements,
+ // VarType (must be EVT_Object), and ObjectType
+ //
+ // For ObjectType == EOT_Blend, EOT_DepthStencil, EOT_Rasterizer, EOT_Sampler
+ // struct
+ // {
+ // uint32_t cAssignments;
+ // SBinaryAssignment Assignments[cAssignments];
+ // } Blocks[Elements]
+ //
+ // For EObjectType == EOT_Texture*, EOT_Buffer
+ // <nothing>
+ //
+ // For EObjectType == EOT_*Shader, EOT_String
+ // uint32_t oData[Elements]; // offsets to a shader data block or a nullptr-terminated string
+ //
+ // For EObjectType == EOT_GeometryShaderSO
+ // SBinaryGSSOInitializer[Elements]
+ //
+ // For EObjectType == EOT_*Shader5
+ // SBinaryShaderData5[Elements]
+};
+
+struct SBinaryGSSOInitializer
+{
+ uint32_t oShader; // Offset to shader bytecode data block
+ uint32_t oSODecl; // Offset to StreamOutput decl string
+};
+
+struct SBinaryShaderData5
+{
+ uint32_t oShader; // Offset to shader bytecode data block
+ uint32_t oSODecls[4]; // Offset to StreamOutput decl strings
+ uint32_t cSODecls; // Count of valid oSODecls entries.
+ uint32_t RasterizedStream; // Which stream is used for rasterization
+ uint32_t cInterfaceBindings; // Count of interface bindings.
+ uint32_t oInterfaceBindings; // Offset to SBinaryInterfaceInitializer[cInterfaceBindings].
+};
+
+struct SBinaryType
+{
+ uint32_t oTypeName; // Offset to friendly type name ("float4", "VS_OUTPUT")
+ EVarType VarType; // Numeric, Object, or Struct
+ uint32_t Elements; // # of array elements (0 for non-arrays)
+ uint32_t TotalSize; // Size in bytes; not necessarily Stride * Elements for arrays
+ // because of possible gap left in final register
+ uint32_t Stride; // If an array, this is the spacing between elements.
+ // For unpacked arrays, always divisible by 16-bytes (1 register).
+ // No support for packed arrays
+ uint32_t PackedSize; // Size, in bytes, of this data typed when fully packed
+
+ struct SBinaryMember
+ {
+ uint32_t oName; // Offset to structure member name ("m_pFoo")
+ uint32_t oSemantic; // Offset to semantic ("POSITION0")
+ uint32_t Offset; // Offset, in bytes, relative to start of parent structure
+ uint32_t oType; // Offset to member's type descriptor
+ };
+
+ // the data that follows depends on the VarType:
+ // Numeric: SType::SNumericType
+ // Object: EObjectType
+ // Struct:
+ // struct
+ // {
+ // uint32_t cMembers;
+ // SBinaryMembers Members[cMembers];
+ // } MemberInfo
+ // struct
+ // {
+ // uint32_t oBaseClassType; // Offset to type information (SBinaryType)
+ // uint32_t cInterfaces;
+ // uint32_t oInterfaceTypes[cInterfaces];
+ // } SBinaryTypeInheritance
+ // Interface: (nothing)
+};
+
+struct SBinaryNumericType
+{
+ ENumericLayout NumericLayout : 3; // scalar (1x1), vector (1xN), matrix (NxN)
+ EScalarType ScalarType : 5; // float32, int32, int8, etc.
+ uint32_t Rows : 3; // 1 <= Rows <= 4
+ uint32_t Columns : 3; // 1 <= Columns <= 4
+ uint32_t IsColumnMajor : 1; // applies only to matrices
+ uint32_t IsPackedArray : 1; // if this is an array, indicates whether elements should be greedily packed
+};
+
+struct SBinaryTypeInheritance
+{
+ uint32_t oBaseClass; // Offset to base class type info or 0 if no base class.
+ uint32_t cInterfaces;
+
+ // Followed by uint32_t[cInterfaces] with offsets to the type
+ // info of each interface.
+};
+
+struct SBinaryGroup
+{
+ uint32_t oName;
+ uint32_t cTechniques;
+};
+
+struct SBinaryTechnique
+{
+ uint32_t oName;
+ uint32_t cPasses;
+};
+
+struct SBinaryPass
+{
+ uint32_t oName;
+ uint32_t cAssignments;
+};
+
+enum ECompilerAssignmentType
+{
+ ECAT_Invalid, // Assignment-specific data (always in the unstructured blob)
+ ECAT_Constant, // -N SConstant structures
+ ECAT_Variable, // -nullptr terminated string with variable name ("foo")
+ ECAT_ConstIndex, // -SConstantIndex structure
+ ECAT_VariableIndex, // -SVariableIndex structure
+ ECAT_ExpressionIndex, // -SIndexedObjectExpression structure
+ ECAT_Expression, // -Data block containing FXLVM code
+ ECAT_InlineShader, // -Data block containing shader
+ ECAT_InlineShader5, // -Data block containing shader with extended 5.0 data (SBinaryShaderData5)
+};
+
+struct SBinaryAssignment
+{
+ uint32_t iState; // index into g_lvGeneral
+ uint32_t Index; // the particular index to assign to (see g_lvGeneral to find the # of valid indices)
+ ECompilerAssignmentType AssignmentType;
+ uint32_t oInitializer; // Offset of assignment-specific data
+
+ struct SConstantIndex
+ {
+ uint32_t oArrayName;
+ uint32_t Index;
+ };
+
+ struct SVariableIndex
+ {
+ uint32_t oArrayName;
+ uint32_t oIndexVarName;
+ };
+
+ struct SIndexedObjectExpression
+ {
+ uint32_t oArrayName;
+ uint32_t oCode;
+ };
+
+ struct SInlineShader
+ {
+ uint32_t oShader;
+ uint32_t oSODecl;
+ };
+};
+
+struct SBinaryConstant
+{
+ EScalarType Type;
+ union
+ {
+ BOOL bValue;
+ INT iValue;
+ float fValue;
+ };
+};
+
+static_assert( sizeof(SBinaryHeader) == 76, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryHeader::SVarCounts) == 12, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryHeader5) == 96, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryConstantBuffer) == 20, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAnnotation) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryNumericVariable) == 24, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryInterfaceVariable) == 16, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryInterfaceInitializer) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryObjectVariable) == 16, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryGSSOInitializer) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryShaderData5) == 36, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryType) == 24, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryType::SBinaryMember) == 16, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryNumericType) == 4, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryTypeInheritance) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryGroup) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryTechnique) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryPass) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAssignment) == 16, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAssignment::SConstantIndex) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAssignment::SVariableIndex) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAssignment::SIndexedObjectExpression) == 8, "FX11 binary size mismatch" );
+static_assert( sizeof(SBinaryAssignment::SInlineShader) == 8, "FX11 binary size mismatch" );
+
+} // end namespace D3DX11Effects
+
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectStateBase11.h
+//
+// Direct3D 11 Effects States Header
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+namespace D3DX11Effects
+{
+
+//////////////////////////////////////////////////////////////////////////
+// Effect HLSL states and late resolve lists
+//////////////////////////////////////////////////////////////////////////
+
+struct RValue
+{
+ const char *m_pName;
+ uint32_t m_Value;
+};
+
+#define RVALUE_END() { nullptr, 0U }
+#define RVALUE_ENTRY(prefix, x) { #x, (uint32_t)prefix##x }
+
+enum ELhsType;
+
+struct LValue
+{
+ const char *m_pName; // name of the LHS side of expression
+ EBlockType m_BlockType; // type of block it can appear in
+ D3D_SHADER_VARIABLE_TYPE m_Type; // data type allows
+ uint32_t m_Cols; // number of [m_Type]'s required (1 for a scalar, 4 for a vector)
+ uint32_t m_Indices; // max index allowable (if LHS is an array; otherwise this is 1)
+ bool m_VectorScalar; // can be both vector and scalar (setting as a scalar sets all m_Indices values simultaneously)
+ const RValue *m_pRValue; // pointer to table of allowable RHS "late resolve" values
+ ELhsType m_LhsType; // ELHS_* enum value that corresponds to this entry
+ uint32_t m_Offset; // offset into the given block type where this value should be written
+ uint32_t m_Stride; // for vectors, byte stride between two consecutive values. if 0, m_Type's size is used
+};
+
+#define LVALUE_END() { nullptr, D3D_SVT_UINT, 0, 0, 0, nullptr }
+
+extern const LValue g_lvGeneral[];
+extern const uint32_t g_lvGeneralCount;
+
+} // end namespace D3DX11Effects
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectStates11.h
+//
+// Direct3D 11 Effects States Header
+// This file defines properties of states which can appear in
+// state blocks and pass blocks.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "EffectStateBase11.h"
+
+namespace D3DX11Effects
+{
+
+//////////////////////////////////////////////////////////////////////////
+// Effect HLSL late resolve lists (state values)
+//////////////////////////////////////////////////////////////////////////
+
+static const RValue g_rvNULL[] =
+{
+ { "nullptr", 0 },
+ RVALUE_END()
+};
+
+
+static const RValue g_rvBOOL[] =
+{
+ { "false", 0 },
+ { "true", 1 },
+ RVALUE_END()
+};
+
+static const RValue g_rvDEPTH_WRITE_MASK[] =
+{
+ { "ZERO", D3D11_DEPTH_WRITE_MASK_ZERO },
+ { "ALL", D3D11_DEPTH_WRITE_MASK_ALL },
+ RVALUE_END()
+};
+
+static const RValue g_rvFILL[] =
+{
+ { "WIREFRAME", D3D11_FILL_WIREFRAME },
+ { "SOLID", D3D11_FILL_SOLID },
+ RVALUE_END()
+};
+
+static const RValue g_rvFILTER[] =
+{
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_POINT_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_POINT_MAG_LINEAR_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_POINT_MAG_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_LINEAR_MAG_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_LINEAR_MAG_POINT_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_LINEAR_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, ANISOTROPIC ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_POINT_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_POINT_MAG_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_LINEAR_MAG_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_LINEAR_MIP_POINT ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_MIP_LINEAR ),
+ RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_ANISOTROPIC ),
+ RVALUE_END()
+};
+
+static const RValue g_rvBLEND[] =
+{
+ { "ZERO", D3D11_BLEND_ZERO },
+ { "ONE", D3D11_BLEND_ONE },
+ { "SRC_COLOR", D3D11_BLEND_SRC_COLOR },
+ { "INV_SRC_COLOR", D3D11_BLEND_INV_SRC_COLOR },
+ { "SRC_ALPHA", D3D11_BLEND_SRC_ALPHA },
+ { "INV_SRC_ALPHA", D3D11_BLEND_INV_SRC_ALPHA },
+ { "DEST_ALPHA", D3D11_BLEND_DEST_ALPHA },
+ { "INV_DEST_ALPHA", D3D11_BLEND_INV_DEST_ALPHA },
+ { "DEST_COLOR", D3D11_BLEND_DEST_COLOR },
+ { "INV_DEST_COLOR", D3D11_BLEND_INV_DEST_COLOR },
+ { "SRC_ALPHA_SAT", D3D11_BLEND_SRC_ALPHA_SAT },
+ { "BLEND_FACTOR", D3D11_BLEND_BLEND_FACTOR },
+ { "INV_BLEND_FACTOR", D3D11_BLEND_INV_BLEND_FACTOR },
+ { "SRC1_COLOR", D3D11_BLEND_SRC1_COLOR },
+ { "INV_SRC1_COLOR", D3D11_BLEND_INV_SRC1_COLOR },
+ { "SRC1_ALPHA", D3D11_BLEND_SRC1_ALPHA },
+ { "INV_SRC1_ALPHA", D3D11_BLEND_INV_SRC1_ALPHA },
+
+ RVALUE_END()
+};
+
+static const RValue g_rvTADDRESS[] =
+{
+ { "CLAMP", D3D11_TEXTURE_ADDRESS_CLAMP },
+ { "WRAP", D3D11_TEXTURE_ADDRESS_WRAP },
+ { "MIRROR", D3D11_TEXTURE_ADDRESS_MIRROR },
+ { "BORDER", D3D11_TEXTURE_ADDRESS_BORDER },
+ { "MIRROR_ONCE", D3D11_TEXTURE_ADDRESS_MIRROR_ONCE },
+ RVALUE_END()
+};
+
+static const RValue g_rvCULL[] =
+{
+ { "NONE", D3D11_CULL_NONE },
+ { "FRONT", D3D11_CULL_FRONT },
+ { "BACK", D3D11_CULL_BACK },
+ RVALUE_END()
+};
+
+static const RValue g_rvCMP[] =
+{
+ { "NEVER", D3D11_COMPARISON_NEVER },
+ { "LESS", D3D11_COMPARISON_LESS },
+ { "EQUAL", D3D11_COMPARISON_EQUAL },
+ { "LESS_EQUAL", D3D11_COMPARISON_LESS_EQUAL },
+ { "GREATER", D3D11_COMPARISON_GREATER },
+ { "NOT_EQUAL", D3D11_COMPARISON_NOT_EQUAL },
+ { "GREATER_EQUAL", D3D11_COMPARISON_GREATER_EQUAL },
+ { "ALWAYS", D3D11_COMPARISON_ALWAYS },
+ RVALUE_END()
+};
+
+static const RValue g_rvSTENCILOP[] =
+{
+ { "KEEP", D3D11_STENCIL_OP_KEEP },
+ { "ZERO", D3D11_STENCIL_OP_ZERO },
+ { "REPLACE", D3D11_STENCIL_OP_REPLACE },
+ { "INCR_SAT", D3D11_STENCIL_OP_INCR_SAT },
+ { "DECR_SAT", D3D11_STENCIL_OP_DECR_SAT },
+ { "INVERT", D3D11_STENCIL_OP_INVERT },
+ { "INCR", D3D11_STENCIL_OP_INCR },
+ { "DECR", D3D11_STENCIL_OP_DECR },
+ RVALUE_END()
+};
+
+static const RValue g_rvBLENDOP[] =
+{
+ { "ADD", D3D11_BLEND_OP_ADD },
+ { "SUBTRACT", D3D11_BLEND_OP_SUBTRACT },
+ { "REV_SUBTRACT", D3D11_BLEND_OP_REV_SUBTRACT },
+ { "MIN", D3D11_BLEND_OP_MIN },
+ { "MAX", D3D11_BLEND_OP_MAX },
+ RVALUE_END()
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// Effect HLSL states
+//////////////////////////////////////////////////////////////////////////
+
+#define strideof( s, m ) offsetof_fx(s,m[1]) - offsetof_fx(s,m[0])
+
+const LValue g_lvGeneral[] =
+{
+ // RObjects
+ { "RasterizerState", EBT_Pass, D3D_SVT_RASTERIZER, 1, 1, false, nullptr, ELHS_RasterizerBlock, offsetof_fx(SPassBlock, BackingStore.pRasterizerBlock), 0 },
+ { "DepthStencilState", EBT_Pass, D3D_SVT_DEPTHSTENCIL, 1, 1, false, nullptr, ELHS_DepthStencilBlock, offsetof_fx(SPassBlock, BackingStore.pDepthStencilBlock), 0 },
+ { "BlendState", EBT_Pass, D3D_SVT_BLEND, 1, 1, false, nullptr, ELHS_BlendBlock, offsetof_fx(SPassBlock, BackingStore.pBlendBlock), 0 },
+ { "RenderTargetView", EBT_Pass, D3D_SVT_RENDERTARGETVIEW, 1, 8, false, nullptr, ELHS_RenderTargetView, offsetof_fx(SPassBlock, BackingStore.pRenderTargetViews), 0 },
+ { "DepthStencilView", EBT_Pass, D3D_SVT_DEPTHSTENCILVIEW, 1, 8, false, nullptr, ELHS_DepthStencilView, offsetof_fx(SPassBlock, BackingStore.pDepthStencilView), 0 },
+ { "GenerateMips", EBT_Pass, D3D_SVT_TEXTURE, 1, 1, false, nullptr, ELHS_GenerateMips, 0, 0 },
+ // Shaders
+ { "VertexShader", EBT_Pass, D3D_SVT_VERTEXSHADER, 1, 1, false, g_rvNULL, ELHS_VertexShaderBlock, offsetof_fx(SPassBlock, BackingStore.pVertexShaderBlock), 0 },
+ { "PixelShader", EBT_Pass, D3D_SVT_PIXELSHADER, 1, 1, false, g_rvNULL, ELHS_PixelShaderBlock, offsetof_fx(SPassBlock, BackingStore.pPixelShaderBlock), 0 },
+ { "GeometryShader", EBT_Pass, D3D_SVT_GEOMETRYSHADER, 1, 1, false, g_rvNULL, ELHS_GeometryShaderBlock, offsetof_fx(SPassBlock, BackingStore.pGeometryShaderBlock), 0 },
+ // RObject config assignments
+ { "DS_StencilRef", EBT_Pass, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_DS_StencilRef, offsetof_fx(SPassBlock, BackingStore.StencilRef), 0 },
+ { "AB_BlendFactor", EBT_Pass, D3D_SVT_FLOAT, 4, 1, false, nullptr, ELHS_B_BlendFactor, offsetof_fx(SPassBlock, BackingStore.BlendFactor), 0 },
+ { "AB_SampleMask", EBT_Pass, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_B_SampleMask, offsetof_fx(SPassBlock, BackingStore.SampleMask), 0 },
+
+ { "FillMode", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, g_rvFILL, ELHS_FillMode, offsetof_fx(SRasterizerBlock, BackingStore.FillMode), 0 },
+ { "CullMode", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, g_rvCULL, ELHS_CullMode, offsetof_fx(SRasterizerBlock, BackingStore.CullMode), 0 },
+ { "FrontCounterClockwise", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_FrontCC, offsetof_fx(SRasterizerBlock, BackingStore.FrontCounterClockwise), 0 },
+ { "DepthBias", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_DepthBias, offsetof_fx(SRasterizerBlock, BackingStore.DepthBias), 0 },
+ { "DepthBiasClamp", EBT_Rasterizer, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_DepthBiasClamp, offsetof_fx(SRasterizerBlock, BackingStore.DepthBiasClamp), 0 },
+ { "SlopeScaledDepthBias", EBT_Rasterizer, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_SlopeScaledDepthBias, offsetof_fx(SRasterizerBlock, BackingStore.SlopeScaledDepthBias), 0 },
+ { "DepthClipEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_DepthClipEnable, offsetof_fx(SRasterizerBlock, BackingStore.DepthClipEnable), 0 },
+ { "ScissorEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_ScissorEnable, offsetof_fx(SRasterizerBlock, BackingStore.ScissorEnable), 0 },
+ { "MultisampleEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_MultisampleEnable, offsetof_fx(SRasterizerBlock, BackingStore.MultisampleEnable), 0 },
+ { "AntialiasedLineEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_AntialiasedLineEnable, offsetof_fx(SRasterizerBlock, BackingStore.AntialiasedLineEnable), 0 },
+
+ { "DepthEnable", EBT_DepthStencil, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_DepthEnable, offsetof_fx(SDepthStencilBlock, BackingStore.DepthEnable), 0 },
+ { "DepthWriteMask", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvDEPTH_WRITE_MASK, ELHS_DepthWriteMask, offsetof_fx(SDepthStencilBlock, BackingStore.DepthWriteMask), 0 },
+ { "DepthFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_DepthFunc, offsetof_fx(SDepthStencilBlock, BackingStore.DepthFunc), 0 },
+ { "StencilEnable", EBT_DepthStencil, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_StencilEnable, offsetof_fx(SDepthStencilBlock, BackingStore.StencilEnable), 0 },
+ { "StencilReadMask", EBT_DepthStencil, D3D_SVT_UINT8, 1, 1, false, nullptr, ELHS_StencilReadMask, offsetof_fx(SDepthStencilBlock, BackingStore.StencilReadMask), 0 },
+ { "StencilWriteMask", EBT_DepthStencil, D3D_SVT_UINT8, 1, 1, false, nullptr, ELHS_StencilWriteMask, offsetof_fx(SDepthStencilBlock, BackingStore.StencilWriteMask), 0 },
+ { "FrontFaceStencilFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilFailOp, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFailOp), 0 },
+ { "FrontFaceStencilDepthFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilDepthFailOp), 0 },
+ { "FrontFaceStencilPass", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilPassOp, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilPassOp), 0 },
+ { "FrontFaceStencilFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_FrontFaceStencilFunc, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFunc), 0 },
+ { "BackFaceStencilFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilFailOp, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFailOp), 0 },
+ { "BackFaceStencilDepthFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilDepthFailOp), 0 },
+ { "BackFaceStencilPass", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilPassOp, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilPassOp), 0 },
+ { "BackFaceStencilFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_BackFaceStencilFunc, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFunc), 0 },
+
+ { "AlphaToCoverageEnable", EBT_Blend, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_AlphaToCoverage, offsetof_fx(SBlendBlock, BackingStore.AlphaToCoverageEnable), 0 },
+ { "BlendEnable", EBT_Blend, D3D_SVT_BOOL, 1, 8, false, g_rvBOOL, ELHS_BlendEnable, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendEnable), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "SrcBlend", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_SrcBlend, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlend), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "DestBlend", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_DestBlend, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlend), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "BlendOp", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLENDOP, ELHS_BlendOp, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOp), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "SrcBlendAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_SrcBlendAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlendAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "DestBlendAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_DestBlendAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlendAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "BlendOpAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLENDOP, ELHS_BlendOpAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOpAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
+ { "RenderTargetWriteMask", EBT_Blend, D3D_SVT_UINT8, 1, 8, false, nullptr, ELHS_RenderTargetWriteMask, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].RenderTargetWriteMask), strideof(SBlendBlock, BackingStore.RenderTarget) },
+
+ { "Filter", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvFILTER, ELHS_Filter, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.Filter), 0 },
+ { "AddressU", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressU, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressU), 0 },
+ { "AddressV", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressV, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressV), 0 },
+ { "AddressW", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressW, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressW), 0 },
+ { "MipLODBias", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MipLODBias, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MipLODBias), 0 },
+ { "MaxAnisotropy", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_MaxAnisotropy, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxAnisotropy), 0 },
+ { "ComparisonFunc", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_ComparisonFunc, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.ComparisonFunc), 0 },
+ { "BorderColor", EBT_Sampler, D3D_SVT_FLOAT, 4, 1, false, nullptr, ELHS_BorderColor, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.BorderColor), 0 },
+ { "MinLOD", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MinLOD, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MinLOD), 0 },
+ { "MaxLOD", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MaxLOD, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxLOD), 0 },
+ { "Texture", EBT_Sampler, D3D_SVT_TEXTURE, 1, 1, false, g_rvNULL, ELHS_Texture, offsetof_fx(SSamplerBlock, BackingStore.pTexture), 0 },
+
+ // D3D11
+ { "HullShader", EBT_Pass, D3D11_SVT_HULLSHADER, 1, 1, false, g_rvNULL, ELHS_HullShaderBlock, offsetof_fx(SPassBlock, BackingStore.pHullShaderBlock), 0 },
+ { "DomainShader", EBT_Pass, D3D11_SVT_DOMAINSHADER, 1, 1, false, g_rvNULL, ELHS_DomainShaderBlock, offsetof_fx(SPassBlock, BackingStore.pDomainShaderBlock), 0 },
+ { "ComputeShader", EBT_Pass, D3D11_SVT_COMPUTESHADER, 1, 1, false, g_rvNULL, ELHS_ComputeShaderBlock, offsetof_fx(SPassBlock, BackingStore.pComputeShaderBlock), 0 },
+};
+
+#define NUM_STATES (sizeof(g_lvGeneral) / sizeof(LValue))
+#define MAX_VECTOR_SCALAR_INDEX 8
+
+const uint32_t g_lvGeneralCount = NUM_STATES;
+
+} // end namespace D3DX11Effects
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: SOParser.h
+//
+// Direct3D 11 Effects Stream Out Decl Parser
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <stdio.h>
+#include <string.h>
+
+namespace D3DX11Effects
+{
+
+//////////////////////////////////////////////////////////////////////////
+// CSOParser
+//////////////////////////////////////////////////////////////////////////
+
+class CSOParser
+{
+
+ CEffectVector<D3D11_SO_DECLARATION_ENTRY> m_vDecls; // Set of parsed decl entries
+ D3D11_SO_DECLARATION_ENTRY m_newEntry; // Currently parsing entry
+ LPSTR m_SemanticString[D3D11_SO_BUFFER_SLOT_COUNT]; // Copy of strings
+
+ static const size_t MAX_ERROR_SIZE = 254;
+ char m_pError[ MAX_ERROR_SIZE + 1 ]; // Error buffer
+
+public:
+ CSOParser()
+ {
+ ZeroMemory(&m_newEntry, sizeof(m_newEntry));
+ ZeroMemory(m_SemanticString, sizeof(m_SemanticString));
+ m_pError[0] = 0;
+ }
+
+ ~CSOParser()
+ {
+ for( size_t Stream = 0; Stream < D3D11_SO_STREAM_COUNT; ++Stream )
+ {
+ SAFE_DELETE_ARRAY( m_SemanticString[Stream] );
+ }
+ }
+
+ // Parse a single string, assuming stream 0
+ HRESULT Parse( _In_z_ LPCSTR pString )
+ {
+ m_vDecls.Clear();
+ return Parse( 0, pString );
+ }
+
+ // Parse all 4 streams
+ HRESULT Parse( _In_z_ LPSTR pStreams[D3D11_SO_STREAM_COUNT] )
+ {
+ HRESULT hr = S_OK;
+ m_vDecls.Clear();
+ for( uint32_t iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
+ {
+ hr = Parse( iDecl, pStreams[iDecl] );
+ if( FAILED(hr) )
+ {
+ char str[16];
+ sprintf_s( str, 16, " in stream %u.", iDecl );
+ str[15] = 0;
+ strcat_s( m_pError, MAX_ERROR_SIZE, str );
+ return hr;
+ }
+ }
+ return hr;
+ }
+
+ // Return resulting declarations
+ D3D11_SO_DECLARATION_ENTRY *GetDeclArray()
+ {
+ return &m_vDecls[0];
+ }
+
+ char* GetErrorString()
+ {
+ return m_pError;
+ }
+
+ uint32_t GetDeclCount() const
+ {
+ return m_vDecls.GetSize();
+ }
+
+ // Return resulting buffer strides
+ void GetStrides( uint32_t strides[4] )
+ {
+ size_t len = GetDeclCount();
+ strides[0] = strides[1] = strides[2] = strides[3] = 0;
+
+ for( size_t i=0; i < len; i++ )
+ {
+ strides[m_vDecls[i].OutputSlot] += m_vDecls[i].ComponentCount * sizeof(float);
+ }
+ }
+
+protected:
+
+ // Parse a single string "[<slot> :] <semantic>[<index>][.<mask>]; [[<slot> :] <semantic>[<index>][.<mask>][;]]"
+ HRESULT Parse( _In_ uint32_t Stream, _In_z_ LPCSTR pString )
+ {
+ HRESULT hr = S_OK;
+
+ m_pError[0] = 0;
+
+ if( pString == nullptr )
+ return S_OK;
+
+ uint32_t len = (uint32_t)strlen( pString );
+ if( len == 0 )
+ return S_OK;
+
+ SAFE_DELETE_ARRAY( m_SemanticString[Stream] );
+ VN( m_SemanticString[Stream] = new char[len + 1] );
+ strcpy_s( m_SemanticString[Stream], len + 1, pString );
+
+ LPSTR pSemantic = m_SemanticString[Stream];
+
+ while( true )
+ {
+ // Each decl entry is delimited by a semi-colon
+ LPSTR pSemi = strchr( pSemantic, ';' );
+
+ // strip leading and trailing spaces
+ LPSTR pEnd;
+ if( pSemi != nullptr )
+ {
+ *pSemi = '\0';
+ pEnd = pSemi - 1;
+ }
+ else
+ {
+ pEnd = pSemantic + strlen( pSemantic );
+ }
+ while( isspace( (unsigned char)*pSemantic ) )
+ pSemantic++;
+ while( pEnd > pSemantic && isspace( (unsigned char)*pEnd ) )
+ {
+ *pEnd = '\0';
+ pEnd--;
+ }
+
+ if( *pSemantic != '\0' )
+ {
+ VH( AddSemantic( pSemantic ) );
+ m_newEntry.Stream = Stream;
+
+ VH( m_vDecls.Add( m_newEntry ) );
+ }
+ if( pSemi == nullptr )
+ break;
+ pSemantic = pSemi + 1;
+ }
+
+lExit:
+ return hr;
+ }
+
+ // Parse a single decl "[<slot> :] <semantic>[<index>][.<mask>]"
+ HRESULT AddSemantic( _Inout_z_ LPSTR pSemantic )
+ {
+ HRESULT hr = S_OK;
+
+ assert( pSemantic );
+
+ ZeroMemory( &m_newEntry, sizeof(m_newEntry) );
+ VH( ConsumeOutputSlot( &pSemantic ) );
+ VH( ConsumeRegisterMask( pSemantic ) );
+ VH( ConsumeSemanticIndex( pSemantic ) );
+
+ // pSenantic now contains only the SemanticName (all other fields were consumed)
+ if( strcmp( "$SKIP", pSemantic ) != 0 )
+ {
+ m_newEntry.SemanticName = pSemantic;
+ }
+
+lExit:
+ return hr;
+ }
+
+ // Parse optional mask "[.<mask>]"
+ HRESULT ConsumeRegisterMask( _Inout_z_ LPSTR pSemantic )
+ {
+ HRESULT hr = S_OK;
+ const char *pFullMask1 = "xyzw";
+ const char *pFullMask2 = "rgba";
+ size_t stringLength;
+ size_t startComponent = 0;
+ LPCSTR p;
+
+ assert( pSemantic );
+
+ pSemantic = strchr( pSemantic, '.' );
+
+ if( pSemantic == nullptr )
+ {
+ m_newEntry.ComponentCount = 4;
+ return S_OK;
+ }
+
+ *pSemantic = '\0';
+ pSemantic++;
+
+ stringLength = strlen( pSemantic );
+ p = strstr(pFullMask1, pSemantic );
+ if( p )
+ {
+ startComponent = (uint32_t)( p - pFullMask1 );
+ }
+ else
+ {
+ p = strstr( pFullMask2, pSemantic );
+ if( p )
+ startComponent = (uint32_t)( p - pFullMask2 );
+ else
+ {
+ sprintf_s( m_pError, MAX_ERROR_SIZE, "ID3D11Effect::ParseSODecl - invalid mask declaration '%s'", pSemantic );
+ VH( E_FAIL );
+ }
+
+ }
+
+ if( stringLength == 0 )
+ stringLength = 4;
+
+ m_newEntry.StartComponent = (uint8_t)startComponent;
+ m_newEntry.ComponentCount = (uint8_t)stringLength;
+
+lExit:
+ return hr;
+ }
+
+ // Parse optional output slot "[<slot> :]"
+ HRESULT ConsumeOutputSlot( _Inout_z_ LPSTR* ppSemantic )
+ {
+ assert( ppSemantic && *ppSemantic );
+ _Analysis_assume_( ppSemantic && *ppSemantic );
+
+ HRESULT hr = S_OK;
+ LPSTR pColon = strchr( *ppSemantic, ':' );
+
+ if( pColon == nullptr )
+ return S_OK;
+
+ if( pColon == *ppSemantic )
+ {
+ strcpy_s( m_pError, MAX_ERROR_SIZE,
+ "ID3D11Effect::ParseSODecl - Invalid output slot" );
+ VH( E_FAIL );
+ }
+
+ *pColon = '\0';
+ int outputSlot = atoi( *ppSemantic );
+ if( outputSlot < 0 || outputSlot > 255 )
+ {
+ strcpy_s( m_pError, MAX_ERROR_SIZE,
+ "ID3D11Effect::ParseSODecl - Invalid output slot" );
+ VH( E_FAIL );
+ }
+ m_newEntry.OutputSlot = (uint8_t)outputSlot;
+
+ while( *ppSemantic < pColon )
+ {
+ if( !isdigit( (unsigned char)**ppSemantic ) )
+ {
+ sprintf_s( m_pError, MAX_ERROR_SIZE, "ID3D11Effect::ParseSODecl - Non-digit '%c' in output slot", **ppSemantic );
+ VH( E_FAIL );
+ }
+ (*ppSemantic)++;
+ }
+
+ // skip the colon (which is now '\0')
+ (*ppSemantic)++;
+
+ while( isspace( (unsigned char)**ppSemantic ) )
+ (*ppSemantic)++;
+
+lExit:
+ return hr;
+ }
+
+ // Parse optional index "[<index>]"
+ HRESULT ConsumeSemanticIndex( _Inout_z_ LPSTR pSemantic )
+ {
+ assert( pSemantic );
+
+ uint32_t uLen = (uint32_t)strlen( pSemantic );
+
+ // Grab semantic index
+ while( uLen > 0 && isdigit( (unsigned char)pSemantic[uLen - 1] ) )
+ uLen--;
+
+ if( isdigit( (unsigned char)pSemantic[uLen] ) )
+ {
+ m_newEntry.SemanticIndex = atoi( pSemantic + uLen );
+ pSemantic[uLen] = '\0';
+ }
+ else
+ {
+ m_newEntry.SemanticIndex = 0;
+ }
+
+ return S_OK;
+ }
+};
+
+} // end namespace D3DX11Effects
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: Effect.h
+//
+// Direct3D 11 Effects Header for ID3DX11Effect Implementation
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "EffectBinaryFormat.h"
+#include "IUnknownImp.h"
+
+#ifdef _DEBUG
+extern void __cdecl D3DXDebugPrintf(UINT lvl, _In_z_ _Printf_format_string_ LPCSTR szFormat, ...);
+#define DPF D3DXDebugPrintf
+#else
+#define DPF
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4481)
+// VS 2010 considers 'override' to be a extension, but it's part of C++11 as of VS 2012
+
+//////////////////////////////////////////////////////////////////////////
+
+using namespace D3DX11Core;
+
+namespace D3DX11Effects
+{
+
+//////////////////////////////////////////////////////////////////////////
+// Forward defines
+//////////////////////////////////////////////////////////////////////////
+
+struct SBaseBlock;
+struct SShaderBlock;
+struct SPassBlock;
+struct SClassInstance;
+struct SInterface;
+struct SShaderResource;
+struct SUnorderedAccessView;
+struct SRenderTargetView;
+struct SDepthStencilView;
+struct SSamplerBlock;
+struct SDepthStencilBlock;
+struct SBlendBlock;
+struct SRasterizerBlock;
+struct SString;
+struct SD3DShaderVTable;
+struct SClassInstanceGlobalVariable;
+
+struct SAssignment;
+struct SVariable;
+struct SGlobalVariable;
+struct SAnnotation;
+struct SConstantBuffer;
+
+class CEffect;
+class CEffectLoader;
+
+enum ELhsType;
+
+// Allows the use of 32-bit and 64-bit timers depending on platform type
+typedef size_t Timer;
+
+//////////////////////////////////////////////////////////////////////////
+// Reflection & Type structures
+//////////////////////////////////////////////////////////////////////////
+
+// CEffectMatrix is used internally instead of float arrays
+struct CEffectMatrix
+{
+ union
+ {
+ struct
+ {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ float _41, _42, _43, _44;
+
+ };
+ float m[4][4];
+ };
+};
+
+struct CEffectVector4
+{
+ float x;
+ float y;
+ float z;
+ float w;
+};
+
+union UDataPointer
+{
+ void *pGeneric;
+ uint8_t *pNumeric;
+ float *pNumericFloat;
+ uint32_t *pNumericDword;
+ int *pNumericInt;
+ BOOL *pNumericBool;
+ SString *pString;
+ SShaderBlock *pShader;
+ SBaseBlock *pBlock;
+ SBlendBlock *pBlend;
+ SDepthStencilBlock *pDepthStencil;
+ SRasterizerBlock *pRasterizer;
+ SInterface *pInterface;
+ SShaderResource *pShaderResource;
+ SUnorderedAccessView *pUnorderedAccessView;
+ SRenderTargetView *pRenderTargetView;
+ SDepthStencilView *pDepthStencilView;
+ SSamplerBlock *pSampler;
+ CEffectVector4 *pVector;
+ CEffectMatrix *pMatrix;
+ UINT_PTR Offset;
+};
+
+enum EMemberDataType
+{
+ MDT_ClassInstance,
+ MDT_BlendState,
+ MDT_DepthStencilState,
+ MDT_RasterizerState,
+ MDT_SamplerState,
+ MDT_Buffer,
+ MDT_ShaderResourceView,
+};
+
+struct SMemberDataPointer
+{
+ EMemberDataType Type;
+ union
+ {
+ IUnknown *pGeneric;
+ ID3D11ClassInstance *pD3DClassInstance;
+ ID3D11BlendState *pD3DEffectsManagedBlendState;
+ ID3D11DepthStencilState *pD3DEffectsManagedDepthStencilState;
+ ID3D11RasterizerState *pD3DEffectsManagedRasterizerState;
+ ID3D11SamplerState *pD3DEffectsManagedSamplerState;
+ ID3D11Buffer *pD3DEffectsManagedConstantBuffer;
+ ID3D11ShaderResourceView*pD3DEffectsManagedTextureBuffer;
+ } Data;
+};
+
+struct SType : public ID3DX11EffectType
+{
+ static const UINT_PTR c_InvalidIndex = (uint32_t) -1;
+ static const uint32_t c_ScalarSize = sizeof(uint32_t);
+
+ // packing rule constants
+ static const uint32_t c_ScalarsPerRegister = 4;
+ static const uint32_t c_RegisterSize = c_ScalarsPerRegister * c_ScalarSize; // must be a power of 2!!
+
+ EVarType VarType; // numeric, object, struct
+ uint32_t Elements; // # of array elements (0 for non-arrays)
+ char *pTypeName; // friendly name of the type: "VS_OUTPUT", "float4", etc.
+
+ // *Size and stride values are always 0 for object types
+ // *Annotations adhere to packing rules (even though they do not reside in constant buffers)
+ // for consistency's sake
+ //
+ // Packing rules:
+ // *Structures and array elements are always register aligned
+ // *Single-row values (or, for column major matrices, single-column) are greedily
+ // packed unless doing so would span a register boundary, in which case they are
+ // register aligned
+
+ uint32_t TotalSize; // Total size of this data type in a constant buffer from
+ // start to finish (padding in between elements is included,
+ // but padding at the end is not since that would require
+ // knowledge of the following data type).
+
+ uint32_t Stride; // Number of bytes to advance between elements.
+ // Typically a multiple of 16 for arrays, vectors, matrices.
+ // For scalars and small vectors/matrices, this can be 4 or 8.
+
+ uint32_t PackedSize; // Size, in bytes, of this data typed when fully packed
+
+ union
+ {
+ SBinaryNumericType NumericType;
+ EObjectType ObjectType; // not all values of EObjectType are valid here (e.g. constant buffer)
+ struct
+ {
+ SVariable *pMembers; // array of type instances describing structure members
+ uint32_t Members;
+ BOOL ImplementsInterface; // true if this type implements an interface
+ BOOL HasSuperClass; // true if this type has a parent class
+ } StructType;
+ void* InterfaceType; // nothing for interfaces
+ };
+
+
+ SType() :
+ VarType(EVT_Invalid),
+ Elements(0),
+ pTypeName(nullptr),
+ TotalSize(0),
+ Stride(0),
+ PackedSize(0)
+ {
+ C_ASSERT( sizeof(NumericType) <= sizeof(StructType) );
+ C_ASSERT( sizeof(ObjectType) <= sizeof(StructType) );
+ C_ASSERT( sizeof(InterfaceType) <= sizeof(StructType) );
+ ZeroMemory( &StructType, sizeof(StructType) );
+ }
+
+ bool IsEqual(SType *pOtherType) const;
+
+ bool IsObjectType(EObjectType ObjType) const
+ {
+ return IsObjectTypeHelper(VarType, ObjectType, ObjType);
+ }
+ bool IsShader() const
+ {
+ return IsShaderHelper(VarType, ObjectType);
+ }
+ bool BelongsInConstantBuffer() const
+ {
+ return (VarType == EVT_Numeric) || (VarType == EVT_Struct);
+ }
+ bool IsStateBlockObject() const
+ {
+ return IsStateBlockObjectHelper(VarType, ObjectType);
+ }
+ bool IsClassInstance() const
+ {
+ return (VarType == EVT_Struct) && StructType.ImplementsInterface;
+ }
+ bool IsInterface() const
+ {
+ return IsInterfaceHelper(VarType, ObjectType);
+ }
+ bool IsShaderResource() const
+ {
+ return IsShaderResourceHelper(VarType, ObjectType);
+ }
+ bool IsUnorderedAccessView() const
+ {
+ return IsUnorderedAccessViewHelper(VarType, ObjectType);
+ }
+ bool IsSampler() const
+ {
+ return IsSamplerHelper(VarType, ObjectType);
+ }
+ bool IsRenderTargetView() const
+ {
+ return IsRenderTargetViewHelper(VarType, ObjectType);
+ }
+ bool IsDepthStencilView() const
+ {
+ return IsDepthStencilViewHelper(VarType, ObjectType);
+ }
+
+ uint32_t GetTotalUnpackedSize(_In_ bool IsSingleElement) const;
+ uint32_t GetTotalPackedSize(_In_ bool IsSingleElement) const;
+ HRESULT GetDescHelper(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc, _In_ bool IsSingleElement) const;
+
+ STDMETHOD_(bool, IsValid)() override { return true; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override { return GetDescHelper(pDesc, false); }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(_In_z_ LPCSTR Semantic) override;
+ STDMETHOD_(LPCSTR, GetMemberName)(_In_ uint32_t Index) override;
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(_In_ uint32_t Index) override;
+
+ IUNKNOWN_IMP(SType, ID3DX11EffectType, IUnknown);
+};
+
+// Represents a type structure for a single element.
+// It seems pretty trivial, but it has a different virtual table which enables
+// us to accurately represent a type that consists of a single element
+struct SSingleElementType : public ID3DX11EffectType
+{
+ SType *pType;
+
+ STDMETHOD_(bool, IsValid)() override { return true; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override { return ((SType*)pType)->GetDescHelper(pDesc, true); }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(uint32_t Index) override { return ((SType*)pType)->GetMemberTypeByIndex(Index); }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name) override { return ((SType*)pType)->GetMemberTypeByName(Name); }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic) override { return ((SType*)pType)->GetMemberTypeBySemantic(Semantic); }
+ STDMETHOD_(LPCSTR, GetMemberName)(uint32_t Index) override { return ((SType*)pType)->GetMemberName(Index); }
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(uint32_t Index) override { return ((SType*)pType)->GetMemberSemantic(Index); }
+
+ IUNKNOWN_IMP(SSingleElementType, ID3DX11EffectType, IUnknown);
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Block definitions
+//////////////////////////////////////////////////////////////////////////
+
+void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, uint32_t Index);
+
+struct SBaseBlock
+{
+ EBlockType BlockType;
+
+ bool IsUserManaged:1;
+
+ uint32_t AssignmentCount;
+ SAssignment *pAssignments;
+
+ SBaseBlock();
+
+ bool ApplyAssignments(CEffect *pEffect);
+
+ inline SSamplerBlock *AsSampler() const
+ {
+ assert( BlockType == EBT_Sampler );
+ return (SSamplerBlock*) this;
+ }
+
+ inline SDepthStencilBlock *AsDepthStencil() const
+ {
+ assert( BlockType == EBT_DepthStencil );
+ return (SDepthStencilBlock*) this;
+ }
+
+ inline SBlendBlock *AsBlend() const
+ {
+ assert( BlockType == EBT_Blend );
+ return (SBlendBlock*) this;
+ }
+
+ inline SRasterizerBlock *AsRasterizer() const
+ {
+ assert( BlockType == EBT_Rasterizer );
+ return (SRasterizerBlock*) this;
+ }
+
+ inline SPassBlock *AsPass() const
+ {
+ assert( BlockType == EBT_Pass );
+ return (SPassBlock*) this;
+ }
+};
+
+struct STechnique : public ID3DX11EffectTechnique
+{
+ char *pName;
+
+ uint32_t PassCount;
+ SPassBlock *pPasses;
+
+ uint32_t AnnotationCount;
+ SAnnotation *pAnnotations;
+
+ bool InitiallyValid;
+ bool HasDependencies;
+
+ STechnique();
+
+ STDMETHOD_(bool, IsValid)() override;
+ STDMETHOD(GetDesc)(_Out_ D3DX11_TECHNIQUE_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override;
+
+ IUNKNOWN_IMP(STechnique, ID3DX11EffectTechnique, IUnknown);
+};
+
+struct SGroup : public ID3DX11EffectGroup
+{
+ char *pName;
+
+ uint32_t TechniqueCount;
+ STechnique *pTechniques;
+
+ uint32_t AnnotationCount;
+ SAnnotation *pAnnotations;
+
+ bool InitiallyValid;
+ bool HasDependencies;
+
+ SGroup();
+
+ STDMETHOD_(bool, IsValid)() override;
+ STDMETHOD(GetDesc)(_Out_ D3DX11_GROUP_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(_In_z_ LPCSTR Name) override;
+
+ IUNKNOWN_IMP(SGroup, ID3DX11EffectGroup, IUnknown);
+};
+
+struct SPassBlock : SBaseBlock, public ID3DX11EffectPass
+{
+ struct
+ {
+ ID3D11BlendState* pBlendState;
+ FLOAT BlendFactor[4];
+ uint32_t SampleMask;
+ ID3D11DepthStencilState *pDepthStencilState;
+ uint32_t StencilRef;
+ union
+ {
+ D3D11_SO_DECLARATION_ENTRY *pEntry;
+ char *pEntryDesc;
+ } GSSODesc;
+
+ // Pass assignments can write directly into these
+ SBlendBlock *pBlendBlock;
+ SDepthStencilBlock *pDepthStencilBlock;
+ SRasterizerBlock *pRasterizerBlock;
+ uint32_t RenderTargetViewCount;
+ SRenderTargetView *pRenderTargetViews[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
+ SDepthStencilView *pDepthStencilView;
+ SShaderBlock *pVertexShaderBlock;
+ SShaderBlock *pPixelShaderBlock;
+ SShaderBlock *pGeometryShaderBlock;
+ SShaderBlock *pComputeShaderBlock;
+ SShaderBlock *pDomainShaderBlock;
+ SShaderBlock *pHullShaderBlock;
+ } BackingStore;
+
+ char *pName;
+
+ uint32_t AnnotationCount;
+ SAnnotation *pAnnotations;
+
+ CEffect *pEffect;
+
+ bool InitiallyValid; // validity of all state objects and shaders in pass upon BindToDevice
+ bool HasDependencies; // if pass expressions or pass state blocks have dependencies on variables (if true, IsValid != InitiallyValid possibly)
+
+ SPassBlock();
+
+ void ApplyPassAssignments();
+ bool CheckShaderDependencies( _In_ const SShaderBlock* pBlock );
+ bool CheckDependencies();
+
+ template<EObjectType EShaderType>
+ HRESULT GetShaderDescHelper(_Out_ D3DX11_PASS_SHADER_DESC *pDesc);
+
+ STDMETHOD_(bool, IsValid)() override;
+ STDMETHOD(GetDesc)(_Out_ D3DX11_PASS_DESC *pDesc) override;
+
+ STDMETHOD(GetVertexShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+ STDMETHOD(GetGeometryShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+ STDMETHOD(GetPixelShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+ STDMETHOD(GetHullShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+ STDMETHOD(GetDomainShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+ STDMETHOD(GetComputeShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD(Apply)(_In_ uint32_t Flags, _In_ ID3D11DeviceContext* pContext) override;
+
+ STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override;
+
+ IUNKNOWN_IMP(SPassBlock, ID3DX11EffectPass, IUnknown);
+};
+
+struct SDepthStencilBlock : SBaseBlock
+{
+ ID3D11DepthStencilState *pDSObject;
+ D3D11_DEPTH_STENCIL_DESC BackingStore;
+ bool IsValid;
+
+ SDepthStencilBlock();
+};
+
+struct SBlendBlock : SBaseBlock
+{
+ ID3D11BlendState *pBlendObject;
+ D3D11_BLEND_DESC BackingStore;
+ bool IsValid;
+
+ SBlendBlock();
+};
+
+struct SRasterizerBlock : SBaseBlock
+{
+ ID3D11RasterizerState *pRasterizerObject;
+ D3D11_RASTERIZER_DESC BackingStore;
+ bool IsValid;
+
+ SRasterizerBlock();
+};
+
+struct SSamplerBlock : SBaseBlock
+{
+ ID3D11SamplerState *pD3DObject;
+ struct
+ {
+ D3D11_SAMPLER_DESC SamplerDesc;
+ // Sampler "TEXTURE" assignments can write directly into this
+ SShaderResource *pTexture;
+ } BackingStore;
+
+ SSamplerBlock();
+};
+
+struct SInterface
+{
+ SClassInstanceGlobalVariable* pClassInstance;
+
+ SInterface()
+ {
+ pClassInstance = nullptr;
+ }
+};
+
+struct SShaderResource
+{
+ ID3D11ShaderResourceView *pShaderResource;
+
+ SShaderResource()
+ {
+ pShaderResource = nullptr;
+ }
+
+};
+
+struct SUnorderedAccessView
+{
+ ID3D11UnorderedAccessView *pUnorderedAccessView;
+
+ SUnorderedAccessView()
+ {
+ pUnorderedAccessView = nullptr;
+ }
+
+};
+
+struct SRenderTargetView
+{
+ ID3D11RenderTargetView *pRenderTargetView;
+
+ SRenderTargetView();
+};
+
+struct SDepthStencilView
+{
+ ID3D11DepthStencilView *pDepthStencilView;
+
+ SDepthStencilView();
+};
+
+
+template<class T, class D3DTYPE> struct SShaderDependency
+{
+ uint32_t StartIndex;
+ uint32_t Count;
+
+ T *ppFXPointers; // Array of ptrs to FX objects (CBs, SShaderResources, etc)
+ D3DTYPE *ppD3DObjects; // Array of ptrs to matching D3D objects
+
+ SShaderDependency()
+ {
+ StartIndex = Count = 0;
+
+ ppD3DObjects = nullptr;
+ ppFXPointers = nullptr;
+ }
+};
+
+typedef SShaderDependency<SConstantBuffer*, ID3D11Buffer*> SShaderCBDependency;
+typedef SShaderDependency<SSamplerBlock*, ID3D11SamplerState*> SShaderSamplerDependency;
+typedef SShaderDependency<SShaderResource*, ID3D11ShaderResourceView*> SShaderResourceDependency;
+typedef SShaderDependency<SUnorderedAccessView*, ID3D11UnorderedAccessView*> SUnorderedAccessViewDependency;
+typedef SShaderDependency<SInterface*, ID3D11ClassInstance*> SInterfaceDependency;
+
+// Shader VTables are used to eliminate branching in ApplyShaderBlock.
+// The effect owns one D3DShaderVTables for each shader stage
+struct SD3DShaderVTable
+{
+ void ( __stdcall ID3D11DeviceContext::*pSetShader)(ID3D11DeviceChild* pShader, ID3D11ClassInstance*const* ppClassInstances, uint32_t NumClassInstances);
+ void ( __stdcall ID3D11DeviceContext::*pSetConstantBuffers)(uint32_t StartConstantSlot, uint32_t NumBuffers, ID3D11Buffer *const *pBuffers);
+ void ( __stdcall ID3D11DeviceContext::*pSetSamplers)(uint32_t Offset, uint32_t NumSamplers, ID3D11SamplerState*const* pSamplers);
+ void ( __stdcall ID3D11DeviceContext::*pSetShaderResources)(uint32_t Offset, uint32_t NumResources, ID3D11ShaderResourceView *const *pResources);
+ HRESULT ( __stdcall ID3D11Device::*pCreateShader)(const void *pShaderBlob, size_t ShaderBlobSize, ID3D11ClassLinkage* pClassLinkage, ID3D11DeviceChild **ppShader);
+};
+
+
+struct SShaderBlock
+{
+ enum ESigType
+ {
+ ST_Input,
+ ST_Output,
+ ST_PatchConstant,
+ };
+
+ struct SInterfaceParameter
+ {
+ char *pName;
+ uint32_t Index;
+ };
+
+ // this data is classified as reflection-only and will all be discarded at runtime
+ struct SReflectionData
+ {
+ uint8_t *pBytecode;
+ uint32_t BytecodeLength;
+ char *pStreamOutDecls[4]; // set with ConstructGSWithSO
+ uint32_t RasterizedStream; // set with ConstructGSWithSO
+ BOOL IsNullGS;
+ ID3D11ShaderReflection *pReflection;
+ uint32_t InterfaceParameterCount; // set with BindInterfaces (used for function interface parameters)
+ SInterfaceParameter *pInterfaceParameters; // set with BindInterfaces (used for function interface parameters)
+ };
+
+ bool IsValid;
+ SD3DShaderVTable *pVT;
+
+ // This value is nullptr if the shader is nullptr or was never initialized
+ SReflectionData *pReflectionData;
+
+ ID3D11DeviceChild *pD3DObject;
+
+ uint32_t CBDepCount;
+ SShaderCBDependency *pCBDeps;
+
+ uint32_t SampDepCount;
+ SShaderSamplerDependency *pSampDeps;
+
+ uint32_t InterfaceDepCount;
+ SInterfaceDependency *pInterfaceDeps;
+
+ uint32_t ResourceDepCount;
+ SShaderResourceDependency *pResourceDeps;
+
+ uint32_t UAVDepCount;
+ SUnorderedAccessViewDependency *pUAVDeps;
+
+ uint32_t TBufferDepCount;
+ SConstantBuffer **ppTbufDeps;
+
+ ID3DBlob *pInputSignatureBlob; // The input signature is separated from the bytecode because it
+ // is always available, even after Optimize() has been called.
+
+ SShaderBlock(SD3DShaderVTable *pVirtualTable = nullptr);
+
+ EObjectType GetShaderType();
+
+ HRESULT OnDeviceBind();
+
+ // Public API helpers
+ HRESULT ComputeStateBlockMask(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask);
+
+ HRESULT GetShaderDesc(_Out_ D3DX11_EFFECT_SHADER_DESC *pDesc, _In_ bool IsInline);
+
+ HRESULT GetVertexShader(_Outptr_ ID3D11VertexShader **ppVS);
+ HRESULT GetGeometryShader(_Outptr_ ID3D11GeometryShader **ppGS);
+ HRESULT GetPixelShader(_Outptr_ ID3D11PixelShader **ppPS);
+ HRESULT GetHullShader(_Outptr_ ID3D11HullShader **ppHS);
+ HRESULT GetDomainShader(_Outptr_ ID3D11DomainShader **ppDS);
+ HRESULT GetComputeShader(_Outptr_ ID3D11ComputeShader **ppCS);
+
+ HRESULT GetSignatureElementDesc(_In_ ESigType SigType, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
+};
+
+
+
+struct SString
+{
+ char *pString;
+
+ SString();
+};
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// Global Variable & Annotation structure/interface definitions
+//////////////////////////////////////////////////////////////////////////
+
+//
+// This is a general structure that can describe
+// annotations, variables, and structure members
+//
+struct SVariable
+{
+ // For annotations/variables/variable members:
+ // 1) If numeric, pointer to data (for variables: points into backing store,
+ // for annotations, points into reflection heap)
+ // OR
+ // 2) If object, pointer to the block. If object array, subsequent array elements are found in
+ // contiguous blocks; the Nth block is found by ((<SpecificBlockType> *) pBlock) + N
+ // (this is because variables that are arrays of objects have their blocks allocated contiguously)
+ //
+ // For structure members:
+ // Offset of this member (in bytes) from parent structure (structure members must be numeric/struct)
+ UDataPointer Data;
+ union
+ {
+ uint32_t MemberDataOffsetPlus4; // 4 added so that 0 == nullptr can represent "unused"
+ SMemberDataPointer *pMemberData;
+ };
+
+ SType *pType;
+ char *pName;
+ char *pSemantic;
+ uint32_t ExplicitBindPoint;
+
+ SVariable()
+ {
+ ZeroMemory(this, sizeof(*this));
+ ExplicitBindPoint = uint32_t(-1);
+ }
+};
+
+// Template definitions for all of the various ID3DX11EffectVariable specializations
+#include "EffectVariable.inl"
+
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderVariable (SAnonymousShader implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+struct SAnonymousShader : public TUncastableVariable<ID3DX11EffectShaderVariable>, public ID3DX11EffectType
+{
+ SShaderBlock *pShaderBlock;
+
+ SAnonymousShader(_In_ SShaderBlock *pBlock = nullptr);
+
+ // ID3DX11EffectShaderVariable interface
+ STDMETHOD_(bool, IsValid)() override;
+ STDMETHOD_(ID3DX11EffectType*, GetType)() override;
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index) override;
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override;
+
+ // other casts are handled by TUncastableVariable
+ STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() override;
+
+ STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetRawValue)(_Out_writes_bytes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(GetShaderDesc)(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) override;
+
+ STDMETHOD(GetVertexShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) override;
+ STDMETHOD(GetGeometryShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) override;
+ STDMETHOD(GetPixelShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) override;
+ STDMETHOD(GetHullShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) override;
+ STDMETHOD(GetDomainShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) override;
+ STDMETHOD(GetComputeShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) override;
+
+ STDMETHOD(GetInputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+ STDMETHOD(GetOutputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+ STDMETHOD(GetPatchConstantSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+
+ // ID3DX11EffectType interface
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(_In_z_ LPCSTR Semantic) override;
+
+ STDMETHOD_(LPCSTR, GetMemberName)(_In_ uint32_t Index) override;
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(_In_ uint32_t Index) override;
+
+ IUNKNOWN_IMP(SAnonymousShader, ID3DX11EffectShaderVariable, ID3DX11EffectVariable);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectConstantBuffer (SConstantBuffer implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+struct SConstantBuffer : public TUncastableVariable<ID3DX11EffectConstantBuffer>, public ID3DX11EffectType
+{
+ ID3D11Buffer *pD3DObject;
+ SShaderResource TBuffer; // nullptr iff IsTbuffer == false
+
+ uint8_t *pBackingStore;
+ uint32_t Size; // in bytes
+
+ char *pName;
+
+ uint32_t AnnotationCount;
+ SAnnotation *pAnnotations;
+
+ uint32_t VariableCount; // # of variables contained in this cbuffer
+ SGlobalVariable *pVariables; // array of size [VariableCount], points into effect's contiguous variable list
+ uint32_t ExplicitBindPoint; // Used when a CB has been explicitly bound (register(bXX)). -1 if not
+
+ bool IsDirty:1; // Set when any member is updated; cleared on CB apply
+ bool IsTBuffer:1; // true iff TBuffer.pShaderResource != nullptr
+ bool IsUserManaged:1; // Set if you don't want effects to update this buffer
+ bool IsEffectOptimized:1;// Set if the effect has been optimized
+ bool IsUsedByExpression:1;// Set if used by any expressions
+ bool IsUserPacked:1; // Set if the elements have user-specified offsets
+ bool IsSingle:1; // Set to true if you want to share this CB with cloned Effects
+ bool IsNonUpdatable:1; // Set to true if you want to share this CB with cloned Effects
+
+ union
+ {
+ // These are used to store the original ID3D11Buffer* for use in UndoSetConstantBuffer
+ uint32_t MemberDataOffsetPlus4; // 4 added so that 0 == nullptr can represent "unused"
+ SMemberDataPointer *pMemberData;
+ };
+
+ CEffect *pEffect;
+
+ SConstantBuffer()
+ {
+ pD3DObject = nullptr;
+ ZeroMemory(&TBuffer, sizeof(TBuffer));
+ ExplicitBindPoint = uint32_t(-1);
+ pBackingStore = nullptr;
+ Size = 0;
+ pName = nullptr;
+ VariableCount = 0;
+ pVariables = nullptr;
+ AnnotationCount = 0;
+ pAnnotations = nullptr;
+ IsDirty = false;
+ IsTBuffer = false;
+ IsUserManaged = false;
+ IsEffectOptimized = false;
+ IsUsedByExpression = false;
+ IsUserPacked = false;
+ IsSingle = false;
+ IsNonUpdatable = false;
+ pEffect = nullptr;
+ }
+
+ bool ClonedSingle() const;
+
+ // ID3DX11EffectConstantBuffer interface
+ STDMETHOD_(bool, IsValid)() override;
+ STDMETHOD_(ID3DX11EffectType*, GetType)() override;
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index) override;
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override;
+
+ // other casts are handled by TUncastableVariable
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() override;
+
+ STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetRawValue)(_Out_writes_bytes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetConstantBuffer)(_In_ ID3D11Buffer *pConstantBuffer) override;
+ STDMETHOD(GetConstantBuffer)(_Outptr_ ID3D11Buffer **ppConstantBuffer) override;
+ STDMETHOD(UndoSetConstantBuffer)() override;
+
+ STDMETHOD(SetTextureBuffer)(_In_ ID3D11ShaderResourceView *pTextureBuffer) override;
+ STDMETHOD(GetTextureBuffer)(_Outptr_ ID3D11ShaderResourceView **ppTextureBuffer) override;
+ STDMETHOD(UndoSetTextureBuffer)() override;
+
+ // ID3DX11EffectType interface
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(_In_z_ LPCSTR Semantic) override;
+
+ STDMETHOD_(LPCSTR, GetMemberName)(_In_ uint32_t Index) override;
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(_In_ uint32_t Index) override;
+
+ IUNKNOWN_IMP(SConstantBuffer, ID3DX11EffectConstantBuffer, ID3DX11EffectVariable);
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// Assignments
+//////////////////////////////////////////////////////////////////////////
+
+enum ERuntimeAssignmentType
+{
+ ERAT_Invalid,
+ // [Destination] refers to the destination location, which is always the backing store of the pass/state block.
+ // [Source] refers to the current source of data, always coming from either a constant buffer's
+ // backing store (for numeric assignments), an object variable's block array, or an anonymous (unowned) block
+
+ // Numeric variables:
+ ERAT_Constant, // Source is unused.
+ // No dependencies; this assignment can be safely removed after load.
+ ERAT_NumericVariable, // Source points to the CB's backing store where the value lives.
+ // 1 dependency: the variable itself.
+ ERAT_NumericConstIndex, // Source points to the CB's backing store where the value lives, offset by N.
+ // 1 dependency: the variable array being indexed.
+ ERAT_NumericVariableIndex, // Source points to the last used element of the variable in the CB's backing store.
+ // 2 dependencies: the index variable followed by the array variable.
+
+ // Object variables:
+ ERAT_ObjectInlineShader, // An anonymous, immutable shader block pointer is copied to the destination immediately.
+ // No dependencies; this assignment can be safely removed after load.
+ ERAT_ObjectVariable, // A pointer to the block owned by the object variable is copied to the destination immediately.
+ // No dependencies; this assignment can be safely removed after load.
+ ERAT_ObjectConstIndex, // A pointer to the Nth block owned by an object variable is copied to the destination immediately.
+ // No dependencies; this assignment can be safely removed after load.
+ ERAT_ObjectVariableIndex, // Source points to the first block owned by an object variable array
+ // (the offset from this, N, is taken from another variable).
+ // 1 dependency: the variable being used to index the array.
+};
+
+struct SAssignment
+{
+ struct SDependency
+ {
+ SGlobalVariable *pVariable;
+
+ SDependency()
+ {
+ pVariable = nullptr;
+ }
+ };
+
+ ELhsType LhsType; // PS, VS, DepthStencil etc.
+
+ // The value of SAssignment.AssignmentType determines how the other fields behave
+ // (DependencyCount, pDependencies, Destination, and Source)
+ ERuntimeAssignmentType AssignmentType;
+
+ Timer LastRecomputedTime;
+
+ // see comments in ERuntimeAssignmentType for how dependencies and data pointers are handled
+ uint32_t DependencyCount;
+ SDependency *pDependencies;
+
+ UDataPointer Destination; // This value never changes after load, and always refers to the backing store
+ UDataPointer Source; // This value, on the other hand, can change if variable- or expression- driven
+
+ uint32_t DataSize : 16; // Size of the data element to be copied in bytes (if numeric) or
+ // stride of the block type (if object)
+ uint32_t MaxElements : 16; // Max allowable index (needed because we don't store object arrays as dependencies,
+ // and therefore have no way of getting their Element count)
+
+ bool IsObjectAssignment() // True for Shader and RObject assignments (the type that appear in pass blocks)
+ {
+ return IsObjectAssignmentHelper(LhsType);
+ }
+
+ SAssignment()
+ {
+ LhsType = ELHS_Invalid;
+ AssignmentType = ERAT_Invalid;
+
+ Destination.pGeneric = nullptr;
+ Source.pGeneric = nullptr;
+
+ LastRecomputedTime = 0;
+ DependencyCount = 0;
+ pDependencies = nullptr;
+
+ DataSize = 0;
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Private effect heaps
+//////////////////////////////////////////////////////////////////////////
+
+// Used to efficiently reallocate data
+// 1) For every piece of data that needs reallocation, move it to its new location
+// and add an entry into the table
+// 2) For everyone that references one of these data blocks, do a quick table lookup
+// to find the old pointer and then replace it with the new one
+struct SPointerMapping
+{
+ void *pOld;
+ void *pNew;
+
+ static bool AreMappingsEqual(const SPointerMapping &pMap1, const SPointerMapping &pMap2)
+ {
+ return (pMap1.pOld == pMap2.pOld);
+ }
+
+ uint32_t Hash()
+ {
+ // hash the pointer itself
+ // (using the pointer as a hash would be very bad)
+ return ComputeHash((uint8_t*)&pOld, sizeof(pOld));
+ }
+};
+
+typedef CEffectHashTableWithPrivateHeap<SPointerMapping, SPointerMapping::AreMappingsEqual> CPointerMappingTable;
+
+// Assist adding data to a block of memory
+class CEffectHeap
+{
+protected:
+ uint8_t *m_pData;
+ uint32_t m_dwBufferSize;
+ uint32_t m_dwSize;
+
+ template <bool bCopyData>
+ HRESULT AddDataInternal(_In_reads_bytes_(dwSize) const void *pData, _In_ uint32_t dwSize, _Outptr_ void **ppPointer);
+
+public:
+ HRESULT ReserveMemory(uint32_t dwSize);
+ uint32_t GetSize();
+ uint8_t* GetDataStart() { return m_pData; }
+
+ // AddData and AddString append existing data to the buffer - they change m_dwSize. Users are
+ // not expected to modify the data pointed to by the return pointer
+ HRESULT AddString(_In_z_ const char *pString, _Outptr_result_z_ char **ppPointer);
+ HRESULT AddData(_In_reads_(dwSize) const void *pData, _In_ uint32_t dwSize, _Outptr_ void **ppPointer);
+
+ // Allocate behaves like a standard new - it will allocate memory, move m_dwSize. The caller is
+ // expected to use the returned pointer
+ void* Allocate(uint32_t dwSize);
+
+ // Move data from the general heap and optional free memory
+ HRESULT MoveData(_Inout_updates_bytes_(size) void **ppData, _In_ uint32_t size);
+ HRESULT MoveString(_Inout_updates_z_(1) char **ppStringData);
+ HRESULT MoveInterfaceParameters(_In_ uint32_t InterfaceCount, _Inout_updates_(1) SShaderBlock::SInterfaceParameter **ppInterfaces);
+ HRESULT MoveEmptyDataBlock(_Inout_updates_(1) void **ppData, _In_ uint32_t size);
+
+ bool IsInHeap(_In_ void *pData) const
+ {
+ return (pData >= m_pData && pData < (m_pData + m_dwBufferSize));
+ }
+
+ CEffectHeap();
+ ~CEffectHeap();
+};
+
+class CEffectReflection
+{
+public:
+ // Single memory block support
+ CEffectHeap m_Heap;
+};
+
+
+class CEffect : public ID3DX11Effect
+{
+ friend struct SBaseBlock;
+ friend struct SPassBlock;
+ friend class CEffectLoader;
+ friend struct SConstantBuffer;
+ friend struct TSamplerVariable<TGlobalVariable<ID3DX11EffectSamplerVariable>>;
+ friend struct TSamplerVariable<TVariable<TMember<ID3DX11EffectSamplerVariable>>>;
+
+protected:
+
+ uint32_t m_RefCount;
+ uint32_t m_Flags;
+
+ // Private heap - all pointers should point into here
+ CEffectHeap m_Heap;
+
+ // Reflection object
+ CEffectReflection *m_pReflection;
+
+ // global variables in the effect (aka parameters)
+ uint32_t m_VariableCount;
+ SGlobalVariable *m_pVariables;
+
+ // anonymous shader variables (one for every inline shader assignment)
+ uint32_t m_AnonymousShaderCount;
+ SAnonymousShader *m_pAnonymousShaders;
+
+ // techniques within this effect (the actual data is located in each group)
+ uint32_t m_TechniqueCount;
+
+ // groups within this effect
+ uint32_t m_GroupCount;
+ SGroup *m_pGroups;
+ SGroup *m_pNullGroup;
+
+ uint32_t m_ShaderBlockCount;
+ SShaderBlock *m_pShaderBlocks;
+
+ uint32_t m_DepthStencilBlockCount;
+ SDepthStencilBlock *m_pDepthStencilBlocks;
+
+ uint32_t m_BlendBlockCount;
+ SBlendBlock *m_pBlendBlocks;
+
+ uint32_t m_RasterizerBlockCount;
+ SRasterizerBlock *m_pRasterizerBlocks;
+
+ uint32_t m_SamplerBlockCount;
+ SSamplerBlock *m_pSamplerBlocks;
+
+ uint32_t m_MemberDataCount;
+ SMemberDataPointer *m_pMemberDataBlocks;
+
+ uint32_t m_InterfaceCount;
+ SInterface *m_pInterfaces;
+
+ uint32_t m_CBCount;
+ SConstantBuffer *m_pCBs;
+
+ uint32_t m_StringCount;
+ SString *m_pStrings;
+
+ uint32_t m_ShaderResourceCount;
+ SShaderResource *m_pShaderResources;
+
+ uint32_t m_UnorderedAccessViewCount;
+ SUnorderedAccessView *m_pUnorderedAccessViews;
+
+ uint32_t m_RenderTargetViewCount;
+ SRenderTargetView *m_pRenderTargetViews;
+
+ uint32_t m_DepthStencilViewCount;
+ SDepthStencilView *m_pDepthStencilViews;
+
+ Timer m_LocalTimer;
+
+ // temporary index variable for assignment evaluation
+ uint32_t m_FXLIndex;
+
+ ID3D11Device *m_pDevice;
+ ID3D11DeviceContext *m_pContext;
+ ID3D11ClassLinkage *m_pClassLinkage;
+
+ // Master lists of reflection interfaces
+ CEffectVectorOwner<SSingleElementType> m_pTypeInterfaces;
+ CEffectVectorOwner<SMember> m_pMemberInterfaces;
+
+ //////////////////////////////////////////////////////////////////////////
+ // String & Type pooling
+
+ typedef SType *LPSRUNTIMETYPE;
+ static bool AreTypesEqual(const LPSRUNTIMETYPE &pType1, const LPSRUNTIMETYPE &pType2) { return (pType1->IsEqual(pType2)); }
+ static bool AreStringsEqual(const LPCSTR &pStr1, const LPCSTR &pStr2) { return strcmp(pStr1, pStr2) == 0; }
+
+ typedef CEffectHashTableWithPrivateHeap<SType *, AreTypesEqual> CTypeHashTable;
+ typedef CEffectHashTableWithPrivateHeap<LPCSTR, AreStringsEqual> CStringHashTable;
+
+ // These are used to pool types & type-related strings
+ // until Optimize() is called
+ CTypeHashTable *m_pTypePool;
+ CStringHashTable *m_pStringPool;
+ CDataBlockStore *m_pPooledHeap;
+ // After Optimize() is called, the type/string pools should be deleted and all
+ // remaining data should be migrated into the optimized type heap
+ CEffectHeap *m_pOptimizedTypeHeap;
+
+ // Pools a string or type and modifies the pointer
+ void AddStringToPool(const char **ppString);
+ void AddTypeToPool(SType **ppType);
+
+ HRESULT OptimizeTypes(_Inout_ CPointerMappingTable *pMappingTable, _In_ bool Cloning = false);
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // Runtime (performance critical)
+
+ void ApplyShaderBlock(_In_ SShaderBlock *pBlock);
+ bool ApplyRenderStateBlock(_In_ SBaseBlock *pBlock);
+ bool ApplySamplerBlock(_In_ SSamplerBlock *pBlock);
+ void ApplyPassBlock(_Inout_ SPassBlock *pBlock);
+ bool EvaluateAssignment(_Inout_ SAssignment *pAssignment);
+ bool ValidateShaderBlock(_Inout_ SShaderBlock* pBlock );
+ bool ValidatePassBlock(_Inout_ SPassBlock* pBlock );
+
+ //////////////////////////////////////////////////////////////////////////
+ // Non-runtime functions (not performance critical)
+
+ SGlobalVariable *FindLocalVariableByName(_In_z_ LPCSTR pVarName); // Looks in the current effect only
+ SGlobalVariable *FindVariableByName(_In_z_ LPCSTR pVarName);
+ SVariable *FindVariableByNameWithParsing(_In_z_ LPCSTR pVarName);
+ SConstantBuffer *FindCB(_In_z_ LPCSTR pName);
+ void ReplaceCBReference(_In_ SConstantBuffer *pOldBufferBlock, _In_ ID3D11Buffer *pNewBuffer); // Used by user-managed CBs
+ void ReplaceSamplerReference(_In_ SSamplerBlock *pOldSamplerBlock, _In_ ID3D11SamplerState *pNewSampler);
+ void AddRefAllForCloning( _In_ CEffect* pEffectSource );
+ HRESULT CopyMemberInterfaces( _In_ CEffect* pEffectSource );
+ HRESULT CopyStringPool( _In_ CEffect* pEffectSource, _Inout_ CPointerMappingTable& mappingTable );
+ HRESULT CopyTypePool( _In_ CEffect* pEffectSource, _Inout_ CPointerMappingTable& mappingTableTypes, _Inout_ CPointerMappingTable& mappingTableStrings );
+ HRESULT CopyOptimizedTypePool( _In_ CEffect* pEffectSource, _Inout_ CPointerMappingTable& mappingTableTypes );
+ HRESULT RecreateCBs();
+ HRESULT FixupMemberInterface( _Inout_ SMember* pMember, _In_ CEffect* pEffectSource, _Inout_ CPointerMappingTable& mappingTableStrings );
+
+ void ValidateIndex(_In_ uint32_t Elements);
+
+ void IncrementTimer();
+ void HandleLocalTimerRollover();
+
+ friend struct SConstantBuffer;
+
+public:
+ CEffect( uint32_t Flags = 0 );
+ virtual ~CEffect();
+ void ReleaseShaderRefection();
+
+ // Initialize must be called after the effect is created
+ HRESULT LoadEffect(_In_reads_bytes_(cbEffectBuffer) const void *pEffectBuffer, _In_ uint32_t cbEffectBuffer);
+
+ // Once the effect is fully loaded, call BindToDevice to attach it to a device
+ HRESULT BindToDevice(_In_ ID3D11Device *pDevice, _In_z_ LPCSTR srcName );
+
+ Timer GetCurrentTime() const { return m_LocalTimer; }
+
+ bool IsReflectionData(void *pData) const { return m_pReflection->m_Heap.IsInHeap(pData); }
+ bool IsRuntimeData(void *pData) const { return m_Heap.IsInHeap(pData); }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Public interface
+
+ // IUnknown
+ STDMETHOD(QueryInterface)(REFIID iid, _COM_Outptr_ LPVOID *ppv) override;
+ STDMETHOD_(ULONG, AddRef)() override;
+ STDMETHOD_(ULONG, Release)() override;
+
+ // ID3DX11Effect
+ STDMETHOD_(bool, IsValid)() override { return true; }
+
+ STDMETHOD(GetDevice)(_Outptr_ ID3D11Device** ppDevice) override;
+
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_DESC *pDesc) override;
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableByName)(_In_z_ LPCSTR Name) override;
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableBySemantic)(_In_z_ LPCSTR Semantic) override;
+
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3DX11EffectGroup*, GetGroupByIndex)(_In_ uint32_t Index) override;
+ STDMETHOD_(ID3DX11EffectGroup*, GetGroupByName)(_In_z_ LPCSTR Name) override;
+
+ STDMETHOD_(ID3D11ClassLinkage*, GetClassLinkage)() override;
+
+ STDMETHOD(CloneEffect)(_In_ uint32_t Flags, _Outptr_ ID3DX11Effect** ppClonedEffect) override;
+ STDMETHOD(Optimize)() override;
+ STDMETHOD_(bool, IsOptimized)() override;
+
+ //////////////////////////////////////////////////////////////////////////
+ // New reflection helpers
+
+ ID3DX11EffectType * CreatePooledSingleElementTypeInterface(_In_ SType *pType);
+ ID3DX11EffectVariable * CreatePooledVariableMemberInterface(_In_ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity,
+ _In_ const SVariable *pMember,
+ _In_ const UDataPointer Data, _In_ bool IsSingleElement, _In_ uint32_t Index);
+
+};
+
+}
+
+#pragma warning(pop)
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectAPI.cpp
+//
+// Effect API entry point
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+
+#include <memory>
+
+using namespace D3DX11Effects;
+
+//-------------------------------------------------------------------------------------
+
+struct handle_closer { void operator()(HANDLE h) { if (h) CloseHandle(h); } };
+
+typedef public std::unique_ptr<void, handle_closer> ScopedHandle;
+
+inline HANDLE safe_handle( HANDLE h ) { return (h == INVALID_HANDLE_VALUE) ? 0 : h; }
+
+//-------------------------------------------------------------------------------------
+
+static HRESULT LoadBinaryFromFile( _In_z_ LPCWSTR pFileName, _Inout_ std::unique_ptr<uint8_t[]>& data, _Out_ uint32_t& size )
+{
+ // open the file
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
+ ScopedHandle hFile( safe_handle( CreateFile2( pFileName,
+ GENERIC_READ,
+ FILE_SHARE_READ,
+ OPEN_EXISTING,
+ nullptr ) ) );
+#else
+ ScopedHandle hFile( safe_handle( CreateFileW( pFileName,
+ GENERIC_READ,
+ FILE_SHARE_READ,
+ nullptr,
+ OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL,
+ nullptr ) ) );
+#endif
+
+ if ( !hFile )
+ {
+ return HRESULT_FROM_WIN32( GetLastError() );
+ }
+
+ // Get the file size
+ LARGE_INTEGER FileSize = { 0 };
+
+#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
+ FILE_STANDARD_INFO fileInfo;
+ if ( !GetFileInformationByHandleEx( hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo) ) )
+ {
+ return HRESULT_FROM_WIN32( GetLastError() );
+ }
+ FileSize = fileInfo.EndOfFile;
+#else
+ GetFileSizeEx( hFile.get(), &FileSize );
+#endif
+
+ // File is too big for 32-bit allocation or contains no data, so reject read
+ if ( !FileSize.LowPart || FileSize.HighPart > 0)
+ {
+ return E_FAIL;
+ }
+
+ // create enough space for the file data
+ data.reset( new uint8_t[ FileSize.LowPart ] );
+ if (!data)
+ {
+ return E_OUTOFMEMORY;
+ }
+
+ // read the data in
+ DWORD BytesRead = 0;
+ if (!ReadFile( hFile.get(),
+ data.get(),
+ FileSize.LowPart,
+ &BytesRead,
+ nullptr
+ ))
+ {
+ return HRESULT_FROM_WIN32( GetLastError() );
+ }
+
+ if (BytesRead < FileSize.LowPart)
+ {
+ return E_FAIL;
+ }
+
+ size = BytesRead;
+
+ return S_OK;
+}
+
+//--------------------------------------------------------------------------------------
+
+_Use_decl_annotations_
+HRESULT WINAPI D3DX11CreateEffectFromMemory(LPCVOID pData, SIZE_T DataLength, UINT FXFlags,
+ ID3D11Device *pDevice, ID3DX11Effect **ppEffect, LPCSTR srcName )
+{
+ if ( !pData || !DataLength || !pDevice || !ppEffect )
+ return E_INVALIDARG;
+
+#ifdef _M_X64
+ if ( DataLength > 0xFFFFFFFF )
+ return E_INVALIDARG;
+#endif
+
+ HRESULT hr = S_OK;
+
+ // Note that pData must point to a compiled effect, not HLSL
+ VN( *ppEffect = new CEffect( FXFlags & D3DX11_EFFECT_RUNTIME_VALID_FLAGS) );
+ VH( ((CEffect*)(*ppEffect))->LoadEffect(pData, static_cast<uint32_t>(DataLength) ) );
+ VH( ((CEffect*)(*ppEffect))->BindToDevice(pDevice, (srcName) ? srcName : "D3DX11Effect" ) );
+
+lExit:
+ if (FAILED(hr))
+ {
+ SAFE_RELEASE(*ppEffect);
+ }
+ return hr;
+}
+
+//--------------------------------------------------------------------------------------
+
+_Use_decl_annotations_
+HRESULT WINAPI D3DX11CreateEffectFromFile( LPCWSTR pFileName, UINT FXFlags, ID3D11Device *pDevice, ID3DX11Effect **ppEffect )
+{
+ if ( !pFileName || !pDevice || !ppEffect )
+ return E_INVALIDARG;
+
+ std::unique_ptr<uint8_t[]> fileData;
+ uint32_t size;
+ HRESULT hr = LoadBinaryFromFile( pFileName, fileData, size );
+ if ( FAILED(hr) )
+ return hr;
+
+ hr = S_OK;
+
+ // Note that pData must point to a compiled effect, not HLSL
+ VN( *ppEffect = new CEffect( FXFlags & D3DX11_EFFECT_RUNTIME_VALID_FLAGS) );
+ VH( ((CEffect*)(*ppEffect))->LoadEffect( fileData.get(), size ) );
+
+ // Create debug object name from input filename
+ CHAR strFileA[MAX_PATH];
+ int result = WideCharToMultiByte( CP_ACP, WC_NO_BEST_FIT_CHARS, pFileName, -1, strFileA, MAX_PATH, nullptr, FALSE );
+ if ( !result )
+ {
+ DPF(0, "Failed to load effect file due to WC to MB conversion failure: %S", pFileName);
+ hr = E_FAIL;
+ goto lExit;
+ }
+
+ const CHAR* pstrName = strrchr( strFileA, '\\' );
+ if (!pstrName)
+ {
+ pstrName = strFileA;
+ }
+ else
+ {
+ pstrName++;
+ }
+
+ VH( ((CEffect*)(*ppEffect))->BindToDevice(pDevice, pstrName) );
+
+lExit:
+ if (FAILED(hr))
+ {
+ SAFE_RELEASE(*ppEffect);
+ }
+ return hr;
+}
+
+
+//--------------------------------------------------------------------------------------
+
+_Use_decl_annotations_
+HRESULT D3DX11CompileEffectFromMemory( LPCVOID pData, SIZE_T DataLength, LPCSTR srcName,
+ const D3D_SHADER_MACRO *pDefines, ID3DInclude *pInclude, UINT HLSLFlags, UINT FXFlags,
+ ID3D11Device *pDevice, ID3DX11Effect **ppEffect, ID3DBlob **ppErrors )
+{
+ if ( !pData || !DataLength || !pDevice || !ppEffect )
+ return E_INVALIDARG;
+
+ if ( FXFlags & D3DCOMPILE_EFFECT_CHILD_EFFECT )
+ {
+ DPF(0, "Effect pools (i.e. D3DCOMPILE_EFFECT_CHILD_EFFECT) not supported" );
+ return E_NOTIMPL;
+ }
+
+ ID3DBlob *blob = nullptr;
+ HRESULT hr = D3DCompile( pData, DataLength, srcName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
+ if ( FAILED(hr) )
+ {
+ DPF(0, "D3DCompile of fx_5_0 profile failed: %08X", hr );
+ return hr;
+ }
+
+ hr = S_OK;
+
+ VN( *ppEffect = new CEffect( FXFlags & D3DX11_EFFECT_RUNTIME_VALID_FLAGS ) );
+ VH( ((CEffect*)(*ppEffect))->LoadEffect(blob->GetBufferPointer(), static_cast<uint32_t>( blob->GetBufferSize() ) ) );
+ SAFE_RELEASE( blob );
+
+ VH( ((CEffect*)(*ppEffect))->BindToDevice(pDevice, (srcName) ? srcName : "D3DX11Effect" ) );
+
+lExit:
+ if (FAILED(hr))
+ {
+ SAFE_RELEASE(*ppEffect);
+ }
+ return hr;
+}
+
+//--------------------------------------------------------------------------------------
+
+_Use_decl_annotations_
+HRESULT D3DX11CompileEffectFromFile( LPCWSTR pFileName,
+ const D3D_SHADER_MACRO *pDefines, ID3DInclude *pInclude, UINT HLSLFlags, UINT FXFlags,
+ ID3D11Device *pDevice, ID3DX11Effect **ppEffect, ID3DBlob **ppErrors )
+{
+ if ( !pFileName || !pDevice || !ppEffect )
+ return E_INVALIDARG;
+
+ if ( FXFlags & D3DCOMPILE_EFFECT_CHILD_EFFECT )
+ {
+ DPF(0, "Effect pools (i.e. D3DCOMPILE_EFFECT_CHILD_EFFECT) not supported" );
+ return E_NOTIMPL;
+ }
+
+ ID3DBlob *blob = nullptr;
+
+#if (D3D_COMPILER_VERSION >= 46) && ( !defined(WINAPI_FAMILY) || ( (WINAPI_FAMILY != WINAPI_FAMILY_APP) && (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP) ) )
+
+ HRESULT hr = D3DCompileFromFile( pFileName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
+ if ( FAILED(hr) )
+ {
+ DPF(0, "D3DCompileFromFile of fx_5_0 profile failed %08X: %S", hr, pFileName );
+ return hr;
+ }
+
+#else // D3D_COMPILER_VERSION < 46
+
+ std::unique_ptr<uint8_t[]> fileData;
+ uint32_t size;
+ HRESULT hr = LoadBinaryFromFile( pFileName, fileData, size );
+ if ( FAILED(hr) )
+ {
+ DPF(0, "Failed to load effect file %08X: %S", hr, pFileName);
+ return hr;
+ }
+
+ // Create debug object name from input filename
+ CHAR strFileA[MAX_PATH];
+ int result = WideCharToMultiByte( CP_ACP, WC_NO_BEST_FIT_CHARS, pFileName, -1, strFileA, MAX_PATH, nullptr, FALSE );
+ if ( !result )
+ {
+ DPF(0, "Failed to load effect file due to WC to MB conversion failure: %S", pFileName);
+ return E_FAIL;
+ }
+
+ const CHAR* pstrName = strrchr( strFileA, '\\' );
+ if (!pstrName)
+ {
+ pstrName = strFileA;
+ }
+ else
+ {
+ pstrName++;
+ }
+
+ hr = D3DCompile( fileData.get(), size, pstrName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
+ if ( FAILED(hr) )
+ {
+ DPF(0, "D3DCompile of fx_5_0 profile failed: %08X", hr );
+ return hr;
+ }
+
+#endif // D3D_COMPILER_VERSION
+
+#ifdef _M_X64
+ if ( blob->GetBufferSize() > 0xFFFFFFFF )
+ {
+ SAFE_RELEASE( blob );
+ return E_FAIL;
+ }
+#endif // _M_X64
+
+ hr = S_OK;
+
+ VN( *ppEffect = new CEffect( FXFlags & D3DX11_EFFECT_RUNTIME_VALID_FLAGS ) );
+ VH( ((CEffect*)(*ppEffect))->LoadEffect(blob->GetBufferPointer(), static_cast<uint32_t>( blob->GetBufferSize() ) ) );
+ SAFE_RELEASE( blob );
+
+#if (D3D_COMPILER_VERSION >= 46) && ( !defined(WINAPI_FAMILY) || ( (WINAPI_FAMILY != WINAPI_FAMILY_APP) && (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP) ) )
+ // Create debug object name from input filename
+ CHAR strFileA[MAX_PATH];
+ int result = WideCharToMultiByte( CP_ACP, WC_NO_BEST_FIT_CHARS, pFileName, -1, strFileA, MAX_PATH, nullptr, FALSE );
+ if ( !result )
+ {
+ DPF(0, "Failed to load effect file due to WC to MB conversion failure: %S", pFileName);
+ hr = E_FAIL;
+ goto lExit;
+ }
+
+ const CHAR* pstrName = strrchr( strFileA, '\\' );
+ if (!pstrName)
+ {
+ pstrName = strFileA;
+ }
+ else
+ {
+ pstrName++;
+ }
+#endif
+
+ VH( ((CEffect*)(*ppEffect))->BindToDevice(pDevice, pstrName) );
+
+lExit:
+ if (FAILED(hr))
+ {
+ SAFE_RELEASE(*ppEffect);
+ }
+ return hr;
+}
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectLoad.cpp
+//
+// Direct3D Effects file loading code
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+
+#include "EffectStates11.h"
+
+#define PRIVATENEW new(m_BulkHeap)
+
+namespace D3DX11Effects
+{
+
+static LPCSTR g_szEffectLoadArea = "D3D11EffectLoader";
+
+SRasterizerBlock g_NullRasterizer;
+SDepthStencilBlock g_NullDepthStencil;
+SBlendBlock g_NullBlend;
+SShaderResource g_NullTexture;
+SInterface g_NullInterface;
+SUnorderedAccessView g_NullUnorderedAccessView;
+SRenderTargetView g_NullRenderTargetView;
+SDepthStencilView g_NullDepthStencilView;
+
+// these VTables must be setup in the proper order:
+// 1) SetShader
+// 2) SetConstantBuffers
+// 3) SetSamplers
+// 4) SetShaderResources
+// 5) CreateShader
+SD3DShaderVTable g_vtPS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::PSSetShader,
+ &ID3D11DeviceContext::PSSetConstantBuffers,
+ &ID3D11DeviceContext::PSSetSamplers,
+ &ID3D11DeviceContext::PSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreatePixelShader
+};
+
+SD3DShaderVTable g_vtVS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::VSSetShader,
+ &ID3D11DeviceContext::VSSetConstantBuffers,
+ &ID3D11DeviceContext::VSSetSamplers,
+ &ID3D11DeviceContext::VSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateVertexShader
+};
+
+SD3DShaderVTable g_vtGS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::GSSetShader,
+ &ID3D11DeviceContext::GSSetConstantBuffers,
+ &ID3D11DeviceContext::GSSetSamplers,
+ &ID3D11DeviceContext::GSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateGeometryShader
+};
+
+SD3DShaderVTable g_vtHS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::HSSetShader,
+ &ID3D11DeviceContext::HSSetConstantBuffers,
+ &ID3D11DeviceContext::HSSetSamplers,
+ &ID3D11DeviceContext::HSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateHullShader
+};
+
+SD3DShaderVTable g_vtDS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::DSSetShader,
+ &ID3D11DeviceContext::DSSetConstantBuffers,
+ &ID3D11DeviceContext::DSSetSamplers,
+ &ID3D11DeviceContext::DSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateDomainShader
+};
+
+SD3DShaderVTable g_vtCS = {
+ (void (__stdcall ID3D11DeviceContext::*)(ID3D11DeviceChild*, ID3D11ClassInstance*const*, uint32_t)) &ID3D11DeviceContext::CSSetShader,
+ &ID3D11DeviceContext::CSSetConstantBuffers,
+ &ID3D11DeviceContext::CSSetSamplers,
+ &ID3D11DeviceContext::CSSetShaderResources,
+ (HRESULT (__stdcall ID3D11Device::*)(const void *, size_t, ID3D11ClassLinkage*, ID3D11DeviceChild **)) &ID3D11Device::CreateComputeShader
+};
+
+SShaderBlock g_NullVS(&g_vtVS);
+SShaderBlock g_NullGS(&g_vtGS);
+SShaderBlock g_NullPS(&g_vtPS);
+SShaderBlock g_NullHS(&g_vtHS);
+SShaderBlock g_NullDS(&g_vtDS);
+SShaderBlock g_NullCS(&g_vtCS);
+
+D3D_SHADER_VARIABLE_TYPE GetSimpleParameterTypeFromObjectType(EObjectType ObjectType)
+{
+ switch (ObjectType)
+ {
+ case EOT_String:
+ return D3D_SVT_STRING;
+ case EOT_Blend:
+ return D3D_SVT_BLEND;
+ case EOT_DepthStencil:
+ return D3D_SVT_DEPTHSTENCIL;
+ case EOT_Rasterizer:
+ return D3D_SVT_RASTERIZER;
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ return D3D_SVT_PIXELSHADER;
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ return D3D_SVT_VERTEXSHADER;
+ case EOT_GeometryShader:
+ case EOT_GeometryShaderSO:
+ case EOT_GeometryShader5:
+ return D3D_SVT_GEOMETRYSHADER;
+ case EOT_HullShader5:
+ return D3D_SVT_HULLSHADER;
+ case EOT_DomainShader5:
+ return D3D_SVT_DOMAINSHADER;
+ case EOT_ComputeShader5:
+ return D3D_SVT_COMPUTESHADER;
+ case EOT_RenderTargetView:
+ return D3D_SVT_RENDERTARGETVIEW;
+ case EOT_DepthStencilView:
+ return D3D_SVT_DEPTHSTENCILVIEW;
+ case EOT_Texture:
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ case EOT_Texture3D:
+ case EOT_TextureCube:
+ case EOT_TextureCubeArray:
+ return D3D_SVT_TEXTURE;
+ case EOT_Buffer:
+ return D3D_SVT_BUFFER;
+ case EOT_Sampler:
+ return D3D_SVT_SAMPLER;
+ case EOT_ByteAddressBuffer:
+ return D3D_SVT_BYTEADDRESS_BUFFER;
+ case EOT_StructuredBuffer:
+ return D3D_SVT_STRUCTURED_BUFFER;
+ case EOT_RWTexture1D:
+ return D3D_SVT_RWTEXTURE1D;
+ case EOT_RWTexture1DArray:
+ return D3D_SVT_RWTEXTURE1DARRAY;
+ case EOT_RWTexture2D:
+ return D3D_SVT_RWTEXTURE2D;
+ case EOT_RWTexture2DArray:
+ return D3D_SVT_RWTEXTURE2DARRAY;
+ case EOT_RWTexture3D:
+ return D3D_SVT_RWTEXTURE3D;
+ case EOT_RWBuffer:
+ return D3D_SVT_RWBUFFER;
+ case EOT_RWByteAddressBuffer:
+ return D3D_SVT_RWBYTEADDRESS_BUFFER;
+ case EOT_RWStructuredBuffer:
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ return D3D_SVT_RWSTRUCTURED_BUFFER;
+ case EOT_AppendStructuredBuffer:
+ return D3D_SVT_APPEND_STRUCTURED_BUFFER;
+ case EOT_ConsumeStructuredBuffer:
+ return D3D_SVT_CONSUME_STRUCTURED_BUFFER;
+ default:
+ assert(0);
+ }
+ return D3D_SVT_VOID;
+}
+
+inline HRESULT VerifyPointer(uint32_t oBase, uint32_t dwSize, uint32_t dwMaxSize)
+{
+ uint32_t dwAdd = oBase + dwSize;
+ if (dwAdd < oBase || dwAdd > dwMaxSize)
+ return E_FAIL;
+ return S_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// EffectHeap
+// A simple class which assists in adding data to a block of memory
+//////////////////////////////////////////////////////////////////////////
+
+CEffectHeap::CEffectHeap() : m_pData(nullptr), m_dwSize(0), m_dwBufferSize(0)
+{
+}
+
+CEffectHeap::~CEffectHeap()
+{
+ SAFE_DELETE_ARRAY(m_pData);
+}
+
+uint32_t CEffectHeap::GetSize()
+{
+ return m_dwSize;
+}
+
+HRESULT CEffectHeap::ReserveMemory(uint32_t dwSize)
+{
+ HRESULT hr = S_OK;
+
+ assert(!m_pData);
+ assert(dwSize == AlignToPowerOf2(dwSize, c_DataAlignment));
+
+ m_dwBufferSize = dwSize;
+
+ VN( m_pData = new uint8_t[m_dwBufferSize] );
+
+ // make sure that we have machine word alignment
+ assert(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT CEffectHeap::AddString(const char *pString, char **ppPointer)
+{
+ size_t size = strlen(pString) + 1;
+ assert( size <= 0xffffffff );
+ return AddData(pString, (uint32_t)size, (void**) ppPointer);
+}
+
+// This data is forcibly aligned, so make sure you account for that in calculating heap size
+template <bool bCopyData>
+HRESULT CEffectHeap::AddDataInternal(_In_reads_bytes_(dwSize) const void *pData, _In_ uint32_t dwSize, _Outptr_ void **ppPointer)
+{
+ CCheckedDword chkFinalSize( m_dwSize );
+ uint32_t finalSize;
+ HRESULT hr = S_OK;
+
+ chkFinalSize += dwSize;
+ chkFinalSize += c_DataAlignment; // account for alignment
+
+ VHD( chkFinalSize.GetValue(&finalSize), "Overflow while adding data to Effect heap." );
+
+ // align original value
+ finalSize = AlignToPowerOf2(finalSize - c_DataAlignment, c_DataAlignment);
+ VBD( finalSize <= m_dwBufferSize, "Overflow adding data to Effect heap." );
+
+ *ppPointer = m_pData + m_dwSize;
+ assert(*ppPointer == AlignToPowerOf2(*ppPointer, c_DataAlignment));
+
+ if( bCopyData )
+ {
+ memcpy(*ppPointer, pData, dwSize);
+ }
+ m_dwSize = finalSize;
+
+lExit:
+ if (FAILED(hr))
+ *ppPointer = nullptr;
+
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT CEffectHeap::AddData(const void *pData, uint32_t dwSize, void **ppPointer)
+{
+ return AddDataInternal<true>( pData, dwSize, ppPointer );
+}
+
+// Moves a string from the general heap to the private heap and modifies the pointer to
+// point to the new memory block.
+// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.
+// This data is forcibly aligned, so make sure you account for that in calculating heap size
+_Use_decl_annotations_
+HRESULT CEffectHeap::MoveString(char **ppString)
+{
+ HRESULT hr;
+ char *pNewPointer;
+
+ if (*ppString == nullptr)
+ return S_OK;
+
+ hr = AddString(*ppString, &pNewPointer);
+ if ( SUCCEEDED(hr) )
+ *ppString = pNewPointer;
+
+ return hr;
+}
+
+// Allocates space but does not move data
+// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.
+// This data is forcibly aligned, so make sure you account for that in calculating heap size
+_Use_decl_annotations_
+HRESULT CEffectHeap::MoveEmptyDataBlock(void **ppData, uint32_t size)
+{
+ HRESULT hr;
+ void *pNewPointer;
+
+ hr = AddDataInternal<false>(*ppData, size, &pNewPointer);
+
+ if (SUCCEEDED(hr))
+ {
+ *ppData = pNewPointer;
+ if (size == 0)
+ {
+ // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this
+ *ppData = nullptr;
+ }
+ }
+
+ return hr;
+}
+
+// Moves an array of SInterfaceParameters from the general heap to the private heap and modifies the pointer to
+// point to the new memory block.
+// The general heap is freed as a whole, so we don't worry about leaking the given string pointer.
+// This data is forcibly aligned, so make sure you account for that in calculating heap size
+_Use_decl_annotations_
+HRESULT CEffectHeap::MoveInterfaceParameters(uint32_t InterfaceCount, SShaderBlock::SInterfaceParameter **ppInterfaces)
+{
+ HRESULT hr;
+ SShaderBlock::SInterfaceParameter *pNewPointer;
+
+ if (*ppInterfaces == nullptr)
+ return S_OK;
+
+ VBD( InterfaceCount <= D3D11_SHADER_MAX_INTERFACES, "Internal loading error: InterfaceCount > D3D11_SHADER_MAX_INTERFACES." );
+ VH( AddData(*ppInterfaces, InterfaceCount * sizeof(SShaderBlock::SInterfaceParameter), (void**)&pNewPointer) );
+
+ for( size_t i=0; i < InterfaceCount; i++ )
+ {
+ VH( MoveString( &pNewPointer[i].pName ) );
+ }
+
+ *ppInterfaces = pNewPointer;
+
+lExit:
+ return hr;
+}
+
+
+// Moves data from the general heap to the private heap and modifies the pointer to
+// point to the new memory block
+// The general heap is freed as a whole, so we don't worry about leaking the given pointer.
+// This data is forcibly aligned, so make sure you account for that in calculating heap size
+_Use_decl_annotations_
+HRESULT CEffectHeap::MoveData(void **ppData, uint32_t size)
+{
+ HRESULT hr;
+ void *pNewPointer;
+
+ hr = AddData(*ppData, size, &pNewPointer);
+ if ( SUCCEEDED(hr) )
+ {
+ *ppData = pNewPointer;
+ if (size == 0)
+ {
+ // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this
+ *ppData = nullptr;
+ }
+ }
+
+ return hr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// Load API
+//////////////////////////////////////////////////////////////////////////
+
+_Use_decl_annotations_
+HRESULT CEffect::LoadEffect(const void *pEffectBuffer, uint32_t cbEffectBuffer)
+{
+ HRESULT hr = S_OK;
+ CEffectLoader loader;
+
+ if (!pEffectBuffer)
+ {
+ DPF(0, "%s: pEffectBuffer is nullptr.", g_szEffectLoadArea);
+ VH( E_INVALIDARG );
+ }
+
+ VH( loader.LoadEffect(this, pEffectBuffer, cbEffectBuffer) );
+
+lExit:
+ if( FAILED( hr ) )
+ {
+ // Release here because m_pShaderBlocks may still be in loader.m_BulkHeap if loading failed before we reallocated the memory
+ ReleaseShaderRefection();
+ }
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// CEffectLoader
+// A helper class which loads an effect
+//////////////////////////////////////////////////////////////////////////
+
+_Use_decl_annotations_
+HRESULT CEffectLoader::GetUnstructuredDataBlock(uint32_t offset, uint32_t *pdwSize, void **ppData)
+{
+ HRESULT hr = S_OK;
+ uint32_t *pBlockSize;
+
+ VH( m_msUnstructured.ReadAtOffset(offset, sizeof(*pBlockSize), (void**) &pBlockSize ) );
+ *pdwSize = *pBlockSize;
+
+ VH( m_msUnstructured.Read(ppData, *pdwSize) );
+
+lExit:
+ return hr;
+}
+
+// position in buffer is lost on error
+//
+// This function should be used in 1:1 conjunction with CEffectHeap::MoveString;
+// that is, any string added to the reflection heap with this function
+// must be relocated with MoveString at some point later on.
+_Use_decl_annotations_
+HRESULT CEffectLoader::GetStringAndAddToReflection(uint32_t offset, char **ppString)
+{
+ HRESULT hr = S_OK;
+ LPCSTR pName;
+ size_t oldPos;
+
+ if (offset == 0)
+ {
+ *ppString = nullptr;
+ goto lExit;
+ }
+
+ oldPos = m_msUnstructured.GetPosition();
+
+ VH( m_msUnstructured.ReadAtOffset(offset, &pName) );
+ m_ReflectionMemory += AlignToPowerOf2( (uint32_t)strlen(pName) + 1, c_DataAlignment);
+ *ppString = const_cast<char*>(pName);
+
+ m_msUnstructured.Seek(oldPos);
+
+lExit:
+ return hr;
+}
+
+// position in buffer is lost on error
+//
+// This function should be used in 1:1 conjunction with CEffectHeap::MoveInterfaceParameters;
+// that is, any array of parameters added to the reflection heap with this function
+// must be relocated with MoveInterfaceParameters at some point later on.
+_Use_decl_annotations_
+HRESULT CEffectLoader::GetInterfaceParametersAndAddToReflection( uint32_t InterfaceCount, uint32_t offset, SShaderBlock::SInterfaceParameter **ppInterfaces )
+{
+ HRESULT hr = S_OK;
+ SBinaryInterfaceInitializer* pInterfaceInitializer;
+ size_t oldPos;
+
+ if (offset == 0)
+ {
+ *ppInterfaces = nullptr;
+ goto lExit;
+ }
+
+ oldPos = m_msUnstructured.GetPosition();
+
+ VBD( InterfaceCount <= D3D11_SHADER_MAX_INTERFACES, "Internal loading error: InterfaceCount > D3D11_SHADER_MAX_INTERFACES." );
+ m_ReflectionMemory += AlignToPowerOf2(InterfaceCount * sizeof(SShaderBlock::SInterfaceParameter), c_DataAlignment);
+ assert( ppInterfaces != 0 );
+ _Analysis_assume_( ppInterfaces != 0 );
+ (*ppInterfaces) = PRIVATENEW SShaderBlock::SInterfaceParameter[InterfaceCount];
+ VN( *ppInterfaces );
+
+ VHD( m_msUnstructured.ReadAtOffset(offset, sizeof(SBinaryInterfaceInitializer) * InterfaceCount, (void**)&pInterfaceInitializer),
+ "Invalid pEffectBuffer: cannot read interface initializer." );
+
+ for( size_t i=0; i < InterfaceCount; i++ )
+ {
+ (*ppInterfaces)[i].Index = pInterfaceInitializer[i].ArrayIndex;
+ VHD( m_msUnstructured.ReadAtOffset(pInterfaceInitializer[i].oInstanceName, const_cast<LPCSTR*>(&(*ppInterfaces)[i].pName)),
+ "Invalid pEffectBuffer: cannot read interface initializer." );
+ m_ReflectionMemory += AlignToPowerOf2( (uint32_t)strlen((*ppInterfaces)[i].pName) + 1, c_DataAlignment);
+ }
+
+ m_msUnstructured.Seek(oldPos);
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupCBPointer(_Inout_ SConstantBuffer **ppCB)
+{
+ HRESULT hr = S_OK;
+
+ size_t index = (SConstantBuffer*)*ppCB - m_pOldCBs;
+ assert( index * sizeof(SConstantBuffer) == ((size_t)(SConstantBuffer*)*ppCB - (size_t)m_pOldCBs) );
+ VBD( index < m_pEffect->m_CBCount, "Internal loading error: invalid constant buffer index." );
+ *ppCB = (SConstantBuffer*)(m_pEffect->m_pCBs + index);
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupShaderPointer(_Inout_ SShaderBlock **ppShaderBlock)
+{
+ HRESULT hr = S_OK;
+ if (*ppShaderBlock != &g_NullVS && *ppShaderBlock != &g_NullGS && *ppShaderBlock != &g_NullPS &&
+ *ppShaderBlock != &g_NullHS && *ppShaderBlock != &g_NullDS && *ppShaderBlock != &g_NullCS &&
+ *ppShaderBlock != nullptr)
+ {
+ size_t index = *ppShaderBlock - m_pOldShaders;
+ assert( index * sizeof(SShaderBlock) == ((size_t)*ppShaderBlock - (size_t)m_pOldShaders) );
+ VBD( index < m_pEffect->m_ShaderBlockCount, "Internal loading error: invalid shader index." );
+ *ppShaderBlock = m_pEffect->m_pShaderBlocks + index;
+ }
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupDSPointer(_Inout_ SDepthStencilBlock **ppDSBlock)
+{
+ HRESULT hr = S_OK;
+ if (*ppDSBlock != &g_NullDepthStencil && *ppDSBlock != nullptr)
+ {
+ size_t index = *ppDSBlock - m_pOldDS;
+ assert( index * sizeof(SDepthStencilBlock) == ((size_t)*ppDSBlock - (size_t)m_pOldDS) );
+ VBD( index < m_pEffect->m_DepthStencilBlockCount, "Internal loading error: invalid depth-stencil state index." );
+ *ppDSBlock = m_pEffect->m_pDepthStencilBlocks + index;
+ }
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupABPointer(_Inout_ SBlendBlock **ppABBlock)
+{
+ HRESULT hr = S_OK;
+ if (*ppABBlock != &g_NullBlend && *ppABBlock != nullptr)
+ {
+ size_t index = *ppABBlock - m_pOldAB;
+ assert( index * sizeof(SBlendBlock) == ((size_t)*ppABBlock - (size_t)m_pOldAB) );
+ VBD( index < m_pEffect->m_BlendBlockCount, "Internal loading error: invalid blend state index." );
+ *ppABBlock = m_pEffect->m_pBlendBlocks + index;
+ }
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupRSPointer(_Inout_ SRasterizerBlock **ppRSBlock)
+{
+ HRESULT hr = S_OK;
+ if (*ppRSBlock != &g_NullRasterizer && *ppRSBlock != nullptr)
+ {
+ size_t index = *ppRSBlock - m_pOldRS;
+ assert( index * sizeof(SRasterizerBlock) == ((size_t)*ppRSBlock - (size_t)m_pOldRS) );
+ VBD( index < m_pEffect->m_RasterizerBlockCount, "Internal loading error: invalid rasterizer state index." );
+ *ppRSBlock = m_pEffect->m_pRasterizerBlocks + index;
+ }
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupSamplerPointer(_Inout_ SSamplerBlock **ppSampler)
+{
+ HRESULT hr = S_OK;
+ size_t index = *ppSampler - m_pOldSamplers;
+ assert( index * sizeof(SSamplerBlock) == ((size_t)*ppSampler - (size_t)m_pOldSamplers) );
+ VBD( index < m_pEffect->m_SamplerBlockCount, "Internal loading error: invalid sampler index." );
+ *ppSampler = m_pEffect->m_pSamplerBlocks + index;
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupInterfacePointer(_Inout_ SInterface **ppInterface, _In_ bool CheckBackgroundInterfaces)
+{
+ HRESULT hr = S_OK;
+ if (*ppInterface != &g_NullInterface && *ppInterface != nullptr)
+ {
+ size_t index = *ppInterface - m_pOldInterfaces;
+ if(index < m_OldInterfaceCount)
+ {
+ assert( index * sizeof(SInterface) == ((size_t)*ppInterface - (size_t)m_pOldInterfaces) );
+ *ppInterface = m_pEffect->m_pInterfaces + index;
+ }
+ else
+ {
+ VBD( CheckBackgroundInterfaces, "Internal loading error: invalid interface pointer." );
+ for( index=0; index < m_BackgroundInterfaces.GetSize(); index++ )
+ {
+ if( *ppInterface == m_BackgroundInterfaces[ (uint32_t)index ] )
+ {
+ // The interfaces m_BackgroundInterfaces were concatenated to the original ones in m_pEffect->m_pInterfaces
+ *ppInterface = m_pEffect->m_pInterfaces + (m_OldInterfaceCount + index);
+ break;
+ }
+ }
+ VBD( index < m_BackgroundInterfaces.GetSize(), "Internal loading error: invalid interface pointer." );
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupShaderResourcePointer(_Inout_ SShaderResource **ppResource)
+{
+ HRESULT hr = S_OK;
+ if (*ppResource != &g_NullTexture && *ppResource != nullptr)
+ {
+ size_t index = *ppResource - m_pOldShaderResources;
+ assert( index * sizeof(SShaderResource) == ((size_t)*ppResource - (size_t)m_pOldShaderResources) );
+
+ // could be a TBuffer or a texture; better check first
+ if (index < m_pEffect->m_ShaderResourceCount)
+ {
+ *ppResource = m_pEffect->m_pShaderResources + index;
+ }
+ else
+ {
+ // if this is a TBuffer, then the shader resource pointer
+ // actually points into a SConstantBuffer's TBuffer field
+ index = (SConstantBuffer*)*ppResource - (SConstantBuffer*)&m_pOldCBs->TBuffer;
+ assert( index * sizeof(SConstantBuffer) == ((size_t)(SConstantBuffer*)*ppResource - (size_t)(SConstantBuffer*)&m_pOldCBs->TBuffer) );
+ VBD( index < m_pEffect->m_CBCount, "Internal loading error: invalid SRV index." );
+ *ppResource = &m_pEffect->m_pCBs[index].TBuffer;
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupUnorderedAccessViewPointer(_Inout_ SUnorderedAccessView **ppUnorderedAccessView)
+{
+ HRESULT hr = S_OK;
+ if (*ppUnorderedAccessView != &g_NullUnorderedAccessView && *ppUnorderedAccessView != nullptr)
+ {
+ size_t index = *ppUnorderedAccessView - m_pOldUnorderedAccessViews;
+ assert( index * sizeof(SUnorderedAccessView) == ((size_t)*ppUnorderedAccessView - (size_t)m_pOldUnorderedAccessViews) );
+
+ VBD( index < m_pEffect->m_UnorderedAccessViewCount, "Internal loading error: invalid UAV index." );
+ *ppUnorderedAccessView = m_pEffect->m_pUnorderedAccessViews + index;
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupRenderTargetViewPointer(_Inout_ SRenderTargetView **ppRenderTargetView)
+{
+ HRESULT hr = S_OK;
+ if (*ppRenderTargetView != &g_NullRenderTargetView && *ppRenderTargetView != nullptr)
+ {
+ size_t index = *ppRenderTargetView - m_pOldRenderTargetViews;
+ assert( index * sizeof(SRenderTargetView) == ((size_t)*ppRenderTargetView - (size_t)m_pOldRenderTargetViews) );
+ VBD( index < m_pEffect->m_RenderTargetViewCount, "Internal loading error: invalid RTV index." );
+ *ppRenderTargetView = m_pEffect->m_pRenderTargetViews + index;
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupDepthStencilViewPointer(_Inout_ SDepthStencilView **ppDepthStencilView)
+{
+ HRESULT hr = S_OK;
+ if (*ppDepthStencilView != &g_NullDepthStencilView && *ppDepthStencilView != nullptr)
+ {
+ size_t index = *ppDepthStencilView - m_pOldDepthStencilViews;
+ assert( index * sizeof(SDepthStencilView) == ((size_t)*ppDepthStencilView - (size_t)m_pOldDepthStencilViews) );
+ VBD( index < m_pEffect->m_DepthStencilViewCount, "Internal loading error: invalid DSV index." );
+ *ppDepthStencilView = m_pEffect->m_pDepthStencilViews + index;
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupStringPointer(_Inout_ SString **ppString)
+{
+ HRESULT hr = S_OK;
+ size_t index = *ppString - m_pOldStrings;
+ assert( index * sizeof(SString) == ((size_t)*ppString - (size_t)m_pOldStrings) );
+ VBD(index < m_pEffect->m_StringCount, "Internal loading error: invalid string index." );
+ *ppString = m_pEffect->m_pStrings + index;
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupMemberDataPointer(_Inout_ SMemberDataPointer **ppMemberData)
+{
+ HRESULT hr = S_OK;
+ size_t index = *ppMemberData - m_pOldMemberDataBlocks;
+ assert( index * sizeof(SMemberDataPointer) == ((size_t)*ppMemberData - (size_t)m_pOldMemberDataBlocks) );
+ VBD( index < m_pEffect->m_MemberDataCount, "Internal loading error: invalid member block index." );
+ *ppMemberData = m_pEffect->m_pMemberDataBlocks + index;
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupVariablePointer(_Inout_ SGlobalVariable **ppVar)
+{
+ HRESULT hr = S_OK;
+ size_t index = *ppVar - m_pOldVars;
+
+ if( index < m_pEffect->m_VariableCount )
+ {
+ assert( index * sizeof(SGlobalVariable) == ((size_t)*ppVar - (size_t)m_pOldVars) );
+ *ppVar = m_pEffect->m_pVariables + index;
+ }
+ else if( m_pvOldMemberInterfaces )
+ {
+ // When cloning, m_pvOldMemberInterfaces may be non-nullptr, and *ppVar may point to a variable in it.
+ const size_t Members = m_pvOldMemberInterfaces->GetSize();
+ for( index=0; index < Members; index++ )
+ {
+ if( (ID3DX11EffectVariable*)(*m_pvOldMemberInterfaces)[ (uint32_t)index] == (ID3DX11EffectVariable*)*ppVar )
+ {
+ break;
+ }
+ }
+ VBD( index < Members, "Internal loading error: invalid member pointer." );
+ *ppVar = (SGlobalVariable*)m_pEffect->m_pMemberInterfaces[ (uint32_t)index];
+ }
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::FixupGroupPointer(_Inout_ SGroup **ppGroup)
+{
+ HRESULT hr = S_OK;
+ if( *ppGroup != nullptr )
+ {
+ size_t index = *ppGroup - m_pOldGroups;
+ assert( index * sizeof(SGroup) == ((size_t)*ppGroup - (size_t)m_pOldGroups) );
+ VBD( index < m_pEffect->m_GroupCount, "Internal loading error: invalid group index." );
+ *ppGroup = m_pEffect->m_pGroups + index;
+ }
+lExit:
+ return hr;
+}
+
+static HRESULT GetEffectVersion( _In_ uint32_t effectFileTag, _Out_ DWORD* pVersion )
+{
+ assert( pVersion != nullptr );
+ if( !pVersion )
+ return E_FAIL;
+
+ for( size_t i = 0; i < _countof(g_EffectVersions); i++ )
+ {
+ if( g_EffectVersions[i].m_Tag == effectFileTag )
+ {
+ *pVersion = g_EffectVersions[i].m_Version;
+ return S_OK;
+ }
+ }
+
+ return E_FAIL;
+}
+
+_Use_decl_annotations_
+HRESULT CEffectLoader::LoadEffect(CEffect *pEffect, const void *pEffectBuffer, uint32_t cbEffectBuffer)
+{
+
+ HRESULT hr = S_OK;
+ uint32_t i, varSize, cMemberDataBlocks;
+ CCheckedDword chkVariables = 0;
+
+ // Used for cloning
+ m_pvOldMemberInterfaces = nullptr;
+
+ m_BulkHeap.EnableAlignment();
+
+ assert(pEffect && pEffectBuffer);
+ m_pEffect = pEffect;
+ m_EffectMemory = m_ReflectionMemory = 0;
+
+ VN( m_pEffect->m_pReflection = new CEffectReflection() );
+ m_pReflection = m_pEffect->m_pReflection;
+
+ // Begin effect load
+ VN( m_pEffect->m_pTypePool = new CEffect::CTypeHashTable );
+ VN( m_pEffect->m_pStringPool = new CEffect::CStringHashTable );
+ VN( m_pEffect->m_pPooledHeap = new CDataBlockStore );
+ m_pEffect->m_pPooledHeap->EnableAlignment();
+ m_pEffect->m_pTypePool->SetPrivateHeap(m_pEffect->m_pPooledHeap);
+ m_pEffect->m_pStringPool->SetPrivateHeap(m_pEffect->m_pPooledHeap);
+
+ VH( m_pEffect->m_pTypePool->AutoGrow() );
+ VH( m_pEffect->m_pStringPool->AutoGrow() );
+
+ // Load from blob
+ m_pData = (uint8_t*)pEffectBuffer;
+ m_dwBufferSize = cbEffectBuffer;
+
+ VH( m_msStructured.SetData(m_pData, m_dwBufferSize) );
+
+ // At this point, we assume that the blob is valid
+ VHD( m_msStructured.Read((void**) &m_pHeader, sizeof(*m_pHeader)), "pEffectBuffer is too small." );
+
+ // Verify the version
+ if( FAILED( hr = GetEffectVersion( m_pHeader->Tag, &m_Version ) ) )
+ {
+ DPF(0, "Effect version is unrecognized. This runtime supports fx_5_0 to %s.", g_EffectVersions[_countof(g_EffectVersions)-1].m_pName );
+ VH( hr );
+ }
+
+ if( m_pHeader->RequiresPool() || m_pHeader->Pool.cObjectVariables > 0 || m_pHeader->Pool.cNumericVariables > 0 )
+ {
+ DPF(0, "Effect11 does not support EffectPools." );
+ VH( E_FAIL );
+ }
+
+ // Get shader block count
+ VBD( m_pHeader->cInlineShaders <= m_pHeader->cTotalShaders, "Invalid Effect header: cInlineShaders > cTotalShaders." );
+
+ // Make sure the counts for the Effect don't overflow
+ chkVariables = m_pHeader->Effect.cObjectVariables;
+ chkVariables += m_pHeader->Effect.cNumericVariables;
+ chkVariables += m_pHeader->cInterfaceVariables;
+ chkVariables *= sizeof(SGlobalVariable);
+ VH( chkVariables.GetValue(&varSize) );
+
+ // Make sure the counts for the SMemberDataPointers don't overflow
+ chkVariables = m_pHeader->cClassInstanceElements;
+ chkVariables += m_pHeader->cBlendStateBlocks;
+ chkVariables += m_pHeader->cRasterizerStateBlocks;
+ chkVariables += m_pHeader->cDepthStencilBlocks;
+ chkVariables += m_pHeader->cSamplers;
+ chkVariables += m_pHeader->Effect.cCBs; // Buffer (for CBuffers and TBuffers)
+ chkVariables += m_pHeader->Effect.cCBs; // SRV (for TBuffers)
+ VHD( chkVariables.GetValue(&cMemberDataBlocks), "Overflow: too many Effect variables." );
+
+ // Allocate effect resources
+ VN( m_pEffect->m_pCBs = PRIVATENEW SConstantBuffer[m_pHeader->Effect.cCBs] );
+ VN( m_pEffect->m_pDepthStencilBlocks = PRIVATENEW SDepthStencilBlock[m_pHeader->cDepthStencilBlocks] );
+ VN( m_pEffect->m_pRasterizerBlocks = PRIVATENEW SRasterizerBlock[m_pHeader->cRasterizerStateBlocks] );
+ VN( m_pEffect->m_pBlendBlocks = PRIVATENEW SBlendBlock[m_pHeader->cBlendStateBlocks] );
+ VN( m_pEffect->m_pSamplerBlocks = PRIVATENEW SSamplerBlock[m_pHeader->cSamplers] );
+
+ // we allocate raw bytes for variables because they are polymorphic types that need to be placement new'ed
+ VN( m_pEffect->m_pVariables = (SGlobalVariable *)PRIVATENEW uint8_t[varSize] );
+ VN( m_pEffect->m_pAnonymousShaders = PRIVATENEW SAnonymousShader[m_pHeader->cInlineShaders] );
+
+ VN( m_pEffect->m_pGroups = PRIVATENEW SGroup[m_pHeader->cGroups] );
+ VN( m_pEffect->m_pShaderBlocks = PRIVATENEW SShaderBlock[m_pHeader->cTotalShaders] );
+ VN( m_pEffect->m_pStrings = PRIVATENEW SString[m_pHeader->cStrings] );
+ VN( m_pEffect->m_pShaderResources = PRIVATENEW SShaderResource[m_pHeader->cShaderResources] );
+ VN( m_pEffect->m_pUnorderedAccessViews = PRIVATENEW SUnorderedAccessView[m_pHeader->cUnorderedAccessViews] );
+ VN( m_pEffect->m_pInterfaces = PRIVATENEW SInterface[m_pHeader->cInterfaceVariableElements] );
+ VN( m_pEffect->m_pMemberDataBlocks = PRIVATENEW SMemberDataPointer[cMemberDataBlocks] );
+ VN( m_pEffect->m_pRenderTargetViews = PRIVATENEW SRenderTargetView[m_pHeader->cRenderTargetViews] );
+ VN( m_pEffect->m_pDepthStencilViews = PRIVATENEW SDepthStencilView[m_pHeader->cDepthStencilViews] );
+
+ uint32_t oStructured = m_pHeader->cbUnstructured + sizeof(SBinaryHeader5);
+ VHD( m_msStructured.Seek(oStructured), "Invalid pEffectBuffer: Missing structured data block." );
+ VH( m_msUnstructured.SetData(m_pData + sizeof(SBinaryHeader5), oStructured - sizeof(SBinaryHeader5)) );
+
+ VH( LoadCBs() );
+ VH( LoadObjectVariables() );
+ VH( LoadInterfaceVariables() );
+ VH( LoadGroups() );
+
+ // Build shader dependencies
+ for (i=0; i<m_pEffect->m_ShaderBlockCount; i++)
+ {
+ VH( BuildShaderBlock(&m_pEffect->m_pShaderBlocks[i]) );
+ }
+
+ for( size_t iGroup=0; iGroup<m_pHeader->cGroups; iGroup++ )
+ {
+ SGroup *pGroup = &m_pEffect->m_pGroups[iGroup];
+ pGroup->HasDependencies = false;
+
+ for( size_t iTechnique=0; iTechnique < pGroup->TechniqueCount; iTechnique++ )
+ {
+ STechnique* pTech = &pGroup->pTechniques[iTechnique];
+ pTech->HasDependencies = false;
+
+ for( size_t iPass=0; iPass < pTech->PassCount; iPass++ )
+ {
+ SPassBlock *pPass = &pTech->pPasses[iPass];
+
+ pTech->HasDependencies |= pPass->CheckDependencies();
+ }
+ pGroup->HasDependencies |= pTech->HasDependencies;
+ }
+ }
+
+ VH( InitializeReflectionDataAndMoveStrings() );
+ VH( ReallocateReflectionData() );
+ VH( ReallocateEffectData() );
+
+ VB( m_pReflection->m_Heap.GetSize() == m_ReflectionMemory );
+
+ // Verify that all of the various block/variable types were loaded
+ VBD( m_pEffect->m_VariableCount == (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables), "Internal loading error: mismatched variable count." );
+ VBD( m_pEffect->m_ShaderBlockCount == m_pHeader->cTotalShaders, "Internal loading error: mismatched shader block count." );
+ VBD( m_pEffect->m_AnonymousShaderCount == m_pHeader->cInlineShaders, "Internal loading error: mismatched anonymous variable count." );
+ VBD( m_pEffect->m_ShaderResourceCount == m_pHeader->cShaderResources, "Internal loading error: mismatched SRV count." );
+ VBD( m_pEffect->m_InterfaceCount == m_pHeader->cInterfaceVariableElements + m_BackgroundInterfaces.GetSize(), "Internal loading error: mismatched interface count." );
+ VBD( m_pEffect->m_UnorderedAccessViewCount == m_pHeader->cUnorderedAccessViews, "Internal loading error: mismatched UAV count." );
+ VBD( m_pEffect->m_MemberDataCount == cMemberDataBlocks, "Internal loading error: mismatched member data block count." );
+ VBD( m_pEffect->m_RenderTargetViewCount == m_pHeader->cRenderTargetViews, "Internal loading error: mismatched RTV count." );
+ VBD( m_pEffect->m_DepthStencilViewCount == m_pHeader->cDepthStencilViews, "Internal loading error: mismatched DSV count." );
+ VBD( m_pEffect->m_DepthStencilBlockCount == m_pHeader->cDepthStencilBlocks, "Internal loading error: mismatched depth-stencil state count." );
+ VBD( m_pEffect->m_BlendBlockCount == m_pHeader->cBlendStateBlocks, "Internal loading error: mismatched blend state count." );
+ VBD( m_pEffect->m_RasterizerBlockCount == m_pHeader->cRasterizerStateBlocks, "Internal loading error: mismatched rasterizer state count." );
+ VBD( m_pEffect->m_SamplerBlockCount == m_pHeader->cSamplers, "Internal loading error: mismatched sampler count." );
+ VBD( m_pEffect->m_StringCount == m_pHeader->cStrings, "Internal loading error: mismatched string count." );
+
+ // Uncomment if you really need this information
+ // DPF(0, "Effect heap size: %d, reflection heap size: %d, allocations avoided: %d", m_EffectMemory, m_ReflectionMemory, m_BulkHeap.m_cAllocations);
+
+lExit:
+ return hr;
+}
+
+// position in buffer is lost on error
+_Use_decl_annotations_
+HRESULT CEffectLoader::LoadStringAndAddToPool(char **ppString, uint32_t dwOffset)
+{
+ HRESULT hr = S_OK;
+ char *pName;
+ uint32_t hash;
+ size_t oldPos;
+ CEffect::CStringHashTable::CIterator iter;
+ uint32_t len;
+
+ if (dwOffset == 0)
+ {
+ *ppString = nullptr;
+ goto lExit;
+ }
+
+ oldPos = m_msUnstructured.GetPosition();
+
+ VHD( m_msUnstructured.ReadAtOffset(dwOffset, (LPCSTR *) &pName), "Invalid pEffectBuffer: cannot read string." );
+ len = (uint32_t)strlen(pName);
+ hash = ComputeHash((uint8_t *)pName, len);
+ if (FAILED(m_pEffect->m_pStringPool->FindValueWithHash(pName, hash, &iter)))
+ {
+ assert( m_pEffect->m_pPooledHeap != 0 );
+ _Analysis_assume_( m_pEffect->m_pPooledHeap != 0 );
+ VN( (*ppString) = new(*m_pEffect->m_pPooledHeap) char[len + 1] );
+ memcpy(*ppString, pName, len + 1);
+ VHD( m_pEffect->m_pStringPool->AddValueWithHash(*ppString, hash), "Internal loading error: failed to add string to pool." );
+ }
+ else
+ {
+ *ppString = const_cast<LPSTR>(iter.GetData());
+ }
+
+ m_msUnstructured.Seek(oldPos);
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT CEffectLoader::LoadTypeAndAddToPool(SType **ppType, uint32_t dwOffset)
+{
+ HRESULT hr = S_OK;
+ SBinaryType *psType;
+ SBinaryNumericType *pNumericType;
+ EObjectType *pObjectType;
+ uint32_t cMembers, iMember, cInterfaces;
+ uint32_t oBaseClassType;
+ SType temporaryType;
+ CEffect::CTypeHashTable::CIterator iter;
+ uint8_t *pHashBuffer;
+ uint32_t hash;
+ SVariable *pTempMembers = nullptr;
+
+ m_HashBuffer.Empty();
+
+ VHD( m_msUnstructured.ReadAtOffset(dwOffset, sizeof(SBinaryType), (void**) &psType), "Invalid pEffectBuffer: cannot read type." );
+ VHD( LoadStringAndAddToPool(&temporaryType.pTypeName, psType->oTypeName), "Invalid pEffectBuffer: cannot read type name." );
+ temporaryType.VarType = psType->VarType;
+ temporaryType.Elements = psType->Elements;
+ temporaryType.TotalSize = psType->TotalSize;
+ temporaryType.Stride = psType->Stride;
+ temporaryType.PackedSize = psType->PackedSize;
+
+ // sanity check elements, size, stride, etc.
+ uint32_t cElements = std::max<uint32_t>(1, temporaryType.Elements);
+ VBD( cElements * temporaryType.Stride == AlignToPowerOf2(temporaryType.TotalSize, SType::c_RegisterSize), "Invalid pEffectBuffer: invalid type size." );
+ VBD( temporaryType.Stride % SType::c_RegisterSize == 0, "Invalid pEffectBuffer: invalid type stride." );
+ VBD( temporaryType.PackedSize <= temporaryType.TotalSize && temporaryType.PackedSize % cElements == 0, "Invalid pEffectBuffer: invalid type packed size." );
+
+ switch(temporaryType.VarType)
+ {
+ case EVT_Object:
+ VHD( m_msUnstructured.Read((void**) &pObjectType, sizeof(uint32_t)), "Invalid pEffectBuffer: cannot read object type." );
+ temporaryType.ObjectType = *pObjectType;
+ VBD( temporaryType.VarType > EOT_Invalid && temporaryType.VarType < EOT_Count, "Invalid pEffectBuffer: invalid object type." );
+
+ VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) +
+ sizeof(temporaryType.pTypeName) + sizeof(temporaryType.ObjectType)) );
+ memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType));
+ pHashBuffer += sizeof(temporaryType.VarType);
+ memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements));
+ pHashBuffer += sizeof(temporaryType.Elements);
+ memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName));
+ pHashBuffer += sizeof(temporaryType.pTypeName);
+ memcpy(pHashBuffer, &temporaryType.ObjectType, sizeof(temporaryType.ObjectType));
+ break;
+
+ case EVT_Interface:
+ temporaryType.InterfaceType = nullptr;
+
+ VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) +
+ sizeof(temporaryType.pTypeName) + sizeof(temporaryType.ObjectType)) );
+ memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType));
+ pHashBuffer += sizeof(temporaryType.VarType);
+ memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements));
+ pHashBuffer += sizeof(temporaryType.Elements);
+ memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName));
+ pHashBuffer += sizeof(temporaryType.pTypeName);
+ memcpy(pHashBuffer, &temporaryType.ObjectType, sizeof(temporaryType.ObjectType));
+ break;
+
+ case EVT_Numeric:
+ VHD( m_msUnstructured.Read((void**) &pNumericType, sizeof(SBinaryNumericType)), "Invalid pEffectBuffer: cannot read numeric type." );
+ temporaryType.NumericType = *pNumericType;
+ VBD( temporaryType.NumericType.Rows >= 1 && temporaryType.NumericType.Rows <= 4 &&
+ temporaryType.NumericType.Columns >= 1 && temporaryType.NumericType.Columns <= 4 &&
+ temporaryType.NumericType.NumericLayout != ENL_Invalid && temporaryType.NumericType.NumericLayout < ENL_Count &&
+ temporaryType.NumericType.ScalarType > EST_Invalid && temporaryType.NumericType.ScalarType < EST_Count,
+ "Invalid pEffectBuffer: invalid numeric type.");
+
+ if (temporaryType.NumericType.NumericLayout != ENL_Matrix)
+ {
+ VBD( temporaryType.NumericType.IsColumnMajor == false, "Invalid pEffectBuffer: only matricies can be column major." );
+ }
+
+ VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) +
+ sizeof(temporaryType.pTypeName) + sizeof(temporaryType.NumericType)) );
+ memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType));
+ pHashBuffer += sizeof(temporaryType.VarType);
+ memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements));
+ pHashBuffer += sizeof(temporaryType.Elements);
+ memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName));
+ pHashBuffer += sizeof(temporaryType.pTypeName);
+ memcpy(pHashBuffer, &temporaryType.NumericType, sizeof(temporaryType.NumericType));
+ break;
+
+ case EVT_Struct:
+ VHD( m_msUnstructured.Read(&cMembers), "Invalid pEffectBuffer: cannot read struct." );
+
+ temporaryType.StructType.Members = cMembers;
+
+ VN( pTempMembers = new SVariable[cMembers] );
+ temporaryType.StructType.pMembers = pTempMembers;
+
+ // read up all of the member descriptors at once
+ SBinaryType::SBinaryMember *psMember;
+ VHD( m_msUnstructured.Read((void**) &psMember, cMembers * sizeof(*psMember)), "Invalid pEffectBuffer: cannot read struct members." );
+
+ {
+ // Determine if this type implements an interface
+ VHD( m_msUnstructured.Read(&oBaseClassType), "Invalid pEffectBuffer: cannot read base class type." );
+ VHD( m_msUnstructured.Read(&cInterfaces), "Invalid pEffectBuffer: cannot read interfaces." );
+ if( cInterfaces > 0 )
+ {
+ temporaryType.StructType.ImplementsInterface = 1;
+ temporaryType.StructType.HasSuperClass = ( oBaseClassType > 0 ) ? 1 : 0;
+ }
+ else if( oBaseClassType > 0 )
+ {
+ // Get parent type and copy its ImplementsInterface
+ SType* pBaseClassType;
+ VH( LoadTypeAndAddToPool(&pBaseClassType, oBaseClassType) );
+ temporaryType.StructType.ImplementsInterface = pBaseClassType->StructType.ImplementsInterface;
+ temporaryType.StructType.HasSuperClass = 1;
+ }
+ // Read (and ignore) the interface types
+ uint32_t *poInterface;
+ VHD( m_msUnstructured.Read((void**) &poInterface, cInterfaces * sizeof(poInterface)), "Invalid pEffectBuffer: cannot read interface types." );
+ }
+
+ uint32_t totalSize;
+ totalSize = 0;
+ for (iMember=0; iMember<cMembers; iMember++)
+ {
+ SVariable *pMember;
+
+ pMember = temporaryType.StructType.pMembers + iMember;
+
+ VBD( psMember[iMember].Offset == totalSize ||
+ psMember[iMember].Offset == AlignToPowerOf2(totalSize, SType::c_RegisterSize),
+ "Internal loading error: invalid member offset." );
+
+ pMember->Data.Offset = psMember[iMember].Offset;
+
+ VH( LoadTypeAndAddToPool(&pMember->pType, psMember[iMember].oType) );
+ VH( LoadStringAndAddToPool(&pMember->pName, psMember[iMember].oName) );
+ VH( LoadStringAndAddToPool(&pMember->pSemantic, psMember[iMember].oSemantic) );
+
+ totalSize = psMember[iMember].Offset + pMember->pType->TotalSize;
+ }
+ VBD( AlignToPowerOf2(totalSize, SType::c_RegisterSize) == temporaryType.Stride, "Internal loading error: invlid type size." );
+
+ VN( pHashBuffer = m_HashBuffer.AddRange(sizeof(temporaryType.VarType) + sizeof(temporaryType.Elements) +
+ sizeof(temporaryType.pTypeName) + sizeof(temporaryType.StructType.Members) + cMembers * sizeof(SVariable)) );
+
+ memcpy(pHashBuffer, &temporaryType.VarType, sizeof(temporaryType.VarType));
+ pHashBuffer += sizeof(temporaryType.VarType);
+ memcpy(pHashBuffer, &temporaryType.Elements, sizeof(temporaryType.Elements));
+ pHashBuffer += sizeof(temporaryType.Elements);
+ memcpy(pHashBuffer, &temporaryType.pTypeName, sizeof(temporaryType.pTypeName));
+ pHashBuffer += sizeof(temporaryType.pTypeName);
+ memcpy(pHashBuffer, &temporaryType.StructType.Members, sizeof(temporaryType.StructType.Members));
+ pHashBuffer += sizeof(temporaryType.StructType.Members);
+ memcpy(pHashBuffer, temporaryType.StructType.pMembers, cMembers * sizeof(SVariable));
+ break;
+
+ default:
+ assert(0);
+ VHD( E_FAIL, "Internal loading error: invalid variable type." );
+ }
+
+ hash = ComputeHash(&m_HashBuffer[0], m_HashBuffer.GetSize());
+ if (FAILED(m_pEffect->m_pTypePool->FindValueWithHash(&temporaryType, hash, &iter)))
+ {
+ assert( m_pEffect->m_pPooledHeap != nullptr );
+
+ // allocate real member array, if necessary
+ if (temporaryType.VarType == EVT_Struct)
+ {
+ VN( temporaryType.StructType.pMembers = new(*m_pEffect->m_pPooledHeap) SVariable[temporaryType.StructType.Members] );
+ memcpy(temporaryType.StructType.pMembers, pTempMembers, temporaryType.StructType.Members * sizeof(SVariable));
+ }
+
+ // allocate real type
+ VN( (*ppType) = new(*m_pEffect->m_pPooledHeap) SType );
+ memcpy(*ppType, &temporaryType, sizeof(temporaryType));
+ ZeroMemory(&temporaryType, sizeof(temporaryType));
+ VH( m_pEffect->m_pTypePool->AddValueWithHash(*ppType, hash) );
+ }
+ else
+ {
+ *ppType = iter.GetData();
+ }
+
+lExit:
+ SAFE_DELETE_ARRAY(pTempMembers);
+ return hr;
+}
+
+// Numeric data in annotations are tightly packed (unlike in CBs which follow D3D11 packing rules). This unpacks them.
+uint32_t CEffectLoader::UnpackData(uint8_t *pDestData, uint8_t *pSrcData, uint32_t PackedDataSize, SType *pType, uint32_t *pBytesRead)
+{
+ uint32_t bytesRead = 0;
+ HRESULT hr = S_OK;
+ uint32_t elementsToCopy = std::max<uint32_t>(pType->Elements, 1);
+
+ switch (pType->VarType)
+ {
+ case EVT_Struct:
+ for (size_t i = 0; i < elementsToCopy; ++ i)
+ {
+ for (size_t j = 0; j < pType->StructType.Members; ++ j)
+ {
+ uint32_t br;
+ assert(PackedDataSize > bytesRead);
+
+ VH( UnpackData(pDestData + pType->StructType.pMembers[j].Data.Offset,
+ pSrcData + bytesRead, PackedDataSize - bytesRead,
+ pType->StructType.pMembers[j].pType, &br) );
+
+ bytesRead += br;
+ }
+ pDestData += pType->Stride;
+ }
+ break;
+
+ case EVT_Numeric:
+ if (pType->NumericType.IsPackedArray)
+ {
+ // No support for packed arrays
+ assert(0);
+ VHD(E_FAIL, "Internal loading error: packed arrays are not supported." );
+ }
+ else
+ {
+ uint32_t bytesToCopy;
+
+ if (pType->NumericType.IsColumnMajor)
+ {
+ uint32_t registers = pType->NumericType.Columns;
+ uint32_t entries = pType->NumericType.Rows;
+ bytesToCopy = entries * registers * SType::c_ScalarSize;
+
+ for (size_t i = 0; i < elementsToCopy; ++ i)
+ {
+ for (size_t j = 0; j < registers; ++ j)
+ {
+ for (size_t k = 0; k < entries; ++ k)
+ {
+ // type cast to an arbitrary scalar
+ ((uint32_t*)pDestData)[k] = ((uint32_t*)pSrcData)[k * registers + j];
+ }
+ pDestData += SType::c_RegisterSize; // advance to next register
+ }
+ pSrcData += bytesToCopy;
+ bytesRead += bytesToCopy;
+ }
+ }
+ else
+ {
+ uint32_t registers = pType->NumericType.Rows;
+ uint32_t entries = pType->NumericType.Columns;
+ bytesToCopy = entries * SType::c_ScalarSize;
+
+ for (size_t i = 0; i < elementsToCopy; ++ i)
+ {
+ for (size_t j = 0; j < registers; ++ j)
+ {
+ memcpy(pDestData, pSrcData, bytesToCopy);
+
+ pDestData += SType::c_RegisterSize; // advance to next register
+ pSrcData += bytesToCopy;
+ bytesRead += bytesToCopy;
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ // shouldn't be called on non-struct/numeric types
+ assert(0);
+ VHD(E_FAIL, "Internal loading error: UnpackData should not be called on non-struct, non-numeric types." );
+ }
+
+lExit:
+ *pBytesRead = bytesRead;
+ return hr;
+}
+
+// Read info from the compiled blob and initialize a numeric variable
+HRESULT CEffectLoader::LoadNumericVariable(_In_ SConstantBuffer *pParentCB)
+{
+ HRESULT hr = S_OK;
+ SBinaryNumericVariable *psVar;
+ SGlobalVariable *pVar;
+ SType *pType;
+ void *pDefaultValue;
+
+ // Read variable info
+ VHD( m_msStructured.Read((void**) &psVar, sizeof(*psVar)), "Invalid pEffectBuffer: cannot read numeric variable." );
+ VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),
+ "Internal loading error: invalid variable counts.");
+ pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];
+
+ // Get type
+ VH( LoadTypeAndAddToPool(&pType, psVar->oType) );
+
+ // Make sure the right polymorphic type is created
+ VH( PlacementNewVariable(pVar, pType, false) );
+
+ if (psVar->Flags & D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
+ {
+ pVar->ExplicitBindPoint = psVar->Offset;
+ }
+ else
+ {
+ pVar->ExplicitBindPoint = uint32_t(-1);
+ }
+
+ pVar->pEffect = m_pEffect;
+ pVar->pType = pType;
+ pVar->pCB = pParentCB;
+ pVar->Data.pGeneric = pParentCB->pBackingStore + psVar->Offset;
+ VBD( psVar->Offset + pVar->pType->TotalSize <= pVar->pCB->Size, "Invalid pEffectBuffer: invalid variable offset." );
+
+ if (pType->VarType == EVT_Struct && pType->StructType.ImplementsInterface && !pParentCB->IsTBuffer)
+ {
+ pVar->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;
+ m_pEffect->m_MemberDataCount += std::max<uint32_t>(pType->Elements,1);
+ }
+
+ // Get name & semantic
+ VHD( GetStringAndAddToReflection(psVar->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read variable name." );
+ VHD( GetStringAndAddToReflection(psVar->oSemantic, &pVar->pSemantic), "Invalid pEffectBuffer: cannot read variable semantic." );
+
+ // Ensure the variable fits in the CBuffer and doesn't overflow
+ VBD( pType->TotalSize + psVar->Offset <= pParentCB->Size &&
+ pType->TotalSize + psVar->Offset >= pType->TotalSize, "Invalid pEffectBuffer: variable does not fit in CB." );
+
+ ZeroMemory(pVar->Data.pGeneric, pType->TotalSize);
+
+ // Get default value
+ if (0 != psVar->oDefaultValue)
+ {
+ uint32_t bytesUnpacked;
+ VHD( m_msUnstructured.ReadAtOffset(psVar->oDefaultValue, pType->PackedSize, &pDefaultValue), "Invalid pEffectBuffer: cannot read default value." );
+ VH( UnpackData((uint8_t*) pVar->Data.pGeneric, (uint8_t*) pDefaultValue, pType->PackedSize, pType, &bytesUnpacked) );
+ VBD( bytesUnpacked == pType->PackedSize, "Invalid pEffectBuffer: invalid type packed size.");
+ }
+
+ // We need to use offsets until we fixup
+ pVar->Data.Offset = psVar->Offset;
+
+ // Read annotations
+ VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );
+
+ m_pEffect->m_VariableCount++;
+
+lExit:
+ return hr;
+}
+
+// Read info from the compiled blob and initialize a constant buffer
+HRESULT CEffectLoader::LoadCBs()
+{
+ HRESULT hr = S_OK;
+ uint32_t iCB, iVar;
+
+ for (iCB=0; iCB<m_pHeader->Effect.cCBs; iCB++)
+ {
+ SBinaryConstantBuffer *psCB;
+ SConstantBuffer *pCB;
+
+ VHD( m_msStructured.Read((void**) &psCB, sizeof(*psCB)), "Invalid pEffectBuffer: cannot read CB." );
+ pCB = &m_pEffect->m_pCBs[iCB];
+
+ VHD( GetStringAndAddToReflection(psCB->oName, &pCB->pName), "Invalid pEffectBuffer: cannot read CB name." );
+
+ pCB->IsTBuffer = (psCB->Flags & SBinaryConstantBuffer::c_IsTBuffer) != 0 ? true : false;
+ pCB->IsSingle = (psCB->Flags & SBinaryConstantBuffer::c_IsSingle) != 0 ? true : false;
+ pCB->Size = psCB->Size;
+ pCB->ExplicitBindPoint = psCB->ExplicitBindPoint;
+ VBD( pCB->Size == AlignToPowerOf2(pCB->Size, SType::c_RegisterSize), "Invalid pEffectBuffer: CB size not a power of 2." );
+ VN( pCB->pBackingStore = PRIVATENEW uint8_t[pCB->Size] );
+
+ pCB->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;
+ m_pEffect->m_MemberDataCount += 2;
+
+ // point this CB to variables that it owns
+ pCB->VariableCount = psCB->cVariables;
+ if (pCB->VariableCount > 0)
+ {
+ pCB->pVariables = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];
+ }
+ else
+ {
+ pCB->pVariables = nullptr;
+ }
+
+ // Read annotations
+ VH( LoadAnnotations(&pCB->AnnotationCount, &pCB->pAnnotations) );
+
+ for (iVar=0; iVar<psCB->cVariables; iVar++)
+ {
+ VH( LoadNumericVariable(pCB) );
+ }
+ }
+
+ m_pEffect->m_CBCount = m_pHeader->Effect.cCBs;
+
+lExit:
+ return hr;
+}
+
+// Used by LoadAssignment to initialize members on load
+_Use_decl_annotations_
+HRESULT CEffectLoader::ExecuteConstantAssignment(const SBinaryConstant *pConstant, void *pLHS, D3D_SHADER_VARIABLE_TYPE lhsType)
+{
+ HRESULT hr = S_OK;
+
+ switch(pConstant->Type)
+ {
+ case EST_UInt:
+ case EST_Int:
+ case EST_Bool:
+ switch(lhsType)
+ {
+ case D3D_SVT_BOOL:
+ case D3D_SVT_INT:
+ case D3D_SVT_UINT:
+ *(uint32_t*) pLHS = pConstant->iValue;
+ break;
+
+ case D3D_SVT_UINT8:
+ *(uint8_t*) pLHS = (uint8_t) pConstant->iValue;
+ break;
+
+ case D3D_SVT_FLOAT:
+ *(float*) pLHS = (float) pConstant->iValue;
+ break;
+
+ default:
+ VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );
+ }
+ break;
+
+ case EST_Float:
+ switch(lhsType)
+ {
+ case D3D_SVT_BOOL:
+ case D3D_SVT_INT:
+ case D3D_SVT_UINT:
+ *(uint32_t*) pLHS = (uint32_t) pConstant->fValue;
+ break;
+
+ case D3D_SVT_UINT8:
+ *(uint8_t*) pLHS = (uint8_t) pConstant->fValue;
+ break;
+
+ case D3D_SVT_FLOAT:
+ *(float*) pLHS = pConstant->fValue;
+ break;
+
+ default:
+ VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );
+ }
+ break;
+
+ default:
+ VHD( E_FAIL, "Internal loading error: invalid left-hand assignment type." );
+ }
+
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize a set of assignments
+_Use_decl_annotations_
+HRESULT CEffectLoader::LoadAssignments( uint32_t Assignments, SAssignment **ppAssignments,
+ uint8_t *pBackingStore, uint32_t *pRTVAssignments, uint32_t *pFinalAssignments )
+{
+ HRESULT hr = S_OK;
+ uint32_t i, j;
+
+ SBinaryAssignment *psAssignments;
+ uint32_t finalAssignments = 0; // the number of assignments worth keeping
+ uint32_t renderTargetViewAssns = 0; // Number of render target view assns, used by passes since SetRTV is a vararg call
+
+ *pFinalAssignments = 0;
+ if (pRTVAssignments)
+ *pRTVAssignments = 0;
+
+ VHD( m_msStructured.Read((void**) &psAssignments, sizeof(*psAssignments) * Assignments), "Invalid pEffectBuffer: cannot read assignments." );
+
+ // allocate enough room to store all of the assignments (even though some may go unused)
+ VN( (*ppAssignments) = PRIVATENEW SAssignment[Assignments] )
+
+ //
+ // In this loop, we read assignments 1-by-1, keeping some and discarding others.
+ // We write to the "next" assignment which is given by &(*ppAssignments)[finalAssignments];
+ // if an assignment is worth keeping, we increment finalAssignments.
+ // This means that if you want to keep an assignment, you must be careful to initialize
+ // all members of SAssignment because old values from preceding discarded assignments might remain.
+ //
+ for (i = 0; i < Assignments; ++ i)
+ {
+ SGlobalVariable *pVarArray, *pVarIndex, *pVar;
+ const char *pGlobalVarName;
+ SAssignment *pAssignment = &(*ppAssignments)[finalAssignments];
+ uint8_t *pLHS;
+
+ VBD( psAssignments[i].iState < NUM_STATES, "Invalid pEffectBuffer: invalid assignment state." );
+ VBD( psAssignments[i].Index < g_lvGeneral[psAssignments[i].iState].m_Indices, "Invalid pEffectBuffer: invalid assignment index." );
+
+ pAssignment->LhsType = g_lvGeneral[psAssignments[i].iState].m_LhsType;
+
+ // Count RenderTargetView assignments
+ if (pAssignment->LhsType == ELHS_RenderTargetView)
+ renderTargetViewAssns++;
+
+ switch (g_lvGeneral[psAssignments[i].iState].m_Type)
+ {
+ case D3D_SVT_UINT8:
+ assert(g_lvGeneral[psAssignments[i].iState].m_Cols == 1); // uint8_t arrays not supported
+ pAssignment->DataSize = sizeof(uint8_t);
+ // Store an offset for destination instead of a pointer so that it's easy to relocate it later
+
+ break;
+
+ case D3D_SVT_BOOL:
+ case D3D_SVT_INT:
+ case D3D_SVT_UINT:
+ case D3D_SVT_FLOAT:
+ pAssignment->DataSize = SType::c_ScalarSize * g_lvGeneral[psAssignments[i].iState].m_Cols;
+ break;
+
+ case D3D_SVT_RASTERIZER:
+ pAssignment->DataSize = sizeof(SRasterizerBlock);
+ break;
+
+ case D3D_SVT_DEPTHSTENCIL:
+ pAssignment->DataSize = sizeof(SDepthStencilBlock);
+ break;
+
+ case D3D_SVT_BLEND:
+ pAssignment->DataSize = sizeof(SBlendBlock);
+ break;
+
+ case D3D_SVT_VERTEXSHADER:
+ case D3D_SVT_GEOMETRYSHADER:
+ case D3D_SVT_PIXELSHADER:
+ case D3D_SVT_HULLSHADER:
+ case D3D_SVT_DOMAINSHADER:
+ case D3D_SVT_COMPUTESHADER:
+ pAssignment->DataSize = sizeof(SShaderBlock);
+ break;
+
+ case D3D_SVT_TEXTURE:
+ case D3D_SVT_TEXTURE1D:
+ case D3D_SVT_TEXTURE2D:
+ case D3D_SVT_TEXTURE2DMS:
+ case D3D_SVT_TEXTURE3D:
+ case D3D_SVT_TEXTURECUBE:
+ case D3D_SVT_TEXTURECUBEARRAY:
+ case D3D_SVT_BYTEADDRESS_BUFFER:
+ case D3D_SVT_STRUCTURED_BUFFER:
+ pAssignment->DataSize = sizeof(SShaderResource);
+ break;
+
+ case D3D_SVT_RENDERTARGETVIEW:
+ pAssignment->DataSize = sizeof(SRenderTargetView);
+ break;
+
+ case D3D_SVT_DEPTHSTENCILVIEW:
+ pAssignment->DataSize = sizeof(SDepthStencilView);
+ break;
+
+ case D3D_SVT_RWTEXTURE1D:
+ case D3D_SVT_RWTEXTURE1DARRAY:
+ case D3D_SVT_RWTEXTURE2D:
+ case D3D_SVT_RWTEXTURE2DARRAY:
+ case D3D_SVT_RWTEXTURE3D:
+ case D3D_SVT_RWBUFFER:
+ case D3D_SVT_RWBYTEADDRESS_BUFFER:
+ case D3D_SVT_RWSTRUCTURED_BUFFER:
+ case D3D_SVT_APPEND_STRUCTURED_BUFFER:
+ case D3D_SVT_CONSUME_STRUCTURED_BUFFER:
+ pAssignment->DataSize = sizeof(SUnorderedAccessView);
+ break;
+
+ case D3D_SVT_INTERFACE_POINTER:
+ pAssignment->DataSize = sizeof(SInterface);
+ break;
+
+ default:
+ assert(0);
+ VHD( E_FAIL, "Internal loading error: invalid assignment type.");
+ }
+
+ uint32_t lhsStride;
+ if( g_lvGeneral[psAssignments[i].iState].m_Stride > 0 )
+ lhsStride = g_lvGeneral[psAssignments[i].iState].m_Stride;
+ else
+ lhsStride = pAssignment->DataSize;
+
+ // Store only the destination offset so that the backing store pointers can be easily fixed up later
+ pAssignment->Destination.Offset = g_lvGeneral[psAssignments[i].iState].m_Offset + lhsStride * psAssignments[i].Index;
+
+ // As a result, you should use pLHS in this function instead of the destination pointer
+ pLHS = pBackingStore + pAssignment->Destination.Offset;
+
+ switch (psAssignments[i].AssignmentType)
+ {
+ case ECAT_Constant: // e.g. LHS = 1; or LHS = nullptr;
+ uint32_t *pNumConstants;
+ SBinaryConstant *pConstants;
+
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(uint32_t), (void**) &pNumConstants), "Invalid pEffectBuffer: cannot read NumConstants." );
+ VHD( m_msUnstructured.Read((void **)&pConstants, sizeof(SBinaryConstant) * (*pNumConstants)), "Invalid pEffectBuffer: cannot read constants." );
+
+ if(pAssignment->IsObjectAssignment())
+ {
+ // make sure this is a nullptr assignment
+ VBD( *pNumConstants == 1 && (pConstants[0].Type == EST_Int || pConstants[0].Type == EST_UInt) && pConstants[0].iValue == 0,
+ "Invalid pEffectBuffer: non-nullptr constant assignment to object.");
+
+ switch (pAssignment->LhsType)
+ {
+ case ELHS_DepthStencilBlock:
+ *((void **)pLHS) = &g_NullDepthStencil;
+ break;
+ case ELHS_BlendBlock:
+ *((void **)pLHS) = &g_NullBlend;
+ break;
+ case ELHS_RasterizerBlock:
+ *((void **)pLHS) = &g_NullRasterizer;
+ break;
+ case ELHS_VertexShaderBlock:
+ *((void **)pLHS) = &g_NullVS;
+ break;
+ case ELHS_PixelShaderBlock:
+ *((void **)pLHS) = &g_NullPS;
+ break;
+ case ELHS_GeometryShaderBlock:
+ *((void **)pLHS) = &g_NullGS;
+ break;
+ case ELHS_HullShaderBlock:
+ *((void **)pLHS) = &g_NullHS;
+ break;
+ case ELHS_DomainShaderBlock:
+ *((void **)pLHS) = &g_NullDS;
+ break;
+ case ELHS_ComputeShaderBlock:
+ *((void **)pLHS) = &g_NullCS;
+ break;
+ case ELHS_Texture:
+ *((void **)pLHS) = &g_NullTexture;
+ break;
+ case ELHS_DepthStencilView:
+ *((void **)pLHS) = &g_NullDepthStencilView;
+ break;
+ case ELHS_RenderTargetView:
+ *((void **)pLHS) = &g_NullRenderTargetView;
+ break;
+ default:
+ assert(0);
+ }
+ }
+ else
+ {
+ VBD( *pNumConstants == g_lvGeneral[psAssignments[i].iState].m_Cols, "Internal loading error: mismatch constant count." );
+ for (j = 0; j < *pNumConstants; ++ j)
+ {
+ VH( ExecuteConstantAssignment(pConstants + j, pLHS, g_lvGeneral[psAssignments[i].iState].m_Type) );
+ pLHS += SType::c_ScalarSize; // arrays of constants will always be regular scalar sized, never byte-sized
+ }
+ }
+
+ // Can get rid of this assignment
+ break;
+
+ case ECAT_Variable: // e.g. LHS = myVar;
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, &pGlobalVarName), "Invalid pEffectBuffer: cannot read variable name." );
+
+ VBD( pVar = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find variable name." );
+
+ if (pAssignment->IsObjectAssignment())
+ {
+ VBD( pVar->pType->VarType == EVT_Object &&
+ GetSimpleParameterTypeFromObjectType(pVar->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,
+ "Loading error: invalid variable type or object type." );
+
+ // Write directly into the state block's backing store
+ *((void **)pLHS) = pVar->Data.pGeneric;
+
+ // Now we can get rid of this assignment
+ }
+ else
+ {
+ VBD( pVar->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );
+
+ pAssignment->DependencyCount = 1;
+ VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );
+ pAssignment->pDependencies->pVariable = pVar;
+
+ // Store an offset for numeric values instead of a pointer so that it's easy to relocate it later
+ pAssignment->Source.Offset = pVar->Data.Offset;
+ pAssignment->AssignmentType = ERAT_NumericVariable;
+
+ // Can't get rid of this assignment
+ ++ finalAssignments;
+ }
+ break;
+
+ case ECAT_ConstIndex: // e.g. LHS = myGS[1]
+ SBinaryAssignment::SConstantIndex *psConstIndex;
+
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psConstIndex), (void**) &psConstIndex),
+ "Invalid pEffectBuffer: cannot read assignment initializer." );
+ VHD( m_msUnstructured.ReadAtOffset(psConstIndex->oArrayName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read array name." );
+
+ VBD( pVarArray = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find array name." );
+
+ if (pAssignment->IsObjectAssignment())
+ {
+ VBD( psConstIndex->Index < pVarArray->pType->Elements, "Invalid pEffectBuffer: out of bounds array index." );
+ VBD( pVarArray->pType->VarType == EVT_Object &&
+ GetSimpleParameterTypeFromObjectType(pVarArray->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,
+ "Loading error: invalid variable type or object type." );
+
+ // Write directly into the state block's backing store
+ *((void **)pLHS) = GetBlockByIndex(pVarArray->pType->VarType, pVarArray->pType->ObjectType, pVarArray->Data.pGeneric, psConstIndex->Index);
+ VBD( nullptr != *((void **)pLHS), "Internal loading error: invalid block." );
+
+ // Now we can get rid of this assignment
+ }
+ else
+ {
+ VBD( pVarArray->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );
+
+ pAssignment->DependencyCount = 1;
+ VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );
+ pAssignment->pDependencies->pVariable = pVarArray;
+
+ CCheckedDword chkDataLen = psConstIndex->Index;
+ uint32_t dataLen;
+ chkDataLen *= SType::c_ScalarSize;
+ chkDataLen += pAssignment->DataSize;
+ VHD( chkDataLen.GetValue(&dataLen), "Overflow: assignment size." );
+ VBD( dataLen <= pVarArray->pType->TotalSize, "Internal loading error: assignment size mismatch" );
+
+ pAssignment->Source.Offset = pVarArray->Data.Offset + psConstIndex->Index * SType::c_ScalarSize;
+
+ // _NumericConstIndex is not used here because _NumericVariable
+ // does the same stuff in a more general fashion with no perf hit.
+ pAssignment->AssignmentType = ERAT_NumericVariable;
+
+ // Can't get rid of this assignment
+ ++ finalAssignments;
+ }
+ break;
+
+ case ECAT_VariableIndex: // e.g. LHS = myVar[numLights];
+ SBinaryAssignment::SVariableIndex *psVarIndex;
+
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psVarIndex), (void**) &psVarIndex),
+ "Invalid pEffectBuffer: cannot read assignment initializer." );
+ VHD( m_msUnstructured.ReadAtOffset(psVarIndex->oArrayName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read variable name." );
+ VBD( pVarArray = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find variable name." );
+
+ VHD( m_msUnstructured.ReadAtOffset(psVarIndex->oIndexVarName, &pGlobalVarName), "Invalid pEffectBuffer: cannot read index variable name." );
+ VBD( pVarIndex = m_pEffect->FindVariableByName(pGlobalVarName), "Loading error: cannot find index variable name." );
+
+ // Only support integer indices
+ VBD( pVarIndex->pType->VarType == EVT_Numeric && (pVarIndex->pType->NumericType.ScalarType == EST_Int || pVarIndex->pType->NumericType.ScalarType == EST_UInt),
+ "Invalid pEffectBuffer: invalid index variable type.");
+ VBD( pVarArray->pType->Elements > 0, "Invalid pEffectBuffer: array variable is not an array." );
+
+ pVarIndex->pCB->IsUsedByExpression = true;
+
+ if (pAssignment->IsObjectAssignment())
+ {
+ VBD( pVarArray->pType->VarType == EVT_Object &&
+ GetSimpleParameterTypeFromObjectType(pVarArray->pType->ObjectType) == g_lvGeneral[psAssignments[i].iState].m_Type,
+ "Loading error: invalid variable type or object type." );
+
+ // MaxElements is only 16-bits wide
+ VBD( pVarArray->pType->Elements <= 0xFFFF, "Internal error: array size is too large." );
+ pAssignment->MaxElements = pVarArray->pType->Elements;
+
+ pAssignment->DependencyCount = 1;
+ VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );
+ pAssignment->pDependencies[0].pVariable = pVarIndex;
+
+ // Point this assignment to the start of the variable's object array.
+ // When this assignment is dirty, we write the value of this pointer plus
+ // the index given by its one dependency directly into the destination
+ pAssignment->Source = pVarArray->Data;
+ pAssignment->AssignmentType = ERAT_ObjectVariableIndex;
+ }
+ else
+ {
+ VBD( pVarArray->pType->BelongsInConstantBuffer(), "Invalid pEffectBuffer: assignment type mismatch." );
+
+ pAssignment->DependencyCount = 2;
+ VN( pAssignment->pDependencies = PRIVATENEW SAssignment::SDependency[pAssignment->DependencyCount] );
+ pAssignment->pDependencies[0].pVariable = pVarIndex;
+ pAssignment->pDependencies[1].pVariable = pVarArray;
+
+ // When pVarIndex is updated, we update the source pointer.
+ // When pVarArray is updated, we copy data from the source to the destination.
+ pAssignment->Source.pGeneric = nullptr;
+ pAssignment->AssignmentType = ERAT_NumericVariableIndex;
+ }
+
+ // Can't get rid of this assignment
+ ++ finalAssignments;
+
+ break;
+
+ case ECAT_ExpressionIndex:// e.g. LHS = myVar[a + b * c];
+ case ECAT_Expression: // e.g. LHS = a + b * c;
+ // we do not support FXLVM
+ VHD( E_NOTIMPL, "FXLVM Expressions (complex assignments like myVar[i*2]) are not supported in Effects11." );
+ break;
+
+ case ECAT_InlineShader:
+ case ECAT_InlineShader5:
+ uint32_t cbShaderBin;
+ uint8_t *pShaderBin;
+ SShaderBlock *pShaderBlock;
+ SAnonymousShader *pAnonShader;
+ union
+ {
+ SBinaryAssignment::SInlineShader *psInlineShader;
+ SBinaryShaderData5 *psInlineShader5;
+ };
+
+ // Inline shader assignments must be object types
+ assert(pAssignment->IsObjectAssignment());
+
+ C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oShader) == offsetof(SBinaryShaderData5,oShader) );
+ C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oSODecl) == offsetof(SBinaryShaderData5,oSODecls) );
+ if( psAssignments[i].AssignmentType == ECAT_InlineShader )
+ {
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psInlineShader), (void**) &psInlineShader),
+ "Invalid pEffectBuffer: cannot read inline shader." );
+ }
+ else
+ {
+ VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psInlineShader5), (void**) &psInlineShader5),
+ "Invalid pEffectBuffer: cannot read inline shader." );
+ }
+
+ VBD( m_pEffect->m_ShaderBlockCount < m_pHeader->cTotalShaders, "Internal loading error: shader count is out incorrect." );
+ VBD( m_pEffect->m_AnonymousShaderCount < m_pHeader->cInlineShaders, "Internal loading error: anonymous shader count is out incorrect." );
+
+ pShaderBlock = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];
+ pAnonShader = &m_pEffect->m_pAnonymousShaders[m_pEffect->m_AnonymousShaderCount];
+ pAnonShader->pShaderBlock = pShaderBlock;
+
+ ++ m_pEffect->m_ShaderBlockCount;
+ ++ m_pEffect->m_AnonymousShaderCount;
+
+ // Write directly into the state block's backing store
+ *((void **)pLHS) = pShaderBlock;
+
+ VHD( GetUnstructuredDataBlock(psInlineShader->oShader, &cbShaderBin, (void **) &pShaderBin), "Invalid pEffectBuffer: cannot read inline shader block." );
+
+ if (cbShaderBin > 0)
+ {
+ VN( pShaderBlock->pReflectionData = PRIVATENEW SShaderBlock::SReflectionData );
+
+ pShaderBlock->pReflectionData->BytecodeLength = cbShaderBin;
+ pShaderBlock->pReflectionData->pBytecode = (uint8_t*) pShaderBin;
+ pShaderBlock->pReflectionData->pStreamOutDecls[0] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[1] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[2] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[3] = nullptr;
+ pShaderBlock->pReflectionData->RasterizedStream = 0;
+ pShaderBlock->pReflectionData->IsNullGS = FALSE;
+ pShaderBlock->pReflectionData->pReflection = nullptr;
+ pShaderBlock->pReflectionData->InterfaceParameterCount = 0;
+ pShaderBlock->pReflectionData->pInterfaceParameters = nullptr;
+ }
+
+ switch (pAssignment->LhsType)
+ {
+ case ELHS_PixelShaderBlock:
+ pShaderBlock->pVT = &g_vtPS;
+ VBD( psInlineShader->oSODecl == 0, "Internal loading error: pixel shaders cannot have stream out decls." );
+ break;
+
+ case ELHS_GeometryShaderBlock:
+ pShaderBlock->pVT = &g_vtGS;
+ if( psAssignments[i].AssignmentType == ECAT_InlineShader )
+ {
+ if (psInlineShader->oSODecl)
+ {
+ // This is a GS with SO
+ VHD( GetStringAndAddToReflection(psInlineShader->oSODecl, &pShaderBlock->pReflectionData->pStreamOutDecls[0]),
+ "Invalid pEffectBuffer: cannot read SO decl." );
+ }
+ }
+ else
+ {
+ // This is a GS with addressable stream out
+ for( size_t iDecl=0; iDecl < psInlineShader5->cSODecls; ++iDecl )
+ {
+ if (psInlineShader5->oSODecls[iDecl])
+ {
+ VHD( GetStringAndAddToReflection(psInlineShader5->oSODecls[iDecl], &pShaderBlock->pReflectionData->pStreamOutDecls[iDecl]),
+ "Invalid pEffectBuffer: cannot read SO decl." );
+ }
+ }
+ pShaderBlock->pReflectionData->RasterizedStream = psInlineShader5->RasterizedStream;
+ }
+ break;
+
+ case ELHS_VertexShaderBlock:
+ pShaderBlock->pVT = &g_vtVS;
+ VBD( psInlineShader->oSODecl == 0, "Internal loading error: vertex shaders cannot have stream out decls." );
+ break;
+
+ case ELHS_HullShaderBlock:
+ pShaderBlock->pVT = &g_vtHS;
+ VBD( psInlineShader->oSODecl == 0, "Internal loading error: hull shaders cannot have stream out decls." );
+ break;
+
+ case ELHS_DomainShaderBlock:
+ pShaderBlock->pVT = &g_vtDS;
+ VBD( psInlineShader->oSODecl == 0, "Internal loading error: domain shaders cannot have stream out decls." );
+ break;
+
+ case ELHS_ComputeShaderBlock:
+ pShaderBlock->pVT = &g_vtCS;
+ VBD( psInlineShader->oSODecl == 0, "Internal loading error: compute shaders cannot have stream out decls." );
+ break;
+
+ case ELHS_GeometryShaderSO:
+ assert(0); // Should never happen
+
+ default:
+ VHD( E_FAIL, "Internal loading error: invalid shader type." );
+ }
+
+ if( psAssignments[i].AssignmentType == ECAT_InlineShader5 )
+ {
+ pShaderBlock->pReflectionData->InterfaceParameterCount = psInlineShader5->cInterfaceBindings;
+ VH( GetInterfaceParametersAndAddToReflection( psInlineShader5->cInterfaceBindings, psInlineShader5->oInterfaceBindings, &pShaderBlock->pReflectionData->pInterfaceParameters ) );
+ }
+
+ // Now we can get rid of this assignment
+ break;
+
+ default:
+ assert(0);
+
+ }
+ }
+
+ *pFinalAssignments = finalAssignments;
+ if (pRTVAssignments)
+ *pRTVAssignments = renderTargetViewAssns;
+
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize an object variable
+HRESULT CEffectLoader::LoadObjectVariables()
+{
+ HRESULT hr = S_OK;
+
+ size_t cBlocks = m_pHeader->Effect.cObjectVariables;
+
+ for (size_t iBlock=0; iBlock<cBlocks; iBlock++)
+ {
+ SBinaryObjectVariable *psBlock;
+ SGlobalVariable *pVar;
+ SType *pType;
+ uint32_t elementsToRead;
+ CCheckedDword chkElementsTotal;
+ uint32_t elementsTotal;
+
+ // Read variable info
+ VHD( m_msStructured.Read((void**) &psBlock, sizeof(*psBlock)), "Invalid pEffectBuffer: cannot read object variable." );
+ VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),
+ "Internal loading error: variable count mismatch." );
+ pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];
+
+ // Get type
+ VH( LoadTypeAndAddToPool(&pType, psBlock->oType) );
+
+ // Make sure the right polymorphic type is created
+ VH( PlacementNewVariable(pVar, pType, false) );
+
+ pVar->pEffect = m_pEffect;
+ pVar->pType = pType;
+ pVar->pCB = nullptr;
+ pVar->ExplicitBindPoint = psBlock->ExplicitBindPoint;
+
+ if( pType->IsStateBlockObject() )
+ {
+ pVar->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;
+ m_pEffect->m_MemberDataCount += std::max<uint32_t>(pType->Elements,1);
+ }
+
+ // Get name
+ VHD( GetStringAndAddToReflection(psBlock->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read object variable name." );
+ VHD( GetStringAndAddToReflection(psBlock->oSemantic, &pVar->pSemantic), "Invalid pEffectBuffer: cannot read object variable semantic." );
+
+ m_pEffect->m_VariableCount++;
+ elementsToRead = std::max<uint32_t>(1, pType->Elements);
+ chkElementsTotal = elementsToRead;
+
+ if (pType->IsStateBlockObject())
+ {
+ // State blocks
+ EBlockType blockType;
+ uint32_t *maxBlockCount;
+ uint32_t *currentBlockCount;
+
+ switch (pType->ObjectType)
+ {
+ case EOT_Blend:
+ pVar->Data.pBlock = &m_pEffect->m_pBlendBlocks[m_pEffect->m_BlendBlockCount];
+ maxBlockCount = &m_pHeader->cBlendStateBlocks;
+ currentBlockCount = &m_pEffect->m_BlendBlockCount;
+ blockType = EBT_Blend;
+ break;
+
+ case EOT_DepthStencil:
+ pVar->Data.pBlock = &m_pEffect->m_pDepthStencilBlocks[m_pEffect->m_DepthStencilBlockCount];
+ maxBlockCount = &m_pHeader->cDepthStencilBlocks;
+ currentBlockCount = &m_pEffect->m_DepthStencilBlockCount;
+ blockType = EBT_DepthStencil;
+ break;
+
+ case EOT_Rasterizer:
+ pVar->Data.pBlock = &m_pEffect->m_pRasterizerBlocks[m_pEffect->m_RasterizerBlockCount];
+ maxBlockCount = &m_pHeader->cRasterizerStateBlocks;
+ currentBlockCount = &m_pEffect->m_RasterizerBlockCount;
+ blockType = EBT_Rasterizer;
+ break;
+
+ default:
+ VB(pType->IsSampler());
+ pVar->Data.pBlock = &m_pEffect->m_pSamplerBlocks[m_pEffect->m_SamplerBlockCount];
+ maxBlockCount = &m_pHeader->cSamplers;
+ currentBlockCount = &m_pEffect->m_SamplerBlockCount;
+ blockType = EBT_Sampler;
+ }
+
+ chkElementsTotal += *currentBlockCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: vaiable elements." );
+ VBD( elementsTotal <= *maxBlockCount, "Internal loading error: element count overflow." );
+
+ *currentBlockCount += elementsToRead;
+
+ for (uint32_t iElement = 0; iElement < elementsToRead; ++ iElement)
+ {
+ SBaseBlock *pCurrentBlock;
+ uint32_t cAssignments;
+
+ pCurrentBlock = (SBaseBlock *) GetBlockByIndex(pVar->pType->VarType, pVar->pType->ObjectType, pVar->Data.pGeneric, iElement);
+ VBD( nullptr != pCurrentBlock, "Internal loading error: find state block." );
+
+ pCurrentBlock->BlockType = blockType;
+
+ VHD( m_msStructured.Read(&cAssignments), "Invalid pEffectBuffer: cannot read state block assignments." );
+
+ VH( LoadAssignments( cAssignments, &pCurrentBlock->pAssignments, (uint8_t*)pCurrentBlock, nullptr, &pCurrentBlock->AssignmentCount ) );
+ }
+ }
+ else if (pType->IsShader())
+ {
+ // Shaders
+
+ chkElementsTotal += m_pEffect->m_ShaderBlockCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: shader block count." );
+ VBD( elementsTotal <= m_pHeader->cTotalShaders, "Invalid pEffectBuffer: shader count mismatch." );
+
+ pVar->Data.pShader = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];
+
+ for (size_t iElement=0; iElement<elementsToRead; iElement++)
+ {
+ uint32_t cbShaderBin;
+ void *pShaderBin;
+ SShaderBlock *pShaderBlock;
+
+ union
+ {
+ uint32_t *pOffset;
+ SBinaryGSSOInitializer *psInlineGSSO4;
+ SBinaryShaderData5 *psInlineShader5;
+ };
+
+ C_ASSERT( offsetof(SBinaryGSSOInitializer,oShader) == 0 );
+ C_ASSERT( offsetof(SBinaryShaderData5,oShader) == 0 );
+
+
+ pShaderBlock = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];
+ m_pEffect->m_ShaderBlockCount++;
+
+ // Get shader binary
+ switch (pType->ObjectType)
+ {
+ case EOT_VertexShader:
+ case EOT_GeometryShader:
+ case EOT_PixelShader:
+ VHD( m_msStructured.Read((void**)&pOffset, sizeof(*pOffset)), "Invalid pEffectBuffer: cannot read shader block." );
+ break;
+
+ case EOT_GeometryShaderSO:
+ VHD( m_msStructured.Read((void**)&psInlineGSSO4, sizeof(*psInlineGSSO4)), "Invalid pEffectBuffer: cannot read inline GS with SO." );
+ break;
+
+ case EOT_VertexShader5:
+ case EOT_GeometryShader5:
+ case EOT_HullShader5:
+ case EOT_DomainShader5:
+ case EOT_PixelShader5:
+ case EOT_ComputeShader5:
+ VHD( m_msStructured.Read((void**)&psInlineShader5, sizeof(*psInlineShader5)), "Invalid pEffectBuffer: cannot read inline shader." );
+ break;
+
+ default:
+ VH( E_FAIL );
+ }
+
+ VHD( GetUnstructuredDataBlock(*pOffset, &cbShaderBin, &pShaderBin), "Invalid pEffectBuffer: cannot read shader byte code." );
+
+ if (cbShaderBin > 0)
+ {
+ VN( pShaderBlock->pReflectionData = PRIVATENEW SShaderBlock::SReflectionData );
+
+ pShaderBlock->pReflectionData->BytecodeLength = cbShaderBin;
+ pShaderBlock->pReflectionData->pBytecode = (uint8_t*) pShaderBin;
+ pShaderBlock->pReflectionData->pStreamOutDecls[0] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[1] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[2] =
+ pShaderBlock->pReflectionData->pStreamOutDecls[3] = nullptr;
+ pShaderBlock->pReflectionData->RasterizedStream = 0;
+ pShaderBlock->pReflectionData->IsNullGS = FALSE;
+ pShaderBlock->pReflectionData->pReflection = nullptr;
+ pShaderBlock->pReflectionData->InterfaceParameterCount = 0;
+ pShaderBlock->pReflectionData->pInterfaceParameters = nullptr;
+ }
+
+ switch (pType->ObjectType)
+ {
+ case EOT_PixelShader:
+ pShaderBlock->pVT = &g_vtPS;
+ break;
+
+ case EOT_GeometryShaderSO:
+ // Get StreamOut decl
+ //VH( m_msStructured.Read(&dwOffset) );
+ if (cbShaderBin > 0)
+ {
+ VHD( GetStringAndAddToReflection(psInlineGSSO4->oSODecl, &pShaderBlock->pReflectionData->pStreamOutDecls[0]),
+ "Invalid pEffectBuffer: cannot read stream out decl." );
+ }
+ pShaderBlock->pVT = &g_vtGS;
+ break;
+
+ case EOT_VertexShader5:
+ case EOT_GeometryShader5:
+ case EOT_HullShader5:
+ case EOT_DomainShader5:
+ case EOT_PixelShader5:
+ case EOT_ComputeShader5:
+ // Get StreamOut decls
+ if (cbShaderBin > 0)
+ {
+ for( size_t iDecl=0; iDecl < psInlineShader5->cSODecls; ++iDecl )
+ {
+ VHD( GetStringAndAddToReflection(psInlineShader5->oSODecls[iDecl], &pShaderBlock->pReflectionData->pStreamOutDecls[iDecl]),
+ "Invalid pEffectBuffer: cannot read stream out decls." );
+ }
+ pShaderBlock->pReflectionData->RasterizedStream = psInlineShader5->RasterizedStream;
+ pShaderBlock->pReflectionData->InterfaceParameterCount = psInlineShader5->cInterfaceBindings;
+ VH( GetInterfaceParametersAndAddToReflection( psInlineShader5->cInterfaceBindings, psInlineShader5->oInterfaceBindings, &pShaderBlock->pReflectionData->pInterfaceParameters ) );
+ }
+ switch (pType->ObjectType)
+ {
+ case EOT_VertexShader5:
+ pShaderBlock->pVT = &g_vtVS;
+ break;
+ case EOT_GeometryShader5:
+ pShaderBlock->pVT = &g_vtGS;
+ break;
+ case EOT_HullShader5:
+ pShaderBlock->pVT = &g_vtHS;
+ break;
+ case EOT_DomainShader5:
+ pShaderBlock->pVT = &g_vtDS;
+ break;
+ case EOT_PixelShader5:
+ pShaderBlock->pVT = &g_vtPS;
+ break;
+ case EOT_ComputeShader5:
+ pShaderBlock->pVT = &g_vtCS;
+ break;
+ default:
+ VH( E_FAIL );
+ }
+ break;
+
+ case EOT_GeometryShader:
+ pShaderBlock->pVT = &g_vtGS;
+ break;
+
+ case EOT_VertexShader:
+ pShaderBlock->pVT = &g_vtVS;
+ break;
+
+ default:
+ VHD( E_FAIL, "Invalid pEffectBuffer: invalid shader type." );
+ }
+ }
+ }
+ else if (pType->IsObjectType(EOT_String))
+ {
+ // Strings
+
+ chkElementsTotal += m_pEffect->m_StringCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: string object count." );
+ VBD( elementsTotal <= m_pHeader->cStrings, "Invalid pEffectBuffer: string count mismatch." );
+
+ pVar->Data.pString = &m_pEffect->m_pStrings[m_pEffect->m_StringCount];
+
+ for (size_t iElement=0; iElement<elementsToRead; iElement++)
+ {
+ uint32_t dwOffset;
+ SString *pString;
+
+ pString = &m_pEffect->m_pStrings[m_pEffect->m_StringCount];
+ m_pEffect->m_StringCount++;
+
+ // Get string
+ VHD( m_msStructured.Read(&dwOffset), "Invalid pEffectBuffer: cannot read string offset." );
+ VHD( GetStringAndAddToReflection(dwOffset, &pString->pString), "Invalid pEffectBuffer: cannot read string." );
+ }
+ }
+ else if (pType->IsShaderResource())
+ {
+ // Textures/buffers
+
+ chkElementsTotal += m_pEffect->m_ShaderResourceCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: SRV object count." );
+ VBD( elementsTotal <= m_pHeader->cShaderResources, "Invalid pEffectBuffer: SRV count mismatch." );
+
+ pVar->Data.pShaderResource = &m_pEffect->m_pShaderResources[m_pEffect->m_ShaderResourceCount];
+ m_pEffect->m_ShaderResourceCount += elementsToRead;
+ }
+ else if (pType->IsUnorderedAccessView())
+ {
+ // UnorderedAccessViews
+
+ chkElementsTotal += m_pEffect->m_UnorderedAccessViewCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: UAV object count." );
+ VBD( elementsTotal <= m_pHeader->cUnorderedAccessViews, "Invalid pEffectBuffer: UAV count mismatch." );
+
+ pVar->Data.pUnorderedAccessView = &m_pEffect->m_pUnorderedAccessViews[m_pEffect->m_UnorderedAccessViewCount];
+ m_pEffect->m_UnorderedAccessViewCount += elementsToRead;
+ }
+ else if (pType->IsRenderTargetView())
+ {
+ // RenderTargets
+
+ chkElementsTotal += m_pEffect->m_RenderTargetViewCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: RTV object count." );
+ VBD( elementsTotal <= m_pHeader->cRenderTargetViews, "Invalid pEffectBuffer: RTV count mismatch." );
+
+ pVar->Data.pRenderTargetView = &m_pEffect->m_pRenderTargetViews[m_pEffect->m_RenderTargetViewCount];
+ m_pEffect->m_RenderTargetViewCount += elementsToRead;
+ }
+ else if (pType->IsDepthStencilView())
+ {
+ // DepthStencilViews
+
+ chkElementsTotal += m_pEffect->m_DepthStencilViewCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: DSV object count." );
+ VBD( elementsTotal <= m_pHeader->cDepthStencilViews, "Invalid pEffectBuffer: DSV count mismatch." );
+
+ pVar->Data.pDepthStencilView = &m_pEffect->m_pDepthStencilViews[m_pEffect->m_DepthStencilViewCount];
+ m_pEffect->m_DepthStencilViewCount += elementsToRead;
+ }
+ else
+ {
+ VHD( E_FAIL, "Invalid pEffectBuffer: DSV count mismatch." );
+ }
+
+ // Read annotations
+ VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );
+ }
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize an interface variable
+HRESULT CEffectLoader::LoadInterfaceVariables()
+{
+ HRESULT hr = S_OK;
+ uint32_t iBlock;
+ uint32_t cBlocks;
+
+ cBlocks = m_pHeader->cInterfaceVariables;
+
+ for (iBlock=0; iBlock<cBlocks; iBlock++)
+ {
+ SBinaryInterfaceVariable *psBlock;
+ SGlobalVariable *pVar;
+ SType *pType;
+ uint32_t elementsToRead;
+ CCheckedDword chkElementsTotal;
+ uint32_t elementsTotal;
+ void *pDefaultValue;
+
+ // Read variable info
+ VHD( m_msStructured.Read((void**) &psBlock, sizeof(*psBlock)), "Invalid pEffectBuffer: cannot read interface block." );
+ VBD( m_pEffect->m_VariableCount < (m_pHeader->Effect.cObjectVariables + m_pHeader->Effect.cNumericVariables + m_pHeader->cInterfaceVariables),
+ "Internal loading error: variable count mismatch." );
+ pVar = &m_pEffect->m_pVariables[m_pEffect->m_VariableCount];
+
+ // Get type
+ VH( LoadTypeAndAddToPool(&pType, psBlock->oType) );
+
+ // Make sure the right polymorphic type is created
+ VH( PlacementNewVariable(pVar, pType, false) );
+
+ pVar->pEffect = m_pEffect;
+ pVar->pType = pType;
+ pVar->pCB = nullptr;
+ pVar->ExplicitBindPoint = (uint32_t)-1;
+ pVar->pSemantic = nullptr;
+
+ // Get name
+ VHD( GetStringAndAddToReflection(psBlock->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read interface name." );
+
+ m_pEffect->m_VariableCount++;
+ elementsToRead = std::max<uint32_t>(1, pType->Elements);
+ chkElementsTotal = elementsToRead;
+
+ VBD( pType->IsInterface(), "Internal loading error: invlaid type for interface." );
+
+ chkElementsTotal += m_pEffect->m_InterfaceCount;
+ VHD( chkElementsTotal.GetValue(&elementsTotal), "Overflow: interface count." );
+ VBD( elementsTotal <= m_pHeader->cInterfaceVariableElements, "Invalid pEffectBuffer: interface count mismatch." );
+
+ pVar->Data.pInterface = &m_pEffect->m_pInterfaces[m_pEffect->m_InterfaceCount];
+ m_pEffect->m_InterfaceCount += elementsToRead;
+
+ // Get default value
+ if (0 != psBlock->oDefaultValue)
+ {
+ VHD( m_msUnstructured.ReadAtOffset(psBlock->oDefaultValue, elementsToRead * sizeof(SBinaryInterfaceInitializer), &pDefaultValue),
+ "Invalid pEffectBuffer: cannot read interface initializer offset." );
+ for( size_t i=0; i < elementsToRead; i++ )
+ {
+ SBinaryInterfaceInitializer* pInterfaceInit = &((SBinaryInterfaceInitializer*)pDefaultValue)[i];
+ LPCSTR pClassInstanceName;
+ VHD( m_msUnstructured.ReadAtOffset(pInterfaceInit->oInstanceName, &pClassInstanceName), "Invalid pEffectBuffer: cannot read interface initializer." );
+
+ SGlobalVariable *pCIVariable = m_pEffect->FindVariableByName(pClassInstanceName);
+ VBD( pCIVariable != nullptr, "Loading error: cannot find class instance for interface initializer." );
+ VBD( pCIVariable->pType->IsClassInstance(), "Loading error: variable type mismatch for interface initializer." );
+ if( pInterfaceInit->ArrayIndex == (uint32_t)-1 )
+ {
+ VBD( pCIVariable->pType->Elements == 0, "Loading error: array mismatch for interface initializer." );
+ pVar->Data.pInterface[i].pClassInstance = (SClassInstanceGlobalVariable*)pCIVariable;
+ }
+ else
+ {
+ VBD( pCIVariable->pType->Elements > 0, "Loading error: array mismatch for interface initializer." );
+ VBD( pInterfaceInit->ArrayIndex < pCIVariable->pType->Elements, "Loading error: array index out of range." );
+
+ SMember* pMember = (SMember*)pCIVariable->GetElement( pInterfaceInit->ArrayIndex );
+ VBD( pMember->IsValid(), "Loading error: cannot find member by name." );
+ VBD( pMember->pType->IsClassInstance(), "Loading error: member type mismatch for interface initializer." );
+ pVar->Data.pInterface[i].pClassInstance = (SClassInstanceGlobalVariable*)pMember;
+ }
+ }
+ }
+
+
+ // Read annotations
+ VH( LoadAnnotations(&pVar->AnnotationCount, &pVar->pAnnotations) );
+ }
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize a group (and contained techniques and passes)
+HRESULT CEffectLoader::LoadGroups()
+{
+ HRESULT hr = S_OK;
+ uint32_t TechniquesInEffect = 0;
+
+ for( size_t iGroup=0; iGroup<m_pHeader->cGroups; iGroup++ )
+ {
+ SGroup *pGroup = &m_pEffect->m_pGroups[iGroup];
+ SBinaryGroup *psGroup;
+
+ // Read group info
+ VHD( m_msStructured.Read((void**) &psGroup, sizeof(*psGroup)), "Invalid pEffectBuffer: cannot read group." );
+ pGroup->TechniqueCount = psGroup->cTechniques;
+ VN( pGroup->pTechniques = PRIVATENEW STechnique[pGroup->TechniqueCount] );
+ VHD( GetStringAndAddToReflection(psGroup->oName, &pGroup->pName), "Invalid pEffectBuffer: cannot read group name." );
+
+ if( pGroup->pName == nullptr )
+ {
+ VBD( m_pEffect->m_pNullGroup == nullptr, "Internal loading error: multiple nullptr groups." );
+ m_pEffect->m_pNullGroup = pGroup;
+ }
+
+ // Read annotations
+ VH( LoadAnnotations(&pGroup->AnnotationCount, &pGroup->pAnnotations) );
+
+ for( size_t iTechnique=0; iTechnique < psGroup->cTechniques; iTechnique++ )
+ {
+ VH( LoadTechnique( &pGroup->pTechniques[iTechnique] ) );
+ }
+ TechniquesInEffect += psGroup->cTechniques;
+ }
+
+ VBD( TechniquesInEffect == m_pHeader->cTechniques, "Loading error: technique count mismatch." );
+ m_pEffect->m_TechniqueCount = m_pHeader->cTechniques;
+ m_pEffect->m_GroupCount = m_pHeader->cGroups;
+
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize a technique (and contained passes)
+HRESULT CEffectLoader::LoadTechnique( STechnique* pTech )
+{
+ HRESULT hr = S_OK;
+ uint32_t iPass;
+
+ SBinaryTechnique *psTech;
+
+ // Read technique info
+ VHD( m_msStructured.Read((void**) &psTech, sizeof(*psTech)), "Invalid pEffectBuffer: cannot read technique." );
+ pTech->PassCount = psTech->cPasses;
+ VN( pTech->pPasses = PRIVATENEW SPassBlock[pTech->PassCount] );
+ VHD( GetStringAndAddToReflection(psTech->oName, &pTech->pName), "Invalid pEffectBuffer: cannot read technique name." );
+
+ // Read annotations
+ VH( LoadAnnotations(&pTech->AnnotationCount, &pTech->pAnnotations) );
+
+ for (iPass=0; iPass<psTech->cPasses; iPass++)
+ {
+ SBinaryPass *psPass;
+ SPassBlock *pPass = &pTech->pPasses[iPass];
+
+ // Read pass info
+ VHD( m_msStructured.Read((void**) &psPass, sizeof(SBinaryPass)), "Invalid pEffectBuffer: cannot read pass." );
+ VHD( GetStringAndAddToReflection(psPass->oName, &pPass->pName), "Invalid pEffectBuffer: cannot read pass name." );
+
+ // Read annotations
+ VH( LoadAnnotations(&pPass->AnnotationCount, &pPass->pAnnotations) );
+
+ VH( LoadAssignments( psPass->cAssignments, &pPass->pAssignments, (uint8_t*)pPass, &pPass->BackingStore.RenderTargetViewCount, &pPass->AssignmentCount ) );
+ VBD( pPass->BackingStore.RenderTargetViewCount <= D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, "Invalid pEffectBuffer: too many RTVs in pass." );
+
+ // Initialize other pass information
+ pPass->pEffect = m_pEffect;
+ pPass->BlockType = EBT_Pass;
+ }
+
+lExit:
+ return hr;
+}
+
+
+// Read info from the compiled blob and initialize a set of annotations
+HRESULT CEffectLoader::LoadAnnotations(uint32_t *pcAnnotations, SAnnotation **ppAnnotations)
+{
+ HRESULT hr = S_OK;
+ uint32_t cAnnotations, i, oData;
+ SAnnotation *pAnnotations = nullptr;
+
+ VHD( m_msStructured.Read(&cAnnotations), "Invalid pEffectBuffer: cannot read anootation count." );
+
+ if (cAnnotations)
+ {
+ uint32_t annotationsSize;
+ CCheckedDword chkAnnotationsSize;
+
+ chkAnnotationsSize = cAnnotations;
+ chkAnnotationsSize *= sizeof(SAnnotation);
+ VHD( chkAnnotationsSize.GetValue(&annotationsSize), "Overflow in annotations." );
+
+ // we allocate raw bytes for annotations because they are polymorphic types that need to be placement new'ed
+ VN( pAnnotations = (SAnnotation *) PRIVATENEW uint8_t[annotationsSize] );
+
+ for (i=0; i<cAnnotations; i++)
+ {
+ SBinaryAnnotation *psAnnotation;
+ SAnnotation *pAn = &pAnnotations[i];
+ SType *pType;
+
+ VHD( m_msStructured.Read((void**) &psAnnotation, sizeof(SBinaryAnnotation)), "Invalid pEffectBuffer: cannot read annotation." );
+
+ VH( LoadTypeAndAddToPool(&pType, psAnnotation->oType) );
+
+ // Make sure the right polymorphic type is created
+ VH( PlacementNewVariable(pAn, pType, true) );
+
+ pAn->pEffect = m_pEffect;
+ pAn->pType = pType;
+
+ VHD( GetStringAndAddToReflection(psAnnotation->oName, &pAn->pName), "Invalid pEffectBuffer: cannot read annotation name." );
+
+ if (pType->IsObjectType(EOT_String))
+ {
+ uint32_t cElements = std::max<uint32_t>(1, pType->Elements);
+ uint32_t j;
+ VN( pAn->Data.pString = PRIVATENEW SString[cElements] );
+ for (j = 0; j < cElements; ++ j)
+ {
+ // Read initializer offset
+ VHD( m_msStructured.Read(&oData), "Invalid pEffectBuffer: cannot read string." );
+#pragma warning( disable : 6011 )
+ VHD( GetStringAndAddToReflection(oData, &pAn->Data.pString[j].pString), "Invalid pEffectBuffer: cannot read string initializer." );
+ }
+ }
+ else if (pType->BelongsInConstantBuffer())
+ {
+ void *pDefaultValue;
+ uint32_t bytesUnpacked;
+
+ // Read initializer offset
+ VHD( m_msStructured.Read(&oData), "Invalid pEffectBuffer: cannot read annotation." );
+
+ VBD( oData != 0, "Invalid pEffectBuffer: invalid anotation offset." );
+
+ VN( pAn->Data.pGeneric = PRIVATENEW uint8_t[pType->TotalSize] );
+ ZeroMemory(pAn->Data.pGeneric, pType->TotalSize);
+ VHD( m_msUnstructured.ReadAtOffset(oData, pType->PackedSize, &pDefaultValue), "Invalid pEffectBuffer: cannot read variable default value." );
+ VH( UnpackData((uint8_t*) pAn->Data.pGeneric, (uint8_t*) pDefaultValue, pType->PackedSize, pType, &bytesUnpacked) );
+ VBD( bytesUnpacked == pType->PackedSize, "Invalid pEffectBuffer: packed sizes to not match." );
+ }
+ else
+ {
+ VHD( E_FAIL, "Invalid pEffectBuffer: invalid annotation type." );
+ }
+ }
+ }
+
+ *pcAnnotations = cAnnotations;
+ *ppAnnotations = pAnnotations;
+lExit:
+
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Build shader block dependencies from shader metadata
+//////////////////////////////////////////////////////////////////////////
+
+//
+// Grabs shader resource dependency information from the bytecode of the shader
+// (cbuffer, tbuffer, texture, buffer, sampler, and UAV dependencies),
+// and sets up the given SShaderBlock to point to the dependencies within the effect
+//
+HRESULT CEffectLoader::GrabShaderData(SShaderBlock *pShaderBlock)
+{
+ HRESULT hr = S_OK;
+ CEffectVector<SRange> vRanges[ER_Count], *pvRange;
+
+ SRange *pRange = nullptr;
+ CEffectVector<SConstantBuffer*> vTBuffers;
+
+ //////////////////////////////////////////////////////////////////////////
+ // Step 1: iterate through the resource binding structures and build
+ // an "optimized" list of all of the dependencies
+
+ D3D11_SHADER_DESC ShaderDesc;
+ hr = pShaderBlock->pReflectionData->pReflection->GetDesc( &ShaderDesc );
+ if ( FAILED(hr) )
+ return hr;
+
+ // Since we have the shader desc, let's find out if this is a nullptr GS
+ if( D3D11_SHVER_GET_TYPE( ShaderDesc.Version ) == D3D11_SHVER_VERTEX_SHADER && pShaderBlock->GetShaderType() == EOT_GeometryShader )
+ {
+ pShaderBlock->pReflectionData->IsNullGS = true;
+ }
+
+ pShaderBlock->CBDepCount = pShaderBlock->ResourceDepCount = pShaderBlock->TBufferDepCount = pShaderBlock->SampDepCount = 0;
+ pShaderBlock->UAVDepCount = pShaderBlock->InterfaceDepCount = 0;
+
+ for(uint32_t i = 0; i < ShaderDesc.BoundResources; i++)
+ {
+ LPCSTR pName;
+ uint32_t bindPoint, size;
+ ERanges eRange = ER_CBuffer;
+ SShaderResource *pShaderResource = nullptr;
+ SUnorderedAccessView *pUnorderedAccessView = nullptr;
+ SSamplerBlock *pSampler = nullptr;
+ SConstantBuffer *pCB = nullptr;
+ SVariable *pVariable = nullptr;
+ bool isFX9TextureLoad = false;
+ D3D11_SHADER_INPUT_BIND_DESC ResourceDesc;
+
+ pShaderBlock->pReflectionData->pReflection->GetResourceBindingDesc( i, &ResourceDesc );
+
+ // HUGE ASSUMPTION: the bindpoints we read in the shader metadata are sorted;
+ // i.e. bindpoints are steadily increasing
+ // If this assumption is not met, then we will hit an assert below
+
+ pName = ResourceDesc.Name;
+ bindPoint = ResourceDesc.BindPoint;
+ size = ResourceDesc.BindCount;
+
+ switch( ResourceDesc.Type )
+ {
+ case D3D_SIT_CBUFFER:
+ eRange = ER_CBuffer;
+
+ pCB = m_pEffect->FindCB(pName);
+ VBD( nullptr != pCB, "Loading error: cannot find cbuffer." );
+ VBD( size == 1, "Loading error: cbuffer arrays are not supported." );
+ break;
+
+ case D3D_SIT_TBUFFER:
+ eRange = ER_Texture;
+
+ pCB = m_pEffect->FindCB(pName);
+ VBD( nullptr != pCB, "Loading error: cannot find tbuffer." );
+ VBD( false != pCB->IsTBuffer, "Loading error: cbuffer found where tbuffer is expected." );
+ VBD( size == 1, "Loading error: tbuffer arrays are not supported." );
+ pShaderResource = &pCB->TBuffer;
+ break;
+
+ case D3D_SIT_TEXTURE:
+ case D3D_SIT_STRUCTURED:
+ case D3D_SIT_BYTEADDRESS:
+ {
+ eRange = ER_Texture;
+
+ pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
+ VBD( pVariable != nullptr, "Loading error: cannot find SRV variable." );
+ uint32_t elements = std::max<uint32_t>(1, pVariable->pType->Elements);
+ VBD( size <= elements, "Loading error: SRV array size mismatch." );
+
+ if (pVariable->pType->IsShaderResource())
+ {
+ // this is just a straight texture assignment
+ pShaderResource = pVariable->Data.pShaderResource;
+ }
+ else
+ {
+ // This is a FX9/HLSL9-style texture load instruction that specifies only a sampler
+ VBD( pVariable->pType->IsSampler(), "Loading error: shader dependency is neither an SRV nor sampler.");
+ isFX9TextureLoad = true;
+ pSampler = pVariable->Data.pSampler;
+ // validate that all samplers actually used (i.e. based on size, not elements) in this variable have a valid TEXTURE assignment
+ for (size_t j = 0; j < size; ++ j)
+ {
+ if (nullptr == pSampler[j].BackingStore.pTexture)
+ {
+ // print spew appropriately for samplers vs sampler arrays
+ if (0 == pVariable->pType->Elements)
+ {
+ DPF(0, "%s: Sampler %s does not have a texture bound to it, even though the sampler is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName);
+ }
+ else
+ {
+ DPF(0, "%s: Sampler %s[%u] does not have a texture bound to it, even though the sampler array is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName, j);
+ }
+
+ VH( E_FAIL );
+ }
+ }
+ }
+ }
+ break;
+
+ case D3D_SIT_UAV_RWTYPED:
+ case D3D_SIT_UAV_RWSTRUCTURED:
+ case D3D_SIT_UAV_RWBYTEADDRESS:
+ case D3D_SIT_UAV_APPEND_STRUCTURED:
+ case D3D_SIT_UAV_CONSUME_STRUCTURED:
+ case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
+ eRange = ER_UnorderedAccessView;
+
+ pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
+ VBD( pVariable != nullptr, "Loading error: cannot find UAV variable." );
+ VBD( size <= std::max<uint32_t>(1, pVariable->pType->Elements), "Loading error: UAV array index out of range." );
+ VBD( pVariable->pType->IsUnorderedAccessView(), "Loading error: UAV variable expected." );
+ pUnorderedAccessView = pVariable->Data.pUnorderedAccessView;
+ break;
+
+ case D3D_SIT_SAMPLER:
+ eRange = ER_Sampler;
+
+ pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
+ VBD( pVariable != nullptr, "Loading error: cannot find sampler variable." );
+ VBD( size <= std::max<uint32_t>(1, pVariable->pType->Elements), "Loading error: sampler array index out of range." );
+ VBD( pVariable->pType->IsSampler(), "Loading error: sampler variable expected." );
+ pSampler = pVariable->Data.pSampler;
+ break;
+
+ default:
+ VHD( E_FAIL, "Internal loading error: unexpected shader dependency type." );
+ };
+
+ //
+ // Here's where the "optimized" part comes in; whenever there's
+ // a resource dependency, see if it's located contiguous to
+ // an existing resource dependency and merge them together
+ // if possible
+ //
+ uint32_t rangeCount;
+ pvRange = &vRanges[eRange];
+ rangeCount = pvRange->GetSize();
+
+ if ( rangeCount > 0 )
+ {
+ // Can we continue an existing range?
+ pRange = &( (*pvRange)[rangeCount - 1] );
+
+ // Make sure that bind points are strictly increasing,
+ // otherwise this algorithm breaks and we'd get worse runtime performance
+ assert(pRange->last <= bindPoint);
+
+ if ( pRange->last != bindPoint )
+ {
+ if( eRange != ER_UnorderedAccessView )
+ {
+ // No we can't. Begin a new range by setting rangeCount to 0 and triggering the next IF
+ rangeCount = 0;
+ }
+ else
+ {
+ // UAVs will always be located in one range, as they are more expensive to set
+ while(pRange->last < bindPoint)
+ {
+ VHD( pRange->vResources.Add(&g_NullUnorderedAccessView), "Internal loading error: cannot add UAV to range." );
+ pRange->last++;
+ }
+ }
+ }
+ }
+
+ if ( rangeCount == 0 )
+ {
+ VN( pRange = pvRange->Add() );
+ pRange->start = bindPoint;
+ }
+
+ pRange->last = bindPoint + size;
+
+ switch( ResourceDesc.Type )
+ {
+ case D3D_SIT_CBUFFER:
+ VHD( pRange->vResources.Add(pCB), "Internal loading error: cannot add cbuffer to range." );
+ break;
+ case D3D_SIT_TBUFFER:
+ VHD( pRange->vResources.Add(pShaderResource), "Internal loading error: cannot add tbuffer to range." );
+ VHD( vTBuffers.Add( (SConstantBuffer*)pCB ), "Internal loading error: cannot add tbuffer to vector." );
+ break;
+ case D3D_SIT_TEXTURE:
+ case D3D_SIT_STRUCTURED:
+ case D3D_SIT_BYTEADDRESS:
+ if (isFX9TextureLoad)
+ {
+ // grab all of the textures from each sampler
+ for (size_t j = 0; j < size; ++ j)
+ {
+ VHD( pRange->vResources.Add(pSampler[j].BackingStore.pTexture), "Internal loading error: cannot add SRV to range." );
+ }
+ }
+ else
+ {
+ // add the whole array
+ for (size_t j = 0; j < size; ++ j)
+ {
+ VHD( pRange->vResources.Add(pShaderResource + j), "Internal loading error: cannot add SRV to range." );
+ }
+ }
+ break;
+ case D3D_SIT_UAV_RWTYPED:
+ case D3D_SIT_UAV_RWSTRUCTURED:
+ case D3D_SIT_UAV_RWBYTEADDRESS:
+ case D3D_SIT_UAV_APPEND_STRUCTURED:
+ case D3D_SIT_UAV_CONSUME_STRUCTURED:
+ case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
+ // add the whole array
+ for (size_t j = 0; j < size; ++ j)
+ {
+ VHD( pRange->vResources.Add(pUnorderedAccessView + j), "Internal loading error: cannot add UAV to range." );
+ }
+ break;
+ case D3D_SIT_SAMPLER:
+ // add the whole array
+ for (size_t j = 0; j < size; ++ j)
+ {
+ VHD( pRange->vResources.Add(pSampler + j), "Internal loading error: cannot add sampler to range." );
+ }
+ break;
+ default:
+ VHD( E_FAIL, "Internal loading error: unexpected shader dependency type." );
+ }
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // Step 2: iterate through the interfaces and build
+ // an "optimized" list of all of the dependencies
+
+ uint32_t NumInterfaces = pShaderBlock->pReflectionData->pReflection->GetNumInterfaceSlots();
+ uint32_t CurInterfaceParameter = 0;
+ if( NumInterfaces > 0 )
+ {
+ assert( ShaderDesc.ConstantBuffers > 0 );
+
+ for( uint32_t i=0; i < ShaderDesc.ConstantBuffers; i++ )
+ {
+ ID3D11ShaderReflectionConstantBuffer* pCB = pShaderBlock->pReflectionData->pReflection->GetConstantBufferByIndex(i);
+ VN( pCB );
+ D3D11_SHADER_BUFFER_DESC CBDesc;
+ VHD( pCB->GetDesc( &CBDesc ), "Internal loading error: cannot get CB desc." );
+ if( CBDesc.Type != D3D11_CT_INTERFACE_POINTERS )
+ {
+ continue;
+ }
+
+ for( uint32_t iVar=0; iVar < CBDesc.Variables; iVar++ )
+ {
+ ID3D11ShaderReflectionVariable* pInterfaceVar = pCB->GetVariableByIndex( iVar );
+ VN( pInterfaceVar );
+ D3D11_SHADER_VARIABLE_DESC InterfaceDesc;
+ VHD( pInterfaceVar->GetDesc(&InterfaceDesc), "Internal load error: cannot get IV desc.");
+
+ LPCSTR pName;
+ uint32_t bindPoint, size;
+ SGlobalVariable *pVariable = nullptr;
+ SInterface *pInterface = nullptr;
+ uint32_t VariableElements;
+
+ pName = InterfaceDesc.Name;
+ bindPoint = InterfaceDesc.StartOffset;
+ size = InterfaceDesc.Size;
+
+ if( bindPoint == (uint32_t)-1 )
+ {
+ continue;
+ }
+
+ assert( InterfaceDesc.uFlags & D3D11_SVF_INTERFACE_POINTER );
+ if( InterfaceDesc.uFlags & D3D11_SVF_INTERFACE_PARAMETER )
+ {
+ // This interface pointer is a parameter to the shader
+ if( pShaderBlock->pReflectionData->InterfaceParameterCount == 0 )
+ {
+ // There may be no interface parameters in this shader if it was compiled but had no interfaced bound to it.
+ // The shader cannot be set (correctly) in any pass.
+ continue;
+ }
+ else
+ {
+ VBD( CurInterfaceParameter < pShaderBlock->pReflectionData->InterfaceParameterCount,
+ "Internal loading error: interface count mismatch.");
+ SShaderBlock::SInterfaceParameter* pInterfaceInfo;
+ pInterfaceInfo = &pShaderBlock->pReflectionData->pInterfaceParameters[CurInterfaceParameter];
+ ++CurInterfaceParameter;
+ SGlobalVariable *pParent = m_pEffect->FindVariableByName(pInterfaceInfo->pName);
+ VBD( pParent != nullptr, "Loading error: cannot find parent type." );
+ if( pInterfaceInfo->Index == (uint32_t)-1 )
+ {
+ pVariable = pParent;
+ VariableElements = pVariable->pType->Elements;
+ }
+ else
+ {
+ // We want a specific index of the variable (ex. "MyVar[2]")
+ VBD( size == 1, "Loading error: interface array type mismatch." );
+ pVariable = (SGlobalVariable*)pParent->GetElement( pInterfaceInfo->Index );
+ VBD( pVariable->IsValid(), "Loading error: interface array index out of range." );
+ VariableElements = 0;
+ }
+ }
+ }
+ else
+ {
+ // This interface pointer is a global interface used in the shader
+ pVariable = m_pEffect->FindVariableByName(pName);
+ VBD( pVariable != nullptr, "Loading error: cannot find interface variable." );
+ VariableElements = pVariable->pType->Elements;
+ }
+ VBD( size <= std::max<uint32_t>(1, VariableElements), "Loading error: interface array size mismatch." );
+ if( pVariable->pType->IsInterface() )
+ {
+ pInterface = pVariable->Data.pInterface;
+ }
+ else if( pVariable->pType->IsClassInstance() )
+ {
+ // For class instances, we create background interfaces which point to the class instance. This is done so
+ // the shader can always expect SInterface dependencies, rather than a mix of SInterfaces and class instances
+ VN( pInterface = PRIVATENEW SInterface[size] );
+ if( VariableElements == 0 )
+ {
+ assert( size == 1 );
+ pInterface[0].pClassInstance = (SClassInstanceGlobalVariable*)pVariable;
+ m_BackgroundInterfaces.Add( &pInterface[0] );
+ }
+ else
+ {
+ // Fill each element of the SInstance array individually
+ VBD( size == VariableElements, "Loading error: class instance array size mismatch." );
+ for( uint32_t iElement=0; iElement < size; iElement++ )
+ {
+ SGlobalVariable *pElement = (SGlobalVariable*)pVariable->GetElement( iElement );
+ VBD( pElement->IsValid(), "Internal loading error: class instance array index out of range." );
+ pInterface[iElement].pClassInstance = (SClassInstanceGlobalVariable*)pElement;
+ m_BackgroundInterfaces.Add( &pInterface[iElement] );
+ }
+ }
+ }
+ else
+ {
+ VHD( E_FAIL, "Loading error: invalid interface initializer variable type.");
+ }
+
+ //
+ // Here's where the "optimized" part comes in; whenever there's
+ // a resource dependency, see if it's located contiguous to
+ // an existing resource dependency and merge them together
+ // if possible
+ //
+ uint32_t rangeCount;
+ pvRange = &vRanges[ER_Interfaces];
+ rangeCount = pvRange->GetSize();
+
+ VBD( rangeCount <= 1, "Internal loading error: invalid range count." );
+
+ if ( rangeCount == 0 )
+ {
+ VN( pRange = pvRange->Add() );
+ pRange->start = pRange->last = 0;
+ }
+ else
+ {
+ pRange = &( (*pvRange)[0] );
+ }
+
+ if( bindPoint < pRange->last )
+ {
+ // add interfaces into the range that already exists
+ VBD( bindPoint + size < pRange->last, "Internal loading error: range overlap." );
+ for( uint32_t j = 0; j < size; ++ j )
+ {
+ pRange->vResources[j + bindPoint] = pInterface + j;
+ }
+ }
+ else
+ {
+ // add interfaces to the end of the range
+
+ // add missing interface slots, if necessary
+ while(pRange->last < bindPoint)
+ {
+ VHD( pRange->vResources.Add(&g_NullInterface), "Internal loading error: cannot add nullptr interface to range." );
+ pRange->last++;
+ }
+
+ assert( bindPoint == pRange->last );
+ for( size_t j=0; j < size; ++ j )
+ {
+ VHD( pRange->vResources.Add(pInterface + j), "Internal loading error: cannot at interface to range." );
+ }
+ pRange->last = bindPoint + size;
+ }
+ }
+
+ // There is only one interface cbuffer
+ break;
+ }
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ // Step 3: allocate room in pShaderBlock for all of the dependency
+ // pointers and then hook them up
+
+ pShaderBlock->SampDepCount = vRanges[ ER_Sampler ].GetSize();
+ pShaderBlock->CBDepCount = vRanges[ ER_CBuffer ].GetSize();
+ pShaderBlock->InterfaceDepCount = vRanges[ ER_Interfaces ].GetSize();
+ pShaderBlock->ResourceDepCount = vRanges[ ER_Texture ].GetSize();
+ pShaderBlock->UAVDepCount = vRanges[ ER_UnorderedAccessView ].GetSize();
+ pShaderBlock->TBufferDepCount = vTBuffers.GetSize();
+
+ VN( pShaderBlock->pSampDeps = PRIVATENEW SShaderSamplerDependency[pShaderBlock->SampDepCount] );
+ VN( pShaderBlock->pCBDeps = PRIVATENEW SShaderCBDependency[pShaderBlock->CBDepCount] );
+ VN( pShaderBlock->pInterfaceDeps = PRIVATENEW SInterfaceDependency[pShaderBlock->InterfaceDepCount] );
+ VN( pShaderBlock->pResourceDeps = PRIVATENEW SShaderResourceDependency[pShaderBlock->ResourceDepCount] );
+ VN( pShaderBlock->pUAVDeps = PRIVATENEW SUnorderedAccessViewDependency[pShaderBlock->UAVDepCount] );
+ VN( pShaderBlock->ppTbufDeps = PRIVATENEW SConstantBuffer*[pShaderBlock->TBufferDepCount] );
+
+ for (size_t i=0; i<pShaderBlock->CBDepCount; ++i)
+ {
+ SShaderCBDependency *pDep = &pShaderBlock->pCBDeps[i];
+
+ pRange = &vRanges[ER_CBuffer][i];
+
+ pDep->StartIndex = pRange->start;
+ pDep->Count = pRange->last - pDep->StartIndex;
+ pDep->ppFXPointers = PRIVATENEW SConstantBuffer*[ pDep->Count ];
+ pDep->ppD3DObjects = PRIVATENEW ID3D11Buffer*[ pDep->Count ];
+
+ assert(pDep->Count == pRange->vResources.GetSize());
+ for (size_t j=0; j<pDep->Count; ++j)
+ {
+ pDep->ppFXPointers[j] = (SConstantBuffer *)pRange->vResources[j];
+ pDep->ppD3DObjects[j] = nullptr;
+ }
+ }
+
+ for (size_t i=0; i<pShaderBlock->SampDepCount; ++i)
+ {
+ SShaderSamplerDependency *pDep = &pShaderBlock->pSampDeps[i];
+
+ pRange = &vRanges[ER_Sampler][i];
+
+ pDep->StartIndex = pRange->start;
+ pDep->Count = pRange->last - pDep->StartIndex;
+ pDep->ppFXPointers = PRIVATENEW SSamplerBlock*[ pDep->Count ];
+ pDep->ppD3DObjects = PRIVATENEW ID3D11SamplerState*[ pDep->Count ];
+
+ assert(pDep->Count == pRange->vResources.GetSize());
+ for (size_t j=0; j<pDep->Count; ++j)
+ {
+ pDep->ppFXPointers[j] = (SSamplerBlock *) pRange->vResources[j];
+ pDep->ppD3DObjects[j] = nullptr;
+ }
+ }
+
+ for (size_t i=0; i<pShaderBlock->InterfaceDepCount; ++i)
+ {
+ SInterfaceDependency *pDep = &pShaderBlock->pInterfaceDeps[i];
+
+ pRange = &vRanges[ER_Interfaces][i];
+
+ pDep->StartIndex = pRange->start;
+ pDep->Count = pRange->last - pDep->StartIndex;
+ pDep->ppFXPointers = PRIVATENEW SInterface*[ pDep->Count ];
+ pDep->ppD3DObjects = PRIVATENEW ID3D11ClassInstance*[ pDep->Count ];
+
+ assert(pDep->Count == pRange->vResources.GetSize());
+ for (size_t j=0; j<pDep->Count; ++j)
+ {
+ pDep->ppFXPointers[j] = (SInterface *) pRange->vResources[j];
+ pDep->ppD3DObjects[j] = nullptr;
+ }
+ }
+
+ for (size_t i=0; i<pShaderBlock->ResourceDepCount; ++i)
+ {
+ SShaderResourceDependency *pDep = &pShaderBlock->pResourceDeps[i];
+
+ pRange = &vRanges[ER_Texture][i];
+
+ pDep->StartIndex = pRange->start;
+ pDep->Count = pRange->last - pDep->StartIndex;
+ pDep->ppFXPointers = PRIVATENEW SShaderResource*[ pDep->Count ];
+ pDep->ppD3DObjects = PRIVATENEW ID3D11ShaderResourceView*[ pDep->Count ];
+
+ assert(pDep->Count == pRange->vResources.GetSize());
+ for (size_t j=0; j<pDep->Count; ++j)
+ {
+ pDep->ppFXPointers[j] = (SShaderResource *) pRange->vResources[j];
+ pDep->ppD3DObjects[j] = nullptr;
+ }
+ }
+
+ for (size_t i=0; i<pShaderBlock->UAVDepCount; ++i)
+ {
+ SUnorderedAccessViewDependency *pDep = &pShaderBlock->pUAVDeps[i];
+
+ pRange = &vRanges[ER_UnorderedAccessView][i];
+
+ pDep->StartIndex = pRange->start;
+ pDep->Count = pRange->last - pDep->StartIndex;
+ pDep->ppFXPointers = PRIVATENEW SUnorderedAccessView*[ pDep->Count ];
+ pDep->ppD3DObjects = PRIVATENEW ID3D11UnorderedAccessView*[ pDep->Count ];
+
+ assert(pDep->Count == pRange->vResources.GetSize());
+ for (size_t j=0; j<pDep->Count; ++j)
+ {
+ pDep->ppFXPointers[j] = (SUnorderedAccessView *) pRange->vResources[j];
+ pDep->ppD3DObjects[j] = nullptr;
+ }
+ }
+
+ if (pShaderBlock->TBufferDepCount > 0)
+ {
+ memcpy(pShaderBlock->ppTbufDeps, &vTBuffers[0], pShaderBlock->TBufferDepCount * sizeof(SConstantBuffer*));
+ }
+
+lExit:
+ return hr;
+}
+
+// Create shader reflection interface and grab dependency info
+HRESULT CEffectLoader::BuildShaderBlock(SShaderBlock *pShaderBlock)
+{
+ HRESULT hr = S_OK;
+
+ // unused shader block? that's not right
+ VBD( pShaderBlock->pVT != nullptr, "Internal loading error: nullptr shader vtable." );
+
+ assert(pShaderBlock->pD3DObject == nullptr);
+
+ if (nullptr == pShaderBlock->pReflectionData)
+ {
+ // File contains a shader variable without an assigned shader, or this is a null assignment.
+ // Usually, this is called by one of these guys:
+ // SetVertexShader( nullptr );
+ // or
+ // vertexshader g_VS = nullptr;
+ return S_OK;
+ }
+
+ // Initialize the reflection interface
+ VHD( D3DReflect( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, IID_ID3D11ShaderReflection, (void**)&pShaderBlock->pReflectionData->pReflection ),
+ "Internal loading error: cannot create shader reflection object." );
+
+ // Get dependencies
+ VH( GrabShaderData( pShaderBlock ) );
+
+ // Grab input signatures for VS
+ if( EOT_VertexShader == pShaderBlock->GetShaderType() )
+ {
+ assert( pShaderBlock->pInputSignatureBlob == nullptr );
+ VHD( D3DGetBlobPart( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength,
+ D3D_BLOB_INPUT_SIGNATURE_BLOB, 0,
+ &pShaderBlock->pInputSignatureBlob ),
+ "Internal loading error: cannot get input signature." );
+ }
+
+lExit:
+ return hr;
+}
+
+#undef PRIVATENEW
+
+
+//////////////////////////////////////////////////////////////////////////
+// Code to relocate data to private heaps (reflection & runtime effect)
+//
+// Important note about alignment: all reasonable chunks of data are
+// machine word aligned (that is, any piece of data moved as a whole is
+// aligned as a whole. This means that when computing m_ReflectionMemory
+// or m_EffectMemory, each addition is aligned. This also means
+// that, when later relocating that same memory, you must call MoveData
+// or MoveString on the same chunks that were aligned. This is
+// because: Align(a * b) != a * Align(b).
+//////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////
+// Reflection reallocation code
+//////////////////////////////////////////////////////////////////////////
+
+HRESULT CEffectLoader::CalculateAnnotationSize(uint32_t cAnnotations, SAnnotation *pAnnotations)
+{
+ HRESULT hr = S_OK;
+ uint32_t i;
+
+ m_ReflectionMemory += AlignToPowerOf2(cAnnotations * sizeof(SAnnotation), c_DataAlignment);
+ for (i=0; i<cAnnotations; i++)
+ {
+ if (pAnnotations[i].pType->BelongsInConstantBuffer())
+ {
+ m_ReflectionMemory += AlignToPowerOf2(pAnnotations[i].pType->TotalSize, c_DataAlignment);
+ }
+ else
+ {
+ VBD( pAnnotations[i].pType->IsObjectType(EOT_String), "Invalid pEffectBuffer: invalid annotation type." );
+
+ uint32_t cElements = std::max<uint32_t>(1, pAnnotations[i].pType->Elements);
+
+ m_ReflectionMemory += AlignToPowerOf2(cElements * sizeof(SString), c_DataAlignment);
+
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::ReallocateAnnotationData(uint32_t cAnnotations, SAnnotation **ppAnnotations)
+{
+ HRESULT hr = S_OK;
+ uint32_t i;
+ SAnnotation *pAnnotations;
+
+ VHD( m_pReflection->m_Heap.MoveData((void**) ppAnnotations, cAnnotations * sizeof(SAnnotation)),
+ "Internal loading error: cannot move annotation data." );
+ pAnnotations = *ppAnnotations;
+
+ for (i=0; i<cAnnotations; i++)
+ {
+ SAnnotation *pAn = &pAnnotations[i];
+ pAn->pEffect = m_pEffect;
+
+ VHD( m_pReflection->m_Heap.MoveString(&pAn->pName), "Internal loading error: cannot move annotation name." );
+
+ // Reallocate type later
+ if (pAn->pType->BelongsInConstantBuffer())
+ {
+ VHD( m_pReflection->m_Heap.MoveData( &pAn->Data.pGeneric, pAn->pType->TotalSize ), "Internal loading error: cannot move annotation data." );
+ }
+ else if (pAnnotations[i].pType->IsObjectType(EOT_String))
+ {
+ uint32_t cElements = std::max<uint32_t>(1, pAn->pType->Elements);
+
+ VHD( m_pReflection->m_Heap.MoveData((void**) &pAn->Data.pString, cElements * sizeof(SString)), "Internal loading error: cannot move annotation string." );
+ for (size_t j = 0; j < cElements; ++ j)
+ {
+ VHD( m_pReflection->m_Heap.MoveString(&pAn->Data.pString[j].pString), "Internal loading error: cannot move annotation string element." );
+ }
+ }
+ else
+ {
+ VHD( E_FAIL, "Invalid pEffectBuffer: invalid annotation type." );
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffectLoader::InitializeReflectionDataAndMoveStrings( uint32_t KnownSize )
+{
+ HRESULT hr = S_OK;
+ uint32_t cbStrings;
+ CEffectHeap *pHeap = &m_pReflection->m_Heap;
+
+ // Get byte counts
+ cbStrings = m_pEffect->m_StringCount * sizeof( SString );
+
+ if( KnownSize )
+ {
+ m_ReflectionMemory = KnownSize;
+ }
+ else
+ {
+ m_ReflectionMemory += AlignToPowerOf2(cbStrings, c_DataAlignment);
+
+ for (size_t i=0; i<m_pEffect->m_CBCount; i++)
+ {
+ VH( CalculateAnnotationSize(m_pEffect->m_pCBs[i].AnnotationCount, m_pEffect->m_pCBs[i].pAnnotations) );
+ }
+
+ for (size_t i=0; i<m_pEffect->m_VariableCount; i++)
+ {
+ VH( CalculateAnnotationSize(m_pEffect->m_pVariables[i].AnnotationCount, m_pEffect->m_pVariables[i].pAnnotations) );
+ }
+
+ for (size_t i=0; i<m_pEffect->m_GroupCount; i++)
+ {
+ VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].AnnotationCount, m_pEffect->m_pGroups[i].pAnnotations) );
+
+ for (size_t j=0; j<m_pEffect->m_pGroups[i].TechniqueCount; j++)
+ {
+ VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].pTechniques[j].AnnotationCount, m_pEffect->m_pGroups[i].pTechniques[j].pAnnotations) );
+
+ for (size_t k=0; k<m_pEffect->m_pGroups[i].pTechniques[j].PassCount; k++)
+ {
+ VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount, m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations) );
+ }
+ }
+ }
+
+ // Calculate shader reflection data size
+ for (size_t i=0; i<m_pEffect->m_ShaderBlockCount; i++)
+ {
+ if (nullptr != m_pEffect->m_pShaderBlocks[i].pReflectionData)
+ {
+ m_ReflectionMemory += AlignToPowerOf2(sizeof(SShaderBlock::SReflectionData), c_DataAlignment);
+ m_ReflectionMemory += AlignToPowerOf2(m_pEffect->m_pShaderBlocks[i].pReflectionData->BytecodeLength, c_DataAlignment);
+ // stream out decl is handled as a string, and thus its size is already factored because of GetStringAndAddToReflection
+ }
+ }
+ }
+
+ VHD( pHeap->ReserveMemory(m_ReflectionMemory), "Internal loading error: failed to reserve reflection memory." );
+
+ // Strings are handled separately because we are moving them to reflection
+ m_pOldStrings = m_pEffect->m_pStrings;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pStrings, cbStrings), "Internal loading error: cannot move string data." );
+ for(size_t i=0; i<m_pEffect->m_StringCount; i++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pStrings[i].pString), "Internal loading error: cannot move string pointer." );
+ }
+
+lExit:
+ return hr;
+}
+
+// Move all reflection data to private heap
+HRESULT CEffectLoader::ReallocateReflectionData( bool Cloning )
+{
+ HRESULT hr = S_OK;
+ CEffectHeap *pHeap = &m_pReflection->m_Heap;
+
+ for(size_t i=0; i<m_pEffect->m_CBCount; i++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pCBs[i].pName ), "Internal loading error: cannot move CB name." );
+ VH( ReallocateAnnotationData(m_pEffect->m_pCBs[i].AnnotationCount, &m_pEffect->m_pCBs[i].pAnnotations) );
+ }
+
+ for(size_t i=0; i<m_pEffect->m_VariableCount; i++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pVariables[i].pName ), "Internal loading error: cannot move variable name." );
+ VHD( pHeap->MoveString( &m_pEffect->m_pVariables[i].pSemantic ), "Internal loading error: cannot move variable semantic." );
+ VH( ReallocateAnnotationData(m_pEffect->m_pVariables[i].AnnotationCount, &m_pEffect->m_pVariables[i].pAnnotations) );
+ }
+
+ for(size_t i=0; i<m_pEffect->m_GroupCount; i++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pName ), "Internal loading error: cannot move group name." );
+ VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].AnnotationCount, &m_pEffect->m_pGroups[i].pAnnotations) );
+
+ for(size_t j=0; j<m_pEffect->m_pGroups[i].TechniqueCount; j++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pTechniques[j].pName ), "Internal loading error: cannot move technique name." );
+ VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].pTechniques[j].AnnotationCount, &m_pEffect->m_pGroups[i].pTechniques[j].pAnnotations) );
+
+ for(size_t k=0; k<m_pEffect->m_pGroups[i].pTechniques[j].PassCount; k++)
+ {
+ VHD( pHeap->MoveString( &m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pName ), "Internal loading error: cannot move pass name." );
+ VH( ReallocateAnnotationData(m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount, &m_pEffect->m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations) );
+ }
+ }
+ }
+
+ if( !Cloning )
+ {
+ // When not cloning, every member in m_pMemberInterfaces is from a global variable, so we can take pName and pSemantic
+ // from the parent variable, which were updated above
+ for (size_t i = 0; i < m_pEffect->m_pMemberInterfaces.GetSize(); ++ i)
+ {
+ SMember* pMember = m_pEffect->m_pMemberInterfaces[i];
+ SGlobalVariable* pTopLevelEntity = (SGlobalVariable*)pMember->pTopLevelEntity;
+ VH( FixupVariablePointer( &pTopLevelEntity ) );
+ pMember->pName = pTopLevelEntity->pName;
+ pMember->pSemantic = pTopLevelEntity->pSemantic;
+ }
+ }
+
+ // Move shader bytecode
+ for (size_t i=0; i<m_pEffect->m_ShaderBlockCount; i++)
+ {
+ if (nullptr != m_pEffect->m_pShaderBlocks[i].pReflectionData)
+ {
+ VHD( pHeap->MoveData((void**)&m_pEffect->m_pShaderBlocks[i].pReflectionData, sizeof(SShaderBlock::SReflectionData)),
+ "Internal loading error: cannot move shader reflection block." );
+ VHD( pHeap->MoveData((void**)&m_pEffect->m_pShaderBlocks[i].pReflectionData->pBytecode, m_pEffect->m_pShaderBlocks[i].pReflectionData->BytecodeLength),
+ "Internal loading error: cannot move shader bytecode.");
+ for( size_t iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
+ {
+ VHD( pHeap->MoveString(&m_pEffect->m_pShaderBlocks[i].pReflectionData->pStreamOutDecls[iDecl]), "Internal loading error: cannot move SO decl." );
+ }
+ VH( pHeap->MoveInterfaceParameters(m_pEffect->m_pShaderBlocks[i].pReflectionData->InterfaceParameterCount, &m_pEffect->m_pShaderBlocks[i].pReflectionData->pInterfaceParameters ) );
+ }
+
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Runtime effect reallocation code
+//////////////////////////////////////////////////////////////////////////
+
+template<class T> HRESULT CEffectLoader::ReallocateBlockAssignments(T* &pBlocks, uint32_t cBlocks, T* pOldBlocks)
+{
+ HRESULT hr = S_OK;
+ CEffectHeap *pHeap = &m_pEffect->m_Heap;
+
+ for(size_t i=0; i<cBlocks; i++)
+ {
+ T *pBlock = &pBlocks[i];
+ VHD( pHeap->MoveData((void**) &pBlock->pAssignments, sizeof(SAssignment)*pBlock->AssignmentCount), "Internal loading error: cannot move assignment count." );
+
+ for (size_t j=0; j<pBlock->AssignmentCount; j++)
+ {
+ SAssignment *pAssignment = &pBlock->pAssignments[j];
+ uint32_t cbDeps;
+
+ // When cloning, convert pointers back into offsets
+ if( pOldBlocks )
+ {
+ T *pOldBlock = &pOldBlocks[i];
+ pAssignment->Destination.Offset = (uint32_t)( (UINT_PTR)pAssignment->Destination.pGeneric - (UINT_PTR)pOldBlock ) ;
+ }
+
+ // Convert destination pointers from offset to real pointer
+ pAssignment->Destination.pGeneric = (uint8_t*) pBlock + pAssignment->Destination.Offset;
+
+ // Make sure the data pointer points into the backing store
+ VBD( pAssignment->Destination.pGeneric >= &pBlock->BackingStore &&
+ pAssignment->Destination.pGeneric < (uint8_t*) &pBlock->BackingStore + sizeof(pBlock->BackingStore),
+ "Internal loading error: assignment destination out of range." );
+
+ // Fixup dependencies
+ cbDeps = pAssignment->DependencyCount * sizeof(SAssignment::SDependency);
+ VHD( pHeap->MoveData((void**) &pAssignment->pDependencies, cbDeps), "Internal loading error: cannot move assignment dependencies." );
+
+ SGlobalVariable *pOldVariable = nullptr;
+ for(size_t iDep=0; iDep<pAssignment->DependencyCount; iDep++)
+ {
+ SAssignment::SDependency *pDep = &pAssignment->pDependencies[iDep];
+ // We ignore all but the last variable because below, we only use the last dependency
+ pOldVariable = pDep->pVariable;
+ VH( FixupVariablePointer(&pDep->pVariable) );
+ }
+
+ // Fixup source pointers
+ switch(pAssignment->LhsType)
+ {
+ case ELHS_VertexShaderBlock:
+ case ELHS_PixelShaderBlock:
+ case ELHS_GeometryShaderBlock:
+ case ELHS_HullShaderBlock:
+ case ELHS_DomainShaderBlock:
+ case ELHS_ComputeShaderBlock:
+ VH( FixupShaderPointer(&pAssignment->Source.pShader) );
+ break;
+
+ case ELHS_DepthStencilBlock:
+ VH( FixupDSPointer((SDepthStencilBlock**)&pAssignment->Source.pBlock) );
+ break;
+ case ELHS_BlendBlock:
+ VH( FixupABPointer((SBlendBlock**) &pAssignment->Source.pBlock) );
+ break;
+ case ELHS_RasterizerBlock:
+ VH( FixupRSPointer((SRasterizerBlock**) &pAssignment->Source.pBlock) );
+ break;
+
+ case ELHS_Texture:
+ VH( FixupShaderResourcePointer((SShaderResource**) &pAssignment->Source.pShaderResource) );
+ break;
+
+ default:
+ // Non-object assignment (must have at least one dependency or it would have been pruned by now)
+ assert( !pAssignment->IsObjectAssignment() && pAssignment->DependencyCount > 0 );
+
+ // Numeric variables must be relocated before this function is called
+
+ switch (pAssignment->AssignmentType)
+ {
+ case ERAT_NumericVariable:
+ case ERAT_NumericVariableIndex:
+ // the variable or variable array is always the last dependency in the chain
+ SGlobalVariable *pVariable;
+ pVariable = pAssignment->pDependencies[pAssignment->DependencyCount - 1].pVariable;
+ assert( pVariable->pType->BelongsInConstantBuffer() && nullptr != pVariable->pCB );
+
+ // When cloning, convert pointers back into offsets
+ if( pOldBlocks )
+ {
+ VBD( pOldVariable != nullptr, "Internal loading error: pOldVariable is nullptr." );
+ pAssignment->Source.Offset = pAssignment->Source.pNumeric - pOldVariable->pCB->pBackingStore;
+ }
+
+ // Convert from offset to pointer
+ pAssignment->Source.pNumeric = pVariable->pCB->pBackingStore + pAssignment->Source.Offset;
+ break;
+
+ default:
+ // Shouldn't be able to get here
+ assert(0);
+ VHD( E_FAIL, "Loading error: invalid assignment type." );
+ }
+ break;
+
+ case ELHS_Invalid:
+ VHD( E_FAIL, "Loading error: invalid assignment type." );
+ }
+
+ assert(m_pEffect->m_LocalTimer > 0);
+ m_pEffect->EvaluateAssignment(pAssignment);
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+template<class T> uint32_t CEffectLoader::CalculateBlockAssignmentSize(T* &pBlocks, uint32_t cBlocks)
+{
+ uint32_t dwSize = 0;
+
+ for(size_t i=0; i<cBlocks; i++)
+ {
+ SBaseBlock *pBlock = &pBlocks[i];
+ dwSize += AlignToPowerOf2(pBlock->AssignmentCount * sizeof(SAssignment), c_DataAlignment);
+
+ for (size_t j=0; j<pBlock->AssignmentCount; j++)
+ {
+ SAssignment *pAssignment = &pBlock->pAssignments[j];
+
+ dwSize += AlignToPowerOf2(pAssignment->DependencyCount * sizeof(SAssignment::SDependency), c_DataAlignment);
+ }
+ }
+
+ return dwSize;
+}
+
+HRESULT CEffectLoader::ReallocateShaderBlocks()
+{
+ HRESULT hr = S_OK;
+ CEffectHeap *pHeap = &m_pEffect->m_Heap;
+ const char* pError = "Internal loading error: cannot move shader data.";
+
+ for (size_t i=0; i<m_pEffect->m_ShaderBlockCount; i++)
+ {
+ SShaderBlock *pShader = &m_pEffect->m_pShaderBlocks[i];
+
+ // pShader->pReflection data and all of its members (bytecode, SO decl, etc.) are handled by ReallocateReflectionData()
+ VHD( pHeap->MoveData((void**) &pShader->pCBDeps, pShader->CBDepCount * sizeof(SShaderCBDependency)), pError );
+ VHD( pHeap->MoveData((void**) &pShader->pSampDeps, pShader->SampDepCount * sizeof(SShaderSamplerDependency)), pError );
+ VHD( pHeap->MoveData((void**) &pShader->pInterfaceDeps, pShader->InterfaceDepCount * sizeof(SInterfaceDependency)), pError );
+ VHD( pHeap->MoveData((void**) &pShader->pResourceDeps, pShader->ResourceDepCount * sizeof(SShaderResourceDependency)), pError );
+ VHD( pHeap->MoveData((void**) &pShader->pUAVDeps, pShader->UAVDepCount * sizeof(SUnorderedAccessViewDependency)), pError );
+ VHD( pHeap->MoveData((void**) &pShader->ppTbufDeps, pShader->TBufferDepCount * sizeof(SConstantBuffer*)), pError );
+
+ for (size_t j=0; j<pShader->CBDepCount; j++)
+ {
+ SShaderCBDependency *pCBDeps = &pShader->pCBDeps[j];
+ VHD( pHeap->MoveData((void**) &pCBDeps->ppD3DObjects, pCBDeps->Count * sizeof(ID3D11Buffer*)), pError );
+ VHD( pHeap->MoveData((void**) &pCBDeps->ppFXPointers, pCBDeps->Count * sizeof(SConstantBuffer*)), pError );
+
+ for (size_t k=0; k<pCBDeps->Count; k++)
+ {
+ VH( FixupCBPointer( &pCBDeps->ppFXPointers[k] ) );
+ }
+ }
+
+ for (size_t j=0; j<pShader->SampDepCount; j++)
+ {
+ SShaderSamplerDependency *pSampDeps = &pShader->pSampDeps[j];
+ VHD( pHeap->MoveData((void**) &pSampDeps->ppD3DObjects, pSampDeps->Count * sizeof(ID3D11SamplerState*)), pError );
+ VHD( pHeap->MoveData((void**) &pSampDeps->ppFXPointers, pSampDeps->Count * sizeof(SSamplerBlock*)), pError );
+
+ for (size_t k=0; k<pSampDeps->Count; k++)
+ {
+ VH( FixupSamplerPointer(&pSampDeps->ppFXPointers[k]) );
+ }
+ }
+
+ for (size_t j=0; j<pShader->InterfaceDepCount; j++)
+ {
+ SInterfaceDependency *pInterfaceDeps = &pShader->pInterfaceDeps[j];
+ VHD( pHeap->MoveData((void**) &pInterfaceDeps->ppD3DObjects, pInterfaceDeps->Count * sizeof(ID3D11ClassInstance*)), pError );
+ VHD( pHeap->MoveData((void**) &pInterfaceDeps->ppFXPointers, pInterfaceDeps->Count * sizeof(SInterface*)), pError );
+
+ for (size_t k=0; k<pInterfaceDeps->Count; k++)
+ {
+ VH( FixupInterfacePointer(&pInterfaceDeps->ppFXPointers[k], true) );
+ }
+ }
+
+ for (size_t j=0; j<pShader->ResourceDepCount; j++)
+ {
+ SShaderResourceDependency *pResourceDeps = &pShader->pResourceDeps[j];
+ VHD( pHeap->MoveData((void**) &pResourceDeps->ppD3DObjects, pResourceDeps->Count * sizeof(ID3D11ShaderResourceView*)), pError );
+ VHD( pHeap->MoveData((void**) &pResourceDeps->ppFXPointers, pResourceDeps->Count * sizeof(SShaderResource*)), pError );
+
+ for (size_t k=0; k<pResourceDeps->Count; k++)
+ {
+ VH( FixupShaderResourcePointer(&pResourceDeps->ppFXPointers[k]) );
+ }
+ }
+
+ for (size_t j=0; j<pShader->UAVDepCount; j++)
+ {
+ SUnorderedAccessViewDependency *pUAVDeps = &pShader->pUAVDeps[j];
+ VHD( pHeap->MoveData((void**) &pUAVDeps->ppD3DObjects, pUAVDeps->Count * sizeof(ID3D11UnorderedAccessView*)), pError );
+ VHD( pHeap->MoveData((void**) &pUAVDeps->ppFXPointers, pUAVDeps->Count * sizeof(SUnorderedAccessView*)), pError );
+
+ for (size_t k=0; k<pUAVDeps->Count; k++)
+ {
+ VH( FixupUnorderedAccessViewPointer(&pUAVDeps->ppFXPointers[k]) );
+ }
+ }
+
+ for (size_t j=0; j<pShader->TBufferDepCount; j++)
+ {
+ VH( FixupCBPointer( &pShader->ppTbufDeps[j] ) );
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+
+uint32_t CEffectLoader::CalculateShaderBlockSize()
+{
+ uint32_t dwSize = 0;
+
+ for (size_t i=0; i<m_pEffect->m_ShaderBlockCount; i++)
+ {
+ SShaderBlock *pShader = &m_pEffect->m_pShaderBlocks[i];
+
+ dwSize += AlignToPowerOf2(pShader->CBDepCount * sizeof(SShaderCBDependency), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pShader->SampDepCount * sizeof(SShaderSamplerDependency), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pShader->InterfaceDepCount * sizeof(SInterfaceDependency), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pShader->ResourceDepCount * sizeof(SShaderResourceDependency), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pShader->UAVDepCount * sizeof(SUnorderedAccessViewDependency), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pShader->TBufferDepCount * sizeof(SConstantBuffer*), c_DataAlignment);
+
+ for (size_t j=0; j<pShader->CBDepCount; j++)
+ {
+ SShaderCBDependency *pCBDeps = &pShader->pCBDeps[j];
+ dwSize += AlignToPowerOf2(pCBDeps->Count * sizeof(ID3D11Buffer*), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pCBDeps->Count * sizeof(SConstantBuffer*), c_DataAlignment);
+ }
+
+ for (size_t j=0; j<pShader->SampDepCount; j++)
+ {
+ SShaderSamplerDependency *pSampDeps = &pShader->pSampDeps[j];
+ dwSize += AlignToPowerOf2(pSampDeps->Count * sizeof(ID3D11SamplerState*), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pSampDeps->Count * sizeof(SSamplerBlock*), c_DataAlignment);
+ }
+
+ for (size_t j=0; j<pShader->InterfaceDepCount; j++)
+ {
+ SInterfaceDependency *pInterfaceDeps = &pShader->pInterfaceDeps[j];
+ dwSize += AlignToPowerOf2(pInterfaceDeps->Count * sizeof(ID3D11ClassInstance*), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pInterfaceDeps->Count * sizeof(SInterface*), c_DataAlignment);
+ }
+
+ for (size_t j=0; j<pShader->ResourceDepCount; j++)
+ {
+ SShaderResourceDependency *pResourceDeps = &pShader->pResourceDeps[j];
+ dwSize += AlignToPowerOf2(pResourceDeps->Count * sizeof(ID3D11ShaderResourceView*), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pResourceDeps->Count * sizeof(SShaderResource*), c_DataAlignment);
+ }
+
+ for (size_t j=0; j<pShader->UAVDepCount; j++)
+ {
+ SUnorderedAccessViewDependency *pUAVDeps = &pShader->pUAVDeps[j];
+ dwSize += AlignToPowerOf2(pUAVDeps->Count * sizeof(ID3D11UnorderedAccessView*), c_DataAlignment);
+ dwSize += AlignToPowerOf2(pUAVDeps->Count * sizeof(SUnorderedAccessView*), c_DataAlignment);
+ }
+ }
+
+ return dwSize;
+}
+
+// Move all (non-reflection) effect data to private heap
+#pragma warning(push)
+#pragma warning(disable: 4616 6239 )
+HRESULT CEffectLoader::ReallocateEffectData( bool Cloning )
+{
+ HRESULT hr = S_OK;
+ CEffectHeap *pHeap = &m_pEffect->m_Heap;
+ uint32_t cbCBs = sizeof(SConstantBuffer) * m_pEffect->m_CBCount;
+ uint32_t cbVariables = sizeof(SGlobalVariable) * m_pEffect->m_VariableCount;
+ uint32_t cbGroups = sizeof(STechnique) * m_pEffect->m_GroupCount;
+ uint32_t cbShaders = sizeof(SShaderBlock) * m_pEffect->m_ShaderBlockCount;
+ uint32_t cbDS = sizeof(SDepthStencilBlock) * m_pEffect->m_DepthStencilBlockCount;
+ uint32_t cbAB = sizeof(SBlendBlock) * m_pEffect->m_BlendBlockCount;
+ uint32_t cbRS = sizeof(SRasterizerBlock) * m_pEffect->m_RasterizerBlockCount;
+ uint32_t cbSamplers = sizeof(SSamplerBlock) * m_pEffect->m_SamplerBlockCount;
+ uint32_t cbMemberDatas = sizeof(SMemberDataPointer) * m_pEffect->m_MemberDataCount;
+ uint32_t cbInterfaces = sizeof(SInterface) * m_pEffect->m_InterfaceCount;
+ uint32_t cbBackgroundInterfaces = sizeof(SInterface) * m_BackgroundInterfaces.GetSize();
+ uint32_t cbShaderResources = sizeof(SShaderResource) * m_pEffect->m_ShaderResourceCount;
+ uint32_t cbUnorderedAccessViews = sizeof(SUnorderedAccessView) * m_pEffect->m_UnorderedAccessViewCount;
+ uint32_t cbRenderTargetViews = sizeof(SRenderTargetView) * m_pEffect->m_RenderTargetViewCount;
+ uint32_t cbDepthStencilViews = sizeof(SDepthStencilView) * m_pEffect->m_DepthStencilViewCount;
+ uint32_t cbAnonymousShaders = sizeof(SAnonymousShader) * m_pEffect->m_AnonymousShaderCount;
+
+ // Calculate memory needed
+ m_EffectMemory += AlignToPowerOf2(cbCBs, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbVariables, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbGroups, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbShaders, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbMemberDatas, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbInterfaces + cbBackgroundInterfaces, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbShaderResources, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbUnorderedAccessViews, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbRenderTargetViews, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbDepthStencilViews, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbDS, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbAB, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbRS, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbSamplers, c_DataAlignment);
+ m_EffectMemory += AlignToPowerOf2(cbAnonymousShaders, c_DataAlignment);
+
+ m_EffectMemory += CalculateShaderBlockSize();
+
+ for (size_t i=0; i<m_pEffect->m_CBCount; i++)
+ {
+ SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];
+
+ m_EffectMemory += AlignToPowerOf2(pCB->Size, c_DataAlignment);
+ }
+
+ for (size_t i=0; i<m_pEffect->m_GroupCount; i++)
+ {
+ SGroup *pGroup = &m_pEffect->m_pGroups[i];
+
+ m_EffectMemory += AlignToPowerOf2(pGroup->TechniqueCount * sizeof(STechnique), c_DataAlignment);
+
+ for (size_t j=0; j<pGroup->TechniqueCount; j++)
+ {
+ STechnique *pTech = &pGroup->pTechniques[j];
+
+ m_EffectMemory += AlignToPowerOf2(pTech->PassCount * sizeof(SPassBlock), c_DataAlignment);
+ m_EffectMemory += CalculateBlockAssignmentSize(pTech->pPasses, pTech->PassCount);
+ }
+ };
+
+ m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pBlendBlocks, m_pEffect->m_BlendBlockCount);
+ m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pDepthStencilBlocks, m_pEffect->m_DepthStencilBlockCount);
+ m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pRasterizerBlocks, m_pEffect->m_RasterizerBlockCount);
+ m_EffectMemory += CalculateBlockAssignmentSize(m_pEffect->m_pSamplerBlocks, m_pEffect->m_SamplerBlockCount);
+
+ // Reserve memory
+ VHD( pHeap->ReserveMemory(m_EffectMemory), "Internal loading error: cannot reserve effect memory." );
+
+ // Move DataMemberPointer blocks
+ m_pOldMemberDataBlocks = m_pEffect->m_pMemberDataBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pMemberDataBlocks, cbMemberDatas), "Internal loading error: cannot move member data blocks." );
+
+ // Move CBs
+ m_pOldCBs = m_pEffect->m_pCBs;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pCBs, cbCBs), "Internal loading error: cannot move CB count." );
+ for (size_t i=0; i<m_pEffect->m_CBCount; i++)
+ {
+ SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];
+
+ VHD( pHeap->MoveData((void**) &pCB->pBackingStore, pCB->Size), "Internal loading error: cannot move CB backing store." );
+
+ if( !Cloning )
+ {
+ // When creating the effect, MemberDataOffsetPlus4 is used, not pMemberData
+ if( pCB->MemberDataOffsetPlus4 )
+ {
+ pCB->pMemberData = (SMemberDataPointer*)( (uint8_t*)m_pEffect->m_pMemberDataBlocks + ( pCB->MemberDataOffsetPlus4 - 4 ) );
+ }
+ }
+ else if (pCB->pMemberData)
+ {
+ // When cloning an effect, pMemberData points to valid data in the original effect
+ VH( FixupMemberDataPointer( &pCB->pMemberData ) );
+ }
+ }
+
+ // Move numeric variables; move all variable types
+ m_pOldVars = m_pEffect->m_pVariables;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pVariables, cbVariables), "Internal loading error: cannot move variable count." );
+ for (size_t i=0; i<m_pEffect->m_VariableCount; i++)
+ {
+ SGlobalVariable *pVar = &m_pEffect->m_pVariables[i];
+ pVar->pEffect = m_pEffect;
+
+ if( Cloning && pVar->pType->BelongsInConstantBuffer())
+ {
+ // Convert pointer back to offset
+ // pVar->pCB refers to the old CB
+ pVar->Data.Offset = (UINT_PTR)pVar->Data.pGeneric - (UINT_PTR)pVar->pCB->pBackingStore;
+ }
+
+ if (pVar->pCB)
+ {
+ VH( FixupCBPointer( &pVar->pCB ) );
+ }
+
+ if( !Cloning )
+ {
+ // When creating the effect, MemberDataOffsetPlus4 is used, not pMemberData
+ if( pVar->MemberDataOffsetPlus4 )
+ {
+ pVar->pMemberData = (SMemberDataPointer*)( (uint8_t*)m_pEffect->m_pMemberDataBlocks + ( pVar->MemberDataOffsetPlus4 - 4 ) );
+ }
+ }
+ else if (pVar->pMemberData)
+ {
+ // When cloning an effect, pMemberData points to valid data in the original effect
+ VH( FixupMemberDataPointer( &pVar->pMemberData ) );
+ }
+
+ if (pVar->pType->BelongsInConstantBuffer())
+ {
+ // Convert from offsets to pointers
+ pVar->Data.pGeneric = pVar->pCB->pBackingStore + pVar->Data.Offset;
+ }
+ }
+
+ // Fixup each CB's array of child variable pointers
+ for (size_t i=0; i<m_pEffect->m_CBCount; i++)
+ {
+ SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];
+ pCB->pEffect = m_pEffect;
+
+ if (pCB->pVariables != nullptr)
+ {
+ VH( FixupVariablePointer(&pCB->pVariables) );
+ }
+ }
+
+ // Move shaders
+ m_pOldShaders = m_pEffect->m_pShaderBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pShaderBlocks, cbShaders), "Internal loading error: cannot move shader count." );
+
+ // Move interfaces, combining global interfaces and those that were created during shader initialization
+ m_pOldInterfaces = m_pEffect->m_pInterfaces;
+ m_OldInterfaceCount = m_pEffect->m_InterfaceCount;
+ VHD( pHeap->MoveEmptyDataBlock((void**) &m_pEffect->m_pInterfaces, cbInterfaces + cbBackgroundInterfaces), "Internal loading error: cannot move shader." );
+ memcpy( m_pEffect->m_pInterfaces, m_pOldInterfaces, cbInterfaces );
+ for( size_t i=0; i < m_BackgroundInterfaces.GetSize(); i++ )
+ {
+ assert( m_BackgroundInterfaces[i] != nullptr );
+ uint8_t* pDst = (uint8_t*)m_pEffect->m_pInterfaces + ( m_pEffect->m_InterfaceCount * sizeof(SInterface) );
+ memcpy( pDst, m_BackgroundInterfaces[i], sizeof(SInterface) );
+ m_pEffect->m_InterfaceCount++;
+ }
+
+ m_pOldShaderResources = m_pEffect->m_pShaderResources;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pShaderResources, cbShaderResources), "Internal loading error: cannot move SRVs." );
+
+ m_pOldUnorderedAccessViews = m_pEffect->m_pUnorderedAccessViews;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pUnorderedAccessViews, cbUnorderedAccessViews), "Internal loading error: cannot move UAVS." );
+
+ m_pOldRenderTargetViews = m_pEffect->m_pRenderTargetViews;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pRenderTargetViews, cbRenderTargetViews), "Internal loading error: cannot move RTVs." );
+
+ m_pOldDepthStencilViews = m_pEffect->m_pDepthStencilViews;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pDepthStencilViews, cbDepthStencilViews), "Internal loading error: cannot move DSVs." );
+
+ m_pOldDS = m_pEffect->m_pDepthStencilBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pDepthStencilBlocks, cbDS), "Internal loading error: cannot move depth-stencil state blocks." );
+ VH( ReallocateBlockAssignments(m_pEffect->m_pDepthStencilBlocks, m_pEffect->m_DepthStencilBlockCount, Cloning ? m_pOldDS : nullptr) );
+
+ m_pOldAB = m_pEffect->m_pBlendBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pBlendBlocks, cbAB), "Internal loading error: cannot move blend state blocks." );
+ VH( ReallocateBlockAssignments(m_pEffect->m_pBlendBlocks, m_pEffect->m_BlendBlockCount, Cloning ? m_pOldAB : nullptr) );
+
+ m_pOldRS = m_pEffect->m_pRasterizerBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pRasterizerBlocks, cbRS), "Internal loading error: cannot move rasterizer state blocks." );
+ VH( ReallocateBlockAssignments(m_pEffect->m_pRasterizerBlocks, m_pEffect->m_RasterizerBlockCount, Cloning ? m_pOldRS : nullptr) );
+
+ m_pOldSamplers = m_pEffect->m_pSamplerBlocks;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pSamplerBlocks, cbSamplers), "Internal loading error: cannot move samplers." );
+ VH( ReallocateBlockAssignments(m_pEffect->m_pSamplerBlocks, m_pEffect->m_SamplerBlockCount, Cloning ? m_pOldSamplers : nullptr) );
+
+ // Fixup sampler backing stores
+ for (size_t i=0; i<m_pEffect->m_SamplerBlockCount; ++i)
+ {
+ VH( FixupShaderResourcePointer(&m_pEffect->m_pSamplerBlocks[i].BackingStore.pTexture) );
+ }
+
+ // Fixup each interface's class instance variable pointer
+ for (size_t i=0; i<m_pEffect->m_InterfaceCount; i++)
+ {
+ SInterface *pInterface = &m_pEffect->m_pInterfaces[i];
+
+ if (pInterface->pClassInstance != nullptr)
+ {
+ VH( FixupVariablePointer( (SGlobalVariable**)&pInterface->pClassInstance ) );
+ }
+ }
+
+ // Fixup pointers for non-numeric variables
+ for (size_t i=0; i<m_pEffect->m_VariableCount; i++)
+ {
+ SGlobalVariable *pVar = &m_pEffect->m_pVariables[i];
+
+ if (pVar->pType->IsShader())
+ {
+ VH( FixupShaderPointer(&pVar->Data.pShader) );
+ }
+ else if (pVar->pType->IsShaderResource())
+ {
+ VH( FixupShaderResourcePointer(&pVar->Data.pShaderResource) );
+ }
+ else if (pVar->pType->IsUnorderedAccessView())
+ {
+ VH( FixupUnorderedAccessViewPointer(&pVar->Data.pUnorderedAccessView) );
+ }
+ else if (pVar->pType->IsInterface())
+ {
+ VH( FixupInterfacePointer(&pVar->Data.pInterface, false) );
+ }
+ else if (pVar->pType->IsObjectType(EOT_String))
+ {
+ if( !m_pEffect->IsOptimized() )
+ {
+ VH( FixupStringPointer(&pVar->Data.pString) );
+ }
+ }
+ else if (pVar->pType->IsStateBlockObject())
+ {
+ switch(pVar->pType->ObjectType)
+ {
+ case EOT_DepthStencil:
+ VH( FixupDSPointer((SDepthStencilBlock**) &pVar->Data.pBlock) );
+ break;
+ case EOT_Blend:
+ VH( FixupABPointer((SBlendBlock**) &pVar->Data.pBlock) );
+ break;
+ case EOT_Rasterizer:
+ VH( FixupRSPointer((SRasterizerBlock**) &pVar->Data.pBlock) );
+ break;
+ case EOT_Sampler:
+ VB(pVar->pType->IsSampler());
+ VH( FixupSamplerPointer((SSamplerBlock**) &pVar->Data.pBlock) );
+ break;
+ default:
+ VH( E_FAIL );
+ }
+ }
+ else if (pVar->pType->VarType == EVT_Struct || pVar->pType->VarType == EVT_Numeric)
+ {
+ if( pVar->pType->IsClassInstance() )
+ {
+ // do nothing
+ }
+ else
+ {
+ // do nothing
+ }
+ }
+ else if (pVar->pType->IsRenderTargetView())
+ {
+ VH( FixupRenderTargetViewPointer(&pVar->Data.pRenderTargetView) );
+ }
+ else if (pVar->pType->IsDepthStencilView())
+ {
+ VH( FixupDepthStencilViewPointer(&pVar->Data.pDepthStencilView) );
+ }
+ else
+ {
+ VHD( E_FAIL, "Internal loading error: Invalid variable type." );
+ }
+ }
+
+ // Fixup created members
+ for (size_t i = 0; i < m_pEffect->m_pMemberInterfaces.GetSize(); ++ i)
+ {
+ SMember* pMember = m_pEffect->m_pMemberInterfaces[i];
+ SGlobalVariable** ppTopLevelEntity = (SGlobalVariable**)&pMember->pTopLevelEntity;
+ VN( *ppTopLevelEntity );
+
+ // This might be set to false later, for supporting textures inside classes
+ const bool bGlobalMemberDataBlock = true;
+
+ if( Cloning )
+ {
+ if( pMember->pType->BelongsInConstantBuffer() )
+ {
+ assert( pMember->Data.pGeneric == nullptr || (*ppTopLevelEntity)->pEffect->m_Heap.IsInHeap(pMember->Data.pGeneric) );
+ pMember->Data.Offset = (uint32_t)( (uint8_t*)pMember->Data.pGeneric - (uint8_t*)(*ppTopLevelEntity)->pCB->pBackingStore );
+ }
+ if( bGlobalMemberDataBlock && pMember->pMemberData )
+ {
+ pMember->MemberDataOffsetPlus4 = (uint32_t)( (uint8_t*)pMember->pMemberData - (uint8_t*)(*ppTopLevelEntity)->pEffect->m_pMemberDataBlocks ) + 4;
+ }
+ }
+
+ VH( FixupVariablePointer( ppTopLevelEntity ) );
+
+ if (pMember->pType->BelongsInConstantBuffer())
+ {
+ // Convert from offsets to pointers
+ pMember->Data.pGeneric = (*ppTopLevelEntity)->pCB->pBackingStore + pMember->Data.Offset;
+ }
+ if( bGlobalMemberDataBlock && pMember->MemberDataOffsetPlus4 )
+ {
+ pMember->pMemberData = (SMemberDataPointer*)( (uint8_t*)m_pEffect->m_pMemberDataBlocks + ( pMember->MemberDataOffsetPlus4 - 4 ) );
+ }
+ }
+
+ // Fixup shader data
+ VH( ReallocateShaderBlocks() );
+
+ // Move groups, techniques, and passes
+ m_pOldGroups = m_pEffect->m_pGroups;
+ VHD( pHeap->MoveData((void**) &m_pEffect->m_pGroups, cbGroups), "Internal loading error: cannot move groups." );
+ for (size_t i=0; i<m_pEffect->m_GroupCount; i++)
+ {
+ SGroup *pGroup = &m_pEffect->m_pGroups[i];
+ uint32_t cbTechniques;
+
+ cbTechniques = pGroup->TechniqueCount * sizeof(STechnique);
+ VHD( pHeap->MoveData((void**) &pGroup->pTechniques, cbTechniques), "Internal loading error: cannot move techniques." );
+
+ for (size_t j=0; j<pGroup->TechniqueCount; j++)
+ {
+ STechnique *pTech = &pGroup->pTechniques[j];
+ uint32_t cbPass;
+
+ cbPass = pTech->PassCount * sizeof(SPassBlock);
+ SPassBlock* pOldPasses = Cloning ? pTech->pPasses : nullptr;
+ VHD( pHeap->MoveData((void**) &pTech->pPasses, cbPass), "Internal loading error: cannot move passes." );
+
+ for (size_t iPass = 0; iPass < pTech->PassCount; ++ iPass)
+ {
+ pTech->pPasses[iPass].pEffect = m_pEffect;
+
+ // Fixup backing store pointers in passes
+ VH( FixupABPointer((SBlendBlock**) &pTech->pPasses[iPass].BackingStore.pBlendBlock) );
+ VH( FixupDSPointer((SDepthStencilBlock**) &pTech->pPasses[iPass].BackingStore.pDepthStencilBlock) );
+ VH( FixupRSPointer((SRasterizerBlock**) &pTech->pPasses[iPass].BackingStore.pRasterizerBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pVertexShaderBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pPixelShaderBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pGeometryShaderBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pHullShaderBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pDomainShaderBlock) );
+ VH( FixupShaderPointer((SShaderBlock**) &pTech->pPasses[iPass].BackingStore.pComputeShaderBlock) );
+ VH( FixupDepthStencilViewPointer( &pTech->pPasses[iPass].BackingStore.pDepthStencilView) );
+ for (size_t iRT = 0; iRT < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; iRT++)
+ {
+ VH( FixupRenderTargetViewPointer( &pTech->pPasses[iPass].BackingStore.pRenderTargetViews[iRT] ) );
+ }
+ }
+
+ VH( ReallocateBlockAssignments( pTech->pPasses, pTech->PassCount, pOldPasses ) );
+ }
+ }
+ VH( FixupGroupPointer( &m_pEffect->m_pNullGroup ) );
+
+ // Move anonymous shader variables
+ VHD( pHeap->MoveData((void **) &m_pEffect->m_pAnonymousShaders, cbAnonymousShaders), "Internal loading error: cannot move anonymous shaders." );
+ for (size_t i=0; i<m_pEffect->m_AnonymousShaderCount; ++i)
+ {
+ SAnonymousShader *pAnonymousShader = m_pEffect->m_pAnonymousShaders + i;
+ VH( FixupShaderPointer((SShaderBlock**) &pAnonymousShader->pShaderBlock) );
+ }
+
+ VBD( pHeap->GetSize() == m_EffectMemory, "Loading error: effect size mismatch." );
+
+lExit:
+ return hr;
+}
+#pragma warning(pop)
+
+}
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectLoad.h
+//
+// Direct3D 11 Effects header for the FX file loader
+// A CEffectLoader is created at load time to facilitate loading
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+namespace D3DX11Effects
+{
+
+// Ranges are used for dependency checking during load
+
+enum ERanges
+{
+ ER_CBuffer = 0,
+ ER_Texture, // Includes TBuffers
+ ER_Sampler,
+ ER_UnorderedAccessView,
+ ER_Interfaces,
+ ER_Count // This should be the size of the enum
+};
+
+struct SRange
+{
+ uint32_t start;
+ uint32_t last;
+ CEffectVector<void *> vResources; // should be (last - start) in length, resource type depends on the range type
+};
+
+// Used during load to validate assignments
+D3D_SHADER_VARIABLE_TYPE GetSimpleParameterTypeFromObjectType(EObjectType ObjectType);
+
+
+// A class to facilitate loading an Effect. This class is a friend of CEffect.
+class CEffectLoader
+{
+ friend HRESULT CEffect::CloneEffect(_In_ uint32_t Flags, _Outptr_ ID3DX11Effect** ppClonedEffect );
+
+protected:
+ // Load-time allocations that eventually get moved happen out of the TempHeap. This heap will grow as needed
+ CDataBlockStore m_BulkHeap;
+
+ uint8_t *m_pData;
+ SBinaryHeader5 *m_pHeader;
+ DWORD m_Version;
+
+ CEffect *m_pEffect;
+ CEffectReflection *m_pReflection;
+
+ D3DX11Core::CMemoryStream m_msStructured;
+ D3DX11Core::CMemoryStream m_msUnstructured;
+
+ // used to avoid repeated hash buffer allocations in LoadTypeAndAddToPool
+ CEffectVector<uint8_t> m_HashBuffer;
+
+ uint32_t m_dwBufferSize; // Size of data buffer in bytes
+
+ // List of SInterface blocks created to back class instances bound to shaders
+ CEffectVector<SInterface*> m_BackgroundInterfaces;
+
+ // Pointers to pre-reallocation data
+ SGlobalVariable *m_pOldVars;
+ SShaderBlock *m_pOldShaders;
+ SDepthStencilBlock *m_pOldDS;
+ SBlendBlock *m_pOldAB;
+ SRasterizerBlock *m_pOldRS;
+ SConstantBuffer *m_pOldCBs;
+ SSamplerBlock *m_pOldSamplers;
+ uint32_t m_OldInterfaceCount;
+ SInterface *m_pOldInterfaces;
+ SShaderResource *m_pOldShaderResources;
+ SUnorderedAccessView *m_pOldUnorderedAccessViews;
+ SRenderTargetView *m_pOldRenderTargetViews;
+ SDepthStencilView *m_pOldDepthStencilViews;
+ SString *m_pOldStrings;
+ SMemberDataPointer *m_pOldMemberDataBlocks;
+ CEffectVectorOwner<SMember> *m_pvOldMemberInterfaces;
+ SGroup *m_pOldGroups;
+
+ uint32_t m_EffectMemory; // Effect private heap
+ uint32_t m_ReflectionMemory; // Reflection private heap
+
+ // Loader helpers
+ HRESULT LoadCBs();
+ HRESULT LoadNumericVariable(_In_ SConstantBuffer *pParentCB);
+ HRESULT LoadObjectVariables();
+ HRESULT LoadInterfaceVariables();
+
+ HRESULT LoadTypeAndAddToPool(_Outptr_ SType **ppType, _In_ uint32_t dwOffset);
+ HRESULT LoadStringAndAddToPool(_Outptr_result_maybenull_z_ char **ppString, _In_ uint32_t dwOffset);
+ HRESULT LoadAssignments( _In_ uint32_t Assignments, _Out_writes_(Assignments) SAssignment **pAssignments,
+ _In_ uint8_t *pBackingStore, _Out_opt_ uint32_t *pRTVAssignments, _Out_opt_ uint32_t *pFinalAssignments );
+ HRESULT LoadGroups();
+ HRESULT LoadTechnique( STechnique* pTech );
+ HRESULT LoadAnnotations(uint32_t *pcAnnotations, SAnnotation **ppAnnotations);
+
+ HRESULT ExecuteConstantAssignment(_In_ const SBinaryConstant *pConstant, _Out_writes_bytes_(4) void *pLHS, _In_ D3D_SHADER_VARIABLE_TYPE lhsType);
+ uint32_t UnpackData(uint8_t *pDestData, uint8_t *pSrcData, uint32_t PackedDataSize, SType *pType, uint32_t *pBytesRead);
+
+ // Build shader blocks
+ HRESULT ConvertRangesToBindings(SShaderBlock *pShaderBlock, CEffectVector<SRange> *pvRanges );
+ HRESULT GrabShaderData(SShaderBlock *pShaderBlock);
+ HRESULT BuildShaderBlock(SShaderBlock *pShaderBlock);
+
+ // Memory compactors
+ HRESULT InitializeReflectionDataAndMoveStrings( uint32_t KnownSize = 0 );
+ HRESULT ReallocateReflectionData( bool Cloning = false );
+ HRESULT ReallocateEffectData( bool Cloning = false );
+ HRESULT ReallocateShaderBlocks();
+ template<class T> HRESULT ReallocateBlockAssignments(T* &pBlocks, uint32_t cBlocks, T* pOldBlocks = nullptr);
+ HRESULT ReallocateAnnotationData(uint32_t cAnnotations, SAnnotation **ppAnnotations);
+
+ HRESULT CalculateAnnotationSize(uint32_t cAnnotations, SAnnotation *pAnnotations);
+ uint32_t CalculateShaderBlockSize();
+ template<class T> uint32_t CalculateBlockAssignmentSize(T* &pBlocks, uint32_t cBlocks);
+
+ HRESULT FixupCBPointer(_Inout_ SConstantBuffer **ppCB);
+ HRESULT FixupShaderPointer(_Inout_ SShaderBlock **ppShaderBlock);
+ HRESULT FixupDSPointer(_Inout_ SDepthStencilBlock **ppDSBlock);
+ HRESULT FixupABPointer(_Inout_ SBlendBlock **ppABBlock);
+ HRESULT FixupRSPointer(_Inout_ SRasterizerBlock **ppRSBlock);
+ HRESULT FixupInterfacePointer(_Inout_ SInterface **ppInterface, _In_ bool CheckBackgroundInterfaces);
+ HRESULT FixupShaderResourcePointer(_Inout_ SShaderResource **ppResource);
+ HRESULT FixupUnorderedAccessViewPointer(_Inout_ SUnorderedAccessView **ppResource);
+ HRESULT FixupRenderTargetViewPointer(_Inout_ SRenderTargetView **ppRenderTargetView);
+ HRESULT FixupDepthStencilViewPointer(_Inout_ SDepthStencilView **ppDepthStencilView);
+ HRESULT FixupSamplerPointer(_Inout_ SSamplerBlock **ppSampler);
+ HRESULT FixupVariablePointer(_Inout_ SGlobalVariable **ppVar);
+ HRESULT FixupStringPointer(_Inout_ SString **ppString);
+ HRESULT FixupMemberDataPointer(_Inout_ SMemberDataPointer **ppMemberData);
+ HRESULT FixupGroupPointer(_Inout_ SGroup **ppGroup);
+
+ // Methods to retrieve data from the unstructured block
+ // (these do not make copies; they simply return pointers into the block)
+ HRESULT GetStringAndAddToReflection(_In_ uint32_t offset, _Outptr_result_maybenull_z_ char **ppPointer); // Returns a string from the file string block, updates m_EffectMemory
+ HRESULT GetUnstructuredDataBlock(_In_ uint32_t offset, _Out_ uint32_t *pdwSize, _Outptr_result_buffer_(*pdwSize) void **ppData);
+ // This function makes a copy of the array of SInterfaceParameters, but not a copy of the strings
+ HRESULT GetInterfaceParametersAndAddToReflection( _In_ uint32_t InterfaceCount, _In_ uint32_t offset, _Outptr_result_buffer_all_maybenull_(InterfaceCount) SShaderBlock::SInterfaceParameter **ppInterfaces );
+public:
+
+ HRESULT LoadEffect(_In_ CEffect *pEffect, _In_reads_bytes_(cbEffectBuffer) const void *pEffectBuffer, _In_ uint32_t cbEffectBuffer);
+};
+
+
+}
\ No newline at end of file
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectNonRuntime.cpp
+//
+// D3DX11 Effect low-frequency utility functions
+// These functions are not intended to be called regularly. They
+// are typically called when creating, cloning, or optimizing an
+// Effect, or reflecting a variable.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+#include "SOParser.h"
+
+namespace D3DX11Effects
+{
+
+extern SUnorderedAccessView g_NullUnorderedAccessView;
+
+SBaseBlock::SBaseBlock()
+: BlockType(EBT_Invalid)
+, IsUserManaged(false)
+, AssignmentCount(0)
+, pAssignments(nullptr)
+{
+
+}
+
+SPassBlock::SPassBlock()
+{
+ pName = nullptr;
+ AnnotationCount = 0;
+ pAnnotations = nullptr;
+ InitiallyValid = true;
+ HasDependencies = false;
+ ZeroMemory(&BackingStore, sizeof(BackingStore));
+}
+
+STechnique::STechnique()
+: pName(nullptr)
+, PassCount(0)
+, pPasses(nullptr)
+, AnnotationCount(0)
+, pAnnotations(nullptr)
+, InitiallyValid( true )
+, HasDependencies( false )
+{
+}
+
+SGroup::SGroup()
+: pName(nullptr)
+, TechniqueCount(0)
+, pTechniques(nullptr)
+, AnnotationCount(0)
+, pAnnotations(nullptr)
+, InitiallyValid( true )
+, HasDependencies( false )
+{
+}
+
+SDepthStencilBlock::SDepthStencilBlock()
+{
+ pDSObject = nullptr;
+ ZeroMemory(&BackingStore, sizeof(BackingStore));
+ IsValid = true;
+
+ BackingStore.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
+ BackingStore.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.DepthEnable = true;
+ BackingStore.DepthFunc = D3D11_COMPARISON_LESS;
+ BackingStore.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
+ BackingStore.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
+ BackingStore.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
+ BackingStore.StencilEnable = false;
+ BackingStore.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
+ BackingStore.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
+}
+
+SBlendBlock::SBlendBlock()
+{
+ pBlendObject = nullptr;
+ ZeroMemory(&BackingStore, sizeof(BackingStore));
+ IsValid = true;
+
+ BackingStore.AlphaToCoverageEnable = false;
+ BackingStore.IndependentBlendEnable = true;
+ for( size_t i=0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++ )
+ {
+ BackingStore.RenderTarget[i].SrcBlend = D3D11_BLEND_ONE;
+ BackingStore.RenderTarget[i].DestBlend = D3D11_BLEND_ZERO;
+ BackingStore.RenderTarget[i].BlendOp = D3D11_BLEND_OP_ADD;
+ BackingStore.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE;
+ BackingStore.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ZERO;
+ BackingStore.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_ADD;
+ memset(&BackingStore.RenderTarget[i].RenderTargetWriteMask, 0x0F, sizeof(BackingStore.RenderTarget[i].RenderTargetWriteMask));
+ }
+}
+
+SRasterizerBlock::SRasterizerBlock()
+{
+ pRasterizerObject = nullptr;
+ ZeroMemory(&BackingStore, sizeof(BackingStore));
+ IsValid = true;
+
+ BackingStore.AntialiasedLineEnable = false;
+ BackingStore.CullMode = D3D11_CULL_BACK;
+ BackingStore.DepthBias = D3D11_DEFAULT_DEPTH_BIAS;
+ BackingStore.DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP;
+ BackingStore.FillMode = D3D11_FILL_SOLID;
+ BackingStore.FrontCounterClockwise = false;
+ BackingStore.MultisampleEnable = false;
+ BackingStore.ScissorEnable = false;
+ BackingStore.SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
+ BackingStore.DepthClipEnable = true;
+}
+
+SSamplerBlock::SSamplerBlock()
+{
+ pD3DObject = nullptr;
+ ZeroMemory(&BackingStore, sizeof(BackingStore));
+
+ BackingStore.SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
+ BackingStore.SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
+ BackingStore.SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+ BackingStore.SamplerDesc.BorderColor[3] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;
+ BackingStore.SamplerDesc.BorderColor[2] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;
+ BackingStore.SamplerDesc.BorderColor[1] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;
+ BackingStore.SamplerDesc.BorderColor[0] = D3D11_DEFAULT_BORDER_COLOR_COMPONENT;
+ BackingStore.SamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+ BackingStore.SamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+ BackingStore.SamplerDesc.MaxAnisotropy = (UINT32) D3D11_DEFAULT_MAX_ANISOTROPY;
+ BackingStore.SamplerDesc.MipLODBias = D3D11_DEFAULT_MIP_LOD_BIAS;
+ BackingStore.SamplerDesc.MinLOD = -FLT_MAX;
+ BackingStore.SamplerDesc.MaxLOD = FLT_MAX;
+}
+
+SShaderBlock::SShaderBlock(SD3DShaderVTable *pVirtualTable)
+{
+ IsValid = true;
+
+ pVT = pVirtualTable;
+
+ pReflectionData = nullptr;
+
+ pD3DObject = nullptr;
+
+ CBDepCount = 0;
+ pCBDeps = nullptr;
+
+ SampDepCount = 0;
+ pSampDeps = nullptr;
+
+ InterfaceDepCount = 0;
+ pInterfaceDeps = nullptr;
+
+ ResourceDepCount = 0;
+ pResourceDeps = nullptr;
+
+ UAVDepCount = 0;
+ pUAVDeps = nullptr;
+
+ TBufferDepCount = 0;
+ ppTbufDeps = nullptr;
+
+ pInputSignatureBlob = nullptr;
+}
+
+HRESULT SShaderBlock::OnDeviceBind()
+{
+ HRESULT hr = S_OK;
+ uint32_t i, j;
+
+ // Update all CB deps
+ for (i=0; i<CBDepCount; i++)
+ {
+ assert(pCBDeps[i].Count);
+
+ for (j=0; j<pCBDeps[i].Count; j++)
+ {
+ pCBDeps[i].ppD3DObjects[j] = pCBDeps[i].ppFXPointers[j]->pD3DObject;
+
+ if ( !pCBDeps[i].ppD3DObjects[j] )
+ VH( E_FAIL );
+ }
+ }
+
+ // Update all sampler deps
+ for (i=0; i<SampDepCount; i++)
+ {
+ assert(pSampDeps[i].Count);
+
+ for (j=0; j<pSampDeps[i].Count; j++)
+ {
+ pSampDeps[i].ppD3DObjects[j] = pSampDeps[i].ppFXPointers[j]->pD3DObject;
+
+ if ( !pSampDeps[i].ppD3DObjects[j] )
+ VH( E_FAIL );
+ }
+ }
+
+ // Texture deps will be set automatically on use since they are initially marked dirty.
+
+lExit:
+ return hr;
+}
+
+extern SD3DShaderVTable g_vtVS;
+extern SD3DShaderVTable g_vtGS;
+extern SD3DShaderVTable g_vtPS;
+extern SD3DShaderVTable g_vtHS;
+extern SD3DShaderVTable g_vtDS;
+extern SD3DShaderVTable g_vtCS;
+
+EObjectType SShaderBlock::GetShaderType()
+{
+ if (&g_vtVS == pVT)
+ return EOT_VertexShader;
+ else if (&g_vtGS == pVT)
+ return EOT_GeometryShader;
+ else if (&g_vtPS == pVT)
+ return EOT_PixelShader;
+ else if (&g_vtHS == pVT)
+ return EOT_HullShader5;
+ else if (&g_vtDS == pVT)
+ return EOT_DomainShader5;
+ else if (&g_vtCS == pVT)
+ return EOT_ComputeShader5;
+
+ return EOT_Invalid;
+}
+
+#define _SET_BIT(bytes, x) (bytes[x / 8] |= (1 << (x % 8)))
+
+HRESULT SShaderBlock::ComputeStateBlockMask(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
+{
+ HRESULT hr = S_OK;
+ uint32_t i, j;
+ uint8_t *pSamplerMask = nullptr, *pShaderResourceMask = nullptr, *pConstantBufferMask = nullptr, *pUnorderedAccessViewMask = nullptr, *pInterfaceMask = nullptr;
+
+ switch (GetShaderType())
+ {
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ pStateBlockMask->VS = 1;
+ pSamplerMask = pStateBlockMask->VSSamplers;
+ pShaderResourceMask = pStateBlockMask->VSShaderResources;
+ pConstantBufferMask = pStateBlockMask->VSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->VSInterfaces;
+ pUnorderedAccessViewMask = nullptr;
+ break;
+
+ case EOT_GeometryShader:
+ case EOT_GeometryShader5:
+ pStateBlockMask->GS = 1;
+ pSamplerMask = pStateBlockMask->GSSamplers;
+ pShaderResourceMask = pStateBlockMask->GSShaderResources;
+ pConstantBufferMask = pStateBlockMask->GSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->GSInterfaces;
+ pUnorderedAccessViewMask = nullptr;
+ break;
+
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ pStateBlockMask->PS = 1;
+ pSamplerMask = pStateBlockMask->PSSamplers;
+ pShaderResourceMask = pStateBlockMask->PSShaderResources;
+ pConstantBufferMask = pStateBlockMask->PSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->PSInterfaces;
+ pUnorderedAccessViewMask = &pStateBlockMask->PSUnorderedAccessViews;
+ break;
+
+ case EOT_HullShader5:
+ pStateBlockMask->HS = 1;
+ pSamplerMask = pStateBlockMask->HSSamplers;
+ pShaderResourceMask = pStateBlockMask->HSShaderResources;
+ pConstantBufferMask = pStateBlockMask->HSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->HSInterfaces;
+ pUnorderedAccessViewMask = nullptr;
+ break;
+
+ case EOT_DomainShader5:
+ pStateBlockMask->DS = 1;
+ pSamplerMask = pStateBlockMask->DSSamplers;
+ pShaderResourceMask = pStateBlockMask->DSShaderResources;
+ pConstantBufferMask = pStateBlockMask->DSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->DSInterfaces;
+ pUnorderedAccessViewMask = nullptr;
+ break;
+
+ case EOT_ComputeShader5:
+ pStateBlockMask->CS = 1;
+ pSamplerMask = pStateBlockMask->CSSamplers;
+ pShaderResourceMask = pStateBlockMask->CSShaderResources;
+ pConstantBufferMask = pStateBlockMask->CSConstantBuffers;
+ pInterfaceMask = pStateBlockMask->CSInterfaces;
+ pUnorderedAccessViewMask = &pStateBlockMask->CSUnorderedAccessViews;
+ break;
+
+ default:
+ assert(0);
+ VH(E_FAIL);
+ }
+
+ for (i = 0; i < SampDepCount; ++ i)
+ {
+ for (j = 0; j < pSampDeps[i].Count; ++ j)
+ {
+ _SET_BIT(pSamplerMask, (pSampDeps[i].StartIndex + j));
+ }
+ }
+
+ for (i = 0; i < InterfaceDepCount; ++ i)
+ {
+ for (j = 0; j < pInterfaceDeps[i].Count; ++ j)
+ {
+ _SET_BIT(pInterfaceMask, (pInterfaceDeps[i].StartIndex + j));
+ }
+ }
+
+ for (i = 0; i < ResourceDepCount; ++ i)
+ {
+ for (j = 0; j < pResourceDeps[i].Count; ++ j)
+ {
+ _SET_BIT(pShaderResourceMask, (pResourceDeps[i].StartIndex + j));
+ }
+ }
+
+ for (i = 0; i < CBDepCount; ++ i)
+ {
+ for (j = 0; j < pCBDeps[i].Count; ++ j)
+ {
+ _SET_BIT(pConstantBufferMask, (pCBDeps[i].StartIndex + j));
+ }
+ }
+
+ for (i = 0; i < UAVDepCount; ++ i)
+ {
+ assert( pUnorderedAccessViewMask != 0 );
+ _Analysis_assume_( pUnorderedAccessViewMask != 0 );
+ for (j = 0; j < pUAVDeps[i].Count; ++ j)
+ {
+ if( pUAVDeps[i].ppFXPointers[j] != &g_NullUnorderedAccessView )
+ _SET_BIT(pUnorderedAccessViewMask, (pUAVDeps[i].StartIndex + j));
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+#undef _SET_BIT
+
+HRESULT SShaderBlock::GetShaderDesc(_Out_ D3DX11_EFFECT_SHADER_DESC *pDesc, _In_ bool IsInline)
+{
+ HRESULT hr = S_OK;
+
+ ZeroMemory(pDesc, sizeof(*pDesc));
+
+ pDesc->pInputSignature = pInputSignatureBlob ? (const uint8_t*)pInputSignatureBlob->GetBufferPointer() : nullptr;
+ pDesc->IsInline = IsInline;
+
+ if (nullptr != pReflectionData)
+ {
+ // initialize these only if present; otherwise leave them nullptr or 0
+ pDesc->pBytecode = pReflectionData->pBytecode;
+ pDesc->BytecodeLength = pReflectionData->BytecodeLength;
+ for( size_t iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
+ {
+ pDesc->SODecls[iDecl] = pReflectionData->pStreamOutDecls[iDecl];
+ }
+ pDesc->RasterizedStream = pReflectionData->RasterizedStream;
+
+ // get # of input & output signature entries
+ assert( pReflectionData->pReflection != 0 );
+ _Analysis_assume_( pReflectionData->pReflection != 0 );
+
+ D3D11_SHADER_DESC ShaderDesc;
+ hr = pReflectionData->pReflection->GetDesc( &ShaderDesc );
+ if ( SUCCEEDED(hr) )
+ {
+ pDesc->NumInputSignatureEntries = ShaderDesc.InputParameters;
+ pDesc->NumOutputSignatureEntries = ShaderDesc.OutputParameters;
+ pDesc->NumPatchConstantSignatureEntries = ShaderDesc.PatchConstantParameters;
+ }
+ }
+lExit:
+ return hr;
+}
+
+HRESULT SShaderBlock::GetVertexShader(_Outptr_ ID3D11VertexShader **ppVS)
+{
+ if (EOT_VertexShader == GetShaderType() ||
+ EOT_VertexShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppVS = static_cast<ID3D11VertexShader *>( pD3DObject );
+ SAFE_ADDREF(*ppVS);
+ return S_OK;
+ }
+ else
+ {
+ *ppVS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetVertexShader: This shader variable is not a vertex shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+HRESULT SShaderBlock::GetGeometryShader(_Outptr_ ID3D11GeometryShader **ppGS)
+{
+ if (EOT_GeometryShader == GetShaderType() ||
+ EOT_GeometryShaderSO == GetShaderType() ||
+ EOT_GeometryShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppGS = static_cast<ID3D11GeometryShader *>( pD3DObject );
+ SAFE_ADDREF(*ppGS);
+ return S_OK;
+ }
+ else
+ {
+ *ppGS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetGeometryShader: This shader variable is not a geometry shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+HRESULT SShaderBlock::GetPixelShader(_Outptr_ ID3D11PixelShader **ppPS)
+{
+ if (EOT_PixelShader == GetShaderType() ||
+ EOT_PixelShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppPS = static_cast<ID3D11PixelShader *>( pD3DObject );
+ SAFE_ADDREF(*ppPS);
+ return S_OK;
+ }
+ else
+ {
+ *ppPS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetPixelShader: This shader variable is not a pixel shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+HRESULT SShaderBlock::GetHullShader(_Outptr_ ID3D11HullShader **ppHS)
+{
+ if (EOT_HullShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppHS = static_cast<ID3D11HullShader *>( pD3DObject );
+ SAFE_ADDREF(*ppHS);
+ return S_OK;
+ }
+ else
+ {
+ *ppHS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetHullShader: This shader variable is not a hull shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+HRESULT SShaderBlock::GetDomainShader(_Outptr_ ID3D11DomainShader **ppDS)
+{
+ if (EOT_DomainShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppDS = static_cast<ID3D11DomainShader *>( pD3DObject );
+ SAFE_ADDREF(*ppDS);
+ return S_OK;
+ }
+ else
+ {
+ *ppDS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetDomainShader: This shader variable is not a domain shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+HRESULT SShaderBlock::GetComputeShader(_Outptr_ ID3D11ComputeShader **ppCS)
+{
+ if (EOT_ComputeShader5 == GetShaderType())
+ {
+ assert( pD3DObject != 0 );
+ _Analysis_assume_( pD3DObject != 0 );
+ *ppCS = static_cast<ID3D11ComputeShader *>( pD3DObject );
+ SAFE_ADDREF(*ppCS);
+ return S_OK;
+ }
+ else
+ {
+ *ppCS = nullptr;
+ DPF(0, "ID3DX11EffectShaderVariable::GetComputeShader: This shader variable is not a compute shader");
+ return D3DERR_INVALIDCALL;
+ }
+}
+
+_Use_decl_annotations_
+HRESULT SShaderBlock::GetSignatureElementDesc(ESigType SigType, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+ LPCSTR pFuncName = nullptr;
+ switch( SigType )
+ {
+ case ST_Input:
+ pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
+ break;
+ case ST_Output:
+ pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
+ break;
+ case ST_PatchConstant:
+ pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
+ break;
+ default:
+ assert( false );
+ return E_FAIL;
+ };
+
+ if (nullptr != pReflectionData)
+ {
+ // get # of signature entries
+ assert( pReflectionData->pReflection != 0 );
+ _Analysis_assume_( pReflectionData->pReflection != 0 );
+
+ D3D11_SHADER_DESC ShaderDesc;
+ VH( pReflectionData->pReflection->GetDesc( &ShaderDesc ) );
+
+ D3D11_SIGNATURE_PARAMETER_DESC ParamDesc ={0};
+ if( pReflectionData->IsNullGS )
+ {
+ switch( SigType )
+ {
+ case ST_Input:
+ // The input signature for a null-GS is the output signature of the previous VS
+ SigType = ST_Output;
+ break;
+ case ST_PatchConstant:
+ // GeometryShaders cannot have patch constant signatures
+ return E_INVALIDARG;
+ };
+ }
+
+ switch( SigType )
+ {
+ case ST_Input:
+ if( Element >= ShaderDesc.InputParameters )
+ {
+ DPF( 0, "%s: Invalid Element index (%u) specified", pFuncName, Element );
+ VH( E_INVALIDARG );
+ }
+ VH( pReflectionData->pReflection->GetInputParameterDesc( Element, &ParamDesc ) );
+ break;
+ case ST_Output:
+ if( Element >= ShaderDesc.OutputParameters )
+ {
+ DPF( 0, "%s: Invalid Element index (%u) specified", pFuncName, Element );
+ VH( E_INVALIDARG );
+ }
+ VH( pReflectionData->pReflection->GetOutputParameterDesc( Element, &ParamDesc ) );
+ break;
+ case ST_PatchConstant:
+ if( Element >= ShaderDesc.PatchConstantParameters )
+ {
+ DPF( 0, "%s: Invalid Element index (%u) specified", pFuncName, Element );
+ VH( E_INVALIDARG );
+ }
+ VH( pReflectionData->pReflection->GetPatchConstantParameterDesc( Element, &ParamDesc ) );
+ break;
+ };
+
+ pDesc->SemanticName = ParamDesc.SemanticName;
+ pDesc->SystemValueType = ParamDesc.SystemValueType;
+
+ // Pixel shaders need to be special-cased as they don't technically output SVs
+ if( pDesc->SystemValueType == D3D_NAME_UNDEFINED && GetShaderType() == EOT_PixelShader && pDesc->SemanticName != 0 )
+ {
+ if( _stricmp(pDesc->SemanticName, "SV_TARGET") == 0 )
+ {
+ pDesc->SystemValueType = D3D_NAME_TARGET;
+ }
+ else if( _stricmp(pDesc->SemanticName, "SV_DEPTH") == 0 )
+ {
+ pDesc->SystemValueType = D3D_NAME_DEPTH;
+ }
+ else if( _stricmp(pDesc->SemanticName, "SV_COVERAGE") == 0 )
+ {
+ pDesc->SystemValueType = D3D_NAME_COVERAGE;
+ }
+ }
+
+ pDesc->SemanticIndex = ParamDesc.SemanticIndex;
+ pDesc->Register = ParamDesc.Register;
+ pDesc->Mask = ParamDesc.Mask;
+ pDesc->ComponentType = ParamDesc.ComponentType;
+ pDesc->ReadWriteMask = ParamDesc.ReadWriteMask;
+ }
+ else
+ {
+ DPF(0, "%s: Cannot get signatures; shader bytecode is not present", pFuncName);
+ VH( D3DERR_INVALIDCALL );
+ }
+
+lExit:
+ return hr;
+}
+
+SString::SString()
+{
+ pString = nullptr;
+}
+
+SRenderTargetView::SRenderTargetView()
+{
+ pRenderTargetView = nullptr;
+}
+
+SDepthStencilView::SDepthStencilView()
+{
+ pDepthStencilView = nullptr;
+}
+
+void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, uint32_t Index)
+{
+ switch( VarType )
+ {
+ case EVT_Interface:
+ return (SInterface *)pBaseBlock + Index;
+ case EVT_Object:
+ switch (ObjectType)
+ {
+ case EOT_Blend:
+ return (SBlendBlock *)pBaseBlock + Index;
+ case EOT_DepthStencil:
+ return (SDepthStencilBlock *)pBaseBlock + Index;
+ case EOT_Rasterizer:
+ return (SRasterizerBlock *)pBaseBlock + Index;
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ case EOT_GeometryShader:
+ case EOT_GeometryShaderSO:
+ case EOT_GeometryShader5:
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ case EOT_HullShader5:
+ case EOT_DomainShader5:
+ case EOT_ComputeShader5:
+ return (SShaderBlock *)pBaseBlock + Index;
+ case EOT_String:
+ return (SString *)pBaseBlock + Index;
+ case EOT_Sampler:
+ return (SSamplerBlock *)pBaseBlock + Index;
+ case EOT_Buffer:
+ case EOT_Texture:
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ case EOT_Texture3D:
+ case EOT_TextureCube:
+ case EOT_TextureCubeArray:
+ case EOT_ByteAddressBuffer:
+ case EOT_StructuredBuffer:
+ return (SShaderResource *)pBaseBlock + Index;
+ case EOT_DepthStencilView:
+ return (SDepthStencilView *)pBaseBlock + Index;
+ case EOT_RenderTargetView:
+ return (SRenderTargetView *)pBaseBlock + Index;
+ case EOT_RWTexture1D:
+ case EOT_RWTexture1DArray:
+ case EOT_RWTexture2D:
+ case EOT_RWTexture2DArray:
+ case EOT_RWTexture3D:
+ case EOT_RWBuffer:
+ case EOT_RWByteAddressBuffer:
+ case EOT_RWStructuredBuffer:
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ case EOT_AppendStructuredBuffer:
+ case EOT_ConsumeStructuredBuffer:
+ return (SUnorderedAccessView *)pBaseBlock + Index;
+ default:
+ assert(0);
+ return nullptr;
+ }
+ default:
+ assert(0);
+ return nullptr;
+ }
+}
+
+//--------------------------------------------------------------------------------------
+// CEffect
+//--------------------------------------------------------------------------------------
+
+CEffect::CEffect( uint32_t Flags )
+{
+ m_RefCount = 1;
+
+ m_pVariables = nullptr;
+ m_pAnonymousShaders = nullptr;
+ m_pGroups = nullptr;
+ m_pNullGroup = nullptr;
+ m_pShaderBlocks = nullptr;
+ m_pDepthStencilBlocks = nullptr;
+ m_pBlendBlocks = nullptr;
+ m_pRasterizerBlocks = nullptr;
+ m_pSamplerBlocks = nullptr;
+ m_pCBs = nullptr;
+ m_pStrings = nullptr;
+ m_pMemberDataBlocks = nullptr;
+ m_pInterfaces = nullptr;
+ m_pShaderResources = nullptr;
+ m_pUnorderedAccessViews = nullptr;
+ m_pRenderTargetViews = nullptr;
+ m_pDepthStencilViews = nullptr;
+ m_pDevice = nullptr;
+ m_pClassLinkage = nullptr;
+ m_pContext = nullptr;
+
+ m_VariableCount = 0;
+ m_AnonymousShaderCount = 0;
+ m_ShaderBlockCount = 0;
+ m_DepthStencilBlockCount = 0;
+ m_BlendBlockCount = 0;
+ m_RasterizerBlockCount = 0;
+ m_SamplerBlockCount = 0;
+ m_StringCount = 0;
+ m_MemberDataCount = 0;
+ m_InterfaceCount = 0;
+ m_ShaderResourceCount = 0;
+ m_UnorderedAccessViewCount = 0;
+ m_RenderTargetViewCount = 0;
+ m_DepthStencilViewCount = 0;
+ m_CBCount = 0;
+ m_TechniqueCount = 0;
+ m_GroupCount = 0;
+
+ m_pReflection = nullptr;
+ m_LocalTimer = 1;
+ m_Flags = Flags;
+ m_FXLIndex = 0;
+
+ m_pTypePool = nullptr;
+ m_pStringPool = nullptr;
+ m_pPooledHeap = nullptr;
+ m_pOptimizedTypeHeap = nullptr;
+}
+
+void CEffect::ReleaseShaderRefection()
+{
+ for( size_t i = 0; i < m_ShaderBlockCount; ++ i )
+ {
+ SAFE_RELEASE( m_pShaderBlocks[i].pInputSignatureBlob );
+ if( m_pShaderBlocks[i].pReflectionData )
+ {
+ SAFE_RELEASE( m_pShaderBlocks[i].pReflectionData->pReflection );
+ }
+ }
+}
+
+CEffect::~CEffect()
+{
+ ID3D11InfoQueue *pInfoQueue = nullptr;
+
+ // Mute debug spew
+ if (m_pDevice)
+ {
+ HRESULT hr = m_pDevice->QueryInterface(__uuidof(ID3D11InfoQueue), (void**) &pInfoQueue);
+ if ( FAILED(hr) )
+ pInfoQueue = nullptr;
+ }
+
+ if (pInfoQueue)
+ {
+ D3D11_INFO_QUEUE_FILTER filter;
+ D3D11_MESSAGE_CATEGORY messageCategory = D3D11_MESSAGE_CATEGORY_STATE_SETTING;
+ ZeroMemory(&filter, sizeof(filter));
+
+ filter.DenyList.NumCategories = 1;
+ filter.DenyList.pCategoryList = &messageCategory;
+ pInfoQueue->PushStorageFilter(&filter);
+ }
+
+ if( nullptr != m_pDevice )
+ {
+ // if m_pDevice == nullptr, then we failed LoadEffect(), which means ReleaseShaderReflection was already called.
+
+ // Release the shader reflection info, as it was not created on the private heap
+ // This must be called before we delete m_pReflection
+ ReleaseShaderRefection();
+ }
+
+ SAFE_DELETE( m_pReflection );
+ SAFE_DELETE( m_pTypePool );
+ SAFE_DELETE( m_pStringPool );
+ SAFE_DELETE( m_pPooledHeap );
+ SAFE_DELETE( m_pOptimizedTypeHeap );
+
+ // this code assumes the effect has been loaded & relocated,
+ // so check for that before freeing the resources
+
+ if (nullptr != m_pDevice)
+ {
+ // Keep the following in line with AddRefAllForCloning
+
+ assert(nullptr == m_pRasterizerBlocks || m_Heap.IsInHeap(m_pRasterizerBlocks));
+ for (size_t i = 0; i < m_RasterizerBlockCount; ++ i)
+ {
+ SAFE_RELEASE(m_pRasterizerBlocks[i].pRasterizerObject);
+ }
+
+ assert(nullptr == m_pBlendBlocks || m_Heap.IsInHeap(m_pBlendBlocks));
+ for (size_t i = 0; i < m_BlendBlockCount; ++ i)
+ {
+ SAFE_RELEASE(m_pBlendBlocks[i].pBlendObject);
+ }
+
+ assert(nullptr == m_pDepthStencilBlocks || m_Heap.IsInHeap(m_pDepthStencilBlocks));
+ for (size_t i = 0; i < m_DepthStencilBlockCount; ++ i)
+ {
+ SAFE_RELEASE(m_pDepthStencilBlocks[i].pDSObject);
+ }
+
+ assert(nullptr == m_pSamplerBlocks || m_Heap.IsInHeap(m_pSamplerBlocks));
+ for (size_t i = 0; i < m_SamplerBlockCount; ++ i)
+ {
+ SAFE_RELEASE(m_pSamplerBlocks[i].pD3DObject);
+ }
+
+ assert(nullptr == m_pShaderResources || m_Heap.IsInHeap(m_pShaderResources));
+ for (size_t i = 0; i < m_ShaderResourceCount; ++ i)
+ {
+ SAFE_RELEASE(m_pShaderResources[i].pShaderResource);
+ }
+
+ assert(nullptr == m_pUnorderedAccessViews || m_Heap.IsInHeap(m_pUnorderedAccessViews));
+ for (size_t i = 0; i < m_UnorderedAccessViewCount; ++ i)
+ {
+ SAFE_RELEASE(m_pUnorderedAccessViews[i].pUnorderedAccessView);
+ }
+
+ assert(nullptr == m_pRenderTargetViews || m_Heap.IsInHeap(m_pRenderTargetViews));
+ for (size_t i = 0; i < m_RenderTargetViewCount; ++ i)
+ {
+ SAFE_RELEASE(m_pRenderTargetViews[i].pRenderTargetView);
+ }
+
+ assert(nullptr == m_pDepthStencilViews || m_Heap.IsInHeap(m_pDepthStencilViews));
+ for (size_t i = 0; i < m_DepthStencilViewCount; ++ i)
+ {
+ SAFE_RELEASE(m_pDepthStencilViews[i].pDepthStencilView);
+ }
+
+ assert(nullptr == m_pMemberDataBlocks || m_Heap.IsInHeap(m_pMemberDataBlocks));
+ for (size_t i = 0; i < m_MemberDataCount; ++ i)
+ {
+ switch( m_pMemberDataBlocks[i].Type )
+ {
+ case MDT_ClassInstance:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DClassInstance);
+ break;
+ case MDT_BlendState:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedBlendState);
+ break;
+ case MDT_DepthStencilState:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedDepthStencilState);
+ break;
+ case MDT_RasterizerState:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedRasterizerState);
+ break;
+ case MDT_SamplerState:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedSamplerState);
+ break;
+ case MDT_Buffer:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedConstantBuffer);
+ break;
+ case MDT_ShaderResourceView:
+ SAFE_RELEASE(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedTextureBuffer);
+ break;
+ default:
+ assert( false );
+ }
+ }
+
+ assert(nullptr == m_pCBs || m_Heap.IsInHeap(m_pCBs));
+ for (size_t i = 0; i < m_CBCount; ++ i)
+ {
+ SAFE_RELEASE(m_pCBs[i].TBuffer.pShaderResource);
+ SAFE_RELEASE(m_pCBs[i].pD3DObject);
+ }
+
+ assert(nullptr == m_pShaderBlocks || m_Heap.IsInHeap(m_pShaderBlocks));
+ _Analysis_assume_( m_ShaderBlockCount == 0 || m_pShaderBlocks != 0 );
+ for (size_t i = 0; i < m_ShaderBlockCount; ++ i)
+ {
+ SAFE_RELEASE(m_pShaderBlocks[i].pD3DObject);
+ }
+
+ SAFE_RELEASE( m_pDevice );
+ }
+ SAFE_RELEASE( m_pClassLinkage );
+ assert( m_pContext == nullptr );
+
+ // Restore debug spew
+ if (pInfoQueue)
+ {
+ pInfoQueue->PopStorageFilter();
+ SAFE_RELEASE(pInfoQueue);
+ }
+}
+
+// AddRef all D3D object when cloning
+void CEffect::AddRefAllForCloning( _In_ CEffect* pEffectSource )
+{
+#ifdef NDEBUG
+ UNREFERENCED_PARAMETER(pEffectSource);
+#endif
+ // Keep the following in line with ~CEffect
+
+ assert( m_pDevice != nullptr );
+
+ for( size_t i = 0; i < m_ShaderBlockCount; ++ i )
+ {
+ SAFE_ADDREF( m_pShaderBlocks[i].pInputSignatureBlob );
+ if( m_pShaderBlocks[i].pReflectionData )
+ {
+ SAFE_ADDREF( m_pShaderBlocks[i].pReflectionData->pReflection );
+ }
+ }
+
+ assert(nullptr == m_pRasterizerBlocks || pEffectSource->m_Heap.IsInHeap(m_pRasterizerBlocks));
+ for ( size_t i = 0; i < m_RasterizerBlockCount; ++ i)
+ {
+ SAFE_ADDREF(m_pRasterizerBlocks[i].pRasterizerObject);
+ }
+
+ assert(nullptr == m_pBlendBlocks || pEffectSource->m_Heap.IsInHeap(m_pBlendBlocks));
+ for ( size_t i = 0; i < m_BlendBlockCount; ++ i)
+ {
+ SAFE_ADDREF(m_pBlendBlocks[i].pBlendObject);
+ }
+
+ assert(nullptr == m_pDepthStencilBlocks || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilBlocks));
+ for ( size_t i = 0; i < m_DepthStencilBlockCount; ++ i)
+ {
+ SAFE_ADDREF(m_pDepthStencilBlocks[i].pDSObject);
+ }
+
+ assert(nullptr == m_pSamplerBlocks || pEffectSource->m_Heap.IsInHeap(m_pSamplerBlocks));
+ for ( size_t i = 0; i < m_SamplerBlockCount; ++ i)
+ {
+ SAFE_ADDREF(m_pSamplerBlocks[i].pD3DObject);
+ }
+
+ assert(nullptr == m_pShaderResources || pEffectSource->m_Heap.IsInHeap(m_pShaderResources));
+ for ( size_t i = 0; i < m_ShaderResourceCount; ++ i)
+ {
+ SAFE_ADDREF(m_pShaderResources[i].pShaderResource);
+ }
+
+ assert(nullptr == m_pUnorderedAccessViews || pEffectSource->m_Heap.IsInHeap(m_pUnorderedAccessViews));
+ for ( size_t i = 0; i < m_UnorderedAccessViewCount; ++ i)
+ {
+ SAFE_ADDREF(m_pUnorderedAccessViews[i].pUnorderedAccessView);
+ }
+
+ assert(nullptr == m_pRenderTargetViews || pEffectSource->m_Heap.IsInHeap(m_pRenderTargetViews));
+ for ( size_t i = 0; i < m_RenderTargetViewCount; ++ i)
+ {
+ SAFE_ADDREF(m_pRenderTargetViews[i].pRenderTargetView);
+ }
+
+ assert(nullptr == m_pDepthStencilViews || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilViews));
+ for ( size_t i = 0; i < m_DepthStencilViewCount; ++ i)
+ {
+ SAFE_ADDREF(m_pDepthStencilViews[i].pDepthStencilView);
+ }
+
+ assert(nullptr == m_pMemberDataBlocks || pEffectSource->m_Heap.IsInHeap(m_pMemberDataBlocks));
+ for ( size_t i = 0; i < m_MemberDataCount; ++ i)
+ {
+ switch( m_pMemberDataBlocks[i].Type )
+ {
+ case MDT_ClassInstance:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DClassInstance);
+ break;
+ case MDT_BlendState:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedBlendState);
+ break;
+ case MDT_DepthStencilState:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedDepthStencilState);
+ break;
+ case MDT_RasterizerState:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedRasterizerState);
+ break;
+ case MDT_SamplerState:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedSamplerState);
+ break;
+ case MDT_Buffer:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedConstantBuffer);
+ break;
+ case MDT_ShaderResourceView:
+ SAFE_ADDREF(m_pMemberDataBlocks[i].Data.pD3DEffectsManagedTextureBuffer);
+ break;
+ default:
+ assert( false );
+ }
+ }
+
+ // There's no need to AddRef CBs, since they are recreated
+ assert(nullptr == m_pCBs || pEffectSource->m_Heap.IsInHeap(m_pCBs));
+ for ( size_t i = 0; i < m_CBCount; ++ i)
+ {
+ SAFE_ADDREF(m_pCBs[i].TBuffer.pShaderResource);
+ SAFE_ADDREF(m_pCBs[i].pD3DObject);
+ }
+
+ assert(nullptr == m_pShaderBlocks || pEffectSource->m_Heap.IsInHeap(m_pShaderBlocks));
+ for ( size_t i = 0; i < m_ShaderBlockCount; ++ i)
+ {
+ SAFE_ADDREF(m_pShaderBlocks[i].pD3DObject);
+ }
+
+ SAFE_ADDREF( m_pDevice );
+
+ SAFE_ADDREF( m_pClassLinkage );
+ assert( m_pContext == nullptr );
+}
+
+_Use_decl_annotations_
+HRESULT CEffect::QueryInterface(REFIID iid, LPVOID *ppv)
+{
+ HRESULT hr = S_OK;
+
+ if(nullptr == ppv)
+ {
+ DPF(0, "ID3DX11Effect::QueryInterface: nullptr parameter");
+ hr = E_INVALIDARG;
+ goto EXIT;
+ }
+
+ *ppv = nullptr;
+ if(IsEqualIID(iid, IID_IUnknown))
+ {
+ *ppv = (IUnknown *) this;
+ }
+ else if(IsEqualIID(iid, IID_ID3DX11Effect))
+ {
+ *ppv = (ID3DX11Effect *) this;
+ }
+ else
+ {
+ return E_NOINTERFACE;
+ }
+
+ AddRef();
+
+EXIT:
+ return hr;
+}
+
+ULONG CEffect::AddRef()
+{
+ return ++ m_RefCount;
+}
+
+ULONG CEffect::Release()
+{
+ if (-- m_RefCount > 0)
+ {
+ return m_RefCount;
+ }
+ else
+ {
+ delete this;
+ }
+
+ return 0;
+}
+
+// In all shaders, replace pOldBufferBlock with pNewBuffer, if pOldBufferBlock is a dependency
+_Use_decl_annotations_
+void CEffect::ReplaceCBReference(SConstantBuffer *pOldBufferBlock, ID3D11Buffer *pNewBuffer)
+{
+ for (size_t iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)
+ {
+ for (size_t iCBDep = 0; iCBDep < m_pShaderBlocks[iShaderBlock].CBDepCount; iCBDep++)
+ {
+ for (size_t iCB = 0; iCB < m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].Count; iCB++)
+ {
+ if (m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].ppFXPointers[iCB] == pOldBufferBlock)
+ m_pShaderBlocks[iShaderBlock].pCBDeps[iCBDep].ppD3DObjects[iCB] = pNewBuffer;
+ }
+ }
+ }
+}
+
+// In all shaders, replace pOldSamplerBlock with pNewSampler, if pOldSamplerBlock is a dependency
+_Use_decl_annotations_
+void CEffect::ReplaceSamplerReference(SSamplerBlock *pOldSamplerBlock, ID3D11SamplerState *pNewSampler)
+{
+ for (size_t iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)
+ {
+ for (size_t iSamplerDep = 0; iSamplerDep < m_pShaderBlocks[iShaderBlock].SampDepCount; iSamplerDep++)
+ {
+ for (size_t iSampler = 0; iSampler < m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].Count; iSampler++)
+ {
+ if (m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].ppFXPointers[iSampler] == pOldSamplerBlock)
+ m_pShaderBlocks[iShaderBlock].pSampDeps[iSamplerDep].ppD3DObjects[iSampler] = pNewSampler;
+ }
+ }
+ }
+}
+
+// Call BindToDevice after the effect has been fully loaded.
+// BindToDevice will release all D3D11 objects and create new ones on the new device
+_Use_decl_annotations_
+HRESULT CEffect::BindToDevice(ID3D11Device *pDevice, LPCSTR srcName)
+{
+ HRESULT hr = S_OK;
+
+ // Set new device
+ if (pDevice == nullptr)
+ {
+ DPF(0, "ID3DX11Effect: pDevice must point to a valid D3D11 device");
+ return D3DERR_INVALIDCALL;
+ }
+
+ if (m_pDevice != nullptr)
+ {
+ DPF(0, "ID3DX11Effect: Internal error, rebinding effects to a new device is not supported");
+ return D3DERR_INVALIDCALL;
+ }
+
+ bool featureLevelGE11 = ( pDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0 );
+
+ pDevice->AddRef();
+ SAFE_RELEASE(m_pDevice);
+ m_pDevice = pDevice;
+ VH( m_pDevice->CreateClassLinkage( &m_pClassLinkage ) );
+ SetDebugObjectName(m_pClassLinkage,srcName);
+
+ // Create all constant buffers
+ SConstantBuffer *pCB = m_pCBs;
+ SConstantBuffer *pCBLast = m_pCBs + m_CBCount;
+ for(; pCB != pCBLast; pCB++)
+ {
+ SAFE_RELEASE(pCB->pD3DObject);
+ SAFE_RELEASE(pCB->TBuffer.pShaderResource);
+
+ // This is a CBuffer
+ if (pCB->Size > 0)
+ {
+ if (pCB->IsTBuffer)
+ {
+ D3D11_BUFFER_DESC bufDesc;
+ // size is always register aligned
+ bufDesc.ByteWidth = pCB->Size;
+ bufDesc.Usage = D3D11_USAGE_DEFAULT;
+ bufDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+ bufDesc.CPUAccessFlags = 0;
+ bufDesc.MiscFlags = 0;
+
+ VH( pDevice->CreateBuffer( &bufDesc, nullptr, &pCB->pD3DObject) );
+ SetDebugObjectName(pCB->pD3DObject, srcName );
+
+ D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
+ viewDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
+ viewDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
+ viewDesc.Buffer.ElementOffset = 0;
+ viewDesc.Buffer.ElementWidth = pCB->Size / SType::c_RegisterSize;
+
+ VH( pDevice->CreateShaderResourceView( pCB->pD3DObject, &viewDesc, &pCB->TBuffer.pShaderResource) );
+ SetDebugObjectName(pCB->TBuffer.pShaderResource, srcName );
+ }
+ else
+ {
+ D3D11_BUFFER_DESC bufDesc;
+ // size is always register aligned
+ bufDesc.ByteWidth = pCB->Size;
+ bufDesc.Usage = D3D11_USAGE_DEFAULT;
+ bufDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+ bufDesc.CPUAccessFlags = 0;
+ bufDesc.MiscFlags = 0;
+
+ VH( pDevice->CreateBuffer( &bufDesc, nullptr, &pCB->pD3DObject) );
+ SetDebugObjectName( pCB->pD3DObject, srcName );
+ pCB->TBuffer.pShaderResource = nullptr;
+ }
+
+ pCB->IsDirty = true;
+ }
+ else
+ {
+ pCB->IsDirty = false;
+ }
+ }
+
+ // Create all RasterizerStates
+ SRasterizerBlock *pRB = m_pRasterizerBlocks;
+ SRasterizerBlock *pRBLast = m_pRasterizerBlocks + m_RasterizerBlockCount;
+ for(; pRB != pRBLast; pRB++)
+ {
+ SAFE_RELEASE(pRB->pRasterizerObject);
+ if( SUCCEEDED( m_pDevice->CreateRasterizerState( &pRB->BackingStore, &pRB->pRasterizerObject) ) )
+ {
+ pRB->IsValid = true;
+ SetDebugObjectName( pRB->pRasterizerObject, srcName );
+ }
+ else
+ pRB->IsValid = false;
+ }
+
+ // Create all DepthStencils
+ SDepthStencilBlock *pDS = m_pDepthStencilBlocks;
+ SDepthStencilBlock *pDSLast = m_pDepthStencilBlocks + m_DepthStencilBlockCount;
+ for(; pDS != pDSLast; pDS++)
+ {
+ SAFE_RELEASE(pDS->pDSObject);
+ if( SUCCEEDED( m_pDevice->CreateDepthStencilState( &pDS->BackingStore, &pDS->pDSObject) ) )
+ {
+ pDS->IsValid = true;
+ SetDebugObjectName( pDS->pDSObject, srcName );
+ }
+ else
+ pDS->IsValid = false;
+ }
+
+ // Create all BlendStates
+ SBlendBlock *pBlend = m_pBlendBlocks;
+ SBlendBlock *pBlendLast = m_pBlendBlocks + m_BlendBlockCount;
+ for(; pBlend != pBlendLast; pBlend++)
+ {
+ SAFE_RELEASE(pBlend->pBlendObject);
+ if( SUCCEEDED( m_pDevice->CreateBlendState( &pBlend->BackingStore, &pBlend->pBlendObject ) ) )
+ {
+ pBlend->IsValid = true;
+ SetDebugObjectName( pBlend->pBlendObject, srcName );
+ }
+ else
+ pBlend->IsValid = false;
+ }
+
+ // Create all Samplers
+ SSamplerBlock *pSampler = m_pSamplerBlocks;
+ SSamplerBlock *pSamplerLast = m_pSamplerBlocks + m_SamplerBlockCount;
+ for(; pSampler != pSamplerLast; pSampler++)
+ {
+ SAFE_RELEASE(pSampler->pD3DObject);
+
+ VH( m_pDevice->CreateSamplerState( &pSampler->BackingStore.SamplerDesc, &pSampler->pD3DObject) );
+ SetDebugObjectName( pSampler->pD3DObject, srcName );
+ }
+
+ // Create all shaders
+ ID3D11ClassLinkage* neededClassLinkage = featureLevelGE11 ? m_pClassLinkage : nullptr;
+ SShaderBlock *pShader = m_pShaderBlocks;
+ SShaderBlock *pShaderLast = m_pShaderBlocks + m_ShaderBlockCount;
+ for(; pShader != pShaderLast; pShader++)
+ {
+ SAFE_RELEASE(pShader->pD3DObject);
+
+ if (nullptr == pShader->pReflectionData)
+ {
+ // nullptr shader. It's one of these:
+ // PixelShader ps;
+ // or
+ // SetPixelShader( nullptr );
+ continue;
+ }
+
+ if (pShader->pReflectionData->pStreamOutDecls[0] || pShader->pReflectionData->pStreamOutDecls[1] ||
+ pShader->pReflectionData->pStreamOutDecls[2] || pShader->pReflectionData->pStreamOutDecls[3] )
+ {
+ // This is a geometry shader, process it's data
+ CSOParser soParser;
+ VH( soParser.Parse(pShader->pReflectionData->pStreamOutDecls) );
+ uint32_t strides[4];
+ soParser.GetStrides( strides );
+ hr = m_pDevice->CreateGeometryShaderWithStreamOutput(pShader->pReflectionData->pBytecode,
+ pShader->pReflectionData->BytecodeLength,
+ soParser.GetDeclArray(),
+ soParser.GetDeclCount(),
+ strides,
+ featureLevelGE11 ? 4 : 1,
+ pShader->pReflectionData->RasterizedStream,
+ neededClassLinkage,
+ reinterpret_cast<ID3D11GeometryShader**>(&pShader->pD3DObject) );
+ if (FAILED(hr))
+ {
+ DPF(1, "ID3DX11Effect::Load - failed to create GeometryShader with StreamOutput decl: \"%s\"", soParser.GetErrorString() );
+ pShader->IsValid = false;
+ hr = S_OK;
+ }
+ else
+ {
+ SetDebugObjectName( pShader->pD3DObject, srcName );
+ }
+ }
+ else
+ {
+ // This is a regular shader
+ if( pShader->pReflectionData->RasterizedStream == D3D11_SO_NO_RASTERIZED_STREAM )
+ pShader->IsValid = false;
+ else
+ {
+ if( FAILED( (m_pDevice->*(pShader->pVT->pCreateShader))( (uint32_t *) pShader->pReflectionData->pBytecode, pShader->pReflectionData->BytecodeLength, neededClassLinkage, &pShader->pD3DObject) ) )
+ {
+ DPF(1, "ID3DX11Effect::Load - failed to create shader" );
+ pShader->IsValid = false;
+ }
+ else
+ {
+ SetDebugObjectName( pShader->pD3DObject, srcName );
+ }
+ }
+ }
+
+ // Update all dependency pointers
+ VH( pShader->OnDeviceBind() );
+ }
+
+ // Initialize the member data pointers for all variables
+ uint32_t CurMemberData = 0;
+ for (uint32_t i = 0; i < m_VariableCount; ++ i)
+ {
+ if( m_pVariables[i].pMemberData )
+ {
+ if( m_pVariables[i].pType->IsClassInstance() )
+ {
+ for (uint32_t j = 0; j < std::max<size_t>(m_pVariables[i].pType->Elements,1); ++j)
+ {
+ assert( CurMemberData < m_MemberDataCount );
+ ID3D11ClassInstance** ppCI = &(m_pVariables[i].pMemberData + j)->Data.pD3DClassInstance;
+ (m_pVariables[i].pMemberData + j)->Type = MDT_ClassInstance;
+ (m_pVariables[i].pMemberData + j)->Data.pD3DClassInstance = nullptr;
+ if( m_pVariables[i].pType->TotalSize > 0 )
+ {
+ // ignore failures in GetClassInstance;
+ m_pClassLinkage->GetClassInstance( m_pVariables[i].pName, j, ppCI );
+ }
+ else
+ {
+ // The HLSL compiler optimizes out zero-sized classes, so we have to create class instances from scratch
+ if( FAILED( m_pClassLinkage->CreateClassInstance( m_pVariables[i].pType->pTypeName, 0, 0, 0, 0, ppCI ) ) )
+ {
+ DPF(0, "ID3DX11Effect: Out of memory while trying to create new class instance interface");
+ }
+ else
+ {
+ SetDebugObjectName( *ppCI, srcName );
+ }
+ }
+ CurMemberData++;
+ }
+ }
+ else if( m_pVariables[i].pType->IsStateBlockObject() )
+ {
+ for (size_t j = 0; j < std::max<size_t>(m_pVariables[i].pType->Elements,1); ++j)
+ {
+ switch( m_pVariables[i].pType->ObjectType )
+ {
+ case EOT_Blend:
+ (m_pVariables[i].pMemberData + j)->Type = MDT_BlendState;
+ (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedBlendState = nullptr;
+ break;
+ case EOT_Rasterizer:
+ (m_pVariables[i].pMemberData + j)->Type = MDT_RasterizerState;
+ (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedRasterizerState = nullptr;
+ break;
+ case EOT_DepthStencil:
+ (m_pVariables[i].pMemberData + j)->Type = MDT_DepthStencilState;
+ (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedDepthStencilState = nullptr;
+ break;
+ case EOT_Sampler:
+ (m_pVariables[i].pMemberData + j)->Type = MDT_SamplerState;
+ (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedSamplerState = nullptr;
+ break;
+ default:
+ VB( false );
+ }
+ CurMemberData++;
+ }
+ }
+ else
+ {
+ VB( false );
+ }
+ }
+ }
+ for(pCB = m_pCBs; pCB != pCBLast; pCB++)
+ {
+ (pCB->pMemberData + 0)->Type = MDT_Buffer;
+ (pCB->pMemberData + 0)->Data.pD3DEffectsManagedConstantBuffer = nullptr;
+ CurMemberData++;
+ (pCB->pMemberData + 1)->Type = MDT_ShaderResourceView;
+ (pCB->pMemberData + 1)->Data.pD3DEffectsManagedTextureBuffer = nullptr;
+ CurMemberData++;
+ }
+
+
+ // Determine which techniques and passes are known to be invalid
+ for( size_t iGroup=0; iGroup < m_GroupCount; iGroup++ )
+ {
+ SGroup* pGroup = &m_pGroups[iGroup];
+ pGroup->InitiallyValid = true;
+
+ for( size_t iTech=0; iTech < pGroup->TechniqueCount; iTech++ )
+ {
+ STechnique* pTechnique = &pGroup->pTechniques[iTech];
+ pTechnique->InitiallyValid = true;
+
+ for( size_t iPass = 0; iPass < pTechnique->PassCount; iPass++ )
+ {
+ SPassBlock* pPass = &pTechnique->pPasses[iPass];
+ pPass->InitiallyValid = true;
+
+ if( pPass->BackingStore.pBlendBlock != nullptr && !pPass->BackingStore.pBlendBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pDepthStencilBlock != nullptr && !pPass->BackingStore.pDepthStencilBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pRasterizerBlock != nullptr && !pPass->BackingStore.pRasterizerBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pVertexShaderBlock != nullptr && !pPass->BackingStore.pVertexShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pPixelShaderBlock != nullptr && !pPass->BackingStore.pPixelShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pGeometryShaderBlock != nullptr && !pPass->BackingStore.pGeometryShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pHullShaderBlock != nullptr && !pPass->BackingStore.pHullShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pDomainShaderBlock != nullptr && !pPass->BackingStore.pDomainShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+ if( pPass->BackingStore.pComputeShaderBlock != nullptr && !pPass->BackingStore.pComputeShaderBlock->IsValid )
+ pPass->InitiallyValid = false;
+
+ pTechnique->InitiallyValid &= pPass->InitiallyValid;
+ }
+ pGroup->InitiallyValid &= pTechnique->InitiallyValid;
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+// FindVariableByName, plus an understanding of literal indices
+// This code handles A[i].
+// It does not handle anything else, like A.B, A[B[i]], A[B]
+SVariable * CEffect::FindVariableByNameWithParsing(_In_z_ LPCSTR pName)
+{
+ SGlobalVariable *pVariable;
+ const uint32_t MAX_PARSABLE_NAME_LENGTH = 256;
+ char pScratchString[MAX_PARSABLE_NAME_LENGTH];
+
+ const char* pSource = pName;
+ char* pDest = pScratchString;
+ char* pEnd = pScratchString + MAX_PARSABLE_NAME_LENGTH;
+
+ pVariable = nullptr;
+
+ while( *pSource != 0 )
+ {
+ if( pDest == pEnd )
+ {
+ pVariable = FindLocalVariableByName(pName);
+ if( pVariable == nullptr )
+ {
+ DPF( 0, "Name %s is too long to parse", pName );
+ }
+ return pVariable;
+ }
+
+ if( *pSource == '[' )
+ {
+ // parse previous variable name
+ *pDest = 0;
+ assert( pVariable == nullptr );
+ pVariable = FindLocalVariableByName(pScratchString);
+ if( pVariable == nullptr )
+ {
+ return nullptr;
+ }
+ pDest = pScratchString;
+ }
+ else if( *pSource == ']' )
+ {
+ // parse integer
+ *pDest = 0;
+ uint32_t index = atoi(pScratchString);
+ assert( pVariable != 0 );
+ _Analysis_assume_( pVariable != 0 );
+ pVariable = (SGlobalVariable*)pVariable->GetElement(index);
+ if( pVariable && !pVariable->IsValid() )
+ {
+ pVariable = nullptr;
+ }
+ return pVariable;
+ }
+ else
+ {
+ // add character
+ *pDest = *pSource;
+ pDest++;
+ }
+ pSource++;
+ }
+
+ if( pDest != pScratchString )
+ {
+ // parse the variable name (there was no [i])
+ *pDest = 0;
+ assert( pVariable == nullptr );
+ pVariable = FindLocalVariableByName(pScratchString);
+ }
+
+ return pVariable;
+}
+
+SGlobalVariable * CEffect::FindVariableByName(_In_z_ LPCSTR pName)
+{
+ SGlobalVariable *pVariable;
+
+ pVariable = FindLocalVariableByName(pName);
+
+ return pVariable;
+}
+
+SGlobalVariable * CEffect::FindLocalVariableByName(_In_z_ LPCSTR pName)
+{
+ SGlobalVariable *pVariable, *pVariableEnd;
+
+ pVariableEnd = m_pVariables + m_VariableCount;
+ for (pVariable = m_pVariables; pVariable != pVariableEnd; pVariable++)
+ {
+ if (strcmp( pVariable->pName, pName) == 0)
+ {
+ return pVariable;
+ }
+ }
+
+ return nullptr;
+}
+
+
+//
+// Checks to see if two types are equivalent (either at runtime
+// or during the type-pooling load process)
+//
+// Major assumption: if both types are structures, then their
+// member types & names should already have been added to the pool,
+// in which case their member type & name pointers should be equal.
+//
+// This is true because complex data types (structures) have all
+// sub-types translated before the containing type is translated,
+// which means that simple sub-types (numeric types) have already
+// been pooled.
+//
+bool SType::IsEqual(SType *pOtherType) const
+{
+ if (VarType != pOtherType->VarType || Elements != pOtherType->Elements
+ || strcmp(pTypeName, pOtherType->pTypeName) != 0)
+ {
+ return false;
+ }
+
+ switch (VarType)
+ {
+ case EVT_Struct:
+ {
+ if (StructType.Members != pOtherType->StructType.Members)
+ {
+ return false;
+ }
+ assert(StructType.pMembers != nullptr && pOtherType->StructType.pMembers != nullptr);
+
+ uint32_t i;
+ for (i = 0; i < StructType.Members; ++ i)
+ {
+ // names for types must exist (not true for semantics)
+ assert(StructType.pMembers[i].pName != nullptr && pOtherType->StructType.pMembers[i].pName != nullptr);
+
+ if (StructType.pMembers[i].pType != pOtherType->StructType.pMembers[i].pType ||
+ StructType.pMembers[i].Data.Offset != pOtherType->StructType.pMembers[i].Data.Offset ||
+ StructType.pMembers[i].pName != pOtherType->StructType.pMembers[i].pName ||
+ StructType.pMembers[i].pSemantic != pOtherType->StructType.pMembers[i].pSemantic)
+ {
+ return false;
+ }
+ }
+ }
+ break;
+
+ case EVT_Object:
+ {
+ if (ObjectType != pOtherType->ObjectType)
+ {
+ return false;
+ }
+ }
+ break;
+
+ case EVT_Numeric:
+ {
+ if (NumericType.Rows != pOtherType->NumericType.Rows ||
+ NumericType.Columns != pOtherType->NumericType.Columns ||
+ NumericType.ScalarType != pOtherType->NumericType.ScalarType ||
+ NumericType.NumericLayout != pOtherType->NumericType.NumericLayout ||
+ NumericType.IsColumnMajor != pOtherType->NumericType.IsColumnMajor ||
+ NumericType.IsPackedArray != pOtherType->NumericType.IsPackedArray)
+ {
+ return false;
+ }
+ }
+ break;
+
+ case EVT_Interface:
+ {
+ // VarType and pTypeName handled above
+ }
+ break;
+
+ default:
+ {
+ assert(0);
+ return false;
+ }
+ break;
+ }
+
+ assert(TotalSize == pOtherType->TotalSize && Stride == pOtherType->Stride && PackedSize == pOtherType->PackedSize);
+
+ return true;
+}
+
+uint32_t SType::GetTotalUnpackedSize(_In_ bool IsSingleElement) const
+{
+ if (VarType == EVT_Object)
+ {
+ return 0;
+ }
+ else if (VarType == EVT_Interface)
+ {
+ return 0;
+ }
+ else if (Elements > 0 && IsSingleElement)
+ {
+ assert( ( TotalSize == 0 && Stride == 0 ) ||
+ ( (TotalSize > (Stride * (Elements - 1))) && (TotalSize <= (Stride * Elements)) ) );
+ return TotalSize - Stride * (Elements - 1);
+ }
+ else
+ {
+ return TotalSize;
+ }
+}
+
+uint32_t SType::GetTotalPackedSize(_In_ bool IsSingleElement) const
+{
+ if (Elements > 0 && IsSingleElement)
+ {
+ assert(PackedSize % Elements == 0);
+ return PackedSize / Elements;
+ }
+ else
+ {
+ return PackedSize;
+ }
+}
+
+SConstantBuffer *CEffect::FindCB(_In_z_ LPCSTR pName)
+{
+ uint32_t i;
+
+ for (i=0; i<m_CBCount; i++)
+ {
+ if (!strcmp(m_pCBs[i].pName, pName))
+ {
+ return &m_pCBs[i];
+ }
+ }
+
+ return nullptr;
+}
+
+bool CEffect::IsOptimized()
+{
+ if ((m_Flags & D3DX11_EFFECT_OPTIMIZED) != 0)
+ {
+ assert(nullptr == m_pReflection);
+ return true;
+ }
+ else
+ {
+ assert(nullptr != m_pReflection);
+ return false;
+ }
+}
+
+// Replace *ppType with the corresponding value in pMappingTable
+// pMappingTable table describes how to map old type pointers to new type pointers
+static HRESULT RemapType(_Inout_ SType **ppType, _Inout_ CPointerMappingTable *pMappingTable)
+{
+ HRESULT hr = S_OK;
+
+ SPointerMapping ptrMapping;
+ CPointerMappingTable::CIterator iter;
+ ptrMapping.pOld = *ppType;
+ VH( pMappingTable->FindValueWithHash(ptrMapping, ptrMapping.Hash(), &iter) );
+ *ppType = (SType *) iter.GetData().pNew;
+
+lExit:
+ return hr;
+}
+
+// Replace *ppString with the corresponding value in pMappingTable
+// pMappingTable table describes how to map old string pointers to new string pointers
+static HRESULT RemapString(_In_ char **ppString, _Inout_ CPointerMappingTable *pMappingTable)
+{
+ HRESULT hr = S_OK;
+
+ SPointerMapping ptrMapping;
+ CPointerMappingTable::CIterator iter;
+ ptrMapping.pOld = *ppString;
+ VH( pMappingTable->FindValueWithHash(ptrMapping, ptrMapping.Hash(), &iter) );
+ *ppString = (char *) iter.GetData().pNew;
+
+lExit:
+ return hr;
+}
+
+// Used in cloning, copy m_pMemberInterfaces from pEffectSource to this
+HRESULT CEffect::CopyMemberInterfaces( _In_ CEffect* pEffectSource )
+{
+ HRESULT hr = S_OK;
+
+ uint32_t Members = pEffectSource->m_pMemberInterfaces.GetSize();
+ m_pMemberInterfaces.AddRange(Members);
+ uint32_t i=0; // after a failure, this holds the failing index
+ for(; i < Members; i++ )
+ {
+ SMember* pOldMember = pEffectSource->m_pMemberInterfaces[i];
+ if( pOldMember == nullptr )
+ {
+ // During Optimization, m_pMemberInterfaces[i] was set to nullptr because it was an annotation
+ m_pMemberInterfaces[i] = nullptr;
+ continue;
+ }
+
+ SMember *pNewMember;
+ assert( pOldMember->pTopLevelEntity != nullptr );
+
+ if (nullptr == (pNewMember = CreateNewMember((SType*)pOldMember->pType, false)))
+ {
+ DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");
+ VN( pNewMember );
+ }
+
+ pNewMember->pType = pOldMember->pType;
+ pNewMember->pName = pOldMember->pName;
+ pNewMember->pSemantic = pOldMember->pSemantic;
+ pNewMember->Data.pGeneric = pOldMember->Data.pGeneric;
+ pNewMember->IsSingleElement = pOldMember->IsSingleElement;
+ pNewMember->pTopLevelEntity = pOldMember->pTopLevelEntity;
+ pNewMember->pMemberData = pOldMember->pMemberData;
+
+ m_pMemberInterfaces[i] = pNewMember;
+ }
+
+lExit:
+ if( FAILED(hr) )
+ {
+ assert( i < Members );
+ ZeroMemory( &m_pMemberInterfaces[i], sizeof(SMember) * ( Members - i ) );
+ }
+ return hr;
+}
+
+// Used in cloning, copy the string pool from pEffectSource to this and build mappingTable
+// for use in RemapString
+_Use_decl_annotations_
+HRESULT CEffect::CopyStringPool( CEffect* pEffectSource, CPointerMappingTable& mappingTable )
+{
+ HRESULT hr = S_OK;
+ assert( m_pPooledHeap != 0 );
+ _Analysis_assume_( m_pPooledHeap != 0 );
+ VN( m_pStringPool = new CEffect::CStringHashTable );
+ m_pStringPool->SetPrivateHeap(m_pPooledHeap);
+ VH( m_pStringPool->AutoGrow() );
+
+ CStringHashTable::CIterator stringIter;
+
+ // move strings over, build mapping table
+ for (pEffectSource->m_pStringPool->GetFirstEntry(&stringIter); !pEffectSource->m_pStringPool->PastEnd(&stringIter); pEffectSource->m_pStringPool->GetNextEntry(&stringIter))
+ {
+ SPointerMapping ptrMapping;
+ char *pString;
+
+ const char* pOldString = stringIter.GetData();
+ ptrMapping.pOld = (void*)pOldString;
+ uint32_t len = (uint32_t)strlen(pOldString);
+ uint32_t hash = ptrMapping.Hash();
+ VN( pString = new(*m_pPooledHeap) char[len + 1] );
+ ptrMapping.pNew = (void*)pString;
+ memcpy(ptrMapping.pNew, ptrMapping.pOld, len + 1);
+ VH( m_pStringPool->AddValueWithHash(pString, hash) );
+
+ VH( mappingTable.AddValueWithHash(ptrMapping, hash) );
+ }
+
+ // Uncomment to print string mapping
+ /*
+ CPointerMappingTable::CIterator mapIter;
+ for (mappingTable.GetFirstEntry(&mapIter); !mappingTable.PastEnd(&mapIter); mappingTable.GetNextEntry(&mapIter))
+ {
+ SPointerMapping ptrMapping = mapIter.GetData();
+ DPF(0, "string: 0x%x : 0x%x %s", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew, (char*)ptrMapping.pNew );
+ }*/
+
+lExit:
+ return hr;
+}
+
+// Used in cloning, copy the unoptimized type pool from pEffectSource to this and build mappingTableTypes
+// for use in RemapType. mappingTableStrings is the mapping table previously filled when copying strings.
+_Use_decl_annotations_
+HRESULT CEffect::CopyTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes, CPointerMappingTable& mappingTableStrings )
+{
+ HRESULT hr = S_OK;
+ assert( m_pPooledHeap != 0 );
+ _Analysis_assume_( m_pPooledHeap != 0 );
+ VN( m_pTypePool = new CEffect::CTypeHashTable );
+ m_pTypePool->SetPrivateHeap(m_pPooledHeap);
+ VH( m_pTypePool->AutoGrow() );
+
+ CTypeHashTable::CIterator typeIter;
+ CPointerMappingTable::CIterator mapIter;
+
+ // first pass: move types over, build mapping table
+ for (pEffectSource->m_pTypePool->GetFirstEntry(&typeIter); !pEffectSource->m_pTypePool->PastEnd(&typeIter); pEffectSource->m_pTypePool->GetNextEntry(&typeIter))
+ {
+ SPointerMapping ptrMapping;
+ SType *pType;
+
+ ptrMapping.pOld = typeIter.GetData();
+ uint32_t hash = ptrMapping.Hash();
+ VN( (ptrMapping.pNew) = new(*m_pPooledHeap) SType );
+ memcpy(ptrMapping.pNew, ptrMapping.pOld, sizeof(SType));
+
+ pType = (SType *) ptrMapping.pNew;
+
+ // if this is a struct, move its members to the newly allocated space
+ if (EVT_Struct == pType->VarType)
+ {
+ SVariable* pOldMembers = pType->StructType.pMembers;
+ VN( pType->StructType.pMembers = new(*m_pPooledHeap) SVariable[pType->StructType.Members] );
+ memcpy(pType->StructType.pMembers, pOldMembers, pType->StructType.Members * sizeof(SVariable));
+ }
+
+ VH( m_pTypePool->AddValueWithHash(pType, hash) );
+ VH( mappingTableTypes.AddValueWithHash(ptrMapping, hash) );
+ }
+
+ // second pass: fixup structure member & name pointers
+ for (mappingTableTypes.GetFirstEntry(&mapIter); !mappingTableTypes.PastEnd(&mapIter); mappingTableTypes.GetNextEntry(&mapIter))
+ {
+ SPointerMapping ptrMapping = mapIter.GetData();
+
+ // Uncomment to print type mapping
+ //DPF(0, "type: 0x%x : 0x%x", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew );
+
+ SType *pType = (SType *) ptrMapping.pNew;
+
+ if( pType->pTypeName )
+ {
+ VH( RemapString(&pType->pTypeName, &mappingTableStrings) );
+ }
+
+ // if this is a struct, fix up its members' pointers
+ if (EVT_Struct == pType->VarType)
+ {
+ for (uint32_t i = 0; i < pType->StructType.Members; ++ i)
+ {
+ VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTableTypes) );
+ if( pType->StructType.pMembers[i].pName )
+ {
+ VH( RemapString(&pType->StructType.pMembers[i].pName, &mappingTableStrings) );
+ }
+ if( pType->StructType.pMembers[i].pSemantic )
+ {
+ VH( RemapString(&pType->StructType.pMembers[i].pSemantic, &mappingTableStrings) );
+ }
+ }
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+// Used in cloning, copy the unoptimized type pool from pEffectSource to this and build mappingTableTypes
+// for use in RemapType. mappingTableStrings is the mapping table previously filled when copying strings.
+_Use_decl_annotations_
+HRESULT CEffect::CopyOptimizedTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes )
+{
+ HRESULT hr = S_OK;
+ CEffectHeap* pOptimizedTypeHeap = nullptr;
+
+ assert( pEffectSource->m_pOptimizedTypeHeap != 0 );
+ _Analysis_assume_( pEffectSource->m_pOptimizedTypeHeap != 0 );
+ assert( m_pTypePool == 0 );
+ assert( m_pStringPool == 0 );
+ assert( m_pPooledHeap == 0 );
+
+ VN( pOptimizedTypeHeap = new CEffectHeap );
+ VH( pOptimizedTypeHeap->ReserveMemory( pEffectSource->m_pOptimizedTypeHeap->GetSize() ) );
+ CPointerMappingTable::CIterator mapIter;
+
+ // first pass: move types over, build mapping table
+ uint8_t* pReadTypes = pEffectSource->m_pOptimizedTypeHeap->GetDataStart();
+ while( pEffectSource->m_pOptimizedTypeHeap->IsInHeap( pReadTypes ) )
+ {
+ SPointerMapping ptrMapping;
+ SType *pType;
+ uint32_t moveSize;
+
+ ptrMapping.pOld = ptrMapping.pNew = pReadTypes;
+ moveSize = sizeof(SType);
+ VH( pOptimizedTypeHeap->MoveData(&ptrMapping.pNew, moveSize) );
+ pReadTypes += moveSize;
+
+ pType = (SType *) ptrMapping.pNew;
+
+ // if this is a struct, move its members to the newly allocated space
+ if (EVT_Struct == pType->VarType)
+ {
+ moveSize = pType->StructType.Members * sizeof(SVariable);
+ VH( pOptimizedTypeHeap->MoveData((void **)&pType->StructType.pMembers, moveSize) );
+ pReadTypes += moveSize;
+ }
+
+ VH( mappingTableTypes.AddValueWithHash(ptrMapping, ptrMapping.Hash()) );
+ }
+
+ // second pass: fixup structure member & name pointers
+ for (mappingTableTypes.GetFirstEntry(&mapIter); !mappingTableTypes.PastEnd(&mapIter); mappingTableTypes.GetNextEntry(&mapIter))
+ {
+ SPointerMapping ptrMapping = mapIter.GetData();
+
+ // Uncomment to print type mapping
+ //DPF(0, "type: 0x%x : 0x%x", (UINT_PTR)ptrMapping.pOld, (UINT_PTR)ptrMapping.pNew );
+
+ SType *pType = (SType *) ptrMapping.pNew;
+
+ // if this is a struct, fix up its members' pointers
+ if (EVT_Struct == pType->VarType)
+ {
+ for (uint32_t i = 0; i < pType->StructType.Members; ++ i)
+ {
+ VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTableTypes) );
+ }
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+// Used in cloning, create new ID3D11ConstantBuffers for each non-single CB
+HRESULT CEffect::RecreateCBs()
+{
+ HRESULT hr = S_OK;
+ uint32_t i; // after a failure, this holds the failing index
+
+ for (i = 0; i < m_CBCount; ++ i)
+ {
+ SConstantBuffer* pCB = &m_pCBs[i];
+
+ pCB->IsNonUpdatable = pCB->IsUserManaged || pCB->ClonedSingle();
+
+ if( pCB->Size > 0 && !pCB->ClonedSingle() )
+ {
+ ID3D11Buffer** ppOriginalBuffer;
+ ID3D11ShaderResourceView** ppOriginalTBufferView;
+
+ if( pCB->IsUserManaged )
+ {
+ ppOriginalBuffer = &pCB->pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;
+ ppOriginalTBufferView = &pCB->pMemberData[1].Data.pD3DEffectsManagedTextureBuffer;
+ }
+ else
+ {
+ ppOriginalBuffer = &pCB->pD3DObject;
+ ppOriginalTBufferView = &pCB->TBuffer.pShaderResource;
+ }
+
+ VN( *ppOriginalBuffer );
+ D3D11_BUFFER_DESC bufDesc;
+ (*ppOriginalBuffer)->GetDesc( &bufDesc );
+ ID3D11Buffer* pNewBuffer = nullptr;
+ VH( m_pDevice->CreateBuffer( &bufDesc, nullptr, &pNewBuffer ) );
+ SetDebugObjectName( pNewBuffer, "D3DX11Effect" );
+ (*ppOriginalBuffer)->Release();
+ (*ppOriginalBuffer) = pNewBuffer;
+ pNewBuffer = nullptr;
+
+ if( pCB->IsTBuffer )
+ {
+ VN( *ppOriginalTBufferView );
+ D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
+ (*ppOriginalTBufferView)->GetDesc( &viewDesc );
+ ID3D11ShaderResourceView* pNewView = nullptr;
+ VH( m_pDevice->CreateShaderResourceView( (*ppOriginalBuffer), &viewDesc, &pNewView) );
+ SetDebugObjectName( pNewView, "D3DX11Effect" );
+ (*ppOriginalTBufferView)->Release();
+ (*ppOriginalTBufferView) = pNewView;
+ pNewView = nullptr;
+ }
+ else
+ {
+ assert( *ppOriginalTBufferView == nullptr );
+ ReplaceCBReference( pCB, (*ppOriginalBuffer) );
+ }
+
+ pCB->IsDirty = true;
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+// Move Name and Semantic strings using mappingTableStrings
+_Use_decl_annotations_
+HRESULT CEffect::FixupMemberInterface( SMember* pMember, CEffect* pEffectSource, CPointerMappingTable& mappingTableStrings )
+{
+ HRESULT hr = S_OK;
+
+ if( pMember->pName )
+ {
+ if( pEffectSource->m_pReflection && pEffectSource->m_pReflection->m_Heap.IsInHeap(pMember->pName) )
+ {
+ pMember->pName = (char*)((UINT_PTR)pMember->pName - (UINT_PTR)pEffectSource->m_pReflection->m_Heap.GetDataStart() + (UINT_PTR)m_pReflection->m_Heap.GetDataStart());
+ }
+ else
+ {
+ VH( RemapString(&pMember->pName, &mappingTableStrings) );
+ }
+ }
+ if( pMember->pSemantic )
+ {
+ if( pEffectSource->m_pReflection && pEffectSource->m_pReflection->m_Heap.IsInHeap(pMember->pSemantic) )
+ {
+ pMember->pSemantic = (char*)((UINT_PTR)pMember->pSemantic - (UINT_PTR)pEffectSource->m_pReflection->m_Heap.GetDataStart() + (UINT_PTR)m_pReflection->m_Heap.GetDataStart());
+ }
+ else
+ {
+ VH( RemapString(&pMember->pSemantic, &mappingTableStrings) );
+ }
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Public API to create a copy of this effect
+HRESULT CEffect::CloneEffect(_In_ uint32_t Flags, _Outptr_ ID3DX11Effect** ppClonedEffect )
+{
+ HRESULT hr = S_OK;
+ CPointerMappingTable mappingTableTypes;
+ CPointerMappingTable mappingTableStrings;
+
+ CEffectLoader loader;
+ CEffect* pNewEffect = nullptr;
+ CDataBlockStore* pTempHeap = nullptr;
+
+
+ VN( pNewEffect = new CEffect( m_Flags ) );
+ if( Flags & D3DX11_EFFECT_CLONE_FORCE_NONSINGLE )
+ {
+ // The effect is cloned as if there was no original, so don't mark it as cloned
+ pNewEffect->m_Flags &= ~(uint32_t)D3DX11_EFFECT_CLONE;
+ }
+ else
+ {
+ pNewEffect->m_Flags |= D3DX11_EFFECT_CLONE;
+ }
+
+ pNewEffect->m_VariableCount = m_VariableCount;
+ pNewEffect->m_pVariables = m_pVariables;
+ pNewEffect->m_AnonymousShaderCount = m_AnonymousShaderCount;
+ pNewEffect->m_pAnonymousShaders = m_pAnonymousShaders;
+ pNewEffect->m_TechniqueCount = m_TechniqueCount;
+ pNewEffect->m_GroupCount = m_GroupCount;
+ pNewEffect->m_pGroups = m_pGroups;
+ pNewEffect->m_pNullGroup = m_pNullGroup;
+ pNewEffect->m_ShaderBlockCount = m_ShaderBlockCount;
+ pNewEffect->m_pShaderBlocks = m_pShaderBlocks;
+ pNewEffect->m_DepthStencilBlockCount = m_DepthStencilBlockCount;
+ pNewEffect->m_pDepthStencilBlocks = m_pDepthStencilBlocks;
+ pNewEffect->m_BlendBlockCount = m_BlendBlockCount;
+ pNewEffect->m_pBlendBlocks = m_pBlendBlocks;
+ pNewEffect->m_RasterizerBlockCount = m_RasterizerBlockCount;
+ pNewEffect->m_pRasterizerBlocks = m_pRasterizerBlocks;
+ pNewEffect->m_SamplerBlockCount = m_SamplerBlockCount;
+ pNewEffect->m_pSamplerBlocks = m_pSamplerBlocks;
+ pNewEffect->m_MemberDataCount = m_MemberDataCount;
+ pNewEffect->m_pMemberDataBlocks = m_pMemberDataBlocks;
+ pNewEffect->m_InterfaceCount = m_InterfaceCount;
+ pNewEffect->m_pInterfaces = m_pInterfaces;
+ pNewEffect->m_CBCount = m_CBCount;
+ pNewEffect->m_pCBs = m_pCBs;
+ pNewEffect->m_StringCount = m_StringCount;
+ pNewEffect->m_pStrings = m_pStrings;
+ pNewEffect->m_ShaderResourceCount = m_ShaderResourceCount;
+ pNewEffect->m_pShaderResources = m_pShaderResources;
+ pNewEffect->m_UnorderedAccessViewCount = m_UnorderedAccessViewCount;
+ pNewEffect->m_pUnorderedAccessViews = m_pUnorderedAccessViews;
+ pNewEffect->m_RenderTargetViewCount = m_RenderTargetViewCount;
+ pNewEffect->m_pRenderTargetViews = m_pRenderTargetViews;
+ pNewEffect->m_DepthStencilViewCount = m_DepthStencilViewCount;
+ pNewEffect->m_pDepthStencilViews = m_pDepthStencilViews;
+ pNewEffect->m_LocalTimer = m_LocalTimer;
+ pNewEffect->m_FXLIndex = m_FXLIndex;
+ pNewEffect->m_pDevice = m_pDevice;
+ pNewEffect->m_pClassLinkage = m_pClassLinkage;
+
+ pNewEffect->AddRefAllForCloning( this );
+
+
+ // m_pMemberInterfaces is a vector of cbuffer members that were created when the user called GetMemberBy* or GetElement
+ // or during Effect loading when an interface is initialized to a global class variable elment.
+ VH( pNewEffect->CopyMemberInterfaces( this ) );
+
+ loader.m_pvOldMemberInterfaces = &m_pMemberInterfaces;
+ loader.m_pEffect = pNewEffect;
+ loader.m_EffectMemory = loader.m_ReflectionMemory = 0;
+
+
+ // Move data from current effect to new effect
+ if( !IsOptimized() )
+ {
+ VN( pNewEffect->m_pReflection = new CEffectReflection() );
+ loader.m_pReflection = pNewEffect->m_pReflection;
+
+ // make sure strings are moved before ReallocateEffectData
+ VH( loader.InitializeReflectionDataAndMoveStrings( m_pReflection->m_Heap.GetSize() ) );
+ }
+ VH( loader.ReallocateEffectData( true ) );
+ if( !IsOptimized() )
+ {
+ VH( loader.ReallocateReflectionData( true ) );
+ }
+
+
+ // Data structures for remapping type pointers and string pointers
+ VN( pTempHeap = new CDataBlockStore );
+ pTempHeap->EnableAlignment();
+ mappingTableTypes.SetPrivateHeap(pTempHeap);
+ mappingTableStrings.SetPrivateHeap(pTempHeap);
+ VH( mappingTableTypes.AutoGrow() );
+ VH( mappingTableStrings.AutoGrow() );
+
+ if( !IsOptimized() )
+ {
+ // Let's re-create the type pool and string pool
+ VN( pNewEffect->m_pPooledHeap = new CDataBlockStore );
+ pNewEffect->m_pPooledHeap->EnableAlignment();
+
+ VH( pNewEffect->CopyStringPool( this, mappingTableStrings ) );
+ VH( pNewEffect->CopyTypePool( this, mappingTableTypes, mappingTableStrings ) );
+ }
+ else
+ {
+ // There's no string pool after optimizing. Let's re-create the type pool
+ VH( pNewEffect->CopyOptimizedTypePool( this, mappingTableTypes ) );
+ }
+
+ // fixup this effect's variable's types
+ VH( pNewEffect->OptimizeTypes(&mappingTableTypes, true) );
+ VH( pNewEffect->RecreateCBs() );
+
+
+ for (uint32_t i = 0; i < pNewEffect->m_pMemberInterfaces.GetSize(); ++ i)
+ {
+ SMember* pMember = pNewEffect->m_pMemberInterfaces[i];
+ VH( pNewEffect->FixupMemberInterface( pMember, this, mappingTableStrings ) );
+ }
+
+
+lExit:
+ SAFE_DELETE( pTempHeap );
+ if( FAILED( hr ) )
+ {
+ SAFE_DELETE( pNewEffect );
+ }
+ *ppClonedEffect = pNewEffect;
+ return hr;
+}
+
+// Move all type pointers using pMappingTable.
+// This is called after creating the optimized type pool or during cloning.
+HRESULT CEffect::OptimizeTypes(_Inout_ CPointerMappingTable *pMappingTable, _In_ bool Cloning)
+{
+ HRESULT hr = S_OK;
+
+ // find all child types, point them to the new location
+ for (size_t i = 0; i < m_VariableCount; ++ i)
+ {
+ VH( RemapType((SType**)&m_pVariables[i].pType, pMappingTable) );
+ }
+
+ uint32_t Members = m_pMemberInterfaces.GetSize();
+ for( size_t i=0; i < Members; i++ )
+ {
+ if( m_pMemberInterfaces[i] != nullptr )
+ {
+ VH( RemapType((SType**)&m_pMemberInterfaces[i]->pType, pMappingTable) );
+ }
+ }
+
+ // when cloning, there may be annotations
+ if( Cloning )
+ {
+ for (size_t iVar = 0; iVar < m_VariableCount; ++ iVar)
+ {
+ for(size_t i = 0; i < m_pVariables[iVar].AnnotationCount; ++ i )
+ {
+ VH( RemapType((SType**)&m_pVariables[iVar].pAnnotations[i].pType, pMappingTable) );
+ }
+ }
+ for (size_t iCB = 0; iCB < m_CBCount; ++ iCB)
+ {
+ for(size_t i = 0; i < m_pCBs[iCB].AnnotationCount; ++ i )
+ {
+ VH( RemapType((SType**)&m_pCBs[iCB].pAnnotations[i].pType, pMappingTable) );
+ }
+ }
+ for (size_t iGroup = 0; iGroup < m_GroupCount; ++ iGroup)
+ {
+ for(size_t i = 0; i < m_pGroups[iGroup].AnnotationCount; ++ i )
+ {
+ VH( RemapType((SType**)&m_pGroups[iGroup].pAnnotations[i].pType, pMappingTable) );
+ }
+ for(size_t iTech = 0; iTech < m_pGroups[iGroup].TechniqueCount; ++ iTech )
+ {
+ for(size_t i = 0; i < m_pGroups[iGroup].pTechniques[iTech].AnnotationCount; ++ i )
+ {
+ VH( RemapType((SType**)&m_pGroups[iGroup].pTechniques[iTech].pAnnotations[i].pType, pMappingTable) );
+ }
+ for(size_t iPass = 0; iPass < m_pGroups[iGroup].pTechniques[iTech].PassCount; ++ iPass )
+ {
+ for(size_t i = 0; i < m_pGroups[iGroup].pTechniques[iTech].pPasses[iPass].AnnotationCount; ++ i )
+ {
+ VH( RemapType((SType**)&m_pGroups[iGroup].pTechniques[iTech].pPasses[iPass].pAnnotations[i].pType, pMappingTable) );
+ }
+ }
+ }
+ }
+ }
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Public API to shed this effect of its reflection data
+
+HRESULT CEffect::Optimize()
+{
+ HRESULT hr = S_OK;
+ CEffectHeap *pOptimizedTypeHeap = nullptr;
+
+ if (IsOptimized())
+ {
+ DPF(0, "ID3DX11Effect::Optimize: Effect has already been Optimize()'ed");
+ return S_OK;
+ }
+
+ // Delete annotations, names, semantics, and string data on variables
+
+ for (size_t i = 0; i < m_VariableCount; ++ i)
+ {
+ m_pVariables[i].AnnotationCount = 0;
+ m_pVariables[i].pAnnotations = nullptr;
+ m_pVariables[i].pName = nullptr;
+ m_pVariables[i].pSemantic = nullptr;
+
+ // 2) Point string variables to nullptr
+ if (m_pVariables[i].pType->IsObjectType(EOT_String))
+ {
+ assert(nullptr != m_pVariables[i].Data.pString);
+ m_pVariables[i].Data.pString = nullptr;
+ }
+ }
+
+ // Delete annotations and names on CBs
+
+ for (size_t i = 0; i < m_CBCount; ++ i)
+ {
+ m_pCBs[i].AnnotationCount = 0;
+ m_pCBs[i].pAnnotations = nullptr;
+ m_pCBs[i].pName = nullptr;
+ m_pCBs[i].IsEffectOptimized = true;
+ }
+
+ // Delete annotations and names on techniques and passes
+
+ for (size_t i = 0; i < m_GroupCount; ++ i)
+ {
+ m_pGroups[i].AnnotationCount = 0;
+ m_pGroups[i].pAnnotations = nullptr;
+ m_pGroups[i].pName = nullptr;
+
+ for (size_t j = 0; j < m_pGroups[i].TechniqueCount; ++ j)
+ {
+ m_pGroups[i].pTechniques[j].AnnotationCount = 0;
+ m_pGroups[i].pTechniques[j].pAnnotations = nullptr;
+ m_pGroups[i].pTechniques[j].pName = nullptr;
+
+ for (size_t k = 0; k < m_pGroups[i].pTechniques[j].PassCount; ++ k)
+ {
+ m_pGroups[i].pTechniques[j].pPasses[k].AnnotationCount = 0;
+ m_pGroups[i].pTechniques[j].pPasses[k].pAnnotations = nullptr;
+ m_pGroups[i].pTechniques[j].pPasses[k].pName = nullptr;
+ }
+ }
+ };
+
+ // 2) Remove shader bytecode & stream out decls
+ // (all are contained within pReflectionData)
+
+ for (size_t i = 0; i < m_ShaderBlockCount; ++ i)
+ {
+ if( m_pShaderBlocks[i].pReflectionData )
+ {
+ // pReflection was not created with PRIVATENEW
+ SAFE_RELEASE( m_pShaderBlocks[i].pReflectionData->pReflection );
+
+ m_pShaderBlocks[i].pReflectionData = nullptr;
+ }
+ }
+
+ uint32_t Members = m_pMemberInterfaces.GetSize();
+ for( size_t i=0; i < Members; i++ )
+ {
+ assert( m_pMemberInterfaces[i] != nullptr );
+ if( IsReflectionData(m_pMemberInterfaces[i]->pTopLevelEntity) )
+ {
+ assert( IsReflectionData(m_pMemberInterfaces[i]->Data.pGeneric) );
+
+ // This is checked when cloning (so we don't clone Optimized-out member variables)
+ m_pMemberInterfaces[i] = nullptr;
+ }
+ else
+ {
+ m_pMemberInterfaces[i]->pName = nullptr;
+ m_pMemberInterfaces[i]->pSemantic = nullptr;
+ }
+ }
+
+
+
+ // get rid of the name/type hash tables and string data,
+ // then reallocate the type data and fix up this effect
+ CPointerMappingTable mappingTable;
+ CTypeHashTable::CIterator typeIter;
+ CPointerMappingTable::CIterator mapIter;
+ CCheckedDword chkSpaceNeeded = 0;
+ uint32_t spaceNeeded;
+
+ // first pass: compute needed space
+ for (m_pTypePool->GetFirstEntry(&typeIter); !m_pTypePool->PastEnd(&typeIter); m_pTypePool->GetNextEntry(&typeIter))
+ {
+ SType *pType = typeIter.GetData();
+
+ chkSpaceNeeded += AlignToPowerOf2(sizeof(SType), c_DataAlignment);
+
+ // if this is a struct, allocate room for its members
+ if (EVT_Struct == pType->VarType)
+ {
+ chkSpaceNeeded += AlignToPowerOf2(pType->StructType.Members * sizeof(SVariable), c_DataAlignment);
+ }
+ }
+
+ VH( chkSpaceNeeded.GetValue(&spaceNeeded) );
+
+ assert(nullptr == m_pOptimizedTypeHeap);
+ VN( pOptimizedTypeHeap = new CEffectHeap );
+ VH( pOptimizedTypeHeap->ReserveMemory(spaceNeeded));
+
+ // use the private heap that we're about to destroy as scratch space for the mapping table
+ mappingTable.SetPrivateHeap(m_pPooledHeap);
+ VH( mappingTable.AutoGrow() );
+
+ // second pass: move types over, build mapping table
+ for (m_pTypePool->GetFirstEntry(&typeIter); !m_pTypePool->PastEnd(&typeIter); m_pTypePool->GetNextEntry(&typeIter))
+ {
+ SPointerMapping ptrMapping;
+ SType *pType;
+
+ ptrMapping.pOld = ptrMapping.pNew = typeIter.GetData();
+ VH( pOptimizedTypeHeap->MoveData(&ptrMapping.pNew, sizeof(SType)) );
+
+ pType = (SType *) ptrMapping.pNew;
+
+ // if this is a struct, move its members to the newly allocated space
+ if (EVT_Struct == pType->VarType)
+ {
+ VH( pOptimizedTypeHeap->MoveData((void **)&pType->StructType.pMembers, pType->StructType.Members * sizeof(SVariable)) );
+ }
+
+ VH( mappingTable.AddValueWithHash(ptrMapping, ptrMapping.Hash()) );
+ }
+
+ // third pass: fixup structure member & name pointers
+ for (mappingTable.GetFirstEntry(&mapIter); !mappingTable.PastEnd(&mapIter); mappingTable.GetNextEntry(&mapIter))
+ {
+ SPointerMapping ptrMapping = mapIter.GetData();
+ SType *pType = (SType *) ptrMapping.pNew;
+
+ pType->pTypeName = nullptr;
+
+ // if this is a struct, fix up its members' pointers
+ if (EVT_Struct == pType->VarType)
+ {
+ for (size_t i = 0; i < pType->StructType.Members; ++ i)
+ {
+ VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTable) );
+ pType->StructType.pMembers[i].pName = nullptr;
+ pType->StructType.pMembers[i].pSemantic = nullptr;
+ }
+ }
+ }
+
+ // fixup this effect's variable's types
+ VH( OptimizeTypes(&mappingTable) );
+
+ m_pOptimizedTypeHeap = pOptimizedTypeHeap;
+ pOptimizedTypeHeap = nullptr;
+
+#ifdef D3DX11_FX_PRINT_HASH_STATS
+ DPF(0, "Compiler string pool hash table statistics:");
+ m_pTypePool->PrintHashTableStats();
+ DPF(0, "Compiler type pool hash table statistics:");
+ m_pStringPool->PrintHashTableStats();
+#endif // D3DX11_FX_PRINT_HASH_STATS
+
+ SAFE_DELETE(m_pTypePool);
+ SAFE_DELETE(m_pStringPool);
+ SAFE_DELETE(m_pPooledHeap);
+
+ DPF(0, "ID3DX11Effect::Optimize: %u bytes of reflection data freed.", m_pReflection->m_Heap.GetSize());
+ SAFE_DELETE(m_pReflection);
+ m_Flags |= D3DX11_EFFECT_OPTIMIZED;
+
+lExit:
+ SAFE_DELETE(pOptimizedTypeHeap);
+ return hr;
+}
+
+SMember * CreateNewMember(_In_ SType *pType, _In_ bool IsAnnotation)
+{
+ switch (pType->VarType)
+ {
+ case EVT_Struct:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SNumericAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SNumericAnnotationMember;
+ }
+ else if (pType->StructType.ImplementsInterface)
+ {
+ assert(sizeof(SClassInstanceGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SClassInstanceGlobalVariableMember;
+ }
+ else
+ {
+ assert(sizeof(SNumericGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SNumericGlobalVariableMember;
+ }
+ break;
+ case EVT_Interface:
+ assert(sizeof(SInterfaceGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SInterfaceGlobalVariableMember;
+ break;
+ case EVT_Object:
+ switch (pType->ObjectType)
+ {
+ case EOT_String:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SStringAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SStringAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SStringGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SStringGlobalVariableMember;
+ }
+
+ break;
+ case EOT_Texture:
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ case EOT_Texture3D:
+ case EOT_TextureCube:
+ case EOT_TextureCubeArray:
+ case EOT_Buffer:
+ case EOT_ByteAddressBuffer:
+ case EOT_StructuredBuffer:
+ assert(!IsAnnotation);
+ assert(sizeof(SShaderResourceGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SShaderResourceGlobalVariableMember;
+ break;
+ case EOT_RWTexture1D:
+ case EOT_RWTexture1DArray:
+ case EOT_RWTexture2D:
+ case EOT_RWTexture2DArray:
+ case EOT_RWTexture3D:
+ case EOT_RWBuffer:
+ case EOT_RWByteAddressBuffer:
+ case EOT_RWStructuredBuffer:
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ case EOT_AppendStructuredBuffer:
+ case EOT_ConsumeStructuredBuffer:
+ assert(!IsAnnotation);
+ assert(sizeof(SUnorderedAccessViewGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SUnorderedAccessViewGlobalVariableMember;
+ break;
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ case EOT_GeometryShader:
+ case EOT_GeometryShaderSO:
+ case EOT_GeometryShader5:
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ case EOT_HullShader5:
+ case EOT_DomainShader5:
+ case EOT_ComputeShader5:
+ assert(!IsAnnotation);
+ assert(sizeof(SShaderGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SShaderGlobalVariableMember;
+ break;
+ case EOT_Blend:
+ assert(!IsAnnotation);
+ assert(sizeof(SBlendGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SBlendGlobalVariableMember;
+ break;
+ case EOT_Rasterizer:
+ assert(!IsAnnotation);
+ assert(sizeof(SRasterizerGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SRasterizerGlobalVariableMember;
+ break;
+ case EOT_DepthStencil:
+ assert(!IsAnnotation);
+ assert(sizeof(SDepthStencilGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SDepthStencilGlobalVariableMember;
+ break;
+ case EOT_Sampler:
+ assert(!IsAnnotation);
+ assert(sizeof(SSamplerGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SSamplerGlobalVariableMember;
+ break;
+ case EOT_DepthStencilView:
+ assert(!IsAnnotation);
+ assert(sizeof(SDepthStencilViewGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SDepthStencilViewGlobalVariableMember;
+ break;
+ case EOT_RenderTargetView:
+ assert(!IsAnnotation);
+ assert(sizeof(SRenderTargetViewGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SRenderTargetViewGlobalVariableMember;
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal error: invalid object type." );
+ return nullptr;
+ break;
+ }
+ break;
+ case EVT_Numeric:
+ switch (pType->NumericType.NumericLayout)
+ {
+ case ENL_Matrix:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SMatrixAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SMatrixAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SMatrixGlobalVariableMember) == sizeof(SMember));
+ assert(sizeof(SMatrix4x4ColumnMajorGlobalVariableMember) == sizeof(SMember));
+ assert(sizeof(SMatrix4x4RowMajorGlobalVariableMember) == sizeof(SMember));
+
+ if (pType->NumericType.Rows == 4 && pType->NumericType.Columns == 4)
+ {
+ if (pType->NumericType.IsColumnMajor)
+ {
+ return (SMember*) new SMatrix4x4ColumnMajorGlobalVariableMember;
+ }
+ else
+ {
+ return (SMember*) new SMatrix4x4RowMajorGlobalVariableMember;
+ }
+ }
+ else
+ {
+ return (SMember*) new SMatrixGlobalVariableMember;
+ }
+ }
+ break;
+ case ENL_Vector:
+ switch (pType->NumericType.ScalarType)
+ {
+ case EST_Float:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SFloatVectorAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SFloatVectorAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SFloatVectorGlobalVariableMember) == sizeof(SMember));
+ assert(sizeof(SFloatVector4GlobalVariableMember) == sizeof(SMember));
+
+ if (pType->NumericType.Columns == 4)
+ {
+ return (SMember*) new SFloatVector4GlobalVariableMember;
+ }
+ else
+ {
+ return (SMember*) new SFloatVectorGlobalVariableMember;
+ }
+ }
+ break;
+ case EST_Bool:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SBoolVectorAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SBoolVectorAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SBoolVectorGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SBoolVectorGlobalVariableMember;
+ }
+ break;
+ case EST_UInt:
+ case EST_Int:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SIntVectorAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SIntVectorAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SIntVectorGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SIntVectorGlobalVariableMember;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid vector type." );
+ break;
+ }
+ break;
+ case ENL_Scalar:
+ switch (pType->NumericType.ScalarType)
+ {
+ case EST_Float:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SFloatScalarAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SFloatScalarAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SFloatScalarGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SFloatScalarGlobalVariableMember;
+ }
+ break;
+ case EST_UInt:
+ case EST_Int:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SIntScalarAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SIntScalarAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SIntScalarGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SIntScalarGlobalVariableMember;
+ }
+ break;
+ case EST_Bool:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SBoolScalarAnnotationMember) == sizeof(SMember));
+ return (SMember*) new SBoolScalarAnnotationMember;
+ }
+ else
+ {
+ assert(sizeof(SBoolScalarGlobalVariableMember) == sizeof(SMember));
+ return (SMember*) new SBoolScalarGlobalVariableMember;
+ }
+ break;
+ default:
+ DPF( 0, "Internal loading error: invalid scalar type." );
+ assert(0);
+ break;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid numeric type." );
+ break;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid variable type." );
+ break;
+ }
+ return nullptr;
+}
+
+// Global variables are created in place because storage for them was allocated during LoadEffect
+HRESULT PlacementNewVariable(_In_ void *pVar, _In_ SType *pType, _In_ bool IsAnnotation)
+{
+ switch (pType->VarType)
+ {
+ case EVT_Struct:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SNumericAnnotation) == sizeof(SAnnotation));
+ new(pVar) SNumericAnnotation();
+ }
+ else if (pType->StructType.ImplementsInterface)
+ {
+ assert(sizeof(SClassInstanceGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SClassInstanceGlobalVariable;
+ }
+ else
+ {
+ assert(sizeof(SNumericGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SNumericGlobalVariable;
+ }
+ break;
+ case EVT_Interface:
+ assert(sizeof(SInterfaceGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SInterfaceGlobalVariable;
+ break;
+ case EVT_Object:
+ switch (pType->ObjectType)
+ {
+ case EOT_String:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SStringAnnotation) == sizeof(SAnnotation));
+ new(pVar) SStringAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SStringGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SStringGlobalVariable;
+ }
+
+ break;
+ case EOT_Texture:
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ case EOT_Texture3D:
+ case EOT_TextureCube:
+ case EOT_TextureCubeArray:
+ case EOT_Buffer:
+ case EOT_ByteAddressBuffer:
+ case EOT_StructuredBuffer:
+ assert(!IsAnnotation);
+ assert(sizeof(SShaderResourceGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SShaderResourceGlobalVariable;
+ break;
+ case EOT_RWTexture1D:
+ case EOT_RWTexture1DArray:
+ case EOT_RWTexture2D:
+ case EOT_RWTexture2DArray:
+ case EOT_RWTexture3D:
+ case EOT_RWBuffer:
+ case EOT_RWByteAddressBuffer:
+ case EOT_RWStructuredBuffer:
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ case EOT_AppendStructuredBuffer:
+ case EOT_ConsumeStructuredBuffer:
+ assert(!IsAnnotation);
+ assert(sizeof(SUnorderedAccessViewGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SUnorderedAccessViewGlobalVariable;
+ break;
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ case EOT_GeometryShader:
+ case EOT_GeometryShaderSO:
+ case EOT_GeometryShader5:
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ case EOT_HullShader5:
+ case EOT_DomainShader5:
+ case EOT_ComputeShader5:
+ assert(!IsAnnotation);
+ assert(sizeof(SShaderGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SShaderGlobalVariable;
+ break;
+ case EOT_Blend:
+ assert(!IsAnnotation);
+ assert(sizeof(SBlendGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SBlendGlobalVariable;
+ break;
+ case EOT_Rasterizer:
+ assert(!IsAnnotation);
+ assert(sizeof(SRasterizerGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SRasterizerGlobalVariable;
+ break;
+ case EOT_DepthStencil:
+ assert(!IsAnnotation);
+ assert(sizeof(SDepthStencilGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SDepthStencilGlobalVariable;
+ break;
+ case EOT_Sampler:
+ assert(!IsAnnotation);
+ assert(sizeof(SSamplerGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SSamplerGlobalVariable;
+ break;
+ case EOT_RenderTargetView:
+ assert(!IsAnnotation);
+ assert(sizeof(SRenderTargetViewGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SRenderTargetViewGlobalVariable;
+ break;
+ case EOT_DepthStencilView:
+ assert(!IsAnnotation);
+ assert(sizeof(SDepthStencilViewGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SDepthStencilViewGlobalVariable;
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid object type." );
+ return E_FAIL;
+ break;
+ }
+ break;
+ case EVT_Numeric:
+ switch (pType->NumericType.NumericLayout)
+ {
+ case ENL_Matrix:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SMatrixAnnotation) == sizeof(SAnnotation));
+ new(pVar) SMatrixAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SMatrixGlobalVariable) == sizeof(SGlobalVariable));
+ assert(sizeof(SMatrix4x4ColumnMajorGlobalVariable) == sizeof(SGlobalVariable));
+ assert(sizeof(SMatrix4x4RowMajorGlobalVariable) == sizeof(SGlobalVariable));
+
+ if (pType->NumericType.Rows == 4 && pType->NumericType.Columns == 4)
+ {
+ if (pType->NumericType.IsColumnMajor)
+ {
+ new(pVar) SMatrix4x4ColumnMajorGlobalVariable;
+ }
+ else
+ {
+ new(pVar) SMatrix4x4RowMajorGlobalVariable;
+ }
+ }
+ else
+ {
+ new(pVar) SMatrixGlobalVariable;
+ }
+ }
+ break;
+ case ENL_Vector:
+ switch (pType->NumericType.ScalarType)
+ {
+ case EST_Float:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SFloatVectorAnnotation) == sizeof(SAnnotation));
+ new(pVar) SFloatVectorAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SFloatVectorGlobalVariable) == sizeof(SGlobalVariable));
+ assert(sizeof(SFloatVector4GlobalVariable) == sizeof(SGlobalVariable));
+
+ if (pType->NumericType.Columns == 4)
+ {
+ new(pVar) SFloatVector4GlobalVariable;
+ }
+ else
+ {
+ new(pVar) SFloatVectorGlobalVariable;
+ }
+ }
+ break;
+ case EST_Bool:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SBoolVectorAnnotation) == sizeof(SAnnotation));
+ new(pVar) SBoolVectorAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SBoolVectorGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SBoolVectorGlobalVariable;
+ }
+ break;
+ case EST_UInt:
+ case EST_Int:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SIntVectorAnnotation) == sizeof(SAnnotation));
+ new(pVar) SIntVectorAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SIntVectorGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SIntVectorGlobalVariable;
+ }
+ break;
+ }
+ break;
+ case ENL_Scalar:
+ switch (pType->NumericType.ScalarType)
+ {
+ case EST_Float:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SFloatScalarAnnotation) == sizeof(SAnnotation));
+ new(pVar) SFloatScalarAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SFloatScalarGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SFloatScalarGlobalVariable;
+ }
+ break;
+ case EST_UInt:
+ case EST_Int:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SIntScalarAnnotation) == sizeof(SAnnotation));
+ new(pVar) SIntScalarAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SIntScalarGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SIntScalarGlobalVariable;
+ }
+ break;
+ case EST_Bool:
+ if (IsAnnotation)
+ {
+ assert(sizeof(SBoolScalarAnnotation) == sizeof(SAnnotation));
+ new(pVar) SBoolScalarAnnotation;
+ }
+ else
+ {
+ assert(sizeof(SBoolScalarGlobalVariable) == sizeof(SGlobalVariable));
+ new(pVar) SBoolScalarGlobalVariable;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid scalar type." );
+ return E_FAIL;
+ break;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid numeric type." );
+ return E_FAIL;
+ break;
+ }
+ break;
+ default:
+ assert(0);
+ DPF( 0, "Internal loading error: invalid variable type." );
+ return E_FAIL;
+ break;
+ }
+ return S_OK;
+}
+
+}
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectReflection.cpp
+//
+// Direct3D 11 Effects public reflection APIs
+//
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+
+namespace D3DX11Effects
+{
+
+SEffectInvalidType g_InvalidType;
+
+SEffectInvalidScalarVariable g_InvalidScalarVariable;
+SEffectInvalidVectorVariable g_InvalidVectorVariable;
+SEffectInvalidMatrixVariable g_InvalidMatrixVariable;
+SEffectInvalidStringVariable g_InvalidStringVariable;
+SEffectInvalidClassInstanceVariable g_InvalidClassInstanceVariable;
+SEffectInvalidInterfaceVariable g_InvalidInterfaceVariable;
+SEffectInvalidShaderResourceVariable g_InvalidShaderResourceVariable;
+SEffectInvalidUnorderedAccessViewVariable g_InvalidUnorderedAccessViewVariable;
+SEffectInvalidRenderTargetViewVariable g_InvalidRenderTargetViewVariable;
+SEffectInvalidDepthStencilViewVariable g_InvalidDepthStencilViewVariable;
+SEffectInvalidConstantBuffer g_InvalidConstantBuffer;
+SEffectInvalidShaderVariable g_InvalidShaderVariable;
+SEffectInvalidBlendVariable g_InvalidBlendVariable;
+SEffectInvalidDepthStencilVariable g_InvalidDepthStencilVariable;
+SEffectInvalidRasterizerVariable g_InvalidRasterizerVariable;
+SEffectInvalidSamplerVariable g_InvalidSamplerVariable;
+
+SEffectInvalidPass g_InvalidPass;
+SEffectInvalidTechnique g_InvalidTechnique;
+SEffectInvalidGroup g_InvalidGroup;
+
+
+//////////////////////////////////////////////////////////////////////////
+// Helper routine implementations
+//////////////////////////////////////////////////////////////////////////
+
+ID3DX11EffectConstantBuffer * NoParentCB()
+{
+ DPF(0, "ID3DX11EffectVariable::GetParentConstantBuffer: Variable does not have a parent constant buffer");
+ // have to typecast because the type of g_InvalidScalarVariable has not been declared yet
+ return &g_InvalidConstantBuffer;
+}
+
+_Use_decl_annotations_
+ID3DX11EffectVariable * GetAnnotationByIndexHelper(const char *pClassName, uint32_t Index, uint32_t AnnotationCount, SAnnotation *pAnnotations)
+{
+ if (Index >= AnnotationCount)
+ {
+ DPF(0, "%s::GetAnnotationByIndex: Invalid index (%u, total: %u)", pClassName, Index, AnnotationCount);
+ return &g_InvalidScalarVariable;
+ }
+
+ return pAnnotations + Index;
+}
+
+_Use_decl_annotations_
+ID3DX11EffectVariable * GetAnnotationByNameHelper(const char *pClassName, LPCSTR Name, uint32_t AnnotationCount, SAnnotation *pAnnotations)
+{
+ uint32_t i;
+ for (i = 0; i < AnnotationCount; ++ i)
+ {
+ if (strcmp(pAnnotations[i].pName, Name) == 0)
+ {
+ return pAnnotations + i;
+ }
+ }
+
+ DPF(0, "%s::GetAnnotationByName: Annotation [%s] not found", pClassName, Name);
+ return &g_InvalidScalarVariable;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Effect routines to pool interfaces
+//////////////////////////////////////////////////////////////////////////
+
+ID3DX11EffectType * CEffect::CreatePooledSingleElementTypeInterface(_In_ SType *pType)
+{
+ if (IsOptimized())
+ {
+ DPF(0, "ID3DX11Effect: Cannot create new type interfaces since the effect has been Optimize()'ed");
+ return &g_InvalidType;
+ }
+
+ for (size_t i = 0; i < m_pTypeInterfaces.GetSize(); ++ i)
+ {
+ if (m_pTypeInterfaces[i]->pType == pType)
+ {
+ return (SSingleElementType*)m_pTypeInterfaces[i];
+ }
+ }
+ SSingleElementType *pNewType;
+ if (nullptr == (pNewType = new SSingleElementType))
+ {
+ DPF(0, "ID3DX11Effect: Out of memory while trying to create new type interface");
+ return &g_InvalidType;
+ }
+
+ pNewType->pType = pType;
+ m_pTypeInterfaces.Add(pNewType);
+
+ return pNewType;
+}
+
+// Create a member variable (via GetMemberBy* or GetElement)
+_Use_decl_annotations_
+ID3DX11EffectVariable * CEffect::CreatePooledVariableMemberInterface(TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity,
+ const SVariable *pMember,
+ const UDataPointer Data, bool IsSingleElement, uint32_t Index)
+{
+ bool IsAnnotation;
+
+ if (IsOptimized())
+ {
+ DPF(0, "ID3DX11Effect: Cannot create new variable interfaces since the effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ for (size_t i = 0; i < m_pMemberInterfaces.GetSize(); ++ i)
+ {
+ if (m_pMemberInterfaces[i]->pType == pMember->pType &&
+ m_pMemberInterfaces[i]->pName == pMember->pName &&
+ m_pMemberInterfaces[i]->pSemantic == pMember->pSemantic &&
+ m_pMemberInterfaces[i]->Data.pGeneric == Data.pGeneric &&
+ m_pMemberInterfaces[i]->IsSingleElement == (uint32_t)IsSingleElement &&
+ ((SMember*)m_pMemberInterfaces[i])->pTopLevelEntity == pTopLevelEntity)
+ {
+ return (ID3DX11EffectVariable *) m_pMemberInterfaces[i];
+ }
+ }
+
+ // is this annotation or runtime data?
+ if( pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity) )
+ {
+ assert( pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric) );
+ IsAnnotation = true;
+ }
+ else
+ {
+ // if the heap is empty, we are still loading the Effect, and thus creating a member for a variable initializer
+ // ex. Interface myInt = myClassArray[2];
+ if( pTopLevelEntity->pEffect->m_Heap.GetSize() > 0 )
+ {
+ assert( pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity) );
+ if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
+ {
+ // strings are funny; their data is reflection data, so ignore those
+ assert( pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric) );
+ }
+ }
+ IsAnnotation = false;
+ }
+
+ SMember *pNewMember;
+
+ if (nullptr == (pNewMember = CreateNewMember((SType*)pMember->pType, IsAnnotation)))
+ {
+ DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");
+ return &g_InvalidScalarVariable;
+ }
+
+ pNewMember->pType = pMember->pType;
+ pNewMember->pName = pMember->pName;
+ pNewMember->pSemantic = pMember->pSemantic;
+ pNewMember->Data.pGeneric = Data.pGeneric;
+ pNewMember->IsSingleElement = IsSingleElement;
+ pNewMember->pTopLevelEntity = pTopLevelEntity;
+
+ if( IsSingleElement && pMember->pMemberData )
+ {
+ assert( !IsAnnotation );
+ // This is an element of a global variable array
+ pNewMember->pMemberData = pMember->pMemberData + Index;
+ }
+
+ if (FAILED(m_pMemberInterfaces.Add(pNewMember)))
+ {
+ SAFE_DELETE(pNewMember);
+ DPF(0, "ID3DX11Effect: Out of memory while trying to create new member variable interface");
+ return &g_InvalidScalarVariable;
+ }
+
+ return (ID3DX11EffectVariable *) pNewMember;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectType (SType, SSingleElementType implementations)
+//////////////////////////////////////////////////////////////////////////
+
+static ID3DX11EffectType * GetTypeByIndexHelper(uint32_t Index, uint32_t VariableCount,
+ SVariable *pVariables, uint32_t SizeOfVariableType)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByIndex";
+
+ if (Index >= VariableCount)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, VariableCount);
+ return &g_InvalidType;
+ }
+
+ SVariable *pVariable = (SVariable *)((uint8_t *)pVariables + Index * SizeOfVariableType);
+ if (nullptr == pVariable->pName)
+ {
+ DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidType;
+ }
+
+ return (ID3DX11EffectType *) pVariable->pType;
+}
+
+static ID3DX11EffectType * GetTypeByNameHelper(LPCSTR Name, uint32_t VariableCount,
+ SVariable *pVariables, uint32_t SizeOfVariableType)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByName";
+
+ if (nullptr == Name)
+ {
+ DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
+ return &g_InvalidType;
+ }
+
+ uint32_t i;
+ SVariable *pVariable;
+
+ for (i = 0; i < VariableCount; ++ i)
+ {
+ pVariable = (SVariable *)((uint8_t *)pVariables + i * SizeOfVariableType);
+ if (nullptr == pVariable->pName)
+ {
+ DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidType;
+ }
+ if (strcmp(pVariable->pName, Name) == 0)
+ {
+ return (ID3DX11EffectType *) pVariable->pType;
+ }
+ }
+
+ DPF(0, "%s: Member type [%s] not found", pFuncName, Name);
+ return &g_InvalidType;
+}
+
+
+static ID3DX11EffectType * GetTypeBySemanticHelper(LPCSTR Semantic, uint32_t VariableCount,
+ SVariable *pVariables, uint32_t SizeOfVariableType)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeBySemantic";
+
+ if (nullptr == Semantic)
+ {
+ DPF(0, "%s: Parameter Semantic was nullptr.", pFuncName);
+ return &g_InvalidType;
+ }
+
+ uint32_t i;
+ SVariable *pVariable;
+
+ for (i = 0; i < VariableCount; ++ i)
+ {
+ pVariable = (SVariable *)((uint8_t *)pVariables + i * SizeOfVariableType);
+ if (nullptr == pVariable->pName)
+ {
+ DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidType;
+ }
+ if (nullptr != pVariable->pSemantic &&
+ _stricmp(pVariable->pSemantic, Semantic) == 0)
+ {
+ return (ID3DX11EffectType *) pVariable->pType;
+ }
+ }
+
+ DPF(0, "%s: Member type with semantic [%s] not found", pFuncName, Semantic);
+ return &g_InvalidType;
+}
+
+ID3DX11EffectType * SType::GetMemberTypeByIndex(_In_ uint32_t Index)
+{
+ if (VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectType::GetMemberTypeByIndex: This interface does not refer to a structure");
+ return &g_InvalidType;
+ }
+
+ return GetTypeByIndexHelper(Index, StructType.Members, StructType.pMembers, sizeof(SVariable));
+}
+
+ID3DX11EffectType * SType::GetMemberTypeByName(_In_z_ LPCSTR Name)
+{
+ if (VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectType::GetMemberTypeByName: This interface does not refer to a structure");
+ return &g_InvalidType;
+ }
+
+ return GetTypeByNameHelper(Name, StructType.Members, StructType.pMembers, sizeof(SVariable));
+}
+
+ID3DX11EffectType * SType::GetMemberTypeBySemantic(_In_z_ LPCSTR Semantic)
+{
+ if (VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectType::GetMemberTypeBySemantic: This interface does not refer to a structure");
+ return &g_InvalidType;
+ }
+
+ return GetTypeBySemanticHelper(Semantic, StructType.Members, StructType.pMembers, sizeof(SVariable));
+}
+
+LPCSTR SType::GetMemberName(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";
+
+ if (VarType != EVT_Struct)
+ {
+ DPF(0, "%s: This interface does not refer to a structure", pFuncName);
+ return nullptr;
+ }
+
+ if (Index >= StructType.Members)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, StructType.Members);
+ return nullptr;
+ }
+
+ SVariable *pVariable = StructType.pMembers + Index;
+
+ if (nullptr == pVariable->pName)
+ {
+ DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);
+ return nullptr;
+ }
+
+ return pVariable->pName;
+}
+
+LPCSTR SType::GetMemberSemantic(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";
+
+ if (VarType != EVT_Struct)
+ {
+ DPF(0, "%s: This interface does not refer to a structure", pFuncName);
+ return nullptr;
+ }
+
+ if (Index >= StructType.Members)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, StructType.Members);
+ return nullptr;
+ }
+
+ SVariable *pVariable = StructType.pMembers + Index;
+
+ if (nullptr == pVariable->pName)
+ {
+ DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);
+ return nullptr;
+ }
+
+ return pVariable->pSemantic;
+}
+
+HRESULT SType::GetDescHelper(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc, _In_ bool IsSingleElement) const
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetDesc";
+
+ VERIFYPARAMETER(pDesc);
+
+ pDesc->TypeName = pTypeName;
+
+ // intentionally return 0 so they know it's not a single element array
+ pDesc->Elements = IsSingleElement ? 0 : Elements;
+ pDesc->PackedSize = GetTotalPackedSize(IsSingleElement);
+ pDesc->UnpackedSize = GetTotalUnpackedSize(IsSingleElement);
+ pDesc->Stride = Stride;
+
+ switch (VarType)
+ {
+ case EVT_Numeric:
+ switch (NumericType.NumericLayout)
+ {
+ case ENL_Matrix:
+ if (NumericType.IsColumnMajor)
+ {
+ pDesc->Class = D3D_SVC_MATRIX_COLUMNS;
+ }
+ else
+ {
+ pDesc->Class = D3D_SVC_MATRIX_ROWS;
+ }
+ break;
+ case ENL_Vector:
+ pDesc->Class = D3D_SVC_VECTOR;
+ break;
+ case ENL_Scalar:
+ pDesc->Class = D3D_SVC_SCALAR;
+ break;
+ default:
+ assert(0);
+ }
+
+ switch (NumericType.ScalarType)
+ {
+ case EST_Bool:
+ pDesc->Type = D3D_SVT_BOOL;
+ break;
+ case EST_Int:
+ pDesc->Type = D3D_SVT_INT;
+ break;
+ case EST_UInt:
+ pDesc->Type = D3D_SVT_UINT;
+ break;
+ case EST_Float:
+ pDesc->Type = D3D_SVT_FLOAT;
+ break;
+ default:
+ assert(0);
+ }
+
+ pDesc->Rows = NumericType.Rows;
+ pDesc->Columns = NumericType.Columns;
+ pDesc->Members = 0;
+
+ break;
+
+ case EVT_Struct:
+ pDesc->Rows = 0;
+ pDesc->Columns = 0;
+ pDesc->Members = StructType.Members;
+ if( StructType.ImplementsInterface )
+ {
+ pDesc->Class = D3D_SVC_INTERFACE_CLASS;
+ }
+ else
+ {
+ pDesc->Class = D3D_SVC_STRUCT;
+ }
+ pDesc->Type = D3D_SVT_VOID;
+ break;
+
+ case EVT_Interface:
+ pDesc->Rows = 0;
+ pDesc->Columns = 0;
+ pDesc->Members = 0;
+ pDesc->Class = D3D_SVC_INTERFACE_POINTER;
+ pDesc->Type = D3D_SVT_INTERFACE_POINTER;
+ break;
+
+ case EVT_Object:
+ pDesc->Rows = 0;
+ pDesc->Columns = 0;
+ pDesc->Members = 0;
+ pDesc->Class = D3D_SVC_OBJECT;
+
+ switch (ObjectType)
+ {
+ case EOT_String:
+ pDesc->Type = D3D_SVT_STRING;
+ break;
+ case EOT_Blend:
+ pDesc->Type = D3D_SVT_BLEND;
+ break;
+ case EOT_DepthStencil:
+ pDesc->Type = D3D_SVT_DEPTHSTENCIL;
+ break;
+ case EOT_Rasterizer:
+ pDesc->Type = D3D_SVT_RASTERIZER;
+ break;
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ pDesc->Type = D3D_SVT_PIXELSHADER;
+ break;
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ pDesc->Type = D3D_SVT_VERTEXSHADER;
+ break;
+ case EOT_GeometryShader:
+ case EOT_GeometryShaderSO:
+ case EOT_GeometryShader5:
+ pDesc->Type = D3D_SVT_GEOMETRYSHADER;
+ break;
+ case EOT_HullShader5:
+ pDesc->Type = D3D_SVT_HULLSHADER;
+ break;
+ case EOT_DomainShader5:
+ pDesc->Type = D3D_SVT_DOMAINSHADER;
+ break;
+ case EOT_ComputeShader5:
+ pDesc->Type = D3D_SVT_COMPUTESHADER;
+ break;
+ case EOT_Texture:
+ pDesc->Type = D3D_SVT_TEXTURE;
+ break;
+ case EOT_Texture1D:
+ pDesc->Type = D3D_SVT_TEXTURE1D;
+ break;
+ case EOT_Texture1DArray:
+ pDesc->Type = D3D_SVT_TEXTURE1DARRAY;
+ break;
+ case EOT_Texture2D:
+ pDesc->Type = D3D_SVT_TEXTURE2D;
+ break;
+ case EOT_Texture2DArray:
+ pDesc->Type = D3D_SVT_TEXTURE2DARRAY;
+ break;
+ case EOT_Texture2DMS:
+ pDesc->Type = D3D_SVT_TEXTURE2DMS;
+ break;
+ case EOT_Texture2DMSArray:
+ pDesc->Type = D3D_SVT_TEXTURE2DMSARRAY;
+ break;
+ case EOT_Texture3D:
+ pDesc->Type = D3D_SVT_TEXTURE3D;
+ break;
+ case EOT_TextureCube:
+ pDesc->Type = D3D_SVT_TEXTURECUBE;
+ break;
+ case EOT_TextureCubeArray:
+ pDesc->Type = D3D_SVT_TEXTURECUBEARRAY;
+ break;
+ case EOT_Buffer:
+ pDesc->Type = D3D_SVT_BUFFER;
+ break;
+ case EOT_Sampler:
+ pDesc->Type = D3D_SVT_SAMPLER;
+ break;
+ case EOT_RenderTargetView:
+ pDesc->Type = D3D_SVT_RENDERTARGETVIEW;
+ break;
+ case EOT_DepthStencilView:
+ pDesc->Type = D3D_SVT_DEPTHSTENCILVIEW;
+ break;
+ case EOT_RWTexture1D:
+ pDesc->Type = D3D_SVT_RWTEXTURE1D;
+ break;
+ case EOT_RWTexture1DArray:
+ pDesc->Type = D3D_SVT_RWTEXTURE1DARRAY;
+ break;
+ case EOT_RWTexture2D:
+ pDesc->Type = D3D_SVT_RWTEXTURE2D;
+ break;
+ case EOT_RWTexture2DArray:
+ pDesc->Type = D3D_SVT_RWTEXTURE2DARRAY;
+ break;
+ case EOT_RWTexture3D:
+ pDesc->Type = D3D_SVT_RWTEXTURE3D;
+ break;
+ case EOT_RWBuffer:
+ pDesc->Type = D3D_SVT_RWBUFFER;
+ break;
+ case EOT_ByteAddressBuffer:
+ pDesc->Type = D3D_SVT_BYTEADDRESS_BUFFER;
+ break;
+ case EOT_RWByteAddressBuffer:
+ pDesc->Type = D3D_SVT_RWBYTEADDRESS_BUFFER;
+ break;
+ case EOT_StructuredBuffer:
+ pDesc->Type = D3D_SVT_STRUCTURED_BUFFER;
+ break;
+ case EOT_RWStructuredBuffer:
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ pDesc->Type = D3D_SVT_RWSTRUCTURED_BUFFER;
+ break;
+ case EOT_AppendStructuredBuffer:
+ pDesc->Type = D3D_SVT_APPEND_STRUCTURED_BUFFER;
+ break;
+ case EOT_ConsumeStructuredBuffer:
+ pDesc->Type = D3D_SVT_CONSUME_STRUCTURED_BUFFER;
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+
+lExit:
+ return hr;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderVariable (SAnonymousShader implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+SAnonymousShader::SAnonymousShader(_In_ SShaderBlock *pBlock) : pShaderBlock(pBlock)
+{
+}
+
+bool SAnonymousShader::IsValid()
+{
+ return pShaderBlock && pShaderBlock->IsValid;
+}
+
+ID3DX11EffectType * SAnonymousShader::GetType()
+{
+ return (ID3DX11EffectType *) this;
+}
+
+HRESULT SAnonymousShader::GetDesc(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc)
+{
+ pDesc->Annotations = 0;
+ pDesc->Flags = 0;
+
+ pDesc->Name = "$Anonymous";
+ pDesc->Semantic = nullptr;
+ pDesc->BufferOffset = 0;
+
+ return S_OK;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByIndex(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectVariable::GetAnnotationByIndex: Anonymous shaders cannot have annotations");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByName(_In_z_ LPCSTR Name)
+{
+ UNREFERENCED_PARAMETER(Name);
+ DPF(0, "ID3DX11EffectVariable::GetAnnotationByName: Anonymous shaders cannot have annotations");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetMemberByIndex(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetMemberByName(_In_z_ LPCSTR Name)
+{
+ UNREFERENCED_PARAMETER(Name);
+ DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetMemberBySemantic(_In_z_ LPCSTR Semantic)
+{
+ UNREFERENCED_PARAMETER(Semantic);
+ DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * SAnonymousShader::GetElement(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectVariable::GetElement: Anonymous shaders cannot have elements");
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectConstantBuffer * SAnonymousShader::GetParentConstantBuffer()
+{
+ return NoParentCB();
+}
+
+ID3DX11EffectShaderVariable * SAnonymousShader::AsShader()
+{
+ return (ID3DX11EffectShaderVariable *) this;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::SetRawValue(const void *pData, uint32_t Offset, uint32_t Count)
+{
+ UNREFERENCED_PARAMETER(pData);
+ UNREFERENCED_PARAMETER(Offset);
+ UNREFERENCED_PARAMETER(Count);
+ return ObjectSetRawValue();
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetRawValue(void *pData, uint32_t Offset, uint32_t Count)
+{
+ UNREFERENCED_PARAMETER(pData);
+ UNREFERENCED_PARAMETER(Offset);
+ UNREFERENCED_PARAMETER(Count);
+ return ObjectGetRawValue();
+}
+
+#define ANONYMOUS_SHADER_INDEX_CHECK() \
+ HRESULT hr = S_OK; \
+ if (0 != ShaderIndex) \
+ { \
+ DPF(0, "%s: Invalid index specified", pFuncName); \
+ VH(E_INVALIDARG); \
+ } \
+
+HRESULT SAnonymousShader::GetShaderDesc(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ hr = pShaderBlock->GetShaderDesc(pDesc, true);
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetVertexShader(uint32_t ShaderIndex, ID3D11VertexShader **ppVS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetVertexShader(ppVS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetGeometryShader(uint32_t ShaderIndex, ID3D11GeometryShader **ppGS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetGeometryShader(ppGS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetPixelShader(uint32_t ShaderIndex, ID3D11PixelShader **ppPS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetPixelShader(ppPS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetHullShader(uint32_t ShaderIndex, ID3D11HullShader **ppHS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetHullShader(ppHS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetDomainShader(uint32_t ShaderIndex, ID3D11DomainShader **ppDS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetDomainShader(ppDS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetComputeShader(uint32_t ShaderIndex, ID3D11ComputeShader **ppCS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetComputeShader(ppCS) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetInputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetOutputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SAnonymousShader::GetPatchConstantSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
+
+ ANONYMOUS_SHADER_INDEX_CHECK();
+
+ VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+HRESULT SAnonymousShader::GetDesc(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc)
+{
+ pDesc->Class = D3D_SVC_OBJECT;
+
+ switch (pShaderBlock->GetShaderType())
+ {
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ pDesc->TypeName = "vertexshader";
+ pDesc->Type = D3D_SVT_VERTEXSHADER;
+ break;
+ case EOT_GeometryShader:
+ case EOT_GeometryShader5:
+ pDesc->TypeName = "geometryshader";
+ pDesc->Type = D3D_SVT_GEOMETRYSHADER;
+ break;
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ pDesc->TypeName = "pixelshader";
+ pDesc->Type = D3D_SVT_PIXELSHADER;
+ break;
+ case EOT_HullShader5:
+ pDesc->TypeName = "Hullshader";
+ pDesc->Type = D3D_SVT_HULLSHADER;
+ break;
+ case EOT_DomainShader5:
+ pDesc->TypeName = "Domainshader";
+ pDesc->Type = D3D_SVT_DOMAINSHADER;
+ break;
+ case EOT_ComputeShader5:
+ pDesc->TypeName = "Computeshader";
+ pDesc->Type = D3D_SVT_COMPUTESHADER;
+ break;
+ }
+
+ pDesc->Elements = 0;
+ pDesc->Members = 0;
+ pDesc->Rows = 0;
+ pDesc->Columns = 0;
+ pDesc->PackedSize = 0;
+ pDesc->UnpackedSize = 0;
+ pDesc->Stride = 0;
+
+ return S_OK;
+}
+
+ID3DX11EffectType * SAnonymousShader::GetMemberTypeByIndex(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectType::GetMemberTypeByIndex: This interface does not refer to a structure");
+ return &g_InvalidType;
+}
+
+ID3DX11EffectType * SAnonymousShader::GetMemberTypeByName(_In_z_ LPCSTR Name)
+{
+ UNREFERENCED_PARAMETER(Name);
+ DPF(0, "ID3DX11EffectType::GetMemberTypeByName: This interface does not refer to a structure");
+ return &g_InvalidType;
+}
+
+ID3DX11EffectType * SAnonymousShader::GetMemberTypeBySemantic(_In_z_ LPCSTR Semantic)
+{
+ UNREFERENCED_PARAMETER(Semantic);
+ DPF(0, "ID3DX11EffectType::GetMemberTypeBySemantic: This interface does not refer to a structure");
+ return &g_InvalidType;
+}
+
+LPCSTR SAnonymousShader::GetMemberName(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectType::GetMemberName: This interface does not refer to a structure");
+ return nullptr;
+}
+
+LPCSTR SAnonymousShader::GetMemberSemantic(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ DPF(0, "ID3DX11EffectType::GetMemberSemantic: This interface does not refer to a structure");
+ return nullptr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectConstantBuffer (SConstantBuffer implementation)
+//////////////////////////////////////////////////////////////////////////
+
+bool SConstantBuffer::IsValid()
+{
+ return true;
+}
+
+ID3DX11EffectType * SConstantBuffer::GetType()
+{
+ return (ID3DX11EffectType *) this;
+}
+
+HRESULT SConstantBuffer::GetDesc(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc)
+{
+ pDesc->Annotations = AnnotationCount;
+ pDesc->Flags = 0;
+
+ pDesc->Name = pName;
+ pDesc->Semantic = nullptr;
+ pDesc->BufferOffset = 0;
+
+ if (ExplicitBindPoint != -1)
+ {
+ pDesc->ExplicitBindPoint = ExplicitBindPoint;
+ pDesc->Flags |= D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
+ }
+ else
+ {
+ pDesc->ExplicitBindPoint = 0;
+ }
+
+ return S_OK;
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetAnnotationByIndex(_In_ uint32_t Index)
+{
+ return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetAnnotationByName(_In_z_ LPCSTR Name)
+{
+ return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetMemberByIndex(_In_ uint32_t Index)
+{
+ SGlobalVariable *pMember;
+ UDataPointer dataPtr;
+
+ if (IsEffectOptimized)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableByIndexHelper<SGlobalVariable>(Index, VariableCount, (SGlobalVariable*)pVariables,
+ nullptr, &pMember, &dataPtr.pGeneric))
+ {
+ return &g_InvalidScalarVariable;
+ }
+
+ return (ID3DX11EffectVariable *) pMember;
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetMemberByName(_In_z_ LPCSTR Name)
+{
+ SGlobalVariable *pMember;
+ UDataPointer dataPtr;
+ uint32_t index;
+
+ if (IsEffectOptimized)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByName: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableByNameHelper<SGlobalVariable>(Name, VariableCount, (SGlobalVariable*)pVariables,
+ nullptr, &pMember, &dataPtr.pGeneric, &index))
+ {
+ return &g_InvalidScalarVariable;
+ }
+
+ return (ID3DX11EffectVariable *) pMember;
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetMemberBySemantic(_In_z_ LPCSTR Semantic)
+{
+ SGlobalVariable *pMember;
+ UDataPointer dataPtr;
+ uint32_t index;
+
+ if (IsEffectOptimized)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableBySemanticHelper<SGlobalVariable>(Semantic, VariableCount, (SGlobalVariable*)pVariables,
+ nullptr, &pMember, &dataPtr.pGeneric, &index))
+ {
+ return &g_InvalidScalarVariable;
+ }
+
+ return (ID3DX11EffectVariable *) pMember;
+}
+
+ID3DX11EffectVariable * SConstantBuffer::GetElement(_In_ uint32_t Index)
+{
+ UNREFERENCED_PARAMETER(Index);
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
+ DPF(0, "%s: This interface does not refer to an array", pFuncName);
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectConstantBuffer * SConstantBuffer::GetParentConstantBuffer()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetParentConstantBuffer";
+ DPF(0, "%s: Constant buffers do not have parent constant buffers", pFuncName);
+ return &g_InvalidConstantBuffer;
+}
+
+ID3DX11EffectConstantBuffer * SConstantBuffer::AsConstantBuffer()
+{
+ return (ID3DX11EffectConstantBuffer *) this;
+}
+
+HRESULT SConstantBuffer::GetDesc(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc)
+{
+ pDesc->TypeName = IsTBuffer ? "tbuffer" : "cbuffer";
+ pDesc->Class = D3D_SVC_OBJECT;
+ pDesc->Type = IsTBuffer ? D3D_SVT_TBUFFER : D3D_SVT_CBUFFER;
+
+ pDesc->Elements = 0;
+ pDesc->Members = VariableCount;
+ pDesc->Rows = 0;
+ pDesc->Columns = 0;
+
+ uint32_t i;
+ pDesc->PackedSize = 0;
+ for (i = 0; i < VariableCount; ++ i)
+ {
+ pDesc->PackedSize += pVariables[i].pType->PackedSize;
+ }
+
+ pDesc->UnpackedSize = Size;
+ assert(pDesc->UnpackedSize >= pDesc->PackedSize);
+
+ pDesc->Stride = AlignToPowerOf2(pDesc->UnpackedSize, SType::c_RegisterSize);
+
+ return S_OK;
+}
+
+ID3DX11EffectType * SConstantBuffer::GetMemberTypeByIndex(_In_ uint32_t Index)
+{
+ return GetTypeByIndexHelper(Index, VariableCount, pVariables, sizeof (SGlobalVariable));
+}
+
+ID3DX11EffectType * SConstantBuffer::GetMemberTypeByName(_In_z_ LPCSTR Name)
+{
+ return GetTypeByNameHelper(Name, VariableCount, pVariables, sizeof (SGlobalVariable));
+}
+
+ID3DX11EffectType * SConstantBuffer::GetMemberTypeBySemantic(_In_z_ LPCSTR Semantic)
+{
+ return GetTypeBySemanticHelper(Semantic, VariableCount, pVariables, sizeof (SGlobalVariable));
+}
+
+LPCSTR SConstantBuffer::GetMemberName(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";
+
+ if (IsEffectOptimized)
+ {
+ DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);
+ return nullptr;
+ }
+
+ if (Index >= VariableCount)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, VariableCount);
+ return nullptr;
+ }
+
+ return pVariables[Index].pName;
+}
+
+LPCSTR SConstantBuffer::GetMemberSemantic(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";
+
+ if (IsEffectOptimized)
+ {
+ DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);
+ return nullptr;
+ }
+
+ if (Index >= VariableCount)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, VariableCount);
+ return nullptr;
+ }
+
+ return pVariables[Index].pSemantic;
+}
+
+_Use_decl_annotations_
+HRESULT SConstantBuffer::SetRawValue(const void *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
+
+ VERIFYPARAMETER(pData);
+
+ if ((Offset + Count < Offset) ||
+ (Count + (uint8_t*)pData < (uint8_t*)pData) ||
+ ((Offset + Count) > Size))
+ {
+ // overflow of some kind
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ if (IsUsedByExpression)
+ {
+ uint32_t i;
+ for (i = 0; i < VariableCount; ++ i)
+ {
+ ((SGlobalVariable*)pVariables)[i].DirtyVariable();
+ }
+ }
+ else
+ {
+ IsDirty = true;
+ }
+
+ memcpy(pBackingStore + Offset, pData, Count);
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+HRESULT SConstantBuffer::GetRawValue(void *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
+
+ VERIFYPARAMETER(pData);
+
+ if ((Offset + Count < Offset) ||
+ (Count + (uint8_t*)pData < (uint8_t*)pData) ||
+ ((Offset + Count) > Size))
+ {
+ // overflow of some kind
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ memcpy(pData, pBackingStore + Offset, Count);
+
+lExit:
+ return hr;
+}
+
+bool SConstantBuffer::ClonedSingle() const
+{
+ return IsSingle && ( pEffect->m_Flags & D3DX11_EFFECT_CLONE );
+}
+
+HRESULT SConstantBuffer::SetConstantBuffer(_In_ ID3D11Buffer *pConstantBuffer)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::SetConstantBuffer";
+
+ if (IsTBuffer)
+ {
+ DPF(0, "%s: This is a texture buffer; use SetTextureBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ // Replace all references to the old shader block with this one
+ pEffect->ReplaceCBReference(this, pConstantBuffer);
+
+ if( !IsUserManaged )
+ {
+ // Save original cbuffer in case we UndoSet
+ assert( pMemberData[0].Type == MDT_Buffer );
+ VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == nullptr );
+ pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;
+ pD3DObject = nullptr;
+ IsUserManaged = true;
+ IsNonUpdatable = true;
+ }
+
+ SAFE_ADDREF( pConstantBuffer );
+ SAFE_RELEASE( pD3DObject );
+ pD3DObject = pConstantBuffer;
+
+lExit:
+ return hr;
+}
+
+HRESULT SConstantBuffer::GetConstantBuffer(_Outptr_ ID3D11Buffer **ppConstantBuffer)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetConstantBuffer";
+
+ VERIFYPARAMETER(ppConstantBuffer);
+
+ if (IsTBuffer)
+ {
+ DPF(0, "%s: This is a texture buffer; use GetTextureBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ assert( pD3DObject );
+ _Analysis_assume_( pD3DObject );
+ *ppConstantBuffer = pD3DObject;
+ SAFE_ADDREF(*ppConstantBuffer);
+
+lExit:
+ return hr;
+}
+
+HRESULT SConstantBuffer::UndoSetConstantBuffer()
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::UndoSetConstantBuffer";
+
+ if (IsTBuffer)
+ {
+ DPF(0, "%s: This is a texture buffer; use UndoSetTextureBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ if( !IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Replace all references to the old shader block with this one
+ pEffect->ReplaceCBReference(this, pMemberData[0].Data.pD3DEffectsManagedConstantBuffer);
+
+ // Revert to original cbuffer
+ SAFE_RELEASE( pD3DObject );
+ pD3DObject = pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;
+ pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = nullptr;
+ IsUserManaged = false;
+ IsNonUpdatable = ClonedSingle();
+
+lExit:
+ return hr;
+}
+
+HRESULT SConstantBuffer::SetTextureBuffer(_In_ ID3D11ShaderResourceView *pTextureBuffer)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::SetTextureBuffer";
+
+ if (!IsTBuffer)
+ {
+ DPF(0, "%s: This is a constant buffer; use SetConstantBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ if( !IsUserManaged )
+ {
+ // Save original cbuffer and tbuffer in case we UndoSet
+ assert( pMemberData[0].Type == MDT_Buffer );
+ VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == nullptr );
+ pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;
+ pD3DObject = nullptr;
+ assert( pMemberData[1].Type == MDT_ShaderResourceView );
+ VB( pMemberData[1].Data.pD3DEffectsManagedTextureBuffer == nullptr );
+ pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = TBuffer.pShaderResource;
+ TBuffer.pShaderResource = nullptr;
+ IsUserManaged = true;
+ IsNonUpdatable = true;
+ }
+
+ SAFE_ADDREF( pTextureBuffer );
+ SAFE_RELEASE(pD3DObject); // won't be needing this anymore...
+ SAFE_RELEASE( TBuffer.pShaderResource );
+ TBuffer.pShaderResource = pTextureBuffer;
+
+lExit:
+ return hr;
+}
+
+HRESULT SConstantBuffer::GetTextureBuffer(_Outptr_ ID3D11ShaderResourceView **ppTextureBuffer)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetTextureBuffer";
+
+ VERIFYPARAMETER(ppTextureBuffer);
+
+ if (!IsTBuffer)
+ {
+ DPF(0, "%s: This is a constant buffer; use GetConstantBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ assert( TBuffer.pShaderResource );
+ _Analysis_assume_( TBuffer.pShaderResource );
+ *ppTextureBuffer = TBuffer.pShaderResource;
+ SAFE_ADDREF(*ppTextureBuffer);
+
+lExit:
+ return hr;
+}
+
+HRESULT SConstantBuffer::UndoSetTextureBuffer()
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::UndoSetTextureBuffer";
+
+ if (!IsTBuffer)
+ {
+ DPF(0, "%s: This is a texture buffer; use UndoSetConstantBuffer instead", pFuncName);
+ VH(D3DERR_INVALIDCALL);
+ }
+
+ if( !IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Revert to original cbuffer
+ SAFE_RELEASE( pD3DObject );
+ pD3DObject = pMemberData[0].Data.pD3DEffectsManagedConstantBuffer;
+ pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = nullptr;
+ SAFE_RELEASE( TBuffer.pShaderResource );
+ TBuffer.pShaderResource = pMemberData[1].Data.pD3DEffectsManagedTextureBuffer;
+ pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = nullptr;
+ IsUserManaged = false;
+ IsNonUpdatable = ClonedSingle();
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectPass (CEffectPass implementation)
+//////////////////////////////////////////////////////////////////////////
+
+bool SPassBlock::IsValid()
+{
+ if( HasDependencies )
+ return pEffect->ValidatePassBlock( this );
+ return InitiallyValid;
+}
+
+HRESULT SPassBlock::GetDesc(_Out_ D3DX11_PASS_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectPass::GetDesc";
+
+ VERIFYPARAMETER(pDesc);
+
+ ZeroMemory(pDesc, sizeof(*pDesc));
+
+ pDesc->Name = pName;
+ pDesc->Annotations = AnnotationCount;
+
+ SAssignment *pAssignment;
+ SAssignment *pLastAssn;
+
+ pEffect->IncrementTimer();
+
+ pAssignment = pAssignments;
+ pLastAssn = pAssignments + AssignmentCount;
+
+ for(; pAssignment < pLastAssn; pAssignment++)
+ {
+ pEffect->EvaluateAssignment(pAssignment);
+ }
+
+ if( BackingStore.pVertexShaderBlock && BackingStore.pVertexShaderBlock->pInputSignatureBlob )
+ {
+ // pInputSignatureBlob can be null if we're setting a nullptr VS "SetVertexShader( nullptr )"
+ pDesc->pIAInputSignature = (uint8_t*)BackingStore.pVertexShaderBlock->pInputSignatureBlob->GetBufferPointer();
+ pDesc->IAInputSignatureSize = BackingStore.pVertexShaderBlock->pInputSignatureBlob->GetBufferSize();
+ }
+
+ pDesc->StencilRef = BackingStore.StencilRef;
+ pDesc->SampleMask = BackingStore.SampleMask;
+ pDesc->BlendFactor[0] = BackingStore.BlendFactor[0];
+ pDesc->BlendFactor[1] = BackingStore.BlendFactor[1];
+ pDesc->BlendFactor[2] = BackingStore.BlendFactor[2];
+ pDesc->BlendFactor[3] = BackingStore.BlendFactor[3];
+
+lExit:
+ return hr;
+}
+
+extern SShaderBlock g_NullVS;
+extern SShaderBlock g_NullGS;
+extern SShaderBlock g_NullPS;
+extern SShaderBlock g_NullHS;
+extern SShaderBlock g_NullDS;
+extern SShaderBlock g_NullCS;
+
+SAnonymousShader g_AnonymousNullVS(&g_NullVS);
+SAnonymousShader g_AnonymousNullGS(&g_NullGS);
+SAnonymousShader g_AnonymousNullPS(&g_NullPS);
+SAnonymousShader g_AnonymousNullHS(&g_NullHS);
+SAnonymousShader g_AnonymousNullDS(&g_NullDS);
+SAnonymousShader g_AnonymousNullCS(&g_NullCS);
+
+template<EObjectType EShaderType>
+HRESULT SPassBlock::GetShaderDescHelper(D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+ uint32_t i;
+ LPCSTR pFuncName = nullptr;
+ SShaderBlock *pShaderBlock = nullptr;
+
+ ApplyPassAssignments();
+
+ switch (EShaderType)
+ {
+ case EOT_VertexShader:
+ case EOT_VertexShader5:
+ pFuncName = "ID3DX11EffectPass::GetVertexShaderDesc";
+ pShaderBlock = BackingStore.pVertexShaderBlock;
+ break;
+ case EOT_PixelShader:
+ case EOT_PixelShader5:
+ pFuncName = "ID3DX11EffectPass::GetPixelShaderDesc";
+ pShaderBlock = BackingStore.pPixelShaderBlock;
+ break;
+ case EOT_GeometryShader:
+ case EOT_GeometryShader5:
+ pFuncName = "ID3DX11EffectPass::GetGeometryShaderDesc";
+ pShaderBlock = BackingStore.pGeometryShaderBlock;
+ break;
+ case EOT_HullShader5:
+#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
+ pFuncName = "ID3DX11EffectPass::GetHullShaderDesc";
+ pShaderBlock = BackingStore.pHullShaderBlock;
+ break;
+ case EOT_DomainShader5:
+#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
+ pFuncName = "ID3DX11EffectPass::GetDomainShaderDesc";
+ pShaderBlock = BackingStore.pDomainShaderBlock;
+ break;
+ case EOT_ComputeShader5:
+#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
+ pFuncName = "ID3DX11EffectPass::GetComputeShaderDesc";
+ pShaderBlock = BackingStore.pComputeShaderBlock;
+ break;
+ default:
+ assert(0);
+ }
+
+ VERIFYPARAMETER(pDesc);
+
+ // in case of error (or in case the assignment doesn't exist), return something reasonable
+ pDesc->pShaderVariable = &g_InvalidShaderVariable;
+ pDesc->ShaderIndex = 0;
+
+ if (nullptr != pShaderBlock)
+ {
+ uint32_t elements, varCount, anonymousShaderCount;
+ SGlobalVariable *pVariables;
+ SAnonymousShader *pAnonymousShaders;
+
+ if (pShaderBlock == &g_NullVS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullVS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else if (pShaderBlock == &g_NullGS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullGS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else if (pShaderBlock == &g_NullPS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullPS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else if (pShaderBlock == &g_NullHS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullHS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else if (pShaderBlock == &g_NullDS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullDS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else if (pShaderBlock == &g_NullCS)
+ {
+ pDesc->pShaderVariable = &g_AnonymousNullCS;
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ else
+ {
+ VB( pEffect->IsRuntimeData(pShaderBlock) );
+ varCount = pEffect->m_VariableCount;
+ pVariables = pEffect->m_pVariables;
+ anonymousShaderCount = pEffect->m_AnonymousShaderCount;
+ pAnonymousShaders = pEffect->m_pAnonymousShaders;
+ }
+
+ for (i = 0; i < varCount; ++ i)
+ {
+ elements = std::max<uint32_t>(1, pVariables[i].pType->Elements);
+ // make sure the variable type matches, and don't forget about GeometryShaderSO's
+ if (pVariables[i].pType->IsShader())
+ {
+ if (pShaderBlock >= pVariables[i].Data.pShader && pShaderBlock < pVariables[i].Data.pShader + elements)
+ {
+ pDesc->pShaderVariable = (ID3DX11EffectShaderVariable *)(pVariables + i);
+ pDesc->ShaderIndex = (uint32_t)(UINT_PTR)(pShaderBlock - pVariables[i].Data.pShader);
+ // we're done
+ goto lExit;
+ }
+ }
+ }
+
+ for (i = 0; i < anonymousShaderCount; ++ i)
+ {
+ if (pShaderBlock == pAnonymousShaders[i].pShaderBlock)
+ {
+ VB(EShaderType == pAnonymousShaders[i].pShaderBlock->GetShaderType())
+ pDesc->pShaderVariable = (pAnonymousShaders + i);
+ pDesc->ShaderIndex = 0;
+ // we're done
+ goto lExit;
+ }
+ }
+
+ DPF(0, "%s: Internal error; shader not found", pFuncName);
+ VH( E_FAIL );
+ }
+
+lExit:
+ return hr;
+}
+
+HRESULT SPassBlock::GetVertexShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_VertexShader>(pDesc);
+}
+
+HRESULT SPassBlock::GetPixelShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_PixelShader>(pDesc);
+}
+
+HRESULT SPassBlock::GetGeometryShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_GeometryShader>(pDesc);
+}
+
+HRESULT SPassBlock::GetHullShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_HullShader5>(pDesc);
+}
+
+HRESULT SPassBlock::GetDomainShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_DomainShader5>(pDesc);
+}
+
+HRESULT SPassBlock::GetComputeShaderDesc(_Out_ D3DX11_PASS_SHADER_DESC *pDesc)
+{
+ return GetShaderDescHelper<EOT_ComputeShader5>(pDesc);
+}
+
+ID3DX11EffectVariable * SPassBlock::GetAnnotationByIndex(_In_ uint32_t Index)
+{
+ return GetAnnotationByIndexHelper("ID3DX11EffectPass", Index, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectVariable * SPassBlock::GetAnnotationByName(_In_z_ LPCSTR Name)
+{
+ return GetAnnotationByNameHelper("ID3DX11EffectPass", Name, AnnotationCount, pAnnotations);
+}
+
+HRESULT SPassBlock::Apply(_In_ uint32_t Flags, _In_ ID3D11DeviceContext* pContext)
+
+{
+ UNREFERENCED_PARAMETER(Flags);
+ HRESULT hr = S_OK;
+
+ // Flags are unused, so should be 0
+
+
+ assert( pEffect->m_pContext == nullptr );
+ pEffect->m_pContext = pContext;
+ pEffect->ApplyPassBlock(this);
+ pEffect->m_pContext = nullptr;
+
+lExit:
+ return hr;
+}
+
+HRESULT SPassBlock::ComputeStateBlockMask(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
+{
+ HRESULT hr = S_OK;
+
+ // flags indicating whether the following shader types were caught by assignment checks or not
+ bool bVS = false, bGS = false, bPS = false, bHS = false, bDS = false, bCS = false;
+
+ for (size_t i = 0; i < AssignmentCount; ++ i)
+ {
+ bool bShader = false;
+
+ switch (pAssignments[i].LhsType)
+ {
+ case ELHS_VertexShaderBlock:
+ bVS = true;
+ bShader = true;
+ break;
+ case ELHS_GeometryShaderBlock:
+ bGS = true;
+ bShader = true;
+ break;
+ case ELHS_PixelShaderBlock:
+ bPS = true;
+ bShader = true;
+ break;
+ case ELHS_HullShaderBlock:
+ bHS = true;
+ bShader = true;
+ break;
+ case ELHS_DomainShaderBlock:
+ bDS = true;
+ bShader = true;
+ break;
+ case ELHS_ComputeShaderBlock:
+ bCS = true;
+ bShader = true;
+ break;
+
+ case ELHS_RasterizerBlock:
+ pStateBlockMask->RSRasterizerState = 1;
+ break;
+ case ELHS_BlendBlock:
+ pStateBlockMask->OMBlendState = 1;
+ break;
+ case ELHS_DepthStencilBlock:
+ pStateBlockMask->OMDepthStencilState = 1;
+ break;
+
+ default:
+ // ignore this assignment (must be a scalar/vector assignment associated with a state object)
+ break;
+ }
+
+ if (bShader)
+ {
+ for (size_t j = 0; j < pAssignments[i].MaxElements; ++ j)
+ {
+ // compute state block mask for the union of ALL shaders
+ VH( pAssignments[i].Source.pShader[j].ComputeStateBlockMask(pStateBlockMask) );
+ }
+ }
+ }
+
+ // go over the state block objects in case there was no corresponding assignment
+ if (nullptr != BackingStore.pRasterizerBlock)
+ {
+ pStateBlockMask->RSRasterizerState = 1;
+ }
+ if (nullptr != BackingStore.pBlendBlock)
+ {
+ pStateBlockMask->OMBlendState = 1;
+ }
+ if (nullptr != BackingStore.pDepthStencilBlock)
+ {
+ pStateBlockMask->OMDepthStencilState = 1;
+ }
+
+ // go over the shaders only if an assignment didn't already catch them
+ if (false == bVS && nullptr != BackingStore.pVertexShaderBlock)
+ {
+ VH( BackingStore.pVertexShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+ if (false == bGS && nullptr != BackingStore.pGeometryShaderBlock)
+ {
+ VH( BackingStore.pGeometryShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+ if (false == bPS && nullptr != BackingStore.pPixelShaderBlock)
+ {
+ VH( BackingStore.pPixelShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+ if (false == bHS && nullptr != BackingStore.pHullShaderBlock)
+ {
+ VH( BackingStore.pHullShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+ if (false == bDS && nullptr != BackingStore.pDomainShaderBlock)
+ {
+ VH( BackingStore.pDomainShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+ if (false == bCS && nullptr != BackingStore.pComputeShaderBlock)
+ {
+ VH( BackingStore.pComputeShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectTechnique (STechnique implementation)
+//////////////////////////////////////////////////////////////////////////
+
+bool STechnique::IsValid()
+{
+ if( HasDependencies )
+ {
+ for( size_t i = 0; i < PassCount; i++ )
+ {
+ if( !((SPassBlock*)pPasses)[i].IsValid() )
+ return false;
+ }
+ return true;
+ }
+ return InitiallyValid;
+}
+
+HRESULT STechnique::GetDesc(_Out_ D3DX11_TECHNIQUE_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+
+ static LPCSTR pFuncName = "ID3DX11EffectTechnique::GetDesc";
+
+ VERIFYPARAMETER(pDesc);
+
+ pDesc->Name = pName;
+ pDesc->Annotations = AnnotationCount;
+ pDesc->Passes = PassCount;
+
+lExit:
+ return hr;
+}
+
+ID3DX11EffectVariable * STechnique::GetAnnotationByIndex(_In_ uint32_t Index)
+{
+ return GetAnnotationByIndexHelper("ID3DX11EffectTechnique", Index, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectVariable * STechnique::GetAnnotationByName(_In_z_ LPCSTR Name)
+{
+ return GetAnnotationByNameHelper("ID3DX11EffectTechnique", Name, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectPass * STechnique::GetPassByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByIndex";
+
+ if (Index >= PassCount)
+ {
+ DPF(0, "%s: Invalid pass index (%u, total: %u)", pFuncName, Index, PassCount);
+ return &g_InvalidPass;
+ }
+
+ return (ID3DX11EffectPass *)(pPasses + Index);
+}
+
+ID3DX11EffectPass * STechnique::GetPassByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByName";
+
+ uint32_t i;
+
+ for (i = 0; i < PassCount; ++ i)
+ {
+ if (nullptr != pPasses[i].pName &&
+ strcmp(pPasses[i].pName, Name) == 0)
+ {
+ break;
+ }
+ }
+
+ if (i == PassCount)
+ {
+ DPF(0, "%s: Pass [%s] not found", pFuncName, Name);
+ return &g_InvalidPass;
+ }
+
+ return (ID3DX11EffectPass *)(pPasses + i);
+}
+
+HRESULT STechnique::ComputeStateBlockMask(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
+{
+ HRESULT hr = S_OK;
+ uint32_t i;
+
+ _Analysis_assume_( PassCount == 0 || pPasses != 0 );
+ for (i = 0; i < PassCount; ++ i)
+ {
+ VH( ((SPassBlock*)pPasses)[i].ComputeStateBlockMask(pStateBlockMask) );
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectGroup (SGroup implementation)
+//////////////////////////////////////////////////////////////////////////
+
+bool SGroup::IsValid()
+{
+ if( HasDependencies )
+ {
+ for( size_t i = 0; i < TechniqueCount; i++ )
+ {
+ if( !((STechnique*)pTechniques)[i].IsValid() )
+ return false;
+ }
+ return true;
+ }
+ return InitiallyValid;
+}
+
+HRESULT SGroup::GetDesc(_Out_ D3DX11_GROUP_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+
+ static LPCSTR pFuncName = "ID3DX11EffectGroup::GetDesc";
+
+ VERIFYPARAMETER(pDesc);
+
+ pDesc->Name = pName;
+ pDesc->Annotations = AnnotationCount;
+ pDesc->Techniques = TechniqueCount;
+
+lExit:
+ return hr;
+}
+
+ID3DX11EffectVariable * SGroup::GetAnnotationByIndex(_In_ uint32_t Index)
+{
+ return GetAnnotationByIndexHelper("ID3DX11EffectGroup", Index, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectVariable * SGroup::GetAnnotationByName(_In_z_ LPCSTR Name)
+{
+ return GetAnnotationByNameHelper("ID3DX11EffectGroup", Name, AnnotationCount, pAnnotations);
+}
+
+ID3DX11EffectTechnique * SGroup::GetTechniqueByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByIndex";
+
+ if (Index >= TechniqueCount)
+ {
+ DPF(0, "%s: Invalid pass index (%u, total: %u)", pFuncName, Index, TechniqueCount);
+ return &g_InvalidTechnique;
+ }
+
+ return (ID3DX11EffectTechnique *)(pTechniques + Index);
+}
+
+ID3DX11EffectTechnique * SGroup::GetTechniqueByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByName";
+
+ uint32_t i;
+
+ for (i = 0; i < TechniqueCount; ++ i)
+ {
+ if (nullptr != pTechniques[i].pName &&
+ strcmp(pTechniques[i].pName, Name) == 0)
+ {
+ break;
+ }
+ }
+
+ if (i == TechniqueCount)
+ {
+ DPF(0, "%s: Technique [%s] not found", pFuncName, Name);
+ return &g_InvalidTechnique;
+ }
+
+ return (ID3DX11EffectTechnique *)(pTechniques + i);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11Effect Public Reflection APIs (CEffect)
+//////////////////////////////////////////////////////////////////////////
+
+HRESULT CEffect::GetDevice(_Outptr_ ID3D11Device **ppDevice)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11Effect::GetDevice";
+ VERIFYPARAMETER(ppDevice);
+
+ m_pDevice->AddRef();
+ *ppDevice = m_pDevice;
+
+lExit:
+ return hr;
+}
+
+HRESULT CEffect::GetDesc(_Out_ D3DX11_EFFECT_DESC *pDesc)
+{
+ HRESULT hr = S_OK;
+
+ static LPCSTR pFuncName = "ID3DX11Effect::GetDesc";
+
+ VERIFYPARAMETER(pDesc);
+
+ pDesc->ConstantBuffers = m_CBCount;
+ pDesc->GlobalVariables = m_VariableCount;
+ pDesc->Techniques = m_TechniqueCount;
+ pDesc->Groups = m_GroupCount;
+ pDesc->InterfaceVariables = m_InterfaceCount;
+
+lExit:
+ return hr;
+}
+
+ID3DX11EffectConstantBuffer * CEffect::GetConstantBufferByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetConstantBufferByIndex";
+
+ if (Index < m_CBCount)
+ {
+ return m_pCBs + Index;
+ }
+
+ DPF(0, "%s: Invalid constant buffer index", pFuncName);
+ return &g_InvalidConstantBuffer;
+}
+
+ID3DX11EffectConstantBuffer * CEffect::GetConstantBufferByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetConstantBufferByName";
+
+ if (IsOptimized())
+ {
+ DPF(0, "%s: Cannot get constant buffer interfaces by name since the effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidConstantBuffer;
+ }
+
+ if (nullptr == Name)
+ {
+ DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
+ return &g_InvalidConstantBuffer;
+ }
+
+ for (uint32_t i = 0; i < m_CBCount; ++ i)
+ {
+ if (strcmp(m_pCBs[i].pName, Name) == 0)
+ {
+ return m_pCBs + i;
+ }
+ }
+
+ DPF(0, "%s: Constant Buffer [%s] not found", pFuncName, Name);
+ return &g_InvalidConstantBuffer;
+}
+
+ID3DX11EffectVariable * CEffect::GetVariableByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetVariableByIndex";
+
+ if (Index < m_VariableCount)
+ {
+ return m_pVariables + Index;
+ }
+
+ DPF(0, "%s: Invalid variable index", pFuncName);
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * CEffect::GetVariableByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetVariableByName";
+
+ if (IsOptimized())
+ {
+ DPF(0, "%s: Cannot get variable interfaces by name since the effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ if (nullptr == Name)
+ {
+ DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ for (uint32_t i = 0; i < m_VariableCount; ++ i)
+ {
+ if (strcmp(m_pVariables[i].pName, Name) == 0)
+ {
+ return m_pVariables + i;
+ }
+ }
+
+ DPF(0, "%s: Variable [%s] not found", pFuncName, Name);
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectVariable * CEffect::GetVariableBySemantic(_In_z_ LPCSTR Semantic)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetVariableBySemantic";
+
+ if (IsOptimized())
+ {
+ DPF(0, "%s: Cannot get variable interfaces by semantic since the effect has been Optimize()'ed", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ if (nullptr == Semantic)
+ {
+ DPF(0, "%s: Parameter Semantic was nullptr.", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ uint32_t i;
+
+ for (i = 0; i < m_VariableCount; ++ i)
+ {
+ if (nullptr != m_pVariables[i].pSemantic &&
+ _stricmp(m_pVariables[i].pSemantic, Semantic) == 0)
+ {
+ return (ID3DX11EffectVariable *)(m_pVariables + i);
+ }
+ }
+
+ DPF(0, "%s: Variable with semantic [%s] not found", pFuncName, Semantic);
+ return &g_InvalidScalarVariable;
+}
+
+ID3DX11EffectTechnique * CEffect::GetTechniqueByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByIndex";
+
+ if( Index < m_TechniqueCount )
+ {
+ for( size_t i=0; i < m_GroupCount; i++ )
+ {
+ if( Index < m_pGroups[i].TechniqueCount )
+ {
+ return (ID3DX11EffectTechnique *)(m_pGroups[i].pTechniques + Index);
+ }
+ Index -= m_pGroups[i].TechniqueCount;
+ }
+ assert( false );
+ }
+ DPF(0, "%s: Invalid technique index (%u)", pFuncName, Index);
+ return &g_InvalidTechnique;
+}
+
+ID3DX11EffectTechnique * CEffect::GetTechniqueByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByName";
+ const size_t MAX_GROUP_TECHNIQUE_SIZE = 256;
+ char NameCopy[MAX_GROUP_TECHNIQUE_SIZE];
+
+ if (IsOptimized())
+ {
+ DPF(0, "ID3DX11Effect::GetTechniqueByName: Cannot get technique interfaces by name since the effect has been Optimize()'ed");
+ return &g_InvalidTechnique;
+ }
+
+ if (nullptr == Name)
+ {
+ DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
+ return &g_InvalidTechnique;
+ }
+
+ if( FAILED( strcpy_s( NameCopy, MAX_GROUP_TECHNIQUE_SIZE, Name ) ) )
+ {
+ DPF( 0, "Group|Technique name has a length greater than %u.", MAX_GROUP_TECHNIQUE_SIZE );
+ return &g_InvalidTechnique;
+ }
+
+ char* pDelimiter = strchr( NameCopy, '|' );
+ if( pDelimiter == nullptr )
+ {
+ if ( m_pNullGroup == nullptr )
+ {
+ DPF( 0, "The effect contains no default group." );
+ return &g_InvalidTechnique;
+ }
+
+ return m_pNullGroup->GetTechniqueByName( Name );
+ }
+
+ // separate group name and technique name
+ *pDelimiter = 0;
+
+ return GetGroupByName( NameCopy )->GetTechniqueByName( pDelimiter + 1 );
+}
+
+ID3D11ClassLinkage * CEffect::GetClassLinkage()
+{
+ SAFE_ADDREF( m_pClassLinkage );
+ return m_pClassLinkage;
+}
+
+ID3DX11EffectGroup * CEffect::GetGroupByIndex(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetGroupByIndex";
+
+ if( Index < m_GroupCount )
+ {
+ return (ID3DX11EffectGroup *)(m_pGroups + Index);
+ }
+ DPF(0, "%s: Invalid group index (%u)", pFuncName, Index);
+ return &g_InvalidGroup;
+}
+
+ID3DX11EffectGroup * CEffect::GetGroupByName(_In_z_ LPCSTR Name)
+{
+ static LPCSTR pFuncName = "ID3DX11Effect::GetGroupByName";
+
+ if (IsOptimized())
+ {
+ DPF(0, "ID3DX11Effect::GetGroupByName: Cannot get group interfaces by name since the effect has been Optimize()'ed");
+ return &g_InvalidGroup;
+ }
+
+ if (nullptr == Name || Name[0] == 0 )
+ {
+ return m_pNullGroup ? (ID3DX11EffectGroup *)m_pNullGroup : &g_InvalidGroup;
+ }
+
+ uint32_t i = 0;
+ for (; i < m_GroupCount; ++ i)
+ {
+ if (nullptr != m_pGroups[i].pName &&
+ strcmp(m_pGroups[i].pName, Name) == 0)
+ {
+ break;
+ }
+ }
+
+ if (i == m_GroupCount)
+ {
+ DPF(0, "%s: Group [%s] not found", pFuncName, Name);
+ return &g_InvalidGroup;
+ }
+
+ return (ID3DX11EffectGroup *)(m_pGroups + i);
+}
+
+}
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectRuntime.cpp
+//
+// Direct3D 11 Effect runtime routines (performance critical)
+// These functions are expected to be called at high frequency
+// (when applying a pass).
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+
+namespace D3DX11Effects
+{
+ // D3D11_KEEP_UNORDERED_ACCESS_VIEWS == (uint32_t)-1
+ uint32_t g_pNegativeOnes[8] = { D3D11_KEEP_UNORDERED_ACCESS_VIEWS, D3D11_KEEP_UNORDERED_ACCESS_VIEWS, D3D11_KEEP_UNORDERED_ACCESS_VIEWS,
+ D3D11_KEEP_UNORDERED_ACCESS_VIEWS, D3D11_KEEP_UNORDERED_ACCESS_VIEWS, D3D11_KEEP_UNORDERED_ACCESS_VIEWS,
+ D3D11_KEEP_UNORDERED_ACCESS_VIEWS, D3D11_KEEP_UNORDERED_ACCESS_VIEWS };
+
+bool SBaseBlock::ApplyAssignments(CEffect *pEffect)
+{
+ SAssignment *pAssignment = pAssignments;
+ SAssignment *pLastAssn = pAssignments + AssignmentCount;
+ bool bRecreate = false;
+
+ for(; pAssignment < pLastAssn; pAssignment++)
+ {
+ bRecreate |= pEffect->EvaluateAssignment(pAssignment);
+ }
+
+ return bRecreate;
+}
+
+void SPassBlock::ApplyPassAssignments()
+{
+ SAssignment *pAssignment = pAssignments;
+ SAssignment *pLastAssn = pAssignments + AssignmentCount;
+
+ pEffect->IncrementTimer();
+
+ for(; pAssignment < pLastAssn; pAssignment++)
+ {
+ pEffect->EvaluateAssignment(pAssignment);
+ }
+}
+
+// Returns true if the shader uses global interfaces (since these interfaces can be updated through SetClassInstance)
+bool SPassBlock::CheckShaderDependencies( _In_ const SShaderBlock* pBlock )
+{
+ if( pBlock->InterfaceDepCount > 0 )
+ {
+ assert( pBlock->InterfaceDepCount == 1 );
+ for( size_t i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
+ {
+ SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
+ if( pInterfaceDep > pEffect->m_pInterfaces && pInterfaceDep < (pEffect->m_pInterfaces + pEffect->m_InterfaceCount) )
+ {
+ // This is a global interface pointer (as opposed to an SInterface created in a BindInterface call
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+// Returns true if the pass (and sets HasDependencies) if the pass sets objects whose backing stores can be updated
+#pragma warning(push)
+#pragma warning(disable: 4616 6282)
+bool SPassBlock::CheckDependencies()
+{
+ if( HasDependencies )
+ return true;
+
+ for( size_t i=0; i < AssignmentCount; i++ )
+ {
+ if( pAssignments[i].DependencyCount > 0 )
+ return HasDependencies = true;
+ }
+ if( BackingStore.pBlendBlock && BackingStore.pBlendBlock->AssignmentCount > 0 )
+ {
+ for( size_t i=0; i < BackingStore.pBlendBlock->AssignmentCount; i++ )
+ {
+ if( BackingStore.pBlendBlock->pAssignments[i].DependencyCount > 0 )
+ return HasDependencies = true;
+ }
+ }
+ if( BackingStore.pDepthStencilBlock && BackingStore.pDepthStencilBlock->AssignmentCount > 0 )
+ {
+ for( size_t i=0; i < BackingStore.pDepthStencilBlock->AssignmentCount; i++ )
+ {
+ if( BackingStore.pDepthStencilBlock->pAssignments[i].DependencyCount > 0 )
+ return HasDependencies = true;
+ }
+ }
+ if( BackingStore.pRasterizerBlock && BackingStore.pRasterizerBlock->AssignmentCount > 0 )
+ {
+ for( size_t i=0; i < BackingStore.pRasterizerBlock->AssignmentCount; i++ )
+ {
+ if( BackingStore.pRasterizerBlock->pAssignments[i].DependencyCount > 0 )
+ return HasDependencies = true;
+ }
+ }
+ if( BackingStore.pVertexShaderBlock && CheckShaderDependencies( BackingStore.pVertexShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+ if( BackingStore.pGeometryShaderBlock && CheckShaderDependencies( BackingStore.pGeometryShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+ if( BackingStore.pPixelShaderBlock && CheckShaderDependencies( BackingStore.pPixelShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+ if( BackingStore.pHullShaderBlock && CheckShaderDependencies( BackingStore.pHullShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+ if( BackingStore.pDomainShaderBlock && CheckShaderDependencies( BackingStore.pDomainShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+ if( BackingStore.pComputeShaderBlock && CheckShaderDependencies( BackingStore.pComputeShaderBlock ) )
+ {
+ return HasDependencies = true;
+ }
+
+ return HasDependencies;
+}
+#pragma warning(pop)
+
+// Update constant buffer contents if necessary
+inline void CheckAndUpdateCB_FX(ID3D11DeviceContext *pContext, SConstantBuffer *pCB)
+{
+ if (pCB->IsDirty && !pCB->IsNonUpdatable)
+ {
+ // CB out of date; rebuild it
+ pContext->UpdateSubresource(pCB->pD3DObject, 0, nullptr, pCB->pBackingStore, pCB->Size, pCB->Size);
+ pCB->IsDirty = false;
+ }
+}
+
+
+//--------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------
+
+// Set the shader and dependent state (SRVs, samplers, UAVs, interfaces)
+void CEffect::ApplyShaderBlock(_In_ SShaderBlock *pBlock)
+{
+ SD3DShaderVTable *pVT = pBlock->pVT;
+
+ // Apply constant buffers first (tbuffers are done later)
+ SShaderCBDependency *pCBDep = pBlock->pCBDeps;
+ SShaderCBDependency *pLastCBDep = pBlock->pCBDeps + pBlock->CBDepCount;
+
+ for (; pCBDep<pLastCBDep; pCBDep++)
+ {
+ assert(pCBDep->ppFXPointers);
+
+ for (size_t i = 0; i < pCBDep->Count; ++ i)
+ {
+ CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
+ }
+
+ (m_pContext->*(pVT->pSetConstantBuffers))(pCBDep->StartIndex, pCBDep->Count, pCBDep->ppD3DObjects);
+ }
+
+ // Next, apply samplers
+ SShaderSamplerDependency *pSampDep = pBlock->pSampDeps;
+ SShaderSamplerDependency *pLastSampDep = pBlock->pSampDeps + pBlock->SampDepCount;
+
+ for (; pSampDep<pLastSampDep; pSampDep++)
+ {
+ assert(pSampDep->ppFXPointers);
+
+ for (size_t i=0; i<pSampDep->Count; i++)
+ {
+ if ( ApplyRenderStateBlock(pSampDep->ppFXPointers[i]) )
+ {
+ // If the sampler was updated, its pointer will have changed
+ pSampDep->ppD3DObjects[i] = pSampDep->ppFXPointers[i]->pD3DObject;
+ }
+ }
+ (m_pContext->*(pVT->pSetSamplers))(pSampDep->StartIndex, pSampDep->Count, pSampDep->ppD3DObjects);
+ }
+
+ // Set the UAVs
+ // UAV ranges were combined in EffectLoad. This code remains unchanged, however, so that ranges can be easily split
+ assert( pBlock->UAVDepCount < 2 );
+ if( pBlock->UAVDepCount > 0 )
+ {
+ SUnorderedAccessViewDependency *pUAVDep = pBlock->pUAVDeps;
+ assert(pUAVDep->ppFXPointers != 0);
+ _Analysis_assume_(pUAVDep->ppFXPointers != 0);
+
+ for (size_t i=0; i<pUAVDep->Count; i++)
+ {
+ pUAVDep->ppD3DObjects[i] = pUAVDep->ppFXPointers[i]->pUnorderedAccessView;
+ }
+
+ if( EOT_ComputeShader5 == pBlock->GetShaderType() )
+ {
+ m_pContext->CSSetUnorderedAccessViews( pUAVDep->StartIndex, pUAVDep->Count, pUAVDep->ppD3DObjects, g_pNegativeOnes );
+ }
+ else
+ {
+ // This call could be combined with the call to set render targets if both exist in the pass
+ m_pContext->OMSetRenderTargetsAndUnorderedAccessViews( D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL, nullptr, nullptr, pUAVDep->StartIndex, pUAVDep->Count, pUAVDep->ppD3DObjects, g_pNegativeOnes );
+ }
+ }
+
+ // TBuffers are funny:
+ // We keep two references to them. One is in as a standard texture dep, and that gets used for all sets
+ // The other is as a part of the TBufferDeps array, which tells us to rebuild the matching CBs.
+ // These two refs could be rolled into one, but then we would have to predicate on each CB or each texture.
+ SConstantBuffer **ppTB = pBlock->ppTbufDeps;
+ SConstantBuffer **ppLastTB = ppTB + pBlock->TBufferDepCount;
+
+ for (; ppTB<ppLastTB; ppTB++)
+ {
+ CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)*ppTB);
+ }
+
+ // Set the textures
+ SShaderResourceDependency *pResourceDep = pBlock->pResourceDeps;
+ SShaderResourceDependency *pLastResourceDep = pBlock->pResourceDeps + pBlock->ResourceDepCount;
+
+ for (; pResourceDep<pLastResourceDep; pResourceDep++)
+ {
+ assert(pResourceDep->ppFXPointers != 0);
+ _Analysis_assume_(pResourceDep->ppFXPointers != 0);
+
+ for (size_t i=0; i<pResourceDep->Count; i++)
+ {
+ pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
+ }
+
+ (m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
+ }
+
+ // Update Interface dependencies
+ uint32_t Interfaces = 0;
+ ID3D11ClassInstance** ppClassInstances = nullptr;
+ assert( pBlock->InterfaceDepCount < 2 );
+ if( pBlock->InterfaceDepCount > 0 )
+ {
+ SInterfaceDependency *pInterfaceDep = pBlock->pInterfaceDeps;
+ assert(pInterfaceDep->ppFXPointers);
+
+ ppClassInstances = pInterfaceDep->ppD3DObjects;
+ Interfaces = pInterfaceDep->Count;
+ for (size_t i=0; i<pInterfaceDep->Count; i++)
+ {
+ assert(pInterfaceDep->ppFXPointers != 0);
+ _Analysis_assume_(pInterfaceDep->ppFXPointers != 0);
+ SClassInstanceGlobalVariable* pCI = pInterfaceDep->ppFXPointers[i]->pClassInstance;
+ if( pCI )
+ {
+ assert( pCI->pMemberData != 0 );
+ _Analysis_assume_( pCI->pMemberData != 0 );
+ pInterfaceDep->ppD3DObjects[i] = pCI->pMemberData->Data.pD3DClassInstance;
+ }
+ else
+ {
+ pInterfaceDep->ppD3DObjects[i] = nullptr;
+ }
+ }
+ }
+
+ // Now set the shader
+ (m_pContext->*(pVT->pSetShader))(pBlock->pD3DObject, ppClassInstances, Interfaces);
+}
+
+// Returns true if the block D3D data was recreated
+bool CEffect::ApplyRenderStateBlock(_In_ SBaseBlock *pBlock)
+{
+ if( pBlock->IsUserManaged )
+ {
+ return false;
+ }
+
+ bool bRecreate = pBlock->ApplyAssignments(this);
+
+ if (bRecreate)
+ {
+ switch (pBlock->BlockType)
+ {
+ case EBT_Sampler:
+ {
+ SSamplerBlock *pSBlock = pBlock->AsSampler();
+
+ assert(pSBlock->pD3DObject != 0);
+ _Analysis_assume_(pSBlock->pD3DObject != 0);
+ pSBlock->pD3DObject->Release();
+
+ HRESULT hr = m_pDevice->CreateSamplerState( &pSBlock->BackingStore.SamplerDesc, &pSBlock->pD3DObject );
+ if ( SUCCEEDED(hr) )
+ {
+ SetDebugObjectName(pSBlock->pD3DObject, "D3DX11Effect");
+ }
+ }
+ break;
+
+ case EBT_DepthStencil:
+ {
+ SDepthStencilBlock *pDSBlock = pBlock->AsDepthStencil();
+
+ assert(nullptr != pDSBlock->pDSObject);
+ SAFE_RELEASE( pDSBlock->pDSObject );
+ if( SUCCEEDED( m_pDevice->CreateDepthStencilState( &pDSBlock->BackingStore, &pDSBlock->pDSObject ) ) )
+ {
+ pDSBlock->IsValid = true;
+ SetDebugObjectName( pDSBlock->pDSObject, "D3DX11Effect" );
+ }
+ else
+ pDSBlock->IsValid = false;
+ }
+ break;
+
+ case EBT_Blend:
+ {
+ SBlendBlock *pBBlock = pBlock->AsBlend();
+
+ assert(nullptr != pBBlock->pBlendObject);
+ SAFE_RELEASE( pBBlock->pBlendObject );
+ if( SUCCEEDED( m_pDevice->CreateBlendState( &pBBlock->BackingStore, &pBBlock->pBlendObject ) ) )
+ {
+ pBBlock->IsValid = true;
+ SetDebugObjectName( pBBlock->pBlendObject, "D3DX11Effect" );
+ }
+ else
+ pBBlock->IsValid = false;
+ }
+ break;
+
+ case EBT_Rasterizer:
+ {
+ SRasterizerBlock *pRBlock = pBlock->AsRasterizer();
+
+ assert(nullptr != pRBlock->pRasterizerObject);
+
+ SAFE_RELEASE( pRBlock->pRasterizerObject );
+ if( SUCCEEDED( m_pDevice->CreateRasterizerState( &pRBlock->BackingStore, &pRBlock->pRasterizerObject ) ) )
+ {
+ pRBlock->IsValid = true;
+ SetDebugObjectName( pRBlock->pRasterizerObject, "D3DX11Effect" );
+ }
+ else
+ pRBlock->IsValid = false;
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+ }
+
+ return bRecreate;
+}
+
+void CEffect::ValidateIndex(_In_ uint32_t Elements)
+{
+ if (m_FXLIndex >= Elements)
+ {
+ DPF(0, "ID3DX11Effect: Overindexing variable array (size: %u, index: %u), using index = 0 instead", Elements, m_FXLIndex);
+ m_FXLIndex = 0;
+ }
+}
+
+// Returns true if the assignment was changed
+bool CEffect::EvaluateAssignment(_Inout_ SAssignment *pAssignment)
+{
+ bool bNeedUpdate = false;
+ SGlobalVariable *pVarDep0, *pVarDep1;
+
+ switch (pAssignment->AssignmentType)
+ {
+ case ERAT_NumericVariable:
+ assert(pAssignment->DependencyCount == 1);
+ if (pAssignment->pDependencies[0].pVariable->LastModifiedTime >= pAssignment->LastRecomputedTime)
+ {
+ memcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
+ bNeedUpdate = true;
+ }
+ break;
+
+ case ERAT_NumericVariableIndex:
+ assert(pAssignment->DependencyCount == 2);
+ pVarDep0 = pAssignment->pDependencies[0].pVariable;
+ pVarDep1 = pAssignment->pDependencies[1].pVariable;
+
+ if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
+ {
+ m_FXLIndex = *pVarDep0->Data.pNumericDword;
+
+ ValidateIndex(pVarDep1->pType->Elements);
+
+ // Array index variable is dirty, update the pointer
+ pAssignment->Source.pNumeric = pVarDep1->Data.pNumeric + pVarDep1->pType->Stride * m_FXLIndex;
+
+ // Copy the new data
+ memcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
+ bNeedUpdate = true;
+ }
+ else if (pVarDep1->LastModifiedTime >= pAssignment->LastRecomputedTime)
+ {
+ // Only the array variable is dirty, copy the new data
+ memcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
+ bNeedUpdate = true;
+ }
+ break;
+
+ case ERAT_ObjectVariableIndex:
+ assert(pAssignment->DependencyCount == 1);
+ pVarDep0 = pAssignment->pDependencies[0].pVariable;
+ if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
+ {
+ m_FXLIndex = *pVarDep0->Data.pNumericDword;
+ ValidateIndex(pAssignment->MaxElements);
+
+ // Array index variable is dirty, update the destination pointer
+ *((void **)pAssignment->Destination.pGeneric) = pAssignment->Source.pNumeric +
+ pAssignment->DataSize * m_FXLIndex;
+ bNeedUpdate = true;
+ }
+ break;
+
+ default:
+ //case ERAT_Constant: -- These are consumed and discarded
+ //case ERAT_ObjectVariable: -- These are consumed and discarded
+ //case ERAT_ObjectConstIndex: -- These are consumed and discarded
+ //case ERAT_ObjectInlineShader: -- These are consumed and discarded
+ //case ERAT_NumericConstIndex: -- ERAT_NumericVariable should be generated instead
+ assert(0);
+ break;
+ }
+
+ // Mark the assignment as not dirty
+ pAssignment->LastRecomputedTime = m_LocalTimer;
+
+ return bNeedUpdate;
+}
+
+// Returns false if this shader has interface dependencies which are nullptr (SetShader will fail).
+bool CEffect::ValidateShaderBlock( _Inout_ SShaderBlock* pBlock )
+{
+ if( !pBlock->IsValid )
+ return false;
+ if( pBlock->InterfaceDepCount > 0 )
+ {
+ assert( pBlock->InterfaceDepCount == 1 );
+ for( size_t i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
+ {
+ SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
+ assert( pInterfaceDep != 0 );
+ _Analysis_assume_( pInterfaceDep != 0 );
+ if( pInterfaceDep->pClassInstance == nullptr )
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Returns false if any state in the pass is invalid
+bool CEffect::ValidatePassBlock( _Inout_ SPassBlock* pBlock )
+{
+ pBlock->ApplyPassAssignments();
+
+ if (nullptr != pBlock->BackingStore.pBlendBlock)
+ {
+ ApplyRenderStateBlock(pBlock->BackingStore.pBlendBlock);
+ pBlock->BackingStore.pBlendState = pBlock->BackingStore.pBlendBlock->pBlendObject;
+ if( !pBlock->BackingStore.pBlendBlock->IsValid )
+ return false;
+ }
+
+ if( nullptr != pBlock->BackingStore.pDepthStencilBlock )
+ {
+ ApplyRenderStateBlock( pBlock->BackingStore.pDepthStencilBlock );
+ pBlock->BackingStore.pDepthStencilState = pBlock->BackingStore.pDepthStencilBlock->pDSObject;
+ if( !pBlock->BackingStore.pDepthStencilBlock->IsValid )
+ return false;
+ }
+
+ if( nullptr != pBlock->BackingStore.pRasterizerBlock )
+ {
+ ApplyRenderStateBlock( pBlock->BackingStore.pRasterizerBlock );
+ if( !pBlock->BackingStore.pRasterizerBlock->IsValid )
+ return false;
+ }
+
+ if( nullptr != pBlock->BackingStore.pVertexShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pVertexShaderBlock) )
+ return false;
+
+ if( nullptr != pBlock->BackingStore.pGeometryShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pGeometryShaderBlock) )
+ return false;
+
+ if( nullptr != pBlock->BackingStore.pPixelShaderBlock )
+ {
+ if( !ValidateShaderBlock(pBlock->BackingStore.pPixelShaderBlock) )
+ return false;
+ else if( pBlock->BackingStore.pPixelShaderBlock->UAVDepCount > 0 &&
+ pBlock->BackingStore.RenderTargetViewCount > pBlock->BackingStore.pPixelShaderBlock->pUAVDeps[0].StartIndex )
+ {
+ return false;
+ }
+ }
+
+ if( nullptr != pBlock->BackingStore.pHullShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pHullShaderBlock) )
+ return false;
+
+ if( nullptr != pBlock->BackingStore.pDomainShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pDomainShaderBlock) )
+ return false;
+
+ if( nullptr != pBlock->BackingStore.pComputeShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pComputeShaderBlock) )
+ return false;
+
+ return true;
+}
+
+// Set all state defined in the pass
+void CEffect::ApplyPassBlock(_Inout_ SPassBlock *pBlock)
+{
+ pBlock->ApplyPassAssignments();
+
+ if (nullptr != pBlock->BackingStore.pBlendBlock)
+ {
+ ApplyRenderStateBlock(pBlock->BackingStore.pBlendBlock);
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pBlendBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid BlendState." );
+#endif
+ pBlock->BackingStore.pBlendState = pBlock->BackingStore.pBlendBlock->pBlendObject;
+ m_pContext->OMSetBlendState(pBlock->BackingStore.pBlendState,
+ pBlock->BackingStore.BlendFactor,
+ pBlock->BackingStore.SampleMask);
+ }
+
+ if (nullptr != pBlock->BackingStore.pDepthStencilBlock)
+ {
+ ApplyRenderStateBlock(pBlock->BackingStore.pDepthStencilBlock);
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pDepthStencilBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid DepthStencilState." );
+#endif
+ pBlock->BackingStore.pDepthStencilState = pBlock->BackingStore.pDepthStencilBlock->pDSObject;
+ m_pContext->OMSetDepthStencilState(pBlock->BackingStore.pDepthStencilState,
+ pBlock->BackingStore.StencilRef);
+ }
+
+ if (nullptr != pBlock->BackingStore.pRasterizerBlock)
+ {
+ ApplyRenderStateBlock(pBlock->BackingStore.pRasterizerBlock);
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pRasterizerBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid RasterizerState." );
+#endif
+ m_pContext->RSSetState(pBlock->BackingStore.pRasterizerBlock->pRasterizerObject);
+ }
+
+ if (nullptr != pBlock->BackingStore.pRenderTargetViews[0])
+ {
+ // Grab all render targets
+ ID3D11RenderTargetView *pRTV[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
+
+ assert(pBlock->BackingStore.RenderTargetViewCount <= D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT);
+ _Analysis_assume_(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT >= pBlock->BackingStore.RenderTargetViewCount);
+
+ for (uint32_t i=0; i<pBlock->BackingStore.RenderTargetViewCount; i++)
+ {
+ pRTV[i] = pBlock->BackingStore.pRenderTargetViews[i]->pRenderTargetView;
+ }
+
+ // This call could be combined with the call to set PS UAVs if both exist in the pass
+ m_pContext->OMSetRenderTargetsAndUnorderedAccessViews( pBlock->BackingStore.RenderTargetViewCount, pRTV, pBlock->BackingStore.pDepthStencilView->pDepthStencilView, 7, D3D11_KEEP_UNORDERED_ACCESS_VIEWS, nullptr, nullptr );
+ }
+
+ if (nullptr != pBlock->BackingStore.pVertexShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pVertexShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid vertex shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pVertexShaderBlock);
+ }
+
+ if (nullptr != pBlock->BackingStore.pPixelShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pPixelShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid pixel shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pPixelShaderBlock);
+ }
+
+ if (nullptr != pBlock->BackingStore.pGeometryShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pGeometryShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid geometry shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pGeometryShaderBlock);
+ }
+
+ if (nullptr != pBlock->BackingStore.pHullShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pHullShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid hull shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pHullShaderBlock);
+ }
+
+ if (nullptr != pBlock->BackingStore.pDomainShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pDomainShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid domain shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pDomainShaderBlock);
+ }
+
+ if (nullptr != pBlock->BackingStore.pComputeShaderBlock)
+ {
+#ifdef FXDEBUG
+ if( !pBlock->BackingStore.pComputeShaderBlock->IsValid )
+ DPF( 0, "Pass::Apply - warning: applying invalid compute shader." );
+#endif
+ ApplyShaderBlock(pBlock->BackingStore.pComputeShaderBlock);
+ }
+}
+
+void CEffect::IncrementTimer()
+{
+ m_LocalTimer++;
+
+#ifndef _M_X64
+#if _DEBUG
+ if (m_LocalTimer > g_TimerRolloverCount)
+ {
+ DPF(0, "Rolling over timer (current time: %u, rollover cap: %u).", m_LocalTimer, g_TimerRolloverCount);
+#else
+ if (m_LocalTimer >= 0x80000000) // check to see if we've exceeded ~2 billion
+ {
+#endif
+ HandleLocalTimerRollover();
+
+ m_LocalTimer = 1;
+ }
+#endif // _M_X64
+}
+
+// This function resets all timers, rendering all assignments dirty
+// This is clearly bad for performance, but should only happen every few billion ticks
+void CEffect::HandleLocalTimerRollover()
+{
+ uint32_t i, j, k;
+
+ // step 1: update variables
+ for (i = 0; i < m_VariableCount; ++ i)
+ {
+ m_pVariables[i].LastModifiedTime = 0;
+ }
+
+ // step 2: update assignments on all blocks (pass, depth stencil, rasterizer, blend, sampler)
+ for (uint32_t iGroup = 0; iGroup < m_GroupCount; ++ iGroup)
+ {
+ for (i = 0; i < m_pGroups[iGroup].TechniqueCount; ++ i)
+ {
+ for (j = 0; j < m_pGroups[iGroup].pTechniques[i].PassCount; ++ j)
+ {
+ for (k = 0; k < m_pGroups[iGroup].pTechniques[i].pPasses[j].AssignmentCount; ++ k)
+ {
+ m_pGroups[iGroup].pTechniques[i].pPasses[j].pAssignments[k].LastRecomputedTime = 0;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < m_DepthStencilBlockCount; ++ i)
+ {
+ for (j = 0; j < m_pDepthStencilBlocks[i].AssignmentCount; ++ j)
+ {
+ m_pDepthStencilBlocks[i].pAssignments[j].LastRecomputedTime = 0;
+ }
+ }
+
+ for (i = 0; i < m_RasterizerBlockCount; ++ i)
+ {
+ for (j = 0; j < m_pRasterizerBlocks[i].AssignmentCount; ++ j)
+ {
+ m_pRasterizerBlocks[i].pAssignments[j].LastRecomputedTime = 0;
+ }
+ }
+
+ for (i = 0; i < m_BlendBlockCount; ++ i)
+ {
+ for (j = 0; j < m_pBlendBlocks[i].AssignmentCount; ++ j)
+ {
+ m_pBlendBlocks[i].pAssignments[j].LastRecomputedTime = 0;
+ }
+ }
+
+ for (i = 0; i < m_SamplerBlockCount; ++ i)
+ {
+ for (j = 0; j < m_pSamplerBlocks[i].AssignmentCount; ++ j)
+ {
+ m_pSamplerBlocks[i].pAssignments[j].LastRecomputedTime = 0;
+ }
+ }
+}
+
+}
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: EffectVariable.inl
+//
+// Direct3D 11 Effects Variable reflection template
+// These templates define the many Effect variable types.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma warning(push)
+#pragma warning(disable : 4127)
+
+//////////////////////////////////////////////////////////////////////////
+// Invalid variable forward defines
+//////////////////////////////////////////////////////////////////////////
+
+struct SEffectInvalidScalarVariable;
+struct SEffectInvalidVectorVariable;
+struct SEffectInvalidMatrixVariable;
+struct SEffectInvalidStringVariable;
+struct SEffectInvalidClassInstanceVariable;
+struct SEffectInvalidInterfaceVariable;
+struct SEffectInvalidShaderResourceVariable;
+struct SEffectInvalidUnorderedAccessViewVariable;
+struct SEffectInvalidRenderTargetViewVariable;
+struct SEffectInvalidDepthStencilViewVariable;
+struct SEffectInvalidConstantBuffer;
+struct SEffectInvalidShaderVariable;
+struct SEffectInvalidBlendVariable;
+struct SEffectInvalidDepthStencilVariable;
+struct SEffectInvalidRasterizerVariable;
+struct SEffectInvalidSamplerVariable;
+struct SEffectInvalidTechnique;
+struct SEffectInvalidPass;
+struct SEffectInvalidType;
+
+extern SEffectInvalidScalarVariable g_InvalidScalarVariable;
+extern SEffectInvalidVectorVariable g_InvalidVectorVariable;
+extern SEffectInvalidMatrixVariable g_InvalidMatrixVariable;
+extern SEffectInvalidStringVariable g_InvalidStringVariable;
+extern SEffectInvalidClassInstanceVariable g_InvalidClassInstanceVariable;
+extern SEffectInvalidInterfaceVariable g_InvalidInterfaceVariable;
+extern SEffectInvalidShaderResourceVariable g_InvalidShaderResourceVariable;
+extern SEffectInvalidUnorderedAccessViewVariable g_InvalidUnorderedAccessViewVariable;
+extern SEffectInvalidRenderTargetViewVariable g_InvalidRenderTargetViewVariable;
+extern SEffectInvalidDepthStencilViewVariable g_InvalidDepthStencilViewVariable;
+extern SEffectInvalidConstantBuffer g_InvalidConstantBuffer;
+extern SEffectInvalidShaderVariable g_InvalidShaderVariable;
+extern SEffectInvalidBlendVariable g_InvalidBlendVariable;
+extern SEffectInvalidDepthStencilVariable g_InvalidDepthStencilVariable;
+extern SEffectInvalidRasterizerVariable g_InvalidRasterizerVariable;
+extern SEffectInvalidSamplerVariable g_InvalidSamplerVariable;
+extern SEffectInvalidTechnique g_InvalidTechnique;
+extern SEffectInvalidPass g_InvalidPass;
+extern SEffectInvalidType g_InvalidType;
+
+enum ETemplateVarType
+{
+ ETVT_Bool,
+ ETVT_Int,
+ ETVT_Float,
+ ETVT_bool
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Invalid effect variable struct definitions
+//////////////////////////////////////////////////////////////////////////
+
+struct SEffectInvalidType : public ID3DX11EffectType
+{
+ STDMETHOD_(bool, IsValid)() override { return false; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidType; }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidType; }
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(_In_z_ LPCSTR Semantic) override { UNREFERENCED_PARAMETER(Semantic); return &g_InvalidType; }
+ STDMETHOD_(LPCSTR, GetMemberName)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return nullptr; }
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return nullptr; }
+ IUNKNOWN_IMP(SEffectInvalidType, ID3DX11EffectType, IUnknown);
+};
+
+template<typename IBaseInterface>
+struct TEffectInvalidVariable : public IBaseInterface
+{
+public:
+ STDMETHOD_(bool, IsValid)() override { return false; }
+ STDMETHOD_(ID3DX11EffectType*, GetType)() override { return &g_InvalidType; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic) override { UNREFERENCED_PARAMETER(Semantic); return &g_InvalidScalarVariable; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override { return &g_InvalidConstantBuffer; }
+
+ STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() override { return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() override { return &g_InvalidVectorVariable; }
+ STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() override { return &g_InvalidMatrixVariable; }
+ STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() override { return &g_InvalidStringVariable; }
+ STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() override { return &g_InvalidClassInstanceVariable; }
+ STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() override { return &g_InvalidInterfaceVariable; }
+ STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() override { return &g_InvalidShaderResourceVariable; }
+ STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() override { return &g_InvalidUnorderedAccessViewVariable; }
+ STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() override { return &g_InvalidRenderTargetViewVariable; }
+ STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() override { return &g_InvalidDepthStencilViewVariable; }
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() override { return &g_InvalidConstantBuffer; }
+ STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() override { return &g_InvalidShaderVariable; }
+ STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() override { return &g_InvalidBlendVariable; }
+ STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() override { return &g_InvalidDepthStencilVariable; }
+ STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() override { return &g_InvalidRasterizerVariable; }
+ STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() override { return &g_InvalidSamplerVariable; }
+
+ STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetRawValue)(_Out_writes_bytes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+};
+
+struct SEffectInvalidScalarVariable : public TEffectInvalidVariable<ID3DX11EffectScalarVariable>
+{
+public:
+
+ STDMETHOD(SetFloat)(_In_ const float Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
+ STDMETHOD(GetFloat)(_Out_ float *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
+
+ STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ STDMETHOD(SetInt)(_In_ const int Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
+ STDMETHOD(GetInt)(_Out_ int *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
+
+ STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ STDMETHOD(SetBool)(_In_ const bool Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
+ STDMETHOD(GetBool)(_Out_ bool *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
+
+ STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidScalarVariable, ID3DX11EffectScalarVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidVectorVariable : public TEffectInvalidVariable<ID3DX11EffectVectorVariable>
+{
+public:
+ STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+ STDMETHOD(SetIntVector)(_In_reads_(4) const int *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+ STDMETHOD(SetBoolVector)(_In_reads_(4) const bool *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+
+ STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+ STDMETHOD(GetIntVector)(_Out_writes_(4) int *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+ STDMETHOD(GetBoolVector)(_Out_writes_(4) bool *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
+
+ STDMETHOD(SetBoolVectorArray) (_In_reads_(4*Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+ STDMETHOD(SetIntVectorArray) (_In_reads_(4*Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+ STDMETHOD(SetFloatVectorArray)(_In_reads_(4*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+
+ STDMETHOD(GetBoolVectorArray) (_Out_writes_(4*Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+ STDMETHOD(GetIntVectorArray) (_Out_writes_(4*Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+ STDMETHOD(GetFloatVectorArray)(_Out_writes_(4*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
+
+ IUNKNOWN_IMP(SEffectInvalidVectorVariable, ID3DX11EffectVectorVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidMatrixVariable : public TEffectInvalidVariable<ID3DX11EffectMatrixVariable>
+{
+public:
+
+ STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
+ STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
+
+ STDMETHOD(SetMatrixArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetMatrixArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ STDMETHOD(SetMatrixPointerArray)(_In_reads_(16*Count) const float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetMatrixPointerArray)(_Out_writes_(16*Count) float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
+ STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
+
+ STDMETHOD(SetMatrixTransposeArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ STDMETHOD(SetMatrixTransposePointerArray)(_In_reads_(16*Count) const float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetMatrixTransposePointerArray)(_Out_writes_(16*Count) float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidMatrixVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidStringVariable : public TEffectInvalidVariable<ID3DX11EffectStringVariable>
+{
+public:
+
+ STDMETHOD(GetString)(_Outptr_result_z_ LPCSTR *ppString) override { UNREFERENCED_PARAMETER(ppString); return E_FAIL; }
+ STDMETHOD(GetStringArray)(_Out_writes_(Count) LPCSTR *ppStrings, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppStrings); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidStringVariable, ID3DX11EffectStringVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidClassInstanceVariable : public TEffectInvalidVariable<ID3DX11EffectClassInstanceVariable>
+{
+public:
+
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3D11ClassInstance **ppClassInstance) override { UNREFERENCED_PARAMETER(ppClassInstance); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidClassInstanceVariable, ID3DX11EffectClassInstanceVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidInterfaceVariable : public TEffectInvalidVariable<ID3DX11EffectInterfaceVariable>
+{
+public:
+
+ STDMETHOD(SetClassInstance)(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance) override
+ { UNREFERENCED_PARAMETER(pEffectClassInstance); return E_FAIL; }
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) override
+ { UNREFERENCED_PARAMETER(ppEffectClassInstance); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidInterfaceVariable, ID3DX11EffectInterfaceVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidShaderResourceVariable : public TEffectInvalidVariable<ID3DX11EffectShaderResourceVariable>
+{
+public:
+
+ STDMETHOD(SetResource)(_In_ ID3D11ShaderResourceView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
+ STDMETHOD(GetResource)(_Outptr_ ID3D11ShaderResourceView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
+
+ STDMETHOD(SetResourceArray)(_In_reads_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetResourceArray)(_Out_writes_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidShaderResourceVariable, ID3DX11EffectShaderResourceVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidUnorderedAccessViewVariable : public TEffectInvalidVariable<ID3DX11EffectUnorderedAccessViewVariable>
+{
+public:
+
+ STDMETHOD(SetUnorderedAccessView)(_In_ ID3D11UnorderedAccessView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
+ STDMETHOD(GetUnorderedAccessView)(_Outptr_ ID3D11UnorderedAccessView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
+
+ STDMETHOD(SetUnorderedAccessViewArray)(_In_reads_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetUnorderedAccessViewArray)(_Out_writes_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidUnorderedAccessViewVariable, ID3DX11EffectUnorderedAccessViewVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidRenderTargetViewVariable : public TEffectInvalidVariable<ID3DX11EffectRenderTargetViewVariable>
+{
+public:
+
+ STDMETHOD(SetRenderTarget)(_In_ ID3D11RenderTargetView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
+ STDMETHOD(GetRenderTarget)(_Outptr_ ID3D11RenderTargetView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
+
+ STDMETHOD(SetRenderTargetArray)(_In_reads_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetRenderTargetArray)(_Out_writes_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidRenderTargetViewVariable, ID3DX11EffectRenderTargetViewVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidDepthStencilViewVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilViewVariable>
+{
+public:
+
+ STDMETHOD(SetDepthStencil)(_In_ ID3D11DepthStencilView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
+ STDMETHOD(GetDepthStencil)(_Outptr_ ID3D11DepthStencilView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
+
+ STDMETHOD(SetDepthStencilArray)(_In_reads_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+ STDMETHOD(GetDepthStencilArray)(_Out_writes_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
+ { UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidDepthStencilViewVariable, ID3DX11EffectDepthStencilViewVariable, ID3DX11EffectVariable);
+};
+
+
+struct SEffectInvalidConstantBuffer : public TEffectInvalidVariable<ID3DX11EffectConstantBuffer>
+{
+public:
+
+ STDMETHOD(SetConstantBuffer)(_In_ ID3D11Buffer *pConstantBuffer) override { UNREFERENCED_PARAMETER(pConstantBuffer); return E_FAIL; }
+ STDMETHOD(GetConstantBuffer)(_Outptr_ ID3D11Buffer **ppConstantBuffer) override { UNREFERENCED_PARAMETER(ppConstantBuffer); return E_FAIL; }
+ STDMETHOD(UndoSetConstantBuffer)() override { return E_FAIL; }
+
+ STDMETHOD(SetTextureBuffer)(_In_ ID3D11ShaderResourceView *pTextureBuffer) override { UNREFERENCED_PARAMETER(pTextureBuffer); return E_FAIL; }
+ STDMETHOD(GetTextureBuffer)(_Outptr_ ID3D11ShaderResourceView **ppTextureBuffer) override { UNREFERENCED_PARAMETER(ppTextureBuffer); return E_FAIL; }
+ STDMETHOD(UndoSetTextureBuffer)() override { return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidConstantBuffer, ID3DX11EffectConstantBuffer, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidShaderVariable : public TEffectInvalidVariable<ID3DX11EffectShaderVariable>
+{
+public:
+
+ STDMETHOD(GetShaderDesc)(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD(GetVertexShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppVS); return E_FAIL; }
+ STDMETHOD(GetGeometryShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppGS); return E_FAIL; }
+ STDMETHOD(GetPixelShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppPS); return E_FAIL; }
+ STDMETHOD(GetHullShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppHS); return E_FAIL; }
+ STDMETHOD(GetDomainShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppDS); return E_FAIL; }
+ STDMETHOD(GetComputeShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppCS); return E_FAIL; }
+
+ STDMETHOD(GetInputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetOutputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetPatchConstantSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidShaderVariable, ID3DX11EffectShaderVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidBlendVariable : public TEffectInvalidVariable<ID3DX11EffectBlendVariable>
+{
+public:
+
+ STDMETHOD(GetBlendState)(_In_ uint32_t Index, _Outptr_ ID3D11BlendState **ppState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
+ STDMETHOD(SetBlendState)(_In_ uint32_t Index, _In_ ID3D11BlendState *pState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
+ STDMETHOD(UndoSetBlendState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_BLEND_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidBlendVariable, ID3DX11EffectBlendVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidDepthStencilVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilVariable>
+{
+public:
+
+ STDMETHOD(GetDepthStencilState)(_In_ uint32_t Index, _Outptr_ ID3D11DepthStencilState **ppState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
+ STDMETHOD(SetDepthStencilState)(_In_ uint32_t Index, _In_ ID3D11DepthStencilState *pState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
+ STDMETHOD(UndoSetDepthStencilState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_DEPTH_STENCIL_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidDepthStencilVariable, ID3DX11EffectDepthStencilVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidRasterizerVariable : public TEffectInvalidVariable<ID3DX11EffectRasterizerVariable>
+{
+public:
+
+ STDMETHOD(GetRasterizerState)(_In_ uint32_t Index, _Outptr_ ID3D11RasterizerState **ppState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
+ STDMETHOD(SetRasterizerState)(_In_ uint32_t Index, _In_ ID3D11RasterizerState *pState) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
+ STDMETHOD(UndoSetRasterizerState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_RASTERIZER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidRasterizerVariable, ID3DX11EffectRasterizerVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidSamplerVariable : public TEffectInvalidVariable<ID3DX11EffectSamplerVariable>
+{
+public:
+
+ STDMETHOD(GetSampler)(_In_ uint32_t Index, _Outptr_ ID3D11SamplerState **ppSampler) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppSampler); return E_FAIL; }
+ STDMETHOD(SetSampler)(_In_ uint32_t Index, _In_ ID3D11SamplerState *pSampler) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pSampler); return E_FAIL; }
+ STDMETHOD(UndoSetSampler)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_SAMPLER_DESC *pDesc) override
+ { UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidSamplerVariable, ID3DX11EffectSamplerVariable, ID3DX11EffectVariable);
+};
+
+struct SEffectInvalidPass : public ID3DX11EffectPass
+{
+public:
+ STDMETHOD_(bool, IsValid)() override { return false; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_PASS_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD(GetVertexShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetGeometryShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetPixelShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetHullShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetDomainShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+ STDMETHOD(GetComputeShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
+
+ STDMETHOD(Apply)(_In_ uint32_t Flags, _In_ ID3D11DeviceContext* pContext) override
+ { UNREFERENCED_PARAMETER(Flags); UNREFERENCED_PARAMETER(pContext); return E_FAIL; }
+ STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override { UNREFERENCED_PARAMETER(pStateBlockMask); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidPass, ID3DX11EffectPass, IUnknown);
+};
+
+struct SEffectInvalidTechnique : public ID3DX11EffectTechnique
+{
+public:
+ STDMETHOD_(bool, IsValid)() override { return false; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_TECHNIQUE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
+
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidPass; }
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidPass; }
+
+ STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override { UNREFERENCED_PARAMETER(pStateBlockMask); return E_FAIL; }
+
+ IUNKNOWN_IMP(SEffectInvalidTechnique, ID3DX11EffectTechnique, IUnknown);
+};
+
+struct SEffectInvalidGroup : public ID3DX11EffectGroup
+{
+public:
+ STDMETHOD_(bool, IsValid)() override { return false; }
+ STDMETHOD(GetDesc)(_Out_ D3DX11_GROUP_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
+
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidTechnique; }
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidTechnique; }
+
+ IUNKNOWN_IMP(SEffectInvalidGroup, ID3DX11EffectGroup, IUnknown);
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Helper routines
+//////////////////////////////////////////////////////////////////////////
+
+// This is an annoying warning that pops up in retail builds because
+// the code that jumps to "lExit" is conditionally not compiled.
+// The only alternative is more #ifdefs in every function
+#pragma warning( disable : 4102 ) // 'label' : unreferenced label
+
+#define VERIFYPARAMETER(x) \
+{ if (!(x)) { DPF(0, "%s: Parameter " #x " was nullptr.", pFuncName); \
+ __BREAK_ON_FAIL; hr = E_INVALIDARG; goto lExit; } }
+
+static HRESULT AnnotationInvalidSetCall(LPCSTR pFuncName)
+{
+ DPF(0, "%s: Annotations are readonly", pFuncName);
+ return D3DERR_INVALIDCALL;
+}
+
+static HRESULT ObjectSetRawValue()
+{
+ DPF(0, "ID3DX11EffectVariable::SetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
+ return D3DERR_INVALIDCALL;
+}
+
+static HRESULT ObjectGetRawValue()
+{
+ DPF(0, "ID3DX11EffectVariable::GetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
+ return D3DERR_INVALIDCALL;
+}
+
+ID3DX11EffectConstantBuffer * NoParentCB();
+
+ID3DX11EffectVariable * GetAnnotationByIndexHelper(_In_z_ const char *pClassName, _In_ uint32_t Index,
+ _In_ uint32_t AnnotationCount, _In_reads_(AnnotationCount) SAnnotation *pAnnotations);
+
+ID3DX11EffectVariable * GetAnnotationByNameHelper(_In_z_ const char *pClassName, _In_z_ LPCSTR Name,
+ _In_ uint32_t AnnotationCount, _In_reads_(AnnotationCount) SAnnotation *pAnnotations);
+
+template<typename SVarType>
+_Success_(return)
+bool GetVariableByIndexHelper(_In_ uint32_t Index, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
+ _In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByIndex";
+
+ if (Index >= VariableCount)
+ {
+ DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, VariableCount);
+ return false;
+ }
+
+ *ppMember = pVariables + Index;
+ *ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
+ return true;
+}
+
+template<typename SVarType>
+_Success_(return)
+bool GetVariableByNameHelper(_In_z_ LPCSTR Name, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
+ _In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr, _Out_ uint32_t* pIndex)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByName";
+
+ if (nullptr == Name)
+ {
+ DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
+ return false;
+ }
+
+ bool bHasSuper = false;
+
+ for (uint32_t i = 0; i < VariableCount; ++ i)
+ {
+ *ppMember = pVariables + i;
+ assert((*ppMember)->pName != 0);
+ _Analysis_assume_((*ppMember)->pName != 0);
+ if (strcmp((*ppMember)->pName, Name) == 0)
+ {
+ *ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
+ *pIndex = i;
+ return true;
+ }
+ else if (i == 0 &&
+ (*ppMember)->pName[0] == '$' &&
+ strcmp((*ppMember)->pName, "$super") == 0)
+ {
+ bHasSuper = true;
+ }
+ }
+
+ if (bHasSuper)
+ {
+ SVarType* pSuper = pVariables;
+
+ return GetVariableByNameHelper<SVarType>(Name,
+ pSuper->pType->StructType.Members,
+ (SVarType*)pSuper->pType->StructType.pMembers,
+ pBaseAddress + pSuper->Data.Offset,
+ ppMember,
+ ppDataPtr,
+ pIndex);
+ }
+
+ DPF(0, "%s: Variable [%s] not found", pFuncName, Name);
+ return false;
+}
+
+template<typename SVarType>
+_Success_(return)
+bool GetVariableBySemanticHelper(_In_z_ LPCSTR Semantic, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
+ _In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr, _Out_ uint32_t* pIndex)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberBySemantic";
+
+ if (nullptr == Semantic)
+ {
+ DPF(0, "%s: Parameter Semantic was nullptr.", pFuncName);
+ return false;
+ }
+
+ for (uint32_t i = 0; i < VariableCount; ++ i)
+ {
+ *ppMember = pVariables + i;
+ if (nullptr != (*ppMember)->pSemantic &&
+ _stricmp((*ppMember)->pSemantic, Semantic) == 0)
+ {
+ *ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
+ *pIndex = i;
+ return true;
+ }
+ }
+
+ DPF(0, "%s: Variable with semantic [%s] not found", pFuncName, Semantic);
+ return false;
+}
+
+inline bool AreBoundsValid(_In_ uint32_t Offset, _In_ uint32_t Count, _In_ const void *pData, _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize)
+{
+ if (Count == 0) return true;
+ uint32_t singleElementSize = pType->GetTotalUnpackedSize(true);
+ assert(singleElementSize <= pType->Stride);
+
+ return ((Offset + Count >= Offset) &&
+ ((Offset + Count) < ((uint32_t)-1) / pType->Stride) &&
+ (Count * pType->Stride + (uint8_t*)pData >= (uint8_t*)pData) &&
+ ((Offset + Count - 1) * pType->Stride + singleElementSize <= TotalUnpackedSize));
+}
+
+// Note that the branches in this code is based on template parameters and will be compiled out
+template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, bool ValidatePtr>
+__forceinline HRESULT CopyScalarValue(_In_ SRC_TYPE SrcValue, _Out_ void *pDest, _In_z_ const char *pFuncName)
+{
+ HRESULT hr = S_OK;
+#ifdef _DEBUG
+ if (ValidatePtr)
+ VERIFYPARAMETER(pDest);
+#else
+ UNREFERENCED_PARAMETER(pFuncName);
+#endif
+
+ switch (SourceType)
+ {
+ case ETVT_Bool:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ *(int*)pDest = (SrcValue != 0) ? -1 : 0;
+ break;
+
+ case ETVT_Int:
+ *(int*)pDest = SrcValue ? 1 : 0;
+ break;
+
+ case ETVT_Float:
+ *(float*)pDest = SrcValue ? 1.0f : 0.0f;
+ break;
+
+ case ETVT_bool:
+ *(bool*)pDest = (SrcValue != 0) ? true : false;
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_Int:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ *(int*)pDest = (SrcValue != 0) ? -1 : 0;
+ break;
+
+ case ETVT_Int:
+ *(int*)pDest = (int) SrcValue;
+ break;
+
+ case ETVT_Float:
+ *(float*)pDest = (float)(SrcValue);
+ break;
+
+ case ETVT_bool:
+ *(bool*)pDest = (SrcValue != 0) ? true : false;
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_Float:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ *(int*)pDest = (SrcValue != 0.0f) ? -1 : 0;
+ break;
+
+ case ETVT_Int:
+ *(int*)pDest = (int) (SrcValue);
+ break;
+
+ case ETVT_Float:
+ *(float*)pDest = (float) SrcValue;
+ break;
+
+ case ETVT_bool:
+ *(bool*)pDest = (SrcValue != 0.0f) ? true : false;
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_bool:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ *(int*)pDest = SrcValue ? -1 : 0;
+ break;
+
+ case ETVT_Int:
+ *(int*)pDest = SrcValue ? 1 : 0;
+ break;
+
+ case ETVT_Float:
+ *(float*)pDest = SrcValue ? 1.0f : 0.0f;
+ break;
+
+ case ETVT_bool:
+ *(bool*)pDest = (SrcValue != 0) ? true : false;
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+
+lExit:
+ return hr;
+}
+
+#pragma warning(push)
+#pragma warning( disable : 6103 )
+template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
+inline HRESULT SetScalarArray(_In_reads_(Count) const SRC_TYPE *pSrcValues, _Out_writes_(Count) DEST_TYPE *pDestValues,
+ _In_ uint32_t Offset, _In_ uint32_t Count,
+ _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ const char *pFuncName)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pSrcValues);
+
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pSrcValues, pType, TotalUnpackedSize))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#else
+ UNREFERENCED_PARAMETER(TotalUnpackedSize);
+ UNREFERENCED_PARAMETER(pFuncName);
+#endif
+
+ uint32_t i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
+ pDestValues += Offset * delta;
+ for (i = 0, j = 0; j < Count; i += delta, ++ j)
+ {
+ // pDestValues[i] = (DEST_TYPE)pSrcValues[j];
+ CopyScalarValue<SourceType, DestType, SRC_TYPE, false>(pSrcValues[j], &pDestValues[i], "SetScalarArray");
+ }
+
+lExit:
+ return hr;
+}
+#pragma warning(pop)
+
+#pragma warning( disable : 6103 )
+template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
+inline HRESULT GetScalarArray(_In_reads_(Count) SRC_TYPE *pSrcValues, _Out_writes_(Count) DEST_TYPE *pDestValues,
+ _In_ uint32_t Offset, _In_ uint32_t Count,
+ _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ const char *pFuncName)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pDestValues);
+
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pDestValues, pType, TotalUnpackedSize))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#else
+ UNREFERENCED_PARAMETER(TotalUnpackedSize);
+ UNREFERENCED_PARAMETER(pFuncName);
+#endif
+
+ uint32_t i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
+ pSrcValues += Offset * delta;
+ for (i = 0, j = 0; j < Count; i += delta, ++ j)
+ {
+ // pDestValues[j] = (DEST_TYPE)pSrcValues[i];
+ CopyScalarValue<SourceType, DestType, SRC_TYPE, false>(pSrcValues[i], &pDestValues[j], "GetScalarArray");
+ }
+
+lExit:
+ return hr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// TVariable - implements type casting and member/element retrieval
+//////////////////////////////////////////////////////////////////////////
+
+// requires that IBaseInterface contain SVariable's fields and support ID3DX11EffectVariable
+template<typename IBaseInterface>
+struct TVariable : public IBaseInterface
+{
+ STDMETHOD_(bool, IsValid)() override { return true; }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index)
+ {
+ SVariable *pMember;
+ UDataPointer dataPtr;
+ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity2 = GetTopLevelEntity();
+
+ if (((ID3DX11Effect*)pTopLevelEntity2->pEffect)->IsOptimized())
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (pType->VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableByIndexHelper<SVariable>(Index, pType->StructType.Members, pType->StructType.pMembers,
+ Data.pNumeric, &pMember, &dataPtr.pGeneric))
+ {
+ return &g_InvalidScalarVariable;
+ }
+
+ return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, Index);
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name)
+ {
+ SVariable *pMember;
+ UDataPointer dataPtr;
+ uint32_t index;
+ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity2 = GetTopLevelEntity();
+
+ if (pTopLevelEntity2->pEffect->IsOptimized())
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByName: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (pType->VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableByNameHelper<SVariable>(Name, pType->StructType.Members, pType->StructType.pMembers,
+ Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
+ {
+ return &g_InvalidScalarVariable;
+
+ }
+
+ return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, index);
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic)
+ {
+ SVariable *pMember;
+ UDataPointer dataPtr;
+ uint32_t index;
+ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity2 = GetTopLevelEntity();
+
+ if (pTopLevelEntity2->pEffect->IsOptimized())
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Cannot get members; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (pType->VarType != EVT_Struct)
+ {
+ DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!GetVariableBySemanticHelper<SVariable>(Semantic, pType->StructType.Members, pType->StructType.pMembers,
+ Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
+ {
+ return &g_InvalidScalarVariable;
+
+ }
+
+ return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, index);
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index)
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
+ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity2 = GetTopLevelEntity();
+ UDataPointer dataPtr;
+
+ if (pTopLevelEntity2->pEffect->IsOptimized())
+ {
+ DPF(0, "ID3DX11EffectVariable::GetElement: Cannot get element; effect has been Optimize()'ed");
+ return &g_InvalidScalarVariable;
+ }
+
+ if (!IsArray())
+ {
+ DPF(0, "%s: This interface does not refer to an array", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ if (Index >= pType->Elements)
+ {
+ DPF(0, "%s: Invalid element index (%u, total: %u)", pFuncName, Index, pType->Elements);
+ return &g_InvalidScalarVariable;
+ }
+
+ if (pType->BelongsInConstantBuffer())
+ {
+ dataPtr.pGeneric = Data.pNumeric + pType->Stride * Index;
+ }
+ else
+ {
+ dataPtr.pGeneric = GetBlockByIndex(pType->VarType, pType->ObjectType, Data.pGeneric, Index);
+ if (nullptr == dataPtr.pGeneric)
+ {
+ DPF(0, "%s: Internal error", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+ }
+
+ return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, (SVariable *) this, dataPtr, true, Index);
+ }
+
+ STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
+
+ if (pType->VarType != EVT_Numeric ||
+ pType->NumericType.NumericLayout != ENL_Scalar)
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ return (ID3DX11EffectScalarVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
+
+ if (pType->VarType != EVT_Numeric ||
+ pType->NumericType.NumericLayout != ENL_Vector)
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidVectorVariable;
+ }
+
+ return (ID3DX11EffectVectorVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
+
+ if (pType->VarType != EVT_Numeric ||
+ pType->NumericType.NumericLayout != ENL_Matrix)
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidMatrixVariable;
+ }
+
+ return (ID3DX11EffectMatrixVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectStringVariable*, AsString)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
+
+ if (!pType->IsObjectType(EOT_String))
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidStringVariable;
+ }
+
+ return (ID3DX11EffectStringVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
+
+ if (!pType->IsClassInstance() )
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidClassInstanceVariable;
+ }
+ else if( pMemberData == nullptr )
+ {
+ DPF(0, "%s: Non-global class instance variables (members of structs or classes) and class instances "
+ "inside tbuffers are not supported.", pFuncName );
+ return &g_InvalidClassInstanceVariable;
+ }
+
+ return (ID3DX11EffectClassInstanceVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
+
+ if (!pType->IsInterface())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidInterfaceVariable;
+ }
+
+ return (ID3DX11EffectInterfaceVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
+
+ if (!pType->IsShaderResource())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidShaderResourceVariable;
+ }
+
+ return (ID3DX11EffectShaderResourceVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
+
+ if (!pType->IsUnorderedAccessView())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidUnorderedAccessViewVariable;
+ }
+
+ return (ID3DX11EffectUnorderedAccessViewVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
+
+ if (!pType->IsRenderTargetView())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidRenderTargetViewVariable;
+ }
+
+ return (ID3DX11EffectRenderTargetViewVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
+
+ if (!pType->IsDepthStencilView())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidDepthStencilViewVariable;
+ }
+
+ return (ID3DX11EffectDepthStencilViewVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidConstantBuffer;
+ }
+
+ STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
+
+ if (!pType->IsShader())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidShaderVariable;
+ }
+
+ return (ID3DX11EffectShaderVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
+
+ if (!pType->IsObjectType(EOT_Blend))
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidBlendVariable;
+ }
+
+ return (ID3DX11EffectBlendVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
+
+ if (!pType->IsObjectType(EOT_DepthStencil))
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidDepthStencilVariable;
+ }
+
+ return (ID3DX11EffectDepthStencilVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
+
+ if (!pType->IsObjectType(EOT_Rasterizer))
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidRasterizerVariable;
+ }
+
+ return (ID3DX11EffectRasterizerVariable *) this;
+ }
+
+ STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)()
+ {
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
+
+ if (!pType->IsSampler())
+ {
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidSamplerVariable;
+ }
+
+ return (ID3DX11EffectSamplerVariable *) this;
+ }
+
+ // Numeric variables should override this
+ STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count)
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return ObjectSetRawValue(); }
+ STDMETHOD(GetRawValue)(_Out_writes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count)
+ { UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return ObjectGetRawValue(); }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// TTopLevelVariable - functionality for annotations and global variables
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TTopLevelVariable : public SVariable, public IBaseInterface
+{
+ // Required to create member/element variable interfaces
+ CEffect *pEffect;
+
+ CEffect* GetEffect()
+ {
+ return pEffect;
+ }
+
+ TTopLevelVariable() : pEffect (nullptr)
+ {
+ }
+
+ uint32_t GetTotalUnpackedSize()
+ {
+ return ((SType*)pType)->GetTotalUnpackedSize(false);
+ }
+
+ STDMETHOD_(ID3DX11EffectType*, GetType)()
+ {
+ return (ID3DX11EffectType*)(SType*)pType;
+ }
+
+ TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
+ {
+ return (TTopLevelVariable<ID3DX11EffectVariable> *)this;
+ }
+
+ bool IsArray()
+ {
+ return (pType->Elements > 0);
+ }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// TMember - functionality for structure/array members of other variables
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TMember : public SVariable, public IBaseInterface
+{
+ // Indicates that this is a single element of a containing array
+ uint32_t IsSingleElement : 1;
+
+ // Required to create member/element variable interfaces
+ TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity;
+
+ TMember()
+ {
+ IsSingleElement = false;
+ pTopLevelEntity = nullptr;
+ }
+
+ CEffect* GetEffect()
+ {
+ return pTopLevelEntity->pEffect;
+ }
+
+ uint32_t GetTotalUnpackedSize()
+ {
+ return pType->GetTotalUnpackedSize(IsSingleElement);
+ }
+
+ STDMETHOD_(ID3DX11EffectType*, GetType)() override
+ {
+ if (IsSingleElement)
+ {
+ return pTopLevelEntity->pEffect->CreatePooledSingleElementTypeInterface( pType );
+ }
+ else
+ {
+ return (ID3DX11EffectType*) pType;
+ }
+ }
+
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override
+ {
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
+
+ VERIFYPARAMETER(pDesc != nullptr);
+
+ pDesc->Name = pName;
+ pDesc->Semantic = pSemantic;
+ pDesc->Flags = 0;
+
+ if (pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity))
+ {
+ // Is part of an annotation
+ assert(pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric));
+ pDesc->Annotations = 0;
+ pDesc->BufferOffset = 0;
+ pDesc->Flags |= D3DX11_EFFECT_VARIABLE_ANNOTATION;
+ }
+ else
+ {
+ // Is part of a global variable
+ assert(pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity));
+ if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
+ {
+ // strings are funny; their data is reflection data, so ignore those
+ assert(pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric));
+ }
+
+ pDesc->Annotations = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->AnnotationCount;
+
+ SConstantBuffer *pCB = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->pCB;
+
+ if (pType->BelongsInConstantBuffer())
+ {
+ assert(pCB != 0);
+ _Analysis_assume_(pCB != 0);
+ UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
+ assert(offset == (uint32_t)offset);
+ pDesc->BufferOffset = (uint32_t)offset;
+ assert(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size);
+ }
+ else
+ {
+ assert(pCB == nullptr);
+ pDesc->BufferOffset = 0;
+ }
+ }
+
+lExit:
+ return hr;
+ }
+
+ TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
+ {
+ return pTopLevelEntity;
+ }
+
+ bool IsArray()
+ {
+ return (pType->Elements > 0 && !IsSingleElement);
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override
+ { return pTopLevelEntity->GetAnnotationByIndex(Index); }
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override
+ { return pTopLevelEntity->GetAnnotationByName(Name); }
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override
+ { return pTopLevelEntity->GetParentConstantBuffer(); }
+
+ // Annotations should never be able to go down this codepath
+ void DirtyVariable()
+ {
+ // make sure to call the global variable's version of dirty variable
+ ((TGlobalVariable<ID3DX11EffectVariable>*)pTopLevelEntity)->DirtyVariable();
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// TAnnotation - functionality for top level annotations
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TAnnotation : public TVariable<TTopLevelVariable<IBaseInterface> >
+{
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override
+ {
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
+
+ VERIFYPARAMETER(pDesc != nullptr);
+
+ pDesc->Name = pName;
+ pDesc->Semantic = pSemantic;
+ pDesc->Flags = D3DX11_EFFECT_VARIABLE_ANNOTATION;
+ pDesc->Annotations = 0;
+ pDesc->BufferOffset = 0;
+ pDesc->ExplicitBindPoint = 0;
+
+lExit:
+ return hr;
+
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override
+ {
+ UNREFERENCED_PARAMETER(Index);
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByIndex";
+ DPF(0, "%s: Only variables may have annotations", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override
+ {
+ UNREFERENCED_PARAMETER(Name);
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByName";
+ DPF(0, "%s: Only variables may have annotations", pFuncName);
+ return &g_InvalidScalarVariable;
+ }
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override
+ { return NoParentCB(); }
+
+ void DirtyVariable()
+ {
+ assert(0);
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// TGlobalVariable - functionality for top level global variables
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TGlobalVariable : public TVariable<TTopLevelVariable<IBaseInterface> >
+{
+ Timer LastModifiedTime;
+
+ // if numeric, pointer to the constant buffer where this variable lives
+ SConstantBuffer *pCB;
+
+ uint32_t AnnotationCount;
+ SAnnotation *pAnnotations;
+
+ TGlobalVariable() :
+ LastModifiedTime(0),
+ pCB(nullptr),
+ AnnotationCount(0),
+ pAnnotations(nullptr)
+ {
+ }
+
+ STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc)
+ {
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
+
+ VERIFYPARAMETER(pDesc != nullptr);
+
+ pDesc->Name = pName;
+ pDesc->Semantic = pSemantic;
+ pDesc->Flags = 0;
+ pDesc->Annotations = AnnotationCount;
+
+ if (pType->BelongsInConstantBuffer())
+ {
+ assert(pCB != 0);
+ _Analysis_assume_(pCB != 0);
+ UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
+ assert(offset == (uint32_t)offset);
+ pDesc->BufferOffset = (uint32_t)offset;
+ assert(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size );
+ }
+ else
+ {
+ assert(pCB == nullptr);
+ pDesc->BufferOffset = 0;
+ }
+
+ if (ExplicitBindPoint != -1)
+ {
+ pDesc->ExplicitBindPoint = ExplicitBindPoint;
+ pDesc->Flags |= D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
+ }
+ else
+ {
+ pDesc->ExplicitBindPoint = 0;
+ }
+
+lExit:
+ return hr;
+ }
+
+ // these are all well defined for global vars
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index)
+ {
+ return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
+ }
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name)
+ {
+ return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
+ }
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
+ {
+ if (nullptr != pCB)
+ {
+ assert(pType->BelongsInConstantBuffer());
+ return (ID3DX11EffectConstantBuffer*)pCB;
+ }
+ else
+ {
+ assert(!pType->BelongsInConstantBuffer());
+ return &g_InvalidConstantBuffer;
+ }
+ }
+
+ inline void DirtyVariable()
+ {
+ assert(pCB != 0);
+ _Analysis_assume_(pCB != 0);
+ pCB->IsDirty = true;
+ LastModifiedTime = pEffect->GetCurrentTime();
+ }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// TNumericVariable - implements raw set/get functionality
+//////////////////////////////////////////////////////////////////////////
+
+// IMPORTANT NOTE: All of these numeric & object aspect classes MUST NOT
+// add data members to the base variable classes. Otherwise type sizes
+// will disagree between object & numeric variables and we cannot eaily
+// create arrays of global variables using SGlobalVariable
+
+// Requires that IBaseInterface have SVariable's members, GetTotalUnpackedSize() and DirtyVariable()
+template<typename IBaseInterface, bool IsAnnotation>
+struct TNumericVariable : public IBaseInterface
+{
+ STDMETHOD(SetRawValue)(_In_reads_bytes_(ByteCount) const void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) override
+ {
+ if (IsAnnotation)
+ {
+ return AnnotationInvalidSetCall("ID3DX11EffectVariable::SetRawValue");
+ }
+ else
+ {
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
+
+ VERIFYPARAMETER(pData);
+
+ if ((ByteOffset + ByteCount < ByteOffset) ||
+ (ByteCount + (uint8_t*)pData < (uint8_t*)pData) ||
+ ((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
+ {
+ // overflow of some kind
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ DirtyVariable();
+ memcpy(Data.pNumeric + ByteOffset, pData, ByteCount);
+
+lExit:
+ return hr;
+ }
+ }
+
+ STDMETHOD(GetRawValue)(_Out_writes_bytes_(ByteCount) void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) override
+ {
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
+
+ VERIFYPARAMETER(pData);
+
+ if ((ByteOffset + ByteCount < ByteOffset) ||
+ (ByteCount + (uint8_t*)pData < (uint8_t*)pData) ||
+ ((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
+ {
+ // overflow of some kind
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ memcpy(pData, Data.pNumeric + ByteOffset, ByteCount);
+
+lExit:
+ return hr;
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectScalarVariable (TFloatScalarVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation>
+struct TFloatScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
+{
+ STDMETHOD(SetFloat)(_In_ const float Value) override;
+ STDMETHOD(GetFloat)(_Out_ float *pValue) override;
+
+ STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetInt)(_In_ const int Value) override;
+ STDMETHOD(GetInt)(_Out_ int *pValue) override;
+
+ STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetBool)(_In_ const bool Value) override;
+ STDMETHOD(GetBool)(_Out_ bool *pValue) override;
+
+ STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Float, ETVT_Float, float, false>(Value, Data.pNumericFloat, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
+{
+ return CopyScalarValue<ETVT_Float, ETVT_Float, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetFloat");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Float, ETVT_Float, float, float>(pData, Data.pNumericFloat, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Float, ETVT_Float, float, float>(Data.pNumericFloat, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetInt(const int Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Int, ETVT_Float, int, false>(Value, Data.pNumericFloat, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
+{
+ return CopyScalarValue<ETVT_Float, ETVT_Int, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetInt");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Int, ETVT_Float, int, float>(pData, Data.pNumericFloat, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Float, ETVT_Int, float, int>(Data.pNumericFloat, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBool(const bool Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_bool, ETVT_Float, bool, false>(Value, Data.pNumericFloat, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
+{
+ return CopyScalarValue<ETVT_Float, ETVT_bool, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetBool");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_bool, ETVT_Float, bool, float>(pData, Data.pNumericFloat, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Float, ETVT_bool, float, bool>(Data.pNumericFloat, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectScalarVariable (TIntScalarVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation>
+struct TIntScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
+{
+ STDMETHOD(SetFloat)(_In_ const float Value) override;
+ STDMETHOD(GetFloat)(_Out_ float *pValue) override;
+
+ STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetInt)(_In_ const int Value) override;
+ STDMETHOD(GetInt)(_Out_ int *pValue) override;
+
+ STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetBool)(_In_ const bool Value) override;
+ STDMETHOD(GetBool)(_Out_ bool *pValue) override;
+
+ STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Float, ETVT_Int, float, false>(Value, Data.pNumericInt, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
+{
+ return CopyScalarValue<ETVT_Int, ETVT_Float, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetFloat");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Float, ETVT_Int, float, int>(pData, Data.pNumericInt, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Int, ETVT_Float, int, float>(Data.pNumericInt, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetInt(const int Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Int, ETVT_Int, int, false>(Value, Data.pNumericInt, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
+{
+ return CopyScalarValue<ETVT_Int, ETVT_Int, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetInt");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Int, ETVT_Int, int, int>(pData, Data.pNumericInt, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Int, ETVT_Int, int, int>(Data.pNumericInt, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBool(const bool Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_bool, ETVT_Int, bool, false>(Value, Data.pNumericInt, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
+{
+ return CopyScalarValue<ETVT_Int, ETVT_bool, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetBool");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_bool, ETVT_Int, bool, int>(pData, Data.pNumericInt, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Int, ETVT_bool, int, bool>(Data.pNumericInt, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectScalarVariable (TBoolScalarVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation>
+struct TBoolScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
+{
+ STDMETHOD(SetFloat)(_In_ const float Value) override;
+ STDMETHOD(GetFloat)(_Out_ float *pValue) override;
+
+ STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetInt)(_In_ const int Value) override;
+ STDMETHOD(GetInt)(_Out_ int *pValue) override;
+
+ STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetBool)(_In_ const bool Value) override;
+ STDMETHOD(GetBool)(_Out_ bool *pValue) override;
+
+ STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Float, ETVT_Bool, float, false>(Value, Data.pNumericBool, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
+{
+ return CopyScalarValue<ETVT_Bool, ETVT_Float, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetFloat");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Float, ETVT_Bool, float, BOOL>(pData, Data.pNumericBool, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Bool, ETVT_Float, BOOL, float>(Data.pNumericBool, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetInt(const int Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_Int, ETVT_Bool, int, false>(Value, Data.pNumericBool, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
+{
+ return CopyScalarValue<ETVT_Bool, ETVT_Int, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetInt");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_Int, ETVT_Bool, int, BOOL>(pData, Data.pNumericBool, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Bool, ETVT_Int, BOOL, int>(Data.pNumericBool, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBool(const bool Value)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return CopyScalarValue<ETVT_bool, ETVT_Bool, bool, false>(Value, Data.pNumericBool, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
+{
+ return CopyScalarValue<ETVT_Bool, ETVT_bool, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetBool");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return SetScalarArray<ETVT_bool, ETVT_Bool, bool, BOOL>(pData, Data.pNumericBool, Offset, Count,
+ pType, GetTotalUnpackedSize(), pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
+{
+ return GetScalarArray<ETVT_Bool, ETVT_bool, BOOL, bool>(Data.pNumericBool, pData, Offset, Count,
+ pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectVectorVariable (TVectorVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType >
+struct TVectorVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
+{
+ STDMETHOD(SetBoolVector) (_In_reads_(4) const bool *pData) override;
+ STDMETHOD(SetIntVector) (_In_reads_(4) const int *pData) override;
+ STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override;
+
+ STDMETHOD(GetBoolVector) (_Out_writes_(4) bool *pData) override;
+ STDMETHOD(GetIntVector) (_Out_writes_(4) int *pData) override;
+ STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override;
+
+
+ STDMETHOD(SetBoolVectorArray) (_In_reads_(Count*4) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(SetIntVectorArray) (_In_reads_(Count*4) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(SetFloatVectorArray)(_In_reads_(Count*4) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(GetBoolVectorArray) (_Out_writes_(Count*4) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetIntVectorArray) (_Out_writes_(Count*4) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetFloatVectorArray)(_Out_writes_(Count*4) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+// Note that branches in this code is based on template parameters and will be compiled out
+#pragma warning (push)
+#pragma warning (disable : 6101)
+template <ETemplateVarType DestType, ETemplateVarType SourceType>
+void __forceinline CopyDataWithTypeConversion(_Out_ void *pDest,
+ _In_ const void *pSource,
+ _In_ size_t dstVecSize, _In_ size_t srcVecSize,
+ _In_ size_t elementCount, _In_ size_t vecCount)
+{
+ switch (SourceType)
+ {
+ case ETVT_Bool:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ memcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Int:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((int*)pDest)[i] = ((bool*)pSource)[i] ? -1 : 0;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Float:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((float*)pDest)[i] = ((bool*)pSource)[i] ? -1.0f : 0.0f;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((bool*)pDest)[i] = (((int*)pSource)[i] != 0) ? true : false;
+
+ pDest = ((bool*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_Int:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((int*)pDest)[i] = (((int*)pSource)[i] != 0) ? -1 : 0;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Int:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ memcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Float:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((float*)pDest)[i] = (float)(((int*)pSource)[i]);
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((bool*)pDest)[i] = (((int*)pSource)[i] != 0) ? true : false;
+
+ pDest = ((bool*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_Float:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((int*)pDest)[i] = (((float*)pSource)[i] != 0.0f) ? -1 : 0;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Int:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((int*)pDest)[i] = (int)((float*)pSource)[i];
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Float:
+ for (size_t i=0; i<vecCount; i++)
+ {
+ memcpy( pDest, pSource, elementCount * SType::c_ScalarSize);
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ ((bool*)pDest)[i] = (((float*)pSource)[i] != 0.0f) ? true : false;
+
+ pDest = ((bool*) pDest) + dstVecSize;
+ pSource = ((float*) pSource) + srcVecSize;
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ case ETVT_bool:
+ switch (DestType)
+ {
+ case ETVT_Bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ reinterpret_cast<int*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1 : 0;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((bool*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Int:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ reinterpret_cast<int*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1 : 0;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((bool*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_Float:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ for (size_t i=0; i<elementCount; i++)
+ reinterpret_cast<float*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1.0f : 0.0f;
+
+ pDest = ((float*) pDest) + dstVecSize;
+ pSource = ((bool*) pSource) + srcVecSize;
+ }
+ break;
+
+ case ETVT_bool:
+ for (size_t j=0; j<vecCount; j++)
+ {
+ memcpy(pDest, pSource, elementCount);
+
+ pDest = ((bool*) pDest) + dstVecSize;
+ pSource = ((bool*) pSource) + srcVecSize;
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+ break;
+
+ default:
+ assert(0);
+ }
+}
+#pragma warning (pop)
+
+// Float Vector
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetFloatVector(const float *pData)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVector(float *pData)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+// Int Vector
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetIntVector(const int *pData)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVector(int *pData)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVector";
+ VERIFYPARAMETER(pData);
+#endif
+
+ CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+// Bool Vector
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetBoolVector(const bool *pData)
+{
+ HRESULT hr = S_OK;
+
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ CopyDataWithTypeConversion<BaseType, ETVT_bool>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVector(bool *pData)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVector";
+ VERIFYPARAMETER(pData);
+#endif
+
+ CopyDataWithTypeConversion<ETVT_bool, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
+
+lExit:
+ return hr;
+}
+
+// Vector Arrays /////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetFloatVectorArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ // ensure we don't write over the padding at the end of the vector array
+ CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVectorArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ // ensure we don't read past the end of the vector array
+ CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+// int
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetIntVectorArray(const int *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ // ensure we don't write over the padding at the end of the vector array
+ CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVectorArray(int *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ // ensure we don't read past the end of the vector array
+ CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+// bool
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetBoolVectorArray(const bool *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ // ensure we don't write over the padding at the end of the vector array
+ CopyDataWithTypeConversion<BaseType, ETVT_bool>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
+_Use_decl_annotations_
+HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVectorArray(bool *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ // ensure we don't read past the end of the vector array
+ CopyDataWithTypeConversion<ETVT_bool, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectVector4Variable (TVectorVariable implementation) [OPTIMIZED]
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TVector4Variable : public TVectorVariable<IBaseInterface, false, ETVT_Float>
+{
+ STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override;
+ STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override;
+
+ STDMETHOD(SetFloatVectorArray)(_In_reads_(Count*4) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetFloatVectorArray)(_Out_writes_(Count*4) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TVector4Variable<IBaseInterface>::SetFloatVector(const float *pData)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ DirtyVariable();
+ Data.pVector[0] = ((CEffectVector4*) pData)[0];
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TVector4Variable<IBaseInterface>::GetFloatVector(float *pData)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(pData);
+#endif
+
+ memcpy(pData, Data.pVector, pType->NumericType.Columns * SType::c_ScalarSize);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TVector4Variable<IBaseInterface>::SetFloatVectorArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ DirtyVariable();
+ // ensure we don't write over the padding at the end of the vector array
+ memcpy(Data.pVector + Offset, pData, std::min<size_t>((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TVector4Variable<IBaseInterface>::GetFloatVectorArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#endif
+
+ // ensure we don't read past the end of the vector array
+ memcpy(pData, Data.pVector + Offset, std::min<size_t>((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));
+
+lExit:
+ return hr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectMatrixVariable (TMatrixVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation>
+struct TMatrixVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
+{
+ STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override;
+ STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override;
+
+ STDMETHOD(SetMatrixArray)(_In_reads_(Count*16) const float *pData, uint32_t Offset, uint32_t Count) override;
+ STDMETHOD(GetMatrixArray)(_Out_writes_(Count*16) float *pData, uint32_t Offset, uint32_t Count) override;
+
+ STDMETHOD(SetMatrixPointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) override;
+ STDMETHOD(GetMatrixPointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) override;
+
+ STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override;
+ STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override;
+
+ STDMETHOD(SetMatrixTransposeArray)(_In_reads_(Count*16) const float *pData, uint32_t Offset, uint32_t Count) override;
+ STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(Count*16) float *pData, uint32_t Offset, uint32_t Count) override;
+
+ STDMETHOD(SetMatrixTransposePointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) override;
+ STDMETHOD(GetMatrixTransposePointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) override;
+};
+
+#pragma warning (push)
+#pragma warning (disable : 6101)
+template<bool Transpose>
+static void SetMatrixTransposeHelper(_In_ const SType *pType, _Out_writes_bytes_(64) uint8_t *pDestData, _In_reads_(16) const float* pMatrix)
+{
+ uint32_t registers, entries;
+
+ if (Transpose)
+ {
+ // row major
+ registers = pType->NumericType.Rows;
+ entries = pType->NumericType.Columns;
+ }
+ else
+ {
+ // column major
+ registers = pType->NumericType.Columns;
+ entries = pType->NumericType.Rows;
+ }
+ _Analysis_assume_( registers <= 4 );
+ _Analysis_assume_( entries <= 4 );
+
+ for (size_t i = 0; i < registers; ++ i)
+ {
+ for (size_t j = 0; j < entries; ++ j)
+ {
+#pragma prefast(suppress:__WARNING_UNRELATED_LOOP_TERMINATION, "regs / entries <= 4")
+ ((float*)pDestData)[j] = ((float*)pMatrix)[j * 4 + i];
+ }
+ pDestData += SType::c_RegisterSize;
+ }
+}
+
+template<bool Transpose>
+static void GetMatrixTransposeHelper(_In_ const SType *pType, _In_reads_bytes_(64) uint8_t *pSrcData, _Out_writes_(16) float* pMatrix)
+{
+ uint32_t registers, entries;
+
+ if (Transpose)
+ {
+ // row major
+ registers = pType->NumericType.Rows;
+ entries = pType->NumericType.Columns;
+ }
+ else
+ {
+ // column major
+ registers = pType->NumericType.Columns;
+ entries = pType->NumericType.Rows;
+ }
+ _Analysis_assume_( registers <= 4 );
+ _Analysis_assume_( entries <= 4 );
+
+ for (size_t i = 0; i < registers; ++ i)
+ {
+ for (size_t j = 0; j < entries; ++ j)
+ {
+ ((float*)pMatrix)[j * 4 + i] = ((float*)pSrcData)[j];
+ }
+ pSrcData += SType::c_RegisterSize;
+ }
+}
+
+template<bool Transpose, bool IsSetting, bool ExtraIndirection>
+HRESULT DoMatrixArrayInternal(_In_ const SType *pType, _In_ uint32_t TotalUnpackedSize,
+ _Out_ uint8_t *pEffectData,
+ void *pMatrixData,
+ _In_ uint32_t Offset, _In_ uint32_t Count, _In_z_ LPCSTR pFuncName)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+#else
+ UNREFERENCED_PARAMETER(TotalUnpackedSize);
+ UNREFERENCED_PARAMETER(pFuncName);
+#endif
+
+ if ((pType->NumericType.IsColumnMajor && Transpose) || (!pType->NumericType.IsColumnMajor && !Transpose))
+ {
+ // fast path
+ uint32_t dataSize;
+ if (Transpose)
+ {
+ dataSize = ((pType->NumericType.Columns - 1) * 4 + pType->NumericType.Rows) * SType::c_ScalarSize;
+ }
+ else
+ {
+ dataSize = ((pType->NumericType.Rows - 1) * 4 + pType->NumericType.Columns) * SType::c_ScalarSize;
+ }
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ CEffectMatrix *pMatrix;
+ if (ExtraIndirection)
+ {
+ pMatrix = ((CEffectMatrix **)pMatrixData)[i];
+ if (!pMatrix)
+ {
+ continue;
+ }
+ }
+ else
+ {
+ pMatrix = ((CEffectMatrix *)pMatrixData) + i;
+ }
+
+ if (IsSetting)
+ {
+ memcpy(pEffectData + pType->Stride * (i + Offset), pMatrix, dataSize);
+ }
+ else
+ {
+ memcpy(pMatrix, pEffectData + pType->Stride * (i + Offset), dataSize);
+ }
+ }
+ }
+ else
+ {
+ // slow path
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ CEffectMatrix *pMatrix;
+ if (ExtraIndirection)
+ {
+ pMatrix = ((CEffectMatrix **)pMatrixData)[i];
+ if (!pMatrix)
+ {
+ continue;
+ }
+ }
+ else
+ {
+ pMatrix = ((CEffectMatrix *)pMatrixData) + i;
+ }
+
+ if (IsSetting)
+ {
+ SetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
+ }
+ else
+ {
+ GetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
+ }
+ }
+ }
+
+lExit:
+ return hr;
+}
+#pragma warning (pop)
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrix(const float *pData)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrix";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<false, true, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float*>(pData), 0, 1, pFuncName);
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrix(float *pData)
+{
+ return DoMatrixArrayInternal<false, false, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrix");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<false, true, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrixArrayInternal<false, false, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixPointerArray(const float **ppData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixPointerArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<false, true, true>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixPointerArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixPointerArray(float **ppData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrixArrayInternal<false, false, true>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixPointerArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTranspose(const float *pData)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTranspose";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<true, true, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float*>(pData), 0, 1, "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTranspose(float *pData)
+{
+ return DoMatrixArrayInternal<true, false, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposeArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<true, true, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposeArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrixArrayInternal<true, false, false>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposePointerArray(const float **ppData, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray";
+ if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
+ DirtyVariable();
+ return DoMatrixArrayInternal<true, true, true>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray");
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposePointerArray(float **ppData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrixArrayInternal<true, false, true>(pType, GetTotalUnpackedSize(),
+ Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposePointerArray");
+}
+
+// Optimize commonly used fast paths
+// (non-annotations only!)
+template<typename IBaseInterface, bool IsColumnMajor>
+struct TMatrix4x4Variable : public TMatrixVariable<IBaseInterface, false>
+{
+ STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override;
+ STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override;
+
+ STDMETHOD(SetMatrixArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetMatrixArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+
+ STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override;
+ STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override;
+
+ STDMETHOD(SetMatrixTransposeArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+inline static void Matrix4x4TransposeHelper(_In_reads_bytes_(64) const void *pSrc, _Out_writes_bytes_(64) void *pDst)
+{
+ uint8_t *pDestData = (uint8_t*)pDst;
+ uint32_t *pMatrix = (uint32_t*)pSrc;
+
+ ((uint32_t*)pDestData)[0 * 4 + 0] = pMatrix[0 * 4 + 0];
+ ((uint32_t*)pDestData)[0 * 4 + 1] = pMatrix[1 * 4 + 0];
+ ((uint32_t*)pDestData)[0 * 4 + 2] = pMatrix[2 * 4 + 0];
+ ((uint32_t*)pDestData)[0 * 4 + 3] = pMatrix[3 * 4 + 0];
+
+ ((uint32_t*)pDestData)[1 * 4 + 0] = pMatrix[0 * 4 + 1];
+ ((uint32_t*)pDestData)[1 * 4 + 1] = pMatrix[1 * 4 + 1];
+ ((uint32_t*)pDestData)[1 * 4 + 2] = pMatrix[2 * 4 + 1];
+ ((uint32_t*)pDestData)[1 * 4 + 3] = pMatrix[3 * 4 + 1];
+
+ ((uint32_t*)pDestData)[2 * 4 + 0] = pMatrix[0 * 4 + 2];
+ ((uint32_t*)pDestData)[2 * 4 + 1] = pMatrix[1 * 4 + 2];
+ ((uint32_t*)pDestData)[2 * 4 + 2] = pMatrix[2 * 4 + 2];
+ ((uint32_t*)pDestData)[2 * 4 + 3] = pMatrix[3 * 4 + 2];
+
+ ((uint32_t*)pDestData)[3 * 4 + 0] = pMatrix[0 * 4 + 3];
+ ((uint32_t*)pDestData)[3 * 4 + 1] = pMatrix[1 * 4 + 3];
+ ((uint32_t*)pDestData)[3 * 4 + 2] = pMatrix[2 * 4 + 3];
+ ((uint32_t*)pDestData)[3 * 4 + 3] = pMatrix[3 * 4 + 3];
+}
+
+inline static void Matrix4x4Copy(_In_reads_bytes_(64) const void *pSrc, _Out_writes_bytes_(64) void *pDst)
+{
+#if 1
+ // In tests, this path ended up generating faster code both on x86 and x64
+ // T1 - Matrix4x4Copy - this path
+ // T2 - Matrix4x4Transpose
+ // T1: 1.88 T2: 1.92 - with 32 bit copies
+ // T1: 1.85 T2: 1.80 - with 64 bit copies
+
+ uint64_t *pDestData = (uint64_t*)pDst;
+ uint64_t *pMatrix = (uint64_t*)pSrc;
+
+ pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
+ pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
+ pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
+ pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
+
+ pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
+ pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
+ pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
+ pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
+#else
+ uint32_t *pDestData = (uint32_t*)pDst;
+ uint32_t *pMatrix = (uint32_t*)pSrc;
+
+ pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
+ pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
+ pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
+ pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
+
+ pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
+ pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
+ pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
+ pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
+
+ pDestData[2 * 4 + 0] = pMatrix[2 * 4 + 0];
+ pDestData[2 * 4 + 1] = pMatrix[2 * 4 + 1];
+ pDestData[2 * 4 + 2] = pMatrix[2 * 4 + 2];
+ pDestData[2 * 4 + 3] = pMatrix[2 * 4 + 3];
+
+ pDestData[3 * 4 + 0] = pMatrix[3 * 4 + 0];
+ pDestData[3 * 4 + 1] = pMatrix[3 * 4 + 1];
+ pDestData[3 * 4 + 2] = pMatrix[3 * 4 + 2];
+ pDestData[3 * 4 + 3] = pMatrix[3 * 4 + 3];
+#endif
+}
+
+
+// Note that branches in this code is based on template parameters and will be compiled out
+#pragma warning (push)
+#pragma warning (disable : 6101)
+template<bool IsColumnMajor, bool Transpose, bool IsSetting>
+inline HRESULT DoMatrix4x4ArrayInternal(_In_ uint8_t *pEffectData,
+ _When_(IsSetting, _In_reads_bytes_(64 * Count))
+ _When_(!IsSetting, _Out_writes_bytes_(64 * Count))
+ void *pMatrixData,
+ _In_ uint32_t Offset, _In_ uint32_t Count
+#ifdef _DEBUG
+ , _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ LPCSTR pFuncName
+#endif
+
+ )
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+#pragma warning( suppress : 6001 )
+ if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
+ {
+ DPF(0, "%s: Invalid range specified", pFuncName);
+ VH(E_INVALIDARG);
+ }
+
+ assert(pType->NumericType.IsColumnMajor == IsColumnMajor && pType->Stride == (4 * SType::c_RegisterSize));
+#endif
+
+ if ((IsColumnMajor && Transpose) || (!IsColumnMajor && !Transpose))
+ {
+ // fast path
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
+
+ if (IsSetting)
+ {
+ Matrix4x4Copy(pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
+ }
+ else
+ {
+ Matrix4x4Copy(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), pMatrix);
+ }
+ }
+ }
+ else
+ {
+ // slow path
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
+
+ if (IsSetting)
+ {
+ Matrix4x4TransposeHelper((float*) pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
+ }
+ else
+ {
+ Matrix4x4TransposeHelper(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), (float*) pMatrix);
+ }
+ }
+ }
+
+lExit:
+ return hr;
+}
+#pragma warning (pop)
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrix(const float *pData)
+{
+ DirtyVariable();
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, false, true>(Data.pNumeric, const_cast<float*>(pData), 0, 1
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrix");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrix(float *pData)
+{
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, false, false>(Data.pNumeric, pData, 0, 1
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrix");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ DirtyVariable();
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, false, true>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixArray");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, false, false>(Data.pNumeric, pData, Offset, Count
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixArray");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTranspose(const float *pData)
+{
+ DirtyVariable();
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, true, true>(Data.pNumeric, const_cast<float*>(pData), 0, 1
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTranspose(float *pData)
+{
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, true, false>(Data.pNumeric, pData, 0, 1
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTransposeArray(const float *pData, uint32_t Offset, uint32_t Count)
+{
+ DirtyVariable();
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, true, true>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
+#else
+ );
+#endif
+}
+
+template<typename IBaseInterface, bool IsColumnMajor>
+_Use_decl_annotations_
+HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTransposeArray(float *pData, uint32_t Offset, uint32_t Count)
+{
+ return DoMatrix4x4ArrayInternal<IsColumnMajor, true, false>(Data.pNumeric, pData, Offset, Count
+#ifdef _DEBUG
+ , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
+#else
+ );
+#endif
+}
+
+#ifdef _DEBUG
+
+// Useful object macro to check bounds and parameters
+#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
+ HRESULT hr = S_OK; \
+ VERIFYPARAMETER(Pointer) \
+ uint32_t elements = IsArray() ? pType->Elements : 1; \
+ \
+ if ((Offset + Count < Offset) || (elements < Offset + Count)) \
+ { \
+ DPF(0, "%s: Invalid range specified", pFuncName); \
+ VH(E_INVALIDARG); \
+ } \
+
+#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
+ HRESULT hr = S_OK; \
+ VERIFYPARAMETER(Pointer) \
+ uint32_t elements = IsArray() ? pType->Elements : 1; \
+ \
+ if (Index >= elements) \
+ { \
+ DPF(0, "%s: Invalid index specified", pFuncName); \
+ VH(E_INVALIDARG); \
+ } \
+
+#define CHECK_SCALAR_BOUNDS(Index) \
+ HRESULT hr = S_OK; \
+ uint32_t elements = IsArray() ? pType->Elements : 1; \
+ \
+ if (Index >= elements) \
+{ \
+ DPF(0, "%s: Invalid index specified", pFuncName); \
+ VH(E_INVALIDARG); \
+} \
+
+#else // _DEBUG
+
+#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
+ HRESULT hr = S_OK; \
+
+#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
+ HRESULT hr = S_OK; \
+
+#define CHECK_SCALAR_BOUNDS(Index) \
+ HRESULT hr = S_OK; \
+
+#endif // _DEBUG
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectStringVariable (TStringVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface, bool IsAnnotation>
+struct TStringVariable : public IBaseInterface
+{
+ STDMETHOD(GetString)(_Outptr_result_z_ LPCSTR *ppString) override;
+ STDMETHOD(GetStringArray)( _Out_writes_(Count) LPCSTR *ppStrings, _In_ uint32_t Offset, _In_ uint32_t Count ) override;
+};
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetString(LPCSTR *ppString)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetString";
+
+ VERIFYPARAMETER(ppString);
+
+ if (GetTopLevelEntity()->pEffect->IsOptimized())
+ {
+ DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
+ return D3DERR_INVALIDCALL;
+ }
+
+ assert(Data.pString != 0);
+ _Analysis_assume_(Data.pString != 0);
+
+ *ppString = Data.pString->pString;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface, bool IsAnnotation>
+_Use_decl_annotations_
+#pragma warning(suppress : 6054)
+HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetStringArray( LPCSTR *ppStrings, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetStringArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppStrings);
+
+ if (GetTopLevelEntity()->pEffect->IsOptimized())
+ {
+ DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
+ return D3DERR_INVALIDCALL;
+ }
+
+ assert(Data.pString != 0);
+ _Analysis_assume_(Data.pString != 0);
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ ppStrings[i] = (Data.pString + Offset + i)->pString;
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectClassInstanceVariable (TClassInstanceVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TClassInstanceVariable : public IBaseInterface
+{
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3D11ClassInstance **ppClassInstance) override;
+};
+
+template<typename IBaseClassInstance>
+HRESULT TClassInstanceVariable<IBaseClassInstance>::GetClassInstance(_Outptr_ ID3D11ClassInstance** ppClassInstance)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectClassInstanceVariable::GetClassInstance";
+
+ assert( pMemberData != 0 && pMemberData->Data.pD3DClassInstance != 0);
+ _Analysis_assume_( pMemberData != 0 && pMemberData->Data.pD3DClassInstance != 0);
+ *ppClassInstance = pMemberData->Data.pD3DClassInstance;
+ SAFE_ADDREF(*ppClassInstance);
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectInterfaceeVariable (TInterfaceVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TInterfaceVariable : public IBaseInterface
+{
+ STDMETHOD(SetClassInstance)(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance) override;
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) override;
+};
+
+template<typename IBaseInterface>
+HRESULT TInterfaceVariable<IBaseInterface>::SetClassInstance(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::SetClassInstance";
+
+ // Note that we don't check if the types are compatible. The debug layer will complain if it is.
+ // IsValid() will not catch type mismatches.
+ SClassInstanceGlobalVariable* pCI = (SClassInstanceGlobalVariable*)pEffectClassInstance;
+ Data.pInterface->pClassInstance = pCI;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+HRESULT TInterfaceVariable<IBaseInterface>::GetClassInstance(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance)
+{
+ HRESULT hr = S_OK;
+ static LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::GetClassInstance";
+
+#ifdef _DEBUG
+ VERIFYPARAMETER(ppEffectClassInstance);
+#endif
+
+ *ppEffectClassInstance = Data.pInterface->pClassInstance;
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderResourceVariable (TShaderResourceVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TShaderResourceVariable : public IBaseInterface
+{
+ STDMETHOD(SetResource)(_In_ ID3D11ShaderResourceView *pResource) override;
+ STDMETHOD(GetResource)(_Outptr_ ID3D11ShaderResourceView **ppResource) override;
+
+ STDMETHOD(SetResourceArray)(_In_reads_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetResourceArray)(_Out_writes_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+static LPCSTR GetTextureTypeNameFromEnum(_In_ EObjectType ObjectType)
+{
+ switch (ObjectType)
+ {
+ case EOT_Buffer:
+ return "Buffer";
+ case EOT_Texture:
+ return "texture";
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ return "Texture1D";
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ return "Texture2DMS";
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ return "Texture2D";
+ case EOT_Texture3D:
+ return "Texture3D";
+ case EOT_TextureCube:
+ return "TextureCube";
+ case EOT_TextureCubeArray:
+ return "TextureCubeArray";
+ case EOT_RWTexture1D:
+ case EOT_RWTexture1DArray:
+ return "RWTexture1D";
+ case EOT_RWTexture2D:
+ case EOT_RWTexture2DArray:
+ return "RWTexture2D";
+ case EOT_RWTexture3D:
+ return "RWTexture3D";
+ case EOT_RWBuffer:
+ return "RWBuffer";
+ case EOT_ByteAddressBuffer:
+ return "ByteAddressBuffer";
+ case EOT_RWByteAddressBuffer:
+ return "RWByteAddressBuffer";
+ case EOT_StructuredBuffer:
+ return "StructuredBuffe";
+ case EOT_RWStructuredBuffer:
+ return "RWStructuredBuffer";
+ case EOT_RWStructuredBufferAlloc:
+ return "RWStructuredBufferAlloc";
+ case EOT_RWStructuredBufferConsume:
+ return "RWStructuredBufferConsume";
+ case EOT_AppendStructuredBuffer:
+ return "AppendStructuredBuffer";
+ case EOT_ConsumeStructuredBuffer:
+ return "ConsumeStructuredBuffer";
+ }
+ return "<unknown texture format>";
+}
+
+static LPCSTR GetResourceDimensionNameFromEnum(_In_ D3D11_RESOURCE_DIMENSION ResourceDimension)
+{
+ switch (ResourceDimension)
+ {
+ case D3D11_RESOURCE_DIMENSION_BUFFER:
+ return "Buffer";
+ case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
+ return "Texture1D";
+ case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
+ return "Texture2D";
+ case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
+ return "Texture3D";
+ }
+ return "<unknown texture format>";
+}
+
+static LPCSTR GetSRVDimensionNameFromEnum(_In_ D3D11_SRV_DIMENSION ViewDimension)
+{
+ switch (ViewDimension)
+ {
+ case D3D11_SRV_DIMENSION_BUFFER:
+ case D3D11_SRV_DIMENSION_BUFFEREX:
+ return "Buffer";
+ case D3D11_SRV_DIMENSION_TEXTURE1D:
+ return "Texture1D";
+ case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
+ return "Texture1DArray";
+ case D3D11_SRV_DIMENSION_TEXTURE2D:
+ return "Texture2D";
+ case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
+ return "Texture2DArray";
+ case D3D11_SRV_DIMENSION_TEXTURE2DMS:
+ return "Texture2DMS";
+ case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
+ return "Texture2DMSArray";
+ case D3D11_SRV_DIMENSION_TEXTURE3D:
+ return "Texture3D";
+ case D3D11_SRV_DIMENSION_TEXTURECUBE:
+ return "TextureCube";
+ }
+ return "<unknown texture format>";
+}
+
+static LPCSTR GetUAVDimensionNameFromEnum(_In_ D3D11_UAV_DIMENSION ViewDimension)
+{
+ switch (ViewDimension)
+ {
+ case D3D11_UAV_DIMENSION_BUFFER:
+ return "Buffer";
+ case D3D11_UAV_DIMENSION_TEXTURE1D:
+ return "RWTexture1D";
+ case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
+ return "RWTexture1DArray";
+ case D3D11_UAV_DIMENSION_TEXTURE2D:
+ return "RWTexture2D";
+ case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
+ return "RWTexture2DArray";
+ case D3D11_UAV_DIMENSION_TEXTURE3D:
+ return "RWTexture3D";
+ }
+ return "<unknown texture format>";
+}
+
+static LPCSTR GetRTVDimensionNameFromEnum(_In_ D3D11_RTV_DIMENSION ViewDimension)
+{
+ switch (ViewDimension)
+ {
+ case D3D11_RTV_DIMENSION_BUFFER:
+ return "Buffer";
+ case D3D11_RTV_DIMENSION_TEXTURE1D:
+ return "Texture1D";
+ case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
+ return "Texture1DArray";
+ case D3D11_RTV_DIMENSION_TEXTURE2D:
+ return "Texture2D";
+ case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
+ return "Texture2DArray";
+ case D3D11_RTV_DIMENSION_TEXTURE2DMS:
+ return "Texture2DMS";
+ case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
+ return "Texture2DMSArray";
+ case D3D11_RTV_DIMENSION_TEXTURE3D:
+ return "Texture3D";
+ }
+ return "<unknown texture format>";
+}
+
+static LPCSTR GetDSVDimensionNameFromEnum(_In_ D3D11_DSV_DIMENSION ViewDimension)
+{
+ switch (ViewDimension)
+ {
+ case D3D11_DSV_DIMENSION_TEXTURE1D:
+ return "Texture1D";
+ case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
+ return "Texture1DArray";
+ case D3D11_DSV_DIMENSION_TEXTURE2D:
+ return "Texture2D";
+ case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
+ return "Texture2DArray";
+ case D3D11_DSV_DIMENSION_TEXTURE2DMS:
+ return "Texture2DMS";
+ case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
+ return "Texture2DMSArray";
+ }
+ return "<unknown texture format>";
+}
+
+static HRESULT ValidateTextureType(_In_ ID3D11ShaderResourceView *pView, _In_ EObjectType ObjectType, _In_z_ LPCSTR pFuncName)
+{
+ if (nullptr != pView)
+ {
+ D3D11_SHADER_RESOURCE_VIEW_DESC desc;
+ pView->GetDesc(&desc);
+ switch (ObjectType)
+ {
+ case EOT_Texture:
+ if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
+ return S_OK;
+ break;
+ case EOT_Buffer:
+ if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
+ break;
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, ByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ else
+ {
+ ID3D11Buffer* pBuffer = nullptr;
+ pView->GetResource( (ID3D11Resource**)&pBuffer );
+ assert( pBuffer != nullptr );
+ D3D11_BUFFER_DESC BufDesc;
+ pBuffer->GetDesc( &BufDesc );
+ SAFE_RELEASE( pBuffer );
+ if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, StructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ else
+ {
+ return S_OK;
+ }
+ }
+ break;
+ case EOT_Texture1D:
+ case EOT_Texture1DArray:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1D ||
+ desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
+ return S_OK;
+ break;
+ case EOT_Texture2D:
+ case EOT_Texture2DArray:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2D ||
+ desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DARRAY)
+ return S_OK;
+ break;
+ case EOT_Texture2DMS:
+ case EOT_Texture2DMSArray:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMS ||
+ desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY)
+ return S_OK;
+ break;
+ case EOT_Texture3D:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE3D)
+ return S_OK;
+ break;
+ case EOT_TextureCube:
+ case EOT_TextureCubeArray:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBE ||
+ desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
+ return S_OK;
+ break;
+ case EOT_ByteAddressBuffer:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
+ return S_OK;
+ break;
+ case EOT_StructuredBuffer:
+ if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX || desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFER)
+ {
+ ID3D11Buffer* pBuffer = nullptr;
+ pView->GetResource( (ID3D11Resource**)&pBuffer );
+ assert( pBuffer != nullptr );
+ D3D11_BUFFER_DESC BufDesc;
+ pBuffer->GetDesc( &BufDesc );
+ SAFE_RELEASE( pBuffer );
+ if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
+ {
+ return S_OK;
+ }
+ else
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ }
+ break;
+ default:
+ assert(0); // internal error, should never get here
+ return E_FAIL;
+ }
+
+
+ DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetSRVDimensionNameFromEnum(desc.ViewDimension));
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderResourceVariable<IBaseInterface>::SetResource(ID3D11ShaderResourceView *pResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResource";
+
+ VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
+#endif
+
+ // Texture variables don't need to be dirtied.
+ SAFE_ADDREF(pResource);
+ SAFE_RELEASE(Data.pShaderResource->pShaderResource);
+ Data.pShaderResource->pShaderResource = pResource;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderResourceVariable<IBaseInterface>::GetResource(ID3D11ShaderResourceView **ppResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResource";
+
+ VERIFYPARAMETER(ppResource);
+#endif
+
+ assert(Data.pShaderResource != 0 && Data.pShaderResource->pShaderResource != 0);
+ _Analysis_assume_(Data.pShaderResource != 0 && Data.pShaderResource->pShaderResource != 0);
+ *ppResource = Data.pShaderResource->pShaderResource;
+ SAFE_ADDREF(*ppResource);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderResourceVariable<IBaseInterface>::SetResourceArray(ID3D11ShaderResourceView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResourceArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+#ifdef _DEBUG
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
+ }
+#endif
+
+ // Texture variables don't need to be dirtied.
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ SShaderResource *pResourceBlock = Data.pShaderResource + Offset + i;
+ SAFE_ADDREF(ppResources[i]);
+ SAFE_RELEASE(pResourceBlock->pShaderResource);
+ pResourceBlock->pShaderResource = ppResources[i];
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderResourceVariable<IBaseInterface>::GetResourceArray(ID3D11ShaderResourceView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResourceArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ ppResources[i] = (Data.pShaderResource + Offset + i)->pShaderResource;
+ SAFE_ADDREF(ppResources[i]);
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectUnorderedAccessViewVariable (TUnorderedAccessViewVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TUnorderedAccessViewVariable : public IBaseInterface
+{
+ STDMETHOD(SetUnorderedAccessView)(_In_ ID3D11UnorderedAccessView *pResource) override;
+ STDMETHOD(GetUnorderedAccessView)(_Outptr_ ID3D11UnorderedAccessView **ppResource) override;
+
+ STDMETHOD(SetUnorderedAccessViewArray)(_In_reads_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetUnorderedAccessViewArray)(_Out_writes_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+static HRESULT ValidateTextureType(_In_ ID3D11UnorderedAccessView *pView, _In_ EObjectType ObjectType, _In_z_ LPCSTR pFuncName)
+{
+ if (nullptr != pView)
+ {
+ D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
+ pView->GetDesc(&desc);
+ switch (ObjectType)
+ {
+ case EOT_RWBuffer:
+ if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
+ break;
+ if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW)
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, RWByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ else
+ {
+ ID3D11Buffer* pBuffer = nullptr;
+ pView->GetResource( (ID3D11Resource**)&pBuffer );
+ assert( pBuffer != nullptr );
+ D3D11_BUFFER_DESC BufDesc;
+ pBuffer->GetDesc( &BufDesc );
+ SAFE_RELEASE( pBuffer );
+ if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, an RWStructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ else
+ {
+ return S_OK;
+ }
+ }
+ break;
+ case EOT_RWTexture1D:
+ case EOT_RWTexture1DArray:
+ if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1D ||
+ desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
+ return S_OK;
+ break;
+ case EOT_RWTexture2D:
+ case EOT_RWTexture2DArray:
+ if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2D ||
+ desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
+ return S_OK;
+ break;
+ case EOT_RWTexture3D:
+ if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE3D)
+ return S_OK;
+ break;
+ case EOT_RWByteAddressBuffer:
+ if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER && (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW))
+ return S_OK;
+ break;
+ case EOT_RWStructuredBuffer:
+ if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER)
+ {
+ ID3D11Buffer* pBuffer = nullptr;
+ pView->GetResource( (ID3D11Resource**)&pBuffer );
+ assert( pBuffer != nullptr );
+ D3D11_BUFFER_DESC BufDesc;
+ pBuffer->GetDesc( &BufDesc );
+ SAFE_RELEASE( pBuffer );
+ if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
+ {
+ return S_OK;
+ }
+ else
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ }
+ break;
+ case EOT_RWStructuredBufferAlloc:
+ case EOT_RWStructuredBufferConsume:
+ if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
+ break;
+ if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_COUNTER)
+ {
+ return S_OK;
+ }
+ else
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, non-Counter buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ break;
+ case EOT_AppendStructuredBuffer:
+ case EOT_ConsumeStructuredBuffer:
+ if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
+ break;
+ if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_APPEND)
+ {
+ return S_OK;
+ }
+ else
+ {
+ DPF(0, "%s: Resource type mismatch; %s expected, non-Append buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
+ return E_INVALIDARG;
+ }
+ break;
+ default:
+ assert(0); // internal error, should never get here
+ return E_FAIL;
+ }
+
+
+ DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetUAVDimensionNameFromEnum(desc.ViewDimension));
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessView(ID3D11UnorderedAccessView *pResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessView";
+
+ VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
+#endif
+
+ // UAV variables don't need to be dirtied.
+ SAFE_ADDREF(pResource);
+ SAFE_RELEASE(Data.pUnorderedAccessView->pUnorderedAccessView);
+ Data.pUnorderedAccessView->pUnorderedAccessView = pResource;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessView(ID3D11UnorderedAccessView **ppResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessView";
+
+ VERIFYPARAMETER(ppResource);
+#endif
+
+ assert(Data.pUnorderedAccessView != 0 && Data.pUnorderedAccessView->pUnorderedAccessView != 0);
+ _Analysis_assume_(Data.pUnorderedAccessView != 0 && Data.pUnorderedAccessView->pUnorderedAccessView != 0);
+ *ppResource = Data.pUnorderedAccessView->pUnorderedAccessView;
+ SAFE_ADDREF(*ppResource);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessViewArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+#ifdef _DEBUG
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
+ }
+#endif
+
+ // Texture variables don't need to be dirtied.
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ SUnorderedAccessView *pResourceBlock = Data.pUnorderedAccessView + Offset + i;
+ SAFE_ADDREF(ppResources[i]);
+ SAFE_RELEASE(pResourceBlock->pUnorderedAccessView);
+ pResourceBlock->pUnorderedAccessView = ppResources[i];
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessViewArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ ppResources[i] = (Data.pUnorderedAccessView + Offset + i)->pUnorderedAccessView;
+ SAFE_ADDREF(ppResources[i]);
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectRenderTargetViewVariable (TRenderTargetViewVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TRenderTargetViewVariable : public IBaseInterface
+{
+ STDMETHOD(SetRenderTarget)(_In_ ID3D11RenderTargetView *pResource) override;
+ STDMETHOD(GetRenderTarget)(_Outptr_ ID3D11RenderTargetView **ppResource) override;
+
+ STDMETHOD(SetRenderTargetArray)(_In_reads_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetRenderTargetArray)(_Out_writes_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTarget(ID3D11RenderTargetView *pResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTarget";
+#endif
+
+ // Texture variables don't need to be dirtied.
+ SAFE_ADDREF(pResource);
+ SAFE_RELEASE(Data.pRenderTargetView->pRenderTargetView);
+ Data.pRenderTargetView->pRenderTargetView = pResource;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTarget(ID3D11RenderTargetView **ppResource)
+{
+ HRESULT hr = S_OK;
+
+ assert(Data.pRenderTargetView->pRenderTargetView != 0);
+ _Analysis_assume_(Data.pRenderTargetView->pRenderTargetView != 0);
+ *ppResource = Data.pRenderTargetView->pRenderTargetView;
+ SAFE_ADDREF(*ppResource);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTargetArray(ID3D11RenderTargetView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTargetArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ // Texture variables don't need to be dirtied.
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ SRenderTargetView *pResourceBlock = Data.pRenderTargetView + Offset + i;
+ SAFE_ADDREF(ppResources[i]);
+ SAFE_RELEASE(pResourceBlock->pRenderTargetView);
+ pResourceBlock->pRenderTargetView = ppResources[i];
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTargetArray(ID3D11RenderTargetView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::GetRenderTargetArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ ppResources[i] = (Data.pRenderTargetView + Offset + i)->pRenderTargetView;
+ SAFE_ADDREF(ppResources[i]);
+ }
+
+lExit:
+ return hr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectDepthStencilViewVariable (TDepthStencilViewVariable implementation)
+//////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TDepthStencilViewVariable : public IBaseInterface
+{
+ STDMETHOD(SetDepthStencil)(_In_ ID3D11DepthStencilView *pResource) override;
+ STDMETHOD(GetDepthStencil)(_Outptr_ ID3D11DepthStencilView **ppResource) override;
+
+ STDMETHOD(SetDepthStencilArray)(_In_reads_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+ STDMETHOD(GetDepthStencilArray)(_Out_writes_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
+};
+
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencil(ID3D11DepthStencilView *pResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencil";
+
+#endif
+
+ // Texture variables don't need to be dirtied.
+ SAFE_ADDREF(pResource);
+ SAFE_RELEASE(Data.pDepthStencilView->pDepthStencilView);
+ Data.pDepthStencilView->pDepthStencilView = pResource;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencil(ID3D11DepthStencilView **ppResource)
+{
+ HRESULT hr = S_OK;
+
+#ifdef _DEBUG
+ static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencil";
+
+ VERIFYPARAMETER(ppResource);
+#endif
+
+ assert(Data.pDepthStencilView->pDepthStencilView != 0);
+ _Analysis_assume_(Data.pDepthStencilView->pDepthStencilView != 0);
+ *ppResource = Data.pDepthStencilView->pDepthStencilView;
+ SAFE_ADDREF(*ppResource);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencilArray(ID3D11DepthStencilView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencilArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ // Texture variables don't need to be dirtied.
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ SDepthStencilView *pResourceBlock = Data.pDepthStencilView + Offset + i;
+ SAFE_ADDREF(ppResources[i]);
+ SAFE_RELEASE(pResourceBlock->pDepthStencilView);
+ pResourceBlock->pDepthStencilView = ppResources[i];
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencilArray(ID3D11DepthStencilView **ppResources, uint32_t Offset, uint32_t Count)
+{
+ static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencilArray";
+
+ CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
+
+ for (size_t i = 0; i < Count; ++ i)
+ {
+ ppResources[i] = (Data.pDepthStencilView + Offset + i)->pDepthStencilView;
+ SAFE_ADDREF(ppResources[i]);
+ }
+
+lExit:
+ return hr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderVariable (TShaderVariable implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TShaderVariable : public IBaseInterface
+{
+ STDMETHOD(GetShaderDesc)(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) override;
+
+ STDMETHOD(GetVertexShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) override;
+ STDMETHOD(GetGeometryShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) override;
+ STDMETHOD(GetPixelShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) override;
+ STDMETHOD(GetHullShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) override;
+ STDMETHOD(GetDomainShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) override;
+ STDMETHOD(GetComputeShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) override;
+
+ STDMETHOD(GetInputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+ STDMETHOD(GetOutputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+ STDMETHOD(GetPatchConstantSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
+
+ STDMETHOD_(bool, IsValid)();
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetShaderDesc(uint32_t ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
+
+ hr = Data.pShader[ShaderIndex].GetShaderDesc(pDesc, false);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetVertexShader(uint32_t ShaderIndex, ID3D11VertexShader **ppVS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppVS);
+
+ VH( Data.pShader[ShaderIndex].GetVertexShader(ppVS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetGeometryShader(uint32_t ShaderIndex, ID3D11GeometryShader **ppGS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppGS);
+
+ VH( Data.pShader[ShaderIndex].GetGeometryShader(ppGS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetPixelShader(uint32_t ShaderIndex, ID3D11PixelShader **ppPS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppPS);
+
+ VH( Data.pShader[ShaderIndex].GetPixelShader(ppPS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetHullShader(uint32_t ShaderIndex, ID3D11HullShader **ppHS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppHS);
+
+ VH( Data.pShader[ShaderIndex].GetHullShader(ppHS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetDomainShader(uint32_t ShaderIndex, ID3D11DomainShader **ppDS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppDS);
+
+ VH( Data.pShader[ShaderIndex].GetDomainShader(ppDS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetComputeShader(uint32_t ShaderIndex, ID3D11ComputeShader **ppCS)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppCS);
+
+ VH( Data.pShader[ShaderIndex].GetComputeShader(ppCS) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetInputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
+
+ VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetOutputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
+
+ VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TShaderVariable<IBaseInterface>::GetPatchConstantSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
+
+ VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+bool TShaderVariable<IBaseInterface>::IsValid()
+{
+ uint32_t numElements = IsArray()? pType->Elements : 1;
+ bool valid = true;
+ while( numElements > 0 && ( valid = Data.pShader[ numElements-1 ].IsValid ) )
+ numElements--;
+ return valid;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectBlendVariable (TBlendVariable implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TBlendVariable : public IBaseInterface
+{
+public:
+ STDMETHOD(GetBlendState)(_In_ uint32_t Index, _Outptr_ ID3D11BlendState **ppState) override;
+ STDMETHOD(SetBlendState)(_In_ uint32_t Index, _In_ ID3D11BlendState *pState) override;
+ STDMETHOD(UndoSetBlendState)(_In_ uint32_t Index) override;
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_BLEND_DESC *pDesc) override;
+ STDMETHOD_(bool, IsValid)() override;
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TBlendVariable<IBaseInterface>::GetBlendState(uint32_t Index, ID3D11BlendState **ppState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBlendState";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
+
+ assert(Data.pBlend[Index].pBlendObject != 0);
+ _Analysis_assume_(Data.pBlend[Index].pBlendObject != 0);
+ *ppState = Data.pBlend[Index].pBlendObject;
+ SAFE_ADDREF(*ppState);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TBlendVariable<IBaseInterface>::SetBlendState(uint32_t Index, ID3D11BlendState *pState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectBlendState::SetBlendState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pBlend[Index].IsUserManaged )
+ {
+ // Save original state object in case we UndoSet
+ assert( pMemberData[Index].Type == MDT_BlendState );
+ VB( pMemberData[Index].Data.pD3DEffectsManagedBlendState == nullptr );
+ pMemberData[Index].Data.pD3DEffectsManagedBlendState = Data.pBlend[Index].pBlendObject;
+ Data.pBlend[Index].pBlendObject = nullptr;
+ Data.pBlend[Index].IsUserManaged = true;
+ }
+
+ SAFE_ADDREF( pState );
+ SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
+ Data.pBlend[Index].pBlendObject = pState;
+ Data.pBlend[Index].IsValid = true;
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TBlendVariable<IBaseInterface>::UndoSetBlendState(uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectBlendState::UndoSetBlendState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pBlend[Index].IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Revert to original state object
+ SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
+ Data.pBlend[Index].pBlendObject = pMemberData[Index].Data.pD3DEffectsManagedBlendState;
+ pMemberData[Index].Data.pD3DEffectsManagedBlendState = nullptr;
+ Data.pBlend[Index].IsUserManaged = false;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TBlendVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_BLEND_DESC *pBlendDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBackingStore";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, pBlendDesc);
+
+ if( Data.pBlend[Index].IsUserManaged )
+ {
+ if( Data.pBlend[Index].pBlendObject )
+ {
+ Data.pBlend[Index].pBlendObject->GetDesc( pBlendDesc );
+ }
+ else
+ {
+ *pBlendDesc = CD3D11_BLEND_DESC( D3D11_DEFAULT );
+ }
+ }
+ else
+ {
+ SBlendBlock *pBlock = Data.pBlend + Index;
+ if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
+ {
+ pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
+ }
+
+ memcpy( pBlendDesc, &pBlock->BackingStore, sizeof(D3D11_BLEND_DESC) );
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+bool TBlendVariable<IBaseInterface>::IsValid()
+{
+ uint32_t numElements = IsArray()? pType->Elements : 1;
+ bool valid = true;
+ while( numElements > 0 && ( valid = Data.pBlend[ numElements-1 ].IsValid ) )
+ numElements--;
+ return valid;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectDepthStencilVariable (TDepthStencilVariable implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TDepthStencilVariable : public IBaseInterface
+{
+public:
+ STDMETHOD(GetDepthStencilState)(_In_ uint32_t Index, _Outptr_ ID3D11DepthStencilState **ppState) override;
+ STDMETHOD(SetDepthStencilState)(_In_ uint32_t Index, _In_ ID3D11DepthStencilState *pState) override;
+ STDMETHOD(UndoSetDepthStencilState)(_In_ uint32_t Index) override;
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_DEPTH_STENCIL_DESC *pDesc) override;
+ STDMETHOD_(bool, IsValid)() override;
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilVariable<IBaseInterface>::GetDepthStencilState(uint32_t Index, ID3D11DepthStencilState **ppState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetDepthStencilState";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
+
+ assert(Data.pDepthStencil[Index].pDSObject != 0);
+ _Analysis_assume_(Data.pDepthStencil[Index].pDSObject != 0);
+ *ppState = Data.pDepthStencil[Index].pDSObject;
+ SAFE_ADDREF(*ppState);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilVariable<IBaseInterface>::SetDepthStencilState(uint32_t Index, ID3D11DepthStencilState *pState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::SetDepthStencilState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pDepthStencil[Index].IsUserManaged )
+ {
+ // Save original state object in case we UndoSet
+ assert( pMemberData[Index].Type == MDT_DepthStencilState );
+ VB( pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState == nullptr );
+ pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = Data.pDepthStencil[Index].pDSObject;
+ Data.pDepthStencil[Index].pDSObject = nullptr;
+ Data.pDepthStencil[Index].IsUserManaged = true;
+ }
+
+ SAFE_ADDREF( pState );
+ SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
+ Data.pDepthStencil[Index].pDSObject = pState;
+ Data.pDepthStencil[Index].IsValid = true;
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+HRESULT TDepthStencilVariable<IBaseInterface>::UndoSetDepthStencilState(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::UndoSetDepthStencilState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pDepthStencil[Index].IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Revert to original state object
+ SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
+ Data.pDepthStencil[Index].pDSObject = pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState;
+ pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = nullptr;
+ Data.pDepthStencil[Index].IsUserManaged = false;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TDepthStencilVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetBackingStore";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, pDepthStencilDesc);
+
+ if( Data.pDepthStencil[Index].IsUserManaged )
+ {
+ if( Data.pDepthStencil[Index].pDSObject )
+ {
+ Data.pDepthStencil[Index].pDSObject->GetDesc( pDepthStencilDesc );
+ }
+ else
+ {
+ *pDepthStencilDesc = CD3D11_DEPTH_STENCIL_DESC( D3D11_DEFAULT );
+ }
+ }
+ else
+ {
+ SDepthStencilBlock *pBlock = Data.pDepthStencil + Index;
+ if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
+ {
+ pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
+ }
+
+ memcpy(pDepthStencilDesc, &pBlock->BackingStore, sizeof(D3D11_DEPTH_STENCIL_DESC));
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+bool TDepthStencilVariable<IBaseInterface>::IsValid()
+{
+ uint32_t numElements = IsArray()? pType->Elements : 1;
+ bool valid = true;
+ while( numElements > 0 && ( valid = Data.pDepthStencil[ numElements-1 ].IsValid ) )
+ numElements--;
+ return valid;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectRasterizerVariable (TRasterizerVariable implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TRasterizerVariable : public IBaseInterface
+{
+public:
+
+ STDMETHOD(GetRasterizerState)(_In_ uint32_t Index, _Outptr_ ID3D11RasterizerState **ppState) override;
+ STDMETHOD(SetRasterizerState)(_In_ uint32_t Index, _In_ ID3D11RasterizerState *pState) override;
+ STDMETHOD(UndoSetRasterizerState)(_In_ uint32_t Index) override;
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_RASTERIZER_DESC *pDesc) override;
+ STDMETHOD_(bool, IsValid)() override;
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRasterizerVariable<IBaseInterface>::GetRasterizerState(uint32_t Index, ID3D11RasterizerState **ppState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetRasterizerState";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
+
+ assert(Data.pRasterizer[Index].pRasterizerObject != 0);
+ _Analysis_assume_(Data.pRasterizer[Index].pRasterizerObject != 0);
+ *ppState = Data.pRasterizer[Index].pRasterizerObject;
+ SAFE_ADDREF(*ppState);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRasterizerVariable<IBaseInterface>::SetRasterizerState(uint32_t Index, ID3D11RasterizerState *pState)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRasterizerState::SetRasterizerState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pRasterizer[Index].IsUserManaged )
+ {
+ // Save original state object in case we UndoSet
+ assert( pMemberData[Index].Type == MDT_RasterizerState );
+ VB( pMemberData[Index].Data.pD3DEffectsManagedRasterizerState == nullptr );
+ pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
+ Data.pRasterizer[Index].pRasterizerObject = nullptr;
+ Data.pRasterizer[Index].IsUserManaged = true;
+ }
+
+ SAFE_ADDREF( pState );
+ SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
+ Data.pRasterizer[Index].pRasterizerObject = pState;
+ Data.pRasterizer[Index].IsValid = true;
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRasterizerVariable<IBaseInterface>::UndoSetRasterizerState(uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRasterizerState::UndoSetRasterizerState";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pRasterizer[Index].IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Revert to original state object
+ SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
+ Data.pRasterizer[Index].pRasterizerObject = pMemberData[Index].Data.pD3DEffectsManagedRasterizerState;
+ pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = nullptr;
+ Data.pRasterizer[Index].IsUserManaged = false;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TRasterizerVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_RASTERIZER_DESC *pRasterizerDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetBackingStore";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, pRasterizerDesc);
+
+ if( Data.pRasterizer[Index].IsUserManaged )
+ {
+ if( Data.pRasterizer[Index].pRasterizerObject )
+ {
+ Data.pRasterizer[Index].pRasterizerObject->GetDesc( pRasterizerDesc );
+ }
+ else
+ {
+ *pRasterizerDesc = CD3D11_RASTERIZER_DESC( D3D11_DEFAULT );
+ }
+ }
+ else
+ {
+ SRasterizerBlock *pBlock = Data.pRasterizer + Index;
+ if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
+ {
+ pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
+ }
+
+ memcpy(pRasterizerDesc, &pBlock->BackingStore, sizeof(D3D11_RASTERIZER_DESC));
+ }
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+bool TRasterizerVariable<IBaseInterface>::IsValid()
+{
+ uint32_t numElements = IsArray()? pType->Elements : 1;
+ bool valid = true;
+ while( numElements > 0 && ( valid = Data.pRasterizer[ numElements-1 ].IsValid ) )
+ numElements--;
+ return valid;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectSamplerVariable (TSamplerVariable implementation)
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TSamplerVariable : public IBaseInterface
+{
+public:
+
+ STDMETHOD(GetSampler)(_In_ uint32_t Index, _Outptr_ ID3D11SamplerState **ppSampler) override;
+ STDMETHOD(SetSampler)(_In_ uint32_t Index, _In_ ID3D11SamplerState *pSampler) override;
+ STDMETHOD(UndoSetSampler)(_In_ uint32_t Index) override;
+ STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_SAMPLER_DESC *pDesc) override;
+};
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TSamplerVariable<IBaseInterface>::GetSampler(uint32_t Index, ID3D11SamplerState **ppSampler)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetSampler";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, ppSampler);
+
+ _Analysis_assume_( Data.pSampler[Index].pD3DObject != 0 );
+ *ppSampler = Data.pSampler[Index].pD3DObject;
+ SAFE_ADDREF(*ppSampler);
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TSamplerVariable<IBaseInterface>::SetSampler(uint32_t Index, ID3D11SamplerState *pSampler)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectSamplerState::SetSampler";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ // Replace all references to the old shader block with this one
+ GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pSampler);
+
+ if( !Data.pSampler[Index].IsUserManaged )
+ {
+ // Save original state object in case we UndoSet
+ assert( pMemberData[Index].Type == MDT_SamplerState );
+ VB( pMemberData[Index].Data.pD3DEffectsManagedSamplerState == nullptr );
+ pMemberData[Index].Data.pD3DEffectsManagedSamplerState = Data.pSampler[Index].pD3DObject;
+ Data.pSampler[Index].pD3DObject = nullptr;
+ Data.pSampler[Index].IsUserManaged = true;
+ }
+
+ SAFE_ADDREF( pSampler );
+ SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
+ Data.pSampler[Index].pD3DObject = pSampler;
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+HRESULT TSamplerVariable<IBaseInterface>::UndoSetSampler(_In_ uint32_t Index)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectSamplerState::UndoSetSampler";
+
+ CHECK_SCALAR_BOUNDS(Index);
+
+ if( !Data.pSampler[Index].IsUserManaged )
+ {
+ return S_FALSE;
+ }
+
+ // Replace all references to the old shader block with this one
+ GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pMemberData[Index].Data.pD3DEffectsManagedSamplerState);
+
+ // Revert to original state object
+ SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
+ Data.pSampler[Index].pD3DObject = pMemberData[Index].Data.pD3DEffectsManagedSamplerState;
+ pMemberData[Index].Data.pD3DEffectsManagedSamplerState = nullptr;
+ Data.pSampler[Index].IsUserManaged = false;
+
+lExit:
+ return hr;
+}
+
+template<typename IBaseInterface>
+_Use_decl_annotations_
+HRESULT TSamplerVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_SAMPLER_DESC *pDesc)
+{
+ static LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetBackingStore";
+
+ CHECK_OBJECT_SCALAR_BOUNDS(Index, pDesc);
+
+ if( Data.pSampler[Index].IsUserManaged )
+ {
+ if( Data.pSampler[Index].pD3DObject )
+ {
+ Data.pSampler[Index].pD3DObject->GetDesc( pDesc );
+ }
+ else
+ {
+ *pDesc = CD3D11_SAMPLER_DESC( D3D11_DEFAULT );
+ }
+ }
+ else
+ {
+ SSamplerBlock *pBlock = Data.pSampler + Index;
+ if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
+ {
+ pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
+ }
+
+ memcpy(pDesc, &pBlock->BackingStore.SamplerDesc, sizeof(D3D11_SAMPLER_DESC));
+ }
+
+lExit:
+ return hr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TUncastableVariable
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename IBaseInterface>
+struct TUncastableVariable : public IBaseInterface
+{
+ STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() override;
+ STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() override;
+ STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() override;
+ STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() override;
+ STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() override;
+ STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() override;
+ STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() override;
+ STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() override;
+ STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() override;
+ STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() override;
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() override;
+ STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() override;
+ STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() override;
+ STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() override;
+ STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() override;
+ STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() override;
+};
+
+template<typename IBaseInterface>
+ID3DX11EffectScalarVariable * TUncastableVariable<IBaseInterface>::AsScalar()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidScalarVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectVectorVariable * TUncastableVariable<IBaseInterface>::AsVector()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidVectorVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectMatrixVariable * TUncastableVariable<IBaseInterface>::AsMatrix()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidMatrixVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectStringVariable * TUncastableVariable<IBaseInterface>::AsString()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidStringVariable;
+}
+
+template<typename IBaseClassInstance>
+ID3DX11EffectClassInstanceVariable * TUncastableVariable<IBaseClassInstance>::AsClassInstance()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidClassInstanceVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectInterfaceVariable * TUncastableVariable<IBaseInterface>::AsInterface()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidInterfaceVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectShaderResourceVariable * TUncastableVariable<IBaseInterface>::AsShaderResource()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidShaderResourceVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectUnorderedAccessViewVariable * TUncastableVariable<IBaseInterface>::AsUnorderedAccessView()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidUnorderedAccessViewVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectRenderTargetViewVariable * TUncastableVariable<IBaseInterface>::AsRenderTargetView()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidRenderTargetViewVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectDepthStencilViewVariable * TUncastableVariable<IBaseInterface>::AsDepthStencilView()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidDepthStencilViewVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectConstantBuffer * TUncastableVariable<IBaseInterface>::AsConstantBuffer()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidConstantBuffer;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectShaderVariable * TUncastableVariable<IBaseInterface>::AsShader()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidShaderVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectBlendVariable * TUncastableVariable<IBaseInterface>::AsBlend()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidBlendVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectDepthStencilVariable * TUncastableVariable<IBaseInterface>::AsDepthStencil()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidDepthStencilVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectRasterizerVariable * TUncastableVariable<IBaseInterface>::AsRasterizer()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidRasterizerVariable;
+}
+
+template<typename IBaseInterface>
+ID3DX11EffectSamplerVariable * TUncastableVariable<IBaseInterface>::AsSampler()
+{
+ static LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
+ DPF(0, "%s: Invalid typecast", pFuncName);
+ return &g_InvalidSamplerVariable;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Macros to instantiate the myriad templates
+////////////////////////////////////////////////////////////////////////////////
+
+// generates a global variable, annotation, global variable member, and annotation member of each struct type
+#define GenerateReflectionClasses(Type, BaseInterface) \
+struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<BaseInterface>, false> { IUNKNOWN_IMP(S##Type##GlobalVariable, BaseInterface, ID3DX11EffectVariable); }; \
+struct S##Type##Annotation : public T##Type##Variable<TAnnotation<BaseInterface>, true> { IUNKNOWN_IMP(S##Type##Annotation, BaseInterface, ID3DX11EffectVariable);}; \
+struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, false> { IUNKNOWN_IMP(S##Type##GlobalVariableMember, BaseInterface, ID3DX11EffectVariable); }; \
+struct S##Type##AnnotationMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, true> { IUNKNOWN_IMP(S##Type##AnnotationMember, BaseInterface, ID3DX11EffectVariable); };
+
+#define GenerateVectorReflectionClasses(Type, BaseType, BaseInterface) \
+struct S##Type##GlobalVariable : public TVectorVariable<TGlobalVariable<BaseInterface>, false, BaseType> { IUNKNOWN_IMP(S##Type##GlobalVariable, BaseInterface, ID3DX11EffectVariable); }; \
+struct S##Type##Annotation : public TVectorVariable<TAnnotation<BaseInterface>, true, BaseType> { IUNKNOWN_IMP(S##Type##Annotation, BaseInterface, ID3DX11EffectVariable);}; \
+struct S##Type##GlobalVariableMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, false, BaseType> { IUNKNOWN_IMP(S##Type##GlobalVariableMember, BaseInterface, ID3DX11EffectVariable);}; \
+struct S##Type##AnnotationMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, true, BaseType> { IUNKNOWN_IMP(S##Type##AnnotationMember, BaseInterface, ID3DX11EffectVariable);};
+
+#define GenerateReflectionGlobalOnlyClasses(Type) \
+struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<ID3DX11Effect##Type##Variable> > { IUNKNOWN_IMP(S##Type##GlobalVariable, ID3DX11Effect##Type##Variable, ID3DX11EffectVariable); }; \
+struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<ID3DX11Effect##Type##Variable> > > { IUNKNOWN_IMP(S##Type##GlobalVariableMember, ID3DX11Effect##Type##Variable, ID3DX11EffectVariable); }; \
+
+GenerateReflectionClasses(Numeric, ID3DX11EffectVariable);
+GenerateReflectionClasses(FloatScalar, ID3DX11EffectScalarVariable);
+GenerateReflectionClasses(IntScalar, ID3DX11EffectScalarVariable);
+GenerateReflectionClasses(BoolScalar, ID3DX11EffectScalarVariable);
+GenerateVectorReflectionClasses(FloatVector, ETVT_Float, ID3DX11EffectVectorVariable);
+GenerateVectorReflectionClasses(BoolVector, ETVT_Bool, ID3DX11EffectVectorVariable);
+GenerateVectorReflectionClasses(IntVector, ETVT_Int, ID3DX11EffectVectorVariable);
+GenerateReflectionClasses(Matrix, ID3DX11EffectMatrixVariable);
+GenerateReflectionClasses(String, ID3DX11EffectStringVariable);
+GenerateReflectionGlobalOnlyClasses(ClassInstance);
+GenerateReflectionGlobalOnlyClasses(Interface);
+GenerateReflectionGlobalOnlyClasses(ShaderResource);
+GenerateReflectionGlobalOnlyClasses(UnorderedAccessView);
+GenerateReflectionGlobalOnlyClasses(RenderTargetView);
+GenerateReflectionGlobalOnlyClasses(DepthStencilView);
+GenerateReflectionGlobalOnlyClasses(Shader);
+GenerateReflectionGlobalOnlyClasses(Blend);
+GenerateReflectionGlobalOnlyClasses(DepthStencil);
+GenerateReflectionGlobalOnlyClasses(Rasterizer);
+GenerateReflectionGlobalOnlyClasses(Sampler);
+
+// Optimized matrix classes
+struct SMatrix4x4ColumnMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, true> { IUNKNOWN_IMP(SMatrix4x4ColumnMajorGlobalVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
+struct SMatrix4x4RowMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, false> { IUNKNOWN_IMP(SMatrix4x4RowMajorGlobalVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
+
+struct SMatrix4x4ColumnMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, true> { IUNKNOWN_IMP(SMatrix4x4ColumnMajorGlobalVariableMember, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
+struct SMatrix4x4RowMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, false> { IUNKNOWN_IMP(SMatrix4x4RowMajorGlobalVariableMember, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
+
+// Optimized vector classes
+struct SFloatVector4GlobalVariable : public TVector4Variable<TGlobalVariable<ID3DX11EffectVectorVariable> > { IUNKNOWN_IMP(SFloatVector4GlobalVariable, ID3DX11EffectVectorVariable, ID3DX11EffectVariable); };
+struct SFloatVector4GlobalVariableMember : public TVector4Variable<TVariable<TMember<ID3DX11EffectVectorVariable> > > { IUNKNOWN_IMP(SFloatVector4GlobalVariableMember, ID3DX11EffectVectorVariable, ID3DX11EffectVariable); };
+
+// These 3 classes should never be used directly
+
+// The "base" global variable struct (all global variables should be the same size in bytes,
+// but we pick this as the default).
+struct SGlobalVariable : public TGlobalVariable<ID3DX11EffectVariable>
+{
+
+};
+
+// The "base" annotation struct (all annotations should be the same size in bytes,
+// but we pick this as the default).
+struct SAnnotation : public TAnnotation<ID3DX11EffectVariable>
+{
+
+};
+
+// The "base" variable member struct (all annotation/global variable members should be the
+// same size in bytes, but we pick this as the default).
+struct SMember : public TVariable<TMember<ID3DX11EffectVariable> >
+{
+
+};
+
+// creates a new variable of the appropriate polymorphic type where pVar was
+HRESULT PlacementNewVariable(_In_ void *pVar, _In_ SType *pType, _In_ bool IsAnnotation);
+SMember * CreateNewMember(_In_ SType *pType, _In_ bool IsAnnotation);
+
+#pragma warning(pop)
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "Effects11_2010_DXSDK.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ Profile|Win32 = Profile|Win32
+ Profile|x64 = Profile|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.Build.0 = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.ActiveCfg = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.Build.0 = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.ActiveCfg = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.Build.0 = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.ActiveCfg = Release|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.Build.0 = Release|x64
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<ItemGroup Label="ProjectConfigurations">
+<ProjectConfiguration Include="Debug|Win32">
+<Configuration>Debug</Configuration>
+<Platform>Win32</Platform>
+</ProjectConfiguration>
+<ProjectConfiguration Include="Debug|x64">
+<Configuration>Debug</Configuration>
+<Platform>x64</Platform>
+</ProjectConfiguration>
+<ProjectConfiguration Include="Profile|Win32">
+<Configuration>Profile</Configuration>
+<Platform>Win32</Platform>
+</ProjectConfiguration>
+<ProjectConfiguration Include="Profile|x64">
+<Configuration>Profile</Configuration>
+<Platform>x64</Platform>
+</ProjectConfiguration>
+<ProjectConfiguration Include="Release|Win32">
+<Configuration>Release</Configuration>
+<Platform>Win32</Platform>
+</ProjectConfiguration>
+<ProjectConfiguration Include="Release|x64">
+<Configuration>Release</Configuration>
+<Platform>x64</Platform>
+</ProjectConfiguration>
+</ItemGroup>
+<PropertyGroup Label="Globals">
+<ProjectName>Effects11</ProjectName>
+<ProjectGuid>{DF460EAB-570D-4B50-9089-2E2FC801BF38}</ProjectGuid>
+<RootNamespace>Effects11</RootNamespace>
+<Keyword>Win32Proj</Keyword>
+</PropertyGroup>
+<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<WholeProgramOptimization>true</WholeProgramOptimization>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<WholeProgramOptimization>true</WholeProgramOptimization>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<WholeProgramOptimization>true</WholeProgramOptimization>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'" Label="Configuration">
+<ConfigurationType>StaticLibrary</ConfigurationType>
+<WholeProgramOptimization>true</WholeProgramOptimization>
+<CharacterSet>Unicode</CharacterSet>
+</PropertyGroup>
+<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+<ImportGroup Label="ExtensionSettings" />
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+</ImportGroup>
+<PropertyGroup Label="UserMacros" />
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x86;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x64;$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x64;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x86;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x64;$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x64;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x86;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <OutDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_DXSDK\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+<ExecutablePath>$(DXSDK_DIR)Utilities\bin\x64;$(DXSDK_DIR)Utilities\bin\x86;$(ExecutablePath)</ExecutablePath>
+<IncludePath>$(DXSDK_DIR)Include;$(IncludePath)</IncludePath>
+<LibraryPath>$(DXSDK_DIR)Lib\x64;$(LibraryPath)</LibraryPath>
+</PropertyGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>Disabled</Optimization>
+<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<SubSystem>Windows</SubSystem>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX86</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>Disabled</Optimization>
+<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<SubSystem>Windows</SubSystem>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX64</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>MaxSpeed</Optimization>
+<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<FunctionLevelLinking>true</FunctionLevelLinking>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<SubSystem>Windows</SubSystem>
+<OptimizeReferences>true</OptimizeReferences>
+<EnableCOMDATFolding>true</EnableCOMDATFolding>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX86</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>MaxSpeed</Optimization>
+<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<FunctionLevelLinking>true</FunctionLevelLinking>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<SubSystem>Windows</SubSystem>
+<OptimizeReferences>true</OptimizeReferences>
+<EnableCOMDATFolding>true</EnableCOMDATFolding>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX64</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>MaxSpeed</Optimization>
+<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<FunctionLevelLinking>true</FunctionLevelLinking>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<SubSystem>Windows</SubSystem>
+<OptimizeReferences>true</OptimizeReferences>
+<EnableCOMDATFolding>true</EnableCOMDATFolding>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX86</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+<ClCompile>
+<WarningLevel>Level4</WarningLevel>
+<Optimization>MaxSpeed</Optimization>
+<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+<OpenMPSupport>false</OpenMPSupport>
+<FunctionLevelLinking>true</FunctionLevelLinking>
+<IntrinsicFunctions>true</IntrinsicFunctions>
+<FloatingPointModel>Fast</FloatingPointModel>
+<ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+<ExceptionHandling>Sync</ExceptionHandling>
+<AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+<PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<PreprocessorDefinitions>WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+<PrecompiledHeader>Use</PrecompiledHeader>
+</ClCompile>
+<Link>
+<AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+<AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+<GenerateDebugInformation>true</GenerateDebugInformation>
+<SubSystem>Windows</SubSystem>
+<OptimizeReferences>true</OptimizeReferences>
+<EnableCOMDATFolding>true</EnableCOMDATFolding>
+<LargeAddressAware>true</LargeAddressAware>
+<RandomizedBaseAddress>true</RandomizedBaseAddress>
+<DataExecutionPrevention>true</DataExecutionPrevention>
+<TargetMachine>MachineX64</TargetMachine>
+<UACExecutionLevel>AsInvoker</UACExecutionLevel>
+<DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+</Link>
+<Manifest>
+<EnableDPIAwareness>false</EnableDPIAwareness>
+</Manifest>
+<PreBuildEvent>
+<Command></Command>
+</PreBuildEvent>
+<PostBuildEvent>
+<Command></Command>
+</PostBuildEvent>
+</ItemDefinitionGroup>
+<ItemGroup />
+<ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp">
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">Create</PrecompiledHeader>
+ </ClCompile>
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+<ImportGroup Label="ExtensionTargets" />
+</Project>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns:atg="http://atg.xbox.com" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<ItemGroup>
+<Filter Include="Resource Files">
+<UniqueIdentifier>{8e114980-c1a3-4ada-ad7c-83caadf5daeb}</UniqueIdentifier>
+<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
+</Filter>
+</ItemGroup>
+<ItemGroup />
+<ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp" />
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+</Project>
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "Effects11_2010_SDK81.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ Profile|Win32 = Profile|Win32
+ Profile|x64 = Profile|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.Build.0 = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.ActiveCfg = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.Build.0 = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.ActiveCfg = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.Build.0 = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.ActiveCfg = Release|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.Build.0 = Release|x64
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|Win32">
+ <Configuration>Profile</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|x64">
+ <Configuration>Profile</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectName>Effects11</ProjectName>
+ <ProjectGuid>{DF460EAB-570D-4B50-9089-2E2FC801BF38}</ProjectGuid>
+ <RootNamespace>Effects11</RootNamespace>
+ <Keyword>Win32Proj</Keyword>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v100</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings" />
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x86.props" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x86.props" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x86.props" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x64.props" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x64.props" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ <Import Project="Windows81SDK_x64.props" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <OutDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2010\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp">
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">Create</PrecompiledHeader>
+ </ClCompile>
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets" />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns:atg="http://atg.xbox.com" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<ItemGroup>
+<Filter Include="Resource Files">
+<UniqueIdentifier>{8e114980-c1a3-4ada-ad7c-83caadf5daeb}</UniqueIdentifier>
+<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
+</Filter>
+</ItemGroup>
+<ItemGroup />
+<ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp" />
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+<ItemGroup></ItemGroup>
+</Project>
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "Effects11_2012.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ Profile|Win32 = Profile|Win32
+ Profile|x64 = Profile|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.Build.0 = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.ActiveCfg = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.Build.0 = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.ActiveCfg = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.Build.0 = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.ActiveCfg = Release|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.Build.0 = Release|x64
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|Win32">
+ <Configuration>Profile</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|x64">
+ <Configuration>Profile</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectName>Effects11</ProjectName>
+ <ProjectGuid>{DF460EAB-570D-4B50-9089-2E2FC801BF38}</ProjectGuid>
+ <RootNamespace>Effects11</RootNamespace>
+ <Keyword>Win32Proj</Keyword>
+ <VCTargetsPath Condition="'$(VCTargetsPath11)' != '' and '$(VSVersion)' == '' and '$(VisualStudioVersion)' == ''">$(VCTargetsPath11)</VCTargetsPath>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v110</PlatformToolset>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings" />
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <OutDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2012\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp">
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">Create</PrecompiledHeader>
+ </ClCompile>
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets" />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns:atg="http://atg.xbox.com" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{8e114980-c1a3-4ada-ad7c-83caadf5daeb}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp" />
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "Effects11_2013.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ Profile|Win32 = Profile|Win32
+ Profile|x64 = Profile|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.Build.0 = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.ActiveCfg = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.Build.0 = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.ActiveCfg = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.Build.0 = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.ActiveCfg = Release|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.Build.0 = Release|x64
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|Win32">
+ <Configuration>Profile</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|x64">
+ <Configuration>Profile</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectName>Effects11</ProjectName>
+ <ProjectGuid>{DF460EAB-570D-4B50-9089-2E2FC801BF38}</ProjectGuid>
+ <RootNamespace>Effects11</RootNamespace>
+ <Keyword>Win32Proj</Keyword>
+ <VCTargetsPath Condition="'$(VCTargetsPath11)' != '' and '$(VSVersion)' == '' and '$(VisualStudioVersion)' == ''">$(VCTargetsPath11)</VCTargetsPath>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>MultiByte</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>false</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v120</PlatformToolset>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings" />
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <OutDir>$(SolutionDir)libs\$(TargetName)\$(Configuration)\</OutDir>
+ <IntDir>$(SolutionDir)objs\$(TargetName)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <OutDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <OutDir>$(SolutionDir)libs\$(TargetName)\$(Configuration)\</OutDir>
+ <IntDir>$(SolutionDir)objs\$(TargetName)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <OutDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <OutDir>$(SolutionDir)libs\$(TargetName)\$(Configuration)\</OutDir>
+ <IntDir>$(SolutionDir)objs\$(TargetName)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <OutDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2013\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;_HAS_ITERATOR_DEBUGGING=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp">
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">Create</PrecompiledHeader>
+ </ClCompile>
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets" />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns:atg="http://atg.xbox.com" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{8e114980-c1a3-4ada-ad7c-83caadf5daeb}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp" />
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "Effects11_2015.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Debug|x64 = Debug|x64
+ Profile|Win32 = Profile|Win32
+ Profile|x64 = Profile|x64
+ Release|Win32 = Release|Win32
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.ActiveCfg = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|x64.Build.0 = Debug|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.ActiveCfg = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|Win32.Build.0 = Profile|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.ActiveCfg = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Profile|x64.Build.0 = Profile|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.ActiveCfg = Release|x64
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|x64.Build.0 = Release|x64
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|Win32">
+ <Configuration>Profile</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Profile|x64">
+ <Configuration>Profile</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectName>Effects11</ProjectName>
+ <ProjectGuid>{DF460EAB-570D-4B50-9089-2E2FC801BF38}</ProjectGuid>
+ <RootNamespace>Effects11</RootNamespace>
+ <Keyword>Win32Proj</Keyword>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ <PlatformToolset>v140</PlatformToolset>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings" />
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <OutDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>Bin\Desktop_2015\$(Platform)\$(Configuration)\</IntDir>
+ <TargetName>Effects11</TargetName>
+ <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;_DEBUG;DEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX86</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">
+ <ClCompile>
+ <WarningLevel>Level4</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <OpenMPSupport>false</OpenMPSupport>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName>
+ <ExceptionHandling>Sync</ExceptionHandling>
+ <AdditionalIncludeDirectories>.\Binary;.\Inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PrecompiledHeaderFile>pchfx.h</PrecompiledHeaderFile>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WIN7_PLATFORM_UPDATE;WIN32;NDEBUG;PROFILE;_WINDOWS;_LIB;D3DXFX_LARGEADDRESS_HANDLE;_WIN32_WINNT=0x0600;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PrecompiledHeader>Use</PrecompiledHeader>
+ </ClCompile>
+ <Link>
+ <AdditionalOptions> %(AdditionalOptions)</AdditionalOptions>
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <SubSystem>Windows</SubSystem>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <LargeAddressAware>true</LargeAddressAware>
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>
+ <DataExecutionPrevention>true</DataExecutionPrevention>
+ <TargetMachine>MachineX64</TargetMachine>
+ <UACExecutionLevel>AsInvoker</UACExecutionLevel>
+ <DelayLoadDLLs>%(DelayLoadDLLs)</DelayLoadDLLs>
+ </Link>
+ <Manifest>
+ <EnableDPIAwareness>false</EnableDPIAwareness>
+ </Manifest>
+ <PreBuildEvent>
+ <Command>
+ </Command>
+ </PreBuildEvent>
+ <PostBuildEvent>
+ <Command>
+ </Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp">
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|X64'">Create</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Profile|X64'">Create</PrecompiledHeader>
+ </ClCompile>
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets" />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns:atg="http://atg.xbox.com" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{8e114980-c1a3-4ada-ad7c-83caadf5daeb}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup />
+ <ItemGroup>
+ <CLInclude Include="pchfx.h" />
+ <CLInclude Include=".\Inc\d3dx11effect.h" />
+ <CLInclude Include=".\Inc\d3dxglobal.h" />
+ <CLInclude Include=".\Binary\EffectBinaryFormat.h" />
+ <CLInclude Include=".\Binary\EffectStateBase11.h" />
+ <CLInclude Include=".\Binary\EffectStates11.h" />
+ <CLInclude Include=".\Binary\SOParser.h" />
+ <ClCompile Include="d3dxGlobal.cpp" />
+ <CLInclude Include="Effect.h" />
+ <ClCompile Include="EffectAPI.cpp" />
+ <ClCompile Include="EffectLoad.cpp" />
+ <CLInclude Include="EffectLoad.h" />
+ <ClCompile Include="EffectNonRuntime.cpp" />
+ <ClCompile Include="EffectReflection.cpp" />
+ <ClCompile Include="EffectRuntime.cpp" />
+ <None Include="EffectVariable.inl" />
+ <CLInclude Include="IUnknownImp.h" />
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+ <ItemGroup>
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: IUnknownImp.h
+//
+// Direct3D 11 Effects Helper for COM interop
+//
+// Lifetime for most Effects objects is based on the the lifetime of the master
+// effect, so the reference count is not used.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#define IUNKNOWN_IMP(Class, Interface, BaseInterface) \
+ \
+HRESULT STDMETHODCALLTYPE Class##::QueryInterface(REFIID iid, _COM_Outptr_ LPVOID *ppv) override \
+{ \
+ if( !ppv ) \
+ return E_INVALIDARG; \
+ \
+ *ppv = nullptr; \
+ if(IsEqualIID(iid, IID_IUnknown)) \
+ { \
+ *ppv = (IUnknown*)((Interface*)this); \
+ } \
+ else if(IsEqualIID(iid, IID_##Interface)) \
+ { \
+ *ppv = (Interface *)this; \
+ } \
+ else if(IsEqualIID(iid, IID_##BaseInterface)) \
+ { \
+ *ppv = (BaseInterface *)this; \
+ } \
+ else \
+ { \
+ return E_NOINTERFACE; \
+ } \
+ \
+ return S_OK; \
+} \
+ \
+ULONG STDMETHODCALLTYPE Class##::AddRef() override \
+{ \
+ return 1; \
+} \
+ \
+ULONG STDMETHODCALLTYPE Class##::Release() override \
+{ \
+ return 0; \
+}
--- /dev/null
+{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff1\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}
+{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}{\f36\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}{\f38\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Tahoma;}
+{\f39\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Verdana;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
+{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}
+{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
+{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}
+{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f40\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f41\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\f43\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f44\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f45\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f46\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\f47\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f48\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f50\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\f51\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;}
+{\f53\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\f54\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\f55\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);}{\f56\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);}
+{\f57\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\f58\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}{\f380\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f381\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}
+{\f383\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f384\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f387\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f388\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}
+{\f400\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\f401\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\f403\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\f404\fbidi \froman\fcharset162\fprq2 Cambria Tur;}
+{\f407\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\f408\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\f420\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}{\f421\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;}
+{\f423\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f424\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;}{\f425\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}{\f426\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);}
+{\f427\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f428\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f429\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}{\f430\fbidi \fswiss\fcharset238\fprq2 Verdana CE;}
+{\f431\fbidi \fswiss\fcharset204\fprq2 Verdana Cyr;}{\f433\fbidi \fswiss\fcharset161\fprq2 Verdana Greek;}{\f434\fbidi \fswiss\fcharset162\fprq2 Verdana Tur;}{\f437\fbidi \fswiss\fcharset186\fprq2 Verdana Baltic;}
+{\f438\fbidi \fswiss\fcharset163\fprq2 Verdana (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
+{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
+{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
+{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}
+{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;}
+{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
+{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
+{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
+{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
+{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
+{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
+{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}
+{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}
+{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
+{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
+{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
+{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;
+\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp }{\*\defpap
+\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0
+\f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\s1\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0
+\f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \slink15 \sqformat \spriority9 heading 1;}{\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0
+\f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \slink16 \sqformat \spriority9 heading 2;}{\*\cs10 \additive \ssemihidden Default Paragraph Font;}{\*
+\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv
+\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs20\alang1025 \ltrch\fcs0 \fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused Normal Table;}{\*\cs15 \additive
+\rtlch\fcs1 \ab\af0\afs32 \ltrch\fcs0 \b\f36\fs32\kerning32 \sbasedon10 \slink1 \slocked \spriority9 Heading 1 Char;}{\*\cs16 \additive \rtlch\fcs1 \ab\ai\af0\afs28 \ltrch\fcs0 \b\i\f36\fs28 \sbasedon10 \slink2 \slocked \spriority9 Heading 2 Char;}{
+\s17\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af38\afs16\alang1025 \ltrch\fcs0 \f38\fs16\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext17 \slink18 \ssemihidden \sunhideused \styrsid7424395 Balloon Text;}
+{\*\cs18 \additive \rtlch\fcs1 \af38\afs16 \ltrch\fcs0 \f38\fs16 \sbasedon10 \slink17 \slocked \ssemihidden \styrsid7424395 Balloon Text Char;}{\*\cs19 \additive \rtlch\fcs1 \af0\afs16 \ltrch\fcs0 \fs16
+\sbasedon10 \ssemihidden \sunhideused \styrsid4538388 annotation reference;}{\s20\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs20\alang1025 \ltrch\fcs0 \f1\fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033
+\sbasedon0 \snext20 \slink21 \ssemihidden \sunhideused \styrsid4538388 annotation text;}{\*\cs21 \additive \rtlch\fcs1 \af1 \ltrch\fcs0 \f1 \sbasedon10 \slink20 \slocked \ssemihidden \styrsid4538388 Comment Text Char;}{
+\s22\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \ab\af1\afs20\alang1025 \ltrch\fcs0 \b\f1\fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon20 \snext20 \slink23 \ssemihidden \sunhideused \styrsid4538388
+annotation subject;}{\*\cs23 \additive \rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f1 \sbasedon21 \slink22 \slocked \ssemihidden \styrsid4538388 Comment Subject Char;}}{\*\rsidtbl \rsid213160\rsid284417\rsid417145\rsid481196\rsid551334\rsid723397\rsid786968
+\rsid1382437\rsid1390003\rsid1521043\rsid1530955\rsid1708989\rsid1783212\rsid1903779\rsid2431884\rsid3165084\rsid3416120\rsid3419781\rsid3754103\rsid3768194\rsid3831520\rsid4538130\rsid4538388\rsid4552277\rsid4680449\rsid4729674\rsid4865270\rsid4987534
+\rsid5128131\rsid5186068\rsid5601121\rsid5864350\rsid6186044\rsid6311778\rsid6384507\rsid6434687\rsid6561471\rsid6910344\rsid6947552\rsid7033180\rsid7424395\rsid7682010\rsid7690850\rsid7744081\rsid8151618\rsid8196281\rsid8198206\rsid8342723\rsid8350925
+\rsid8722561\rsid8852349\rsid8934457\rsid8944153\rsid9573035\rsid9635349\rsid9638545\rsid9724918\rsid10044820\rsid10095979\rsid10228618\rsid10449644\rsid10494075\rsid11166278\rsid11166751\rsid11285353\rsid11366513\rsid11494815\rsid11932529\rsid12061202
+\rsid12533699\rsid12536400\rsid12916885\rsid13264736\rsid13322831\rsid13440556\rsid13455614\rsid13597357\rsid13768671\rsid14097590\rsid14157399\rsid14229900\rsid14305025\rsid14314735\rsid14436896\rsid14565916\rsid14572556\rsid14688892\rsid14752433
+\rsid14904394\rsid15086147\rsid15749945\rsid15814398\rsid15927751\rsid16071312\rsid16126175\rsid16279402\rsid16391569\rsid16404661\rsid16452939\rsid16537688\rsid16606866\rsid16674896}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1
+\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\title Microsoft Permissive License (Ms-PL)}{\author Jonr}{\operator Chuck Walbourn}{\creatim\yr2007\mo2\dy23\hr15\min10}{\revtim\yr2011\mo8\dy15\hr15\min2}
+{\printim\yr2006\mo9\dy28\hr8\min46}{\version3}{\edmins1}{\nofpages1}{\nofwords391}{\nofchars2230}{\*\company Microsoft}{\nofcharsws2616}{\vern49273}}{\*\userprops {\propname _NewReviewCycle}\proptype30{\staticval }}{\*\xmlnstbl {\xmlns1 http://schemas.mi
+crosoft.com/office/word/2003/wordml}{\xmlns2 urn:schemas-microsoft-com:office:smarttags}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect
+\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\hyphcaps0\horzdoc\dghspace120\dgvspace120
+\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\splytwnine\ftnlytwnine\htmautsp\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct\asianbrkrule\rsidroot10494075
+\newtblstyruls\nogrowautofit\utinl \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}
+{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}
+{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar
+\s1\ql \li0\ri0\sb180\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af1\afs31 \ltrch\fcs0
+\fs31\cf1\kerning36\insrsid10494075\charrsid14688892 Microsoft}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid10494075 }{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid5601121 Public}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0
+\fs31\cf1\kerning36\insrsid14688892 }{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid10494075 License (Ms-PL}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid4552277 )}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0
+\fs31\cf1\kerning36\insrsid10494075
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs17 \ltrch\fcs0
+\b\f39\fs17\insrsid10494075
+\par This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.
+\par }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6910344
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs23 \ltrch\fcs0
+\b\f39\fs23\insrsid10494075 1. Definitions
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 The terms \'93reproduce,\'94 \'93reproduction}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7744081 ,}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 \'94 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid551334 \'93derivative works,\'94}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7744081\charrsid7744081 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 and \'93distribution\'94 have the same meaning here as under
+{\*\xmlopen\xmlns2{\factoidname place}}{\*\xmlopen\xmlns2{\factoidname country-region}}U.S.{\*\xmlclose}{\*\xmlclose} copyright law.
+\par }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 A \'93contribution\'94 is the original software}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid4865270 ,}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 }{\rtlch\fcs1
+\af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid11932529 or}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 any additions or changes to the software.
+\par }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid551334 A \'93c}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid551334\charrsid551334 ontributor\'94 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 is}{\rtlch\fcs1 \af39\afs17
+\ltrch\fcs0 \f39\fs17\insrsid12536400\charrsid551334 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid551334\charrsid551334 any person that }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400
+distributes its contribution under this license.}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14229900 {\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid4729674\delrsid4729674 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 \'93Licensed patents
+\'94 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 are }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3831520 a contributor\rquote s }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 patent claims }{\rtlch\fcs1
+\af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3831520 that }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 read directly on }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3831520 its contribution.}{\rtlch\fcs1 \af1 \ltrch\fcs0
+\insrsid14229900\charrsid14229900
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs23 \ltrch\fcs0
+\b\f39\fs23\insrsid5186068
+\par }{\rtlch\fcs1 \ab\af39\afs23 \ltrch\fcs0 \b\f39\fs23\insrsid10494075 2. Grant of Rights
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3754103 each contributor }{\rtlch\fcs1 \af39\afs17
+\ltrch\fcs0 \f39\fs17\insrsid10494075 grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 , prepare derivative works of }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid12536400 ,}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 and distribute }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 or any derivative works that you create.
+\par (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid9724918 each contributor }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 grants you a non-exclusive, worldwide, royalty-free license under }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid15814398 its }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+licensed patents to make, have made, use, sell, offer for sale, }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid1390003 import, }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 and/or otherwise dispose of }{\rtlch\fcs1 \af39\afs17
+\ltrch\fcs0 \f39\fs17\insrsid8944153 its contribution in }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 the software or derivative works of }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid8944153 the contribution in }{\rtlch\fcs1
+\af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 the software.
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs23 \ltrch\fcs0
+\b\f39\fs23\insrsid5186068
+\par }{\rtlch\fcs1 \ab\af39\afs23 \ltrch\fcs0 \b\f39\fs23\insrsid10494075 3. Conditions and Limitations
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid1530955 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 (A) No Trademark License- This license does not grant you rights to use }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid1708989 any contributors\rquote }{
+\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 name, logo, or trademarks.
+\par (B) If you }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid8934457 bring a patent claim against }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10095979 any contributor}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+ over patents that you }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6947552 claim }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7682010 are }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6947552 infringe}{\rtlch\fcs1
+\af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7682010 d by}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 the software, your }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7682010 patent }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075 license}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid7682010 from such contributor}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 to the software ends automatically.
+\par (C) If you distribute }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid3165084 any portion of }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.
+\par (D) If you distribute }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid15749945 any portion of the }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 software in source code form}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid14904394 ,}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 you may do so only under this license}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6384507 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid14904394 by including }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 a complete copy of this license with your distribution}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6384507 .}{\rtlch\fcs1 \af39\afs17
+\ltrch\fcs0 \f39\fs17\insrsid10494075 }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid6384507 I}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 f you distribute }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid15749945
+any portion of }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 the software in compiled or object code form}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid16452939 ,}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+ you may only do so under a license that complies with this license.
+\par }\pard \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14572556 {\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 (E) The software is licensed \'93as-is.\'94 You bear the risk of using it. }{
+\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid284417 The contributors }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075
+give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid1783212 the contributors }{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0 \f39\fs17\insrsid10494075 exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.}{\rtlch\fcs1 \af39\afs17 \ltrch\fcs0
+\f39\fs17\insrsid10494075\charrsid14572556
+\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a
+9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad
+5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6
+b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0
+0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6
+a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f
+c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512
+0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462
+a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865
+6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b
+4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b
+4757e8d3f729e245eb2b260a0238fd010000ffff0300504b03041400060008000000210096b5ade296060000501b0000160000007468656d652f7468656d652f
+7468656d65312e786d6cec594f6fdb3614bf0fd87720746f6327761a07758ad8b19b2d4d1bc46e871e698996d850a240d2497d1bdae38001c3ba618715d86d87
+615b8116d8a5fb34d93a6c1dd0afb0475292c5585e9236d88aad3e2412f9e3fbff1e1fa9abd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad
+79482a9c0498f184b4bd2991deb58df7dfbb8ad755446282607d22d771db8b944ad79796a40fc3585ee62949606ecc458c15bc8a702910f808e8c66c69b9565b
+5d8a314d3c94e018c8de1a8fa94fd05093f43672e23d06af89927ac06762a049136785c10607758d9053d965021d62d6f6804fc08f86e4bef210c352c144dbab
+999fb7b4717509af678b985ab0b6b4ae6f7ed9ba6c4170b06c788a705430adf71bad2b5b057d03606a1ed7ebf5babd7a41cf00b0ef83a6569632cd467faddec9
+699640f6719e76b7d6ac355c7c89feca9cccad4ea7d36c65b258a206641f1b73f8b5da6a6373d9c11b90c537e7f08dce66b7bbeae00dc8e257e7f0fd2badd586
+8b37a088d1e4600ead1ddaef67d40bc898b3ed4af81ac0d76a197c86826828a24bb318f3442d8ab518dfe3a20f000d6458d104a9694ac6d88728eee2782428d6
+0cf03ac1a5193be4cbb921cd0b495fd054b5bd0f530c1931a3f7eaf9f7af9e3f45c70f9e1d3ff8e9f8e1c3e3073f5a42ceaa6d9c84e5552fbffdeccfc71fa33f
+9e7ef3f2d117d57859c6fffac327bffcfc793510d26726ce8b2f9ffcf6ecc98baf3efdfdbb4715f04d814765f890c644a29be408edf3181433567125272371be
+15c308d3f28acd249438c19a4b05fd9e8a1cf4cd296699771c393ac4b5e01d01e5a30a787d72cf1178108989a2159c77a2d801ee72ce3a5c545a6147f32a9979
+3849c26ae66252c6ed637c58c5bb8b13c7bfbd490a75330f4b47f16e441c31f7184e140e494214d273fc80900aedee52ead87597fa824b3e56e82e451d4c2b4d
+32a423279a668bb6690c7e9956e90cfe766cb37b077538abd27a8b1cba48c80acc2a841f12e698f13a9e281c57911ce298950d7e03aba84ac8c154f8655c4f2a
+f074481847bd804859b5e696007d4b4edfc150b12addbecba6b18b148a1e54d1bc81392f23b7f84137c2715a851dd0242a633f900710a218ed715505dfe56e86
+e877f0034e16bafb0e258ebb4faf06b769e888340b103d3311da9750aa9d0a1cd3e4efca31a3508f6d0c5c5c398602f8e2ebc71591f5b616e24dd893aa3261fb
+44f95d843b5974bb5c04f4edafb95b7892ec1108f3f98de75dc97d5772bdff7cc95d94cf672db4b3da0a6557f70db629362d72bcb0431e53c6066acac80d699a
+6409fb44d08741bdce9c0e4971624a2378cceaba830b05366b90e0ea23aaa241845368b0eb9e2612ca8c742851ca251ceccc70256d8d87265dd96361531f186c
+3d9058edf2c00eafe8e1fc5c509031bb4d680e9f39a3154de0accc56ae644441edd76156d7429d995bdd88664a9dc3ad50197c38af1a0c16d684060441db0256
+5e85f3b9660d0713cc48a0ed6ef7dedc2dc60b17e92219e180643ed27acffba86e9c94c78ab90980d8a9f0913ee49d62b512b79626fb06dccee2a432bbc60276
+b9f7dec44b7904cfbca4f3f6443ab2a49c9c2c41476dafd55c6e7ac8c769db1bc399161ee314bc2e75cf8759081743be1236ec4f4d6693e5336fb672c5dc24a8
+c33585b5fb9cc24e1d4885545b58463634cc5416022cd19cacfccb4d30eb45296023fd35a458598360f8d7a4003bbaae25e331f155d9d9a5116d3bfb9a95523e
+51440ca2e0088dd844ec6370bf0e55d027a012ae264c45d02f708fa6ad6da6dce29c255df9f6cae0ec38666984b372ab5334cf640b37795cc860de4ae2816e95
+b21be5ceaf8a49f90b52a51cc6ff3355f47e0237052b81f6800fd7b802239daf6d8f0b1571a8426944fdbe80c6c1d40e8816b88b8569082ab84c36ff0539d4ff
+6dce591a26ade1c0a7f669880485fd484582903d284b26fa4e2156cff62e4b9265844c4495c495a9157b440e091bea1ab8aaf7760f4510eaa69a6465c0e04ec6
+9ffb9e65d028d44d4e39df9c1a52ecbd3607fee9cec7263328e5d661d3d0e4f62f44acd855ed7ab33cdf7bcb8ae889599bd5c8b3029895b6825696f6af29c239
+b75a5bb1e6345e6ee6c28117e73586c1a2214ae1be07e93fb0ff51e133fb65426fa843be0fb515c187064d0cc206a2fa926d3c902e907670048d931db4c1a449
+59d366ad93b65abe595f70a75bf03d616c2dd959fc7d4e6317cd99cbcec9c58b34766661c7d6766ca1a9c1b327531486c6f941c638c67cd22a7f75e2a37be0e8
+2db8df9f30254d30c1372581a1f51c983c80e4b71ccdd28dbf000000ffff0300504b0304140006000800000021000dd1909fb60000001b010000270000007468
+656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f78277086f6fd3ba109126dd88d0add40384e4
+350d363f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89d93b64b060828e6f37ed1567914b284d2624
+52282e3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd5001996509affb3fd381a89672f1f165dfe5141
+73d9850528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0fbfff0000001c020000130000000000000000
+0000000000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6a7e7c0000000360100000b00000000000000
+000000000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a0000001c0000000000000000000000000019
+0200007468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d001400060008000000210096b5ade296060000501b00001600000000
+000000000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d00140006000800000021000dd1909fb60000001b01000027
+00000000000000000000000000a00900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d0100009b0a00000000}
+{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
+617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
+6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
+656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
+{\*\latentstyles\lsdstimax267\lsdlockeddef0\lsdsemihiddendef1\lsdunhideuseddef1\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;
+\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;
+\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 1;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 2;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 3;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 4;
+\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 5;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 6;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 7;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 8;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 9;
+\lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdpriority59 \lsdlocked0 Table Grid;
+\lsdunhideused0 \lsdlocked0 Placeholder Text;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdunhideused0 \lsdlocked0 Revision;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdpriority37 \lsdlocked0 Bibliography;
+\lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;}}{\*\datastore 0105000002000000180000004d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000
+d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e5000000000000000000000000808a
+33fc965bcc01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
+00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ImportGroup Label="PropertySheets" />
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup>
+ <ExecutablePath>$(ProgramFiles)\Windows Kits\8.1\bin\x64;$(ExecutablePath)</ExecutablePath>
+ <IncludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(IncludePath)</IncludePath>
+ <LibraryPath>$(ProgramFiles)\Windows Kits\8.1\lib\winv6.3\um\x64;$(LibraryPath)</LibraryPath>
+ <ExcludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(ExcludePath)</ExcludePath>
+ </PropertyGroup>
+<ItemDefinitionGroup />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ImportGroup Label="PropertySheets" />
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup>
+ <ExecutablePath>$(ProgramFiles)\Windows Kits\8.1\bin\x86;$(ExecutablePath)</ExecutablePath>
+ <IncludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(IncludePath)</IncludePath>
+ <LibraryPath>$(ProgramFiles)\Windows Kits\8.1\lib\winv6.3\um\x86;$(LibraryPath)</LibraryPath>
+ <ExcludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(ExcludePath)</ExcludePath>
+ </PropertyGroup>
+<ItemDefinitionGroup />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ImportGroup Label="PropertySheets" />
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup>
+ <ExecutablePath>$(VCInstallDir)bin\x86_amd64;$(VCInstallDir)bin;$(WindowsSdkDir)bin\NETFX 4.0 Tools;$(ProgramFiles)\Windows Kits\8.1\bin\x86;$(VSInstallDir)Common7\Tools\bin;$(VSInstallDir)Common7\tools;$(VSInstallDir)Common7\ide;$(ProgramFiles)\HTML Help Workshop;$(FrameworkSDKDir)\bin;$(MSBuildToolsPath32);$(VSInstallDir);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>
+ <IncludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(FrameworkSDKDir)\include;</IncludePath>
+ <LibraryPath>$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(ProgramFiles)\Windows Kits\8.1\lib\winv6.3\um\x64;$(FrameworkSDKDir)\lib\x64</LibraryPath>
+ <ExcludePath>$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(FrameworkSDKDir)\include;$(MSBuildToolsPath32);$(VCInstallDir)atlmfc\lib;$(VCInstallDir)lib;</ExcludePath>
+ </PropertyGroup>
+<ItemDefinitionGroup />
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ImportGroup Label="PropertySheets" />
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup>
+ <ExecutablePath>$(VCInstallDir)bin;$(WindowsSdkDir)bin\NETFX 4.0 Tools;$(ProgramFiles)\Windows Kits\8.1\bin\x86;$(VSInstallDir)Common7\Tools\bin;$(VSInstallDir)Common7\tools;$(VSInstallDir)Common7\ide;$(ProgramFiles)\HTML Help Workshop;$(FrameworkSDKDir)\bin;$(MSBuildToolsPath32);$(VSInstallDir);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>
+ <IncludePath>$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(FrameworkSDKDir)\include;</IncludePath>
+ <LibraryPath>$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(ProgramFiles)\Windows Kits\8.1\lib\winv6.3\um\x86;$(FrameworkSDKDir)\lib</LibraryPath>
+ <ExcludePath>$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(ProgramFiles)\Windows Kits\8.1\Include\um;$(ProgramFiles)\Windows Kits\8.1\Include\shared;$(ProgramFiles)\Windows Kits\8.1\Include\winrt;$(FrameworkSDKDir)\include;$(MSBuildToolsPath32);$(VCInstallDir)atlmfc\lib;$(VCInstallDir)lib;</ExcludePath>
+ </PropertyGroup>
+<ItemDefinitionGroup />
+</Project>
\ No newline at end of file
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: d3dxGlobal.cpp
+//
+// Direct3D 11 Effects implementation for helper data structures
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#include "pchfx.h"
+
+// VS 2010's stdint.h conflicts with intsafe.h
+#pragma warning(push)
+#pragma warning(disable : 4005)
+#include <intsafe.h>
+#pragma warning(pop)
+
+#include <stdio.h>
+#include <stdarg.h>
+
+namespace D3DX11Core
+{
+
+//////////////////////////////////////////////////////////////////////////
+// CMemoryStream - A class to simplify reading binary data
+//////////////////////////////////////////////////////////////////////////
+
+CMemoryStream::CMemoryStream() : m_pData(nullptr), m_cbData(0), m_readPtr(0)
+{
+}
+
+CMemoryStream::~CMemoryStream()
+{
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::SetData(const void *pData, size_t size)
+{
+ m_pData = (uint8_t*) pData;
+ m_cbData = size;
+ m_readPtr = 0;
+
+ return S_OK;
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::ReadAtOffset(size_t offset, size_t size, void **ppData)
+{
+ if (offset >= m_cbData)
+ return E_FAIL;
+
+ m_readPtr = offset;
+ return Read(ppData, size);
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::ReadAtOffset(size_t offset, LPCSTR *ppString)
+{
+ if (offset >= m_cbData)
+ return E_FAIL;
+
+ m_readPtr = offset;
+ return Read(ppString);
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::Read(void **ppData, size_t size)
+{
+ size_t temp = m_readPtr + size;
+
+ if (temp < m_readPtr || temp > m_cbData)
+ return E_FAIL;
+
+ *ppData = m_pData + m_readPtr;
+ m_readPtr = temp;
+ return S_OK;
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::Read(uint32_t *pDword)
+{
+ uint32_t *pTempDword;
+ HRESULT hr;
+
+ hr = Read((void**) &pTempDword, sizeof(uint32_t));
+ if (FAILED(hr))
+ return E_FAIL;
+
+ *pDword = *pTempDword;
+ return S_OK;
+}
+
+_Use_decl_annotations_
+HRESULT CMemoryStream::Read(LPCSTR *ppString)
+{
+ size_t iChar=m_readPtr;
+ for(; m_pData[iChar]; iChar++)
+ {
+ if (iChar > m_cbData)
+ return E_FAIL;
+ }
+
+ *ppString = (LPCSTR) (m_pData + m_readPtr);
+ m_readPtr = iChar;
+
+ return S_OK;
+}
+
+size_t CMemoryStream::GetPosition()
+{
+ return m_readPtr;
+}
+
+HRESULT CMemoryStream::Seek(_In_ size_t offset)
+{
+ if (offset > m_cbData)
+ return E_FAIL;
+
+ m_readPtr = offset;
+ return S_OK;
+}
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+// CDataBlock - used to dynamically build up the effect file in memory
+//////////////////////////////////////////////////////////////////////////
+
+CDataBlock::CDataBlock() :
+ m_size(0),
+ m_maxSize(0),
+ m_pData(nullptr),
+ m_pNext(nullptr),
+ m_IsAligned(false)
+{
+}
+
+CDataBlock::~CDataBlock()
+{
+ SAFE_DELETE_ARRAY(m_pData);
+ SAFE_DELETE(m_pNext);
+}
+
+void CDataBlock::EnableAlignment()
+{
+ m_IsAligned = true;
+}
+
+_Use_decl_annotations_
+HRESULT CDataBlock::AddData(const void *pvNewData, uint32_t bufferSize, CDataBlock **ppBlock)
+{
+ HRESULT hr = S_OK;
+ uint32_t bytesToCopy;
+ const uint8_t *pNewData = (const uint8_t*) pvNewData;
+
+ if (m_maxSize == 0)
+ {
+ // This is a brand new DataBlock, fill it up
+ m_maxSize = std::max<uint32_t>(8192, bufferSize);
+
+ VN( m_pData = new uint8_t[m_maxSize] );
+ }
+
+ assert(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
+
+ bytesToCopy = std::min(m_maxSize - m_size, bufferSize);
+ memcpy(m_pData + m_size, pNewData, bytesToCopy);
+ pNewData += bytesToCopy;
+
+ if (m_IsAligned)
+ {
+ assert(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
+ m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
+ }
+ else
+ {
+ m_size += bytesToCopy;
+ }
+
+ bufferSize -= bytesToCopy;
+ *ppBlock = this;
+
+ if (bufferSize != 0)
+ {
+ assert(nullptr == m_pNext); // make sure we're not overwriting anything
+
+ // Couldn't fit all data into this block, spill over into next
+ VN( m_pNext = new CDataBlock() );
+ if (m_IsAligned)
+ {
+ m_pNext->EnableAlignment();
+ }
+ VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
+ }
+
+lExit:
+ return hr;
+}
+
+_Use_decl_annotations_
+void* CDataBlock::Allocate(uint32_t bufferSize, CDataBlock **ppBlock)
+{
+ void *pRetValue;
+ uint32_t temp = m_size + bufferSize;
+
+ if (temp < m_size)
+ return nullptr;
+
+ *ppBlock = this;
+
+ if (m_maxSize == 0)
+ {
+ // This is a brand new DataBlock, fill it up
+ m_maxSize = std::max<uint32_t>(8192, bufferSize);
+
+ m_pData = new uint8_t[m_maxSize];
+ if (!m_pData)
+ return nullptr;
+ memset(m_pData, 0xDD, m_maxSize);
+ }
+ else if (temp > m_maxSize)
+ {
+ assert(nullptr == m_pNext); // make sure we're not overwriting anything
+
+ // Couldn't fit data into this block, spill over into next
+ m_pNext = new CDataBlock();
+ if (!m_pNext)
+ return nullptr;
+ if (m_IsAligned)
+ {
+ m_pNext->EnableAlignment();
+ }
+
+ return m_pNext->Allocate(bufferSize, ppBlock);
+ }
+
+ assert(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
+
+ pRetValue = m_pData + m_size;
+ if (m_IsAligned)
+ {
+ assert(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
+ m_size = AlignToPowerOf2(temp, c_DataAlignment);
+ }
+ else
+ {
+ m_size = temp;
+ }
+
+ return pRetValue;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+CDataBlockStore::CDataBlockStore() :
+ m_pFirst(nullptr),
+ m_pLast(nullptr),
+ m_Size(0),
+ m_Offset(0),
+ m_IsAligned(false)
+{
+#if _DEBUG
+ m_cAllocations = 0;
+#endif
+}
+
+CDataBlockStore::~CDataBlockStore()
+{
+ // Can't just do SAFE_DELETE(m_pFirst) since it blows the stack when deleting long chains of data
+ CDataBlock* pData = m_pFirst;
+ while(pData)
+ {
+ CDataBlock* pCurrent = pData;
+ pData = pData->m_pNext;
+ pCurrent->m_pNext = nullptr;
+ delete pCurrent;
+ }
+
+ // m_pLast will be deleted automatically
+}
+
+void CDataBlockStore::EnableAlignment()
+{
+ m_IsAligned = true;
+}
+
+_Use_decl_annotations_
+HRESULT CDataBlockStore::AddString(LPCSTR pString, uint32_t *pOffset)
+{
+ size_t strSize = strlen(pString) + 1;
+ assert( strSize <= 0xffffffff );
+ return AddData(pString, (uint32_t)strSize, pOffset);
+}
+
+_Use_decl_annotations_
+HRESULT CDataBlockStore::AddData(const void *pNewData, uint32_t bufferSize, uint32_t *pCurOffset)
+{
+ HRESULT hr = S_OK;
+
+ if (bufferSize == 0)
+ {
+ if (pCurOffset)
+ {
+ *pCurOffset = 0;
+ }
+ goto lExit;
+ }
+
+ if (!m_pFirst)
+ {
+ VN( m_pFirst = new CDataBlock() );
+ if (m_IsAligned)
+ {
+ m_pFirst->EnableAlignment();
+ }
+ m_pLast = m_pFirst;
+ }
+
+ if (pCurOffset)
+ *pCurOffset = m_Size + m_Offset;
+
+ VH( m_pLast->AddData(pNewData, bufferSize, &m_pLast) );
+ m_Size += bufferSize;
+
+lExit:
+ return hr;
+}
+
+void* CDataBlockStore::Allocate(_In_ uint32_t bufferSize)
+{
+ void *pRetValue = nullptr;
+
+#if _DEBUG
+ m_cAllocations++;
+#endif
+
+ if (!m_pFirst)
+ {
+ m_pFirst = new CDataBlock();
+ if (!m_pFirst)
+ return nullptr;
+
+ if (m_IsAligned)
+ {
+ m_pFirst->EnableAlignment();
+ }
+ m_pLast = m_pFirst;
+ }
+
+ if (FAILED(UIntAdd(m_Size, bufferSize, &m_Size)))
+ return nullptr;
+
+ pRetValue = m_pLast->Allocate(bufferSize, &m_pLast);
+ if (!pRetValue)
+ return nullptr;
+
+ return pRetValue;
+}
+
+uint32_t CDataBlockStore::GetSize()
+{
+ return m_Size;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+#ifdef _DEBUG
+_Use_decl_annotations_
+void __cdecl D3DXDebugPrintf(UINT lvl, LPCSTR szFormat, ...)
+{
+ UNREFERENCED_PARAMETER(lvl);
+
+ char strA[4096];
+ char strB[4096];
+
+ va_list ap;
+ va_start(ap, szFormat);
+ vsprintf_s(strA, sizeof(strA), szFormat, ap);
+ strA[4095] = '\0';
+ va_end(ap);
+
+ sprintf_s(strB, sizeof(strB), "Effects11: %s\r\n", strA);
+
+ strB[4095] = '\0';
+
+ OutputDebugStringA(strB);
+}
+#endif // _DEBUG
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: D3DX11Effect.h
+//
+// Direct3D 11 Effect Types & APIs Header
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#define D3DX11_EFFECTS_VERSION 1111
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#define DCOMMON_H_INCLUDED
+#define NO_D3D11_DEBUG_NAME
+#elif (_WIN32_WINNT >= 0x0602) || defined(_WIN7_PLATFORM_UPDATE)
+#include <d3d11_1.h>
+#include <d3d11shader.h>
+#else
+#include <d3d11.h>
+#include <d3d11shader.h>
+#endif
+
+#pragma comment( lib, "d3dcompiler.lib" )
+#pragma comment( lib, "dxguid.lib" )
+
+// VS 2010's stdint.h conflicts with intsafe.h
+#pragma warning(push)
+#pragma warning(disable : 4005)
+#include <stdint.h>
+#pragma warning(pop)
+
+#if defined(_MSC_VER) && (_MSC_VER<1610) && !defined(_In_reads_)
+#define _Analysis_assume_(exp) __analysis_assume(exp)
+#define _In_reads_(exp) _In_count_x_(exp)
+#define _In_reads_opt_(exp) _In_opt_count_x_(exp)
+#define _In_reads_bytes_(exp) _In_bytecount_x_(exp)
+#define _Inout_updates_(exp) _Inout_cap_x_(exp)
+#define _Inout_updates_z_(exp) _Inout_z_cap_x_(exp)
+#define _Inout_updates_bytes_(exp) _Inout_bytecap_x_(exp)
+#define _Out_writes_(exp) _Out_cap_x_(exp)
+#define _Out_writes_bytes_(exp) _Out_bytecap_x_(exp)
+#define _Outptr_ _Deref_out_
+#define _Outptr_result_z_ _Deref_out_z_
+#define _Outptr_opt_result_maybenull_ _Deref_opt_out_opt_
+#define _Outptr_result_maybenull_z_ _Deref_opt_out_opt_z_
+#define _Outptr_result_buffer_(exp) _Deref_post_cap_x_(exp)
+#define _Outptr_result_buffer_all_maybenull_(exp) _Deref_post_opt_cap_x_(exp)
+#define _COM_Outptr_ _Deref_out_
+#define _When_(test,exp)
+#endif
+
+#ifndef _Use_decl_annotations_
+#define _Use_decl_annotations_
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// File contents:
+//
+// 1) Stateblock enums, structs, interfaces, flat APIs
+// 2) Effect enums, structs, interfaces, flat APIs
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef D3DX11_BYTES_FROM_BITS
+#define D3DX11_BYTES_FROM_BITS(x) (((x) + 7) / 8)
+#endif // D3DX11_BYTES_FROM_BITS
+
+#ifndef D3DERR_INVALIDCALL
+#define D3DERR_INVALIDCALL MAKE_HRESULT( 1, 0x876, 2156 )
+#endif
+
+struct D3DX11_STATE_BLOCK_MASK
+{
+ uint8_t VS;
+ uint8_t VSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t VSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t VSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t VSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+
+ uint8_t HS;
+ uint8_t HSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t HSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t HSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t HSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+
+ uint8_t DS;
+ uint8_t DSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t DSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t DSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t DSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+
+ uint8_t GS;
+ uint8_t GSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t GSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t GSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t GSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+
+ uint8_t PS;
+ uint8_t PSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t PSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t PSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t PSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+ uint8_t PSUnorderedAccessViews;
+
+ uint8_t CS;
+ uint8_t CSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
+ uint8_t CSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t CSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
+ uint8_t CSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
+ uint8_t CSUnorderedAccessViews;
+
+ uint8_t IAVertexBuffers[D3DX11_BYTES_FROM_BITS(D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT)];
+ uint8_t IAIndexBuffer;
+ uint8_t IAInputLayout;
+ uint8_t IAPrimitiveTopology;
+
+ uint8_t OMRenderTargets;
+ uint8_t OMDepthStencilState;
+ uint8_t OMBlendState;
+
+ uint8_t RSViewports;
+ uint8_t RSScissorRects;
+ uint8_t RSRasterizerState;
+
+ uint8_t SOBuffers;
+
+ uint8_t Predication;
+};
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT flags:
+// -------------------------------------
+//
+// These flags are passed in when creating an effect, and affect
+// the runtime effect behavior:
+//
+// (Currently none)
+//
+//
+// These flags are set by the effect runtime:
+//
+// D3DX11_EFFECT_OPTIMIZED
+// This effect has been optimized. Reflection functions that rely on
+// names/semantics/strings should fail. This is set when Optimize() is
+// called, but CEffect::IsOptimized() should be used to test for this.
+//
+// D3DX11_EFFECT_CLONE
+// This effect is a clone of another effect. Single CBs will never be
+// updated when internal variable values are changed.
+// This flag is not set when the D3DX11_EFFECT_CLONE_FORCE_NONSINGLE flag
+// is used in cloning.
+//
+//----------------------------------------------------------------------------
+
+#define D3DX11_EFFECT_OPTIMIZED (1 << 21)
+#define D3DX11_EFFECT_CLONE (1 << 22)
+
+// Mask of valid D3DCOMPILE_EFFECT flags for D3DX11CreateEffect*
+#define D3DX11_EFFECT_RUNTIME_VALID_FLAGS (0)
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_VARIABLE flags:
+// ----------------------------
+//
+// These flags describe an effect variable (global or annotation),
+// and are returned in D3DX11_EFFECT_VARIABLE_DESC::Flags.
+//
+// D3DX11_EFFECT_VARIABLE_ANNOTATION
+// Indicates that this is an annotation on a technique, pass, or global
+// variable. Otherwise, this is a global variable. Annotations cannot
+// be shared.
+//
+// D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT
+// Indicates that the variable has been explicitly bound using the
+// register keyword.
+//----------------------------------------------------------------------------
+
+#define D3DX11_EFFECT_VARIABLE_ANNOTATION (1 << 1)
+#define D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT (1 << 2)
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_CLONE flags:
+// ----------------------------
+//
+// These flags modify the effect cloning process and are passed into Clone.
+//
+// D3DX11_EFFECT_CLONE_FORCE_NONSINGLE
+// Ignore all "single" qualifiers on cbuffers. All cbuffers will have their
+// own ID3D11Buffer's created in the cloned effect.
+//----------------------------------------------------------------------------
+
+#define D3DX11_EFFECT_CLONE_FORCE_NONSINGLE (1 << 0)
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectType //////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_TYPE_DESC:
+//
+// Retrieved by ID3DX11EffectType::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_EFFECT_TYPE_DESC
+{
+ LPCSTR TypeName; // Name of the type
+ // (e.g. "float4" or "MyStruct")
+
+ D3D_SHADER_VARIABLE_CLASS Class; // (e.g. scalar, vector, object, etc.)
+ D3D_SHADER_VARIABLE_TYPE Type; // (e.g. float, texture, vertexshader, etc.)
+
+ uint32_t Elements; // Number of elements in this type
+ // (0 if not an array)
+ uint32_t Members; // Number of members
+ // (0 if not a structure)
+ uint32_t Rows; // Number of rows in this type
+ // (0 if not a numeric primitive)
+ uint32_t Columns; // Number of columns in this type
+ // (0 if not a numeric primitive)
+
+ uint32_t PackedSize; // Number of bytes required to represent
+ // this data type, when tightly packed
+ uint32_t UnpackedSize; // Number of bytes occupied by this data
+ // type, when laid out in a constant buffer
+ uint32_t Stride; // Number of bytes to seek between elements,
+ // when laid out in a constant buffer
+};
+
+typedef interface ID3DX11EffectType ID3DX11EffectType;
+typedef interface ID3DX11EffectType *LPD3D11EFFECTTYPE;
+
+// {4250D721-D5E5-491F-B62B-587C43186285}
+DEFINE_GUID(IID_ID3DX11EffectType,
+ 0x4250d721, 0xd5e5, 0x491f, 0xb6, 0x2b, 0x58, 0x7c, 0x43, 0x18, 0x62, 0x85);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectType
+
+DECLARE_INTERFACE_(ID3DX11EffectType, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11EffectType
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) PURE;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+ STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(THIS_ _In_z_ LPCSTR Semantic) PURE;
+ STDMETHOD_(LPCSTR, GetMemberName)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(LPCSTR, GetMemberSemantic)(THIS_ _In_ uint32_t Index) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectVariable //////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_VARIABLE_DESC:
+//
+// Retrieved by ID3DX11EffectVariable::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_EFFECT_VARIABLE_DESC
+{
+ LPCSTR Name; // Name of this variable, annotation,
+ // or structure member
+ LPCSTR Semantic; // Semantic string of this variable
+ // or structure member (nullptr for
+ // annotations or if not present)
+
+ uint32_t Flags; // D3DX11_EFFECT_VARIABLE_* flags
+ uint32_t Annotations; // Number of annotations on this variable
+ // (always 0 for annotations)
+
+ uint32_t BufferOffset; // Offset into containing cbuffer or tbuffer
+ // (always 0 for annotations or variables
+ // not in constant buffers)
+
+ uint32_t ExplicitBindPoint; // Used if the variable has been explicitly bound
+ // using the register keyword. Check Flags for
+ // D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
+};
+
+typedef interface ID3DX11EffectVariable ID3DX11EffectVariable;
+typedef interface ID3DX11EffectVariable *LPD3D11EFFECTVARIABLE;
+
+// {036A777D-B56E-4B25-B313-CC3DDAB71873}
+DEFINE_GUID(IID_ID3DX11EffectVariable,
+ 0x036a777d, 0xb56e, 0x4b25, 0xb3, 0x13, 0xcc, 0x3d, 0xda, 0xb7, 0x18, 0x73);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectVariable
+
+// Forward defines
+typedef interface ID3DX11EffectScalarVariable ID3DX11EffectScalarVariable;
+typedef interface ID3DX11EffectVectorVariable ID3DX11EffectVectorVariable;
+typedef interface ID3DX11EffectMatrixVariable ID3DX11EffectMatrixVariable;
+typedef interface ID3DX11EffectStringVariable ID3DX11EffectStringVariable;
+typedef interface ID3DX11EffectClassInstanceVariable ID3DX11EffectClassInstanceVariable;
+typedef interface ID3DX11EffectInterfaceVariable ID3DX11EffectInterfaceVariable;
+typedef interface ID3DX11EffectShaderResourceVariable ID3DX11EffectShaderResourceVariable;
+typedef interface ID3DX11EffectUnorderedAccessViewVariable ID3DX11EffectUnorderedAccessViewVariable;
+typedef interface ID3DX11EffectRenderTargetViewVariable ID3DX11EffectRenderTargetViewVariable;
+typedef interface ID3DX11EffectDepthStencilViewVariable ID3DX11EffectDepthStencilViewVariable;
+typedef interface ID3DX11EffectConstantBuffer ID3DX11EffectConstantBuffer;
+typedef interface ID3DX11EffectShaderVariable ID3DX11EffectShaderVariable;
+typedef interface ID3DX11EffectBlendVariable ID3DX11EffectBlendVariable;
+typedef interface ID3DX11EffectDepthStencilVariable ID3DX11EffectDepthStencilVariable;
+typedef interface ID3DX11EffectRasterizerVariable ID3DX11EffectRasterizerVariable;
+typedef interface ID3DX11EffectSamplerVariable ID3DX11EffectSamplerVariable;
+
+DECLARE_INTERFACE_(ID3DX11EffectVariable, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11EffectVariable
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ _In_z_ LPCSTR Semantic) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ _In_ uint32_t Index) PURE;
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)(THIS) PURE;
+
+ STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectStringVariable*, AsString)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)(THIS) PURE;
+ STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)(THIS) PURE;
+
+ STDMETHOD(SetRawValue)(THIS_ _In_reads_bytes_(ByteCount) const void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) PURE;
+ STDMETHOD(GetRawValue)(THIS_ _Out_writes_bytes_(ByteCount) void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectScalarVariable ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectScalarVariable ID3DX11EffectScalarVariable;
+typedef interface ID3DX11EffectScalarVariable *LPD3D11EFFECTSCALARVARIABLE;
+
+// {921EF2E5-A65D-4E92-9FC6-4E9CC09A4ADE}
+DEFINE_GUID(IID_ID3DX11EffectScalarVariable,
+ 0x921ef2e5, 0xa65d, 0x4e92, 0x9f, 0xc6, 0x4e, 0x9c, 0xc0, 0x9a, 0x4a, 0xde);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectScalarVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectScalarVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectScalarVariable
+ STDMETHOD(SetFloat)(THIS_ _In_ const float Value) PURE;
+ STDMETHOD(GetFloat)(THIS_ _Out_ float *pValue) PURE;
+
+ STDMETHOD(SetFloatArray)(THIS_ _In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetFloatArray)(THIS_ _Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+
+ STDMETHOD(SetInt)(THIS_ _In_ const int Value) PURE;
+ STDMETHOD(GetInt)(THIS_ _Out_ int *pValue) PURE;
+
+ STDMETHOD(SetIntArray)(THIS_ _In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetIntArray)(THIS_ _Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+
+ STDMETHOD(SetBool)(THIS_ _In_ const bool Value) PURE;
+ STDMETHOD(GetBool)(THIS_ _Out_ bool *pValue) PURE;
+
+ STDMETHOD(SetBoolArray)(THIS_ _In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetBoolArray)(THIS_ _Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectVectorVariable ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectVectorVariable ID3DX11EffectVectorVariable;
+typedef interface ID3DX11EffectVectorVariable *LPD3D11EFFECTVECTORVARIABLE;
+
+// {5E785D4A-D87B-48D8-B6E6-0F8CA7E7467A}
+DEFINE_GUID(IID_ID3DX11EffectVectorVariable,
+ 0x5e785d4a, 0xd87b, 0x48d8, 0xb6, 0xe6, 0x0f, 0x8c, 0xa7, 0xe7, 0x46, 0x7a);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectVectorVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectVectorVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectVectorVariable
+ STDMETHOD(SetBoolVector) (THIS_ _In_reads_(4) const bool *pData) PURE;
+ STDMETHOD(SetIntVector) (THIS_ _In_reads_(4) const int *pData) PURE;
+ STDMETHOD(SetFloatVector)(THIS_ _In_reads_(4) const float *pData) PURE;
+
+ STDMETHOD(GetBoolVector) (THIS_ _Out_writes_(4) bool *pData) PURE;
+ STDMETHOD(GetIntVector) (THIS_ _Out_writes_(4) int *pData) PURE;
+ STDMETHOD(GetFloatVector)(THIS_ _Out_writes_(4) float *pData) PURE;
+
+ STDMETHOD(SetBoolVectorArray) (THIS_ _In_reads_(Count*4) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(SetIntVectorArray) (THIS_ _In_reads_(Count*4) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(SetFloatVectorArray)(THIS_ _In_reads_(Count*4) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+
+ STDMETHOD(GetBoolVectorArray) (THIS_ _Out_writes_(Count*4) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetIntVectorArray) (THIS_ _Out_writes_(Count*4) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetFloatVectorArray)(THIS_ _Out_writes_(Count*4) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectMatrixVariable ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectMatrixVariable ID3DX11EffectMatrixVariable;
+typedef interface ID3DX11EffectMatrixVariable *LPD3D11EFFECTMATRIXVARIABLE;
+
+// {E1096CF4-C027-419A-8D86-D29173DC803E}
+DEFINE_GUID(IID_ID3DX11EffectMatrixVariable,
+ 0xe1096cf4, 0xc027, 0x419a, 0x8d, 0x86, 0xd2, 0x91, 0x73, 0xdc, 0x80, 0x3e);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectMatrixVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectMatrixVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectMatrixVariable
+ STDMETHOD(SetMatrix)(THIS_ _In_reads_(16) const float *pData) PURE;
+ STDMETHOD(GetMatrix)(THIS_ _Out_writes_(16) float *pData) PURE;
+
+ STDMETHOD(SetMatrixArray)(THIS_ _In_reads_(Count*16) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetMatrixArray)(THIS_ _Out_writes_(Count*16) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+
+ STDMETHOD(SetMatrixPointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) PURE;
+ STDMETHOD(GetMatrixPointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) PURE;
+
+ STDMETHOD(SetMatrixTranspose)(THIS_ _In_reads_(16) const float *pData) PURE;
+ STDMETHOD(GetMatrixTranspose)(THIS_ _Out_writes_(16) float *pData) PURE;
+
+ STDMETHOD(SetMatrixTransposeArray)(THIS_ _In_reads_(Count*16) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetMatrixTransposeArray)(THIS_ _Out_writes_(Count*16) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+
+ STDMETHOD(SetMatrixTransposePointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) PURE;
+ STDMETHOD(GetMatrixTransposePointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectStringVariable ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectStringVariable ID3DX11EffectStringVariable;
+typedef interface ID3DX11EffectStringVariable *LPD3D11EFFECTSTRINGVARIABLE;
+
+// {F355C818-01BE-4653-A7CC-60FFFEDDC76D}
+DEFINE_GUID(IID_ID3DX11EffectStringVariable,
+ 0xf355c818, 0x01be, 0x4653, 0xa7, 0xcc, 0x60, 0xff, 0xfe, 0xdd, 0xc7, 0x6d);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectStringVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectStringVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectStringVariable
+ STDMETHOD(GetString)(THIS_ _Outptr_result_z_ LPCSTR *ppString) PURE;
+ STDMETHOD(GetStringArray)(THIS_ _Out_writes_(Count) LPCSTR *ppStrings, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectClassInstanceVariable ////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectClassInstanceVariable ID3DX11EffectClassInstanceVariable;
+typedef interface ID3DX11EffectClassInstanceVariable *LPD3D11EFFECTCLASSINSTANCEVARIABLE;
+
+// {926A8053-2A39-4DB4-9BDE-CF649ADEBDC1}
+DEFINE_GUID(IID_ID3DX11EffectClassInstanceVariable,
+ 0x926a8053, 0x2a39, 0x4db4, 0x9b, 0xde, 0xcf, 0x64, 0x9a, 0xde, 0xbd, 0xc1);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectClassInstanceVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectClassInstanceVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectClassInstanceVariable
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3D11ClassInstance** ppClassInstance) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectInterfaceVariable ////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectInterfaceVariable ID3DX11EffectInterfaceVariable;
+typedef interface ID3DX11EffectInterfaceVariable *LPD3D11EFFECTINTERFACEVARIABLE;
+
+// {516C8CD8-1C80-40A4-B19B-0688792F11A5}
+DEFINE_GUID(IID_ID3DX11EffectInterfaceVariable,
+ 0x516c8cd8, 0x1c80, 0x40a4, 0xb1, 0x9b, 0x06, 0x88, 0x79, 0x2f, 0x11, 0xa5);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectInterfaceVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectInterfaceVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectInterfaceVariable
+ STDMETHOD(SetClassInstance)(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance) PURE;
+ STDMETHOD(GetClassInstance)(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderResourceVariable ////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectShaderResourceVariable ID3DX11EffectShaderResourceVariable;
+typedef interface ID3DX11EffectShaderResourceVariable *LPD3D11EFFECTSHADERRESOURCEVARIABLE;
+
+// {350DB233-BBE0-485C-9BFE-C0026B844F89}
+DEFINE_GUID(IID_ID3DX11EffectShaderResourceVariable,
+ 0x350db233, 0xbbe0, 0x485c, 0x9b, 0xfe, 0xc0, 0x02, 0x6b, 0x84, 0x4f, 0x89);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectShaderResourceVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectShaderResourceVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectShaderResourceVariable
+ STDMETHOD(SetResource)(THIS_ _In_ ID3D11ShaderResourceView *pResource) PURE;
+ STDMETHOD(GetResource)(THIS_ _Outptr_ ID3D11ShaderResourceView **ppResource) PURE;
+
+ STDMETHOD(SetResourceArray)(THIS_ _In_reads_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetResourceArray)(THIS_ _Out_writes_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectUnorderedAccessViewVariable ////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectUnorderedAccessViewVariable ID3DX11EffectUnorderedAccessViewVariable;
+typedef interface ID3DX11EffectUnorderedAccessViewVariable *LPD3D11EFFECTUNORDEREDACCESSVIEWVARIABLE;
+
+// {79B4AC8C-870A-47D2-B05A-8BD5CC3EE6C9}
+DEFINE_GUID(IID_ID3DX11EffectUnorderedAccessViewVariable,
+ 0x79b4ac8c, 0x870a, 0x47d2, 0xb0, 0x5a, 0x8b, 0xd5, 0xcc, 0x3e, 0xe6, 0xc9);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectUnorderedAccessViewVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectUnorderedAccessViewVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectUnorderedAccessViewVariable
+ STDMETHOD(SetUnorderedAccessView)(THIS_ _In_ ID3D11UnorderedAccessView *pResource) PURE;
+ STDMETHOD(GetUnorderedAccessView)(THIS_ _Outptr_ ID3D11UnorderedAccessView **ppResource) PURE;
+
+ STDMETHOD(SetUnorderedAccessViewArray)(THIS_ _In_reads_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetUnorderedAccessViewArray)(THIS_ _Out_writes_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectRenderTargetViewVariable //////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectRenderTargetViewVariable ID3DX11EffectRenderTargetViewVariable;
+typedef interface ID3DX11EffectRenderTargetViewVariable *LPD3D11EFFECTRENDERTARGETVIEWVARIABLE;
+
+// {D5066909-F40C-43F8-9DB5-057C2A208552}
+DEFINE_GUID(IID_ID3DX11EffectRenderTargetViewVariable,
+ 0xd5066909, 0xf40c, 0x43f8, 0x9d, 0xb5, 0x05, 0x7c, 0x2a, 0x20, 0x85, 0x52);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectRenderTargetViewVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectRenderTargetViewVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectRenderTargetViewVariable
+ STDMETHOD(SetRenderTarget)(THIS_ _In_ ID3D11RenderTargetView *pResource) PURE;
+ STDMETHOD(GetRenderTarget)(THIS_ _Outptr_ ID3D11RenderTargetView **ppResource) PURE;
+
+ STDMETHOD(SetRenderTargetArray)(THIS_ _In_reads_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetRenderTargetArray)(THIS_ _Out_writes_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectDepthStencilViewVariable //////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectDepthStencilViewVariable ID3DX11EffectDepthStencilViewVariable;
+typedef interface ID3DX11EffectDepthStencilViewVariable *LPD3D11EFFECTDEPTHSTENCILVIEWVARIABLE;
+
+// {33C648AC-2E9E-4A2E-9CD6-DE31ACC5B347}
+DEFINE_GUID(IID_ID3DX11EffectDepthStencilViewVariable,
+ 0x33c648ac, 0x2e9e, 0x4a2e, 0x9c, 0xd6, 0xde, 0x31, 0xac, 0xc5, 0xb3, 0x47);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectDepthStencilViewVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectDepthStencilViewVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectDepthStencilViewVariable
+ STDMETHOD(SetDepthStencil)(THIS_ _In_ ID3D11DepthStencilView *pResource) PURE;
+ STDMETHOD(GetDepthStencil)(THIS_ _Outptr_ ID3D11DepthStencilView **ppResource) PURE;
+
+ STDMETHOD(SetDepthStencilArray)(THIS_ _In_reads_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+ STDMETHOD(GetDepthStencilArray)(THIS_ _Out_writes_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectConstantBuffer ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectConstantBuffer ID3DX11EffectConstantBuffer;
+typedef interface ID3DX11EffectConstantBuffer *LPD3D11EFFECTCONSTANTBUFFER;
+
+// {2CB6C733-82D2-4000-B3DA-6219D9A99BF2}
+DEFINE_GUID(IID_ID3DX11EffectConstantBuffer,
+ 0x2cb6c733, 0x82d2, 0x4000, 0xb3, 0xda, 0x62, 0x19, 0xd9, 0xa9, 0x9b, 0xf2);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectConstantBuffer
+
+DECLARE_INTERFACE_(ID3DX11EffectConstantBuffer, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectConstantBuffer
+ STDMETHOD(SetConstantBuffer)(THIS_ _In_ ID3D11Buffer *pConstantBuffer) PURE;
+ STDMETHOD(UndoSetConstantBuffer)(THIS) PURE;
+ STDMETHOD(GetConstantBuffer)(THIS_ _Outptr_ ID3D11Buffer **ppConstantBuffer) PURE;
+
+ STDMETHOD(SetTextureBuffer)(THIS_ _In_ ID3D11ShaderResourceView *pTextureBuffer) PURE;
+ STDMETHOD(UndoSetTextureBuffer)(THIS) PURE;
+ STDMETHOD(GetTextureBuffer)(THIS_ _Outptr_ ID3D11ShaderResourceView **ppTextureBuffer) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectShaderVariable ////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_SHADER_DESC:
+//
+// Retrieved by ID3DX11EffectShaderVariable::GetShaderDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_EFFECT_SHADER_DESC
+{
+ const uint8_t *pInputSignature; // Passed into CreateInputLayout,
+ // valid on VS and GS only
+
+ bool IsInline; // Is this an anonymous shader variable
+ // resulting from an inline shader assignment?
+
+
+ // -- The following fields are not valid after Optimize() --
+ const uint8_t *pBytecode; // Shader bytecode
+ uint32_t BytecodeLength;
+
+ LPCSTR SODecls[D3D11_SO_STREAM_COUNT]; // Stream out declaration string (for GS with SO)
+ uint32_t RasterizedStream;
+
+ uint32_t NumInputSignatureEntries; // Number of entries in the input signature
+ uint32_t NumOutputSignatureEntries; // Number of entries in the output signature
+ uint32_t NumPatchConstantSignatureEntries; // Number of entries in the patch constant signature
+};
+
+
+typedef interface ID3DX11EffectShaderVariable ID3DX11EffectShaderVariable;
+typedef interface ID3DX11EffectShaderVariable *LPD3D11EFFECTSHADERVARIABLE;
+
+// {7508B344-020A-4EC7-9118-62CDD36C88D7}
+DEFINE_GUID(IID_ID3DX11EffectShaderVariable,
+ 0x7508b344, 0x020a, 0x4ec7, 0x91, 0x18, 0x62, 0xcd, 0xd3, 0x6c, 0x88, 0xd7);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectShaderVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectShaderVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectShaderVariable
+ STDMETHOD(GetShaderDesc)(THIS_ _In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) PURE;
+
+ STDMETHOD(GetVertexShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) PURE;
+ STDMETHOD(GetGeometryShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) PURE;
+ STDMETHOD(GetPixelShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) PURE;
+ STDMETHOD(GetHullShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) PURE;
+ STDMETHOD(GetDomainShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) PURE;
+ STDMETHOD(GetComputeShader)(THIS_ _In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) PURE;
+
+ STDMETHOD(GetInputSignatureElementDesc)(THIS_ _In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+ STDMETHOD(GetOutputSignatureElementDesc)(THIS_ _In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+ STDMETHOD(GetPatchConstantSignatureElementDesc)(THIS_ _In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectBlendVariable /////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectBlendVariable ID3DX11EffectBlendVariable;
+typedef interface ID3DX11EffectBlendVariable *LPD3D11EFFECTBLENDVARIABLE;
+
+// {D664F4D7-3B81-4805-B277-C1DF58C39F53}
+DEFINE_GUID(IID_ID3DX11EffectBlendVariable,
+ 0xd664f4d7, 0x3b81, 0x4805, 0xb2, 0x77, 0xc1, 0xdf, 0x58, 0xc3, 0x9f, 0x53);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectBlendVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectBlendVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectBlendVariable
+ STDMETHOD(GetBlendState)(THIS_ _In_ uint32_t Index, _Outptr_ ID3D11BlendState **ppState) PURE;
+ STDMETHOD(SetBlendState)(THIS_ _In_ uint32_t Index, _In_ ID3D11BlendState *pState) PURE;
+ STDMETHOD(UndoSetBlendState)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD(GetBackingStore)(THIS_ _In_ uint32_t Index, _Out_ D3D11_BLEND_DESC *pDesc) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectDepthStencilVariable //////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectDepthStencilVariable ID3DX11EffectDepthStencilVariable;
+typedef interface ID3DX11EffectDepthStencilVariable *LPD3D11EFFECTDEPTHSTENCILVARIABLE;
+
+// {69B5751B-61A5-48E5-BD41-D93988111563}
+DEFINE_GUID(IID_ID3DX11EffectDepthStencilVariable,
+ 0x69b5751b, 0x61a5, 0x48e5, 0xbd, 0x41, 0xd9, 0x39, 0x88, 0x11, 0x15, 0x63);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectDepthStencilVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectDepthStencilVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectDepthStencilVariable
+ STDMETHOD(GetDepthStencilState)(THIS_ _In_ uint32_t Index, _Outptr_ ID3D11DepthStencilState **ppState) PURE;
+ STDMETHOD(SetDepthStencilState)(THIS_ _In_ uint32_t Index, _In_ ID3D11DepthStencilState *pState) PURE;
+ STDMETHOD(UndoSetDepthStencilState)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD(GetBackingStore)(THIS_ _In_ uint32_t Index, _Out_ D3D11_DEPTH_STENCIL_DESC *pDesc) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectRasterizerVariable ////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectRasterizerVariable ID3DX11EffectRasterizerVariable;
+typedef interface ID3DX11EffectRasterizerVariable *LPD3D11EFFECTRASTERIZERVARIABLE;
+
+// {53A262F6-5F74-4151-A132-E3DD19A62C9D}
+DEFINE_GUID(IID_ID3DX11EffectRasterizerVariable,
+ 0x53a262f6, 0x5f74, 0x4151, 0xa1, 0x32, 0xe3, 0xdd, 0x19, 0xa6, 0x2c, 0x9d);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectRasterizerVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectRasterizerVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectRasterizerVariable
+ STDMETHOD(GetRasterizerState)(THIS_ _In_ uint32_t Index, _Outptr_ ID3D11RasterizerState **ppState) PURE;
+ STDMETHOD(SetRasterizerState)(THIS_ _In_ uint32_t Index, _In_ ID3D11RasterizerState *pState) PURE;
+ STDMETHOD(UndoSetRasterizerState)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD(GetBackingStore)(THIS_ _In_ uint32_t Index, _Out_ D3D11_RASTERIZER_DESC *pDesc) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectSamplerVariable ///////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX11EffectSamplerVariable ID3DX11EffectSamplerVariable;
+typedef interface ID3DX11EffectSamplerVariable *LPD3D11EFFECTSAMPLERVARIABLE;
+
+// {C6402E55-1095-4D95-8931-F92660513DD9}
+DEFINE_GUID(IID_ID3DX11EffectSamplerVariable,
+ 0xc6402e55, 0x1095, 0x4d95, 0x89, 0x31, 0xf9, 0x26, 0x60, 0x51, 0x3d, 0xd9);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectSamplerVariable
+
+DECLARE_INTERFACE_(ID3DX11EffectSamplerVariable, ID3DX11EffectVariable)
+{
+ // IUnknown
+ // ID3DX11EffectVariable
+
+ // ID3DX11EffectSamplerVariable
+ STDMETHOD(GetSampler)(THIS_ _In_ uint32_t Index, _Outptr_ ID3D11SamplerState **ppSampler) PURE;
+ STDMETHOD(SetSampler)(THIS_ _In_ uint32_t Index, _In_ ID3D11SamplerState *pSampler) PURE;
+ STDMETHOD(UndoSetSampler)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD(GetBackingStore)(THIS_ _In_ uint32_t Index, _Out_ D3D11_SAMPLER_DESC *pDesc) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectPass //////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_PASS_DESC:
+//
+// Retrieved by ID3DX11EffectPass::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_PASS_DESC
+{
+ LPCSTR Name; // Name of this pass (nullptr if not anonymous)
+ uint32_t Annotations; // Number of annotations on this pass
+
+ uint8_t *pIAInputSignature; // Signature from VS or GS (if there is no VS)
+ // or nullptr if neither exists
+ size_t IAInputSignatureSize; // Singature size in bytes
+
+ uint32_t StencilRef; // Specified in SetDepthStencilState()
+ uint32_t SampleMask; // Specified in SetBlendState()
+ FLOAT BlendFactor[4]; // Specified in SetBlendState()
+};
+
+//----------------------------------------------------------------------------
+// D3DX11_PASS_SHADER_DESC:
+//
+// Retrieved by ID3DX11EffectPass::Get**ShaderDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_PASS_SHADER_DESC
+{
+ ID3DX11EffectShaderVariable *pShaderVariable; // The variable that this shader came from.
+ // If this is an inline shader assignment,
+ // the returned interface will be an
+ // anonymous shader variable, which is
+ // not retrievable any other way. It's
+ // name in the variable description will
+ // be "$Anonymous".
+ // If there is no assignment of this type in
+ // the pass block, pShaderVariable != nullptr,
+ // but pShaderVariable->IsValid() == false.
+
+ uint32_t ShaderIndex; // The element of pShaderVariable (if an array)
+ // or 0 if not applicable
+};
+
+typedef interface ID3DX11EffectPass ID3DX11EffectPass;
+typedef interface ID3DX11EffectPass *LPD3D11EFFECTPASS;
+
+// {3437CEC4-4AC1-4D87-8916-F4BD5A41380C}
+DEFINE_GUID(IID_ID3DX11EffectPass,
+ 0x3437cec4, 0x4ac1, 0x4d87, 0x89, 0x16, 0xf4, 0xbd, 0x5a, 0x41, 0x38, 0x0c);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectPass
+
+DECLARE_INTERFACE_(ID3DX11EffectPass, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11EffectPass
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_PASS_DESC *pDesc) PURE;
+
+ STDMETHOD(GetVertexShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+ STDMETHOD(GetGeometryShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+ STDMETHOD(GetPixelShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+ STDMETHOD(GetHullShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+ STDMETHOD(GetDomainShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+ STDMETHOD(GetComputeShaderDesc)(THIS_ _Out_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD(Apply)(THIS_ _In_ uint32_t Flags, _In_ ID3D11DeviceContext* pContext) PURE;
+
+ STDMETHOD(ComputeStateBlockMask)(THIS_ _Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectTechnique /////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_TECHNIQUE_DESC:
+//
+// Retrieved by ID3DX11EffectTechnique::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_TECHNIQUE_DESC
+{
+ LPCSTR Name; // Name of this technique (nullptr if not anonymous)
+ uint32_t Passes; // Number of passes contained within
+ uint32_t Annotations; // Number of annotations on this technique
+};
+
+typedef interface ID3DX11EffectTechnique ID3DX11EffectTechnique;
+typedef interface ID3DX11EffectTechnique *LPD3D11EFFECTTECHNIQUE;
+
+// {51198831-1F1D-4F47-BD76-41CB0835B1DE}
+DEFINE_GUID(IID_ID3DX11EffectTechnique,
+ 0x51198831, 0x1f1d, 0x4f47, 0xbd, 0x76, 0x41, 0xcb, 0x08, 0x35, 0xb1, 0xde);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectTechnique
+
+DECLARE_INTERFACE_(ID3DX11EffectTechnique, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11EffectTechnique
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_TECHNIQUE_DESC *pDesc) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD(ComputeStateBlockMask)(THIS_ _Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11EffectTechnique /////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_GROUP_DESC:
+//
+// Retrieved by ID3DX11EffectTechnique::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_GROUP_DESC
+{
+ LPCSTR Name; // Name of this group (only nullptr if global)
+ uint32_t Techniques; // Number of techniques contained within
+ uint32_t Annotations; // Number of annotations on this group
+};
+
+typedef interface ID3DX11EffectGroup ID3DX11EffectGroup;
+typedef interface ID3DX11EffectGroup *LPD3D11EFFECTGROUP;
+
+// {03074acf-97de-485f-b201-cb775264afd6}
+DEFINE_GUID(IID_ID3DX11EffectGroup,
+ 0x03074acf, 0x97de, 0x485f, 0xb2, 0x01, 0xcb, 0x77, 0x52, 0x64, 0xaf, 0xd6);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11EffectGroup
+
+DECLARE_INTERFACE_(ID3DX11EffectGroup, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11EffectGroup
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_GROUP_DESC *pDesc) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11Effect //////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_EFFECT_DESC:
+//
+// Retrieved by ID3DX11Effect::GetDesc()
+//----------------------------------------------------------------------------
+
+struct D3DX11_EFFECT_DESC
+{
+ uint32_t ConstantBuffers; // Number of constant buffers in this effect
+ uint32_t GlobalVariables; // Number of global variables in this effect
+ uint32_t InterfaceVariables; // Number of global interfaces in this effect
+ uint32_t Techniques; // Number of techniques in this effect
+ uint32_t Groups; // Number of groups in this effect
+};
+
+typedef interface ID3DX11Effect ID3DX11Effect;
+typedef interface ID3DX11Effect *LPD3D11EFFECT;
+
+// {FA61CA24-E4BA-4262-9DB8-B132E8CAE319}
+DEFINE_GUID(IID_ID3DX11Effect,
+ 0xfa61ca24, 0xe4ba, 0x4262, 0x9d, 0xb8, 0xb1, 0x32, 0xe8, 0xca, 0xe3, 0x19);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11Effect
+
+DECLARE_INTERFACE_(ID3DX11Effect, IUnknown)
+{
+ // IUnknown
+
+ // ID3DX11Effect
+ STDMETHOD_(bool, IsValid)(THIS) PURE;
+
+ STDMETHOD(GetDevice)(THIS_ _Outptr_ ID3D11Device** ppDevice) PURE;
+
+ STDMETHOD(GetDesc)(THIS_ _Out_ D3DX11_EFFECT_DESC *pDesc) PURE;
+
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+ STDMETHOD_(ID3DX11EffectVariable*, GetVariableBySemantic)(THIS_ _In_z_ LPCSTR Semantic) PURE;
+
+ STDMETHOD_(ID3DX11EffectGroup*, GetGroupByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectGroup*, GetGroupByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(THIS_ _In_ uint32_t Index) PURE;
+ STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(THIS_ _In_z_ LPCSTR Name) PURE;
+
+ STDMETHOD_(ID3D11ClassLinkage*, GetClassLinkage)(THIS) PURE;
+
+ STDMETHOD(CloneEffect)(THIS_ _In_ uint32_t Flags, _Outptr_ ID3DX11Effect** ppClonedEffect ) PURE;
+ STDMETHOD(Optimize)(THIS) PURE;
+ STDMETHOD_(bool, IsOptimized)(THIS) PURE;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+//----------------------------------------------------------------------------
+// D3DX11CreateEffectFromMemory
+//
+// Creates an effect instance from a compiled effect in memory
+//
+// Parameters:
+//
+// [in]
+//
+// pData
+// Blob of compiled effect data
+// DataLength
+// Length of the data blob
+// FXFlags
+// Flags pertaining to Effect creation
+// pDevice
+// Pointer to the D3D11 device on which to create Effect resources
+// srcName [optional]
+// ASCII string to use for debug object naming
+//
+// [out]
+//
+// ppEffect
+// Address of the newly created Effect interface
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX11CreateEffectFromMemory( _In_reads_bytes_(DataLength) LPCVOID pData,
+ _In_ SIZE_T DataLength,
+ _In_ UINT FXFlags,
+ _In_ ID3D11Device *pDevice,
+ _Outptr_ ID3DX11Effect **ppEffect,
+ _In_opt_z_ LPCSTR srcName = nullptr );
+
+//----------------------------------------------------------------------------
+// D3DX11CreateEffectFromFile
+//
+// Creates an effect instance from a compiled effect data file
+//
+// Parameters:
+//
+// [in]
+//
+// pFileName
+// Compiled effect file
+// FXFlags
+// Flags pertaining to Effect creation
+// pDevice
+// Pointer to the D3D11 device on which to create Effect resources
+//
+// [out]
+//
+// ppEffect
+// Address of the newly created Effect interface
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX11CreateEffectFromFile( _In_z_ LPCWSTR pFileName,
+ _In_ UINT FXFlags,
+ _In_ ID3D11Device *pDevice,
+ _Outptr_ ID3DX11Effect **ppEffect );
+
+//----------------------------------------------------------------------------
+// D3DX11CompileEffectFromMemory
+//
+// Complies an effect shader source file in memory and then creates an effect instance
+//
+// Parameters:
+//
+// [in]
+//
+// pData
+// Pointer to FX shader as an ASCII string
+// DataLength
+// Length of the FX shader ASCII string
+// srcName [optional]
+// ASCII string to use for debug object naming
+// pDefines [optional]
+// A NULL-terminated array of shader macros
+// pInclude [optional]
+// A pointer to an include interface
+// HLSLFlags
+// HLSL compile options (see D3DCOMPILE flags)
+// FXFlags
+// Flags pertaining to Effect compilation (see D3DCOMPILE_EFFECT flags)
+// pDevice
+// Pointer to the D3D11 device on which to create Effect resources
+//
+// [out]
+//
+// ppEffect
+// Address of the newly created Effect interface
+//
+//----------------------------------------------------------------------------
+
+HRESULT D3DX11CompileEffectFromMemory( _In_reads_bytes_(DataLength) LPCVOID pData,
+ _In_ SIZE_T DataLength,
+ _In_opt_z_ LPCSTR srcName,
+ _In_opt_ const D3D_SHADER_MACRO *pDefines,
+ _In_opt_ ID3DInclude *pInclude,
+ _In_ UINT HLSLFlags,
+ _In_ UINT FXFlags,
+ _In_ ID3D11Device *pDevice,
+ _Out_ ID3DX11Effect **ppEffect,
+ _Outptr_opt_result_maybenull_ ID3DBlob **ppErrors );
+
+//----------------------------------------------------------------------------
+// D3DX11CompileEffectFromFile
+//
+// Complies an effect shader source file and then creates an effect instance
+//
+// Parameters:
+//
+// [in]
+//
+// pFileName
+// FX shader source file
+// pDefines [optional]
+// A NULL-terminated array of shader macros
+// pInclude [optional]
+// A pointer to an include interface
+// HLSLFlags
+// HLSL compile options (see D3DCOMPILE flags)
+// FXFlags
+// Flags pertaining to Effect compilation (see D3DCOMPILE_EFFECT flags)
+// pDevice
+// Pointer to the D3D11 device on which to create Effect resources
+//
+// [out]
+//
+// ppEffect
+// Address of the newly created Effect interface
+//
+//----------------------------------------------------------------------------
+
+HRESULT D3DX11CompileEffectFromFile( _In_z_ LPCWSTR pFileName,
+ _In_opt_ const D3D_SHADER_MACRO *pDefines,
+ _In_opt_ ID3DInclude *pInclude,
+ _In_ UINT HLSLFlags,
+ _In_ UINT FXFlags,
+ _In_ ID3D11Device *pDevice,
+ _Out_ ID3DX11Effect **ppEffect,
+ _Outptr_opt_result_maybenull_ ID3DBlob **ppErrors );
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: D3DXGlobal.h
+//
+// Direct3D 11 Effects helper defines and data structures
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <assert.h>
+#include <string.h>
+
+namespace D3DX11Debug
+{
+ // Helper sets a D3D resource name string (used by PIX and debug layer leak reporting).
+ inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_z_ const char *name )
+ {
+ #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
+ resource->SetPrivateData( WKPDID_D3DDebugObjectName, static_cast<UINT>(strlen(name)), name );
+ #else
+ UNREFERENCED_PARAMETER(resource);
+ UNREFERENCED_PARAMETER(name);
+ #endif
+ }
+
+ template<UINT TNameLength>
+ inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_z_ const char (&name)[TNameLength])
+ {
+ #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
+ resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name);
+ #else
+ UNREFERENCED_PARAMETER(resource);
+ UNREFERENCED_PARAMETER(name);
+ #endif
+ }
+}
+
+using namespace D3DX11Debug;
+
+#define SAFE_RELEASE(p) { if (p) { (p)->Release(); (p) = nullptr; } }
+#define SAFE_ADDREF(p) { if (p) { (p)->AddRef(); } }
+
+#define SAFE_DELETE_ARRAY(p) { delete [](p); p = nullptr; }
+#define SAFE_DELETE(p) { delete (p); p = nullptr; }
+
+#if FXDEBUG
+#define __BREAK_ON_FAIL { __debugbreak(); }
+#else
+#define __BREAK_ON_FAIL
+#endif
+
+#define VA(x, action) { hr = (x); if (FAILED(hr)) { action; __BREAK_ON_FAIL; return hr; } }
+#define VNA(x,action) { if (!(x)) { action; __BREAK_ON_FAIL; hr = E_OUTOFMEMORY; goto lExit; } }
+#define VBA(x,action) { if (!(x)) { action; __BREAK_ON_FAIL; hr = E_FAIL; goto lExit; } }
+#define VHA(x,action) { hr = (x); if (FAILED(hr)) { action; __BREAK_ON_FAIL; goto lExit; } }
+
+#define V(x) { VA (x, 0) }
+#define VN(x) { VNA(x, 0) }
+#define VB(x) { VBA(x, 0) }
+#define VH(x) { VHA(x, 0) }
+
+#define VBD(x,str) { VBA(x, DPF(1,str)) }
+#define VHD(x,str) { VHA(x, DPF(1,str)) }
+
+#define VEASSERT(x) { hr = (x); if (FAILED(hr)) { __BREAK_ON_FAIL; assert(!#x); goto lExit; } }
+#define VNASSERT(x) { if (!(x)) { __BREAK_ON_FAIL; assert(!#x); hr = E_OUTOFMEMORY; goto lExit; } }
+
+#define D3DX11FLTASSIGN(a,b) { *reinterpret_cast< UINT32* >(&(a)) = *reinterpret_cast< UINT32* >(&(b)); }
+
+// Preferred data alignment -- must be a power of 2!
+static const uint32_t c_DataAlignment = sizeof(UINT_PTR);
+
+inline uint32_t AlignToPowerOf2(uint32_t Value, uint32_t Alignment)
+{
+ assert((Alignment & (Alignment - 1)) == 0);
+ // to align to 2^N, add 2^N - 1 and AND with all but lowest N bits set
+ _Analysis_assume_(Alignment > 0 && Value < MAXDWORD - Alignment);
+ return (Value + Alignment - 1) & (~(Alignment - 1));
+}
+
+inline void * AlignToPowerOf2(void *pValue, UINT_PTR Alignment)
+{
+ assert((Alignment & (Alignment - 1)) == 0);
+ // to align to 2^N, add 2^N - 1 and AND with all but lowest N bits set
+ return (void *)(((UINT_PTR)pValue + Alignment - 1) & (~((UINT_PTR)Alignment - 1)));
+}
+
+namespace D3DX11Core
+{
+
+//////////////////////////////////////////////////////////////////////////
+// CMemoryStream - A class to simplify reading binary data
+//////////////////////////////////////////////////////////////////////////
+class CMemoryStream
+{
+ uint8_t *m_pData;
+ size_t m_cbData;
+ size_t m_readPtr;
+
+public:
+ HRESULT SetData(_In_reads_bytes_(size) const void *pData, _In_ size_t size);
+
+ HRESULT Read(_Out_ uint32_t *pUint);
+ HRESULT Read(_Outptr_result_buffer_(size) void **ppData, _In_ size_t size);
+ HRESULT Read(_Outptr_ LPCSTR *ppString);
+
+ HRESULT ReadAtOffset(_In_ size_t offset, _In_ size_t size, _Outptr_result_buffer_(size) void **ppData);
+ HRESULT ReadAtOffset(_In_ size_t offset, _Outptr_result_z_ LPCSTR *ppString);
+
+ size_t GetPosition();
+ HRESULT Seek(_In_ size_t offset);
+
+ CMemoryStream();
+ ~CMemoryStream();
+};
+
+}
+
+#if defined(_DEBUG) && !defined(_M_X64)
+
+namespace D3DX11Debug
+{
+
+// This variable indicates how many ticks to go before rolling over
+// all of the timer variables in the FX system.
+// It is read from the system registry in debug builds; in retail the high bit is simply tested.
+
+_declspec(selectany) unsigned int g_TimerRolloverCount = 0x80000000;
+}
+
+#endif // _DEBUG && !_M_X64
+
+
+//////////////////////////////////////////////////////////////////////////
+// CEffectVector - A vector implementation
+//////////////////////////////////////////////////////////////////////////
+
+template<class T> class CEffectVector
+{
+protected:
+#if _DEBUG
+ T *m_pCastData; // makes debugging easier to have a casted version of the data
+#endif // _DEBUG
+
+ uint8_t *m_pData;
+ uint32_t m_MaxSize;
+ uint32_t m_CurSize;
+
+ HRESULT Grow()
+ {
+ return Reserve(m_CurSize + 1);
+ }
+
+ HRESULT Reserve(_In_ uint32_t DesiredSize)
+ {
+ if (DesiredSize > m_MaxSize)
+ {
+ uint8_t *pNewData;
+ uint32_t newSize = std::max(m_MaxSize * 2, DesiredSize);
+
+ if (newSize < 16)
+ newSize = 16;
+
+ if ((newSize < m_MaxSize) || (newSize < m_CurSize) || (newSize >= UINT_MAX / sizeof(T)))
+ {
+ m_hLastError = E_OUTOFMEMORY;
+ return m_hLastError;
+ }
+
+ pNewData = new uint8_t[newSize * sizeof(T)];
+ if (pNewData == nullptr)
+ {
+ m_hLastError = E_OUTOFMEMORY;
+ return m_hLastError;
+ }
+
+ if (m_pData)
+ {
+ memcpy(pNewData, m_pData, m_CurSize * sizeof(T));
+ delete []m_pData;
+ }
+
+ m_pData = pNewData;
+ m_MaxSize = newSize;
+ }
+#if _DEBUG
+ m_pCastData = (T*) m_pData;
+#endif // _DEBUG
+ return S_OK;
+ }
+
+public:
+ HRESULT m_hLastError;
+
+ CEffectVector<T>() : m_hLastError(S_OK), m_pData(nullptr), m_CurSize(0), m_MaxSize(0)
+ {
+#if _DEBUG
+ m_pCastData = nullptr;
+#endif // _DEBUG
+ }
+
+ ~CEffectVector<T>()
+ {
+ Clear();
+ }
+
+ // cleanly swaps two vectors -- useful for when you want
+ // to reallocate a vector and copy data over, then swap them back
+ void SwapVector(_Out_ CEffectVector<T> &vOther)
+ {
+ uint8_t tempData[sizeof(*this)];
+
+ memcpy(tempData, this, sizeof(*this));
+ memcpy(this, &vOther, sizeof(*this));
+ memcpy(&vOther, tempData, sizeof(*this));
+ }
+
+ HRESULT CopyFrom(_In_ const CEffectVector<T> &vOther)
+ {
+ HRESULT hr = S_OK;
+ Clear();
+ VN( m_pData = new uint8_t[vOther.m_MaxSize * sizeof(T)] );
+
+ m_CurSize = vOther.m_CurSize;
+ m_MaxSize = vOther.m_MaxSize;
+ m_hLastError = vOther.m_hLastError;
+
+ for (size_t i = 0; i < m_CurSize; ++ i)
+ {
+ ((T*)m_pData)[i] = ((T*)vOther.m_pData)[i];
+ }
+
+lExit:
+
+#if _DEBUG
+ m_pCastData = (T*) m_pData;
+#endif // _DEBUG
+
+ return hr;
+ }
+
+ void Clear()
+ {
+ Empty();
+ SAFE_DELETE_ARRAY(m_pData);
+ m_MaxSize = 0;
+#if _DEBUG
+ m_pCastData = nullptr;
+#endif // _DEBUG
+ }
+
+ void ClearWithoutDestructor()
+ {
+ m_CurSize = 0;
+ m_hLastError = S_OK;
+ SAFE_DELETE_ARRAY(m_pData);
+ m_MaxSize = 0;
+
+#if _DEBUG
+ m_pCastData = nullptr;
+#endif // _DEBUG
+ }
+
+ void Empty()
+ {
+
+ // manually invoke destructor on all elements
+ for (size_t i = 0; i < m_CurSize; ++ i)
+ {
+ ((T*)m_pData + i)->~T();
+ }
+ m_CurSize = 0;
+ m_hLastError = S_OK;
+ }
+
+ T* Add()
+ {
+ if (FAILED(Grow()))
+ return nullptr;
+
+ // placement new
+ return new((T*)m_pData + (m_CurSize ++)) T;
+ }
+
+ T* AddRange(_In_ uint32_t count)
+ {
+ if (m_CurSize + count < m_CurSize)
+ {
+ m_hLastError = E_OUTOFMEMORY;
+ return nullptr;
+ }
+
+ if (FAILED(Reserve(m_CurSize + count)))
+ return nullptr;
+
+ T *pData = (T*)m_pData + m_CurSize;
+ for (size_t i = 0; i < count; ++ i)
+ {
+ new(pData + i) T;
+ }
+ m_CurSize += count;
+ return pData;
+ }
+
+ HRESULT Add(_In_ const T& var)
+ {
+ if (FAILED(Grow()))
+ return m_hLastError;
+
+ memcpy((T*)m_pData + m_CurSize, &var, sizeof(T));
+ m_CurSize++;
+
+ return S_OK;
+ }
+
+ HRESULT AddRange(_In_reads_(count) const T *pVar, _In_ uint32_t count)
+ {
+ if (m_CurSize + count < m_CurSize)
+ {
+ m_hLastError = E_OUTOFMEMORY;
+ return m_hLastError;
+ }
+
+ if (FAILED(Reserve(m_CurSize + count)))
+ return m_hLastError;
+
+ memcpy((T*)m_pData + m_CurSize, pVar, count * sizeof(T));
+ m_CurSize += count;
+
+ return S_OK;
+ }
+
+ HRESULT Insert(_In_ const T& var, _In_ uint32_t index)
+ {
+ assert(index < m_CurSize);
+
+ if (FAILED(Grow()))
+ return m_hLastError;
+
+ memmove((T*)m_pData + index + 1, (T*)m_pData + index, (m_CurSize - index) * sizeof(T));
+ memcpy((T*)m_pData + index, &var, sizeof(T));
+ m_CurSize++;
+
+ return S_OK;
+ }
+
+ HRESULT InsertRange(_In_reads_(count) const T *pVar, _In_ uint32_t index, _In_ uint32_t count)
+ {
+ assert(index < m_CurSize);
+
+ if (m_CurSize + count < m_CurSize)
+ {
+ m_hLastError = E_OUTOFMEMORY;
+ return m_hLastError;
+ }
+
+ if (FAILED(Reserve(m_CurSize + count)))
+ return m_hLastError;
+
+ memmove((T*)m_pData + index + count, (T*)m_pData + index, (m_CurSize - index) * sizeof(T));
+ memcpy((T*)m_pData + index, pVar, count * sizeof(T));
+ m_CurSize += count;
+
+ return S_OK;
+ }
+
+ inline T& operator[](_In_ size_t index)
+ {
+ assert(index < m_CurSize);
+ return ((T*)m_pData)[index];
+ }
+
+ // Deletes element at index and shifts all other values down
+ void Delete(_In_ uint32_t index)
+ {
+ assert(index < m_CurSize);
+
+ -- m_CurSize;
+ memmove((T*)m_pData + index, (T*)m_pData + index + 1, (m_CurSize - index) * sizeof(T));
+ }
+
+ // Deletes element at index and moves the last element into its place
+ void QuickDelete(_In_ uint32_t index)
+ {
+ assert(index < m_CurSize);
+
+ -- m_CurSize;
+ memcpy((T*)m_pData + index, (T*)m_pData + m_CurSize, sizeof(T));
+ }
+
+ inline uint32_t GetSize() const
+ {
+ return m_CurSize;
+ }
+
+ inline T* GetData() const
+ {
+ return (T*)m_pData;
+ }
+
+ uint32_t FindIndexOf(_In_ const void *pEntry) const
+ {
+ for (size_t i = 0; i < m_CurSize; ++ i)
+ {
+ if (((T*)m_pData + i) == pEntry)
+ return i;
+ }
+
+ return -1;
+ }
+
+ void Sort(int (__cdecl *pfnCompare)(const void *pElem1, const void *pElem2))
+ {
+ qsort(m_pData, m_CurSize, sizeof(T), pfnCompare);
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// CEffectVectorOwner - implements a vector of ptrs to objects. The vector owns the objects.
+//////////////////////////////////////////////////////////////////////////
+template<class T> class CEffectVectorOwner : public CEffectVector<T*>
+{
+public:
+ ~CEffectVectorOwner<T>()
+ {
+ Clear();
+
+ for (size_t i=0; i<m_CurSize; i++)
+ SAFE_DELETE(((T**)m_pData)[i]);
+
+ SAFE_DELETE_ARRAY(m_pData);
+ }
+
+ void Clear()
+ {
+ Empty();
+ SAFE_DELETE_ARRAY(m_pData);
+ m_MaxSize = 0;
+ }
+
+ void Empty()
+ {
+ // manually invoke destructor on all elements
+ for (size_t i = 0; i < m_CurSize; ++ i)
+ {
+ SAFE_DELETE(((T**)m_pData)[i]);
+ }
+ m_CurSize = 0;
+ m_hLastError = S_OK;
+ }
+
+ void Delete(_In_ uint32_t index)
+ {
+ assert(index < m_CurSize);
+
+ SAFE_DELETE(((T**)m_pData)[index]);
+
+ CEffectVector<T*>::Delete(index);
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Checked uint32_t, uint64_t
+// Use CheckedNumber only with uint32_t and uint64_t
+//////////////////////////////////////////////////////////////////////////
+template <class T, T MaxValue> class CheckedNumber
+{
+ T m_Value;
+ bool m_bValid;
+
+public:
+ CheckedNumber<T, MaxValue>() : m_Value(0), m_bValid(true)
+ {
+ }
+
+ CheckedNumber<T, MaxValue>(const T &value) : m_Value(value), m_bValid(true)
+ {
+ }
+
+ CheckedNumber<T, MaxValue>(const CheckedNumber<T, MaxValue> &value) : m_bValid(value.m_bValid), m_Value(value.m_Value)
+ {
+ }
+
+ CheckedNumber<T, MaxValue> &operator+(const CheckedNumber<T, MaxValue> &other)
+ {
+ CheckedNumber<T, MaxValue> Res(*this);
+ return Res+=other;
+ }
+
+ CheckedNumber<T, MaxValue> &operator+=(const CheckedNumber<T, MaxValue> &other)
+ {
+ if (!other.m_bValid)
+ {
+ m_bValid = false;
+ }
+ else
+ {
+ m_Value += other.m_Value;
+
+ if (m_Value < other.m_Value)
+ m_bValid = false;
+ }
+
+ return *this;
+ }
+
+ CheckedNumber<T, MaxValue> &operator*(const CheckedNumber<T, MaxValue> &other)
+ {
+ CheckedNumber<T, MaxValue> Res(*this);
+ return Res*=other;
+ }
+
+ CheckedNumber<T, MaxValue> &operator*=(const CheckedNumber<T, MaxValue> &other)
+ {
+ if (!other.m_bValid)
+ {
+ m_bValid = false;
+ }
+ else
+ {
+ if (other.m_Value != 0)
+ {
+ if (m_Value > MaxValue / other.m_Value)
+ {
+ m_bValid = false;
+ }
+ }
+ m_Value *= other.m_Value;
+ }
+
+ return *this;
+ }
+
+ HRESULT GetValue(_Out_ T *pValue)
+ {
+ if (!m_bValid)
+ {
+ *pValue = uint32_t(-1);
+ return E_FAIL;
+ }
+
+ *pValue = m_Value;
+ return S_OK;
+ }
+};
+
+typedef CheckedNumber<uint32_t, _UI32_MAX> CCheckedDword;
+typedef CheckedNumber<uint64_t, _UI64_MAX> CCheckedDword64;
+
+
+//////////////////////////////////////////////////////////////////////////
+// Data Block Store - A linked list of allocations
+//////////////////////////////////////////////////////////////////////////
+
+class CDataBlock
+{
+protected:
+ uint32_t m_size;
+ uint32_t m_maxSize;
+ uint8_t *m_pData;
+ CDataBlock *m_pNext;
+
+ bool m_IsAligned; // Whether or not to align the data to c_DataAlignment
+
+public:
+ // AddData appends an existing use buffer to the data block
+ HRESULT AddData(_In_reads_bytes_(bufferSize) const void *pNewData, _In_ uint32_t bufferSize, _Outptr_ CDataBlock **ppBlock);
+
+ // Allocate reserves bufferSize bytes of contiguous memory and returns a pointer to the user
+ void* Allocate(_In_ uint32_t bufferSize, _Outptr_ CDataBlock **ppBlock);
+
+ void EnableAlignment();
+
+ CDataBlock();
+ ~CDataBlock();
+
+ friend class CDataBlockStore;
+};
+
+
+class CDataBlockStore
+{
+protected:
+ CDataBlock *m_pFirst;
+ CDataBlock *m_pLast;
+ uint32_t m_Size;
+ uint32_t m_Offset; // m_Offset gets added to offsets returned from AddData & AddString. Use this to set a global for the entire string block
+ bool m_IsAligned; // Whether or not to align the data to c_DataAlignment
+
+public:
+#if _DEBUG
+ uint32_t m_cAllocations;
+#endif
+
+public:
+ HRESULT AddString(_In_z_ LPCSTR pString, _Inout_ uint32_t *pOffset);
+ // Writes a null-terminated string to buffer
+
+ HRESULT AddData(_In_reads_bytes_(bufferSize) const void *pNewData, _In_ uint32_t bufferSize, _Inout_ uint32_t *pOffset);
+ // Writes data block to buffer
+
+ // Memory allocator support
+ void* Allocate(_In_ uint32_t bufferSize);
+ uint32_t GetSize();
+ void EnableAlignment();
+
+ CDataBlockStore();
+ ~CDataBlockStore();
+};
+
+// Custom allocator that uses CDataBlockStore
+// The trick is that we never free, so we don't have to keep as much state around
+// Use PRIVATENEW in CEffectLoader
+
+static void* __cdecl operator new(_In_ size_t s, _In_ CDataBlockStore &pAllocator)
+{
+#ifdef _M_X64
+ assert( s <= 0xffffffff );
+#endif
+ return pAllocator.Allocate( (uint32_t)s );
+}
+
+static void __cdecl operator delete(_In_opt_ void* p, _In_ CDataBlockStore &pAllocator)
+{
+ UNREFERENCED_PARAMETER(p);
+ UNREFERENCED_PARAMETER(pAllocator);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// Hash table
+//////////////////////////////////////////////////////////////////////////
+
+#define HASH_MIX(a,b,c) \
+{ \
+ a -= b; a -= c; a ^= (c>>13); \
+ b -= c; b -= a; b ^= (a<<8); \
+ c -= a; c -= b; c ^= (b>>13); \
+ a -= b; a -= c; a ^= (c>>12); \
+ b -= c; b -= a; b ^= (a<<16); \
+ c -= a; c -= b; c ^= (b>>5); \
+ a -= b; a -= c; a ^= (c>>3); \
+ b -= c; b -= a; b ^= (a<<10); \
+ c -= a; c -= b; c ^= (b>>15); \
+}
+
+static uint32_t ComputeHash(_In_reads_bytes_(cbToHash) const uint8_t *pb, _In_ uint32_t cbToHash)
+{
+ uint32_t cbLeft = cbToHash;
+
+ uint32_t a;
+ uint32_t b;
+ a = b = 0x9e3779b9; // the golden ratio; an arbitrary value
+
+ uint32_t c = 0;
+
+ while (cbLeft >= 12)
+ {
+ const uint32_t *pdw = reinterpret_cast<const uint32_t *>(pb);
+
+ a += pdw[0];
+ b += pdw[1];
+ c += pdw[2];
+
+ HASH_MIX(a,b,c);
+ pb += 12;
+ cbLeft -= 12;
+ }
+
+ c += cbToHash;
+
+ switch(cbLeft) // all the case statements fall through
+ {
+ case 11: c+=((uint32_t) pb[10] << 24);
+ case 10: c+=((uint32_t) pb[9] << 16);
+ case 9 : c+=((uint32_t) pb[8] << 8);
+ // the first byte of c is reserved for the length
+ case 8 : b+=((uint32_t) pb[7] << 24);
+ case 7 : b+=((uint32_t) pb[6] << 16);
+ case 6 : b+=((uint32_t) pb[5] << 8);
+ case 5 : b+=pb[4];
+ case 4 : a+=((uint32_t) pb[3] << 24);
+ case 3 : a+=((uint32_t) pb[2] << 16);
+ case 2 : a+=((uint32_t) pb[1] << 8);
+ case 1 : a+=pb[0];
+ }
+
+ HASH_MIX(a,b,c);
+
+ return c;
+}
+
+static uint32_t ComputeHashLower(_In_reads_bytes_(cbToHash) const uint8_t *pb, _In_ uint32_t cbToHash)
+{
+ uint32_t cbLeft = cbToHash;
+
+ uint32_t a;
+ uint32_t b;
+ a = b = 0x9e3779b9; // the golden ratio; an arbitrary value
+ uint32_t c = 0;
+
+ while (cbLeft >= 12)
+ {
+ uint8_t pbT[12];
+ for( size_t i = 0; i < 12; i++ )
+ pbT[i] = (uint8_t)tolower(pb[i]);
+
+ uint32_t *pdw = reinterpret_cast<uint32_t *>(pbT);
+
+ a += pdw[0];
+ b += pdw[1];
+ c += pdw[2];
+
+ HASH_MIX(a,b,c);
+ pb += 12;
+ cbLeft -= 12;
+ }
+
+ c += cbToHash;
+
+ uint8_t pbT[12];
+ for( size_t i = 0; i < cbLeft; i++ )
+ pbT[i] = (uint8_t)tolower(pb[i]);
+
+ switch(cbLeft) // all the case statements fall through
+ {
+ case 11: c+=((uint32_t) pbT[10] << 24);
+ case 10: c+=((uint32_t) pbT[9] << 16);
+ case 9 : c+=((uint32_t) pbT[8] << 8);
+ // the first byte of c is reserved for the length
+ case 8 : b+=((uint32_t) pbT[7] << 24);
+ case 7 : b+=((uint32_t) pbT[6] << 16);
+ case 6 : b+=((uint32_t) pbT[5] << 8);
+ case 5 : b+=pbT[4];
+ case 4 : a+=((uint32_t) pbT[3] << 24);
+ case 3 : a+=((uint32_t) pbT[2] << 16);
+ case 2 : a+=((uint32_t) pbT[1] << 8);
+ case 1 : a+=pbT[0];
+ }
+
+ HASH_MIX(a,b,c);
+
+ return c;
+}
+
+static uint32_t ComputeHash(_In_z_ LPCSTR pString)
+{
+ return ComputeHash(reinterpret_cast<const uint8_t*>(pString), (uint32_t)strlen(pString));
+}
+
+
+// 1) these numbers are prime
+// 2) each is slightly less than double the last
+// 4) each is roughly in between two powers of 2;
+// (2^n hash table sizes are VERY BAD; they effectively truncate your
+// precision down to the n least significant bits of the hash)
+static const uint32_t c_PrimeSizes[] =
+{
+ 11,
+ 23,
+ 53,
+ 97,
+ 193,
+ 389,
+ 769,
+ 1543,
+ 3079,
+ 6151,
+ 12289,
+ 24593,
+ 49157,
+ 98317,
+ 196613,
+ 393241,
+ 786433,
+ 1572869,
+ 3145739,
+ 6291469,
+ 12582917,
+ 25165843,
+ 50331653,
+ 100663319,
+ 201326611,
+ 402653189,
+ 805306457,
+ 1610612741,
+};
+
+template<typename T, bool (*pfnIsEqual)(const T &Data1, const T &Data2)>
+class CEffectHashTable
+{
+protected:
+
+ struct SHashEntry
+ {
+ uint32_t Hash;
+ T Data;
+ SHashEntry *pNext;
+ };
+
+ // Array of hash entries
+ SHashEntry **m_rgpHashEntries;
+ uint32_t m_NumHashSlots;
+ uint32_t m_NumEntries;
+ bool m_bOwnHashEntryArray;
+
+public:
+ class CIterator
+ {
+ friend class CEffectHashTable;
+
+ protected:
+ SHashEntry **ppHashSlot;
+ SHashEntry *pHashEntry;
+
+ public:
+ T GetData()
+ {
+ assert(pHashEntry != 0);
+ _Analysis_assume_(pHashEntry != 0);
+ return pHashEntry->Data;
+ }
+
+ uint32_t GetHash()
+ {
+ assert(pHashEntry != 0);
+ _Analysis_assume_(pHashEntry != 0);
+ return pHashEntry->Hash;
+ }
+ };
+
+ CEffectHashTable() : m_rgpHashEntries(nullptr), m_NumHashSlots(0), m_NumEntries(0), m_bOwnHashEntryArray(false)
+ {
+ }
+
+ HRESULT Initialize(_In_ const CEffectHashTable *pOther)
+ {
+ HRESULT hr = S_OK;
+ SHashEntry **rgpNewHashEntries = nullptr;
+ uint32_t valuesMigrated = 0;
+ uint32_t actualSize;
+
+ Cleanup();
+
+ actualSize = pOther->m_NumHashSlots;
+ VN( rgpNewHashEntries = new SHashEntry*[actualSize] );
+
+ ZeroMemory(rgpNewHashEntries, sizeof(SHashEntry*) * actualSize);
+
+ // Expensive operation: rebuild the hash table
+ CIterator iter, nextIter;
+ pOther->GetFirstEntry(&iter);
+ while (!pOther->PastEnd(&iter))
+ {
+ uint32_t index = iter.GetHash() % actualSize;
+
+ // we need to advance to the next element
+ // before we seize control of this element and move
+ // it to the new table
+ nextIter = iter;
+ pOther->GetNextEntry(&nextIter);
+
+ // seize this hash entry, migrate it to the new table
+ SHashEntry *pNewEntry;
+ VN( pNewEntry = new SHashEntry );
+
+ pNewEntry->pNext = rgpNewHashEntries[index];
+ pNewEntry->Data = iter.pHashEntry->Data;
+ pNewEntry->Hash = iter.pHashEntry->Hash;
+ rgpNewHashEntries[index] = pNewEntry;
+
+ iter = nextIter;
+ ++ valuesMigrated;
+ }
+
+ assert(valuesMigrated == pOther->m_NumEntries);
+
+ m_rgpHashEntries = rgpNewHashEntries;
+ m_NumHashSlots = actualSize;
+ m_NumEntries = pOther->m_NumEntries;
+ m_bOwnHashEntryArray = true;
+ rgpNewHashEntries = nullptr;
+
+lExit:
+ SAFE_DELETE_ARRAY( rgpNewHashEntries );
+ return hr;
+ }
+
+protected:
+ void CleanArray()
+ {
+ if (m_bOwnHashEntryArray)
+ {
+ SAFE_DELETE_ARRAY(m_rgpHashEntries);
+ m_bOwnHashEntryArray = false;
+ }
+ }
+
+public:
+ void Cleanup()
+ {
+ for (size_t i = 0; i < m_NumHashSlots; ++ i)
+ {
+ SHashEntry *pCurrentEntry = m_rgpHashEntries[i];
+ SHashEntry *pTempEntry;
+ while (nullptr != pCurrentEntry)
+ {
+ pTempEntry = pCurrentEntry->pNext;
+ SAFE_DELETE(pCurrentEntry);
+ pCurrentEntry = pTempEntry;
+ -- m_NumEntries;
+ }
+ }
+ CleanArray();
+ m_NumHashSlots = 0;
+ assert(m_NumEntries == 0);
+ }
+
+ ~CEffectHashTable()
+ {
+ Cleanup();
+ }
+
+ static uint32_t GetNextHashTableSize(_In_ uint32_t DesiredSize)
+ {
+ // figure out the next logical size to use
+ for (size_t i = 0; i < _countof(c_PrimeSizes); ++i )
+ {
+ if (c_PrimeSizes[i] >= DesiredSize)
+ {
+ return c_PrimeSizes[i];
+ }
+ }
+
+ return DesiredSize;
+ }
+
+ // O(n) function
+ // Grows to the next suitable size (based off of the prime number table)
+ // DesiredSize is merely a suggestion
+ HRESULT Grow(_In_ uint32_t DesiredSize,
+ _In_ uint32_t ProvidedArraySize = 0,
+ _In_reads_opt_(ProvidedArraySize) void** ProvidedArray = nullptr,
+ _In_ bool OwnProvidedArray = false)
+ {
+ HRESULT hr = S_OK;
+ SHashEntry **rgpNewHashEntries = nullptr;
+ uint32_t valuesMigrated = 0;
+ uint32_t actualSize;
+
+ VB( DesiredSize > m_NumHashSlots );
+
+ actualSize = GetNextHashTableSize(DesiredSize);
+
+ if (ProvidedArray &&
+ ProvidedArraySize >= actualSize)
+ {
+ rgpNewHashEntries = reinterpret_cast<SHashEntry**>(ProvidedArray);
+ }
+ else
+ {
+ OwnProvidedArray = true;
+
+ VN( rgpNewHashEntries = new SHashEntry*[actualSize] );
+ }
+
+ ZeroMemory(rgpNewHashEntries, sizeof(SHashEntry*) * actualSize);
+
+ // Expensive operation: rebuild the hash table
+ CIterator iter, nextIter;
+ GetFirstEntry(&iter);
+ while (!PastEnd(&iter))
+ {
+ uint32_t index = iter.GetHash() % actualSize;
+
+ // we need to advance to the next element
+ // before we seize control of this element and move
+ // it to the new table
+ nextIter = iter;
+ GetNextEntry(&nextIter);
+
+ // seize this hash entry, migrate it to the new table
+ iter.pHashEntry->pNext = rgpNewHashEntries[index];
+ rgpNewHashEntries[index] = iter.pHashEntry;
+
+ iter = nextIter;
+ ++ valuesMigrated;
+ }
+
+ assert(valuesMigrated == m_NumEntries);
+
+ CleanArray();
+ m_rgpHashEntries = rgpNewHashEntries;
+ m_NumHashSlots = actualSize;
+ m_bOwnHashEntryArray = OwnProvidedArray;
+
+lExit:
+ return hr;
+ }
+
+ HRESULT AutoGrow()
+ {
+ // arbitrary heuristic -- grow if 1:1
+ if (m_NumEntries >= m_NumHashSlots)
+ {
+ // grows this hash table so that it is roughly 50% full
+ return Grow(m_NumEntries * 2 + 1);
+ }
+ return S_OK;
+ }
+
+#if _DEBUG
+ void PrintHashTableStats()
+ {
+ if (m_NumHashSlots == 0)
+ {
+ DPF(0, "Uninitialized hash table!");
+ return;
+ }
+
+ float variance = 0.0f;
+ float mean = (float)m_NumEntries / (float)m_NumHashSlots;
+ uint32_t unusedSlots = 0;
+
+ DPF(0, "Hash table slots: %d, Entries in table: %d", m_NumHashSlots, m_NumEntries);
+
+ for (size_t i = 0; i < m_NumHashSlots; ++ i)
+ {
+ uint32_t entries = 0;
+ SHashEntry *pCurrentEntry = m_rgpHashEntries[i];
+
+ while (nullptr != pCurrentEntry)
+ {
+ SHashEntry *pCurrentEntry2 = m_rgpHashEntries[i];
+
+ // check other hash entries in this slot for hash collisions or duplications
+ while (pCurrentEntry2 != pCurrentEntry)
+ {
+ if (pCurrentEntry->Hash == pCurrentEntry2->Hash)
+ {
+ if (pfnIsEqual(pCurrentEntry->Data, pCurrentEntry2->Data))
+ {
+ assert(0);
+ DPF(0, "Duplicate entry (identical hash, identical data) found!");
+ }
+ else
+ {
+ DPF(0, "Hash collision (hash: %d)", pCurrentEntry->Hash);
+ }
+ }
+ pCurrentEntry2 = pCurrentEntry2->pNext;
+ }
+
+ pCurrentEntry = pCurrentEntry->pNext;
+ ++ entries;
+ }
+
+ if (0 == entries)
+ {
+ ++ unusedSlots;
+ }
+
+ // mean must be greater than 0 at this point
+ variance += (float)entries * (float)entries / mean;
+ }
+
+ variance /= std::max(1.0f, (m_NumHashSlots - 1));
+ variance -= (mean * mean);
+
+ DPF(0, "Mean number of entries per slot: %f, Standard deviation: %f, Unused slots; %d", mean, variance, unusedSlots);
+ }
+#endif // _DEBUG
+
+ // S_OK if element is found, E_FAIL otherwise
+ HRESULT FindValueWithHash(_In_ T Data, _In_ uint32_t Hash, _Out_ CIterator *pIterator)
+ {
+ assert(m_NumHashSlots > 0);
+
+ uint32_t index = Hash % m_NumHashSlots;
+ SHashEntry *pEntry = m_rgpHashEntries[index];
+ while (nullptr != pEntry)
+ {
+ if (Hash == pEntry->Hash && pfnIsEqual(pEntry->Data, Data))
+ {
+ pIterator->ppHashSlot = m_rgpHashEntries + index;
+ pIterator->pHashEntry = pEntry;
+ return S_OK;
+ }
+ pEntry = pEntry->pNext;
+ }
+ return E_FAIL;
+ }
+
+ // S_OK if element is found, E_FAIL otherwise
+ HRESULT FindFirstMatchingValue(_In_ uint32_t Hash, _Out_ CIterator *pIterator)
+ {
+ assert(m_NumHashSlots > 0);
+
+ uint32_t index = Hash % m_NumHashSlots;
+ SHashEntry *pEntry = m_rgpHashEntries[index];
+ while (nullptr != pEntry)
+ {
+ if (Hash == pEntry->Hash)
+ {
+ pIterator->ppHashSlot = m_rgpHashEntries + index;
+ pIterator->pHashEntry = pEntry;
+ return S_OK;
+ }
+ pEntry = pEntry->pNext;
+ }
+ return E_FAIL;
+ }
+
+ // Adds data at the specified hash slot without checking for existence
+ HRESULT AddValueWithHash(_In_ T Data, _In_ uint32_t Hash)
+ {
+ HRESULT hr = S_OK;
+
+ assert(m_NumHashSlots > 0);
+
+ SHashEntry *pHashEntry;
+ uint32_t index = Hash % m_NumHashSlots;
+
+ VN( pHashEntry = new SHashEntry );
+ pHashEntry->pNext = m_rgpHashEntries[index];
+ pHashEntry->Data = Data;
+ pHashEntry->Hash = Hash;
+ m_rgpHashEntries[index] = pHashEntry;
+
+ ++ m_NumEntries;
+
+lExit:
+ return hr;
+ }
+
+ // Iterator code:
+ //
+ // CMyHashTable::CIterator myIt;
+ // for (myTable.GetFirstEntry(&myIt); !myTable.PastEnd(&myIt); myTable.GetNextEntry(&myIt)
+ // { myTable.GetData(&myIt); }
+ void GetFirstEntry(_Out_ CIterator *pIterator)
+ {
+ SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
+ pIterator->ppHashSlot = m_rgpHashEntries;
+ while (pIterator->ppHashSlot < ppEnd)
+ {
+ if (nullptr != *(pIterator->ppHashSlot))
+ {
+ pIterator->pHashEntry = *(pIterator->ppHashSlot);
+ return;
+ }
+ ++ pIterator->ppHashSlot;
+ }
+ }
+
+ bool PastEnd(_Inout_ CIterator *pIterator)
+ {
+ SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
+ assert(pIterator->ppHashSlot >= m_rgpHashEntries && pIterator->ppHashSlot <= ppEnd);
+ return (pIterator->ppHashSlot == ppEnd);
+ }
+
+ void GetNextEntry(_Inout_ CIterator *pIterator)
+ {
+ SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
+ assert(pIterator->ppHashSlot >= m_rgpHashEntries && pIterator->ppHashSlot <= ppEnd);
+ assert(pIterator->pHashEntry != 0);
+ _Analysis_assume_(pIterator->pHashEntry != 0);
+
+ pIterator->pHashEntry = pIterator->pHashEntry->pNext;
+ if (nullptr != pIterator->pHashEntry)
+ {
+ return;
+ }
+
+ ++ pIterator->ppHashSlot;
+ while (pIterator->ppHashSlot < ppEnd)
+ {
+ pIterator->pHashEntry = *(pIterator->ppHashSlot);
+ if (nullptr != pIterator->pHashEntry)
+ {
+ return;
+ }
+ ++ pIterator->ppHashSlot;
+ }
+ // hit the end of the list, ppHashSlot == ppEnd
+ }
+
+ void RemoveEntry(_Inout_ CIterator *pIterator)
+ {
+ SHashEntry *pTemp;
+ SHashEntry **ppPrev;
+ SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
+
+ assert(pIterator && !PastEnd(pIterator));
+ ppPrev = pIterator->ppHashSlot;
+ pTemp = *ppPrev;
+ while (pTemp)
+ {
+ if (pTemp == pIterator->pHashEntry)
+ {
+ *ppPrev = pTemp->pNext;
+ pIterator->ppHashSlot = ppEnd;
+ delete pTemp;
+ return;
+ }
+ ppPrev = &pTemp->pNext;
+ pTemp = pTemp->pNext;
+ }
+
+ // Should never get here
+ assert(0);
+ }
+
+};
+
+// Allocates the hash slots on the regular heap (since the
+// hash table can grow), but all hash entries are allocated on
+// a private heap
+
+template<typename T, bool (*pfnIsEqual)(const T &Data1, const T &Data2)>
+class CEffectHashTableWithPrivateHeap : public CEffectHashTable<T, pfnIsEqual>
+{
+protected:
+ CDataBlockStore *m_pPrivateHeap;
+
+public:
+ CEffectHashTableWithPrivateHeap()
+ {
+ m_pPrivateHeap = nullptr;
+ }
+
+ void Cleanup()
+ {
+ CleanArray();
+ m_NumHashSlots = 0;
+ m_NumEntries = 0;
+ }
+
+ ~CEffectHashTableWithPrivateHeap()
+ {
+ Cleanup();
+ }
+
+ // Call this only once
+ void SetPrivateHeap(_In_ CDataBlockStore *pPrivateHeap)
+ {
+ assert(nullptr == m_pPrivateHeap);
+ m_pPrivateHeap = pPrivateHeap;
+ }
+
+ // Adds data at the specified hash slot without checking for existence
+ HRESULT AddValueWithHash(_In_ T Data, _In_ uint32_t Hash)
+ {
+ HRESULT hr = S_OK;
+
+ assert(m_pPrivateHeap);
+ _Analysis_assume_(m_pPrivateHeap);
+ assert(m_NumHashSlots > 0);
+
+ SHashEntry *pHashEntry;
+ uint32_t index = Hash % m_NumHashSlots;
+
+ VN( pHashEntry = new(*m_pPrivateHeap) SHashEntry );
+ pHashEntry->pNext = m_rgpHashEntries[index];
+ pHashEntry->Data = Data;
+ pHashEntry->Hash = Hash;
+ m_rgpHashEntries[index] = pHashEntry;
+
+ ++ m_NumEntries;
+
+lExit:
+ return hr;
+ }
+};
--- /dev/null
+//--------------------------------------------------------------------------------------
+// File: pchfx.h
+//
+// Direct3D 11 shader effects precompiled header
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// http://go.microsoft.com/fwlink/p/?LinkId=271568
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#pragma warning(disable : 4102 4127 4201 4505 4616 4706 6326)
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <algorithm>
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#include <D3DCompiler_x.h>
+#define DCOMMON_H_INCLUDED
+#define NO_D3D11_DEBUG_NAME
+#elif (_WIN32_WINNT >= 0x0602) || defined(_WIN7_PLATFORM_UPDATE)
+#include <d3d11_1.h>
+#include <D3DCompiler.h>
+#else
+#include <d3d11.h>
+#include <D3DCompiler.h>
+#endif
+
+#ifndef _WIN32_WINNT_WIN8
+#define _WIN32_WINNT_WIN8 0x0602
+#endif
+
+#undef DEFINE_GUID
+#include "INITGUID.h"
+
+#include "d3dx11effect.h"
+
+#define UNUSED -1
+
+//////////////////////////////////////////////////////////////////////////
+
+#define offsetof_fx( a, b ) (uint32_t)offsetof( a, b )
+
+#include "d3dxGlobal.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "Effect.h"
+#include "EffectStateBase11.h"
+#include "EffectLoad.h"
+
Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Express 2013 for Windows Desktop
+# Visual Studio 2013
VisualStudioVersion = 12.0.31101.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Kodi", "XBMC.vcxproj", "{3A68081D-E8F9-4523-9436-530DE9E5530A}"
ProjectSection(ProjectDependencies) = postProject
{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7} = {C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38} = {DF460EAB-570D-4B50-9089-2E2FC801BF38}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libPlatinum", "libPlatinum.vcxproj", "{B2975495-FBE4-4F94-AAC5-B21A9842BF50}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "visMilkdrop", "..\..\xbmc\visualizations\Milkdrop\Plugin.vcxproj", "{5E479372-4F34-426D-AA1E-9879E94C105D}"
EndProject
-EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ImageLib_dll", "..\..\lib\cximage-6.0\ImageLib.vcxproj", "{3B424C94-2005-44CC-BFB1-4B6C89090732}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ImageLib_jasper", "..\..\lib\cximage-6.0\jasper\jasper.vcxproj", "{3843C3D4-E5A6-4030-87EC-E7EE57242106}"
{034B1D02-CA92-455D-8866-DB95BEE49C10} = {034B1D02-CA92-455D-8866-DB95BEE49C10}
EndProjectSection
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Effects11", "..\..\lib\win32\Effects11\Effects11_2013.vcxproj", "{DF460EAB-570D-4B50-9089-2E2FC801BF38}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug Testsuite|Win32 = Debug Testsuite|Win32
{FE0A91C0-E30A-47CD-8A92-A508C9292452}.Debug|Win32.Build.0 = Debug|Win32
{FE0A91C0-E30A-47CD-8A92-A508C9292452}.Release|Win32.ActiveCfg = Release|Win32
{FE0A91C0-E30A-47CD-8A92-A508C9292452}.Release|Win32.Build.0 = Release|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Debug Testsuite|Win32.Build.0 = Debug|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Debug|Win32.ActiveCfg = Debug|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Debug|Win32.Build.0 = Debug|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Release|Win32.ActiveCfg = Release|Win32
- {00700E12-A63B-4E54-B962-4011A90584BD}.Release|Win32.Build.0 = Release|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Debug Testsuite|Win32.Build.0 = Debug|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Debug|Win32.ActiveCfg = Debug|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Debug|Win32.Build.0 = Debug|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Release|Win32.ActiveCfg = Release|Win32
{5E479372-4F34-426D-AA1E-9879E94C105D}.Release|Win32.Build.0 = Release|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Debug Testsuite|Win32.Build.0 = Debug|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Debug|Win32.ActiveCfg = Debug|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Debug|Win32.Build.0 = Debug|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Release|Win32.ActiveCfg = Release|Win32
- {F9E6874D-60A8-49BA-9393-A2105E63ABCF}.Release|Win32.Build.0 = Release|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Debug Testsuite|Win32.Build.0 = Debug|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Debug|Win32.ActiveCfg = Debug|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Debug|Win32.Build.0 = Debug|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Release|Win32.ActiveCfg = Release|Win32
- {19B16CD0-3B47-47B7-AB0E-81EF2BF1B187}.Release|Win32.Build.0 = Release|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Debug Testsuite|Win32.Build.0 = Debug|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Debug|Win32.ActiveCfg = Debug|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Debug|Win32.Build.0 = Debug|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Release|Win32.ActiveCfg = Release|Win32
- {22B25AEC-7223-46FC-8356-4418327EFDE1}.Release|Win32.Build.0 = Release|Win32
{3B424C94-2005-44CC-BFB1-4B6C89090732}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
{3B424C94-2005-44CC-BFB1-4B6C89090732}.Debug Testsuite|Win32.Build.0 = Debug|Win32
{3B424C94-2005-44CC-BFB1-4B6C89090732}.Debug|Win32.ActiveCfg = Debug|Win32
{0D91724A-E6F6-4708-AF47-9F88BBE2114C}.Debug|Win32.Build.0 = Debug|Win32
{0D91724A-E6F6-4708-AF47-9F88BBE2114C}.Release|Win32.ActiveCfg = Release|Win32
{0D91724A-E6F6-4708-AF47-9F88BBE2114C}.Release|Win32.Build.0 = Release|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Debug Testsuite|Win32.Build.0 = Debug|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Debug|Win32.ActiveCfg = Debug|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Debug|Win32.Build.0 = Debug|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Release|Win32.ActiveCfg = Release|Win32
- {DD4818AE-7E35-40B7-A6A0-0FF83AA1C916}.Release|Win32.Build.0 = Release|Win32
{D450FE9A-CE56-4496-B4AB-379094E642F2}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
{D450FE9A-CE56-4496-B4AB-379094E642F2}.Debug Testsuite|Win32.Build.0 = Debug|Win32
{D450FE9A-CE56-4496-B4AB-379094E642F2}.Debug|Win32.ActiveCfg = Debug|Win32
{AFF288D5-8A77-4817-8DD9-364E183CDBF8}.Debug|Win32.Build.0 = Debug|Win32
{AFF288D5-8A77-4817-8DD9-364E183CDBF8}.Release|Win32.ActiveCfg = Release|Win32
{AFF288D5-8A77-4817-8DD9-364E183CDBF8}.Release|Win32.Build.0 = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug Testsuite|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug Testsuite|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Debug|Win32.Build.0 = Debug|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.ActiveCfg = Release|Win32
+ {DF460EAB-570D-4B50-9089-2E2FC801BF38}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
projects / vuplus_xbmc / commitdiff