Restructuring starts. Got some initial CMake problems sorted. Need to extend.

18 files changed, 0 insertions, 20455 deletions

diff --git a/sample/d3d11/Effects11/Binary/EffectBinaryFormat.h b/sample/d3d11/Effects11/Binary/EffectBinaryFormat.h
deleted file mode 100644
index 50c5ce3..0000000
--- a/sample/d3d11/Effects11/Binary/EffectBinaryFormat.h
+++ /dev/null
@@ -1,666 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       Effect.h
-//  Content:    D3DX11 Effects Binary Format
-//              This is the binary file interface shared between the Effects 
-//              compiler and runtime.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-namespace D3DX11Effects
-{
-
-
-//////////////////////////////////////////////////////////////////////////
-// Version Control
-//////////////////////////////////////////////////////////////////////////
-
-#define D3D10_FXL_VERSION(_Major,_Minor) (('F' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))
-
-struct EVersionTag
-{
-    const char* m_pName;
-    DWORD       m_Version;
-    UINT        m_Tag;
-};
-
-// versions must be listed in ascending order
-static CONST EVersionTag g_EffectVersions[] = 
-{
-    { "fx_4_0", D3D10_FXL_VERSION(4,0),   0xFEFF1001 },
-    { "fx_4_1", D3D10_FXL_VERSION(4,1),   0xFEFF1011 },
-    { "fx_5_0", D3D10_FXL_VERSION(5,0),   0xFEFF2001 },
-};
-#define NUM_EFFECT10_VERSIONS ( sizeof(g_EffectVersions) / sizeof(EVersionTag) )
-
-
-//////////////////////////////////////////////////////////////////////////
-// 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,             // D3D10_BLEND_CONFIG.BlendFactor, points to a float4
-    ELHS_B_SampleMask,              // D3D10_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,
-};
-
-D3DX11INLINE BOOL IsObjectTypeHelper(EVarType InVarType,
-                                     EObjectType InObjType,
-                                     EObjectType TargetObjType)
-{
-    return (InVarType == EVT_Object) && (InObjType == TargetObjType);
-}
-
-D3DX11INLINE BOOL IsSamplerHelper(EVarType InVarType,
-                                  EObjectType InObjType)
-{
-    return (InVarType == EVT_Object) && (InObjType == EOT_Sampler);
-}
-
-D3DX11INLINE BOOL IsStateBlockObjectHelper(EVarType InVarType,
-                                           EObjectType InObjType)
-{
-    return (InVarType == EVT_Object) && ((InObjType == EOT_Blend) || (InObjType == EOT_DepthStencil) || (InObjType == EOT_Rasterizer) || IsSamplerHelper(InVarType, InObjType));
-}
-
-D3DX11INLINE 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));
-}
-
-D3DX11INLINE 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));
-}
-
-D3DX11INLINE BOOL IsInterfaceHelper(EVarType InVarType,
-                                         EObjectType InObjType)
-{
-    return (InVarType == EVT_Interface);
-}
-
-D3DX11INLINE 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));
-}
-
-D3DX11INLINE 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));
-}
-
-D3DX11INLINE BOOL IsRenderTargetViewHelper(EVarType InVarType,
-                                           EObjectType InObjType)
-{
-    return (InVarType == EVT_Object) && (InObjType == EOT_RenderTargetView);
-}
-
-D3DX11INLINE BOOL IsDepthStencilViewHelper(EVarType InVarType,
-                                           EObjectType InObjType)
-{
-    return (InVarType == EVT_Object) && (InObjType == EOT_DepthStencilView);
-}
-
-D3DX11INLINE 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 (BYTE[Header.cbUnstructured))
-//   Structured data block
-//     ConstantBuffer (SBinaryConstantBuffer CB) * Header.Effect.cCBs
-//       UINT  NumAnnotations
-//       Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//       Variable data (SBinaryNumericVariable Var) * (CB.cVariables)
-//         UINT  NumAnnotations
-//         Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//     Object variables (SBinaryObjectVariable Var) * (Header.cObjectVariables) *this structure is variable sized
-//       UINT  NumAnnotations
-//       Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//     Interface variables (SBinaryInterfaceVariable Var) * (Header.cInterfaceVariables) *this structure is variable sized
-//       UINT  NumAnnotations
-//       Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//     Groups (SBinaryGroup Group) * Header.cGroups
-//       UINT  NumAnnotations
-//       Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//       Techniques (SBinaryTechnique Technique) * Group.cTechniques
-//         UINT  NumAnnotations
-//         Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//         Pass (SBinaryPass Pass) * Technique.cPasses
-//           UINT  NumAnnotations
-//           Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
-//           Pass assignments (SBinaryAssignment) * Pass.cAssignments
-
-struct SBinaryHeader
-{
-    struct SVarCounts
-    {
-        UINT  cCBs;
-        UINT  cNumericVariables;
-        UINT  cObjectVariables;
-    };
-
-    UINT        Tag;    // should be equal to c_EffectFileTag
-                        // this is used to identify ASCII vs Binary files
-
-    SVarCounts  Effect;
-    SVarCounts  Pool;
-    
-    UINT        cTechniques;
-    UINT        cbUnstructured;
-
-    UINT        cStrings;
-    UINT        cShaderResources;
-
-    UINT        cDepthStencilBlocks;
-    UINT        cBlendStateBlocks;
-    UINT        cRasterizerStateBlocks;
-    UINT        cSamplers;
-    UINT        cRenderTargetViews;
-    UINT        cDepthStencilViews;
-
-    UINT        cTotalShaders;
-    UINT        cInlineShaders; // of the aforementioned shaders, the number that are defined inline within pass blocks
-
-    D3DX11INLINE bool RequiresPool() const
-    {
-        return (Pool.cCBs != 0) ||
-               (Pool.cNumericVariables != 0) ||
-               (Pool.cObjectVariables != 0);
-    }
-};
-
-struct SBinaryHeader5 : public SBinaryHeader
-{
-    UINT  cGroups;
-    UINT  cUnorderedAccessViews;
-    UINT  cInterfaceVariables;
-    UINT  cInterfaceVariableElements;
-    UINT  cClassInstanceElements;
-};
-
-// Constant buffer definition
-struct SBinaryConstantBuffer
-{
-    // private flags
-    static const UINT   c_IsTBuffer = (1 << 0);
-    static const UINT   c_IsSingle = (1 << 1);
-
-    UINT                oName;                // Offset to constant buffer name
-    UINT                Size;                 // Size, in bytes
-    UINT                Flags;
-    UINT                cVariables;           // # of variables inside this buffer
-    UINT                ExplicitBindPoint;    // Defined if the effect file specifies a bind point using the register keyword
-                                              // otherwise, -1
-};
-
-struct SBinaryAnnotation
-{
-    UINT  oName;                // Offset to variable name
-    UINT  oType;                // Offset to type information (SBinaryType)
-
-    // For numeric annotations:
-    // UINT  oDefaultValue;     // Offset to default initializer value
-    //
-    // For string annotations:
-    // UINT  oStringOffsets[Elements]; // Elements comes from the type data at oType
-};
-
-struct SBinaryNumericVariable
-{
-    UINT  oName;                // Offset to variable name
-    UINT  oType;                // Offset to type information (SBinaryType)
-    UINT  oSemantic;            // Offset to semantic information
-    UINT  Offset;               // Offset in parent constant buffer
-    UINT  oDefaultValue;        // Offset to default initializer value
-    UINT  Flags;                // Explicit bind point
-};
-
-struct SBinaryInterfaceVariable
-{
-    UINT  oName;                // Offset to variable name
-    UINT  oType;                // Offset to type information (SBinaryType)
-    UINT  oDefaultValue;        // Offset to default initializer array (SBinaryInterfaceInitializer[Elements])
-    UINT  Flags;
-};
-
-struct SBinaryInterfaceInitializer
-{
-    UINT  oInstanceName;
-    UINT  ArrayIndex;
-};
-
-struct SBinaryObjectVariable
-{
-    UINT  oName;                // Offset to variable name
-    UINT  oType;                // Offset to type information (SBinaryType)
-    UINT  oSemantic;            // Offset to semantic information
-    UINT  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 
-    // {
-    //   UINT  cAssignments;
-    //   SBinaryAssignment Assignments[cAssignments];
-    // } Blocks[Elements]
-    //
-    // For EObjectType == EOT_Texture*, EOT_Buffer
-    // <nothing>
-    //
-    // For EObjectType == EOT_*Shader, EOT_String
-    // UINT  oData[Elements]; // offsets to a shader data block or a NULL-terminated string
-    //
-    // For EObjectType == EOT_GeometryShaderSO
-    //   SBinaryGSSOInitializer[Elements]
-    //
-    // For EObjectType == EOT_*Shader5
-    //   SBinaryShaderData5[Elements]
-};
-
-struct SBinaryGSSOInitializer
-{
-    UINT  oShader;              // Offset to shader bytecode data block
-    UINT  oSODecl;              // Offset to StreamOutput decl string
-};
-
-struct SBinaryShaderData5
-{
-    UINT  oShader;              // Offset to shader bytecode data block
-    UINT  oSODecls[4];          // Offset to StreamOutput decl strings
-    UINT  cSODecls;             // Count of valid oSODecls entries.
-    UINT  RasterizedStream;     // Which stream is used for rasterization
-    UINT  cInterfaceBindings;   // Count of interface bindings.
-    UINT  oInterfaceBindings;   // Offset to SBinaryInterfaceInitializer[cInterfaceBindings].
-};
-
-struct SBinaryType
-{
-    UINT        oTypeName;      // Offset to friendly type name ("float4", "VS_OUTPUT")
-    EVarType    VarType;        // Numeric, Object, or Struct
-    UINT        Elements;       // # of array elements (0 for non-arrays)
-    UINT        TotalSize;      // Size in bytes; not necessarily Stride * Elements for arrays 
-                                // because of possible gap left in final register
-    UINT        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    
-    UINT        PackedSize;     // Size, in bytes, of this data typed when fully packed
-
-    struct SBinaryMember
-    {
-        UINT    oName;          // Offset to structure member name ("m_pFoo")
-        UINT    oSemantic;      // Offset to semantic ("POSITION0")
-        UINT    Offset;         // Offset, in bytes, relative to start of parent structure
-        UINT    oType;          // Offset to member's type descriptor
-    };
-
-    // the data that follows depends on the VarType:
-    // Numeric: SType::SNumericType
-    // Object:  EObjectType
-    // Struct:  
-    //   struct
-    //   {
-    //        UINT              cMembers;
-    //        SBinaryMembers    Members[cMembers];
-    //   } MemberInfo
-    //   struct
-    //   {
-    //        UINT              oBaseClassType;  // Offset to type information (SBinaryType)
-    //        UINT              cInterfaces;
-    //        UINT              oInterfaceTypes[cInterfaces];
-    //   } SBinaryTypeInheritance
-    // Interface: (nothing)
-};
-
-struct SBinaryNumericType
-{
-    ENumericLayout  NumericLayout   : 3;    // scalar (1x1), vector (1xN), matrix (NxN)
-    EScalarType     ScalarType      : 5;    // float32, int32, int8, etc.
-    UINT            Rows            : 3;    // 1 <= Rows <= 4
-    UINT            Columns         : 3;    // 1 <= Columns <= 4
-    UINT            IsColumnMajor   : 1;    // applies only to matrices
-    UINT            IsPackedArray   : 1;    // if this is an array, indicates whether elements should be greedily packed
-};
-
-struct SBinaryTypeInheritance
-{
-    UINT oBaseClass;            // Offset to base class type info or 0 if no base class.
-    UINT cInterfaces;
-
-    // Followed by UINT[cInterfaces] with offsets to the type
-    // info of each interface.
-};
-
-struct SBinaryGroup
-{
-    UINT  oName;
-    UINT  cTechniques;
-};
-
-struct SBinaryTechnique
-{
-    UINT  oName;
-    UINT  cPasses;
-};
-
-struct SBinaryPass
-{
-    UINT  oName;
-    UINT  cAssignments;
-};
-
-enum ECompilerAssignmentType
-{
-    ECAT_Invalid,                   // Assignment-specific data (always in the unstructured blob)
-    ECAT_Constant,                  // -N SConstant structures
-    ECAT_Variable,                  // -NULL 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
-{
-    UINT  iState;                   // index into g_lvGeneral
-    UINT  Index;                    // the particular index to assign to (see g_lvGeneral to find the # of valid indices)
-    ECompilerAssignmentType AssignmentType;
-    UINT  oInitializer;             // Offset of assignment-specific data
-
-    //struct SConstantAssignment
-    //{
-    //    UINT  NumConstants;         // number of constants to follow
-    //    SCompilerConstant Constants[NumConstants];
-    //};
-
-    struct SConstantIndex
-    {
-        UINT  oArrayName;
-        UINT  Index;
-    };
-
-    struct SVariableIndex
-    {
-        UINT  oArrayName;
-        UINT  oIndexVarName;
-    };
-
-    struct SIndexedObjectExpression
-    {   
-        UINT  oArrayName;
-        UINT  oCode;
-    };
-
-    struct SInlineShader
-    {
-        UINT  oShader;
-        UINT  oSODecl;
-    };
-
-    //struct SExpression or SInlineShader
-    //{
-    //    UINT  DataSize;
-    //    BYTE Data[DataSize];
-    //}
-
-};
-
-struct SBinaryConstant
-{
-    EScalarType Type;
-    union
-    {
-        BOOL    bValue;
-        INT     iValue;
-        float   fValue;
-    };
-};
-
-
-} // end namespace D3DX11Effects
diff --git a/sample/d3d11/Effects11/Binary/EffectStateBase11.h b/sample/d3d11/Effects11/Binary/EffectStateBase11.h
deleted file mode 100644
index 3727da2..0000000
--- a/sample/d3d11/Effects11/Binary/EffectStateBase11.h
+++ /dev/null
@@ -1,49 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectStateBase11.h
-//  Content:    D3DX11 Effects States Header
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-namespace D3DX11Effects
-{
-
-//////////////////////////////////////////////////////////////////////////
-// Effect HLSL states and late resolve lists
-//////////////////////////////////////////////////////////////////////////
-
-struct RValue
-{
-    const char  *m_pName;
-    UINT        m_Value;
-};
-
-#define RVALUE_END()    { NULL, 0U }
-#define RVALUE_ENTRY(prefix, x)         { #x, (UINT)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
-    D3D10_SHADER_VARIABLE_TYPE m_Type;  // data type allows
-    UINT            m_Cols;             // number of [m_Type]'s required (1 for a scalar, 4 for a vector)
-    UINT            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
-    UINT            m_Offset;           // offset into the given block type where this value should be written
-    UINT            m_Stride;           // for vectors, byte stride between two consecutive values. if 0, m_Type's size is used
-};
-
-#define LVALUE_END()    { NULL, D3D10_SVT_UINT, 0, 0, 0, NULL }
-
-extern CONST LValue g_lvGeneral[];
-extern CONST UINT   g_lvGeneralCount;
-
-} // end namespace D3DX11Effects
diff --git a/sample/d3d11/Effects11/Binary/EffectStates11.h b/sample/d3d11/Effects11/Binary/EffectStates11.h
deleted file mode 100644
index 3bb3087..0000000
--- a/sample/d3d11/Effects11/Binary/EffectStates11.h
+++ /dev/null
@@ -1,236 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectStates11.h
-//  Content:    D3DX11 Effects States Header
-//              This file defines properties of states which can appear in
-//              state blocks and pass blocks.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include <EffectStateBase11.h>
-
-namespace D3DX11Effects
-{
-
-//////////////////////////////////////////////////////////////////////////
-// Effect HLSL late resolve lists (state values)
-//////////////////////////////////////////////////////////////////////////
-
-static CONST RValue g_rvNULL[] =
-{
-    { "NULL",  0 },
-    RVALUE_END()
-};
-
-
-static CONST RValue g_rvBOOL[] =
-{
-    { "FALSE",  0 },
-    { "TRUE",   1 },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvDEPTH_WRITE_MASK[] =
-{
-    { "ZERO",   D3D10_DEPTH_WRITE_MASK_ZERO     },
-    { "ALL",    D3D10_DEPTH_WRITE_MASK_ALL      },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvFILL[] =
-{
-    { "WIREFRAME",  D3D10_FILL_WIREFRAME },
-    { "SOLID",      D3D10_FILL_SOLID     },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvFILTER[] =
-{
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_MAG_MIP_POINT                           ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_MAG_POINT_MIP_LINEAR                    ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_POINT_MAG_LINEAR_MIP_POINT              ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_POINT_MAG_MIP_LINEAR                    ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_LINEAR_MAG_MIP_POINT                    ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_LINEAR_MAG_POINT_MIP_LINEAR             ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_MAG_LINEAR_MIP_POINT                    ),
-    RVALUE_ENTRY(D3D10_FILTER_,     MIN_MAG_MIP_LINEAR                          ),
-    RVALUE_ENTRY(D3D10_FILTER_,     ANISOTROPIC                                 ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_MAG_MIP_POINT                ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_MAG_POINT_MIP_LINEAR         ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT   ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_POINT_MAG_MIP_LINEAR         ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_LINEAR_MAG_MIP_POINT         ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR  ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_MAG_LINEAR_MIP_POINT         ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_MIN_MAG_MIP_LINEAR               ),
-    RVALUE_ENTRY(D3D10_FILTER_,     COMPARISON_ANISOTROPIC                      ),
-    RVALUE_ENTRY(D3D10_FILTER_,     TEXT_1BIT                                   ),
-    RVALUE_END()
-};
-
-static CONST RValue g_rvBLEND[] =
-{
-    { "ZERO",               D3D10_BLEND_ZERO            },
-    { "ONE",                D3D10_BLEND_ONE             },
-    { "SRC_COLOR",          D3D10_BLEND_SRC_COLOR        },
-    { "INV_SRC_COLOR",      D3D10_BLEND_INV_SRC_COLOR     },
-    { "SRC_ALPHA",          D3D10_BLEND_SRC_ALPHA        },
-    { "INV_SRC_ALPHA",      D3D10_BLEND_INV_SRC_ALPHA     },
-    { "DEST_ALPHA",         D3D10_BLEND_DEST_ALPHA       },
-    { "INV_DEST_ALPHA",     D3D10_BLEND_INV_DEST_ALPHA    },
-    { "DEST_COLOR",         D3D10_BLEND_DEST_COLOR       },
-    { "INV_DEST_COLOR",     D3D10_BLEND_INV_DEST_COLOR    },
-    { "SRC_ALPHA_SAT",      D3D10_BLEND_SRC_ALPHA_SAT     },
-    { "BLEND_FACTOR",       D3D10_BLEND_BLEND_FACTOR     },
-    { "INV_BLEND_FACTOR",   D3D10_BLEND_INV_BLEND_FACTOR  },
-    { "SRC1_COLOR",         D3D10_BLEND_SRC1_COLOR        },
-    { "INV_SRC1_COLOR",     D3D10_BLEND_INV_SRC1_COLOR    },
-    { "SRC1_ALPHA",         D3D10_BLEND_SRC1_ALPHA       },
-    { "INV_SRC1_ALPHA",     D3D10_BLEND_INV_SRC1_ALPHA    },
-
-    RVALUE_END()
-};
-
-static CONST RValue g_rvTADDRESS[] =
-{
-    { "CLAMP",          D3D10_TEXTURE_ADDRESS_CLAMP      },
-    { "WRAP",           D3D10_TEXTURE_ADDRESS_WRAP       },
-    { "MIRROR",         D3D10_TEXTURE_ADDRESS_MIRROR     },
-    { "BORDER",         D3D10_TEXTURE_ADDRESS_BORDER     },
-    { "MIRROR_ONCE",    D3D10_TEXTURE_ADDRESS_MIRROR_ONCE },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvCULL[] =
-{
-    { "NONE",           D3D10_CULL_NONE     },
-    { "FRONT",          D3D10_CULL_FRONT    },
-    { "BACK",           D3D10_CULL_BACK     },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvCMP[] =
-{
-    { "NEVER",          D3D10_COMPARISON_NEVER        },
-    { "LESS",           D3D10_COMPARISON_LESS         },
-    { "EQUAL",          D3D10_COMPARISON_EQUAL        },
-    { "LESS_EQUAL",     D3D10_COMPARISON_LESS_EQUAL    },
-    { "GREATER",        D3D10_COMPARISON_GREATER      },
-    { "NOT_EQUAL",      D3D10_COMPARISON_NOT_EQUAL     },
-    { "GREATER_EQUAL",  D3D10_COMPARISON_GREATER_EQUAL },
-    { "ALWAYS",         D3D10_COMPARISON_ALWAYS       },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvSTENCILOP[] =
-{
-    { "KEEP",       D3D10_STENCIL_OP_KEEP    },
-    { "ZERO",       D3D10_STENCIL_OP_ZERO    },
-    { "REPLACE",    D3D10_STENCIL_OP_REPLACE },
-    { "INCR_SAT",   D3D10_STENCIL_OP_INCR_SAT },
-    { "DECR_SAT",   D3D10_STENCIL_OP_DECR_SAT },
-    { "INVERT",     D3D10_STENCIL_OP_INVERT  },
-    { "INCR",       D3D10_STENCIL_OP_INCR    },
-    { "DECR",       D3D10_STENCIL_OP_DECR    },
-    RVALUE_END()
-};
-
-static CONST RValue g_rvBLENDOP[] =
-{
-    { "ADD",            D3D10_BLEND_OP_ADD         },
-    { "SUBTRACT",       D3D10_BLEND_OP_SUBTRACT    },
-    { "REV_SUBTRACT",   D3D10_BLEND_OP_REV_SUBTRACT },
-    { "MIN",            D3D10_BLEND_OP_MIN         },
-    { "MAX",            D3D10_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,           D3D10_SVT_RASTERIZER,         1, 1, FALSE, NULL,                    ELHS_RasterizerBlock,           offsetof_fx(SPassBlock, BackingStore.pRasterizerBlock),                        0 },
-    { "DepthStencilState",          EBT_Pass,           D3D10_SVT_DEPTHSTENCIL,       1, 1, FALSE, NULL,                    ELHS_DepthStencilBlock,         offsetof_fx(SPassBlock, BackingStore.pDepthStencilBlock),                      0 },
-    { "BlendState",                 EBT_Pass,           D3D10_SVT_BLEND,              1, 1, FALSE, NULL,                    ELHS_BlendBlock,                offsetof_fx(SPassBlock, BackingStore.pBlendBlock),                             0 },
-    { "RenderTargetView",           EBT_Pass,           D3D10_SVT_RENDERTARGETVIEW,   1, 8, FALSE, NULL,                    ELHS_RenderTargetView,          offsetof_fx(SPassBlock, BackingStore.pRenderTargetViews),                      0 },
-    { "DepthStencilView",           EBT_Pass,           D3D10_SVT_DEPTHSTENCILVIEW,   1, 8, FALSE, NULL,                    ELHS_DepthStencilView,          offsetof_fx(SPassBlock, BackingStore.pDepthStencilView),                       0 },
-    { "GenerateMips",               EBT_Pass,           D3D10_SVT_TEXTURE,            1, 1, FALSE, NULL,                    ELHS_GenerateMips,              0,                                                                          0 },
-    // Shaders
-    { "VertexShader",               EBT_Pass,           D3D10_SVT_VERTEXSHADER,       1, 1, FALSE, g_rvNULL,                ELHS_VertexShaderBlock,         offsetof_fx(SPassBlock, BackingStore.pVertexShaderBlock),                      0 },
-    { "PixelShader",                EBT_Pass,           D3D10_SVT_PIXELSHADER,        1, 1, FALSE, g_rvNULL,                ELHS_PixelShaderBlock,          offsetof_fx(SPassBlock, BackingStore.pPixelShaderBlock),                       0 },
-    { "GeometryShader",             EBT_Pass,           D3D10_SVT_GEOMETRYSHADER,     1, 1, FALSE, g_rvNULL,                ELHS_GeometryShaderBlock,       offsetof_fx(SPassBlock, BackingStore.pGeometryShaderBlock),                    0 },
-    // RObject config assignments
-    { "DS_StencilRef",              EBT_Pass,           D3D10_SVT_UINT,               1, 1, FALSE, NULL,                    ELHS_DS_StencilRef,             offsetof_fx(SPassBlock, BackingStore.StencilRef),                              0 },
-    { "AB_BlendFactor",             EBT_Pass,           D3D10_SVT_FLOAT,              4, 1, FALSE, NULL,                    ELHS_B_BlendFactor,             offsetof_fx(SPassBlock, BackingStore.BlendFactor),                             0 },
-    { "AB_SampleMask",              EBT_Pass,           D3D10_SVT_UINT,               1, 1, FALSE, NULL,                    ELHS_B_SampleMask,              offsetof_fx(SPassBlock, BackingStore.SampleMask),                              0 },
-
-    { "FillMode",                   EBT_Rasterizer,     D3D10_SVT_UINT,               1, 1, FALSE, g_rvFILL,                ELHS_FillMode,                  offsetof_fx(SRasterizerBlock, BackingStore.FillMode),                          0 },
-    { "CullMode",                   EBT_Rasterizer,     D3D10_SVT_UINT,               1, 1, FALSE, g_rvCULL,                ELHS_CullMode,                  offsetof_fx(SRasterizerBlock, BackingStore.CullMode),                          0 },
-    { "FrontCounterClockwise",      EBT_Rasterizer,     D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_FrontCC,                   offsetof_fx(SRasterizerBlock, BackingStore.FrontCounterClockwise),             0 },
-    { "DepthBias",                  EBT_Rasterizer,     D3D10_SVT_UINT,               1, 1, FALSE, NULL,                    ELHS_DepthBias,                 offsetof_fx(SRasterizerBlock, BackingStore.DepthBias),                         0 },
-    { "DepthBiasClamp",             EBT_Rasterizer,     D3D10_SVT_FLOAT,              1, 1, FALSE, NULL,                    ELHS_DepthBiasClamp,            offsetof_fx(SRasterizerBlock, BackingStore.DepthBiasClamp),                    0 },
-    { "SlopeScaledDepthBias",       EBT_Rasterizer,     D3D10_SVT_FLOAT,              1, 1, FALSE, NULL,                    ELHS_SlopeScaledDepthBias,      offsetof_fx(SRasterizerBlock, BackingStore.SlopeScaledDepthBias),              0 },
-    { "DepthClipEnable",            EBT_Rasterizer,     D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_DepthClipEnable,           offsetof_fx(SRasterizerBlock, BackingStore.DepthClipEnable),                   0 },
-    { "ScissorEnable",              EBT_Rasterizer,     D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_ScissorEnable,             offsetof_fx(SRasterizerBlock, BackingStore.ScissorEnable),                     0 },
-    { "MultisampleEnable",          EBT_Rasterizer,     D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_MultisampleEnable,         offsetof_fx(SRasterizerBlock, BackingStore.MultisampleEnable),                 0 },
-    { "AntialiasedLineEnable",      EBT_Rasterizer,     D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_AntialiasedLineEnable,     offsetof_fx(SRasterizerBlock, BackingStore.AntialiasedLineEnable),             0 },
-    
-    { "DepthEnable",                EBT_DepthStencil,   D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_DepthEnable,               offsetof_fx(SDepthStencilBlock, BackingStore.DepthEnable),                     0 },
-    { "DepthWriteMask",             EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvDEPTH_WRITE_MASK,    ELHS_DepthWriteMask,            offsetof_fx(SDepthStencilBlock, BackingStore.DepthWriteMask),                  0 },
-    { "DepthFunc",                  EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvCMP,                 ELHS_DepthFunc,                 offsetof_fx(SDepthStencilBlock, BackingStore.DepthFunc),                       0 },
-    { "StencilEnable",              EBT_DepthStencil,   D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_StencilEnable,             offsetof_fx(SDepthStencilBlock, BackingStore.StencilEnable),                   0 },
-    { "StencilReadMask",            EBT_DepthStencil,   D3D10_SVT_UINT8,              1, 1, FALSE, NULL,                    ELHS_StencilReadMask,           offsetof_fx(SDepthStencilBlock, BackingStore.StencilReadMask),                 0 },
-    { "StencilWriteMask",           EBT_DepthStencil,   D3D10_SVT_UINT8,              1, 1, FALSE, NULL,                    ELHS_StencilWriteMask,          offsetof_fx(SDepthStencilBlock, BackingStore.StencilWriteMask),                0 },
-    { "FrontFaceStencilFail",       EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_FrontFaceStencilFailOp,    offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFailOp),         0 },
-    { "FrontFaceStencilDepthFail",  EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_FrontFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilDepthFailOp),   0 },
-    { "FrontFaceStencilPass",       EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_FrontFaceStencilPassOp,    offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilPassOp),         0 },
-    { "FrontFaceStencilFunc",       EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvCMP,                 ELHS_FrontFaceStencilFunc,      offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFunc),           0 },
-    { "BackFaceStencilFail",        EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_BackFaceStencilFailOp,     offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFailOp),          0 },
-    { "BackFaceStencilDepthFail",   EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_BackFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilDepthFailOp),     0 },
-    { "BackFaceStencilPass",        EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvSTENCILOP,           ELHS_BackFaceStencilPassOp,     offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilPassOp),          0 },
-    { "BackFaceStencilFunc",        EBT_DepthStencil,   D3D10_SVT_UINT,               1, 1, FALSE, g_rvCMP,                 ELHS_BackFaceStencilFunc,       offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFunc),            0 },
-
-    { "AlphaToCoverageEnable",      EBT_Blend,          D3D10_SVT_BOOL,               1, 1, FALSE, g_rvBOOL,                ELHS_AlphaToCoverage,           offsetof_fx(SBlendBlock, BackingStore.AlphaToCoverageEnable),                  0 },
-    { "BlendEnable",                EBT_Blend,          D3D10_SVT_BOOL,               1, 8, FALSE, g_rvBOOL,                ELHS_BlendEnable,               offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendEnable),            strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "SrcBlend",                   EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLEND,               ELHS_SrcBlend,                  offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlend),               strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "DestBlend",                  EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLEND,               ELHS_DestBlend,                 offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlend),              strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "BlendOp",                    EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLENDOP,             ELHS_BlendOp,                   offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOp),                strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "SrcBlendAlpha",              EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLEND,               ELHS_SrcBlendAlpha,             offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlendAlpha),          strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "DestBlendAlpha",             EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLEND,               ELHS_DestBlendAlpha,            offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlendAlpha),         strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "BlendOpAlpha",               EBT_Blend,          D3D10_SVT_UINT,               1, 8, TRUE,  g_rvBLENDOP,             ELHS_BlendOpAlpha,              offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOpAlpha),           strideof(SBlendBlock, BackingStore.RenderTarget) },
-    { "RenderTargetWriteMask",      EBT_Blend,          D3D10_SVT_UINT8,              1, 8, FALSE, NULL,                    ELHS_RenderTargetWriteMask,     offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].RenderTargetWriteMask),  strideof(SBlendBlock, BackingStore.RenderTarget) },
-
-    { "Filter",                     EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, g_rvFILTER,              ELHS_Filter,                    offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.Filter),                   0 },
-    { "AddressU",                   EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, g_rvTADDRESS,            ELHS_AddressU,                  offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressU),                 0 },
-    { "AddressV",                   EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, g_rvTADDRESS,            ELHS_AddressV,                  offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressV),                 0 },
-    { "AddressW",                   EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, g_rvTADDRESS,            ELHS_AddressW,                  offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressW),                 0 },
-    { "MipLODBias",                 EBT_Sampler,        D3D10_SVT_FLOAT,              1, 1, FALSE, NULL,                    ELHS_MipLODBias,                offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MipLODBias),               0 },
-    { "MaxAnisotropy",              EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, NULL,                    ELHS_MaxAnisotropy,             offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxAnisotropy),            0 },
-    { "ComparisonFunc",             EBT_Sampler,        D3D10_SVT_UINT,               1, 1, FALSE, g_rvCMP,                 ELHS_ComparisonFunc,            offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.ComparisonFunc),           0 },
-    { "BorderColor",                EBT_Sampler,        D3D10_SVT_FLOAT,              4, 1, FALSE, NULL,                    ELHS_BorderColor,               offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.BorderColor),              0 },
-    { "MinLOD",                     EBT_Sampler,        D3D10_SVT_FLOAT,              1, 1, FALSE, NULL,                    ELHS_MinLOD,                    offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MinLOD),                   0 },
-    { "MaxLOD",                     EBT_Sampler,        D3D10_SVT_FLOAT,              1, 1, FALSE, NULL,                    ELHS_MaxLOD,                    offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxLOD),                   0 },
-    { "Texture",                    EBT_Sampler,        D3D10_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 UINT g_lvGeneralCount = NUM_STATES;
-
-} // end namespace D3DX11Effects
diff --git a/sample/d3d11/Effects11/Binary/SOParser.h b/sample/d3d11/Effects11/Binary/SOParser.h
deleted file mode 100644
index 1fb95a9..0000000
--- a/sample/d3d11/Effects11/Binary/SOParser.h
+++ /dev/null
@@ -1,311 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       SOParser.h
-//  Content:    D3DX11 Effects Stream Out Decl Parser
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-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 UINT 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( UINT 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( UINT iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
-        {
-            hr = Parse( iDecl, pStreams[iDecl] );
-            if( FAILED(hr) )
-            {
-                char pStream[16];
-                StringCchPrintfA( pStream, 16, " in stream %d.", iDecl );
-                pStream[15] = 0;
-                StringCchCatA( m_pError, MAX_ERROR_SIZE, pStream );
-                return hr;
-            }
-        }
-        return hr;
-    }
-
-    // Return resulting declarations
-    D3D11_SO_DECLARATION_ENTRY *GetDeclArray()
-    {
-        return &m_vDecls[0];
-    }
-
-    char* GetErrorString()
-    {
-        return m_pError;
-    }
-
-    UINT GetDeclCount() const
-    {
-        return m_vDecls.GetSize();
-    }
-
-    // Return resulting buffer strides
-    void GetStrides( UINT strides[4] )
-    {
-        UINT len = GetDeclCount();
-        strides[0] = strides[1] = strides[2] = strides[3] = 0;
-
-        for( UINT 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( UINT Stream, __in_z LPCSTR pString )
-    {
-        HRESULT hr = S_OK;
-
-        m_pError[0] = 0;
-
-        if( pString == NULL )
-            return S_OK;
-
-        UINT len = (UINT)strlen( pString );
-        if( len == 0 )
-            return S_OK;
-
-        SAFE_DELETE_ARRAY( m_SemanticString[Stream] );
-        VN( m_SemanticString[Stream] = NEW char[len + 1] );
-        StringCchCopyA( 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 != NULL )
-            {
-                *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 == NULL )
-                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;
-
-        D3DXASSERT( 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;
-
-        D3DXASSERT( pSemantic );
-
-        pSemantic = strchr( pSemantic, '.' ); 
-
-        if( pSemantic == NULL )
-        {
-            m_newEntry.ComponentCount = 4;
-            return S_OK;
-        }
-
-        *pSemantic = '\0';
-        pSemantic++;
-
-        stringLength = strlen( pSemantic );
-        p = strstr(pFullMask1, pSemantic );
-        if( p )
-        {
-            startComponent = (UINT)( p - pFullMask1 );
-        }
-        else
-        {
-            p = strstr( pFullMask2, pSemantic );
-            if( p )
-                startComponent = (UINT)( p - pFullMask2 );
-            else
-            {
-                StringCchPrintfA( m_pError, MAX_ERROR_SIZE, "ID3D11Effect::ParseSODecl - invalid mask declaration '%s'", pSemantic );
-                VH( E_FAIL );
-            }
-
-        }
-
-        if( stringLength == 0 )
-            stringLength = 4;
-
-        m_newEntry.StartComponent = (BYTE)startComponent;
-        m_newEntry.ComponentCount = (BYTE)stringLength;
-
-lExit:
-        return hr;
-    }
-
-    // Parse optional output slot "[<slot> :]"
-    HRESULT ConsumeOutputSlot( __deref_inout_z LPSTR* ppSemantic )
-    {
-        D3DXASSERT( ppSemantic && *ppSemantic );
-
-        HRESULT hr = S_OK;
-        LPSTR pColon = strchr( *ppSemantic, ':' ); 
-
-        if( pColon == NULL )
-            return S_OK;
-
-        if( pColon == *ppSemantic )
-        {
-            StringCchCopyA( m_pError, MAX_ERROR_SIZE,
-                           "ID3D11Effect::ParseSODecl - Invalid output slot" );
-            VH( E_FAIL );
-        }
-
-        *pColon = '\0';
-        int outputSlot = atoi( *ppSemantic );
-        if( outputSlot < 0 || outputSlot > 255 )
-        {
-            StringCchCopyA( m_pError, MAX_ERROR_SIZE,
-                           "ID3D11Effect::ParseSODecl - Invalid output slot" );
-            VH( E_FAIL );
-        }
-        m_newEntry.OutputSlot = (BYTE)outputSlot;
-
-        while( *ppSemantic < pColon )
-        {
-            if( !isdigit( (unsigned char)**ppSemantic ) )
-            {
-                StringCchPrintfA( 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 )
-    {
-        D3DXASSERT( pSemantic );
-
-        UINT uLen = (UINT)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
diff --git a/sample/d3d11/Effects11/Effect.h b/sample/d3d11/Effects11/Effect.h
deleted file mode 100644
index ec0dafa..0000000
--- a/sample/d3d11/Effects11/Effect.h
+++ /dev/null
@@ -1,1226 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       Effect.h
-//  Content:    D3DX11 Effects Header for ID3DX11Effect Implementation
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "EffectBinaryFormat.h"
-
-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;
-    BYTE                    *pNumeric; 
-    float                   *pNumericFloat;
-    UINT                    *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 = (UINT) -1;
-    static const UINT c_ScalarSize = sizeof(UINT);
-
-    // packing rule constants
-    static const UINT c_ScalarsPerRegister = 4;
-    static const UINT c_RegisterSize = c_ScalarsPerRegister * c_ScalarSize; // must be a power of 2!!    
-    
-    EVarType    VarType;        // numeric, object, struct
-    UINT        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
-
-    UINT        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).
-
-    UINT        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.    
-
-    UINT        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
-            UINT        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(NULL),
-       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);
-    }
-
-    UINT GetTotalUnpackedSize(BOOL IsSingleElement) const; 
-    UINT GetTotalPackedSize(BOOL IsSingleElement) const; 
-    HRESULT GetDescHelper(D3DX11_EFFECT_TYPE_DESC *pDesc, BOOL IsSingleElement) const;
-
-    STDMETHOD_(BOOL, IsValid)() { return TRUE; }
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return GetDescHelper(pDesc, FALSE); }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);
-    STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);
-};
-
-// 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)() { return TRUE; }
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return ((SType*)pType)->GetDescHelper(pDesc, TRUE); }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index) { return ((SType*)pType)->GetMemberTypeByIndex(Index); }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name) { return ((SType*)pType)->GetMemberTypeByName(Name); }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic) { return ((SType*)pType)->GetMemberTypeBySemantic(Semantic); }
-    STDMETHOD_(LPCSTR, GetMemberName)(UINT Index) { return ((SType*)pType)->GetMemberName(Index); }
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index) { return ((SType*)pType)->GetMemberSemantic(Index); }
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Block definitions
-//////////////////////////////////////////////////////////////////////////
-
-void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, UINT Index);
-
-struct SBaseBlock
-{
-    EBlockType      BlockType;
-
-    BOOL            IsUserManaged:1;
-
-    UINT            AssignmentCount;
-    SAssignment     *pAssignments;
-
-    SBaseBlock();
-
-    BOOL ApplyAssignments(CEffect *pEffect);
-
-    D3DX11INLINE SSamplerBlock *AsSampler() const
-    {
-        D3DXASSERT( BlockType == EBT_Sampler );
-        return (SSamplerBlock*) this;
-    }
-
-    D3DX11INLINE SDepthStencilBlock *AsDepthStencil() const
-    {
-        D3DXASSERT( BlockType == EBT_DepthStencil );
-        return (SDepthStencilBlock*) this;
-    }
-
-    D3DX11INLINE SBlendBlock *AsBlend() const
-    {
-        D3DXASSERT( BlockType == EBT_Blend );
-        return (SBlendBlock*) this;
-    }
-
-    D3DX11INLINE SRasterizerBlock *AsRasterizer() const
-    {
-        D3DXASSERT( BlockType == EBT_Rasterizer );
-        return (SRasterizerBlock*) this;
-    }
-
-    D3DX11INLINE SPassBlock *AsPass() const
-    {
-        D3DXASSERT( BlockType == EBT_Pass );
-        return (SPassBlock*) this;
-    }
-};
-
-struct STechnique : public ID3DX11EffectTechnique
-{
-    char        *pName;
-
-    UINT        PassCount;
-    SPassBlock  *pPasses;
-
-    UINT        AnnotationCount;
-    SAnnotation *pAnnotations;
-
-    BOOL        InitiallyValid;
-    BOOL        HasDependencies;
-
-    STechnique();
-
-    STDMETHOD_(BOOL, IsValid)();
-    STDMETHOD(GetDesc)(D3DX11_TECHNIQUE_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(LPCSTR Name);
-
-    STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);
-};
-
-struct SGroup : public ID3DX11EffectGroup
-{
-    char        *pName;
-
-    UINT        TechniqueCount;
-    STechnique  *pTechniques;
-
-    UINT        AnnotationCount;
-    SAnnotation *pAnnotations;
-
-    BOOL        InitiallyValid;
-    BOOL        HasDependencies;
-
-    SGroup();
-
-    STDMETHOD_(BOOL, IsValid)();
-    STDMETHOD(GetDesc)(D3DX11_GROUP_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name);
-};
-
-struct SPassBlock : SBaseBlock, public ID3DX11EffectPass
-{
-    struct
-    {
-        ID3D11BlendState*       pBlendState;
-        FLOAT                   BlendFactor[4];
-        UINT                    SampleMask;
-        ID3D11DepthStencilState *pDepthStencilState;
-        UINT                    StencilRef;
-        union
-        {
-            D3D11_SO_DECLARATION_ENTRY  *pEntry;
-            char                        *pEntryDesc;
-        }                       GSSODesc;
-
-        // Pass assignments can write directly into these
-        SBlendBlock             *pBlendBlock;
-        SDepthStencilBlock      *pDepthStencilBlock;
-        SRasterizerBlock        *pRasterizerBlock;
-        UINT                    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;
-
-    UINT        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( SShaderBlock* pBlock );
-    BOOL CheckDependencies();
-
-    template<EObjectType EShaderType>
-    HRESULT GetShaderDescHelper(D3DX11_PASS_SHADER_DESC *pDesc);
-
-    STDMETHOD_(BOOL, IsValid)();
-    STDMETHOD(GetDesc)(D3DX11_PASS_DESC *pDesc);
-
-    STDMETHOD(GetVertexShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-    STDMETHOD(GetGeometryShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-    STDMETHOD(GetPixelShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-    STDMETHOD(GetHullShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-    STDMETHOD(GetDomainShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-    STDMETHOD(GetComputeShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);
-
-    STDMETHOD(Apply)(UINT Flags, ID3D11DeviceContext* pContext);
-    
-    STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);
-};
-
-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 = NULL;
-    }
-};
-
-struct SShaderResource
-{
-    ID3D11ShaderResourceView *pShaderResource;
-
-    SShaderResource() 
-    {
-        pShaderResource = NULL;
-    }
-
-};
-
-struct SUnorderedAccessView
-{
-    ID3D11UnorderedAccessView *pUnorderedAccessView;
-
-    SUnorderedAccessView() 
-    {
-        pUnorderedAccessView = NULL;
-    }
-
-};
-
-struct SRenderTargetView
-{
-    ID3D11RenderTargetView *pRenderTargetView;
-
-    SRenderTargetView();
-};
-
-struct SDepthStencilView
-{
-    ID3D11DepthStencilView *pDepthStencilView;
-
-    SDepthStencilView();
-};
-
-
-template<class T, class D3DTYPE> struct SShaderDependency
-{
-    UINT    StartIndex;
-    UINT    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 = NULL;
-        ppFXPointers = NULL;
-    }
-};
-
-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 three D3DShaderVTables, one for PS, one for VS, and one for GS.
-struct SD3DShaderVTable
-{
-    void ( __stdcall ID3D11DeviceContext::*pSetShader)(ID3D11DeviceChild* pShader, ID3D11ClassInstance*const* ppClassInstances, UINT NumClassInstances);
-    void ( __stdcall ID3D11DeviceContext::*pSetConstantBuffers)(UINT StartConstantSlot, UINT NumBuffers, ID3D11Buffer *const *pBuffers);
-    void ( __stdcall ID3D11DeviceContext::*pSetSamplers)(UINT Offset, UINT NumSamplers, ID3D11SamplerState*const* pSamplers);
-    void ( __stdcall ID3D11DeviceContext::*pSetShaderResources)(UINT Offset, UINT 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;
-        UINT                        Index;
-    };
-
-    // this data is classified as reflection-only and will all be discarded at runtime
-    struct SReflectionData
-    {
-        BYTE                        *pBytecode;
-        UINT                        BytecodeLength;
-        char                        *pStreamOutDecls[4];        // set with ConstructGSWithSO
-        UINT                        RasterizedStream;           // set with ConstructGSWithSO
-        BOOL                        IsNullGS;
-        ID3D11ShaderReflection      *pReflection;
-        UINT                        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 NULL if the shader is NULL or was never initialized
-    SReflectionData                 *pReflectionData;
-
-    ID3D11DeviceChild               *pD3DObject;
-
-    UINT                            CBDepCount;
-    SShaderCBDependency             *pCBDeps;
-
-    UINT                            SampDepCount;
-    SShaderSamplerDependency        *pSampDeps;
-
-    UINT                            InterfaceDepCount;
-    SInterfaceDependency            *pInterfaceDeps;
-
-    UINT                            ResourceDepCount;
-    SShaderResourceDependency       *pResourceDeps;
-
-    UINT                            UAVDepCount;
-    SUnorderedAccessViewDependency  *pUAVDeps;
-
-    UINT                            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 = NULL);
-
-    EObjectType GetShaderType();
-
-    HRESULT OnDeviceBind();
-
-    // Public API helpers
-    HRESULT ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);
-
-    HRESULT GetShaderDesc(D3DX11_EFFECT_SHADER_DESC *pDesc, BOOL IsInline);
-
-    HRESULT GetVertexShader(ID3D11VertexShader **ppVS);
-    HRESULT GetGeometryShader(ID3D11GeometryShader **ppGS);
-    HRESULT GetPixelShader(ID3D11PixelShader **ppPS);
-    HRESULT GetHullShader(ID3D11HullShader **ppPS);
-    HRESULT GetDomainShader(ID3D11DomainShader **ppPS);
-    HRESULT GetComputeShader(ID3D11ComputeShader **ppPS);
-
-    HRESULT GetSignatureElementDesc(ESigType SigType, UINT Element, 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
-    {
-        UINT                MemberDataOffsetPlus4;  // 4 added so that 0 == NULL can represent "unused"
-        SMemberDataPointer  *pMemberData;
-    };
-
-    SType                   *pType;
-    char                    *pName;
-    char                    *pSemantic;
-    UINT                    ExplicitBindPoint;
-
-    SVariable()
-    {
-        ZeroMemory(this, sizeof(*this));
-        ExplicitBindPoint = -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(SShaderBlock *pBlock = NULL);
-
-    // ID3DX11EffectShaderVariable interface
-    STDMETHOD_(BOOL, IsValid)();
-    STDMETHOD_(ID3DX11EffectType*, GetType)();
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index);
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)();
-
-    // other casts are handled by TUncastableVariable
-    STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)();
-
-    STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count);
-    STDMETHOD(GetRawValue)(__out_bcount(Count) void *pData, UINT Offset, UINT Count);
-
-    STDMETHOD(GetShaderDesc)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc);
-
-    STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS);
-    STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS);
-    STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS);
-    STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS);
-    STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS);
-    STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS);
-
-    STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-    STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-    STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-
-    // ID3DX11EffectType interface
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);
-
-    STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectConstantBuffer (SConstantBuffer implementation)
-////////////////////////////////////////////////////////////////////////////////
-
-struct SConstantBuffer : public TUncastableVariable<ID3DX11EffectConstantBuffer>, public ID3DX11EffectType
-{
-    ID3D11Buffer            *pD3DObject;
-    SShaderResource         TBuffer;            // NULL iff IsTbuffer == FALSE
-
-    BYTE                    *pBackingStore;
-    UINT                    Size;               // in bytes
-
-    char                    *pName;
-
-    UINT                    AnnotationCount;
-    SAnnotation             *pAnnotations;
-
-    UINT                    VariableCount;      // # of variables contained in this cbuffer
-    SGlobalVariable         *pVariables;        // array of size [VariableCount], points into effect's contiguous variable list
-    UINT                    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 != NULL
-    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
-        UINT                MemberDataOffsetPlus4;  // 4 added so that 0 == NULL can represent "unused"
-        SMemberDataPointer  *pMemberData;
-    };
-
-    CEffect                 *pEffect;
-
-    SConstantBuffer()
-    {
-        pD3DObject = NULL;
-        ZeroMemory(&TBuffer, sizeof(TBuffer));
-        ExplicitBindPoint = -1;
-        pBackingStore = NULL;
-        Size = 0;
-        pName = NULL;
-        VariableCount = 0;
-        pVariables = NULL;
-        AnnotationCount = 0;
-        pAnnotations = NULL;
-        IsDirty = FALSE;
-        IsTBuffer = FALSE;
-        IsUserManaged = FALSE;
-        IsEffectOptimized = FALSE;
-        IsUsedByExpression = FALSE;
-        IsUserPacked = FALSE;
-        IsSingle = FALSE;
-        IsNonUpdatable = FALSE;
-        pEffect = NULL;
-    }
-
-    bool ClonedSingle() const;
-
-    // ID3DX11EffectConstantBuffer interface
-    STDMETHOD_(BOOL, IsValid)();
-    STDMETHOD_(ID3DX11EffectType*, GetType)();
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index);
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)();
-
-    // other casts are handled by TUncastableVariable
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)();
-
-    STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count);
-    STDMETHOD(GetRawValue)(__out_bcount(Count) void *pData, UINT Offset, UINT Count);
-
-    STDMETHOD(SetConstantBuffer)(ID3D11Buffer *pConstantBuffer);
-    STDMETHOD(GetConstantBuffer)(ID3D11Buffer **ppConstantBuffer);
-    STDMETHOD(UndoSetConstantBuffer)();
-
-    STDMETHOD(SetTextureBuffer)(ID3D11ShaderResourceView *pTextureBuffer);
-    STDMETHOD(GetTextureBuffer)(ID3D11ShaderResourceView **ppTextureBuffer);
-    STDMETHOD(UndoSetTextureBuffer)();
-
-    // ID3DX11EffectType interface
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);
-
-    STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);
-};
-
-
-//////////////////////////////////////////////////////////////////////////
-// 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 = NULL;
-        }
-    };
-
-    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
-    UINT                    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
-
-    UINT                    DataSize : 16;      // Size of the data element to be copied in bytes (if numeric) or
-                                                // stride of the block type (if object)
-    UINT                    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 = NULL;
-        Source.pGeneric = NULL;
-
-        LastRecomputedTime = 0;
-        DependencyCount = 0;
-        pDependencies = NULL;
-
-        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);
-    }
-
-    UINT Hash()
-    {
-        // hash the pointer itself 
-        // (using the pointer as a hash would be very bad)
-        return ComputeHash((BYTE*)&pOld, sizeof(pOld));
-    }
-};
-
-typedef CEffectHashTableWithPrivateHeap<SPointerMapping, SPointerMapping::AreMappingsEqual> CPointerMappingTable;
-
-// Assist adding data to a block of memory
-class CEffectHeap
-{
-protected:
-    BYTE    *m_pData;
-    UINT    m_dwBufferSize;
-    UINT    m_dwSize;
-
-    template <bool bCopyData>
-    HRESULT AddDataInternal(const void *pData, UINT dwSize, void **ppPointer);
-
-public:
-    HRESULT ReserveMemory(UINT dwSize);
-    UINT GetSize();
-    BYTE* 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(const char *pString, __deref_out_z char **ppPointer);
-    HRESULT AddData(const void *pData, UINT  dwSize, 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(UINT dwSize);
-
-    // Move data from the general heap and optional free memory
-    HRESULT MoveData(void **ppData, UINT size);
-    HRESULT MoveString(__deref_inout_z char **ppStringData);
-    HRESULT MoveInterfaceParameters(UINT InterfaceCount, __in_ecount(1) SShaderBlock::SInterfaceParameter **ppInterfaces);
-    HRESULT MoveEmptyDataBlock(void **ppData, UINT size);
-
-    BOOL IsInHeap(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:
-
-    UINT                    m_RefCount;
-    UINT                    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)
-    UINT                    m_VariableCount;
-    SGlobalVariable         *m_pVariables;
-
-    // anonymous shader variables (one for every inline shader assignment)
-    UINT                    m_AnonymousShaderCount;
-    SAnonymousShader        *m_pAnonymousShaders;
-
-    // techniques within this effect (the actual data is located in each group)
-    UINT                    m_TechniqueCount;
-
-    // groups within this effect
-    UINT                    m_GroupCount;
-    SGroup                  *m_pGroups;
-    SGroup                  *m_pNullGroup;
-
-    UINT                    m_ShaderBlockCount;
-    SShaderBlock            *m_pShaderBlocks;
-
-    UINT                    m_DepthStencilBlockCount;
-    SDepthStencilBlock      *m_pDepthStencilBlocks;
-
-    UINT                    m_BlendBlockCount;
-    SBlendBlock             *m_pBlendBlocks;
-
-    UINT                    m_RasterizerBlockCount;
-    SRasterizerBlock        *m_pRasterizerBlocks;
-
-    UINT                    m_SamplerBlockCount;
-    SSamplerBlock           *m_pSamplerBlocks;
-
-    UINT                    m_MemberDataCount;
-    SMemberDataPointer      *m_pMemberDataBlocks;
-
-    UINT                    m_InterfaceCount;
-    SInterface              *m_pInterfaces;
-
-    UINT                    m_CBCount;
-    SConstantBuffer         *m_pCBs;
-
-    UINT                    m_StringCount;
-    SString                 *m_pStrings;
-
-    UINT                    m_ShaderResourceCount;
-    SShaderResource         *m_pShaderResources;
-
-    UINT                    m_UnorderedAccessViewCount;
-    SUnorderedAccessView    *m_pUnorderedAccessViews;
-
-    UINT                    m_RenderTargetViewCount;
-    SRenderTargetView       *m_pRenderTargetViews;
-
-    UINT                    m_DepthStencilViewCount;
-    SDepthStencilView       *m_pDepthStencilViews; 
-
-    Timer                   m_LocalTimer;
-    
-    // temporary index variable for assignment evaluation
-    UINT                    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(__in const LPCSTR &pStr1, __in 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(CPointerMappingTable *pMappingTable, bool Cloning = false);
-
-
-    //////////////////////////////////////////////////////////////////////////    
-    // Runtime (performance critical)
-    
-    void ApplyShaderBlock(SShaderBlock *pBlock);
-    BOOL ApplyRenderStateBlock(SBaseBlock *pBlock);
-    BOOL ApplySamplerBlock(SSamplerBlock *pBlock);
-    void ApplyPassBlock(SPassBlock *pBlock);
-    BOOL EvaluateAssignment(SAssignment *pAssignment);
-    BOOL ValidateShaderBlock( SShaderBlock* pBlock );
-    BOOL ValidatePassBlock( SPassBlock* pBlock );
-    
-    //////////////////////////////////////////////////////////////////////////    
-    // Non-runtime functions (not performance critical)    
-
-    SGlobalVariable *FindLocalVariableByName(LPCSTR pVarName);      // Looks in the current effect only
-    SGlobalVariable *FindVariableByName(LPCSTR pVarName);
-    SVariable *FindVariableByNameWithParsing(LPCSTR pVarName);
-    SConstantBuffer *FindCB(LPCSTR pName);
-    void ReplaceCBReference(SConstantBuffer *pOldBufferBlock, ID3D11Buffer *pNewBuffer);            // Used by user-managed CBs
-    void ReplaceSamplerReference(SSamplerBlock *pOldSamplerBlock, ID3D11SamplerState *pNewSampler);
-    void AddRefAllForCloning( CEffect* pEffectSource );
-    HRESULT CopyMemberInterfaces( CEffect* pEffectSource );
-    HRESULT CopyStringPool( CEffect* pEffectSource, CPointerMappingTable& mappingTable );
-    HRESULT CopyTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes, CPointerMappingTable& mappingTableStrings );
-    HRESULT CopyOptimizedTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes );
-    HRESULT RecreateCBs();
-    HRESULT FixupMemberInterface( SMember* pMember, CEffect* pEffectSource, CPointerMappingTable& mappingTableStrings );
-
-    void ValidateIndex(UINT Elements);
-
-    void IncrementTimer();    
-    void HandleLocalTimerRollover();
-
-    friend struct SConstantBuffer;
-
-public:
-    CEffect( UINT Flags = 0 );
-    virtual ~CEffect();
-    void ReleaseShaderRefection();
-
-    // Initialize must be called after the effect is created
-    HRESULT LoadEffect(CONST void *pEffectBuffer, UINT cbEffectBuffer);
-
-    // Once the effect is fully loaded, call BindToDevice to attach it to a device
-    HRESULT BindToDevice(ID3D11Device *pDevice);
-
-    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, LPVOID *ppv);
-    STDMETHOD_(ULONG, AddRef)();
-    STDMETHOD_(ULONG, Release)();
-
-    STDMETHOD_(BOOL, IsValid)() { return TRUE; }
-
-    STDMETHOD(GetDevice)(ID3D11Device** ppDevice);    
-
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_DESC *pDesc);
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableByName)(LPCSTR Name);
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableBySemantic)(LPCSTR Semantic);
-
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3DX11EffectGroup*, GetGroupByIndex)(UINT Index);
-    STDMETHOD_(ID3DX11EffectGroup*, GetGroupByName)(LPCSTR Name);
-
-    STDMETHOD_(ID3D11ClassLinkage*, GetClassLinkage)();
-
-    STDMETHOD(CloneEffect)(UINT Flags, ID3DX11Effect** ppClonedEffect);
-    STDMETHOD(Optimize)();
-    STDMETHOD_(BOOL, IsOptimized)();
-
-    //////////////////////////////////////////////////////////////////////////    
-    // New reflection helpers
-
-    ID3DX11EffectType * CreatePooledSingleElementTypeInterface(SType *pType);
-    ID3DX11EffectVariable * CreatePooledVariableMemberInterface(TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity, SVariable *pMember, UDataPointer Data, BOOL IsSingleElement, UINT Index);
-
-};
-
-}
diff --git a/sample/d3d11/Effects11/EffectAPI.cpp b/sample/d3d11/Effects11/EffectAPI.cpp
deleted file mode 100644
index e373e51..0000000
--- a/sample/d3d11/Effects11/EffectAPI.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectAPI.cpp
-//  Content:    D3DX11 Effect DLL entry points
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-
-using namespace D3DX11Effects;
-
-HRESULT WINAPI D3DX11CreateEffectFromMemory(CONST void *pData, SIZE_T DataLength, UINT FXFlags, ID3D11Device *pDevice, ID3DX11Effect **ppEffect)
-{
-    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<UINT>(DataLength)) );
-    VH( ((CEffect*)(*ppEffect))->BindToDevice(pDevice) );
-
-lExit:
-    if (FAILED(hr))
-    {
-        SAFE_RELEASE(*ppEffect);
-    }
-    return hr;
-}
diff --git a/sample/d3d11/Effects11/EffectLoad.cpp b/sample/d3d11/Effects11/EffectLoad.cpp
deleted file mode 100644
index 0e1cf32..0000000
--- a/sample/d3d11/Effects11/EffectLoad.cpp
+++ /dev/null
@@ -1,3982 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectLoad.cpp
-//  Content:    D3DX11 Effects file loading code
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-
-#include <EffectStates11.h>
-
-#define PRIVATENEW new(m_BulkHeap)
-
-namespace D3DX11Effects
-{
-
-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*, UINT)) &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*, UINT)) &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*, UINT)) &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*, UINT)) &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*, UINT)) &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*, UINT)) &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);
-
-D3D10_SHADER_VARIABLE_TYPE GetSimpleParameterTypeFromObjectType(EObjectType ObjectType)
-{
-    switch (ObjectType)
-    {
-    case EOT_String:
-        return D3D10_SVT_STRING;
-    case EOT_Blend:
-        return D3D10_SVT_BLEND;        
-    case EOT_DepthStencil:
-        return D3D10_SVT_DEPTHSTENCIL;        
-    case EOT_Rasterizer:
-        return D3D10_SVT_RASTERIZER;        
-    case EOT_PixelShader:
-    case EOT_PixelShader5:
-        return D3D10_SVT_PIXELSHADER;        
-    case EOT_VertexShader:
-    case EOT_VertexShader5:
-        return D3D10_SVT_VERTEXSHADER;        
-    case EOT_GeometryShader:
-    case EOT_GeometryShaderSO:
-    case EOT_GeometryShader5:
-        return D3D10_SVT_GEOMETRYSHADER;    
-    case EOT_HullShader5:
-        return D3D11_SVT_HULLSHADER;        
-    case EOT_DomainShader5:
-        return D3D11_SVT_DOMAINSHADER;        
-    case EOT_ComputeShader5:
-        return D3D11_SVT_COMPUTESHADER;        
-    case EOT_RenderTargetView:
-        return D3D10_SVT_RENDERTARGETVIEW;
-    case EOT_DepthStencilView:
-        return D3D10_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 D3D10_SVT_TEXTURE;
-    case EOT_Buffer:
-        return D3D10_SVT_BUFFER;        
-    case EOT_Sampler:
-        return D3D10_SVT_SAMPLER;
-    case EOT_ByteAddressBuffer:
-        return D3D11_SVT_BYTEADDRESS_BUFFER;
-    case EOT_StructuredBuffer:
-        return D3D11_SVT_STRUCTURED_BUFFER;
-    case EOT_RWTexture1D:
-        return D3D11_SVT_RWTEXTURE1D;
-    case EOT_RWTexture1DArray:
-        return D3D11_SVT_RWTEXTURE1DARRAY;
-    case EOT_RWTexture2D:
-        return D3D11_SVT_RWTEXTURE2D;
-    case EOT_RWTexture2DArray:
-        return D3D11_SVT_RWTEXTURE2DARRAY;
-    case EOT_RWTexture3D:
-        return D3D11_SVT_RWTEXTURE3D;
-    case EOT_RWBuffer:
-        return D3D11_SVT_RWBUFFER;
-    case EOT_RWByteAddressBuffer:
-        return D3D11_SVT_RWBYTEADDRESS_BUFFER;
-    case EOT_RWStructuredBuffer:
-    case EOT_RWStructuredBufferAlloc:
-    case EOT_RWStructuredBufferConsume:
-        return D3D11_SVT_RWSTRUCTURED_BUFFER;
-    case EOT_AppendStructuredBuffer:
-        return D3D11_SVT_APPEND_STRUCTURED_BUFFER;
-    case EOT_ConsumeStructuredBuffer:
-        return D3D11_SVT_CONSUME_STRUCTURED_BUFFER;
-    default:
-        D3DXASSERT(0);
-    }
-    return D3D10_SVT_VOID;
-}
-
-inline HRESULT VerifyPointer(UINT  oBase, UINT  dwSize, UINT  dwMaxSize)
-{
-    UINT  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 = NULL;
-    m_dwSize = m_dwBufferSize = 0;
-}
-
-CEffectHeap::~CEffectHeap()
-{
-    SAFE_DELETE_ARRAY(m_pData);
-}
-
-UINT  CEffectHeap::GetSize()
-{
-    return m_dwSize;
-}
-
-HRESULT CEffectHeap::ReserveMemory(UINT  dwSize)
-{
-    HRESULT hr = S_OK;
-
-    D3DXASSERT(!m_pData);
-    D3DXASSERT(dwSize == AlignToPowerOf2(dwSize, c_DataAlignment));
-
-    m_dwBufferSize = dwSize;
-
-    VN( m_pData = NEW BYTE[m_dwBufferSize] );
-    
-    // make sure that we have machine word alignment
-    D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
-
-lExit:
-    return hr;
-}
-
-HRESULT CEffectHeap::AddString(const char *pString, __deref_out_z char **ppPointer)
-{
-    size_t size = strlen(pString) + 1;
-    D3DXASSERT( size <= 0xffffffff );
-    return AddData(pString, (UINT)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(const void *pData, UINT  dwSize, void **ppPointer)
-{
-    CCheckedDword chkFinalSize( m_dwSize );
-    UINT  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;
-    D3DXASSERT(*ppPointer == AlignToPowerOf2(*ppPointer, c_DataAlignment));
-
-    if( bCopyData )
-    {
-        memcpy(*ppPointer, pData, dwSize);
-    }
-    m_dwSize = finalSize;
-
-lExit:
-    if (FAILED(hr))
-        *ppPointer = NULL;
-
-    return hr;
-}
-
-HRESULT CEffectHeap::AddData(const void *pData, UINT  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
-HRESULT CEffectHeap::MoveString(__deref_inout_z char **ppString)
-{
-    HRESULT hr;
-    char *pNewPointer;
-
-    if (*ppString == NULL)
-        return S_OK;
-
-    hr = AddString(*ppString, &pNewPointer);
-    *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
-HRESULT CEffectHeap::MoveEmptyDataBlock(void **ppData, UINT  size)
-{
-    HRESULT hr;
-    void *pNewPointer;
-
-    hr = AddDataInternal<false>(*ppData, size, &pNewPointer);
-
-    *ppData = pNewPointer;
-    if (size == 0)
-    {
-        // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this
-        *ppData = NULL;
-    }
-
-    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
-HRESULT CEffectHeap::MoveInterfaceParameters(UINT InterfaceCount, __in_ecount(1) SShaderBlock::SInterfaceParameter **ppInterfaces)
-{
-    HRESULT hr;
-    SShaderBlock::SInterfaceParameter *pNewPointer;
-
-    if (*ppInterfaces == NULL)
-        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( UINT 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
-HRESULT CEffectHeap::MoveData(void **ppData, UINT  size)
-{
-    HRESULT hr;
-    void *pNewPointer;
-
-    hr = AddData(*ppData, size, &pNewPointer);
-    
-    *ppData = pNewPointer;
-    if (size == 0)
-    {
-        // To help catch bugs, set zero-byte blocks to null. There's no real reason to do this
-        *ppData = NULL;
-    }
-
-    return hr;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-// Load API 
-//////////////////////////////////////////////////////////////////////////
-
-HRESULT CEffect::LoadEffect(CONST void *pEffectBuffer, UINT  cbEffectBuffer)
-{
-    HRESULT hr = S_OK;
-    CEffectLoader loader;
-
-    if (!pEffectBuffer)
-    {
-        DPF(0, "%s: pEffectBuffer is NULL.", 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
-//////////////////////////////////////////////////////////////////////////
-
-HRESULT CEffectLoader::GetUnstructuredDataBlock(UINT offset, UINT  *pdwSize, void **ppData)
-{
-    HRESULT hr = S_OK;
-    UINT  *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.
-HRESULT CEffectLoader::GetStringAndAddToReflection(UINT offset, __out_ecount_full(1) char **ppString)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pName;
-    SIZE_T oldPos;
-    
-    if (offset == 0)
-    {
-        *ppString = NULL;
-        goto lExit;
-    }
-
-    oldPos = m_msUnstructured.GetPosition();
-
-    VH( m_msUnstructured.ReadAtOffset(offset, &pName) );
-    m_ReflectionMemory += AlignToPowerOf2( (UINT)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.
-HRESULT CEffectLoader::GetInterfaceParametersAndAddToReflection( UINT InterfaceCount, UINT offset, __out_ecount_full(1) SShaderBlock::SInterfaceParameter **ppInterfaces )
-{
-    HRESULT hr = S_OK;
-    SBinaryInterfaceInitializer* pInterfaceInitializer;
-    SIZE_T oldPos;
-
-    if (offset == 0)
-    {
-        *ppInterfaces = NULL;
-        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);
-    D3DXASSERT( ppInterfaces );
-    (*ppInterfaces) = PRIVATENEW SShaderBlock::SInterfaceParameter[InterfaceCount];
-    VN( *ppInterfaces );
-
-    VHD( m_msUnstructured.ReadAtOffset(offset, sizeof(SBinaryInterfaceInitializer) * InterfaceCount, (void**)&pInterfaceInitializer),
-         "Invalid pEffectBuffer: cannot read interface initializer." );
-
-    for( UINT 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( (UINT)strlen((*ppInterfaces)[i].pName) + 1, c_DataAlignment);
-    }
-
-    m_msUnstructured.Seek(oldPos);
-
-lExit:
-    return hr;
-}
-
-HRESULT CEffectLoader::FixupCBPointer(SConstantBuffer **ppCB)
-{
-    HRESULT hr = S_OK;
-    
-    SIZE_T index = (SConstantBuffer*)*ppCB - m_pOldCBs;
-    D3DXASSERT( 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(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 != NULL)
-    {
-        SIZE_T index = *ppShaderBlock - m_pOldShaders;
-        D3DXASSERT( 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(SDepthStencilBlock **ppDSBlock)
-{
-    HRESULT hr = S_OK;
-    if (*ppDSBlock != &g_NullDepthStencil && *ppDSBlock != NULL)
-    {
-        SIZE_T index = *ppDSBlock - m_pOldDS;
-        D3DXASSERT( 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(SBlendBlock **ppABBlock)
-{
-    HRESULT hr = S_OK;
-    if (*ppABBlock != &g_NullBlend && *ppABBlock != NULL)
-    {
-        SIZE_T index = *ppABBlock - m_pOldAB;
-        D3DXASSERT( 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(SRasterizerBlock **ppRSBlock)
-{
-    HRESULT hr = S_OK;
-    if (*ppRSBlock != &g_NullRasterizer && *ppRSBlock != NULL)
-    {
-        SIZE_T index = *ppRSBlock - m_pOldRS;
-        D3DXASSERT( 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(SSamplerBlock **ppSampler)
-{
-    HRESULT hr = S_OK;
-    SIZE_T index = *ppSampler - m_pOldSamplers;
-    D3DXASSERT( 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(SInterface **ppInterface, bool CheckBackgroundInterfaces)
-{
-    HRESULT hr = S_OK;
-    if (*ppInterface != &g_NullInterface && *ppInterface != NULL)
-    {
-        SIZE_T index = *ppInterface - m_pOldInterfaces;
-        if(index < m_OldInterfaceCount)
-        {
-            D3DXASSERT( 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[ (UINT)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(SShaderResource **ppResource)
-{
-    HRESULT hr = S_OK;
-    if (*ppResource != &g_NullTexture && *ppResource != NULL)
-    {
-        SIZE_T index = *ppResource - m_pOldShaderResources;
-        D3DXASSERT( 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;
-            D3DXASSERT( 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(SUnorderedAccessView **ppUnorderedAccessView)
-{
-    HRESULT hr = S_OK;
-    if (*ppUnorderedAccessView != &g_NullUnorderedAccessView && *ppUnorderedAccessView != NULL)
-    {
-        SIZE_T index = *ppUnorderedAccessView - m_pOldUnorderedAccessViews;
-        D3DXASSERT( 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(SRenderTargetView **ppRenderTargetView)
-{
-    HRESULT hr = S_OK;
-    if (*ppRenderTargetView != &g_NullRenderTargetView && *ppRenderTargetView != NULL)
-    {
-        SIZE_T index = *ppRenderTargetView - m_pOldRenderTargetViews;
-        D3DXASSERT( 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(SDepthStencilView **ppDepthStencilView)
-{
-    HRESULT hr = S_OK;
-    if (*ppDepthStencilView != &g_NullDepthStencilView && *ppDepthStencilView != NULL)
-    {
-        SIZE_T index = *ppDepthStencilView - m_pOldDepthStencilViews;
-        D3DXASSERT( 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(SString **ppString)
-{
-    HRESULT hr = S_OK;
-    SIZE_T index = *ppString - m_pOldStrings;
-    D3DXASSERT( 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(SMemberDataPointer **ppMemberData)
-{
-    HRESULT hr = S_OK;
-    SIZE_T index = *ppMemberData - m_pOldMemberDataBlocks;
-    D3DXASSERT( 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(SGlobalVariable **ppVar)
-{
-    HRESULT hr = S_OK;
-    SIZE_T index = *ppVar - m_pOldVars;
-
-    if( index < m_pEffect->m_VariableCount )
-    {
-        D3DXASSERT( 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-NULL, 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)[ (UINT)index] == (ID3DX11EffectVariable*)*ppVar )
-            {
-                break;
-            }
-        }
-        VBD( index < Members, "Internal loading error: invalid member pointer." );
-        *ppVar = (SGlobalVariable*)m_pEffect->m_pMemberInterfaces[ (UINT)index];
-    }
-lExit:
-    return hr;
-}
-
-HRESULT CEffectLoader::FixupGroupPointer(SGroup **ppGroup)
-{
-    HRESULT hr = S_OK;
-    if( *ppGroup != NULL )
-    {
-        SIZE_T index = *ppGroup - m_pOldGroups;
-        D3DXASSERT( 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;
-}
-
-HRESULT GetEffectVersion( UINT effectFileTag, DWORD* pVersion )
-{
-    D3DXASSERT( pVersion != NULL );
-    if( !pVersion )
-        return E_FAIL;
-
-    for( UINT i = 0; i < NUM_EFFECT10_VERSIONS; i++ )
-    {
-        if( g_EffectVersions[i].m_Tag == effectFileTag )
-        {
-            *pVersion = g_EffectVersions[i].m_Version;
-            return S_OK;
-        }
-    }
-
-    return E_FAIL;
-}
-
-HRESULT CEffectLoader::LoadEffect(CEffect *pEffect, CONST void *pEffectBuffer, UINT  cbEffectBuffer)
-{
-    HRESULT hr = S_OK;
-    UINT  i, varSize, cMemberDataBlocks;
-    CCheckedDword chkVariables = 0;
-
-    // Used for cloning
-    m_pvOldMemberInterfaces = NULL;
-
-    m_BulkHeap.EnableAlignment();
-
-    D3DXASSERT(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 = (BYTE*)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[NUM_EFFECT10_VERSIONS-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 BYTE[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] );
-
-    UINT 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( UINT iGroup=0; iGroup<m_pHeader->cGroups; iGroup++ )
-    {
-        SGroup *pGroup = &m_pEffect->m_pGroups[iGroup];
-        pGroup->HasDependencies = FALSE;
-
-        for( UINT iTechnique=0; iTechnique < pGroup->TechniqueCount; iTechnique++ )
-        {
-            STechnique* pTech = &pGroup->pTechniques[iTechnique];
-            pTech->HasDependencies = FALSE;
-
-            for( UINT 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
-HRESULT CEffectLoader::LoadStringAndAddToPool(__out_ecount_full(1) char **ppString, UINT  dwOffset)
-{
-    HRESULT hr = S_OK;
-    char *pName;
-    UINT  hash;
-    SIZE_T oldPos;
-    CEffect::CStringHashTable::CIterator iter;
-    UINT  len;
-
-    if (dwOffset == 0)
-    {
-        *ppString = NULL;
-        goto lExit;
-    }
-
-    oldPos = m_msUnstructured.GetPosition();
-
-    VHD( m_msUnstructured.ReadAtOffset(dwOffset, (LPCSTR *) &pName), "Invalid pEffectBuffer: cannot read string." );
-    len = (UINT)strlen(pName);
-    hash = ComputeHash((BYTE *)pName, len);
-    if (FAILED(m_pEffect->m_pStringPool->FindValueWithHash(pName, hash, &iter)))
-    {
-        D3DXASSERT( m_pEffect->m_pPooledHeap != NULL );
-        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;
-}
-
-HRESULT CEffectLoader::LoadTypeAndAddToPool(SType **ppType, UINT  dwOffset)
-{
-    HRESULT hr = S_OK;
-    SBinaryType *psType;
-    SBinaryNumericType *pNumericType;
-    EObjectType *pObjectType;
-    UINT  cMembers, iMember, cInterfaces;
-    UINT  oBaseClassType;
-    SType temporaryType;
-    CEffect::CTypeHashTable::CIterator iter;
-    BYTE *pHashBuffer;
-    UINT  hash;
-    SVariable *pTempMembers = NULL;
-    
-    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.
-    UINT  cElements = max(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(UINT)), "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 = NULL; 
-
-        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
-            UINT *poInterface;
-            VHD( m_msUnstructured.Read((void**) &poInterface, cInterfaces * sizeof(poInterface)), "Invalid pEffectBuffer: cannot read interface types." );
-        }
-
-        UINT  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:
-        D3DXASSERT(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)))
-    {
-        D3DXASSERT( m_pEffect->m_pPooledHeap != NULL );
-
-        // 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.
-UINT CEffectLoader::UnpackData(BYTE *pDestData, BYTE *pSrcData, UINT  PackedDataSize, SType *pType, UINT  *pBytesRead)
-{
-    UINT  bytesRead = 0;
-    UINT  i, j, k;
-    UINT  registers, entries;
-    HRESULT hr = S_OK;
-    UINT  elementsToCopy = max(pType->Elements, 1);
-
-    switch (pType->VarType)
-    {
-    case EVT_Struct:
-        for (i = 0; i < elementsToCopy; ++ i)
-        {
-            for (j = 0; j < pType->StructType.Members; ++ j)
-            {
-                UINT  br;
-                D3DXASSERT((UINT_PTR)pType->StructType.pMembers[j].pType == (UINT)(UINT_PTR)pType->StructType.pMembers[j].pType);
-                D3DXASSERT(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
-            D3DXASSERT(0);
-            VHD(E_FAIL, "Internal loading error: packed arrays are not supported." );
-        }
-        else
-        {
-            UINT  bytesToCopy;
-
-            if (pType->NumericType.IsColumnMajor)
-            {
-                registers = pType->NumericType.Columns;
-                entries = pType->NumericType.Rows;
-                bytesToCopy = entries * registers * SType::c_ScalarSize;
-
-                for (i = 0; i < elementsToCopy; ++ i)
-                {
-                    for (j = 0; j < registers; ++ j)
-                    {
-                        for (k = 0; k < entries; ++ k)
-                        {
-                            // type cast to an arbitrary scalar
-                            ((UINT*)pDestData)[k] = ((UINT*)pSrcData)[k * registers + j];
-                        }
-                        pDestData += SType::c_RegisterSize; // advance to next register
-                    }
-                    pSrcData += bytesToCopy;
-                    bytesRead += bytesToCopy;
-                }
-            }
-            else
-            {
-                registers = pType->NumericType.Rows;
-                entries = pType->NumericType.Columns;
-                bytesToCopy = entries * SType::c_ScalarSize;
-
-                for (i = 0; i < elementsToCopy; ++ i)
-                {
-                    for (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
-        D3DXASSERT(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(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 = -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 += max(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)
-    {
-        UINT  bytesUnpacked;
-        VHD( m_msUnstructured.ReadAtOffset(psVar->oDefaultValue, pType->PackedSize, &pDefaultValue), "Invalid pEffectBuffer: cannot read default value." );
-        VH( UnpackData((BYTE*) pVar->Data.pGeneric, (BYTE*) 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;
-    UINT  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 BYTE[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 = NULL;
-        }
-
-        // 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
-HRESULT CEffectLoader::ExecuteConstantAssignment(SBinaryConstant *pConstant, void *pLHS, D3D10_SHADER_VARIABLE_TYPE lhsType)
-{
-    HRESULT hr = S_OK;
-
-    switch(pConstant->Type)
-    {
-    case EST_UInt:
-    case EST_Int:
-    case EST_Bool:
-        switch(lhsType)
-        {
-        case D3D10_SVT_BOOL:
-        case D3D10_SVT_INT:
-        case D3D10_SVT_UINT:
-            *(UINT*) pLHS = pConstant->iValue;
-            break;
-
-        case D3D10_SVT_UINT8:
-            *(BYTE*) pLHS = (BYTE) pConstant->iValue;
-            break;
-
-        case D3D10_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 D3D10_SVT_BOOL:
-        case D3D10_SVT_INT:
-        case D3D10_SVT_UINT:
-            *(UINT*) pLHS = (UINT) pConstant->fValue;
-            break;
-
-        case D3D10_SVT_UINT8:
-            *(BYTE*) pLHS = (BYTE) pConstant->fValue;
-            break;
-
-        case D3D10_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
-HRESULT CEffectLoader::LoadAssignments( UINT Assignments, SAssignment **ppAssignments, BYTE *pBackingStore, UINT *pRTVAssignments, UINT *pFinalAssignments )
-{
-    HRESULT hr = S_OK;
-    UINT  i, j;
-
-    SBinaryAssignment *psAssignments;
-    UINT  finalAssignments = 0;             // the number of assignments worth keeping    
-    UINT  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];
-        BYTE *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 D3D10_SVT_UINT8:
-            D3DXASSERT(g_lvGeneral[psAssignments[i].iState].m_Cols == 1); // BYTE arrays not supported
-            pAssignment->DataSize = sizeof(BYTE);
-            // Store an offset for destination instead of a pointer so that it's easy to relocate it later
-            
-            break;
-
-        case D3D10_SVT_BOOL:
-        case D3D10_SVT_INT:
-        case D3D10_SVT_UINT:
-        case D3D10_SVT_FLOAT:
-            pAssignment->DataSize = SType::c_ScalarSize * g_lvGeneral[psAssignments[i].iState].m_Cols;
-            break;
-
-        case D3D10_SVT_RASTERIZER:
-            pAssignment->DataSize = sizeof(SRasterizerBlock);
-            break;
-
-        case D3D10_SVT_DEPTHSTENCIL:
-            pAssignment->DataSize = sizeof(SDepthStencilBlock);
-            break;
-
-        case D3D10_SVT_BLEND:
-            pAssignment->DataSize = sizeof(SBlendBlock);
-            break;
-
-        case D3D10_SVT_VERTEXSHADER:
-        case D3D10_SVT_GEOMETRYSHADER:
-        case D3D10_SVT_PIXELSHADER:
-        case D3D11_SVT_HULLSHADER:
-        case D3D11_SVT_DOMAINSHADER:
-        case D3D11_SVT_COMPUTESHADER:
-            pAssignment->DataSize = sizeof(SShaderBlock);
-            break;
-
-        case D3D10_SVT_TEXTURE:
-        case D3D10_SVT_TEXTURE1D:
-        case D3D10_SVT_TEXTURE2D:
-        case D3D10_SVT_TEXTURE2DMS:
-        case D3D10_SVT_TEXTURE3D:
-        case D3D10_SVT_TEXTURECUBE:
-        case D3D10_SVT_TEXTURECUBEARRAY:
-        case D3D11_SVT_BYTEADDRESS_BUFFER:
-        case D3D11_SVT_STRUCTURED_BUFFER:
-            pAssignment->DataSize = sizeof(SShaderResource);
-            break;
-
-        case D3D10_SVT_RENDERTARGETVIEW:
-            pAssignment->DataSize = sizeof(SRenderTargetView);
-            break;
-
-        case D3D10_SVT_DEPTHSTENCILVIEW:
-            pAssignment->DataSize = sizeof(SDepthStencilView);
-            break;
-
-        case D3D11_SVT_RWTEXTURE1D:
-        case D3D11_SVT_RWTEXTURE1DARRAY:
-        case D3D11_SVT_RWTEXTURE2D:
-        case D3D11_SVT_RWTEXTURE2DARRAY:
-        case D3D11_SVT_RWTEXTURE3D:
-        case D3D11_SVT_RWBUFFER:
-        case D3D11_SVT_RWBYTEADDRESS_BUFFER:
-        case D3D11_SVT_RWSTRUCTURED_BUFFER:
-        case D3D11_SVT_APPEND_STRUCTURED_BUFFER:
-        case D3D11_SVT_CONSUME_STRUCTURED_BUFFER:
-            pAssignment->DataSize = sizeof(SUnorderedAccessView);
-            break;
-
-        case D3D11_SVT_INTERFACE_POINTER:
-            pAssignment->DataSize = sizeof(SInterface);
-            break;
-
-        default:
-            D3DXASSERT(0);
-            VHD( E_FAIL, "Internal loading error: invalid assignment type.");
-        }
-
-        UINT 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 = NULL;
-            UINT  *pNumConstants;
-            SBinaryConstant *pConstants;
-
-            VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(UINT), (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 NULL assignment
-                VBD( *pNumConstants == 1 && (pConstants[0].Type == EST_Int || pConstants[0].Type == EST_UInt) && pConstants[0].iValue == 0,
-                    "Invalid pEffectBuffer: non-NULL 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:
-                    D3DXASSERT(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( NULL != *((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;
-                UINT  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 = NULL;
-                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:
-            UINT  cbShaderBin;
-            BYTE *pShaderBin;
-            SShaderBlock *pShaderBlock;
-            SAnonymousShader *pAnonShader;
-            union
-            {
-                SBinaryAssignment::SInlineShader *psInlineShader;
-                SBinaryShaderData5 *psInlineShader5;
-            };
-
-            // Inline shader assignments must be object types
-            D3DXASSERT(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 = (BYTE*) pShaderBin;
-                pShaderBlock->pReflectionData->pStreamOutDecls[0] =
-                pShaderBlock->pReflectionData->pStreamOutDecls[1] =
-                pShaderBlock->pReflectionData->pStreamOutDecls[2] =
-                pShaderBlock->pReflectionData->pStreamOutDecls[3] = NULL;
-                pShaderBlock->pReflectionData->RasterizedStream = 0;
-                pShaderBlock->pReflectionData->IsNullGS = FALSE;
-                pShaderBlock->pReflectionData->pReflection = NULL;
-                pShaderBlock->pReflectionData->InterfaceParameterCount = 0;
-                pShaderBlock->pReflectionData->pInterfaceParameters = NULL;
-            }
-
-            switch (pAssignment->LhsType)
-            {
-            case ELHS_PixelShaderBlock:
-                pShaderBlock->pVT = &g_vtPS;
-                VBD( psInlineShader->oSODecl == NULL, "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( UINT 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 == NULL, "Internal loading error: vertex shaders cannot have stream out decls." );
-                break;
-
-            case ELHS_HullShaderBlock:
-                pShaderBlock->pVT = &g_vtHS;
-                VBD( psInlineShader->oSODecl == NULL, "Internal loading error: hull shaders cannot have stream out decls." );
-                break;
-
-            case ELHS_DomainShaderBlock:
-                pShaderBlock->pVT = &g_vtDS;
-                VBD( psInlineShader->oSODecl == NULL, "Internal loading error: domain shaders cannot have stream out decls." );
-                break;
-
-            case ELHS_ComputeShaderBlock:
-                pShaderBlock->pVT = &g_vtCS;
-                VBD( psInlineShader->oSODecl == NULL, "Internal loading error: compute shaders cannot have stream out decls." );
-                break;
-
-            case ELHS_GeometryShaderSO:
-                D3DXASSERT(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:
-            D3DXASSERT(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;
-    UINT  iBlock;
-    UINT  cBlocks;
-
-    cBlocks = m_pHeader->Effect.cObjectVariables;
-
-    for (iBlock=0; iBlock<cBlocks; iBlock++)
-    {
-        SBinaryObjectVariable *psBlock;
-        SGlobalVariable *pVar;
-        SType *pType;
-        UINT  iElement;
-        UINT  elementsToRead;
-        CCheckedDword chkElementsTotal;
-        UINT  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 = NULL;
-        pVar->ExplicitBindPoint = psBlock->ExplicitBindPoint;
-
-        if( pType->IsStateBlockObject() )
-        {
-            pVar->MemberDataOffsetPlus4 = m_pEffect->m_MemberDataCount * sizeof(SMemberDataPointer) + 4;
-            m_pEffect->m_MemberDataCount += max(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 = max(1, pType->Elements);
-        chkElementsTotal = elementsToRead;
-
-        if (pType->IsStateBlockObject())
-        {
-            // State blocks
-            EBlockType blockType;
-            UINT  *maxBlockCount;
-            UINT  *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 (iElement = 0; iElement < elementsToRead; ++ iElement)
-            {
-                SBaseBlock *pCurrentBlock;
-                UINT  cAssignments;
-                
-                pCurrentBlock = (SBaseBlock *) GetBlockByIndex(pVar->pType->VarType, pVar->pType->ObjectType, pVar->Data.pGeneric, iElement);
-                VBD( NULL != 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, (BYTE*)pCurrentBlock, NULL, &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 (iElement=0; iElement<elementsToRead; iElement++)
-            {
-                UINT  cbShaderBin;
-                void *pShaderBin;
-                SShaderBlock *pShaderBlock;
-
-                union
-                {
-                    UINT *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 = (BYTE*) pShaderBin;
-                    pShaderBlock->pReflectionData->pStreamOutDecls[0] =
-                    pShaderBlock->pReflectionData->pStreamOutDecls[1] =
-                    pShaderBlock->pReflectionData->pStreamOutDecls[2] =
-                    pShaderBlock->pReflectionData->pStreamOutDecls[3] = NULL;
-                    pShaderBlock->pReflectionData->RasterizedStream = 0;
-                    pShaderBlock->pReflectionData->IsNullGS = FALSE;
-                    pShaderBlock->pReflectionData->pReflection = NULL;
-                    pShaderBlock->pReflectionData->InterfaceParameterCount = 0;
-                    pShaderBlock->pReflectionData->pInterfaceParameters = NULL;
-                }
-
-                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( UINT 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 (iElement=0; iElement<elementsToRead; iElement++)
-            {
-                UINT  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;
-    UINT  iBlock;
-    UINT  cBlocks;
-
-    cBlocks = m_pHeader->cInterfaceVariables;
-
-    for (iBlock=0; iBlock<cBlocks; iBlock++)
-    {
-        SBinaryInterfaceVariable *psBlock;
-        SGlobalVariable *pVar;
-        SType *pType;
-        UINT  elementsToRead;
-        CCheckedDword chkElementsTotal;
-        UINT  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 = NULL;
-        pVar->ExplicitBindPoint = (UINT)-1;
-        pVar->pSemantic = NULL;
-
-        // Get name
-        VHD( GetStringAndAddToReflection(psBlock->oName, &pVar->pName), "Invalid pEffectBuffer: cannot read interface name." );
-
-        m_pEffect->m_VariableCount++;
-        elementsToRead = max(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( UINT 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 != NULL, "Loading error: cannot find class instance for interface initializer." );
-                VBD( pCIVariable->pType->IsClassInstance(), "Loading error: variable type mismatch for interface initializer." );
-                if( pInterfaceInit->ArrayIndex == (UINT)-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;
-    UINT iGroup;
-    UINT TechniquesInEffect = 0;
-
-    for( 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 == NULL )
-        {
-            VBD( m_pEffect->m_pNullGroup == NULL, "Internal loading error: multiple NULL groups." );
-            m_pEffect->m_pNullGroup = pGroup;
-        }
-
-        // Read annotations
-        VH( LoadAnnotations(&pGroup->AnnotationCount, &pGroup->pAnnotations) );
-
-        UINT iTechnique;
-        for( 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;
-    UINT  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, (BYTE*)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(UINT  *pcAnnotations, SAnnotation **ppAnnotations)
-{
-    HRESULT hr = S_OK;
-    UINT  cAnnotations, i, oData;
-    SAnnotation *pAnnotations = NULL;
-
-    VHD( m_msStructured.Read(&cAnnotations), "Invalid pEffectBuffer: cannot read anootation count." );
-
-    if (cAnnotations)
-    {
-        UINT  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 BYTE[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))
-            {
-                UINT  cElements = max(1, pType->Elements);
-                UINT  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."  );
-                    VHD( GetStringAndAddToReflection(oData, &pAn->Data.pString[j].pString), "Invalid pEffectBuffer: cannot read string initializer."  );
-                }
-            }
-            else if (pType->BelongsInConstantBuffer())
-            {
-                void *pDefaultValue;
-                UINT  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 BYTE[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((BYTE*) pAn->Data.pGeneric, (BYTE*) 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;
-    UINT  i, j;
-    CEffectVector<SRange> vRanges[ER_Count], *pvRange;
-    SRange *pRange = NULL;
-    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;
-    pShaderBlock->pReflectionData->pReflection->GetDesc( &ShaderDesc );
-
-    // Since we have the shader desc, let's find out if this is a NULL 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(i = 0; i < ShaderDesc.BoundResources; i++)
-    {
-        LPCSTR pName;
-        UINT bindPoint, size;
-        ERanges eRange;
-        SShaderResource *pShaderResource = NULL;
-        SUnorderedAccessView *pUnorderedAccessView = NULL;
-        SSamplerBlock *pSampler = NULL;
-        SConstantBuffer *pCB = NULL;
-        SVariable *pVariable = NULL;
-        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 D3D10_SIT_CBUFFER:
-            eRange = ER_CBuffer;
-            
-            pCB = m_pEffect->FindCB(pName);
-            VBD( NULL != pCB, "Loading error: cannot find cbuffer." );
-            VBD( size == 1, "Loading error: cbuffer arrays are not supported." );
-            break;
-
-        case D3D10_SIT_TBUFFER:
-            eRange = ER_Texture;
-            
-            pCB = m_pEffect->FindCB(pName);
-            VBD( NULL != 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 D3D10_SIT_TEXTURE: 
-        case D3D11_SIT_STRUCTURED:
-        case D3D11_SIT_BYTEADDRESS:
-            eRange = ER_Texture;
-
-            pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
-            VBD( pVariable != NULL, "Loading error: cannot find SRV variable." );
-            UINT elements;
-            elements = max(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 (j = 0; j < size; ++ j)
-                {
-                    if (NULL == 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[%d] does not have a texture bound to it, even though the sampler array is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName, j);
-                        }
-                        
-                        VH( E_FAIL );
-                    }
-                }
-            }
-            break;
-
-        case D3D11_SIT_UAV_RWTYPED:
-        case D3D11_SIT_UAV_RWSTRUCTURED:
-        case D3D11_SIT_UAV_RWBYTEADDRESS:
-        case D3D11_SIT_UAV_APPEND_STRUCTURED:
-        case D3D11_SIT_UAV_CONSUME_STRUCTURED:
-        case D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
-            eRange = ER_UnorderedAccessView;
-
-            pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
-            VBD( pVariable != NULL, "Loading error: cannot find UAV variable." );
-            VBD( size <= max(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 D3D10_SIT_SAMPLER:
-            eRange = ER_Sampler;
-
-            pVariable = m_pEffect->FindVariableByNameWithParsing(pName);
-            VBD( pVariable != NULL, "Loading error: cannot find sampler variable." );
-            VBD( size <= max(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
-        //
-        UINT  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
-            D3DXASSERT(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 D3D10_SIT_CBUFFER:
-            VHD( pRange->vResources.Add(pCB), "Internal loading error: cannot add cbuffer to range." );
-            break;
-        case D3D10_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 D3D10_SIT_TEXTURE:
-        case D3D11_SIT_STRUCTURED:
-        case D3D11_SIT_BYTEADDRESS:
-            if (isFX9TextureLoad)
-            {
-                // grab all of the textures from each sampler
-                for (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 (j = 0; j < size; ++ j)
-                {
-                    VHD( pRange->vResources.Add(pShaderResource + j), "Internal loading error: cannot add SRV to range." );
-                }
-            }
-            break;
-        case D3D11_SIT_UAV_RWTYPED:
-        case D3D11_SIT_UAV_RWSTRUCTURED:
-        case D3D11_SIT_UAV_RWBYTEADDRESS:
-        case D3D11_SIT_UAV_APPEND_STRUCTURED:
-        case D3D11_SIT_UAV_CONSUME_STRUCTURED:
-        case D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
-            // add the whole array
-            for (j = 0; j < size; ++ j)
-            {
-                VHD( pRange->vResources.Add(pUnorderedAccessView + j), "Internal loading error: cannot add UAV to range." );
-            }
-            break;
-        case D3D10_SIT_SAMPLER:
-            // add the whole array
-            for (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
-
-    UINT NumInterfaces = pShaderBlock->pReflectionData->pReflection->GetNumInterfaceSlots();
-    UINT CurInterfaceParameter = 0;
-    if( NumInterfaces > 0 )
-    {
-        D3DXASSERT( ShaderDesc.ConstantBuffers > 0 );
-
-        for( 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( UINT iVar=0; iVar < CBDesc.Variables; iVar++ )
-            {
-                ID3D11ShaderReflectionVariable* pInterfaceVar = pCB->GetVariableByIndex( iVar );
-                VN( pInterfaceVar );
-                D3D11_SHADER_VARIABLE_DESC InterfaceDesc;
-                pInterfaceVar->GetDesc( &InterfaceDesc );
-
-                LPCSTR pName;
-                UINT bindPoint, size;
-                SGlobalVariable *pVariable = NULL;
-                SInterface *pInterface = NULL;
-                UINT VariableElements;
-
-                pName = InterfaceDesc.Name;
-                bindPoint = InterfaceDesc.StartOffset;
-                size = InterfaceDesc.Size;
-
-                if( bindPoint == (UINT)-1 )
-                {
-                    continue;
-                }
-
-                D3DXASSERT( 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 != NULL, "Loading error: cannot find parent type." );
-                        if( pInterfaceInfo->Index == (UINT)-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 != NULL, "Loading error: cannot find interface variable." );
-                    VariableElements = pVariable->pType->Elements;
-                }
-                VBD( size <= max(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 )
-                    {
-                        D3DXASSERT( 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( UINT 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
-                //
-                UINT  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( 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 NULL interface to range." );
-                        pRange->last++;
-                    }
-
-                    D3DXASSERT( bindPoint == pRange->last );
-                    for( 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 (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 ];
-
-        D3DXASSERT(pDep->Count == pRange->vResources.GetSize());
-        for (j=0; j<pDep->Count; ++j)
-        {
-            pDep->ppFXPointers[j] = (SConstantBuffer *)pRange->vResources[j];
-            pDep->ppD3DObjects[j] = NULL;
-        }
-    }
-
-    for (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 ];
-
-        D3DXASSERT(pDep->Count == pRange->vResources.GetSize());
-        for (j=0; j<pDep->Count; ++j)
-        {
-            pDep->ppFXPointers[j] = (SSamplerBlock *) pRange->vResources[j];
-            pDep->ppD3DObjects[j] = NULL;
-        }
-    }
-
-    for (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 ];
-
-        D3DXASSERT(pDep->Count == pRange->vResources.GetSize());
-        for (j=0; j<pDep->Count; ++j)
-        {
-            pDep->ppFXPointers[j] = (SInterface *) pRange->vResources[j];
-            pDep->ppD3DObjects[j] = NULL;
-        }
-    }
-
-    for (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 ];
-
-        D3DXASSERT(pDep->Count == pRange->vResources.GetSize());
-        for (j=0; j<pDep->Count; ++j)
-        {
-            pDep->ppFXPointers[j] = (SShaderResource *) pRange->vResources[j];
-            pDep->ppD3DObjects[j] = NULL;
-        }
-    }
-
-    for (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 ];
-
-        D3DXASSERT(pDep->Count == pRange->vResources.GetSize());
-        for (j=0; j<pDep->Count; ++j)
-        {
-            pDep->ppFXPointers[j] = (SUnorderedAccessView *) pRange->vResources[j];
-            pDep->ppD3DObjects[j] = NULL;
-        }
-    }
-
-    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 != NULL, "Internal loading error: NULL shader vtable." );
-
-    D3DXASSERT(pShaderBlock->pD3DObject == NULL);
-
-    if (NULL == 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( NULL );
-        // or 
-        // vertexshader g_VS = NULL;
-        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() )
-    {
-        D3DXASSERT( pShaderBlock->pInputSignatureBlob == NULL );
-        VHD( D3DGetInputSignatureBlob( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, &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(UINT  cAnnotations, SAnnotation *pAnnotations)
-{
-    HRESULT hr = S_OK;
-    UINT  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." );
-
-            UINT  cElements;
-            cElements = max(1, pAnnotations[i].pType->Elements);
-            
-            m_ReflectionMemory += AlignToPowerOf2(cElements * sizeof(SString), c_DataAlignment);
-            
-        }
-    }
-
-lExit:
-    return hr;
-}
-
-HRESULT CEffectLoader::ReallocateAnnotationData(UINT  cAnnotations, SAnnotation **ppAnnotations)
-{
-    HRESULT hr = S_OK;
-    UINT  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))
-        {
-            UINT  j;
-            UINT  cElements = max(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 (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( UINT KnownSize )
-{
-    HRESULT hr = S_OK;
-    UINT  i, j, k;
-    UINT  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 (i=0; i<m_pEffect->m_CBCount; i++)
-        {
-            VH( CalculateAnnotationSize(m_pEffect->m_pCBs[i].AnnotationCount, m_pEffect->m_pCBs[i].pAnnotations) );
-        }
-
-        for (i=0; i<m_pEffect->m_VariableCount; i++)
-        {
-            VH( CalculateAnnotationSize(m_pEffect->m_pVariables[i].AnnotationCount, m_pEffect->m_pVariables[i].pAnnotations) );
-        }
-
-        for (i=0; i<m_pEffect->m_GroupCount; i++)
-        {
-            VH( CalculateAnnotationSize(m_pEffect->m_pGroups[i].AnnotationCount, m_pEffect->m_pGroups[i].pAnnotations) );
-
-            for (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 (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 (i=0; i<m_pEffect->m_ShaderBlockCount; i++)
-        {
-            if (NULL != 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(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;
-    UINT  i, j, k;
-    CEffectHeap *pHeap = &m_pReflection->m_Heap;
-
-    for(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(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(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(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(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 (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 (i=0; i<m_pEffect->m_ShaderBlockCount; i++)
-    {
-        if (NULL != 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( UINT 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, UINT  cBlocks, T* pOldBlocks)
-{
-    HRESULT hr = S_OK;
-    CEffectHeap *pHeap = &m_pEffect->m_Heap;
-    UINT  i, j;
-
-    for(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 (j=0; j<pBlock->AssignmentCount; j++)
-        {
-            SAssignment *pAssignment = &pBlock->pAssignments[j];
-            UINT  cbDeps;
-
-            // When cloning, convert pointers back into offsets
-            if( pOldBlocks )
-            {
-                T *pOldBlock = &pOldBlocks[i];
-                pAssignment->Destination.Offset = (UINT)( (UINT_PTR)pAssignment->Destination.pGeneric - (UINT_PTR)pOldBlock ) ;
-            }
-
-            // Convert destination pointers from offset to real pointer
-            pAssignment->Destination.pGeneric = (BYTE*) pBlock + pAssignment->Destination.Offset;
-
-            // Make sure the data pointer points into the backing store
-            VBD( pAssignment->Destination.pGeneric >= &pBlock->BackingStore && 
-                 pAssignment->Destination.pGeneric < (BYTE*) &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 = NULL;
-            for(UINT  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)
-                D3DXASSERT( !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;
-                    D3DXASSERT( pVariable->pType->BelongsInConstantBuffer() && NULL != pVariable->pCB );
-
-                    // When cloning, convert pointers back into offsets
-                    if( pOldBlocks )
-                    {
-                        VBD( pOldVariable != NULL, "Internal loading error: pOldVariable is NULL." );
-                        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
-                    D3DXASSERT(0);
-                    VHD( E_FAIL, "Loading error: invalid assignment type." );
-                }
-                break;
-
-            case ELHS_Invalid:
-                VHD( E_FAIL, "Loading error: invalid assignment type." );
-            }
-
-            D3DXASSERT(m_pEffect->m_LocalTimer > 0);
-            m_pEffect->EvaluateAssignment(pAssignment);
-        }
-    }
-
-lExit:
-    return hr;
-}
-
-template<class T> UINT  CEffectLoader::CalculateBlockAssignmentSize(T* &pBlocks, UINT  cBlocks)
-{
-    UINT  dwSize = 0;
-    UINT  i, j;
-
-    for(i=0; i<cBlocks; i++)
-    {
-        SBaseBlock *pBlock = &pBlocks[i];
-        dwSize += AlignToPowerOf2(pBlock->AssignmentCount * sizeof(SAssignment), c_DataAlignment);
-        
-        for (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;
-    UINT  i, j, k;
-    CEffectHeap *pHeap = &m_pEffect->m_Heap;
-    const char* pError = "Internal loading error: cannot move shader data.";
-    
-    for (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 (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 (k=0; k<pCBDeps->Count; k++)
-            {
-                VH( FixupCBPointer( &pCBDeps->ppFXPointers[k] ) );
-            }
-        }
-
-        for (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 (k=0; k<pSampDeps->Count; k++)
-            {
-                VH( FixupSamplerPointer(&pSampDeps->ppFXPointers[k]) );
-            }
-        }
-
-        for (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 (k=0; k<pInterfaceDeps->Count; k++)
-            {
-                VH( FixupInterfacePointer(&pInterfaceDeps->ppFXPointers[k], true) );
-            }
-        }
-
-        for (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 (k=0; k<pResourceDeps->Count; k++)
-            {
-                VH( FixupShaderResourcePointer(&pResourceDeps->ppFXPointers[k]) );
-            }
-        }
-
-        for (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 (k=0; k<pUAVDeps->Count; k++)
-            {
-                VH( FixupUnorderedAccessViewPointer(&pUAVDeps->ppFXPointers[k]) );
-            }
-        }
-
-        for (j=0; j<pShader->TBufferDepCount; j++)
-        {
-            VH( FixupCBPointer( &pShader->ppTbufDeps[j] ) );
-        }
-    }
-
-lExit:
-    return hr;
-}
-
-
-UINT  CEffectLoader::CalculateShaderBlockSize()
-{
-    UINT  dwSize = 0;
-    UINT  i, j;
-    
-    for (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 (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 (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 (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 (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 (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
-HRESULT CEffectLoader::ReallocateEffectData( bool Cloning )
-{
-    HRESULT hr = S_OK;
-    UINT i, j;
-    CEffectHeap *pHeap = &m_pEffect->m_Heap;
-    UINT cbCBs = sizeof(SConstantBuffer) * m_pEffect->m_CBCount;
-    UINT cbVariables = sizeof(SGlobalVariable) * m_pEffect->m_VariableCount;
-    UINT cbGroups = sizeof(STechnique) * m_pEffect->m_GroupCount;
-    UINT cbShaders = sizeof(SShaderBlock) * m_pEffect->m_ShaderBlockCount;
-    UINT cbDS = sizeof(SDepthStencilBlock) * m_pEffect->m_DepthStencilBlockCount;
-    UINT cbAB = sizeof(SBlendBlock) * m_pEffect->m_BlendBlockCount;
-    UINT cbRS = sizeof(SRasterizerBlock) * m_pEffect->m_RasterizerBlockCount;
-    UINT cbSamplers = sizeof(SSamplerBlock) * m_pEffect->m_SamplerBlockCount;
-    UINT cbMemberDatas = sizeof(SMemberDataPointer) * m_pEffect->m_MemberDataCount;
-    UINT cbInterfaces = sizeof(SInterface) * m_pEffect->m_InterfaceCount;
-    UINT cbBackgroundInterfaces = sizeof(SInterface) * m_BackgroundInterfaces.GetSize();
-    UINT cbShaderResources = sizeof(SShaderResource) * m_pEffect->m_ShaderResourceCount;
-    UINT cbUnorderedAccessViews = sizeof(SUnorderedAccessView) * m_pEffect->m_UnorderedAccessViewCount;
-    UINT cbRenderTargetViews = sizeof(SRenderTargetView) * m_pEffect->m_RenderTargetViewCount;
-    UINT cbDepthStencilViews = sizeof(SDepthStencilView) * m_pEffect->m_DepthStencilViewCount;
-    UINT 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 (i=0; i<m_pEffect->m_CBCount; i++)
-    {
-        SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];
-
-        m_EffectMemory += AlignToPowerOf2(pCB->Size, c_DataAlignment);
-    }
-
-    for (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 (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 (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*)( (BYTE*)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 (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*)( (BYTE*)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 (i=0; i<m_pEffect->m_CBCount; i++)
-    {
-        SConstantBuffer *pCB = &m_pEffect->m_pCBs[i];
-        pCB->pEffect = m_pEffect;
-
-        if (pCB->pVariables != NULL)
-        {
-            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( i=0; i < m_BackgroundInterfaces.GetSize(); i++ )
-    {
-        D3DXASSERT( m_BackgroundInterfaces[i] != NULL );
-        BYTE* pDst = (BYTE*)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 : NULL) );
-    
-    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 : NULL) );
-
-    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 : NULL) );
-
-    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 : NULL) );
-    
-    // Fixup sampler backing stores
-    for (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 (i=0; i<m_pEffect->m_InterfaceCount; i++)
-    {
-        SInterface *pInterface = &m_pEffect->m_pInterfaces[i];
-
-        if (pInterface->pClassInstance != NULL)
-        {
-            VH( FixupVariablePointer( (SGlobalVariable**)&pInterface->pClassInstance ) );
-        }
-    }
-
-    // Fixup pointers for non-numeric variables
-    for (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 (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() )
-            {
-                D3DXASSERT( pMember->Data.pGeneric == NULL || (*ppTopLevelEntity)->pEffect->m_Heap.IsInHeap(pMember->Data.pGeneric) );
-                pMember->Data.Offset = (UINT)( (BYTE*)pMember->Data.pGeneric - (BYTE*)(*ppTopLevelEntity)->pCB->pBackingStore );
-            }
-            if( bGlobalMemberDataBlock && pMember->pMemberData )
-            {
-                pMember->MemberDataOffsetPlus4 = (UINT)( (BYTE*)pMember->pMemberData - (BYTE*)(*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*)( (BYTE*)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 (i=0; i<m_pEffect->m_GroupCount; i++)
-    {
-        SGroup *pGroup = &m_pEffect->m_pGroups[i];
-        UINT  cbTechniques;
-
-        cbTechniques = pGroup->TechniqueCount * sizeof(STechnique);
-        VHD( pHeap->MoveData((void**) &pGroup->pTechniques, cbTechniques), "Internal loading error: cannot move techniques." );
-
-        for (j=0; j<pGroup->TechniqueCount; j++)
-        {
-            STechnique *pTech = &pGroup->pTechniques[j];
-            UINT  cbPass;
-            UINT  iPass;
-
-            cbPass = pTech->PassCount * sizeof(SPassBlock);
-            SPassBlock* pOldPasses = Cloning ? pTech->pPasses : NULL;
-            VHD( pHeap->MoveData((void**) &pTech->pPasses, cbPass), "Internal loading error: cannot move passes." );
-
-            for (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 (UINT 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 (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;
-}
-
-}
diff --git a/sample/d3d11/Effects11/EffectLoad.h b/sample/d3d11/Effects11/EffectLoad.h
deleted file mode 100644
index c5f5dc1..0000000
--- a/sample/d3d11/Effects11/EffectLoad.h
+++ /dev/null
@@ -1,149 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectLoad.h
-//  Content:    D3DX11 Effects header for the FX file loader 
-//              A CEffectLoader is created at load time to facilitate loading
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#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
-{
-    UINT                    start;
-    UINT                    last;
-    CEffectVector<void *>   vResources; // should be (last - start) in length, resource type depends on the range type
-};
-
-// Used during load to validate assignments
-D3D10_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(UINT Flags, ID3DX11Effect** ppClonedEffect );
-
-protected:
-    // Load-time allocations that eventually get moved happen out of the TempHeap. This heap will grow as needed
-    CDataBlockStore             m_BulkHeap;
-
-    BYTE                        *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<BYTE>         m_HashBuffer;
-
-    UINT                        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;
-    UINT                        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;
-
-    UINT                        m_EffectMemory;     // Effect private heap
-    UINT                        m_ReflectionMemory; // Reflection private heap
-
-    // Loader helpers
-    HRESULT LoadCBs();
-    HRESULT LoadNumericVariable(SConstantBuffer *pParentCB);
-    HRESULT LoadObjectVariables();
-    HRESULT LoadInterfaceVariables();
-
-    HRESULT LoadTypeAndAddToPool(SType **ppType, UINT  dwOffset);
-    HRESULT LoadStringAndAddToPool(__out_ecount_full(1) char **ppString, UINT  dwOffset);
-    HRESULT LoadAssignments( UINT Assignments, SAssignment **pAssignments, BYTE *pBackingStore, UINT *pRTVAssignments, UINT *pFinalAssignments );
-    HRESULT LoadGroups();
-    HRESULT LoadTechnique( STechnique* pTech );
-    HRESULT LoadAnnotations(UINT  *pcAnnotations, SAnnotation **ppAnnotations);
-
-    HRESULT ExecuteConstantAssignment(SBinaryConstant *pConstant, void *pLHS, D3D10_SHADER_VARIABLE_TYPE lhsType);
-    UINT    UnpackData(BYTE *pDestData, BYTE *pSrcData, UINT  PackedDataSize, SType *pType, UINT  *pBytesRead);
-
-    // Build shader blocks
-    HRESULT ConvertRangesToBindings(SShaderBlock *pShaderBlock, CEffectVector<SRange> *pvRanges );
-    HRESULT GrabShaderData(SShaderBlock *pShaderBlock);
-    HRESULT BuildShaderBlock(SShaderBlock *pShaderBlock);
-
-    // Memory compactors
-    HRESULT InitializeReflectionDataAndMoveStrings( UINT KnownSize = 0 );
-    HRESULT ReallocateReflectionData( bool Cloning = false );
-    HRESULT ReallocateEffectData( bool Cloning = false );
-    HRESULT ReallocateShaderBlocks();
-    template<class T> HRESULT ReallocateBlockAssignments(T* &pBlocks, UINT  cBlocks, T* pOldBlocks = NULL);
-    HRESULT ReallocateAnnotationData(UINT  cAnnotations, SAnnotation **ppAnnotations);
-
-    HRESULT CalculateAnnotationSize(UINT  cAnnotations, SAnnotation *pAnnotations);
-    UINT  CalculateShaderBlockSize();
-    template<class T> UINT  CalculateBlockAssignmentSize(T* &pBlocks, UINT  cBlocks);
-
-    HRESULT FixupCBPointer(SConstantBuffer **ppCB);
-    HRESULT FixupShaderPointer(SShaderBlock **ppShaderBlock);
-    HRESULT FixupDSPointer(SDepthStencilBlock **ppDSBlock);
-    HRESULT FixupABPointer(SBlendBlock **ppABBlock);
-    HRESULT FixupRSPointer(SRasterizerBlock **ppRSBlock);
-    HRESULT FixupInterfacePointer(SInterface **ppInterface, bool CheckBackgroundInterfaces);
-    HRESULT FixupShaderResourcePointer(SShaderResource **ppResource);
-    HRESULT FixupUnorderedAccessViewPointer(SUnorderedAccessView **ppResource);
-    HRESULT FixupRenderTargetViewPointer(SRenderTargetView **ppRenderTargetView);
-    HRESULT FixupDepthStencilViewPointer(SDepthStencilView **ppDepthStencilView);
-    HRESULT FixupSamplerPointer(SSamplerBlock **ppSampler);
-    HRESULT FixupVariablePointer(SGlobalVariable **ppVar);
-    HRESULT FixupStringPointer(SString **ppString);
-    HRESULT FixupMemberDataPointer(SMemberDataPointer **ppMemberData);
-    HRESULT FixupGroupPointer(SGroup **ppGroup);
-
-    // Methods to retrieve data from the unstructured block
-    // (these do not make copies; they simply return pointers into the block)
-    HRESULT GetStringAndAddToReflection(UINT  offset, __out_ecount_full(1) char **ppPointer);  // Returns a string from the file string block, updates m_EffectMemory
-    HRESULT GetUnstructuredDataBlock(UINT  offset, UINT  *pdwSize, void **ppData);
-    // This function makes a copy of the array of SInterfaceParameters, but not a copy of the strings
-    HRESULT GetInterfaceParametersAndAddToReflection( UINT InterfaceCount, UINT offset, __out_ecount_full(1) SShaderBlock::SInterfaceParameter **ppInterfaces );
-public:
-
-    HRESULT LoadEffect(CEffect *pEffect, CONST void *pEffectBuffer, UINT  cbEffectBuffer);
-};
-
-
-}
\ No newline at end of file
diff --git a/sample/d3d11/Effects11/EffectNonRuntime.cpp b/sample/d3d11/Effects11/EffectNonRuntime.cpp
deleted file mode 100644
index 5484d50..0000000
--- a/sample/d3d11/Effects11/EffectNonRuntime.cpp
+++ /dev/null
@@ -1,2963 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectNonRuntime.cpp
-//  Content:    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.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-#include "SOParser.h"
-
-namespace D3DX11Effects
-{
-
-extern SUnorderedAccessView g_NullUnorderedAccessView;
-
-SBaseBlock::SBaseBlock()
-: BlockType(EBT_Invalid)
-, IsUserManaged(FALSE)
-, AssignmentCount(0)
-, pAssignments(NULL)
-{
-
-}
-
-SPassBlock::SPassBlock()
-{
-    pName = NULL;
-    AnnotationCount = 0;
-    pAnnotations = NULL;
-    InitiallyValid = TRUE;
-    HasDependencies = FALSE;
-    ZeroMemory(&BackingStore, sizeof(BackingStore));
-}
-
-STechnique::STechnique()
-: pName(NULL)
-, PassCount(0)
-, pPasses(NULL)
-, AnnotationCount(0)
-, pAnnotations(NULL)
-, InitiallyValid( TRUE )
-, HasDependencies( FALSE )
-{
-}
-
-SGroup::SGroup()
-: pName(NULL)
-, TechniqueCount(0)
-, pTechniques(NULL)
-, AnnotationCount(0)
-, pAnnotations(NULL)
-, InitiallyValid( TRUE )
-, HasDependencies( FALSE )
-{
-}
-
-SDepthStencilBlock::SDepthStencilBlock()
-{
-    pDSObject = NULL;
-    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 = NULL;
-    ZeroMemory(&BackingStore, sizeof(BackingStore));
-    IsValid = TRUE;
-
-    BackingStore.AlphaToCoverageEnable = FALSE;
-    BackingStore.IndependentBlendEnable = TRUE;
-    for( UINT 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 = NULL;
-    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 = NULL;
-    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 = NULL;
-    
-    pD3DObject = NULL;
-
-    CBDepCount = 0;
-    pCBDeps = NULL;
-
-    SampDepCount = 0;
-    pSampDeps = NULL;
-
-    InterfaceDepCount = 0;
-    pInterfaceDeps = NULL;
-
-    ResourceDepCount = 0;
-    pResourceDeps = NULL;
-
-    UAVDepCount = 0;
-    pUAVDeps = NULL;
-
-    TBufferDepCount = 0;
-    ppTbufDeps = NULL;
-
-    pInputSignatureBlob = NULL;
-}
-
-HRESULT SShaderBlock::OnDeviceBind()
-{
-    HRESULT hr = S_OK;
-    UINT  i, j;
-
-    // Update all CB deps
-    for (i=0; i<CBDepCount; i++)
-    {
-        D3DXASSERT(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++)
-    {
-        D3DXASSERT(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(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
-{
-    HRESULT hr = S_OK;
-    UINT i, j;
-    BYTE *pSamplerMask = NULL, *pShaderResourceMask = NULL, *pConstantBufferMask = NULL, *pUnorderedAccessViewMask = NULL, *pInterfaceMask = NULL;
-
-    switch (GetShaderType())
-    {
-    case EOT_VertexShader:
-    case EOT_VertexShader5:
-        pStateBlockMask->VS = 1;
-        pSamplerMask = pStateBlockMask->VSSamplers;
-        pShaderResourceMask = pStateBlockMask->VSShaderResources;
-        pConstantBufferMask = pStateBlockMask->VSConstantBuffers;
-        pInterfaceMask = pStateBlockMask->VSInterfaces;
-        pUnorderedAccessViewMask = NULL;
-        break;
-
-    case EOT_GeometryShader:
-    case EOT_GeometryShader5:
-        pStateBlockMask->GS = 1;
-        pSamplerMask = pStateBlockMask->GSSamplers;
-        pShaderResourceMask = pStateBlockMask->GSShaderResources;
-        pConstantBufferMask = pStateBlockMask->GSConstantBuffers;
-        pInterfaceMask = pStateBlockMask->GSInterfaces;
-        pUnorderedAccessViewMask = NULL;
-        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 = NULL;
-        break;
-
-    case EOT_DomainShader5:
-        pStateBlockMask->DS = 1;
-        pSamplerMask = pStateBlockMask->DSSamplers;
-        pShaderResourceMask = pStateBlockMask->DSShaderResources;
-        pConstantBufferMask = pStateBlockMask->DSConstantBuffers;
-        pInterfaceMask = pStateBlockMask->DSInterfaces;
-        pUnorderedAccessViewMask = NULL;
-        break;
-
-    case EOT_ComputeShader5:
-        pStateBlockMask->CS = 1;
-        pSamplerMask = pStateBlockMask->CSSamplers;
-        pShaderResourceMask = pStateBlockMask->CSShaderResources;
-        pConstantBufferMask = pStateBlockMask->CSConstantBuffers;
-        pInterfaceMask = pStateBlockMask->CSInterfaces;
-        pUnorderedAccessViewMask = &pStateBlockMask->CSUnorderedAccessViews;
-        break;
-
-    default:
-        D3DXASSERT(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)
-    {
-        D3DXASSERT( pUnorderedAccessViewMask != NULL );
-        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(D3DX11_EFFECT_SHADER_DESC *pDesc, BOOL IsInline)
-{
-    HRESULT hr = S_OK;
-    
-    ZeroMemory(pDesc, sizeof(*pDesc));
-
-    pDesc->pInputSignature = pInputSignatureBlob ? (const BYTE*)pInputSignatureBlob->GetBufferPointer() : NULL;
-    pDesc->IsInline = IsInline;
-
-    if (NULL != pReflectionData)
-    {
-        // initialize these only if present; otherwise leave them NULL or 0
-        pDesc->pBytecode = pReflectionData->pBytecode;
-        pDesc->BytecodeLength = pReflectionData->BytecodeLength;
-        for( UINT iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
-        {
-            pDesc->SODecls[iDecl] = pReflectionData->pStreamOutDecls[iDecl];
-        }
-        pDesc->RasterizedStream = pReflectionData->RasterizedStream;
-
-        // get # of input & output signature entries
-        D3DXASSERT( pReflectionData->pReflection != NULL );
-
-        D3D11_SHADER_DESC ShaderDesc;
-        pReflectionData->pReflection->GetDesc( &ShaderDesc );
-        pDesc->NumInputSignatureEntries = ShaderDesc.InputParameters;
-        pDesc->NumOutputSignatureEntries = ShaderDesc.OutputParameters;
-        pDesc->NumPatchConstantSignatureEntries = ShaderDesc.PatchConstantParameters;
-    }
-lExit:
-    return hr;
-}
-
-HRESULT SShaderBlock::GetVertexShader(ID3D11VertexShader **ppVS)
-{
-    if (EOT_VertexShader == GetShaderType() ||
-        EOT_VertexShader5 == GetShaderType())
-    {
-        *ppVS = (ID3D11VertexShader *) pD3DObject;
-        SAFE_ADDREF(*ppVS);
-        return S_OK;
-    }
-    else
-    {
-        *ppVS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetVertexShader: This shader variable is not a vertex shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetGeometryShader(ID3D11GeometryShader **ppGS)
-{
-    if (EOT_GeometryShader == GetShaderType() ||
-        EOT_GeometryShaderSO == GetShaderType() ||
-        EOT_GeometryShader5 == GetShaderType())
-    {
-        *ppGS = (ID3D11GeometryShader *) pD3DObject;
-        SAFE_ADDREF(*ppGS);
-        return S_OK;
-    }
-    else
-    {
-        *ppGS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetGeometryShader: This shader variable is not a geometry shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetPixelShader(ID3D11PixelShader **ppPS)
-{
-    if (EOT_PixelShader == GetShaderType() ||
-        EOT_PixelShader5 == GetShaderType())
-    {
-        *ppPS = (ID3D11PixelShader *) pD3DObject;
-        SAFE_ADDREF(*ppPS);
-        return S_OK;
-    }
-    else
-    {
-        *ppPS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetPixelShader: This shader variable is not a pixel shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetHullShader(ID3D11HullShader **ppHS)
-{
-    if (EOT_HullShader5 == GetShaderType())
-    {
-        *ppHS = (ID3D11HullShader *) pD3DObject;
-        SAFE_ADDREF(*ppHS);
-        return S_OK;
-    }
-    else
-    {
-        *ppHS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetHullShader: This shader variable is not a hull shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetDomainShader(ID3D11DomainShader **ppDS)
-{
-    if (EOT_DomainShader5 == GetShaderType())
-    {
-        *ppDS = (ID3D11DomainShader *) pD3DObject;
-        SAFE_ADDREF(*ppDS);
-        return S_OK;
-    }
-    else
-    {
-        *ppDS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetDomainShader: This shader variable is not a domain shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetComputeShader(ID3D11ComputeShader **ppCS)
-{
-    if (EOT_ComputeShader5 == GetShaderType())
-    {
-        *ppCS = (ID3D11ComputeShader *) pD3DObject;
-        SAFE_ADDREF(*ppCS);
-        return S_OK;
-    }
-    else
-    {
-        *ppCS = NULL;
-        DPF(0, "ID3DX11EffectShaderVariable::GetComputeShader: This shader variable is not a compute shader");
-        return D3DERR_INVALIDCALL;
-    }
-}
-
-HRESULT SShaderBlock::GetSignatureElementDesc(ESigType SigType, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName;
-    switch( SigType )
-    {
-    case ST_Input:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
-        break;
-    case ST_Output:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
-        break;
-    case ST_PatchConstant:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
-        break;
-    default:
-        D3DXASSERT( false );
-        return E_FAIL;
-    };
-
-    if (NULL != pReflectionData)
-    {
-        // get # of signature entries
-        D3DXASSERT( pReflectionData->pReflection != NULL );
-
-        D3D11_SHADER_DESC ShaderDesc;
-        VH( pReflectionData->pReflection->GetDesc( &ShaderDesc ) );
-
-        D3D11_SIGNATURE_PARAMETER_DESC ParamDesc;
-        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 (%d) 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 (%d) 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 (%d) 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 == D3D10_NAME_UNDEFINED && GetShaderType() == EOT_PixelShader )
-        {
-            if( _stricmp(pDesc->SemanticName, "SV_TARGET") == 0 )
-            {
-                pDesc->SystemValueType = D3D10_NAME_TARGET;
-            } 
-            else if( _stricmp(pDesc->SemanticName, "SV_DEPTH") == 0 )
-            {
-                pDesc->SystemValueType = D3D10_NAME_DEPTH;
-            } 
-            else if( _stricmp(pDesc->SemanticName, "SV_COVERAGE") == 0 )
-            {
-                pDesc->SystemValueType = D3D10_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 = NULL;
-}
-
-SRenderTargetView::SRenderTargetView()
-{
-    pRenderTargetView = NULL;
-}
-
-SDepthStencilView::SDepthStencilView()
-{
-    pDepthStencilView = NULL;
-}
-
-void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, UINT  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:
-            D3DXASSERT(0);
-            return NULL;
-        }
-    default:
-        D3DXASSERT(0);
-        return NULL;
-    }
-}
-
-CEffect::CEffect( UINT Flags )
-{
-    m_RefCount = 1;
-
-    m_pVariables = NULL;
-    m_pAnonymousShaders = NULL;
-    m_pGroups = NULL;
-    m_pNullGroup = NULL;
-    m_pShaderBlocks = NULL;
-    m_pDepthStencilBlocks = NULL;
-    m_pBlendBlocks = NULL;
-    m_pRasterizerBlocks = NULL;
-    m_pSamplerBlocks = NULL;
-    m_pCBs = NULL;
-    m_pStrings = NULL;
-    m_pMemberDataBlocks = NULL;
-    m_pInterfaces = NULL;
-    m_pShaderResources = NULL;
-    m_pUnorderedAccessViews = NULL;
-    m_pRenderTargetViews = NULL;
-    m_pDepthStencilViews = NULL;
-    m_pDevice = NULL;
-    m_pClassLinkage = NULL;
-    m_pContext = NULL;
-
-    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 = NULL;
-    m_LocalTimer = 1;
-    m_Flags = Flags;
-    m_FXLIndex = 0;
-
-    m_pTypePool = NULL;
-    m_pStringPool = NULL;
-    m_pPooledHeap = NULL;
-    m_pOptimizedTypeHeap = NULL;
-}
-
-void CEffect::ReleaseShaderRefection()
-{
-    for( UINT 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 = NULL;
-
-    // Mute debug spew
-    if (m_pDevice)
-        m_pDevice->QueryInterface(__uuidof(ID3D11InfoQueue), (void**) &pInfoQueue);
-
-    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);
-    }
-
-    UINT  i;
-
-    if( NULL != m_pDevice )
-    {
-        // if m_pDevice == NULL, 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 (NULL != m_pDevice)
-    {
-        // Keep the following in line with AddRefAllForCloning
-
-        D3DXASSERT(NULL == m_pRasterizerBlocks || m_Heap.IsInHeap(m_pRasterizerBlocks));
-        for (i = 0; i < m_RasterizerBlockCount; ++ i)
-        {
-            SAFE_RELEASE(m_pRasterizerBlocks[i].pRasterizerObject);
-        }
-
-        D3DXASSERT(NULL == m_pBlendBlocks || m_Heap.IsInHeap(m_pBlendBlocks));
-        for (i = 0; i < m_BlendBlockCount; ++ i)
-        {
-            SAFE_RELEASE(m_pBlendBlocks[i].pBlendObject);
-        }
-
-        D3DXASSERT(NULL == m_pDepthStencilBlocks || m_Heap.IsInHeap(m_pDepthStencilBlocks));
-        for (i = 0; i < m_DepthStencilBlockCount; ++ i)
-        {
-            SAFE_RELEASE(m_pDepthStencilBlocks[i].pDSObject);
-        }
-
-        D3DXASSERT(NULL == m_pSamplerBlocks || m_Heap.IsInHeap(m_pSamplerBlocks));
-        for (i = 0; i < m_SamplerBlockCount; ++ i)
-        {
-            SAFE_RELEASE(m_pSamplerBlocks[i].pD3DObject);
-        }
-
-        D3DXASSERT(NULL == m_pShaderResources || m_Heap.IsInHeap(m_pShaderResources));
-        for (i = 0; i < m_ShaderResourceCount; ++ i)
-        {
-            SAFE_RELEASE(m_pShaderResources[i].pShaderResource);
-        }
-
-        D3DXASSERT(NULL == m_pUnorderedAccessViews || m_Heap.IsInHeap(m_pUnorderedAccessViews));
-        for (i = 0; i < m_UnorderedAccessViewCount; ++ i)
-        {
-            SAFE_RELEASE(m_pUnorderedAccessViews[i].pUnorderedAccessView);
-        }
-
-        D3DXASSERT(NULL == m_pRenderTargetViews || m_Heap.IsInHeap(m_pRenderTargetViews));
-        for (i = 0; i < m_RenderTargetViewCount; ++ i)
-        {
-            SAFE_RELEASE(m_pRenderTargetViews[i].pRenderTargetView);
-        }
-
-        D3DXASSERT(NULL == m_pDepthStencilViews || m_Heap.IsInHeap(m_pDepthStencilViews));
-        for (i = 0; i < m_DepthStencilViewCount; ++ i)
-        {
-            SAFE_RELEASE(m_pDepthStencilViews[i].pDepthStencilView);
-        }
-
-        D3DXASSERT(NULL == m_pMemberDataBlocks || m_Heap.IsInHeap(m_pMemberDataBlocks));
-        for (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:
-                D3DXASSERT( false );
-            }
-        }
-
-        D3DXASSERT(NULL == m_pCBs || m_Heap.IsInHeap(m_pCBs));
-        for (i = 0; i < m_CBCount; ++ i)
-        {
-            SAFE_RELEASE(m_pCBs[i].TBuffer.pShaderResource);
-            SAFE_RELEASE(m_pCBs[i].pD3DObject);
-        }
-
-        D3DXASSERT(NULL == m_pShaderBlocks || m_Heap.IsInHeap(m_pShaderBlocks));
-        for (i = 0; i < m_ShaderBlockCount; ++ i)
-        {
-            SAFE_RELEASE(m_pShaderBlocks[i].pD3DObject);
-        }
-
-        SAFE_RELEASE( m_pDevice );
-    }
-    SAFE_RELEASE( m_pClassLinkage );
-    D3DXASSERT( m_pContext == NULL );
-
-    // Restore debug spew
-    if (pInfoQueue)
-    {
-        pInfoQueue->PopStorageFilter();
-        SAFE_RELEASE(pInfoQueue);
-    }
-}
-
-// AddRef all D3D object when cloning
-void CEffect::AddRefAllForCloning( CEffect* pEffectSource )
-{
-    UINT  i;
-
-    // Keep the following in line with ~CEffect
-
-    D3DXASSERT( m_pDevice != NULL );
-
-    for( UINT i = 0; i < m_ShaderBlockCount; ++ i )
-    {
-        SAFE_ADDREF( m_pShaderBlocks[i].pInputSignatureBlob );
-        if( m_pShaderBlocks[i].pReflectionData )
-        {
-            SAFE_ADDREF( m_pShaderBlocks[i].pReflectionData->pReflection );
-        }
-    }
-
-    D3DXASSERT(NULL == m_pRasterizerBlocks || pEffectSource->m_Heap.IsInHeap(m_pRasterizerBlocks));
-    for (i = 0; i < m_RasterizerBlockCount; ++ i)
-    {
-        SAFE_ADDREF(m_pRasterizerBlocks[i].pRasterizerObject);
-    }
-
-    D3DXASSERT(NULL == m_pBlendBlocks || pEffectSource->m_Heap.IsInHeap(m_pBlendBlocks));
-    for (i = 0; i < m_BlendBlockCount; ++ i)
-    {
-        SAFE_ADDREF(m_pBlendBlocks[i].pBlendObject);
-    }
-
-    D3DXASSERT(NULL == m_pDepthStencilBlocks || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilBlocks));
-    for (i = 0; i < m_DepthStencilBlockCount; ++ i)
-    {
-        SAFE_ADDREF(m_pDepthStencilBlocks[i].pDSObject);
-    }
-
-    D3DXASSERT(NULL == m_pSamplerBlocks || pEffectSource->m_Heap.IsInHeap(m_pSamplerBlocks));
-    for (i = 0; i < m_SamplerBlockCount; ++ i)
-    {
-        SAFE_ADDREF(m_pSamplerBlocks[i].pD3DObject);
-    }
-
-    D3DXASSERT(NULL == m_pShaderResources || pEffectSource->m_Heap.IsInHeap(m_pShaderResources));
-    for (i = 0; i < m_ShaderResourceCount; ++ i)
-    {
-        SAFE_ADDREF(m_pShaderResources[i].pShaderResource);
-    }
-
-    D3DXASSERT(NULL == m_pUnorderedAccessViews || pEffectSource->m_Heap.IsInHeap(m_pUnorderedAccessViews));
-    for (i = 0; i < m_UnorderedAccessViewCount; ++ i)
-    {
-        SAFE_ADDREF(m_pUnorderedAccessViews[i].pUnorderedAccessView);
-    }
-
-    D3DXASSERT(NULL == m_pRenderTargetViews || pEffectSource->m_Heap.IsInHeap(m_pRenderTargetViews));
-    for (i = 0; i < m_RenderTargetViewCount; ++ i)
-    {
-        SAFE_ADDREF(m_pRenderTargetViews[i].pRenderTargetView);
-    }
-
-    D3DXASSERT(NULL == m_pDepthStencilViews || pEffectSource->m_Heap.IsInHeap(m_pDepthStencilViews));
-    for (i = 0; i < m_DepthStencilViewCount; ++ i)
-    {
-        SAFE_ADDREF(m_pDepthStencilViews[i].pDepthStencilView);
-    }
-
-    D3DXASSERT(NULL == m_pMemberDataBlocks || pEffectSource->m_Heap.IsInHeap(m_pMemberDataBlocks));
-    for (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:
-            D3DXASSERT( false );
-        }
-    }
-
-    // There's no need to AddRef CBs, since they are recreated
-    D3DXASSERT(NULL == m_pCBs || pEffectSource->m_Heap.IsInHeap(m_pCBs));
-    for (i = 0; i < m_CBCount; ++ i)
-    {
-        SAFE_ADDREF(m_pCBs[i].TBuffer.pShaderResource);
-        SAFE_ADDREF(m_pCBs[i].pD3DObject);
-    }
-
-    D3DXASSERT(NULL == m_pShaderBlocks || pEffectSource->m_Heap.IsInHeap(m_pShaderBlocks));
-    for (i = 0; i < m_ShaderBlockCount; ++ i)
-    {
-        SAFE_ADDREF(m_pShaderBlocks[i].pD3DObject);
-    }
-
-    SAFE_ADDREF( m_pDevice );
-
-    SAFE_ADDREF( m_pClassLinkage );
-    D3DXASSERT( m_pContext == NULL );
-}
-
-HRESULT CEffect::QueryInterface(REFIID iid, LPVOID *ppv)
-{
-    HRESULT hr = S_OK;
-
-    if(NULL == ppv)
-    {
-        DPF(0, "ID3DX11Effect::QueryInterface: NULL parameter");
-        hr = E_INVALIDARG;
-        goto EXIT;
-    }
-
-    *ppv = NULL;
-    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
-void CEffect::ReplaceCBReference(SConstantBuffer *pOldBufferBlock, ID3D11Buffer *pNewBuffer)
-{
-    UINT iShaderBlock;
-
-    for (iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)
-    {
-        for (UINT iCBDep = 0; iCBDep < m_pShaderBlocks[iShaderBlock].CBDepCount; iCBDep++)
-        {
-            for (UINT 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
-void CEffect::ReplaceSamplerReference(SSamplerBlock *pOldSamplerBlock, ID3D11SamplerState *pNewSampler)
-{
-    UINT iShaderBlock;
-
-    for (iShaderBlock=0; iShaderBlock<m_ShaderBlockCount; iShaderBlock++)
-    {
-        for (UINT iSamplerDep = 0; iSamplerDep < m_pShaderBlocks[iShaderBlock].SampDepCount; iSamplerDep++)
-        {
-            for (UINT 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
-HRESULT CEffect::BindToDevice(ID3D11Device *pDevice)
-{
-    HRESULT hr = S_OK;
-
-    // Set new device
-    if (pDevice == NULL)
-    {
-        DPF(0, "ID3DX11Effect: pDevice must point to a valid D3D11 device");
-        return D3DERR_INVALIDCALL;
-    }
-
-    if (m_pDevice != NULL)
-    {
-        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 ) );
-
-    // 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, NULL, &pCB->pD3DObject) );
-                
-                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) );
-            }
-            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, NULL, &pCB->pD3DObject) );
-                pCB->TBuffer.pShaderResource = NULL;
-            }
-
-            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;
-        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;
-        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;
-        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) );
-    }
-
-    // Create all shaders
-    ID3D11ClassLinkage* neededClassLinkage = featureLevelGE11 ? m_pClassLinkage : NULL;
-    SShaderBlock *pShader = m_pShaderBlocks;
-    SShaderBlock *pShaderLast = m_pShaderBlocks + m_ShaderBlockCount;
-    for(; pShader != pShaderLast; pShader++)
-    {
-        SAFE_RELEASE(pShader->pD3DObject);
-
-        if (NULL == pShader->pReflectionData)
-        {
-            // NULL shader. It's one of these:
-            // PixelShader ps;
-            // or
-            // SetPixelShader( NULL );
-            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) );
-            UINT strides[4];
-            soParser.GetStrides( strides );
-            hr = m_pDevice->CreateGeometryShaderWithStreamOutput((UINT*) pShader->pReflectionData->pBytecode,
-                                                                pShader->pReflectionData->BytecodeLength,
-                                                                soParser.GetDeclArray(),
-                                                                soParser.GetDeclCount(),
-                                                                strides,
-                                                                featureLevelGE11 ? 4 : 1,
-                                                                pShader->pReflectionData->RasterizedStream,
-                                                                neededClassLinkage,
-                                                                (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
-        {
-            // 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))( (UINT *) pShader->pReflectionData->pBytecode, pShader->pReflectionData->BytecodeLength, neededClassLinkage, &pShader->pD3DObject) ) )
-                {
-                    DPF(1, "ID3DX11Effect::Load - failed to create shader" );
-                    pShader->IsValid = FALSE;
-                }
-            }
-        }
-
-        // Update all dependency pointers
-        VH( pShader->OnDeviceBind() );
-    }
-
-    // Initialize the member data pointers for all variables
-    UINT CurMemberData = 0;
-    for (UINT i = 0; i < m_VariableCount; ++ i)
-    {
-        if( m_pVariables[i].pMemberData )
-        {
-            if( m_pVariables[i].pType->IsClassInstance() )
-            {
-                for (UINT j = 0; j < max(m_pVariables[i].pType->Elements,1); ++j)
-                {
-                    D3DXASSERT( 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 = NULL;
-                    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");
-                        }
-                    }
-                    CurMemberData++;
-                }
-            }
-            else if( m_pVariables[i].pType->IsStateBlockObject() )
-            {
-                for (UINT j = 0; j < max(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 = NULL;
-                        break;
-                    case EOT_Rasterizer:
-                        (m_pVariables[i].pMemberData + j)->Type = MDT_RasterizerState;
-                        (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedRasterizerState = NULL;
-                        break;
-                    case EOT_DepthStencil:
-                        (m_pVariables[i].pMemberData + j)->Type = MDT_DepthStencilState;
-                        (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedDepthStencilState = NULL;
-                        break;
-                    case EOT_Sampler:
-                        (m_pVariables[i].pMemberData + j)->Type = MDT_SamplerState;
-                        (m_pVariables[i].pMemberData + j)->Data.pD3DEffectsManagedSamplerState = NULL;
-                        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 = NULL;
-        CurMemberData++;
-        (pCB->pMemberData + 1)->Type = MDT_ShaderResourceView;
-        (pCB->pMemberData + 1)->Data.pD3DEffectsManagedTextureBuffer = NULL;
-        CurMemberData++;
-    }
-
-
-    // Determine which techniques and passes are known to be invalid
-    for( UINT iGroup=0; iGroup < m_GroupCount; iGroup++ )
-    {
-        SGroup* pGroup = &m_pGroups[iGroup];
-        pGroup->InitiallyValid = TRUE;
-
-        for( UINT iTech=0; iTech < pGroup->TechniqueCount; iTech++ )
-        {
-            STechnique* pTechnique = &pGroup->pTechniques[iTech];
-            pTechnique->InitiallyValid = TRUE;
-           
-            for( UINT iPass = 0; iPass < pTechnique->PassCount; iPass++ )
-            {
-                SPassBlock* pPass = &pTechnique->pPasses[iPass];
-                pPass->InitiallyValid = TRUE;
-
-                if( pPass->BackingStore.pBlendBlock != NULL && !pPass->BackingStore.pBlendBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pDepthStencilBlock != NULL && !pPass->BackingStore.pDepthStencilBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pRasterizerBlock != NULL && !pPass->BackingStore.pRasterizerBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pVertexShaderBlock != NULL && !pPass->BackingStore.pVertexShaderBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pPixelShaderBlock != NULL && !pPass->BackingStore.pPixelShaderBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pGeometryShaderBlock != NULL && !pPass->BackingStore.pGeometryShaderBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pHullShaderBlock != NULL && !pPass->BackingStore.pHullShaderBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pDomainShaderBlock != NULL && !pPass->BackingStore.pDomainShaderBlock->IsValid )
-                    pPass->InitiallyValid = FALSE;
-                if( pPass->BackingStore.pComputeShaderBlock != NULL && !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(LPCSTR pName)
-{
-    SGlobalVariable *pVariable;
-    const UINT 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 = NULL;
-
-    while( *pSource != 0 )
-    {
-        if( pDest == pEnd )
-        {
-            pVariable = FindLocalVariableByName(pName);
-            if( pVariable == NULL )
-            {
-                DPF( 0, "Name %s is too long to parse", &pName );
-            }
-            return pVariable;
-        }
-
-        if( *pSource == '[' )
-        {
-            // parse previous variable name
-            *pDest = 0;
-            D3DXASSERT( pVariable == NULL );
-            pVariable = FindLocalVariableByName(pScratchString);
-            if( pVariable == NULL )
-            {
-                return NULL;
-            }
-            pDest = pScratchString;
-        }
-        else if( *pSource == ']' )
-        {
-            // parse integer
-            *pDest = 0;
-            UINT index = atoi(pScratchString);
-            D3DXASSERT( pVariable != NULL );
-            pVariable = (SGlobalVariable*)pVariable->GetElement(index);
-            if( pVariable && !pVariable->IsValid() )
-            {
-                pVariable = NULL;
-            }
-            return pVariable;
-        }
-        else
-        {
-            // add character
-            *pDest = *pSource;
-            pDest++;
-        }
-        pSource++;
-    }
-
-    if( pDest != pScratchString )
-    {
-        // parse the variable name (there was no [i])
-        *pDest = 0;
-        D3DXASSERT( pVariable == NULL );
-        pVariable = FindLocalVariableByName(pScratchString);
-    }
-
-    return pVariable;
-}
-
-SGlobalVariable * CEffect::FindVariableByName(LPCSTR pName)
-{
-    SGlobalVariable *pVariable;
-
-    pVariable = FindLocalVariableByName(pName);
-
-    return pVariable;
-}
-
-SGlobalVariable * CEffect::FindLocalVariableByName(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 NULL;
-}
-
-
-//
-// 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;
-            }
-            D3DXASSERT(StructType.pMembers != NULL && pOtherType->StructType.pMembers != NULL);
-
-            UINT  i;
-            for (i = 0; i < StructType.Members; ++ i)
-            {
-                // names for types must exist (not true for semantics)
-                D3DXASSERT(StructType.pMembers[i].pName != NULL && pOtherType->StructType.pMembers[i].pName != NULL);
-
-                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:
-        {
-            D3DXASSERT(0);
-            return FALSE;
-        }
-        break;
-    }
-
-    D3DXASSERT(TotalSize == pOtherType->TotalSize && Stride == pOtherType->Stride && PackedSize == pOtherType->PackedSize);
-
-    return TRUE;
-}
-
-UINT SType::GetTotalUnpackedSize(BOOL IsSingleElement) CONST
-{
-    if (VarType == EVT_Object)
-    {
-        return 0;
-    }
-    else if (VarType == EVT_Interface)
-    {
-        return 0;
-    }
-    else if (Elements > 0 && IsSingleElement)
-    {
-        D3DXASSERT( ( TotalSize == 0 && Stride == 0 ) ||
-                    ( (TotalSize > (Stride * (Elements - 1))) && (TotalSize <= (Stride * Elements)) ) );
-        return TotalSize - Stride * (Elements - 1);
-    }
-    else
-    {
-        return TotalSize;
-    }
-}
-
-UINT SType::GetTotalPackedSize(BOOL IsSingleElement) CONST
-{
-    if (Elements > 0 && IsSingleElement)
-    {
-        D3DXASSERT(PackedSize % Elements == 0);
-        return PackedSize / Elements;
-    }
-    else
-    {
-        return PackedSize;
-    }
-}
-
-SConstantBuffer *CEffect::FindCB(LPCSTR pName)
-{
-    UINT  i;
-
-    for (i=0; i<m_CBCount; i++)
-    {
-        if (!strcmp(m_pCBs[i].pName, pName))
-        {
-            return &m_pCBs[i];
-        }
-    }
-
-    return NULL;
-}
-
-inline UINT  PtrToDword(void *pPtr)
-{
-    return (UINT)(UINT_PTR) pPtr;
-}
-
-BOOL CEffect::IsOptimized()
-{
-    if ((m_Flags & D3DX11_EFFECT_OPTIMIZED) != 0)
-    {
-        D3DXASSERT(NULL == m_pReflection);
-        return TRUE;
-    }
-    else
-    {
-        D3DXASSERT(NULL != 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(SType **ppType, 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, 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( CEffect* pEffectSource )
-{
-    HRESULT hr = S_OK;
-    UINT i; // after a failure, this holds the failing index
-
-    UINT Members = pEffectSource->m_pMemberInterfaces.GetSize();
-    m_pMemberInterfaces.AddRange(Members);
-    for( i=0; i < Members; i++ )
-    {
-        SMember* pOldMember = pEffectSource->m_pMemberInterfaces[i];
-        if( pOldMember == NULL )
-        {
-            // During Optimization, m_pMemberInterfaces[i] was set to NULL because it was an annotation
-            m_pMemberInterfaces[i] = NULL;
-            continue;
-        }
-
-        SMember *pNewMember;
-        D3DXASSERT( pOldMember->pTopLevelEntity != NULL );
-
-        if (NULL == (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) )
-    {
-        D3DXASSERT( 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
-HRESULT CEffect::CopyStringPool( CEffect* pEffectSource, CPointerMappingTable& mappingTable )
-{
-    HRESULT hr = S_OK;
-    D3DXASSERT( m_pPooledHeap != NULL );
-    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;
-        UINT len = (UINT)strlen(pOldString);
-        UINT 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.
-HRESULT CEffect::CopyTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes, CPointerMappingTable& mappingTableStrings )
-{
-    HRESULT hr = S_OK;
-    D3DXASSERT( m_pPooledHeap != NULL );
-    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();
-        UINT 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 (UINT 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.
-HRESULT CEffect::CopyOptimizedTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes )
-{
-    HRESULT hr = S_OK;
-    CEffectHeap* pOptimizedTypeHeap = NULL;
-
-    D3DXASSERT( pEffectSource->m_pOptimizedTypeHeap != NULL );
-    D3DXASSERT( m_pTypePool == NULL );
-    D3DXASSERT( m_pStringPool == NULL );
-    D3DXASSERT( m_pPooledHeap == NULL );
-
-    VN( pOptimizedTypeHeap = NEW CEffectHeap );
-    VH( pOptimizedTypeHeap->ReserveMemory( pEffectSource->m_pOptimizedTypeHeap->GetSize() ) );
-    CPointerMappingTable::CIterator mapIter;
-
-    // first pass: move types over, build mapping table
-    BYTE* pReadTypes = pEffectSource->m_pOptimizedTypeHeap->GetDataStart();
-    while( pEffectSource->m_pOptimizedTypeHeap->IsInHeap( pReadTypes ) )
-    {
-        SPointerMapping ptrMapping;
-        SType *pType;
-        UINT 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 (UINT 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;
-    UINT 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 = NULL;
-            VH( m_pDevice->CreateBuffer( &bufDesc, NULL, &pNewBuffer ) );
-            (*ppOriginalBuffer)->Release();
-            (*ppOriginalBuffer) = pNewBuffer;
-            pNewBuffer = NULL;
-
-            if( pCB->IsTBuffer )
-            {
-                VN( *ppOriginalTBufferView );
-                D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
-                (*ppOriginalTBufferView)->GetDesc( &viewDesc );
-                ID3D11ShaderResourceView* pNewView = NULL;
-                VH( m_pDevice->CreateShaderResourceView( (*ppOriginalBuffer), &viewDesc, &pNewView) );
-                (*ppOriginalTBufferView)->Release();
-                (*ppOriginalTBufferView) = pNewView;
-                pNewView = NULL;
-            }
-            else
-            {
-                D3DXASSERT( *ppOriginalTBufferView == NULL );
-                ReplaceCBReference( pCB, (*ppOriginalBuffer) );
-            }
-
-            pCB->IsDirty = TRUE;
-        }
-    }
-
-lExit:
-    return hr;
-}
-
-// Move Name and Semantic strings using mappingTableStrings
-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(UINT Flags, ID3DX11Effect** ppClonedEffect )
-{
-    HRESULT hr = S_OK;
-    CPointerMappingTable mappingTableTypes;
-    CPointerMappingTable mappingTableStrings;
-
-    CEffectLoader loader;
-    CEffect* pNewEffect = NULL;    
-    CDataBlockStore* pTempHeap = NULL;
-
-
-    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 &= ~(UINT)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 (UINT 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(CPointerMappingTable *pMappingTable, bool Cloning)
-{
-    HRESULT hr = S_OK;
-    UINT  i;
-
-    // find all child types, point them to the new location
-    for (i = 0; i < m_VariableCount; ++ i)
-    {
-        VH( RemapType((SType**)&m_pVariables[i].pType, pMappingTable) );
-    }
-
-    UINT Members = m_pMemberInterfaces.GetSize();
-    for( i=0; i < Members; i++ )
-    {
-        if( m_pMemberInterfaces[i] != NULL )
-        {
-            VH( RemapType((SType**)&m_pMemberInterfaces[i]->pType, pMappingTable) );
-        }
-    }
-
-    // when cloning, there may be annotations
-    if( Cloning )
-    {
-        for (UINT iVar = 0; iVar < m_VariableCount; ++ iVar)
-        {
-            for(i = 0; i < m_pVariables[iVar].AnnotationCount; ++ i )
-            {
-                VH( RemapType((SType**)&m_pVariables[iVar].pAnnotations[i].pType, pMappingTable) );
-            }
-        }
-        for (UINT iCB = 0; iCB < m_CBCount; ++ iCB)
-        {
-            for(i = 0; i < m_pCBs[iCB].AnnotationCount; ++ i )
-            {
-                VH( RemapType((SType**)&m_pCBs[iCB].pAnnotations[i].pType, pMappingTable) );
-            }
-        }
-        for (UINT iGroup = 0; iGroup < m_GroupCount; ++ iGroup)
-        {
-            for(i = 0; i < m_pGroups[iGroup].AnnotationCount; ++ i )
-            {
-                VH( RemapType((SType**)&m_pGroups[iGroup].pAnnotations[i].pType, pMappingTable) );
-            }
-            for(UINT iTech = 0; iTech < m_pGroups[iGroup].TechniqueCount; ++ iTech )
-            {
-                for(i = 0; i < m_pGroups[iGroup].pTechniques[iTech].AnnotationCount; ++ i )
-                {
-                    VH( RemapType((SType**)&m_pGroups[iGroup].pTechniques[iTech].pAnnotations[i].pType, pMappingTable) );
-                }
-                for(UINT iPass = 0; iPass < m_pGroups[iGroup].pTechniques[iTech].PassCount; ++ iPass )
-                {
-                    for(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;
-    UINT  i, j, k;
-    CEffectHeap *pOptimizedTypeHeap = NULL;
-    
-    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 (i = 0; i < m_VariableCount; ++ i)
-    {
-        m_pVariables[i].AnnotationCount = 0;
-        m_pVariables[i].pAnnotations = NULL;
-        m_pVariables[i].pName = NULL;
-        m_pVariables[i].pSemantic = NULL;
-
-        // 2) Point string variables to NULL
-        if (m_pVariables[i].pType->IsObjectType(EOT_String))
-        {
-            D3DXASSERT(NULL != m_pVariables[i].Data.pString);
-            m_pVariables[i].Data.pString = NULL;
-        }
-    }
-
-    // Delete annotations and names on CBs
-
-    for (i = 0; i < m_CBCount; ++ i)
-    {
-        m_pCBs[i].AnnotationCount = 0;
-        m_pCBs[i].pAnnotations = NULL;
-        m_pCBs[i].pName = NULL;
-        m_pCBs[i].IsEffectOptimized = TRUE;
-    }
-
-    // Delete annotations and names on techniques and passes
-
-    for (i = 0; i < m_GroupCount; ++ i)
-    {
-        m_pGroups[i].AnnotationCount = 0;
-        m_pGroups[i].pAnnotations = NULL;
-        m_pGroups[i].pName = NULL;
-
-        for (j = 0; j < m_pGroups[i].TechniqueCount; ++ j)
-        {
-            m_pGroups[i].pTechniques[j].AnnotationCount = 0;
-            m_pGroups[i].pTechniques[j].pAnnotations = NULL;
-            m_pGroups[i].pTechniques[j].pName = NULL;
-
-            for (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 = NULL;
-                m_pGroups[i].pTechniques[j].pPasses[k].pName = NULL;
-            }
-        }
-    };
-
-    // 2) Remove shader bytecode & stream out decls
-    //    (all are contained within pReflectionData)
-
-    for (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 = NULL;
-        }
-    }
-
-    UINT Members = m_pMemberInterfaces.GetSize();
-    for( i=0; i < Members; i++ )
-    {
-        D3DXASSERT( m_pMemberInterfaces[i] != NULL );
-        if( IsReflectionData(m_pMemberInterfaces[i]->pTopLevelEntity) )
-        {
-            D3DXASSERT( IsReflectionData(m_pMemberInterfaces[i]->Data.pGeneric) );
-
-            // This is checked when cloning (so we don't clone Optimized-out member variables)
-            m_pMemberInterfaces[i] = NULL;
-        }
-        else
-        {
-            m_pMemberInterfaces[i]->pName = NULL;
-            m_pMemberInterfaces[i]->pSemantic = NULL;
-        }
-    }
-
-
-
-    // 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;
-    UINT  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) );
-
-    D3DXASSERT(NULL == 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 = NULL;
-
-        // if this is a struct, fix up its members' pointers
-        if (EVT_Struct == pType->VarType)
-        {
-            for (i = 0; i < pType->StructType.Members; ++ i)
-            {
-                VH( RemapType((SType**)&pType->StructType.pMembers[i].pType, &mappingTable) );
-                pType->StructType.pMembers[i].pName = NULL;
-                pType->StructType.pMembers[i].pSemantic = NULL;
-            }
-        }
-    }        
-
-    // fixup this effect's variable's types
-    VH( OptimizeTypes(&mappingTable) );
-
-    m_pOptimizedTypeHeap = pOptimizedTypeHeap;
-    pOptimizedTypeHeap = NULL;
-
-#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: %d 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(SType *pType, BOOL IsAnnotation)
-{
-    switch (pType->VarType)
-    {
-    case EVT_Struct:
-        if (IsAnnotation)
-        {
-            D3DXASSERT(sizeof(SNumericAnnotationMember) == sizeof(SMember));
-            return (SMember*) NEW SNumericAnnotationMember;
-        }
-        else if (pType->StructType.ImplementsInterface)
-        {
-            D3DXASSERT(sizeof(SClassInstanceGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SClassInstanceGlobalVariableMember;
-        }
-        else
-        {
-            D3DXASSERT(sizeof(SNumericGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SNumericGlobalVariableMember;
-        }
-        break;
-    case EVT_Interface:
-        D3DXASSERT(sizeof(SInterfaceGlobalVariableMember) == sizeof(SMember));
-        return (SMember*) NEW SInterfaceGlobalVariableMember;
-        break;
-    case EVT_Object:
-        switch (pType->ObjectType)
-        {
-        case EOT_String:
-            if (IsAnnotation)
-            {
-                D3DXASSERT(sizeof(SStringAnnotationMember) == sizeof(SMember));
-                return (SMember*) NEW SStringAnnotationMember;
-            }
-            else
-            {
-                D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SShaderGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SShaderGlobalVariableMember;
-            break;
-        case EOT_Blend:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SBlendGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SBlendGlobalVariableMember;
-            break;
-        case EOT_Rasterizer:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SRasterizerGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SRasterizerGlobalVariableMember;
-            break;
-        case EOT_DepthStencil:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SDepthStencilGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SDepthStencilGlobalVariableMember;
-            break;
-        case EOT_Sampler:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SSamplerGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SSamplerGlobalVariableMember;
-            break;
-        case EOT_DepthStencilView:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SDepthStencilViewGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SDepthStencilViewGlobalVariableMember;
-            break;
-        case EOT_RenderTargetView:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SRenderTargetViewGlobalVariableMember) == sizeof(SMember));
-            return (SMember*) NEW SRenderTargetViewGlobalVariableMember;
-            break;
-        default:
-            D3DXASSERT(0);
-            DPF( 0, "Internal error: invalid object type." );
-            return NULL;
-            break;
-        }
-        break;
-    case EVT_Numeric:
-        switch (pType->NumericType.NumericLayout)
-        {
-        case ENL_Matrix:
-            if (IsAnnotation)
-            {
-                D3DXASSERT(sizeof(SMatrixAnnotationMember) == sizeof(SMember));
-                return (SMember*) NEW SMatrixAnnotationMember;
-            }
-            else
-            {
-                D3DXASSERT(sizeof(SMatrixGlobalVariableMember) == sizeof(SMember));
-                D3DXASSERT(sizeof(SMatrix4x4ColumnMajorGlobalVariableMember) == sizeof(SMember));
-                D3DXASSERT(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)
-                {
-                    D3DXASSERT(sizeof(SFloatVectorAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SFloatVectorAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SFloatVectorGlobalVariableMember) == sizeof(SMember));
-                    D3DXASSERT(sizeof(SFloatVector4GlobalVariableMember) == sizeof(SMember));
-
-                    if (pType->NumericType.Columns == 4)
-                    {
-                        return (SMember*) NEW SFloatVector4GlobalVariableMember;
-                    }
-                    else
-                    {
-                        return (SMember*) NEW SFloatVectorGlobalVariableMember;
-                    }
-                }
-                break;
-            case EST_Bool:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SBoolVectorAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SBoolVectorAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SBoolVectorGlobalVariableMember) == sizeof(SMember));
-                    return (SMember*) NEW SBoolVectorGlobalVariableMember;
-                }
-                break;
-            case EST_UInt:
-            case EST_Int:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SIntVectorAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SIntVectorAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SIntVectorGlobalVariableMember) == sizeof(SMember));
-                    return (SMember*) NEW SIntVectorGlobalVariableMember;
-                }
-                break;
-            default:
-                D3DXASSERT(0);
-                DPF( 0, "Internal loading error: invalid vector type." );
-                break;
-            }
-            break;
-        case ENL_Scalar:
-            switch (pType->NumericType.ScalarType)
-            {
-            case EST_Float:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SFloatScalarAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SFloatScalarAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SFloatScalarGlobalVariableMember) == sizeof(SMember));
-                    return (SMember*) NEW SFloatScalarGlobalVariableMember;
-                }
-                break;
-            case EST_UInt:
-            case EST_Int:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SIntScalarAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SIntScalarAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SIntScalarGlobalVariableMember) == sizeof(SMember));
-                    return (SMember*) NEW SIntScalarGlobalVariableMember;
-                }
-                break;
-            case EST_Bool:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SBoolScalarAnnotationMember) == sizeof(SMember));
-                    return (SMember*) NEW SBoolScalarAnnotationMember;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SBoolScalarGlobalVariableMember) == sizeof(SMember));
-                    return (SMember*) NEW SBoolScalarGlobalVariableMember;
-                }
-                break;
-            default:
-                DPF( 0, "Internal loading error: invalid scalar type." );
-                D3DXASSERT(0);
-                break;
-            }            
-            break;
-        default:
-            D3DXASSERT(0);
-            DPF( 0, "Internal loading error: invalid numeric type." );
-            break;
-        }
-        break;
-    default:
-        D3DXASSERT(0);
-        DPF( 0, "Internal loading error: invalid variable type." );
-        break;
-    }
-    return NULL;
-}
-
-// Global variables are created in place because storage for them was allocated during LoadEffect
-HRESULT PlacementNewVariable(void *pVar, SType *pType, BOOL IsAnnotation)
-{
-    switch (pType->VarType)
-    {
-    case EVT_Struct:
-        if (IsAnnotation)
-        {
-            D3DXASSERT(sizeof(SNumericAnnotation) == sizeof(SAnnotation));
-            new(pVar) SNumericAnnotation();
-        }
-        else if (pType->StructType.ImplementsInterface)
-        {
-            D3DXASSERT(sizeof(SClassInstanceGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SClassInstanceGlobalVariable;
-        }
-        else 
-        {
-            D3DXASSERT(sizeof(SNumericGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SNumericGlobalVariable;
-        }
-        break;
-    case EVT_Interface:
-        D3DXASSERT(sizeof(SInterfaceGlobalVariable) == sizeof(SGlobalVariable));
-        new(pVar) SInterfaceGlobalVariable;
-        break;
-    case EVT_Object:
-        switch (pType->ObjectType)
-        {
-        case EOT_String:
-            if (IsAnnotation)
-            {
-                D3DXASSERT(sizeof(SStringAnnotation) == sizeof(SAnnotation));
-                new(pVar) SStringAnnotation;
-            }
-            else
-            {
-                D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(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:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SShaderGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SShaderGlobalVariable;
-            break;
-        case EOT_Blend:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SBlendGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SBlendGlobalVariable;
-            break;
-        case EOT_Rasterizer:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SRasterizerGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SRasterizerGlobalVariable;
-            break;
-        case EOT_DepthStencil:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SDepthStencilGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SDepthStencilGlobalVariable;
-            break;
-        case EOT_Sampler:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SSamplerGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SSamplerGlobalVariable;
-            break;
-        case EOT_RenderTargetView:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SRenderTargetViewGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SRenderTargetViewGlobalVariable;
-            break;
-        case EOT_DepthStencilView:
-            D3DXASSERT(!IsAnnotation);
-            D3DXASSERT(sizeof(SDepthStencilViewGlobalVariable) == sizeof(SGlobalVariable));
-            new(pVar) SDepthStencilViewGlobalVariable;
-            break;
-        default:
-            D3DXASSERT(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)
-            {
-                D3DXASSERT(sizeof(SMatrixAnnotation) == sizeof(SAnnotation));
-                new(pVar) SMatrixAnnotation;
-            }
-            else
-            {
-                D3DXASSERT(sizeof(SMatrixGlobalVariable) == sizeof(SGlobalVariable));
-                D3DXASSERT(sizeof(SMatrix4x4ColumnMajorGlobalVariable) == sizeof(SGlobalVariable));
-                D3DXASSERT(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)
-                {
-                    D3DXASSERT(sizeof(SFloatVectorAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SFloatVectorAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SFloatVectorGlobalVariable) == sizeof(SGlobalVariable));
-                    D3DXASSERT(sizeof(SFloatVector4GlobalVariable) == sizeof(SGlobalVariable));
-
-                    if (pType->NumericType.Columns == 4)
-                    {
-                        new(pVar) SFloatVector4GlobalVariable;
-                    }
-                    else
-                    {
-                        new(pVar) SFloatVectorGlobalVariable;
-                    }
-                }
-                break;
-            case EST_Bool:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SBoolVectorAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SBoolVectorAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SBoolVectorGlobalVariable) == sizeof(SGlobalVariable));
-                    new(pVar) SBoolVectorGlobalVariable;
-                }
-                break;
-            case EST_UInt:
-            case EST_Int:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SIntVectorAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SIntVectorAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SIntVectorGlobalVariable) == sizeof(SGlobalVariable));
-                    new(pVar) SIntVectorGlobalVariable;
-                }
-                break;
-            }
-            break;
-        case ENL_Scalar:
-            switch (pType->NumericType.ScalarType)
-            {
-            case EST_Float:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SFloatScalarAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SFloatScalarAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SFloatScalarGlobalVariable) == sizeof(SGlobalVariable));
-                    new(pVar) SFloatScalarGlobalVariable;
-                }
-                break;
-            case EST_UInt:
-            case EST_Int:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SIntScalarAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SIntScalarAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SIntScalarGlobalVariable) == sizeof(SGlobalVariable));
-                    new(pVar) SIntScalarGlobalVariable;
-                }
-                break;
-            case EST_Bool:
-                if (IsAnnotation)
-                {
-                    D3DXASSERT(sizeof(SBoolScalarAnnotation) == sizeof(SAnnotation));
-                    new(pVar) SBoolScalarAnnotation;
-                }
-                else
-                {
-                    D3DXASSERT(sizeof(SBoolScalarGlobalVariable) == sizeof(SGlobalVariable));
-                    new(pVar) SBoolScalarGlobalVariable;
-                }
-                break;
-            default:
-                D3DXASSERT(0);
-                DPF( 0, "Internal loading error: invalid scalar type." );
-                return E_FAIL;
-                break;
-            }            
-            break;
-        default:
-            D3DXASSERT(0);
-            DPF( 0, "Internal loading error: invalid numeric type." );
-            return E_FAIL;
-            break;
-        }
-        break;
-    default:
-        D3DXASSERT(0);
-        DPF( 0, "Internal loading error: invalid variable type." );
-        return E_FAIL;
-        break;
-    }
-    return S_OK;
-}
-
-}
diff --git a/sample/d3d11/Effects11/EffectReflection.cpp b/sample/d3d11/Effects11/EffectReflection.cpp
deleted file mode 100644
index 138447b..0000000
--- a/sample/d3d11/Effects11/EffectReflection.cpp
+++ /dev/null
@@ -1,2151 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectReflection.cpp
-//  Content:    D3DX11 Effects public reflection APIs
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#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;
-}
-
-ID3DX11EffectVariable * GetAnnotationByIndexHelper(const char *pClassName, UINT  Index, UINT  AnnotationCount, SAnnotation *pAnnotations)
-{
-    if (Index >= AnnotationCount)
-    {
-        DPF(0, "%s::GetAnnotationByIndex: Invalid index (%d, total: %d)", pClassName, Index, AnnotationCount);
-        return &g_InvalidScalarVariable;
-    }
-
-    return pAnnotations + Index;
-}
-
-ID3DX11EffectVariable * GetAnnotationByNameHelper(const char *pClassName, LPCSTR Name, UINT  AnnotationCount, SAnnotation *pAnnotations)
-{
-    UINT  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(SType *pType)
-{
-    UINT  i;
-
-    if (IsOptimized())
-    {
-        DPF(0, "ID3DX11Effect: Cannot create new type interfaces since the effect has been Optimize()'ed");
-        return &g_InvalidType;
-    }
-
-    for (i = 0; i < m_pTypeInterfaces.GetSize(); ++ i)
-    {
-        if (m_pTypeInterfaces[i]->pType == pType)
-        {
-            return (SSingleElementType*)m_pTypeInterfaces[i];
-        }
-    }
-    SSingleElementType *pNewType;
-    if (NULL == (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)
-ID3DX11EffectVariable * CEffect::CreatePooledVariableMemberInterface(TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity, SVariable *pMember, UDataPointer Data, BOOL IsSingleElement, UINT Index)
-{
-    BOOL IsAnnotation;
-    UINT  i;
-
-    if (IsOptimized())
-    {
-        DPF(0, "ID3DX11Effect: Cannot create new variable interfaces since the effect has been Optimize()'ed");
-        return &g_InvalidScalarVariable;
-    }
-
-    for (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 == IsSingleElement &&
-            ((SMember*)m_pMemberInterfaces[i])->pTopLevelEntity == pTopLevelEntity)
-        {
-            return (ID3DX11EffectVariable *) m_pMemberInterfaces[i];
-        }
-    }
-
-    // is this annotation or runtime data?
-    if( pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity) )
-    {
-        D3DXASSERT( 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 )
-        {
-            D3DXASSERT( pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity) );
-            if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
-            {
-                // strings are funny; their data is reflection data, so ignore those
-                D3DXASSERT( pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric) );
-            }
-        }
-        IsAnnotation = FALSE;
-    }
-
-    SMember *pNewMember;
-
-    if (NULL == (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 )
-    {
-        D3DXASSERT( !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(UINT Index, UINT  VariableCount, 
-                                               SVariable *pVariables, UINT  SizeOfVariableType)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByIndex";
-
-    if (Index >= VariableCount)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);
-        return &g_InvalidType;
-    }
-
-    SVariable *pVariable = (SVariable *)((BYTE *)pVariables + Index * SizeOfVariableType);
-    if (NULL == 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, UINT  VariableCount, 
-                                              SVariable *pVariables, UINT  SizeOfVariableType)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeByName";
-
-    if (NULL == Name)
-    {
-        DPF(0, "%s: Parameter Name was NULL.", pFuncName);
-        return &g_InvalidType;
-    }
-
-    UINT  i;
-    SVariable *pVariable;
-
-    for (i = 0; i < VariableCount; ++ i)
-    {
-        pVariable = (SVariable *)((BYTE *)pVariables + i * SizeOfVariableType);
-        if (NULL == 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, UINT  VariableCount, 
-                                                  SVariable *pVariables, UINT  SizeOfVariableType)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberTypeBySemantic";
-
-    if (NULL == Semantic)
-    {
-        DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);
-        return &g_InvalidType;
-    }
-
-    UINT  i;
-    SVariable *pVariable;
-
-    for (i = 0; i < VariableCount; ++ i)
-    {
-        pVariable = (SVariable *)((BYTE *)pVariables + i * SizeOfVariableType);
-        if (NULL == pVariable->pName)
-        {
-            DPF(0, "%s: Cannot get member types; Effect has been Optimize()'ed", pFuncName);
-            return &g_InvalidType;
-        }
-        if (NULL != 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(UINT 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(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(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(UINT Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";
-
-    if (VarType != EVT_Struct)
-    {
-        DPF(0, "%s: This interface does not refer to a structure", pFuncName);
-        return NULL;
-    }
-
-    if (Index >= StructType.Members)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, StructType.Members);
-        return NULL;
-    }
-
-    SVariable *pVariable = StructType.pMembers + Index;
-
-    if (NULL == pVariable->pName)
-    {
-        DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);
-        return NULL;
-    }
-
-    return pVariable->pName;
-}
-
-LPCSTR SType::GetMemberSemantic(UINT Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";
-
-    if (VarType != EVT_Struct)
-    {
-        DPF(0, "%s: This interface does not refer to a structure", pFuncName);
-        return NULL;
-    }
-
-    if (Index >= StructType.Members)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, StructType.Members);
-        return NULL;
-    }
-
-    SVariable *pVariable = StructType.pMembers + Index;
-
-    if (NULL == pVariable->pName)
-    {
-        DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);
-        return NULL;
-    }
-
-    return pVariable->pSemantic;
-}
-
-HRESULT SType::GetDescHelper(D3DX11_EFFECT_TYPE_DESC *pDesc, BOOL IsSingleElement) const
-{
-    HRESULT hr = S_OK;
-    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 = D3D10_SVC_MATRIX_COLUMNS;
-            }
-            else
-            {
-                pDesc->Class = D3D10_SVC_MATRIX_ROWS;
-            }
-            break;
-        case ENL_Vector:
-            pDesc->Class = D3D10_SVC_VECTOR;
-            break;
-        case ENL_Scalar:
-            pDesc->Class = D3D10_SVC_SCALAR;
-            break;
-        default:
-            D3DXASSERT(0);
-        }
-
-        switch (NumericType.ScalarType)
-        {
-        case EST_Bool:
-            pDesc->Type = D3D10_SVT_BOOL;
-            break;
-        case EST_Int:
-            pDesc->Type = D3D10_SVT_INT;
-            break;
-        case EST_UInt:
-            pDesc->Type = D3D10_SVT_UINT;
-            break;
-        case EST_Float:
-            pDesc->Type = D3D10_SVT_FLOAT;
-            break;
-        default:
-            D3DXASSERT(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 = D3D11_SVC_INTERFACE_CLASS;
-        }
-        else
-        {
-            pDesc->Class = D3D10_SVC_STRUCT;
-        }
-        pDesc->Type = D3D10_SVT_VOID;
-        break;
-
-    case EVT_Interface:
-        pDesc->Rows = 0;
-        pDesc->Columns = 0;
-        pDesc->Members = 0;
-        pDesc->Class = D3D11_SVC_INTERFACE_POINTER;
-        pDesc->Type = D3D11_SVT_INTERFACE_POINTER;
-        break;
-
-    case EVT_Object:
-        pDesc->Rows = 0;
-        pDesc->Columns = 0;
-        pDesc->Members = 0;
-        pDesc->Class = D3D10_SVC_OBJECT;            
-
-        switch (ObjectType)
-        {
-        case EOT_String:
-            pDesc->Type = D3D10_SVT_STRING;
-            break;
-        case EOT_Blend:
-            pDesc->Type = D3D10_SVT_BLEND; 
-            break;
-        case EOT_DepthStencil:
-            pDesc->Type = D3D10_SVT_DEPTHSTENCIL;
-            break;
-        case EOT_Rasterizer:
-            pDesc->Type = D3D10_SVT_RASTERIZER;
-            break;
-        case EOT_PixelShader:
-        case EOT_PixelShader5:
-            pDesc->Type = D3D10_SVT_PIXELSHADER;
-            break;
-        case EOT_VertexShader:
-        case EOT_VertexShader5:
-            pDesc->Type = D3D10_SVT_VERTEXSHADER;
-            break;
-        case EOT_GeometryShader:
-        case EOT_GeometryShaderSO:
-        case EOT_GeometryShader5:
-            pDesc->Type = D3D10_SVT_GEOMETRYSHADER;
-            break;
-        case EOT_HullShader5:
-            pDesc->Type = D3D11_SVT_HULLSHADER;
-            break;
-        case EOT_DomainShader5:
-            pDesc->Type = D3D11_SVT_DOMAINSHADER;
-            break;
-        case EOT_ComputeShader5:
-            pDesc->Type = D3D11_SVT_COMPUTESHADER;
-            break;
-        case EOT_Texture:
-            pDesc->Type = D3D10_SVT_TEXTURE;
-            break;
-        case EOT_Texture1D:
-            pDesc->Type = D3D10_SVT_TEXTURE1D;
-            break;
-        case EOT_Texture1DArray:
-            pDesc->Type = D3D10_SVT_TEXTURE1DARRAY;
-            break;
-        case EOT_Texture2D:
-            pDesc->Type = D3D10_SVT_TEXTURE2D;
-            break;
-        case EOT_Texture2DArray:
-            pDesc->Type = D3D10_SVT_TEXTURE2DARRAY;
-            break;
-        case EOT_Texture2DMS:
-            pDesc->Type = D3D10_SVT_TEXTURE2DMS;
-            break;
-        case EOT_Texture2DMSArray:
-            pDesc->Type = D3D10_SVT_TEXTURE2DMSARRAY;
-            break;
-        case EOT_Texture3D:
-            pDesc->Type = D3D10_SVT_TEXTURE3D;
-            break;
-        case EOT_TextureCube:
-            pDesc->Type = D3D10_SVT_TEXTURECUBE;
-            break;
-        case EOT_TextureCubeArray:
-            pDesc->Type = D3D10_SVT_TEXTURECUBEARRAY;
-            break;
-        case EOT_Buffer:
-            pDesc->Type = D3D10_SVT_BUFFER;
-            break;
-        case EOT_Sampler:
-            pDesc->Type = D3D10_SVT_SAMPLER;
-            break;
-        case EOT_RenderTargetView:
-            pDesc->Type = D3D10_SVT_RENDERTARGETVIEW;
-            break;
-        case EOT_DepthStencilView:
-            pDesc->Type = D3D10_SVT_DEPTHSTENCILVIEW;
-            break;
-        case EOT_RWTexture1D:
-            pDesc->Type = D3D11_SVT_RWTEXTURE1D;
-            break;
-        case EOT_RWTexture1DArray:
-            pDesc->Type = D3D11_SVT_RWTEXTURE1DARRAY;
-            break;
-        case EOT_RWTexture2D:
-            pDesc->Type = D3D11_SVT_RWTEXTURE2D;
-            break;
-        case EOT_RWTexture2DArray:
-            pDesc->Type = D3D11_SVT_RWTEXTURE2DARRAY;
-            break;
-        case EOT_RWTexture3D:
-            pDesc->Type = D3D11_SVT_RWTEXTURE3D;
-            break;
-        case EOT_RWBuffer:
-            pDesc->Type = D3D11_SVT_RWBUFFER;
-            break;
-        case EOT_ByteAddressBuffer:
-            pDesc->Type = D3D11_SVT_BYTEADDRESS_BUFFER;
-            break;
-        case EOT_RWByteAddressBuffer:
-            pDesc->Type = D3D11_SVT_RWBYTEADDRESS_BUFFER;
-            break;
-        case EOT_StructuredBuffer:
-            pDesc->Type = D3D11_SVT_STRUCTURED_BUFFER;
-            break;
-        case EOT_RWStructuredBuffer:
-        case EOT_RWStructuredBufferAlloc:
-        case EOT_RWStructuredBufferConsume:
-            pDesc->Type = D3D11_SVT_RWSTRUCTURED_BUFFER;
-            break;
-        case EOT_AppendStructuredBuffer:
-            pDesc->Type = D3D11_SVT_APPEND_STRUCTURED_BUFFER;
-            break;
-        case EOT_ConsumeStructuredBuffer:
-            pDesc->Type = D3D11_SVT_CONSUME_STRUCTURED_BUFFER;
-            break;
-
-        default:
-            D3DXASSERT(0);
-        }
-        break;
-
-    default:
-        D3DXASSERT(0);
-    }
-
-lExit:
-    return hr;
-
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectShaderVariable (SAnonymousShader implementation)
-////////////////////////////////////////////////////////////////////////////////
-
-SAnonymousShader::SAnonymousShader(SShaderBlock *pBlock)
-{
-    pShaderBlock = pBlock;
-}
-
-BOOL SAnonymousShader::IsValid()
-{
-    return pShaderBlock && pShaderBlock->IsValid;
-}
-
-ID3DX11EffectType * SAnonymousShader::GetType()
-{
-    return (ID3DX11EffectType *) this;
-}
-
-HRESULT SAnonymousShader::GetDesc(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
-{
-    pDesc->Annotations = 0;
-    pDesc->Flags = 0;
-
-    pDesc->Name = "$Anonymous";
-    pDesc->Semantic = NULL;
-    pDesc->BufferOffset = 0;
-
-    return S_OK;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByIndex(UINT Index)
-{
-    DPF(0, "ID3DX11EffectVariable::GetAnnotationByIndex: Anonymous shaders cannot have annotations");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetAnnotationByName(LPCSTR Name)
-{
-    DPF(0, "ID3DX11EffectVariable::GetAnnotationByName: Anonymous shaders cannot have annotations");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetMemberByIndex(UINT  Index)
-{
-    DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetMemberByName(LPCSTR Name)
-{
-    DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetMemberBySemantic(LPCSTR Semantic)
-{
-    DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectVariable * SAnonymousShader::GetElement(UINT Index)
-{
-    DPF(0, "ID3DX11EffectVariable::GetElement: Anonymous shaders cannot have elements");
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectConstantBuffer * SAnonymousShader::GetParentConstantBuffer()
-{
-    return NoParentCB();
-}
-
-ID3DX11EffectShaderVariable * SAnonymousShader::AsShader()
-{
-    return (ID3DX11EffectShaderVariable *) this;
-}
-
-HRESULT SAnonymousShader::SetRawValue(CONST void *pData, UINT Offset, UINT Count) 
-{ 
-    return ObjectSetRawValue(); 
-}
-
-HRESULT SAnonymousShader::GetRawValue(__out_bcount(Count) void *pData, UINT Offset, UINT 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(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    pShaderBlock->GetShaderDesc(pDesc, TRUE);
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetVertexShader(UINT ShaderIndex, ID3D11VertexShader **ppVS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetVertexShader(ppVS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetGeometryShader(UINT ShaderIndex, ID3D11GeometryShader **ppGS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetGeometryShader(ppGS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetPixelShader(UINT ShaderIndex, ID3D11PixelShader **ppPS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetPixelShader(ppPS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetHullShader(UINT ShaderIndex, ID3D11HullShader **ppHS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetHullShader(ppHS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetDomainShader(UINT ShaderIndex, ID3D11DomainShader **ppCS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetDomainShader(ppCS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetComputeShader(UINT ShaderIndex, ID3D11ComputeShader **ppCS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetComputeShader(ppCS) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetInputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetOutputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetPatchConstantSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
-
-    ANONYMOUS_SHADER_INDEX_CHECK();
-
-    VH( pShaderBlock->GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );
-
-lExit:
-    return hr;
-}
-
-HRESULT SAnonymousShader::GetDesc(D3DX11_EFFECT_TYPE_DESC *pDesc)
-{
-    pDesc->Class = D3D10_SVC_OBJECT;
-
-    switch (pShaderBlock->GetShaderType())
-    {
-    case EOT_VertexShader:
-    case EOT_VertexShader5:
-        pDesc->TypeName = "vertexshader";
-        pDesc->Type = D3D10_SVT_VERTEXSHADER;
-        break;
-    case EOT_GeometryShader:
-    case EOT_GeometryShader5:
-        pDesc->TypeName = "geometryshader";
-        pDesc->Type = D3D10_SVT_GEOMETRYSHADER;
-        break;
-    case EOT_PixelShader:
-    case EOT_PixelShader5:
-        pDesc->TypeName = "pixelshader";
-        pDesc->Type = D3D10_SVT_PIXELSHADER;
-        break;
-    case EOT_HullShader5:
-        pDesc->TypeName = "Hullshader";
-        pDesc->Type = D3D11_SVT_HULLSHADER;
-        break;
-    case EOT_DomainShader5:
-        pDesc->TypeName = "Domainshader";
-        pDesc->Type = D3D11_SVT_DOMAINSHADER;
-        break;
-    case EOT_ComputeShader5:
-        pDesc->TypeName = "Computeshader";
-        pDesc->Type = D3D11_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(UINT  Index)
-{
-    DPF(0, "ID3DX11EffectType::GetMemberTypeByIndex: This interface does not refer to a structure");
-    return &g_InvalidType;
-}
-
-ID3DX11EffectType * SAnonymousShader::GetMemberTypeByName(LPCSTR Name)
-{
-    DPF(0, "ID3DX11EffectType::GetMemberTypeByName: This interface does not refer to a structure");
-    return &g_InvalidType;
-}
-
-ID3DX11EffectType * SAnonymousShader::GetMemberTypeBySemantic(LPCSTR Semantic)
-{
-    DPF(0, "ID3DX11EffectType::GetMemberTypeBySemantic: This interface does not refer to a structure");
-    return &g_InvalidType;
-}
-
-LPCSTR SAnonymousShader::GetMemberName(UINT Index)
-{
-    DPF(0, "ID3DX11EffectType::GetMemberName: This interface does not refer to a structure");
-    return NULL;
-}
-
-LPCSTR SAnonymousShader::GetMemberSemantic(UINT Index)
-{
-    DPF(0, "ID3DX11EffectType::GetMemberSemantic: This interface does not refer to a structure");
-    return NULL;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectConstantBuffer (SConstantBuffer implementation)
-//////////////////////////////////////////////////////////////////////////
-
-BOOL SConstantBuffer::IsValid()
-{
-    return TRUE;
-}
-
-ID3DX11EffectType * SConstantBuffer::GetType()
-{
-    return (ID3DX11EffectType *) this;
-}
-
-HRESULT SConstantBuffer::GetDesc(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
-{
-    pDesc->Annotations = AnnotationCount;
-    pDesc->Flags = 0;
-
-    pDesc->Name = pName;
-    pDesc->Semantic = NULL;
-    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(UINT  Index)
-{
-    return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectVariable * SConstantBuffer::GetAnnotationByName(LPCSTR Name)
-{
-    return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectVariable * SConstantBuffer::GetMemberByIndex(UINT  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, 
-        NULL, &pMember, &dataPtr.pGeneric))
-    {
-        return &g_InvalidScalarVariable;
-    }
-
-    return (ID3DX11EffectVariable *) pMember;
-}
-
-ID3DX11EffectVariable * SConstantBuffer::GetMemberByName(LPCSTR Name)
-{
-    SGlobalVariable *pMember;
-    UDataPointer dataPtr;
-    UINT 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, 
-        NULL, &pMember, &dataPtr.pGeneric, &index))
-    {
-        return &g_InvalidScalarVariable;
-    }
-
-    return (ID3DX11EffectVariable *) pMember;
-}
-
-ID3DX11EffectVariable * SConstantBuffer::GetMemberBySemantic(LPCSTR Semantic)
-{
-    SGlobalVariable *pMember;
-    UDataPointer dataPtr;
-    UINT 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, 
-        NULL, &pMember, &dataPtr.pGeneric, &index))
-    {
-        return &g_InvalidScalarVariable;
-    }
-
-    return (ID3DX11EffectVariable *) pMember;
-}
-
-ID3DX11EffectVariable * SConstantBuffer::GetElement(UINT  Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
-    DPF(0, "%s: This interface does not refer to an array", pFuncName);
-    return &g_InvalidScalarVariable;
-}
-
-ID3DX11EffectConstantBuffer * SConstantBuffer::GetParentConstantBuffer()
-{
-    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(D3DX11_EFFECT_TYPE_DESC *pDesc)
-{
-    pDesc->TypeName = IsTBuffer ? "tbuffer" : "cbuffer";
-    pDesc->Class = D3D10_SVC_OBJECT;
-    pDesc->Type = IsTBuffer ? D3D10_SVT_TBUFFER : D3D10_SVT_CBUFFER;
-
-    pDesc->Elements = 0;
-    pDesc->Members = VariableCount;
-    pDesc->Rows = 0;
-    pDesc->Columns = 0;
-
-    UINT  i;
-    pDesc->PackedSize = 0;
-    for (i = 0; i < VariableCount; ++ i)
-    {
-        pDesc->PackedSize += pVariables[i].pType->PackedSize;
-    }
-
-    pDesc->UnpackedSize = Size;
-    D3DXASSERT(pDesc->UnpackedSize >= pDesc->PackedSize);
-
-    pDesc->Stride = AlignToPowerOf2(pDesc->UnpackedSize, SType::c_RegisterSize);
-
-    return S_OK;
-}
-
-ID3DX11EffectType * SConstantBuffer::GetMemberTypeByIndex(UINT  Index)
-{
-    return GetTypeByIndexHelper(Index, VariableCount, pVariables, sizeof (SGlobalVariable));
-}
-
-ID3DX11EffectType * SConstantBuffer::GetMemberTypeByName(LPCSTR Name)
-{
-    return GetTypeByNameHelper(Name, VariableCount, pVariables, sizeof (SGlobalVariable));
-}
-
-ID3DX11EffectType * SConstantBuffer::GetMemberTypeBySemantic(LPCSTR Semantic)
-{
-    return GetTypeBySemanticHelper(Semantic, VariableCount, pVariables, sizeof (SGlobalVariable));
-}
-
-LPCSTR SConstantBuffer::GetMemberName(UINT Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberName";
-
-    if (IsEffectOptimized)
-    {
-        DPF(0, "%s: Cannot get member names; Effect has been Optimize()'ed", pFuncName);
-        return NULL;
-    }
-
-    if (Index >= VariableCount)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);
-        return NULL;
-    }
-
-    return pVariables[Index].pName;
-}
-
-LPCSTR SConstantBuffer::GetMemberSemantic(UINT Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectType::GetMemberSemantic";
-
-    if (IsEffectOptimized)
-    {
-        DPF(0, "%s: Cannot get member semantics; Effect has been Optimize()'ed", pFuncName);
-        return NULL;
-    }
-
-    if (Index >= VariableCount)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);
-        return NULL;
-    }
-
-    return pVariables[Index].pSemantic;
-}
-
-HRESULT SConstantBuffer::SetRawValue(CONST void *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;    
-
-#ifdef _DEBUG
-    LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
-
-    VERIFYPARAMETER(pData);
-
-    if ((Offset + Count < Offset) ||
-        (Count + (BYTE*)pData < (BYTE*)pData) ||
-        ((Offset + Count) > Size))
-    {
-        // overflow of some kind
-        DPF(0, "%s: Invalid range specified", pFuncName);
-        VH(E_INVALIDARG);
-    }
-#endif
-
-    if (IsUsedByExpression)
-    {
-        UINT  i;
-        for (i = 0; i < VariableCount; ++ i)
-        {
-            ((SGlobalVariable*)pVariables)[i].DirtyVariable();
-        }
-    }
-    else
-    {
-        IsDirty = TRUE;
-    }
-
-    memcpy(pBackingStore + Offset, pData, Count);
-
-lExit:
-    return hr;
-}
-
-HRESULT SConstantBuffer::GetRawValue(__out_bcount(Count) void *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;    
-
-#ifdef _DEBUG
-    LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
-
-    VERIFYPARAMETER(pData);
-
-    if ((Offset + Count < Offset) ||
-        (Count + (BYTE*)pData < (BYTE*)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(ID3D11Buffer *pConstantBuffer)
-{
-    HRESULT hr = S_OK;
-    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
-        D3DXASSERT( pMemberData[0].Type == MDT_Buffer );
-        VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == NULL );
-        pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;
-        pD3DObject = NULL;
-        IsUserManaged = TRUE;
-        IsNonUpdatable = TRUE;
-    }
-
-    SAFE_ADDREF( pConstantBuffer );
-    SAFE_RELEASE( pD3DObject );
-    pD3DObject = pConstantBuffer;
-
-lExit:
-    return hr;
-}
-
-HRESULT SConstantBuffer::GetConstantBuffer(ID3D11Buffer **ppConstantBuffer)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetConstantBuffer";
-
-    VERIFYPARAMETER(ppConstantBuffer);
-
-    if (IsTBuffer)
-    {
-        DPF(0, "%s: This is a texture buffer; use GetTextureBuffer instead", pFuncName);
-        VH(D3DERR_INVALIDCALL);
-    }
-
-    *ppConstantBuffer = pD3DObject;
-    SAFE_ADDREF(*ppConstantBuffer);
-
-lExit:
-    return hr;
-}
-
-HRESULT SConstantBuffer::UndoSetConstantBuffer() 
-{
-    HRESULT hr = S_OK;
-    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 = NULL;
-    IsUserManaged = FALSE;
-    IsNonUpdatable = ClonedSingle();
-
-lExit:
-    return hr;
-}
-
-HRESULT SConstantBuffer::SetTextureBuffer(ID3D11ShaderResourceView *pTextureBuffer)
-{
-    HRESULT hr = S_OK;
-    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
-        D3DXASSERT( pMemberData[0].Type == MDT_Buffer );
-        VB( pMemberData[0].Data.pD3DEffectsManagedConstantBuffer == NULL );
-        pMemberData[0].Data.pD3DEffectsManagedConstantBuffer = pD3DObject;
-        pD3DObject = NULL;
-        D3DXASSERT( pMemberData[1].Type == MDT_ShaderResourceView );
-        VB( pMemberData[1].Data.pD3DEffectsManagedTextureBuffer == NULL );
-        pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = TBuffer.pShaderResource;
-        TBuffer.pShaderResource = NULL;
-        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(ID3D11ShaderResourceView **ppTextureBuffer)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectConstantBuffer::GetTextureBuffer";
-
-    VERIFYPARAMETER(ppTextureBuffer);
-
-    if (!IsTBuffer)
-    {
-        DPF(0, "%s: This is a constant buffer; use GetConstantBuffer instead", pFuncName);
-        VH(D3DERR_INVALIDCALL);
-    }
-
-    *ppTextureBuffer = TBuffer.pShaderResource;
-    SAFE_ADDREF(*ppTextureBuffer);
-
-lExit:
-    return hr;
-}
-
-HRESULT SConstantBuffer::UndoSetTextureBuffer()
-{
-    HRESULT hr = S_OK;
-    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 = NULL;
-    SAFE_RELEASE( TBuffer.pShaderResource );
-    TBuffer.pShaderResource = pMemberData[1].Data.pD3DEffectsManagedTextureBuffer;
-    pMemberData[1].Data.pD3DEffectsManagedTextureBuffer = NULL;
-    IsUserManaged = FALSE;
-    IsNonUpdatable = ClonedSingle();
-
-lExit:
-    return hr;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectPass (CEffectPass implementation)
-//////////////////////////////////////////////////////////////////////////
-
-BOOL SPassBlock::IsValid()
-{
-    if( HasDependencies )
-        return pEffect->ValidatePassBlock( this );
-    return InitiallyValid;
-}
-
-HRESULT SPassBlock::GetDesc(D3DX11_PASS_DESC *pDesc)
-{
-    HRESULT hr = S_OK;
-    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 NULL VS "SetVertexShader( NULL )"
-        pDesc->pIAInputSignature = (BYTE*)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;
-    UINT  i;
-    LPCSTR pFuncName = NULL;
-    SShaderBlock *pShaderBlock = NULL;
-
-    ApplyPassAssignments();
-
-    switch (EShaderType)
-    {
-    case EOT_VertexShader:
-    case EOT_VertexShader5:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        pFuncName = "ID3DX11EffectPass::GetVertexShaderDesc";
-        pShaderBlock = BackingStore.pVertexShaderBlock;
-        break;
-    case EOT_PixelShader:
-    case EOT_PixelShader5:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        pFuncName = "ID3DX11EffectPass::GetPixelShaderDesc";
-        pShaderBlock = BackingStore.pPixelShaderBlock;
-        break;
-    case EOT_GeometryShader:
-    case EOT_GeometryShader5:
-#pragma prefast(suppress:__WARNING_UNUSED_POINTER_ASSIGNMENT, "pFuncName used in DPF")
-        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:
-        D3DXASSERT(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 (NULL != pShaderBlock)
-    {
-        UINT 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 = max(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 = (UINT)(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(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_VertexShader>(pDesc);
-}
-
-HRESULT SPassBlock::GetPixelShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_PixelShader>(pDesc);
-}
-
-HRESULT SPassBlock::GetGeometryShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_GeometryShader>(pDesc);
-}
-
-HRESULT SPassBlock::GetHullShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_HullShader5>(pDesc);
-}
-
-HRESULT SPassBlock::GetDomainShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_DomainShader5>(pDesc);
-}
-
-HRESULT SPassBlock::GetComputeShaderDesc(D3DX11_PASS_SHADER_DESC *pDesc)
-{
-    return GetShaderDescHelper<EOT_ComputeShader5>(pDesc);
-}
-
-ID3DX11EffectVariable * SPassBlock::GetAnnotationByIndex(UINT  Index)
-{
-    return GetAnnotationByIndexHelper("ID3DX11EffectPass", Index, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectVariable * SPassBlock::GetAnnotationByName(LPCSTR Name)
-{
-    return GetAnnotationByNameHelper("ID3DX11EffectPass", Name, AnnotationCount, pAnnotations);
-}
-
-HRESULT SPassBlock::Apply(UINT  Flags, ID3D11DeviceContext* pContext)
-{
-    HRESULT hr = S_OK;
-
-    // TODO: Flags are not yet implemented    
-
-    D3DXASSERT( pEffect->m_pContext == NULL );
-    pEffect->m_pContext = pContext;
-    pEffect->ApplyPassBlock(this);
-    pEffect->m_pContext = NULL;
-
-lExit:
-    return hr;
-}
-
-HRESULT SPassBlock::ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
-{
-    HRESULT hr = S_OK;
-    UINT i, j;
-    
-    // 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 (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 (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 (NULL != BackingStore.pRasterizerBlock)
-    {
-        pStateBlockMask->RSRasterizerState = 1;
-    }
-    if (NULL != BackingStore.pBlendBlock)
-    {
-        pStateBlockMask->OMBlendState = 1;
-    }
-    if (NULL != BackingStore.pDepthStencilBlock)
-    {
-        pStateBlockMask->OMDepthStencilState = 1;
-    }
-
-    // go over the shaders only if an assignment didn't already catch them
-    if (FALSE == bVS && NULL != BackingStore.pVertexShaderBlock)
-    {
-        VH( BackingStore.pVertexShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    if (FALSE == bGS && NULL != BackingStore.pGeometryShaderBlock)
-    {
-        VH( BackingStore.pGeometryShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    if (FALSE == bPS && NULL != BackingStore.pPixelShaderBlock)
-    {
-        VH( BackingStore.pPixelShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    if (FALSE == bHS && NULL != BackingStore.pHullShaderBlock)
-    {
-        VH( BackingStore.pHullShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    if (FALSE == bDS && NULL != BackingStore.pDomainShaderBlock)
-    {
-        VH( BackingStore.pDomainShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    if (FALSE == bCS && NULL != BackingStore.pComputeShaderBlock)
-    {
-        VH( BackingStore.pComputeShaderBlock->ComputeStateBlockMask(pStateBlockMask) );
-    }
-    
-lExit:
-    return hr;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectTechnique (STechnique implementation)
-//////////////////////////////////////////////////////////////////////////
-
-BOOL STechnique::IsValid()
-{ 
-    if( HasDependencies )
-    {
-        for( UINT i = 0; i < PassCount; i++ )
-        {
-            if( !((SPassBlock*)pPasses)[i].IsValid() )
-                return FALSE;
-        }
-        return TRUE;
-    }
-    return InitiallyValid;
-}
-
-HRESULT STechnique::GetDesc(D3DX11_TECHNIQUE_DESC *pDesc)
-{
-    HRESULT hr = S_OK;
-
-    LPCSTR pFuncName = "ID3DX11EffectTechnique::GetDesc";
-
-    VERIFYPARAMETER(pDesc);
-
-    pDesc->Name = pName;
-    pDesc->Annotations = AnnotationCount;
-    pDesc->Passes = PassCount;
-
-lExit:
-    return hr;
-}
-
-ID3DX11EffectVariable * STechnique::GetAnnotationByIndex(UINT  Index)
-{
-    return GetAnnotationByIndexHelper("ID3DX11EffectTechnique", Index, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectVariable * STechnique::GetAnnotationByName(LPCSTR Name)
-{
-    return GetAnnotationByNameHelper("ID3DX11EffectTechnique", Name, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectPass * STechnique::GetPassByIndex(UINT  Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByIndex";
-
-    if (Index >= PassCount)
-    {
-        DPF(0, "%s: Invalid pass index (%d, total: %d)", pFuncName, Index, PassCount);
-        return &g_InvalidPass;
-    }
-
-    return (ID3DX11EffectPass *)(pPasses + Index);
-}
-
-ID3DX11EffectPass * STechnique::GetPassByName(LPCSTR Name)
-{
-    LPCSTR pFuncName = "ID3DX11EffectTechnique::GetPassByName";
-
-    UINT  i;
-
-    for (i = 0; i < PassCount; ++ i)
-    {
-        if (NULL != 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(D3DX11_STATE_BLOCK_MASK *pStateBlockMask)
-{
-    HRESULT hr = S_OK;
-    UINT i;
-
-    for (i = 0; i < PassCount; ++ i)
-    {
-        VH( ((SPassBlock*)pPasses)[i].ComputeStateBlockMask(pStateBlockMask) );
-    }
-
-lExit:
-    return hr;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectGroup (SGroup implementation)
-//////////////////////////////////////////////////////////////////////////
-
-BOOL SGroup::IsValid()
-{ 
-    if( HasDependencies )
-    {
-        for( UINT i = 0; i < TechniqueCount; i++ )
-        {
-            if( !((STechnique*)pTechniques)[i].IsValid() )
-                return FALSE;
-        }
-        return TRUE;
-    }
-    return InitiallyValid;
-}
-
-HRESULT SGroup::GetDesc(D3DX11_GROUP_DESC *pDesc)
-{
-    HRESULT hr = S_OK;
-
-    LPCSTR pFuncName = "ID3DX11EffectGroup::GetDesc";
-
-    VERIFYPARAMETER(pDesc);
-
-    pDesc->Name = pName;
-    pDesc->Annotations = AnnotationCount;
-    pDesc->Techniques = TechniqueCount;
-
-lExit:
-    return hr;
-}
-
-ID3DX11EffectVariable * SGroup::GetAnnotationByIndex(UINT  Index)
-{
-    return GetAnnotationByIndexHelper("ID3DX11EffectGroup", Index, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectVariable * SGroup::GetAnnotationByName(LPCSTR Name)
-{
-    return GetAnnotationByNameHelper("ID3DX11EffectGroup", Name, AnnotationCount, pAnnotations);
-}
-
-ID3DX11EffectTechnique * SGroup::GetTechniqueByIndex(UINT  Index)
-{
-    LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByIndex";
-
-    if (Index >= TechniqueCount)
-    {
-        DPF(0, "%s: Invalid pass index (%d, total: %d)", pFuncName, Index, TechniqueCount);
-        return &g_InvalidTechnique;
-    }
-
-    return (ID3DX11EffectTechnique *)(pTechniques + Index);
-}
-
-ID3DX11EffectTechnique * SGroup::GetTechniqueByName(LPCSTR Name)
-{
-    LPCSTR pFuncName = "ID3DX11EffectGroup::GetTechniqueByName";
-
-    UINT  i;
-
-    for (i = 0; i < TechniqueCount; ++ i)
-    {
-        if (NULL != 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(ID3D11Device **ppDevice)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11Effect::GetDevice";
-    VERIFYPARAMETER(ppDevice);
-
-    m_pDevice->AddRef();
-    *ppDevice = m_pDevice;
-
-lExit:
-    return hr;
-}
-
-HRESULT CEffect::GetDesc(D3DX11_EFFECT_DESC *pDesc)
-{
-    HRESULT hr = S_OK;
-
-    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(UINT  Index)
-{
-    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(LPCSTR Name)
-{
-    HRESULT hr = S_OK;
-    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 (NULL == Name)
-    {
-        DPF(0, "%s: Parameter Name was NULL.", pFuncName);
-        return &g_InvalidConstantBuffer;
-    }
-
-    UINT  i;
-
-    for (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(UINT  Index)
-{
-    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(LPCSTR Name)
-{
-    HRESULT hr = S_OK;
-    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 (NULL == Name)
-    {
-        DPF(0, "%s: Parameter Name was NULL.", pFuncName);
-        return &g_InvalidScalarVariable;
-    }
-
-    UINT  i;
-
-    for (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(LPCSTR Semantic)
-{    
-    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 (NULL == Semantic)
-    {
-        DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);
-        return &g_InvalidScalarVariable;
-    }
-
-    UINT  i;
-
-    for (i = 0; i < m_VariableCount; ++ i)
-    {
-        if (NULL != 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(UINT  Index)
-{
-    LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByIndex";
-
-    if( Index < m_TechniqueCount )
-    {
-        UINT i;
-        for( i=0; i < m_GroupCount; i++ )
-        {
-            if( Index < m_pGroups[i].TechniqueCount )
-            {
-                return (ID3DX11EffectTechnique *)(m_pGroups[i].pTechniques + Index);
-            }
-            Index -= m_pGroups[i].TechniqueCount;
-        }
-        D3DXASSERT( FALSE );
-    }
-    DPF(0, "%s: Invalid technique index (%d)", pFuncName, Index);
-    return &g_InvalidTechnique;
-}
-
-ID3DX11EffectTechnique * CEffect::GetTechniqueByName(LPCSTR Name)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11Effect::GetTechniqueByName";
-    const UINT 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 (NULL == Name)
-    {
-        DPF(0, "%s: Parameter Name was NULL.", pFuncName);
-        return &g_InvalidTechnique;
-    }
-
-    if( FAILED( StringCchCopyA( NameCopy, MAX_GROUP_TECHNIQUE_SIZE, Name ) ) )
-    {
-        DPF( 0, "Group|Technique name has a length greater than %d.", MAX_GROUP_TECHNIQUE_SIZE );
-        return &g_InvalidTechnique;
-    }
-
-    char* pDelimiter = strchr( NameCopy, '|' );
-    if( pDelimiter == NULL )
-    {
-        if ( m_pNullGroup == NULL )
-        {
-            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(UINT  Index)
-{
-    LPCSTR pFuncName = "ID3DX11Effect::GetGroupByIndex";
-
-    if( Index < m_GroupCount )
-    {
-        return (ID3DX11EffectGroup *)(m_pGroups + Index);
-    }
-    DPF(0, "%s: Invalid group index (%d)", pFuncName, Index);
-    return &g_InvalidGroup;
-}
-
-ID3DX11EffectGroup * CEffect::GetGroupByName(LPCSTR Name)
-{
-    HRESULT hr = S_OK;
-    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 (NULL == Name || Name[0] == 0 )
-    {
-        return m_pNullGroup ? (ID3DX11EffectGroup *)m_pNullGroup : &g_InvalidGroup;
-    }
-
-    UINT  i;
-
-    for (i = 0; i < m_GroupCount; ++ i)
-    {
-        if (NULL != 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);
-}
-
-}
diff --git a/sample/d3d11/Effects11/EffectRuntime.cpp b/sample/d3d11/Effects11/EffectRuntime.cpp
deleted file mode 100644
index c09dc84..0000000
--- a/sample/d3d11/Effects11/EffectRuntime.cpp
+++ /dev/null
@@ -1,694 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectRuntime.cpp
-//  Content:    D3DX11 Effect runtime routines (performance critical)
-//              These functions are expected to be called at high frequency
-//              (when applying a pass).
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-
-namespace D3DX11Effects
-{
-    // D3D11_KEEP_UNORDERED_ACCESS_VIEWS == (UINT)-1
-    UINT 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( SShaderBlock* pBlock )
-{
-    if( pBlock->InterfaceDepCount > 0 )
-    {
-        D3DXASSERT( pBlock->InterfaceDepCount == 1 );
-        for( UINT i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
-        {
-            SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
-            if( pInterfaceDep > pEffect->m_pInterfaces && pInterfaceDep < (pEffect->m_pInterfaces + pEffect->m_InterfaceCount) )
-            {
-                // This is a global interface pointer (as opposed to an SInterface created in a BindInterface call
-                return TRUE;
-            }
-        }
-    }
-    return FALSE;
-}
-
-// Returns TRUE if the pass (and sets HasDependencies) if the pass sets objects whose backing stores can be updated
-BOOL SPassBlock::CheckDependencies()
-{
-    if( HasDependencies )
-        return TRUE;
-
-    for( UINT i=0; i < AssignmentCount; i++ )
-    {
-        if( pAssignments[i].DependencyCount > 0 )
-            return HasDependencies = TRUE;
-    }
-    if( BackingStore.pBlendBlock && BackingStore.pBlendBlock->AssignmentCount > 0 )
-    {
-        for( UINT 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( UINT 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( UINT 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;
-}
-
-
-// Update constant buffer contents if necessary
-D3DX11INLINE void CheckAndUpdateCB_FX(ID3D11DeviceContext *pContext, SConstantBuffer *pCB)
-{
-    if (pCB->IsDirty && !pCB->IsNonUpdatable)
-    {
-        // CB out of date; rebuild it
-        pContext->UpdateSubresource(pCB->pD3DObject, 0, NULL, pCB->pBackingStore, pCB->Size, pCB->Size);
-        pCB->IsDirty = FALSE;
-    }
-}
-
-
-// Set the shader and dependent state (SRVs, samplers, UAVs, interfaces)
-void CEffect::ApplyShaderBlock(SShaderBlock *pBlock)
-{
-    UINT i;
-
-    SD3DShaderVTable *pVT = pBlock->pVT;
-
-    // Apply constant buffers first (tbuffers are done later)
-    SShaderCBDependency *pCBDep = pBlock->pCBDeps;
-    SShaderCBDependency *pLastCBDep = pBlock->pCBDeps + pBlock->CBDepCount;
-
-    for (; pCBDep<pLastCBDep; pCBDep++)
-    {
-        D3DXASSERT(pCBDep->ppFXPointers);
-
-        for (i = 0; i < pCBDep->Count; ++ i)
-        {
-            CheckAndUpdateCB_FX(m_pContext, (SConstantBuffer*)pCBDep->ppFXPointers[i]);
-        }
-
-        (m_pContext->*(pVT->pSetConstantBuffers))(pCBDep->StartIndex, pCBDep->Count, pCBDep->ppD3DObjects);
-    }
-
-    // Next, apply samplers
-    SShaderSamplerDependency *pSampDep = pBlock->pSampDeps;
-    SShaderSamplerDependency *pLastSampDep = pBlock->pSampDeps + pBlock->SampDepCount;
-
-    for (; pSampDep<pLastSampDep; pSampDep++)
-    {
-        D3DXASSERT(pSampDep->ppFXPointers);
-
-        for (i=0; i<pSampDep->Count; i++)
-        {
-            if ( ApplyRenderStateBlock(pSampDep->ppFXPointers[i]) )
-            {
-                // If the sampler was updated, its pointer will have changed
-                pSampDep->ppD3DObjects[i] = pSampDep->ppFXPointers[i]->pD3DObject;
-            }
-        }
-        (m_pContext->*(pVT->pSetSamplers))(pSampDep->StartIndex, pSampDep->Count, pSampDep->ppD3DObjects);
-    }
- 
-    // Set the UAVs
-    // UAV ranges were combined in EffectLoad.  This code remains unchanged, however, so that ranges can be easily split
-    D3DXASSERT( pBlock->UAVDepCount < 2 );
-    if( pBlock->UAVDepCount > 0 )
-    {
-        SUnorderedAccessViewDependency *pUAVDep = pBlock->pUAVDeps;
-        D3DXASSERT(pUAVDep->ppFXPointers);
-
-        for (i=0; i<pUAVDep->Count; i++)
-        {
-            pUAVDep->ppD3DObjects[i] = pUAVDep->ppFXPointers[i]->pUnorderedAccessView;
-        }
-
-        if( EOT_ComputeShader5 == pBlock->GetShaderType() )
-        {
-            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, NULL, NULL, 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++)
-    {
-        D3DXASSERT(pResourceDep->ppFXPointers);
-
-        for (i=0; i<pResourceDep->Count; i++)
-        {
-            pResourceDep->ppD3DObjects[i] = pResourceDep->ppFXPointers[i]->pShaderResource;
-        }
-
-        (m_pContext->*(pVT->pSetShaderResources))(pResourceDep->StartIndex, pResourceDep->Count, pResourceDep->ppD3DObjects);
-    }
-
-    // Update Interface dependencies
-    UINT Interfaces = 0;
-    ID3D11ClassInstance** ppClassInstances = NULL;
-    D3DXASSERT( pBlock->InterfaceDepCount < 2 );
-    if( pBlock->InterfaceDepCount > 0 )
-    {
-        SInterfaceDependency *pInterfaceDep = pBlock->pInterfaceDeps;
-        D3DXASSERT(pInterfaceDep->ppFXPointers);
-
-        ppClassInstances = pInterfaceDep->ppD3DObjects;
-        Interfaces = pInterfaceDep->Count;
-        for (i=0; i<pInterfaceDep->Count; i++)
-        {
-            SClassInstanceGlobalVariable* pCI = pInterfaceDep->ppFXPointers[i]->pClassInstance;
-            if( pCI )
-            {
-                D3DXASSERT( pCI->pMemberData != NULL );
-                pInterfaceDep->ppD3DObjects[i] = pCI->pMemberData->Data.pD3DClassInstance;
-            }
-            else
-            {
-                pInterfaceDep->ppD3DObjects[i] = NULL;
-            }
-        }
-    }
-
-    // Now set the shader
-    (m_pContext->*(pVT->pSetShader))(pBlock->pD3DObject, ppClassInstances, Interfaces);
-}
-
-// Returns TRUE if the block D3D data was recreated
-BOOL CEffect::ApplyRenderStateBlock(SBaseBlock *pBlock)
-{
-    if( pBlock->IsUserManaged )
-    {
-        return FALSE;
-    }
-
-    BOOL bRecreate = pBlock->ApplyAssignments(this);
-
-    if (bRecreate)
-    {
-        switch (pBlock->BlockType)
-        {
-        case EBT_Sampler:
-            {
-                SSamplerBlock *pSBlock = pBlock->AsSampler();
-
-                D3DXASSERT(NULL != pSBlock->pD3DObject);
-                pSBlock->pD3DObject->Release();
-
-                m_pDevice->CreateSamplerState( &pSBlock->BackingStore.SamplerDesc, &pSBlock->pD3DObject );
-
-            }
-            break;
-
-        case EBT_DepthStencil:
-            {
-                SDepthStencilBlock *pDSBlock = pBlock->AsDepthStencil();
-
-                D3DXASSERT(NULL != pDSBlock->pDSObject);
-                SAFE_RELEASE( pDSBlock->pDSObject );
-                if( SUCCEEDED( m_pDevice->CreateDepthStencilState( &pDSBlock->BackingStore, &pDSBlock->pDSObject ) ) )
-                    pDSBlock->IsValid = TRUE;
-                else
-                    pDSBlock->IsValid = FALSE;
-            }
-            break;
-        
-        case EBT_Blend:
-            {
-                SBlendBlock *pBBlock = pBlock->AsBlend();
-
-                D3DXASSERT(NULL != pBBlock->pBlendObject);
-                SAFE_RELEASE( pBBlock->pBlendObject );
-                if( SUCCEEDED( m_pDevice->CreateBlendState( &pBBlock->BackingStore, &pBBlock->pBlendObject ) ) )
-                    pBBlock->IsValid = TRUE;
-                else
-                    pBBlock->IsValid = FALSE;
-            }
-            break;
-
-        case EBT_Rasterizer:
-            {
-                SRasterizerBlock *pRBlock = pBlock->AsRasterizer();
-
-                D3DXASSERT(NULL != pRBlock->pRasterizerObject);
-
-                SAFE_RELEASE( pRBlock->pRasterizerObject );
-                if( SUCCEEDED( m_pDevice->CreateRasterizerState( &pRBlock->BackingStore, &pRBlock->pRasterizerObject ) ) )
-                    pRBlock->IsValid = TRUE;
-                else
-                    pRBlock->IsValid = FALSE;
-            }
-            break;
-        
-        default:
-            D3DXASSERT(0);
-        }
-    }
-
-    return bRecreate;
-}
-
-void CEffect::ValidateIndex(UINT  Elements)
-{
-    if (m_FXLIndex >= Elements)
-    {
-        DPF(0, "ID3DX11Effect: Overindexing variable array (size: %d, index: %d), using index = 0 instead", Elements, m_FXLIndex);
-        m_FXLIndex = 0;
-    }
-}
-
-// Returns TRUE if the assignment was changed
-BOOL CEffect::EvaluateAssignment(SAssignment *pAssignment)
-{
-    BOOL bNeedUpdate = FALSE;
-    SGlobalVariable *pVarDep0, *pVarDep1;
-    
-    switch (pAssignment->AssignmentType)
-    {
-    case ERAT_NumericVariable:
-        D3DXASSERT(pAssignment->DependencyCount == 1);
-        if (pAssignment->pDependencies[0].pVariable->LastModifiedTime >= pAssignment->LastRecomputedTime)
-        {
-            dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
-            bNeedUpdate = TRUE;
-        }
-        break;
-
-    case ERAT_NumericVariableIndex:
-        D3DXASSERT(pAssignment->DependencyCount == 2);
-        pVarDep0 = pAssignment->pDependencies[0].pVariable;
-        pVarDep1 = pAssignment->pDependencies[1].pVariable;
-
-        if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
-        {
-            m_FXLIndex = *pVarDep0->Data.pNumericDword;
-
-            ValidateIndex(pVarDep1->pType->Elements);
-
-            // Array index variable is dirty, update the pointer
-            pAssignment->Source.pNumeric = pVarDep1->Data.pNumeric + pVarDep1->pType->Stride * m_FXLIndex;
-            
-            // Copy the new data
-            dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
-            bNeedUpdate = TRUE;
-        }
-        else if (pVarDep1->LastModifiedTime >= pAssignment->LastRecomputedTime)
-        {
-            // Only the array variable is dirty, copy the new data
-            dwordMemcpy(pAssignment->Destination.pNumeric, pAssignment->Source.pNumeric, pAssignment->DataSize);
-            bNeedUpdate = TRUE;
-        }
-        break;
-
-    case ERAT_ObjectVariableIndex:
-        D3DXASSERT(pAssignment->DependencyCount == 1);
-        pVarDep0 = pAssignment->pDependencies[0].pVariable;
-        if (pVarDep0->LastModifiedTime >= pAssignment->LastRecomputedTime)
-        {
-            m_FXLIndex = *pVarDep0->Data.pNumericDword;
-            ValidateIndex(pAssignment->MaxElements);
-
-            // Array index variable is dirty, update the destination pointer
-            *((void **)pAssignment->Destination.pGeneric) = pAssignment->Source.pNumeric +
-                pAssignment->DataSize * m_FXLIndex;
-            bNeedUpdate = TRUE;
-        }
-        break;
-
-    default:
-    //case ERAT_Constant:           -- These are consumed and discarded
-    //case ERAT_ObjectVariable:     -- These are consumed and discarded
-    //case ERAT_ObjectConstIndex:   -- These are consumed and discarded
-    //case ERAT_ObjectInlineShader: -- These are consumed and discarded
-    //case ERAT_NumericConstIndex:  -- ERAT_NumericVariable should be generated instead
-        D3DXASSERT(0);
-        break;
-    }
-    
-    // Mark the assignment as not dirty
-    pAssignment->LastRecomputedTime = m_LocalTimer;
-
-    return bNeedUpdate;
-}
-
-// Returns FALSE if this shader has interface dependencies which are NULL (SetShader will fail).
-BOOL CEffect::ValidateShaderBlock( SShaderBlock* pBlock )
-{
-    if( !pBlock->IsValid )
-        return FALSE;
-    if( pBlock->InterfaceDepCount > 0 )
-    {
-        D3DXASSERT( pBlock->InterfaceDepCount == 1 );
-        for( UINT i=0; i < pBlock->pInterfaceDeps[0].Count; i++ )
-        {
-            SInterface* pInterfaceDep = pBlock->pInterfaceDeps[0].ppFXPointers[i];
-            D3DXASSERT( pInterfaceDep != NULL );
-            if( pInterfaceDep->pClassInstance == NULL )
-            {
-                return FALSE;
-            }
-        }
-    }
-    return TRUE;
-}
-
-// Returns FALSE if any state in the pass is invalid
-BOOL CEffect::ValidatePassBlock( SPassBlock* pBlock )
-{
-    pBlock->ApplyPassAssignments();
-
-    if (NULL != pBlock->BackingStore.pBlendBlock)
-    {
-        ApplyRenderStateBlock(pBlock->BackingStore.pBlendBlock);
-        pBlock->BackingStore.pBlendState = pBlock->BackingStore.pBlendBlock->pBlendObject;
-        if( !pBlock->BackingStore.pBlendBlock->IsValid )
-            return FALSE;
-    }
-
-    if( NULL != pBlock->BackingStore.pDepthStencilBlock )
-    {
-        ApplyRenderStateBlock( pBlock->BackingStore.pDepthStencilBlock );
-        pBlock->BackingStore.pDepthStencilState = pBlock->BackingStore.pDepthStencilBlock->pDSObject;
-        if( !pBlock->BackingStore.pDepthStencilBlock->IsValid )
-            return FALSE;
-    }
-
-    if( NULL != pBlock->BackingStore.pRasterizerBlock )
-    {
-        ApplyRenderStateBlock( pBlock->BackingStore.pRasterizerBlock );
-        if( !pBlock->BackingStore.pRasterizerBlock->IsValid )
-            return FALSE;
-    }
-
-    if( NULL != pBlock->BackingStore.pVertexShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pVertexShaderBlock) )
-        return FALSE;
-
-    if( NULL != pBlock->BackingStore.pGeometryShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pGeometryShaderBlock) )
-        return FALSE;
-
-    if( NULL != 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( NULL != pBlock->BackingStore.pHullShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pHullShaderBlock) )
-        return FALSE;
-
-    if( NULL != pBlock->BackingStore.pDomainShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pDomainShaderBlock) )
-        return FALSE;
-
-    if( NULL != pBlock->BackingStore.pComputeShaderBlock && !ValidateShaderBlock(pBlock->BackingStore.pComputeShaderBlock) )
-        return FALSE;
-
-    return TRUE;
-}
-
-// Set all state defined in the pass
-void CEffect::ApplyPassBlock(SPassBlock *pBlock)
-{
-    pBlock->ApplyPassAssignments();
-
-    if (NULL != 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 (NULL != 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 (NULL != 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 (NULL != pBlock->BackingStore.pRenderTargetViews[0])
-    {
-        // Grab all render targets
-        ID3D11RenderTargetView *pRTV[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
-
-        D3DXASSERT(pBlock->BackingStore.RenderTargetViewCount <= D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT);
-        __analysis_assume(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT >= pBlock->BackingStore.RenderTargetViewCount);
-
-        for (UINT i=0; i<pBlock->BackingStore.RenderTargetViewCount; i++)
-        {
-            pRTV[i] = pBlock->BackingStore.pRenderTargetViews[i]->pRenderTargetView;
-        }
-
-        // This call could be combined with the call to set PS UAVs if both exist in the pass
-        m_pContext->OMSetRenderTargetsAndUnorderedAccessViews( pBlock->BackingStore.RenderTargetViewCount, pRTV, pBlock->BackingStore.pDepthStencilView->pDepthStencilView, 7, D3D11_KEEP_UNORDERED_ACCESS_VIEWS, NULL, NULL );
-    }
-
-    if (NULL != 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 (NULL != 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 (NULL != 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 (NULL != 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 (NULL != 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 (NULL != 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 _WIN64
-#if _DEBUG && FXDEBUG
-    if (m_LocalTimer > g_TimerRolloverCount)
-    {
-        DPF(0, "Rolling over timer (current time: %d, rollover cap: %d).", m_LocalTimer, g_TimerRolloverCount);
-#else // else !(_DEBUG && FXDEBUG)
-    if (m_LocalTimer >= 0x80000000) // check to see if we've exceeded ~2 billion
-    {
-#endif // _DEBUG && FXDEBUG
-        HandleLocalTimerRollover();
-
-        m_LocalTimer = 1;
-    }
-#endif // _WIN64
-}
-
-// 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()
-{
-    UINT  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 (UINT 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;
-        }
-    }
-}
-
-}
diff --git a/sample/d3d11/Effects11/EffectVariable.inl b/sample/d3d11/Effects11/EffectVariable.inl
deleted file mode 100644
index 4a8f4b7..0000000
--- a/sample/d3d11/Effects11/EffectVariable.inl
+++ /dev/null
@@ -1,4573 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       EffectVariable.inl
-//  Content:    D3DX11 Effects Variable reflection template
-//              These templates define the many Effect variable types.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-// 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
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Invalid effect variable struct definitions
-//////////////////////////////////////////////////////////////////////////
-
-struct SEffectInvalidType : public ID3DX11EffectType
-{
-    STDMETHOD_(BOOL, IsValid)() { return FALSE; }
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index) { return &g_InvalidType; }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name) { return &g_InvalidType; }
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semanti) { return &g_InvalidType; }
-    STDMETHOD_(LPCSTR, GetMemberName)(UINT Index) { return NULL; }
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index) { return NULL; }
-};
-
-template<typename IBaseInterface>
-struct TEffectInvalidVariable : public IBaseInterface
-{
-public:
-    STDMETHOD_(BOOL, IsValid)() { return FALSE; }
-    STDMETHOD_(ID3DX11EffectType*, GetType)() { return &g_InvalidType; }
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() { return &g_InvalidConstantBuffer; }
-
-    STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() { return &g_InvalidVectorVariable; }
-    STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() { return &g_InvalidMatrixVariable; }
-    STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() { return &g_InvalidStringVariable; }
-    STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() { return &g_InvalidClassInstanceVariable; }
-    STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() { return &g_InvalidInterfaceVariable; }
-    STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() { return &g_InvalidShaderResourceVariable; }
-    STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() { return &g_InvalidUnorderedAccessViewVariable; }
-    STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() { return &g_InvalidRenderTargetViewVariable; }
-    STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() { return &g_InvalidDepthStencilViewVariable; }
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() { return &g_InvalidConstantBuffer; }
-    STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() { return &g_InvalidShaderVariable; }
-    STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() { return &g_InvalidBlendVariable; }
-    STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() { return &g_InvalidDepthStencilVariable; }
-    STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() { return &g_InvalidRasterizerVariable; }
-    STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() { return &g_InvalidSamplerVariable; }
-
-    STDMETHOD(SetRawValue)(CONST void *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetRawValue)(void *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-struct SEffectInvalidScalarVariable : public TEffectInvalidVariable<ID3DX11EffectScalarVariable>
-{
-public:
-
-    STDMETHOD(SetFloat)(CONST float Value) { return E_FAIL; }
-    STDMETHOD(GetFloat)(float *pValue) { return E_FAIL; }
-
-    STDMETHOD(SetFloatArray)(CONST float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetFloatArray)(float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-
-    STDMETHOD(SetInt)(CONST int Value) { return E_FAIL; }
-    STDMETHOD(GetInt)(int *pValue) { return E_FAIL; }
-
-    STDMETHOD(SetIntArray)(CONST int *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetIntArray)(int *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-
-    STDMETHOD(SetBool)(CONST BOOL Value) { return E_FAIL; }
-    STDMETHOD(GetBool)(BOOL *pValue) { return E_FAIL; }
-
-    STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetBoolArray)(BOOL *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidVectorVariable : public TEffectInvalidVariable<ID3DX11EffectVectorVariable>
-{
-public:
-    STDMETHOD(SetFloatVector)(CONST float *pData) { return E_FAIL; };
-    STDMETHOD(SetIntVector)(CONST int *pData) { return E_FAIL; };
-    STDMETHOD(SetBoolVector)(CONST BOOL *pData) { return E_FAIL; };
-
-    STDMETHOD(GetFloatVector)(float *pData) { return E_FAIL; };
-    STDMETHOD(GetIntVector)(int *pData) { return E_FAIL; };
-    STDMETHOD(GetBoolVector)(BOOL *pData) { return E_FAIL; };
-
-    STDMETHOD(SetBoolVectorArray) (CONST BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; };
-    STDMETHOD(SetIntVectorArray)  (CONST int *pData, UINT Offset, UINT Count) { return E_FAIL; };
-    STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT Count) { return E_FAIL; };
-
-    STDMETHOD(GetBoolVectorArray) (BOOL *pData, UINT Offset, UINT Count) { return E_FAIL; };
-    STDMETHOD(GetIntVectorArray)  (int *pData, UINT Offset, UINT Count) { return E_FAIL; };
-    STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT Count) { return E_FAIL; };
-
-};
-
-struct SEffectInvalidMatrixVariable : public TEffectInvalidVariable<ID3DX11EffectMatrixVariable>
-{
-public:
-
-    STDMETHOD(SetMatrix)(CONST float *pData) { return E_FAIL; }
-    STDMETHOD(GetMatrix)(float *pData) { return E_FAIL; }
-
-    STDMETHOD(SetMatrixArray)(CONST float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetMatrixArray)(float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-
-    STDMETHOD(SetMatrixPointerArray)(CONST float **ppData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetMatrixPointerArray)(float **ppData, UINT  Offset, UINT  Count) { return E_FAIL; }
-
-    STDMETHOD(SetMatrixTranspose)(CONST float *pData) { return E_FAIL; }
-    STDMETHOD(GetMatrixTranspose)(float *pData) { return E_FAIL; }
-
-    STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT  Offset, UINT  Count) { return E_FAIL; }
-
-    STDMETHOD(SetMatrixTransposePointerArray)(CONST float **ppData, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetMatrixTransposePointerArray)(float **ppData, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-struct SEffectInvalidStringVariable : public TEffectInvalidVariable<ID3DX11EffectStringVariable>
-{
-public:
-
-    STDMETHOD(GetString)(LPCSTR *ppString) { return E_FAIL; }
-    STDMETHOD(GetStringArray)(LPCSTR *ppStrings, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-struct SEffectInvalidClassInstanceVariable : public TEffectInvalidVariable<ID3DX11EffectClassInstanceVariable>
-{
-public:
-
-    STDMETHOD(GetClassInstance)(ID3D11ClassInstance **ppClassInstance) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidInterfaceVariable : public TEffectInvalidVariable<ID3DX11EffectInterfaceVariable>
-{
-public:
-
-    STDMETHOD(SetClassInstance)(ID3DX11EffectClassInstanceVariable *pEffectClassInstance) { return E_FAIL; }
-    STDMETHOD(GetClassInstance)(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidShaderResourceVariable : public TEffectInvalidVariable<ID3DX11EffectShaderResourceVariable>
-{
-public:
-
-    STDMETHOD(SetResource)(ID3D11ShaderResourceView *pResource) { return E_FAIL; }
-    STDMETHOD(GetResource)(ID3D11ShaderResourceView **ppResource) { return E_FAIL; }
-
-    STDMETHOD(SetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidUnorderedAccessViewVariable : public TEffectInvalidVariable<ID3DX11EffectUnorderedAccessViewVariable>
-{
-public:
-
-    STDMETHOD(SetUnorderedAccessView)(ID3D11UnorderedAccessView *pResource) { return E_FAIL; }
-    STDMETHOD(GetUnorderedAccessView)(ID3D11UnorderedAccessView **ppResource) { return E_FAIL; }
-
-    STDMETHOD(SetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidRenderTargetViewVariable : public TEffectInvalidVariable<ID3DX11EffectRenderTargetViewVariable>
-{
-public:
-
-    STDMETHOD(SetRenderTarget)(ID3D11RenderTargetView *pResource) { return E_FAIL; }
-    STDMETHOD(GetRenderTarget)(ID3D11RenderTargetView **ppResource) { return E_FAIL; }
-
-    STDMETHOD(SetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidDepthStencilViewVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilViewVariable>
-{
-public:
-
-    STDMETHOD(SetDepthStencil)(ID3D11DepthStencilView *pResource) { return E_FAIL; }
-    STDMETHOD(GetDepthStencil)(ID3D11DepthStencilView **ppResource) { return E_FAIL; }
-
-    STDMETHOD(SetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-    STDMETHOD(GetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count) { return E_FAIL; }
-};
-
-
-struct SEffectInvalidConstantBuffer : public TEffectInvalidVariable<ID3DX11EffectConstantBuffer>
-{
-public:
-
-    STDMETHOD(SetConstantBuffer)(ID3D11Buffer *pConstantBuffer) { return E_FAIL; }
-    STDMETHOD(GetConstantBuffer)(ID3D11Buffer **ppConstantBuffer) { return E_FAIL; }
-    STDMETHOD(UndoSetConstantBuffer)() { return E_FAIL; }
-
-    STDMETHOD(SetTextureBuffer)(ID3D11ShaderResourceView *pTextureBuffer) { return E_FAIL; }
-    STDMETHOD(GetTextureBuffer)(ID3D11ShaderResourceView **ppTextureBuffer) { return E_FAIL; }
-    STDMETHOD(UndoSetTextureBuffer)() { return E_FAIL; }
-};
-
-struct SEffectInvalidShaderVariable : public TEffectInvalidVariable<ID3DX11EffectShaderVariable>
-{
-public:
-
-    STDMETHOD(GetShaderDesc)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS) { return E_FAIL; }
-    STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS) { return E_FAIL; }
-    STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS) { return E_FAIL; }
-    STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS) { return E_FAIL; }
-    STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS) { return E_FAIL; }
-    STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS) { return E_FAIL; }
-
-    STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) { return E_FAIL; }
-};
-
-struct SEffectInvalidBlendVariable : public TEffectInvalidVariable<ID3DX11EffectBlendVariable>
-{
-public:
-
-    STDMETHOD(GetBlendState)(UINT Index, ID3D11BlendState **ppBlendState) { return E_FAIL; }
-    STDMETHOD(SetBlendState)(UINT Index, ID3D11BlendState *pBlendState) { return E_FAIL; }
-    STDMETHOD(UndoSetBlendState)(UINT Index) { return E_FAIL; }
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_BLEND_DESC *pBlendDesc) { return E_FAIL; }
-};
-
-struct SEffectInvalidDepthStencilVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilVariable>
-{
-public:
-
-    STDMETHOD(GetDepthStencilState)(UINT Index, ID3D11DepthStencilState **ppDepthStencilState) { return E_FAIL; }
-    STDMETHOD(SetDepthStencilState)(UINT Index, ID3D11DepthStencilState *pDepthStencilState) { return E_FAIL; }
-    STDMETHOD(UndoSetDepthStencilState)(UINT Index) { return E_FAIL; }
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc) { return E_FAIL; }
-};
-
-struct SEffectInvalidRasterizerVariable : public TEffectInvalidVariable<ID3DX11EffectRasterizerVariable>
-{
-public:
-
-    STDMETHOD(GetRasterizerState)(UINT Index, ID3D11RasterizerState **ppRasterizerState) { return E_FAIL; }
-    STDMETHOD(SetRasterizerState)(UINT Index, ID3D11RasterizerState *pRasterizerState) { return E_FAIL; }
-    STDMETHOD(UndoSetRasterizerState)(UINT Index) { return E_FAIL; }
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc) { return E_FAIL; }
-};
-
-struct SEffectInvalidSamplerVariable : public TEffectInvalidVariable<ID3DX11EffectSamplerVariable>
-{
-public:
-
-    STDMETHOD(GetSampler)(UINT Index, ID3D11SamplerState **ppSampler) { return E_FAIL; }
-    STDMETHOD(SetSampler)(UINT Index, ID3D11SamplerState *pSampler) { return E_FAIL; }
-    STDMETHOD(UndoSetSampler)(UINT Index) { return E_FAIL; }
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc) { return E_FAIL; }
-};
-
-struct SEffectInvalidPass : public ID3DX11EffectPass
-{
-public:
-    STDMETHOD_(BOOL, IsValid)() { return FALSE; }
-    STDMETHOD(GetDesc)(D3DX11_PASS_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD(GetVertexShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetGeometryShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetPixelShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetHullShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetDomainShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-    STDMETHOD(GetComputeShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD(Apply)(UINT Flags, ID3D11DeviceContext* pContext) { return E_FAIL; }
-    STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask) { return E_FAIL; }
-};
-
-struct SEffectInvalidTechnique : public ID3DX11EffectTechnique
-{
-public:
-    STDMETHOD_(BOOL, IsValid)() { return FALSE; }
-    STDMETHOD(GetDesc)(D3DX11_TECHNIQUE_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(UINT Index) { return &g_InvalidPass; }
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(LPCSTR Name) { return &g_InvalidPass; }
-
-    STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask) { return E_FAIL; }
-};
-
-struct SEffectInvalidGroup : public ID3DX11EffectGroup
-{
-public:
-    STDMETHOD_(BOOL, IsValid)() { return FALSE; }
-    STDMETHOD(GetDesc)(D3DX11_GROUP_DESC *pDesc) { return E_FAIL; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index) { return &g_InvalidScalarVariable; }
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name) { return &g_InvalidScalarVariable; }
-
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index) { return &g_InvalidTechnique; }
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name) { return &g_InvalidTechnique; }
-};
-
-//////////////////////////////////////////////////////////////////////////
-// 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 NULL.", 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(const char *pClassName, UINT Index, UINT  AnnotationCount, SAnnotation *pAnnotations);
-
-ID3DX11EffectVariable * GetAnnotationByNameHelper(const char *pClassName, LPCSTR Name, UINT  AnnotationCount, SAnnotation *pAnnotations);
-
-template<typename SVarType>
-BOOL GetVariableByIndexHelper(UINT Index, UINT  VariableCount, SVarType *pVariables, 
-                              BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr)
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByIndex";
-
-    if (Index >= VariableCount)
-    {
-        DPF(0, "%s: Invalid index (%d, total: %d)", pFuncName, Index, VariableCount);
-        return FALSE;
-    }
-
-    *ppMember = pVariables + Index;
-    *ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
-    return TRUE;
-}
-
-template<typename SVarType>
-BOOL GetVariableByNameHelper(LPCSTR Name, UINT  VariableCount, SVarType *pVariables, 
-                             BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr, UINT* pIndex)
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByName";
-
-    if (NULL == Name)
-    {
-        DPF(0, "%s: Parameter Name was NULL.", pFuncName);
-        return FALSE;
-    }
-
-    UINT i;
-    bool bHasSuper = false;
-
-    for (i = 0; i < VariableCount; ++ i)
-    {
-        *ppMember = pVariables + i;
-        D3DXASSERT(NULL != (*ppMember)->pName);
-        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>
-BOOL GetVariableBySemanticHelper(LPCSTR Semantic, UINT  VariableCount, SVarType *pVariables, 
-                                 BYTE *pBaseAddress, SVarType **ppMember, void **ppDataPtr, UINT* pIndex)
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberBySemantic";
-
-    if (NULL == Semantic)
-    {
-        DPF(0, "%s: Parameter Semantic was NULL.", pFuncName);
-        return FALSE;
-    }
-
-    UINT i;
-
-    for (i = 0; i < VariableCount; ++ i)
-    {
-        *ppMember = pVariables + i;
-        if (NULL != (*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;
-}
-
-D3DX11INLINE BOOL AreBoundsValid(UINT  Offset, UINT  Count, CONST void *pData, CONST SType *pType, UINT  TotalUnpackedSize)
-{
-    if (Count == 0) return TRUE;
-    UINT  singleElementSize = pType->GetTotalUnpackedSize(TRUE);
-    D3DXASSERT(singleElementSize <= pType->Stride);
-
-    return ((Offset + Count >= Offset) &&
-        ((Offset + Count) < ((UINT)-1) / pType->Stride) &&
-        (Count * pType->Stride + (BYTE*)pData >= (BYTE*)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(SRC_TYPE SrcValue, void *pDest, const char *pFuncName)
-{
-    HRESULT hr = S_OK;
-#ifdef _DEBUG
-    if (ValidatePtr)
-        VERIFYPARAMETER(pDest);
-#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;
-
-        default:
-            D3DXASSERT(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;
-
-        default:
-            D3DXASSERT(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;
-
-        default:
-            D3DXASSERT(0);
-        }
-        break;
-
-    default:
-        D3DXASSERT(0);
-    }
-
-lExit:
-    return S_OK;
-}
-
-template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
-D3DX11INLINE HRESULT SetScalarArray(CONST SRC_TYPE *pSrcValues, DEST_TYPE *pDestValues, UINT  Offset, UINT  Count, 
-                                    SType *pType, UINT  TotalUnpackedSize, const char *pFuncName)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG    
-    VERIFYPARAMETER(pSrcValues);
-
-    if (!AreBoundsValid(Offset, Count, pSrcValues, pType, TotalUnpackedSize))
-    {
-        DPF(0, "%s: Invalid range specified", pFuncName);
-        VH(E_INVALIDARG);
-    }
-#endif
-
-    UINT 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;
-}
-
-template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
-D3DX11INLINE HRESULT GetScalarArray(SRC_TYPE *pSrcValues, DEST_TYPE *pDestValues, UINT  Offset, UINT  Count, 
-                                    SType *pType, UINT  TotalUnpackedSize, const char *pFuncName)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG    
-    VERIFYPARAMETER(pDestValues);
-
-    if (!AreBoundsValid(Offset, Count, pDestValues, pType, TotalUnpackedSize))
-    {
-        DPF(0, "%s: Invalid range specified", pFuncName);
-        VH(E_INVALIDARG);
-    }
-#endif
-
-    UINT 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)() { return TRUE; }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index)
-    {
-        SVariable *pMember;
-        UDataPointer dataPtr;
-        TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
-
-        if (((ID3DX11Effect*)pTopLevelEntity->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 pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, Index);
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name)
-    {
-        SVariable *pMember;
-        UDataPointer dataPtr;
-        UINT index;
-        TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
-
-        if (pTopLevelEntity->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 pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, index);
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic)
-    {
-        SVariable *pMember;
-        UDataPointer dataPtr;
-        UINT index;
-        TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
-
-        if (pTopLevelEntity->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 pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, pMember, dataPtr, FALSE, index);
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index)
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
-        TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity = GetTopLevelEntity();
-        UDataPointer dataPtr;
-
-        if (pTopLevelEntity->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 (%d, total: %d)", 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 (NULL == dataPtr.pGeneric)
-            {
-                DPF(0, "%s: Internal error", pFuncName);
-                return &g_InvalidScalarVariable;
-            }
-        }
-
-        return pTopLevelEntity->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity, (SVariable *) this, dataPtr, TRUE, Index);
-    }
-
-    STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)()
-    {
-        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)()
-    {
-        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)()
-    {
-        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)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
-
-        if (!pType->IsObjectType(EOT_String))
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidStringVariable;
-        }
-
-        return (ID3DX11EffectStringVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
-
-        if (!pType->IsClassInstance() )
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidClassInstanceVariable;
-        }
-        else if( pMemberData == NULL )
-        {
-            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)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
-
-        if (!pType->IsInterface())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidInterfaceVariable;
-        }
-
-        return (ID3DX11EffectInterfaceVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
-
-        if (!pType->IsShaderResource())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidShaderResourceVariable;
-        }
-
-        return (ID3DX11EffectShaderResourceVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
-
-        if (!pType->IsUnorderedAccessView())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidUnorderedAccessViewVariable;
-        }
-
-        return (ID3DX11EffectUnorderedAccessViewVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
-
-        if (!pType->IsRenderTargetView())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidRenderTargetViewVariable;
-        }
-
-        return (ID3DX11EffectRenderTargetViewVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
-
-        if (!pType->IsDepthStencilView())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidDepthStencilViewVariable;
-        }
-
-        return (ID3DX11EffectDepthStencilViewVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
-        DPF(0, "%s: Invalid typecast", pFuncName);
-        return &g_InvalidConstantBuffer;
-    }
-
-    STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
-
-        if (!pType->IsShader())
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidShaderVariable;
-        }
-
-        return (ID3DX11EffectShaderVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
-
-        if (!pType->IsObjectType(EOT_Blend))
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidBlendVariable;
-        }
-
-        return (ID3DX11EffectBlendVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
-
-        if (!pType->IsObjectType(EOT_DepthStencil))
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidDepthStencilVariable;
-        }
-
-        return (ID3DX11EffectDepthStencilVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)()
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
-
-        if (!pType->IsObjectType(EOT_Rasterizer))
-        {
-            DPF(0, "%s: Invalid typecast", pFuncName);
-            return &g_InvalidRasterizerVariable;
-        }
-
-        return (ID3DX11EffectRasterizerVariable *) this;
-    }
-
-    STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)()
-    {
-        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)(CONST void *pData, UINT  Offset, UINT  Count) { return ObjectSetRawValue(); }
-    STDMETHOD(GetRawValue)(void *pData, UINT  Offset, UINT  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 = NULL;
-    }
-
-    UINT  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
-    UINT                                        IsSingleElement : 1;
-
-    // Required to create member/element variable interfaces
-    TTopLevelVariable<ID3DX11EffectVariable>    *pTopLevelEntity;
-
-    TMember()
-    {
-        IsSingleElement = FALSE;
-        pTopLevelEntity = NULL;
-    }
-
-    CEffect* GetEffect()
-    {
-        return pTopLevelEntity->pEffect;
-    }
-
-    UINT  GetTotalUnpackedSize()
-    {
-        return pType->GetTotalUnpackedSize(IsSingleElement);
-    }
-
-    STDMETHOD_(ID3DX11EffectType*, GetType)()
-    {
-        if (IsSingleElement)
-        {
-            return pTopLevelEntity->pEffect->CreatePooledSingleElementTypeInterface( pType );
-        }
-        else
-        {
-            return (ID3DX11EffectType*) pType;
-        }
-    }
-
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
-    {
-        HRESULT hr = S_OK;
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
-
-        VERIFYPARAMETER(pDesc != NULL);
-
-        pDesc->Name = pName;
-        pDesc->Semantic = pSemantic;
-        pDesc->Flags = 0;
-
-        if (pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity))
-        {
-            // Is part of an annotation
-            D3DXASSERT(pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric));
-            pDesc->Annotations = 0;
-            pDesc->BufferOffset = 0;
-            pDesc->Flags |= D3DX11_EFFECT_VARIABLE_ANNOTATION;
-        }
-        else
-        {
-            // Is part of a global variable
-            D3DXASSERT(pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity));
-            if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
-            {
-                // strings are funny; their data is reflection data, so ignore those
-                D3DXASSERT(pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric));
-            }
-            
-            pDesc->Annotations = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->AnnotationCount;
-
-            SConstantBuffer *pCB = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->pCB;
-
-            if (pType->BelongsInConstantBuffer())
-            {   
-                D3DXASSERT(pCB != NULL);
-                UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
-                D3DXASSERT(offset == (UINT)offset);
-                pDesc->BufferOffset = (UINT)offset;
-                D3DXASSERT(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size);
-            }
-            else
-            {
-                D3DXASSERT(pCB == NULL);
-                pDesc->BufferOffset = 0;
-            }
-        }
-
-lExit:
-        return hr;
-    }
-
-    TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
-    {
-        return pTopLevelEntity;
-    }
-
-    BOOL IsArray()
-    {
-        return (pType->Elements > 0 && !IsSingleElement);
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index)
-    { return pTopLevelEntity->GetAnnotationByIndex(Index); }
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
-    { return pTopLevelEntity->GetAnnotationByName(Name); }
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
-    { 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)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
-    {
-        HRESULT hr = S_OK;
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
-
-        VERIFYPARAMETER(pDesc != NULL);
-
-        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)(UINT Index)
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByIndex";
-        DPF(0, "%s: Only variables may have annotations", pFuncName);
-        return &g_InvalidScalarVariable;
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
-    {
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByName";
-        DPF(0, "%s: Only variables may have annotations", pFuncName);
-        return &g_InvalidScalarVariable;
-    }
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
-    { return NoParentCB(); }
-
-    void DirtyVariable()
-    {
-        D3DXASSERT(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;
-
-    UINT            AnnotationCount;
-    SAnnotation     *pAnnotations;
-
-    TGlobalVariable()
-    {
-        LastModifiedTime = 0;
-        pCB = NULL;
-        AnnotationCount = 0;
-        pAnnotations = NULL;
-    }
-
-    STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc)
-    {
-        HRESULT hr = S_OK;
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
-
-        VERIFYPARAMETER(pDesc != NULL);
-
-        pDesc->Name = pName;
-        pDesc->Semantic = pSemantic;
-        pDesc->Flags = 0;
-        pDesc->Annotations = AnnotationCount;
-
-        if (pType->BelongsInConstantBuffer())
-        {
-            D3DXASSERT(pCB != NULL);
-            UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
-            D3DXASSERT(offset == (UINT)offset);
-            pDesc->BufferOffset = (UINT)offset;
-            D3DXASSERT(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size );
-        }
-        else
-        {
-            D3DXASSERT(pCB == NULL);
-            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)(UINT Index)
-    {
-        return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
-    }
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name)
-    {
-        return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
-    }
-
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
-    { 
-        if (NULL != pCB)
-        {
-            D3DXASSERT(pType->BelongsInConstantBuffer());
-            return (ID3DX11EffectConstantBuffer*)pCB; 
-        }
-        else
-        {
-            D3DXASSERT(!pType->BelongsInConstantBuffer());
-            return &g_InvalidConstantBuffer;
-        }
-    }
-
-    D3DX11INLINE void DirtyVariable()
-    {
-        D3DXASSERT(NULL != pCB);
-        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)(CONST void *pData, UINT  ByteOffset, UINT  ByteCount) 
-    {
-        if (IsAnnotation)
-        {
-            return AnnotationInvalidSetCall("ID3DX11EffectVariable::SetRawValue");
-        }
-        else
-        {
-            HRESULT hr = S_OK;    
-
-#ifdef _DEBUG
-            LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
-
-            VERIFYPARAMETER(pData);
-
-            if ((ByteOffset + ByteCount < ByteOffset) ||
-                (ByteCount + (BYTE*)pData < (BYTE*)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_bcount(ByteCount) void *pData, UINT  ByteOffset, UINT  ByteCount)
-    {
-        HRESULT hr = S_OK;    
-
-#ifdef _DEBUG
-        LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
-
-        VERIFYPARAMETER(pData);
-
-        if ((ByteOffset + ByteCount < ByteOffset) ||
-            (ByteCount + (BYTE*)pData < (BYTE*)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)(CONST float Value);
-    STDMETHOD(GetFloat)(float *pValue);
-
-    STDMETHOD(SetFloatArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetFloatArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetInt)(CONST int Value);
-    STDMETHOD(GetInt)(int *pValue);
-
-    STDMETHOD(SetIntArray)(CONST int *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetIntArray)(int *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetBool)(CONST BOOL Value);
-    STDMETHOD(GetBool)(BOOL *pValue);
-
-    STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetBoolArray)(BOOL *pData, UINT  Offset, UINT  Count);
-};
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
-{
-    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>
-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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Float, ETVT_Float, float, float>(Data.pNumericFloat, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
-{
-    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>
-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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Float, ETVT_Int, float, int>(Data.pNumericFloat, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
-{
-    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>
-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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT  Offset, UINT  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)(CONST float Value);
-    STDMETHOD(GetFloat)(float *pValue);
-
-    STDMETHOD(SetFloatArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetFloatArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetInt)(CONST int Value);
-    STDMETHOD(GetInt)(int *pValue);
-
-    STDMETHOD(SetIntArray)(CONST int *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetIntArray)(int *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetBool)(CONST BOOL Value);
-    STDMETHOD(GetBool)(BOOL *pValue);
-
-    STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetBoolArray)(BOOL *pData, UINT  Offset, UINT  Count);
-};
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
-{
-    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>
-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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Int, ETVT_Float, int, float>(Data.pNumericInt, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
-{
-    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>
-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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Int, ETVT_Int, int, int>(Data.pNumericInt, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
-{
-    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>
-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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT  Offset, UINT  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)(CONST float Value);
-    STDMETHOD(GetFloat)(float *pValue);
-
-    STDMETHOD(SetFloatArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetFloatArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetInt)(CONST int Value);
-    STDMETHOD(GetInt)(int *pValue);
-
-    STDMETHOD(SetIntArray)(CONST int *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetIntArray)(int *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetBool)(CONST BOOL Value);
-    STDMETHOD(GetBool)(BOOL *pValue);
-
-    STDMETHOD(SetBoolArray)(CONST BOOL *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetBoolArray)(BOOL *pData, UINT  Offset, UINT  Count);
-};
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
-{
-    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>
-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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Bool, ETVT_Float, BOOL, float>(Data.pNumericBool, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetInt(CONST int Value)
-{
-    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>
-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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(CONST int *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, UINT  Offset, UINT  Count)
-{
-    return GetScalarArray<ETVT_Bool, ETVT_Int, BOOL, int>(Data.pNumericBool, pData, Offset, Count, 
-        pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBool(CONST BOOL Value)
-{
-    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>
-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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(CONST BOOL *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(BOOL *pData, UINT  Offset, UINT  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) (CONST BOOL *pData); 
-    STDMETHOD(SetIntVector)  (CONST int *pData);
-    STDMETHOD(SetFloatVector)(CONST float *pData);
-
-    STDMETHOD(GetBoolVector) (BOOL *pData); 
-    STDMETHOD(GetIntVector)  (int *pData);
-    STDMETHOD(GetFloatVector)(float *pData);
-
-
-    STDMETHOD(SetBoolVectorArray) (CONST BOOL *pData, UINT Offset, UINT Count); 
-    STDMETHOD(SetIntVectorArray)  (CONST int *pData, UINT Offset, UINT Count);
-    STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT Count);
-
-    STDMETHOD(GetBoolVectorArray) (BOOL *pData, UINT Offset, UINT Count); 
-    STDMETHOD(GetIntVectorArray)  (int *pData, UINT Offset, UINT Count);
-    STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT Count);
-};
-
-// Note that branches in this code is based on template parameters and will be compiled out
-template <ETemplateVarType DestType, ETemplateVarType SourceType>
-void __forceinline CopyDataWithTypeConversion(__out_bcount(vecCount * dstVecSize * sizeof(UINT)) void *pDest, CONST void *pSource, UINT dstVecSize, UINT srcVecSize, UINT elementCount, UINT vecCount)
-{
-    UINT i, j;
-
-    switch (SourceType)
-    {
-    case ETVT_Bool:
-        switch (DestType)
-        {
-        case ETVT_Bool:
-            for (j=0; j<vecCount; j++)
-            {
-                dwordMemcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
-
-                pDest = ((float*) pDest) + dstVecSize;
-                pSource = ((float*) pSource) + srcVecSize;
-            }
-            break;
-
-        case ETVT_Int:
-            for (j=0; j<vecCount; j++)
-            {
-                for (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 (j=0; j<vecCount; j++)
-            {
-                for (i=0; i<elementCount; i++)
-                    ((float*)pDest)[i] = ((BOOL*)pSource)[i] ? -1.0f : 0.0f;
-
-                pDest = ((float*) pDest) + dstVecSize;
-                pSource = ((float*) pSource) + srcVecSize;
-            }
-            break;
-
-        default:
-            D3DXASSERT(0);
-        }
-        break;
-
-
-    case ETVT_Int:
-        switch (DestType)
-        {
-        case ETVT_Bool:
-            for (j=0; j<vecCount; j++)
-            {
-                for (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 (j=0; j<vecCount; j++)
-            {
-                dwordMemcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
-
-                pDest = ((float*) pDest) + dstVecSize;
-                pSource = ((float*) pSource) + srcVecSize;
-            }
-            break;
-
-        case ETVT_Float:
-            for (j=0; j<vecCount; j++)
-            {
-                for (i=0; i<elementCount; i++)
-                    ((float*)pDest)[i] = (float)(((int*)pSource)[i]);
-
-                pDest = ((float*) pDest) + dstVecSize;
-                pSource = ((float*) pSource) + srcVecSize;
-            }
-            break;
-
-        default:
-            D3DXASSERT(0);
-        }
-        break;
-
-    case ETVT_Float:
-        switch (DestType)
-        {
-        case ETVT_Bool:
-            for (j=0; j<vecCount; j++)
-            {
-                for (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 (j=0; j<vecCount; j++)
-            {
-                for (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 (i=0; i<vecCount; i++)
-            {
-                dwordMemcpy( pDest, pSource, elementCount * SType::c_ScalarSize);
-
-                pDest = ((float*) pDest) + dstVecSize;
-                pSource = ((float*) pSource) + srcVecSize;
-            }
-            break;
-
-        default:
-            D3DXASSERT(0);
-        }
-        break;
-
-    default:
-        D3DXASSERT(0);
-    }
-}
-
-// Float Vector
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetFloatVector(CONST float *pData)
-{
-    HRESULT hr = S_OK;
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVector(float *pData)
-{
-    HRESULT hr = S_OK;
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetIntVector(CONST int *pData)
-{
-    HRESULT hr = S_OK;
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVector(int *pData)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVector";
-
-#ifdef _DEBUG
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetBoolVector(CONST BOOL *pData)
-{
-    HRESULT hr = S_OK;
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVector(BOOL *pData)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVector";
-
-#ifdef _DEBUG
-    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>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetFloatVectorArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
-
-#ifdef _DEBUG
-    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, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVectorArray(float *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
-
-#ifdef _DEBUG
-    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, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
-
-lExit:
-    return hr;
-}
-
-// int
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetIntVectorArray(CONST int *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVectorArray";
-
-#ifdef _DEBUG
-    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, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVectorArray(int *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVectorArray";
-
-#ifdef _DEBUG
-    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, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
-
-lExit:
-    return hr;
-}
-
-// bool
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetBoolVectorArray(CONST BOOL *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVectorArray";
-
-#ifdef _DEBUG
-    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, max(min((int)Count, (int)pType->Elements - (int)Offset), 0));
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation, ETemplateVarType BaseType>
-HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVectorArray(BOOL *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVectorArray";
-
-#ifdef _DEBUG
-    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, max(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)(CONST float *pData);
-    STDMETHOD(GetFloatVector)(float *pData);
-
-    STDMETHOD(SetFloatVectorArray)(CONST float *pData, UINT Offset, UINT  Count);
-    STDMETHOD(GetFloatVectorArray)(float *pData, UINT Offset, UINT  Count);
-};
-
-template<typename IBaseInterface>
-HRESULT TVector4Variable<IBaseInterface>::SetFloatVector(CONST float *pData)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
-
-#ifdef _DEBUG
-    VERIFYPARAMETER(pData);
-#endif
-
-    DirtyVariable();
-    Data.pVector[0] = ((CEffectVector4*) pData)[0];
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TVector4Variable<IBaseInterface>::GetFloatVector(float *pData)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
-
-#ifdef _DEBUG
-    VERIFYPARAMETER(pData);
-#endif
-
-    dwordMemcpy(pData, Data.pVector, pType->NumericType.Columns * SType::c_ScalarSize);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TVector4Variable<IBaseInterface>::SetFloatVectorArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
-
-#ifdef _DEBUG
-    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
-    dwordMemcpy(Data.pVector + Offset, pData, min((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TVector4Variable<IBaseInterface>::GetFloatVectorArray(float *pData, UINT  Offset, UINT  Count)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
-
-#ifdef _DEBUG
-    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
-    dwordMemcpy(pData, Data.pVector + Offset, min((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)(CONST float *pData);
-    STDMETHOD(GetMatrix)(float *pData);
-
-    STDMETHOD(SetMatrixArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetMatrixPointerArray)(CONST float **ppData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixPointerArray)(float **ppData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetMatrixTranspose)(CONST float *pData);
-    STDMETHOD(GetMatrixTranspose)(float *pData);
-
-    STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetMatrixTransposePointerArray)(CONST float **ppData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixTransposePointerArray)(float **ppData, UINT  Offset, UINT  Count);
-};
-
-template<BOOL Transpose>
-static void SetMatrixTransposeHelper(SType *pType, __out_bcount(64) BYTE *pDestData, CONST float* pMatrix)
-{
-    UINT i, j;
-    UINT 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 (i = 0; i < registers; ++ i)
-    {
-        for (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(SType *pType, __in_bcount(64) BYTE *pSrcData, __out_ecount(16) float* pMatrix)
-{
-    UINT i, j;
-    UINT 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 (i = 0; i < registers; ++ i)
-    {
-        for (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(SType *pType, UINT  TotalUnpackedSize, BYTE *pEffectData, void *pMatrixData, UINT  Offset, UINT  Count, LPCSTR pFuncName)
-{    
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
-    {
-        DPF(0, "%s: Invalid range specified", pFuncName);
-        VH(E_INVALIDARG);
-    }
-#endif
-
-    UINT i;
-
-    if ((pType->NumericType.IsColumnMajor && Transpose) || (!pType->NumericType.IsColumnMajor && !Transpose))
-    {
-        // fast path
-        UINT  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 (i = 0; i < Count; ++ i)
-        {
-            CEffectMatrix *pMatrix;
-            if (ExtraIndirection)
-            {
-                pMatrix = ((CEffectMatrix **)pMatrixData)[i];
-                if (!pMatrix)
-                {
-                    continue;
-                }
-            }
-            else
-            {
-                pMatrix = ((CEffectMatrix *)pMatrixData) + i;
-            }
-
-            if (IsSetting)
-            {
-                dwordMemcpy(pEffectData + pType->Stride * (i + Offset), pMatrix, dataSize);
-            }
-            else
-            {
-                dwordMemcpy(pMatrix, pEffectData + pType->Stride * (i + Offset), dataSize);
-            }
-        }
-    }
-    else
-    {
-        // slow path
-        for (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;
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrix(CONST float *pData)
-{
-    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>
-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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return DoMatrixArrayInternal<FALSE, FALSE, FALSE>(pType, GetTotalUnpackedSize(), 
-        Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixPointerArray(CONST float **ppData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixPointerArray(float **ppData, UINT  Offset, UINT  Count)
-{
-    return DoMatrixArrayInternal<FALSE, FALSE, TRUE>(pType, GetTotalUnpackedSize(), 
-        Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixPointerArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTranspose(CONST float *pData)
-{
-    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>
-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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposeArray(CONST float *pData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposeArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return DoMatrixArrayInternal<TRUE, FALSE, FALSE>(pType, GetTotalUnpackedSize(), 
-        Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposePointerArray(CONST float **ppData, UINT  Offset, UINT  Count)
-{
-    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>
-HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposePointerArray(float **ppData, UINT  Offset, UINT  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)(CONST float *pData);
-    STDMETHOD(GetMatrix)(float *pData);
-
-    STDMETHOD(SetMatrixArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixArray)(float *pData, UINT  Offset, UINT  Count);
-
-    STDMETHOD(SetMatrixTranspose)(CONST float *pData);
-    STDMETHOD(GetMatrixTranspose)(float *pData);
-
-    STDMETHOD(SetMatrixTransposeArray)(CONST float *pData, UINT  Offset, UINT  Count);
-    STDMETHOD(GetMatrixTransposeArray)(float *pData, UINT  Offset, UINT  Count);
-};
-
-D3DX11INLINE static void Matrix4x4TransposeHelper(CONST void *pSrc, void *pDst)
-{
-    BYTE *pDestData = (BYTE*)pDst;
-    UINT *pMatrix = (UINT*)pSrc;
-
-    ((UINT*)pDestData)[0 * 4 + 0] = pMatrix[0 * 4 + 0];
-    ((UINT*)pDestData)[0 * 4 + 1] = pMatrix[1 * 4 + 0];
-    ((UINT*)pDestData)[0 * 4 + 2] = pMatrix[2 * 4 + 0];
-    ((UINT*)pDestData)[0 * 4 + 3] = pMatrix[3 * 4 + 0];
-
-    ((UINT*)pDestData)[1 * 4 + 0] = pMatrix[0 * 4 + 1];
-    ((UINT*)pDestData)[1 * 4 + 1] = pMatrix[1 * 4 + 1];
-    ((UINT*)pDestData)[1 * 4 + 2] = pMatrix[2 * 4 + 1];
-    ((UINT*)pDestData)[1 * 4 + 3] = pMatrix[3 * 4 + 1];
-
-    ((UINT*)pDestData)[2 * 4 + 0] = pMatrix[0 * 4 + 2];
-    ((UINT*)pDestData)[2 * 4 + 1] = pMatrix[1 * 4 + 2];
-    ((UINT*)pDestData)[2 * 4 + 2] = pMatrix[2 * 4 + 2];
-    ((UINT*)pDestData)[2 * 4 + 3] = pMatrix[3 * 4 + 2];
-
-    ((UINT*)pDestData)[3 * 4 + 0] = pMatrix[0 * 4 + 3];
-    ((UINT*)pDestData)[3 * 4 + 1] = pMatrix[1 * 4 + 3];
-    ((UINT*)pDestData)[3 * 4 + 2] = pMatrix[2 * 4 + 3];
-    ((UINT*)pDestData)[3 * 4 + 3] = pMatrix[3 * 4 + 3];
-}
-
-D3DX11INLINE static void Matrix4x4Copy(CONST void *pSrc, 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 *pDestData = (UINT64*)pDst;
-    UINT64 *pMatrix = (UINT64*)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
-    UINT *pDestData = (UINT*)pDst;
-    UINT *pMatrix = (UINT*)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
-template<BOOL IsColumnMajor, BOOL Transpose, BOOL IsSetting>
-D3DX11INLINE HRESULT DoMatrix4x4ArrayInternal(BYTE *pEffectData, void *pMatrixData, UINT  Offset, UINT  Count
-
-#ifdef _DEBUG
-                                              , SType *pType, UINT  TotalUnpackedSize, LPCSTR pFuncName)
-#else
-                                              )
-#endif
-{    
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
-    {
-        DPF(0, "%s: Invalid range specified", pFuncName);
-        VH(E_INVALIDARG);
-    }
-
-    D3DXASSERT(pType->NumericType.IsColumnMajor == IsColumnMajor && pType->Stride == (4 * SType::c_RegisterSize));
-#endif
-
-    UINT i;
-
-    if ((IsColumnMajor && Transpose) || (!IsColumnMajor && !Transpose))
-    {
-        // fast path
-        for (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 (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;
-}
-
-template<typename IBaseInterface, BOOL IsColumnMajor>
-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>
-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>
-HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixArray(CONST float *pData, UINT  Offset, UINT  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>
-HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixArray(float *pData, UINT  Offset, UINT  Count)
-{
-    return DoMatrix4x4ArrayInternal<IsColumnMajor, FALSE, FALSE>(Data.pNumeric, pData, Offset, Count
-#ifdef _DEBUG 
-        , pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixArray");
-#else
-        );
-#endif
-}
-
-template<typename IBaseInterface, BOOL IsColumnMajor>
-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>
-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>
-HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTransposeArray(CONST float *pData, UINT  Offset, UINT  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>
-HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTransposeArray(float *pData, UINT  Offset, UINT  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) \
-    UINT 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) \
-    UINT 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; \
-    UINT 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)(LPCSTR *ppString);
-    STDMETHOD(GetStringArray)( __out_ecount(Count) LPCSTR *ppStrings, UINT  Offset, UINT  Count );
-};
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetString(LPCSTR *ppString)
-{
-    HRESULT hr = S_OK;
-    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;
-    }
-
-    D3DXASSERT(NULL != Data.pString);
-
-    *ppString = Data.pString->pString;
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface, BOOL IsAnnotation>
-HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetStringArray( __out_ecount(Count) LPCSTR *ppStrings, UINT  Offset, UINT  Count)
-{
-    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;
-    }
-
-    D3DXASSERT(NULL != Data.pString);
-
-    UINT i;
-    for (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)(ID3D11ClassInstance **ppClassInstance);
-};
-
-template<typename IBaseClassInstance>
-HRESULT TClassInstanceVariable<IBaseClassInstance>::GetClassInstance(ID3D11ClassInstance** ppClassInstance)
-{
-    HRESULT hr = S_OK;
-    LPCSTR pFuncName = "ID3DX11EffectClassInstanceVariable::GetClassInstance";
-
-    D3DXASSERT( pMemberData != NULL );
-    *ppClassInstance = pMemberData->Data.pD3DClassInstance;
-    SAFE_ADDREF(*ppClassInstance);
-
-lExit:
-    return hr;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectInterfaceeVariable (TInterfaceVariable implementation)
-//////////////////////////////////////////////////////////////////////////
-
-template<typename IBaseInterface>
-struct TInterfaceVariable : public IBaseInterface
-{
-    STDMETHOD(SetClassInstance)(ID3DX11EffectClassInstanceVariable *pEffectClassInstance);
-    STDMETHOD(GetClassInstance)(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance);
-};
-
-template<typename IBaseInterface>
-HRESULT TInterfaceVariable<IBaseInterface>::SetClassInstance(ID3DX11EffectClassInstanceVariable *pEffectClassInstance)
-{
-    HRESULT hr = S_OK;
-    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(ID3DX11EffectClassInstanceVariable **ppEffectClassInstance)
-{
-    HRESULT hr = S_OK;
-    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)(ID3D11ShaderResourceView *pResource);
-    STDMETHOD(GetResource)(ID3D11ShaderResourceView **ppResource);
-
-    STDMETHOD(SetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count);
-    STDMETHOD(GetResourceArray)(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count);
-};
-
-static LPCSTR GetTextureTypeNameFromEnum(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(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(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(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(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(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(ID3D11ShaderResourceView *pView, EObjectType ObjectType, LPCSTR pFuncName)
-{
-    if (NULL != 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 = NULL;
-                pView->GetResource( (ID3D11Resource**)&pBuffer );
-                D3DXASSERT( pBuffer != NULL );
-                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 = NULL;
-                pView->GetResource( (ID3D11Resource**)&pBuffer );
-                D3DXASSERT( pBuffer != NULL );
-                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:
-            D3DXASSERT(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>
-HRESULT TShaderResourceVariable<IBaseInterface>::SetResource(ID3D11ShaderResourceView *pResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    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>
-HRESULT TShaderResourceVariable<IBaseInterface>::GetResource(ID3D11ShaderResourceView **ppResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResource";
-
-    VERIFYPARAMETER(ppResource);
-#endif
-
-    *ppResource = Data.pShaderResource->pShaderResource;
-    SAFE_ADDREF(*ppResource);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderResourceVariable<IBaseInterface>::SetResourceArray(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResourceArray";
-    UINT i;
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-#ifdef _DEBUG
-    for (i = 0; i < Count; ++ i)
-    {
-        VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
-    }
-#endif
-
-    // Texture variables don't need to be dirtied.
-    for (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>
-HRESULT TShaderResourceVariable<IBaseInterface>::GetResourceArray(ID3D11ShaderResourceView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResourceArray";
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    UINT i;
-    for (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)(ID3D11UnorderedAccessView *pResource);
-    STDMETHOD(GetUnorderedAccessView)(ID3D11UnorderedAccessView **ppResource);
-
-    STDMETHOD(SetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count);
-    STDMETHOD(GetUnorderedAccessViewArray)(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count);
-};
-
-static HRESULT ValidateTextureType(ID3D11UnorderedAccessView *pView, EObjectType ObjectType, LPCSTR pFuncName)
-{
-    if (NULL != 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 = NULL;
-                pView->GetResource( (ID3D11Resource**)&pBuffer );
-                D3DXASSERT( pBuffer != NULL );
-                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 = NULL;
-                pView->GetResource( (ID3D11Resource**)&pBuffer );
-                D3DXASSERT( pBuffer != NULL );
-                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:
-            D3DXASSERT(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>
-HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessView(ID3D11UnorderedAccessView *pResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    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>
-HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessView(ID3D11UnorderedAccessView **ppResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessView";
-
-    VERIFYPARAMETER(ppResource);
-#endif
-
-    *ppResource = Data.pUnorderedAccessView->pUnorderedAccessView;
-    SAFE_ADDREF(*ppResource);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessViewArray";
-    UINT i;
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-#ifdef _DEBUG
-    for (i = 0; i < Count; ++ i)
-    {
-        VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
-    }
-#endif
-
-    // Texture variables don't need to be dirtied.
-    for (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>
-HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessViewArray";
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    UINT i;
-    for (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)(ID3D11RenderTargetView *pResource);
-    STDMETHOD(GetRenderTarget)(ID3D11RenderTargetView **ppResource);
-
-    STDMETHOD(SetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count);
-    STDMETHOD(GetRenderTargetArray)(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count);
-};
-
-
-template<typename IBaseInterface>
-HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTarget(ID3D11RenderTargetView *pResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    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>
-HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTarget(ID3D11RenderTargetView **ppResource)
-{
-    HRESULT hr = S_OK;
-
-    *ppResource = Data.pRenderTargetView->pRenderTargetView;
-    SAFE_ADDREF(*ppResource);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTargetArray(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTargetArray";
-    UINT i;
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    // Texture variables don't need to be dirtied.
-    for (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>
-HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTargetArray(ID3D11RenderTargetView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::GetRenderTargetArray";
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    UINT i;
-    for (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)(ID3D11DepthStencilView *pResource);
-    STDMETHOD(GetDepthStencil)(ID3D11DepthStencilView **ppResource);
-
-    STDMETHOD(SetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count);
-    STDMETHOD(GetDepthStencilArray)(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count);
-};
-
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencil(ID3D11DepthStencilView *pResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    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>
-HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencil(ID3D11DepthStencilView **ppResource)
-{
-    HRESULT hr = S_OK;
-
-#ifdef _DEBUG
-    LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencil";
-
-    VERIFYPARAMETER(ppResource);
-#endif
-
-    *ppResource = Data.pDepthStencilView->pDepthStencilView;
-    SAFE_ADDREF(*ppResource);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencilArray(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencilArray";
-    UINT i;
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    // Texture variables don't need to be dirtied.
-    for (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>
-HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencilArray(ID3D11DepthStencilView **ppResources, UINT  Offset, UINT  Count)
-{
-    LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencilArray";
-
-    CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
-
-    UINT i;
-    for (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)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc);
-
-    STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS);
-    STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS);
-    STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS);
-    STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS);
-    STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS);
-    STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS);
-
-    STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-    STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-    STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
-
-    STDMETHOD_(BOOL, IsValid)();
-};
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetShaderDesc(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
-
-    Data.pShader[ShaderIndex].GetShaderDesc(pDesc, FALSE);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetVertexShader(UINT ShaderIndex, ID3D11VertexShader **ppVS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppVS);
-
-    VH( Data.pShader[ShaderIndex].GetVertexShader(ppVS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetGeometryShader(UINT ShaderIndex, ID3D11GeometryShader **ppGS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppGS);
-
-    VH( Data.pShader[ShaderIndex].GetGeometryShader(ppGS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetPixelShader(UINT ShaderIndex, ID3D11PixelShader **ppPS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppPS);
-
-    VH( Data.pShader[ShaderIndex].GetPixelShader(ppPS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetHullShader(UINT ShaderIndex, ID3D11HullShader **ppHS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppHS);
-
-    VH( Data.pShader[ShaderIndex].GetHullShader(ppHS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetDomainShader(UINT ShaderIndex, ID3D11DomainShader **ppDS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppDS);
-
-    VH( Data.pShader[ShaderIndex].GetDomainShader(ppDS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetComputeShader(UINT ShaderIndex, ID3D11ComputeShader **ppCS)
-{
-    LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppCS);
-
-    VH( Data.pShader[ShaderIndex].GetComputeShader(ppCS) );
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TShaderVariable<IBaseInterface>::GetInputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    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>
-HRESULT TShaderVariable<IBaseInterface>::GetOutputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    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>
-HRESULT TShaderVariable<IBaseInterface>::GetPatchConstantSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
-{
-    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()
-{
-    UINT 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)(UINT Index, ID3D11BlendState **ppBlendState);
-    STDMETHOD(SetBlendState)(UINT Index, ID3D11BlendState *pBlendState);
-    STDMETHOD(UndoSetBlendState)(UINT Index);
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_BLEND_DESC *pBlendDesc);
-    STDMETHOD_(BOOL, IsValid)();
-};
-
-template<typename IBaseInterface>
-HRESULT TBlendVariable<IBaseInterface>::GetBlendState(UINT Index, ID3D11BlendState **ppBlendState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBlendState";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(Index, ppBlendState);
-
-    *ppBlendState = Data.pBlend[Index].pBlendObject;
-    SAFE_ADDREF(*ppBlendState);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TBlendVariable<IBaseInterface>::SetBlendState(UINT Index, ID3D11BlendState *pBlendState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectBlendState::SetBlendState";
-
-    CHECK_SCALAR_BOUNDS(Index);
-
-    if( !Data.pBlend[Index].IsUserManaged )
-    {
-        // Save original state object in case we UndoSet
-        D3DXASSERT( pMemberData[Index].Type == MDT_BlendState );
-        VB( pMemberData[Index].Data.pD3DEffectsManagedBlendState == NULL );
-        pMemberData[Index].Data.pD3DEffectsManagedBlendState = Data.pBlend[Index].pBlendObject;
-        Data.pBlend[Index].pBlendObject = NULL;
-        Data.pBlend[Index].IsUserManaged = TRUE;
-    }
-
-    SAFE_ADDREF( pBlendState );
-    SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
-    Data.pBlend[Index].pBlendObject = pBlendState;
-    Data.pBlend[Index].IsValid = TRUE;
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TBlendVariable<IBaseInterface>::UndoSetBlendState(UINT Index)
-{
-    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 = NULL;
-    Data.pBlend[Index].IsUserManaged = FALSE;
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TBlendVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_BLEND_DESC *pBlendDesc)
-{
-    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()
-{
-    UINT 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)(UINT Index, ID3D11DepthStencilState **ppDepthStencilState);
-    STDMETHOD(SetDepthStencilState)(UINT Index, ID3D11DepthStencilState *pDepthStencilState);
-    STDMETHOD(UndoSetDepthStencilState)(UINT Index);
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc);
-    STDMETHOD_(BOOL, IsValid)();
-};
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilVariable<IBaseInterface>::GetDepthStencilState(UINT Index, ID3D11DepthStencilState **ppDepthStencilState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetDepthStencilState";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(Index, ppDepthStencilState);
-
-    *ppDepthStencilState = Data.pDepthStencil[Index].pDSObject;
-    SAFE_ADDREF(*ppDepthStencilState);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilVariable<IBaseInterface>::SetDepthStencilState(UINT Index, ID3D11DepthStencilState *pDepthStencilState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::SetDepthStencilState";
-
-    CHECK_SCALAR_BOUNDS(Index);
-
-    if( !Data.pDepthStencil[Index].IsUserManaged )
-    {
-        // Save original state object in case we UndoSet
-        D3DXASSERT( pMemberData[Index].Type == MDT_DepthStencilState );
-        VB( pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState == NULL );
-        pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = Data.pDepthStencil[Index].pDSObject;
-        Data.pDepthStencil[Index].pDSObject = NULL;
-        Data.pDepthStencil[Index].IsUserManaged = TRUE;
-    }
-
-    SAFE_ADDREF( pDepthStencilState );
-    SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
-    Data.pDepthStencil[Index].pDSObject = pDepthStencilState;
-    Data.pDepthStencil[Index].IsValid = TRUE;
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilVariable<IBaseInterface>::UndoSetDepthStencilState(UINT Index)
-{
-    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 = NULL;
-    Data.pDepthStencil[Index].IsUserManaged = FALSE;
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TDepthStencilVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc)
-{
-    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()
-{
-    UINT 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)(UINT Index, ID3D11RasterizerState **ppRasterizerState);
-    STDMETHOD(SetRasterizerState)(UINT Index, ID3D11RasterizerState *pRasterizerState);
-    STDMETHOD(UndoSetRasterizerState)(UINT Index);
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc);
-    STDMETHOD_(BOOL, IsValid)();
-};
-
-template<typename IBaseInterface>
-HRESULT TRasterizerVariable<IBaseInterface>::GetRasterizerState(UINT Index, ID3D11RasterizerState **ppRasterizerState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetRasterizerState";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(Index, ppRasterizerState);
-
-    *ppRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
-    SAFE_ADDREF(*ppRasterizerState);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TRasterizerVariable<IBaseInterface>::SetRasterizerState(UINT Index, ID3D11RasterizerState *pRasterizerState)
-{
-    LPCSTR pFuncName = "ID3DX11EffectRasterizerState::SetRasterizerState";
-
-    CHECK_SCALAR_BOUNDS(Index);
-
-    if( !Data.pRasterizer[Index].IsUserManaged )
-    {
-        // Save original state object in case we UndoSet
-        D3DXASSERT( pMemberData[Index].Type == MDT_RasterizerState );
-        VB( pMemberData[Index].Data.pD3DEffectsManagedRasterizerState == NULL );
-        pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
-        Data.pRasterizer[Index].pRasterizerObject = NULL;
-        Data.pRasterizer[Index].IsUserManaged = TRUE;
-    }
-
-    SAFE_ADDREF( pRasterizerState );
-    SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
-    Data.pRasterizer[Index].pRasterizerObject = pRasterizerState;
-    Data.pRasterizer[Index].IsValid = TRUE;
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TRasterizerVariable<IBaseInterface>::UndoSetRasterizerState(UINT Index)
-{
-    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 = NULL;
-    Data.pRasterizer[Index].IsUserManaged = FALSE;
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TRasterizerVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc)
-{
-    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()
-{
-    UINT 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)(UINT Index, ID3D11SamplerState **ppSampler);
-    STDMETHOD(SetSampler)(UINT Index, ID3D11SamplerState *pSampler);
-    STDMETHOD(UndoSetSampler)(UINT Index);
-    STDMETHOD(GetBackingStore)(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc);
-};
-
-template<typename IBaseInterface>
-HRESULT TSamplerVariable<IBaseInterface>::GetSampler(UINT Index, ID3D11SamplerState **ppSampler)
-{
-    LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetSampler";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(Index, ppSampler);
-
-    *ppSampler = Data.pSampler[Index].pD3DObject;
-    SAFE_ADDREF(*ppSampler);
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TSamplerVariable<IBaseInterface>::SetSampler(UINT Index, ID3D11SamplerState *pSampler)
-{
-    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
-        D3DXASSERT( pMemberData[Index].Type == MDT_SamplerState );
-        VB( pMemberData[Index].Data.pD3DEffectsManagedSamplerState == NULL );
-        pMemberData[Index].Data.pD3DEffectsManagedSamplerState = Data.pSampler[Index].pD3DObject;
-        Data.pSampler[Index].pD3DObject = NULL;
-        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(UINT Index)
-{
-    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 = NULL;
-    Data.pSampler[Index].IsUserManaged = FALSE;
-
-lExit:
-    return hr;
-}
-
-template<typename IBaseInterface>
-HRESULT TSamplerVariable<IBaseInterface>::GetBackingStore(UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc)
-{
-    LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetBackingStore";
-
-    CHECK_OBJECT_SCALAR_BOUNDS(Index, pSamplerDesc);
-
-    if( Data.pSampler[Index].IsUserManaged )
-    {
-        if( Data.pSampler[Index].pD3DObject )
-        {
-            Data.pSampler[Index].pD3DObject->GetDesc( pSamplerDesc );
-        }
-        else
-        {
-            *pSamplerDesc = 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(pSamplerDesc, &pBlock->BackingStore.SamplerDesc, sizeof(D3D11_SAMPLER_DESC));
-    }
-
-lExit:
-    return hr;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// TUncastableVariable
-////////////////////////////////////////////////////////////////////////////////
-
-template<typename IBaseInterface>
-struct TUncastableVariable : public IBaseInterface
-{
-    STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)();
-    STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)();
-    STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)();
-    STDMETHOD_(ID3DX11EffectStringVariable*, AsString)();
-    STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)();
-    STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)();
-    STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)();
-    STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)();
-    STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)();
-    STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)();
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)();
-    STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)();
-    STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)();
-    STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)();
-    STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)();
-    STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)();
-};
-
-template<typename IBaseInterface>
-ID3DX11EffectScalarVariable * TUncastableVariable<IBaseInterface>::AsScalar()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidScalarVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectVectorVariable * TUncastableVariable<IBaseInterface>::AsVector()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidVectorVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectMatrixVariable * TUncastableVariable<IBaseInterface>::AsMatrix()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidMatrixVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectStringVariable * TUncastableVariable<IBaseInterface>::AsString()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidStringVariable;
-}
-
-template<typename IBaseClassInstance>
-ID3DX11EffectClassInstanceVariable * TUncastableVariable<IBaseClassInstance>::AsClassInstance()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidClassInstanceVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectInterfaceVariable * TUncastableVariable<IBaseInterface>::AsInterface()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidInterfaceVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectShaderResourceVariable * TUncastableVariable<IBaseInterface>::AsShaderResource()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidShaderResourceVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectUnorderedAccessViewVariable * TUncastableVariable<IBaseInterface>::AsUnorderedAccessView()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidUnorderedAccessViewVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectRenderTargetViewVariable * TUncastableVariable<IBaseInterface>::AsRenderTargetView()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidRenderTargetViewVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectDepthStencilViewVariable * TUncastableVariable<IBaseInterface>::AsDepthStencilView()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidDepthStencilViewVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectConstantBuffer * TUncastableVariable<IBaseInterface>::AsConstantBuffer()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidConstantBuffer;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectShaderVariable * TUncastableVariable<IBaseInterface>::AsShader()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidShaderVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectBlendVariable * TUncastableVariable<IBaseInterface>::AsBlend()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidBlendVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectDepthStencilVariable * TUncastableVariable<IBaseInterface>::AsDepthStencil()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidDepthStencilVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectRasterizerVariable * TUncastableVariable<IBaseInterface>::AsRasterizer()
-{
-    LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
-    DPF(0, "%s: Invalid typecast", pFuncName);
-    return &g_InvalidRasterizerVariable;
-}
-
-template<typename IBaseInterface>
-ID3DX11EffectSamplerVariable * TUncastableVariable<IBaseInterface>::AsSampler()
-{
-    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> { }; \
-struct S##Type##Annotation : public T##Type##Variable<TAnnotation<BaseInterface>, TRUE> { }; \
-struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, FALSE> { }; \
-struct S##Type##AnnotationMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, TRUE> { };
-
-#define GenerateVectorReflectionClasses(Type, BaseType, BaseInterface) \
-struct S##Type##GlobalVariable : public TVectorVariable<TGlobalVariable<BaseInterface>, FALSE, BaseType> { }; \
-struct S##Type##Annotation : public TVectorVariable<TAnnotation<BaseInterface>, TRUE, BaseType> { }; \
-struct S##Type##GlobalVariableMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, FALSE, BaseType> { }; \
-struct S##Type##AnnotationMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, TRUE, BaseType> { };
-
-#define GenerateReflectionGlobalOnlyClasses(Type) \
-struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<ID3DX11Effect##Type##Variable> > { }; \
-struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<ID3DX11Effect##Type##Variable> > > { }; \
-
-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> { };
-struct SMatrix4x4RowMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, FALSE> { };
-
-struct SMatrix4x4ColumnMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, TRUE> { };
-struct SMatrix4x4RowMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, FALSE> { };
-
-// Optimized vector classes
-struct SFloatVector4GlobalVariable : public TVector4Variable<TGlobalVariable<ID3DX11EffectVectorVariable> > { };
-struct SFloatVector4GlobalVariableMember : public TVector4Variable<TVariable<TMember<ID3DX11EffectVectorVariable> > > { };
-
-// 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(void *pVar, SType *pType, BOOL IsAnnotation);
-SMember * CreateNewMember(SType *pType, BOOL IsAnnotation);
-
-
diff --git a/sample/d3d11/Effects11/Inc/d3dx11dbg.h b/sample/d3d11/Effects11/Inc/d3dx11dbg.h
deleted file mode 100644
index 49ed3b3..0000000
--- a/sample/d3d11/Effects11/Inc/d3dx11dbg.h
+++ /dev/null
@@ -1,66 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       d3dx11dbg.h
-//  Content:    D3DX11 debugging functions
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-#ifndef __D3DX11DBG_H__
-#define __D3DX11DBG_H__
-
-#ifndef _PREFAST_
-
-#pragma warning( disable: 4068 )
-
-#endif
-
-
-#include <strsafe.h>
-#include <new>
-
-#undef NEW
-#undef DELETE
-
-#define NEW new (std::nothrow)
-#define NEW_PROTO_ARGS size_t s, const std::nothrow_t& t
-
-
-
-typedef signed char    INT8;
-typedef signed short   INT16;
-typedef unsigned char  UINT8;
-typedef unsigned short UINT16;
-
-
-//----------------------------------------------------------------------------
-// DPF
-//----------------------------------------------------------------------------
-
-#ifdef FXDPF
-void cdecl D3DXDebugPrintf(UINT lvl, LPCSTR szFormat, ...);
-#define DPF D3DXDebugPrintf
-#else // !FXDPF
-#pragma warning(disable:4002)
-#define DPF() 0
-#endif // !FXDPF
-
-
-//----------------------------------------------------------------------------
-// D3DXASSERT
-//----------------------------------------------------------------------------
-
-#if _DEBUG
-int WINAPI D3DXDebugAssert(LPCSTR szFile, int nLine, LPCSTR szCondition);
-#define D3DXASSERT(condition) \
-    do { if(!(condition)) D3DXDebugAssert(__FILE__, __LINE__, #condition); } while(0)
-#else // !_DEBUG
-#define D3DXASSERT(condition) 0
-#endif // !_DEBUG
-
-
-
-#endif // __D3DX11DBG_H__
-
diff --git a/sample/d3d11/Effects11/Inc/d3dx11effect.h b/sample/d3d11/Effects11/Inc/d3dx11effect.h
deleted file mode 100644
index fc162fc..0000000
--- a/sample/d3d11/Effects11/Inc/d3dx11effect.h
+++ /dev/null
@@ -1,1566 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (c) Microsoft Corporation.  All rights reserved.
-//
-//  File:       D3DX11Effect.h
-//  Content:    D3DX11 Effect Types & APIs Header
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef __D3DX11EFFECT_H__
-#define __D3DX11EFFECT_H__
-
-#include "d3d11.h" 
-#include "d3d11shader.h"
-
-//////////////////////////////////////////////////////////////////////////////
-// 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
-
-typedef struct _D3DX11_STATE_BLOCK_MASK
-{
-    BYTE VS;
-    BYTE VSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE VSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE VSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE VSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-    
-    BYTE HS;
-    BYTE HSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE HSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE HSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE HSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-
-    BYTE DS;
-    BYTE DSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE DSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE DSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE DSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-
-    BYTE GS;
-    BYTE GSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE GSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE GSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE GSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-    
-    BYTE PS;
-    BYTE PSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE PSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE PSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE PSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-    BYTE PSUnorderedAccessViews;
-    
-    BYTE CS;
-    BYTE CSSamplers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT)];
-    BYTE CSShaderResources[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE CSConstantBuffers[D3DX11_BYTES_FROM_BITS(D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)];
-    BYTE CSInterfaces[D3DX11_BYTES_FROM_BITS(D3D11_SHADER_MAX_INTERFACES)];
-    BYTE CSUnorderedAccessViews;
-
-    BYTE IAVertexBuffers[D3DX11_BYTES_FROM_BITS(D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT)];
-    BYTE IAIndexBuffer;
-    BYTE IAInputLayout;
-    BYTE IAPrimitiveTopology;
-    
-    BYTE OMRenderTargets;
-    BYTE OMDepthStencilState;
-    BYTE OMBlendState;
-    
-    BYTE RSViewports;
-    BYTE RSScissorRects;
-    BYTE RSRasterizerState;
-    
-    BYTE SOBuffers;
-    
-    BYTE Predication;
-} D3DX11_STATE_BLOCK_MASK;
-
-//----------------------------------------------------------------------------
-// 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)
-
-// These are the only valid parameter flags to 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)
-
-//----------------------------------------------------------------------------
-// D3DX11_EFFECT_PASS flags:
-// ----------------------------
-//
-// These flags modify the effect cloning process and are passed into Clone.
-//
-// D3DX11_EFFECT_PASS_COMMIT_CHANGES
-//   This flag tells the effect runtime to assume that the device state was 
-//   not modified outside of effects, so that only updated state needs to
-//   be set.
-//
-// D3DX11_EFFECT_PASS_OMIT_*
-//   When applying a pass, do not set the state indicated in the flag name.
-//----------------------------------------------------------------------------
-
-#define D3DX11_EFFECT_PASS_COMMIT_CHANGES               (1 << 0)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_SHADERS_AND_INTERFACES  (1 << 1)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_STATE_OBJECTS           (1 << 2)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_RTVS_AND_DSVS           (1 << 3)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_SAMPLERS                (1 << 4)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_CBS                     (1 << 5)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_SRVS                    (1 << 6)    // TODO: not yet implemented
-#define D3DX11_EFFECT_PASS_OMIT_UAVS                    (1 << 7)    // TODO: not yet implemented
-
-#define D3DX11_EFFECT_PASS_ONLY_SET_SHADERS_AND_CBS   ( D3DX11_EFFECT_PASS_OMIT_STATE_OBJECTS | \
-                                                        D3DX11_EFFECT_PASS_OMIT_RTVS_AND_DSVS | \
-                                                        D3DX11_EFFECT_PASS_OMIT_SAMPLERS | \
-                                                        D3DX11_EFFECT_PASS_OMIT_SRVS | \
-                                                        D3DX11_EFFECT_PASS_OMIT_UAVS );
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectType //////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_EFFECT_TYPE_DESC:
-//
-// Retrieved by ID3DX11EffectType::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_EFFECT_TYPE_DESC
-{
-    LPCSTR  TypeName;               // Name of the type 
-                                    // (e.g. "float4" or "MyStruct")
-
-    D3D10_SHADER_VARIABLE_CLASS    Class;  // (e.g. scalar, vector, object, etc.)
-    D3D10_SHADER_VARIABLE_TYPE     Type;   // (e.g. float, texture, vertexshader, etc.)
-    
-    UINT    Elements;               // Number of elements in this type
-                                    // (0 if not an array) 
-    UINT    Members;                // Number of members
-                                    // (0 if not a structure)
-    UINT    Rows;                   // Number of rows in this type
-                                    // (0 if not a numeric primitive)
-    UINT    Columns;                // Number of columns in this type
-                                    // (0 if not a numeric primitive)
-    
-    UINT    PackedSize;             // Number of bytes required to represent
-                                    // this data type, when tightly packed
-    UINT    UnpackedSize;           // Number of bytes occupied by this data
-                                    // type, when laid out in a constant buffer
-    UINT    Stride;                 // Number of bytes to seek between elements,
-                                    // when laid out in a constant buffer
-} D3DX11_EFFECT_TYPE_DESC;
-
-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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_TYPE_DESC *pDesc) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    STDMETHOD_(LPCSTR, GetMemberName)(THIS_ UINT Index) PURE;
-    STDMETHOD_(LPCSTR, GetMemberSemantic)(THIS_ UINT Index) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectVariable //////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_EFFECT_VARIABLE_DESC:
-//
-// Retrieved by ID3DX11EffectVariable::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef 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 (NULL for 
-                                    // annotations or if not present)
-    
-    UINT    Flags;                  // D3DX11_EFFECT_VARIABLE_* flags
-    UINT    Annotations;            // Number of annotations on this variable
-                                    // (always 0 for annotations)
-
-    UINT    BufferOffset;           // Offset into containing cbuffer or tbuffer
-                                    // (always 0 for annotations or variables
-                                    // not in constant buffers)
-
-    UINT    ExplicitBindPoint;      // Used if the variable has been explicitly bound
-                                    // using the register keyword. Check Flags for
-                                    // D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
-} D3DX11_EFFECT_VARIABLE_DESC;
-
-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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    
-    STDMETHOD(SetFloat)(THIS_ CONST float Value) PURE;
-    STDMETHOD(GetFloat)(THIS_ float *pValue) PURE;    
-    
-    STDMETHOD(SetFloatArray)(THIS_ CONST float *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetFloatArray)(THIS_ float *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetInt)(THIS_ CONST int Value) PURE;
-    STDMETHOD(GetInt)(THIS_ int *pValue) PURE;
-    
-    STDMETHOD(SetIntArray)(THIS_ CONST int *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetIntArray)(THIS_ int *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetBool)(THIS_ CONST BOOL Value) PURE;
-    STDMETHOD(GetBool)(THIS_ BOOL *pValue) PURE;
-    
-    STDMETHOD(SetBoolArray)(THIS_ CONST BOOL *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetBoolArray)(THIS_ BOOL *pData, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    
-    STDMETHOD(SetBoolVector) (THIS_ CONST BOOL *pData) PURE;
-    STDMETHOD(SetIntVector)  (THIS_ CONST int *pData) PURE;
-    STDMETHOD(SetFloatVector)(THIS_ CONST float *pData) PURE;
-
-    STDMETHOD(GetBoolVector) (THIS_ BOOL *pData) PURE;
-    STDMETHOD(GetIntVector)  (THIS_ int *pData) PURE;
-    STDMETHOD(GetFloatVector)(THIS_ float *pData) PURE;
-
-    STDMETHOD(SetBoolVectorArray) (THIS_ CONST BOOL *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(SetIntVectorArray)  (THIS_ CONST int *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(SetFloatVectorArray)(THIS_ CONST float *pData, UINT Offset, UINT Count) PURE;
-
-    STDMETHOD(GetBoolVectorArray) (THIS_ BOOL *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetIntVectorArray)  (THIS_ int *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetFloatVectorArray)(THIS_ float *pData, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT ByteOffset, UINT ByteCount) PURE;
-    
-    STDMETHOD(SetMatrix)(THIS_ CONST float *pData) PURE;
-    STDMETHOD(GetMatrix)(THIS_ float *pData) PURE;
-    
-    STDMETHOD(SetMatrixArray)(THIS_ CONST float *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetMatrixArray)(THIS_ float *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetMatrixTranspose)(THIS_ CONST float *pData) PURE;
-    STDMETHOD(GetMatrixTranspose)(THIS_ float *pData) PURE;
-    
-    STDMETHOD(SetMatrixTransposeArray)(THIS_ CONST float *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetMatrixTransposeArray)(THIS_ float *pData, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetString)(THIS_ LPCSTR *ppString) PURE;
-    STDMETHOD(GetStringArray)(THIS_ LPCSTR *ppStrings, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_(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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-
-    STDMETHOD(GetClassInstance)(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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_(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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-
-    STDMETHOD(SetClassInstance)(ID3DX11EffectClassInstanceVariable *pEffectClassInstance) PURE;
-    STDMETHOD(GetClassInstance)(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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetResource)(THIS_ ID3D11ShaderResourceView *pResource) PURE;
-    STDMETHOD(GetResource)(THIS_ ID3D11ShaderResourceView **ppResource) PURE;
-    
-    STDMETHOD(SetResourceArray)(THIS_ ID3D11ShaderResourceView **ppResources, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetResourceArray)(THIS_ ID3D11ShaderResourceView **ppResources, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-
-    STDMETHOD(SetUnorderedAccessView)(THIS_ ID3D11UnorderedAccessView *pResource) PURE;
-    STDMETHOD(GetUnorderedAccessView)(THIS_ ID3D11UnorderedAccessView **ppResource) PURE;
-
-    STDMETHOD(SetUnorderedAccessViewArray)(THIS_ ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetUnorderedAccessViewArray)(THIS_ ID3D11UnorderedAccessView **ppResources, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetRenderTarget)(THIS_ ID3D11RenderTargetView *pResource) PURE;
-    STDMETHOD(GetRenderTarget)(THIS_ ID3D11RenderTargetView **ppResource) PURE;
-    
-    STDMETHOD(SetRenderTargetArray)(THIS_ ID3D11RenderTargetView **ppResources, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRenderTargetArray)(THIS_ ID3D11RenderTargetView **ppResources, UINT Offset, UINT 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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetDepthStencil)(THIS_ ID3D11DepthStencilView *pResource) PURE;
-    STDMETHOD(GetDepthStencil)(THIS_ ID3D11DepthStencilView **ppResource) PURE;
-    
-    STDMETHOD(SetDepthStencilArray)(THIS_ ID3D11DepthStencilView **ppResources, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetDepthStencilArray)(THIS_ ID3D11DepthStencilView **ppResources, UINT Offset, UINT 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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(SetConstantBuffer)(THIS_ ID3D11Buffer *pConstantBuffer) PURE;
-    STDMETHOD(UndoSetConstantBuffer)(THIS) PURE;
-    STDMETHOD(GetConstantBuffer)(THIS_ ID3D11Buffer **ppConstantBuffer) PURE;
-    
-    STDMETHOD(SetTextureBuffer)(THIS_ ID3D11ShaderResourceView *pTextureBuffer) PURE;
-    STDMETHOD(UndoSetTextureBuffer)(THIS) PURE;
-    STDMETHOD(GetTextureBuffer)(THIS_ ID3D11ShaderResourceView **ppTextureBuffer) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectShaderVariable ////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_EFFECT_SHADER_DESC:
-//
-// Retrieved by ID3DX11EffectShaderVariable::GetShaderDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_EFFECT_SHADER_DESC
-{
-    CONST BYTE *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 BYTE *pBytecode;                  // Shader bytecode
-    UINT BytecodeLength;
-    
-    LPCSTR SODecls[D3D11_SO_STREAM_COUNT];  // Stream out declaration string (for GS with SO)
-    UINT RasterizedStream;
-    
-    UINT NumInputSignatureEntries;          // Number of entries in the input signature
-    UINT NumOutputSignatureEntries;         // Number of entries in the output signature
-    UINT NumPatchConstantSignatureEntries;  // Number of entries in the patch constant signature
-} D3DX11_EFFECT_SHADER_DESC;
-
-
-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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetShaderDesc)(THIS_ UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc) PURE;
-    
-    STDMETHOD(GetVertexShader)(THIS_ UINT ShaderIndex, ID3D11VertexShader **ppVS) PURE;
-    STDMETHOD(GetGeometryShader)(THIS_ UINT ShaderIndex, ID3D11GeometryShader **ppGS) PURE;
-    STDMETHOD(GetPixelShader)(THIS_ UINT ShaderIndex, ID3D11PixelShader **ppPS) PURE;
-    STDMETHOD(GetHullShader)(THIS_ UINT ShaderIndex, ID3D11HullShader **ppPS) PURE;
-    STDMETHOD(GetDomainShader)(THIS_ UINT ShaderIndex, ID3D11DomainShader **ppPS) PURE;
-    STDMETHOD(GetComputeShader)(THIS_ UINT ShaderIndex, ID3D11ComputeShader **ppPS) PURE;
-    
-    STDMETHOD(GetInputSignatureElementDesc)(THIS_ UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
-    STDMETHOD(GetOutputSignatureElementDesc)(THIS_ UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
-    STDMETHOD(GetPatchConstantSignatureElementDesc)(THIS_ UINT ShaderIndex, UINT Element, 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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetBlendState)(THIS_ UINT Index, ID3D11BlendState **ppBlendState) PURE;
-    STDMETHOD(SetBlendState)(THIS_ UINT Index, ID3D11BlendState *pBlendState) PURE;
-    STDMETHOD(UndoSetBlendState)(THIS_ UINT Index) PURE; 
-    STDMETHOD(GetBackingStore)(THIS_ UINT Index, D3D11_BLEND_DESC *pBlendDesc) 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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetDepthStencilState)(THIS_ UINT Index, ID3D11DepthStencilState **ppDepthStencilState) PURE;
-    STDMETHOD(SetDepthStencilState)(THIS_ UINT Index, ID3D11DepthStencilState *pDepthStencilState) PURE;
-    STDMETHOD(UndoSetDepthStencilState)(THIS_ UINT Index) PURE;
-    STDMETHOD(GetBackingStore)(THIS_ UINT Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc) 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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetRasterizerState)(THIS_ UINT Index, ID3D11RasterizerState **ppRasterizerState) PURE;
-    STDMETHOD(SetRasterizerState)(THIS_ UINT Index, ID3D11RasterizerState *pRasterizerState) PURE;
-    STDMETHOD(UndoSetRasterizerState)(THIS_ UINT Index) PURE;
-    STDMETHOD(GetBackingStore)(THIS_ UINT Index, D3D11_RASTERIZER_DESC *pRasterizerDesc) 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)
-{
-    STDMETHOD_(ID3DX11EffectType*, GetType)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetElement)(THIS_ UINT 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_ CONST void *pData, UINT Offset, UINT Count) PURE;
-    STDMETHOD(GetRawValue)(THIS_ void *pData, UINT Offset, UINT Count) PURE;
-    
-    STDMETHOD(GetSampler)(THIS_ UINT Index, ID3D11SamplerState **ppSampler) PURE;
-    STDMETHOD(SetSampler)(THIS_ UINT Index, ID3D11SamplerState *pSampler) PURE;
-    STDMETHOD(UndoSetSampler)(THIS_ UINT Index) PURE;
-    STDMETHOD(GetBackingStore)(THIS_ UINT Index, D3D11_SAMPLER_DESC *pSamplerDesc) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectPass //////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_PASS_DESC:
-//
-// Retrieved by ID3DX11EffectPass::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_PASS_DESC
-{
-    LPCSTR Name;                    // Name of this pass (NULL if not anonymous)    
-    UINT Annotations;               // Number of annotations on this pass
-    
-    BYTE *pIAInputSignature;        // Signature from VS or GS (if there is no VS)
-                                    // or NULL if neither exists
-    SIZE_T IAInputSignatureSize;    // Singature size in bytes                                
-                                    
-    UINT StencilRef;                // Specified in SetDepthStencilState()
-    UINT SampleMask;                // Specified in SetBlendState()
-    FLOAT BlendFactor[4];           // Specified in SetBlendState()
-} D3DX11_PASS_DESC;
-
-//----------------------------------------------------------------------------
-// D3DX11_PASS_SHADER_DESC:
-//
-// Retrieved by ID3DX11EffectPass::Get**ShaderDesc()
-//----------------------------------------------------------------------------
-
-typedef 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 != NULL,
-                                                    //   but pShaderVariable->IsValid() == FALSE.
-    
-    UINT                        ShaderIndex;        // The element of pShaderVariable (if an array)
-                                                    // or 0 if not applicable
-} D3DX11_PASS_SHADER_DESC;
-
-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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_PASS_DESC *pDesc) PURE;
-    
-    STDMETHOD(GetVertexShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    STDMETHOD(GetGeometryShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    STDMETHOD(GetPixelShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    STDMETHOD(GetHullShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    STDMETHOD(GetDomainShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    STDMETHOD(GetComputeShaderDesc)(THIS_ D3DX11_PASS_SHADER_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD(Apply)(THIS_ UINT Flags, ID3D11DeviceContext* pContext) PURE;
-    
-    STDMETHOD(ComputeStateBlockMask)(THIS_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectTechnique /////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_TECHNIQUE_DESC:
-//
-// Retrieved by ID3DX11EffectTechnique::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_TECHNIQUE_DESC
-{
-    LPCSTR  Name;                   // Name of this technique (NULL if not anonymous)
-    UINT    Passes;                 // Number of passes contained within
-    UINT    Annotations;            // Number of annotations on this technique
-} D3DX11_TECHNIQUE_DESC;
-
-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)
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_TECHNIQUE_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD(ComputeStateBlockMask)(THIS_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11EffectTechnique /////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_GROUP_DESC:
-//
-// Retrieved by ID3DX11EffectTechnique::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_GROUP_DESC
-{
-    LPCSTR  Name;                   // Name of this group (only NULL if global)
-    UINT    Techniques;             // Number of techniques contained within
-    UINT    Annotations;            // Number of annotations on this group
-} D3DX11_GROUP_DESC;
-
-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) 
-{
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-    STDMETHOD(GetDesc)(THIS_ D3DX11_GROUP_DESC *pDesc) PURE;
-
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(THIS_ LPCSTR Name) PURE;
-
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(THIS_ LPCSTR Name) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// ID3DX11Effect //////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//----------------------------------------------------------------------------
-// D3DX11_EFFECT_DESC:
-//
-// Retrieved by ID3DX11Effect::GetDesc()
-//----------------------------------------------------------------------------
-
-typedef struct _D3DX11_EFFECT_DESC
-{
-    UINT    ConstantBuffers;        // Number of constant buffers in this effect
-    UINT    GlobalVariables;        // Number of global variables in this effect
-    UINT    InterfaceVariables;     // Number of global interfaces in this effect
-    UINT    Techniques;             // Number of techniques in this effect
-    UINT    Groups;                 // Number of groups in this effect
-} D3DX11_EFFECT_DESC;
-
-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
-    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
-    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
-    STDMETHOD_(ULONG, Release)(THIS) PURE;
-    
-    STDMETHOD_(BOOL, IsValid)(THIS) PURE;
-
-    // Managing D3D Device
-    STDMETHOD(GetDevice)(THIS_ ID3D11Device** ppDevice) PURE;
-    
-    // New Reflection APIs
-    STDMETHOD(GetDesc)(THIS_ D3DX11_EFFECT_DESC *pDesc) PURE;
-    
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableByName)(THIS_ LPCSTR Name) PURE;
-    STDMETHOD_(ID3DX11EffectVariable*, GetVariableBySemantic)(THIS_ LPCSTR Semantic) PURE;
-    
-    STDMETHOD_(ID3DX11EffectGroup*, GetGroupByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectGroup*, GetGroupByName)(THIS_ LPCSTR Name) PURE;
-
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(THIS_ UINT Index) PURE;
-    STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(THIS_ LPCSTR Name) PURE;
-    
-    STDMETHOD_(ID3D11ClassLinkage*, GetClassLinkage)(THIS) PURE;
-
-    STDMETHOD(CloneEffect)(THIS_ UINT Flags, ID3DX11Effect** ppClonedEffect ) PURE;
-    STDMETHOD(Optimize)(THIS) PURE;
-    STDMETHOD_(BOOL, IsOptimized)(THIS) PURE;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// APIs //////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-#ifdef __cplusplus
-extern "C" {
-#endif //__cplusplus
-
-//----------------------------------------------------------------------------
-// D3DX11CreateEffectFromMemory:
-// --------------------------
-// Creates an effect from a binary effect or file
-//
-// Parameters:
-//
-// [in]
-//
-//
-//  pData
-//      Blob of compiled effect data
-//  DataLength
-//      Length of the data blob
-//  FXFlags
-//      Compilation flags pertaining to Effect compilation, honored
-//      by the Effect compiler
-//  pDevice
-//      Pointer to the D3D11 device on which to create Effect resources
-//
-// [out]
-//
-//  ppEffect
-//      Address of the newly created Effect interface
-//
-//----------------------------------------------------------------------------
-
-HRESULT WINAPI D3DX11CreateEffectFromMemory(CONST void *pData, SIZE_T DataLength, UINT FXFlags, ID3D11Device *pDevice, ID3DX11Effect **ppEffect);
-
-#ifdef __cplusplus
-}
-#endif //__cplusplus
-
-#endif //__D3DX11EFFECT_H__
-
diff --git a/sample/d3d11/Effects11/Inc/d3dxGlobal.h b/sample/d3d11/Effects11/Inc/d3dxGlobal.h
deleted file mode 100644
index 3b5cdf8..0000000
--- a/sample/d3d11/Effects11/Inc/d3dxGlobal.h
+++ /dev/null
@@ -1,1337 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       D3DXGlobal.h
-//  Content:    D3DX11 Effects helper defines and data structures
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#pragma warning(disable : 4100 4127 4189 4201 4245 4389 4505 4701 4706)
-
-namespace D3DX11Debug
-{
-}
-
-using namespace D3DX11Debug;
-
-#include "d3dx11dbg.h"
-
-#define SAFE_RELEASE(p)       { if (p) { (p)->Release();  (p) = NULL; } }
-#define SAFE_ADDREF(p)        { if (p) { (p)->AddRef();               } }
-
-#define SAFE_DELETE_ARRAY(p)  { delete [](p); p = NULL; }
-#define SAFE_DELETE(p)        { delete (p); p = NULL;  }
-
-#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; D3DXASSERT(!#x);                     goto lExit; } }
-#define VNASSERT(x)   {           if (!(x))       { __BREAK_ON_FAIL; D3DXASSERT(!#x); hr = E_OUTOFMEMORY; goto lExit; } }
-
-#define ANALYSIS_ASSUME(x)      { D3DXASSERT(x); __analysis_assume(x); __assume(x); }
-
-#define D3DX11FLTASSIGN(a,b)    { *reinterpret_cast< UINT32* >(&(a)) = *reinterpret_cast< UINT32* >(&(b)); }
-
-// Preferred data alignment -- must be a power of 2!
-static const UINT c_DataAlignment = sizeof(UINT_PTR);
-
-D3DX11INLINE UINT AlignToPowerOf2(UINT Value, UINT Alignment)
-{
-    D3DXASSERT((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));
-}
-
-D3DX11INLINE void * AlignToPowerOf2(void *pValue, UINT_PTR Alignment)
-{
-    D3DXASSERT((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)));
-}
-
-
-// Fast memcpy
-D3DX11INLINE void dwordMemcpy( __out_bcount(uByteCount) void * __restrict pDest, __in_bcount(uByteCount) CONST void * __restrict pSource, UINT uByteCount)
-{
-    UINT i;
-    D3DXASSERT(uByteCount % 4 == 0);
-#ifdef _AMD64_
-    const UINT qwordCount = uByteCount >> 3;
-
-    __int64* src64 = (__int64*) pSource;
-    __int64* dst64 = (__int64*) pDest;
-
-    for (i=0; i<(qwordCount & 0x3); i++)
-    {
-        *(dst64) = *(src64);
-        dst64++;
-        src64++;
-    }
-
-    for (; i<qwordCount; i+= 4)
-    {
-        *(dst64     ) = *(src64     );
-        *(dst64 + 1 ) = *(src64 + 1 );
-        *(dst64 + 2 ) = *(src64 + 2 );
-        *(dst64 + 3 ) = *(src64 + 3 );
-        dst64 += 4;
-        src64 += 4;
-    }
-
-    ANALYSIS_ASSUME( dst64 - static_cast< __int64* >(pDest) <= uByteCount - 4 );
-    ANALYSIS_ASSUME( src64 - static_cast< const __int64* >(pSource) <= uByteCount - 4 );
-    if( uByteCount & 0x4 )
-    {
-        *((UINT*)dst64) = *((UINT*)src64);
-    }
-#else
-    const UINT dwordCount = uByteCount >> 2;
-
-    for (i=0; i<(dwordCount & 0x3); i++)
-    {
-#pragma prefast(suppress: __WARNING_UNRELATED_LOOP_TERMINATION, "(dwordCount & 03) < dwordCount")
-        ((UINT*)pDest)[i  ] = ((UINT*)pSource)[i  ];
-    }
-    for (; i<dwordCount; i+= 4)
-    {
-        ((UINT*)pDest)[i  ] = ((UINT*)pSource)[i  ];
-        ((UINT*)pDest)[i+1] = ((UINT*)pSource)[i+1];
-        ((UINT*)pDest)[i+2] = ((UINT*)pSource)[i+2];
-        ((UINT*)pDest)[i+3] = ((UINT*)pSource)[i+3];
-    }
-#endif
-}
-
-
-namespace D3DX11Core
-{
-
-//////////////////////////////////////////////////////////////////////////
-// CMemoryStream - A class to simplify reading binary data
-//////////////////////////////////////////////////////////////////////////
-class CMemoryStream
-{
-    BYTE    *m_pData;
-    SIZE_T  m_cbData;
-    SIZE_T  m_readPtr;
-
-public:
-    HRESULT SetData(const void *pData, SIZE_T size);
-
-    HRESULT Read(UINT *pUint);
-    HRESULT Read(void **ppData, SIZE_T size);
-    HRESULT Read(LPCSTR *ppString);
-
-    HRESULT ReadAtOffset(SIZE_T offset, SIZE_T size, void **ppData);
-    HRESULT ReadAtOffset(SIZE_T offset, LPCSTR *ppString);
-
-    SIZE_T  GetPosition();
-    HRESULT Seek(SIZE_T offset);
-
-    CMemoryStream();
-    ~CMemoryStream();
-};
-
-}
-
-#if FXDEBUG
-
-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 // FXDEBUG
-
-
-//////////////////////////////////////////////////////////////////////////
-// 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
-
-    BYTE    *m_pData;
-    UINT    m_MaxSize;
-    UINT    m_CurSize;
-
-    HRESULT Grow()
-    {
-        return Reserve(m_CurSize + 1);
-    }
-
-    HRESULT Reserve(UINT DesiredSize)
-    {
-        if (DesiredSize > m_MaxSize)
-        {
-            BYTE *pNewData;
-            UINT newSize = 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 BYTE[newSize * sizeof(T)];
-            if (pNewData == NULL)
-            {
-                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;
-#if _DEBUG
-        m_pCastData = NULL;
-#endif // _DEBUG
-        m_pData = NULL;
-        m_CurSize = m_MaxSize = 0;
-    }
-
-    ~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(CEffectVector<T> &vOther)
-    {
-        BYTE tempData[sizeof(*this)];
-
-        memcpy(tempData, this, sizeof(*this));
-        memcpy(this, &vOther, sizeof(*this));
-        memcpy(&vOther, tempData, sizeof(*this));
-    }
-
-    HRESULT CopyFrom(CEffectVector<T> &vOther)
-    {
-        HRESULT hr = S_OK;
-        Clear();
-        VN( m_pData = NEW BYTE[vOther.m_MaxSize * sizeof(T)] );
-        
-        m_CurSize = vOther.m_CurSize;
-        m_MaxSize = vOther.m_MaxSize;
-        m_hLastError = vOther.m_hLastError;
-
-        UINT i;
-        for (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 = NULL;
-#endif // _DEBUG
-    }
-
-    void ClearWithoutDestructor()
-    {
-        m_CurSize = 0;
-        m_hLastError = S_OK;
-        SAFE_DELETE_ARRAY(m_pData);
-        m_MaxSize = 0;
-
-#if _DEBUG
-        m_pCastData = NULL;
-#endif // _DEBUG
-    }
-
-    void Empty()
-    {
-        UINT i;
-        
-        // manually invoke destructor on all elements
-        for (i = 0; i < m_CurSize; ++ i)
-        {   
-            ((T*)m_pData + i)->~T();
-        }
-        m_CurSize = 0;
-        m_hLastError = S_OK;
-    }
-
-    T* Add()
-    {
-        if (FAILED(Grow()))
-            return NULL;
-
-        // placement new
-        return new((T*)m_pData + (m_CurSize ++)) T;
-    }
-
-    T* AddRange(UINT count)
-    {
-        if (m_CurSize + count < m_CurSize)
-        {
-            m_hLastError = E_OUTOFMEMORY;
-            return NULL;
-        }
-
-        if (FAILED(Reserve(m_CurSize + count)))
-            return NULL;
-
-        T *pData = (T*)m_pData + m_CurSize;
-        UINT i;
-        for (i = 0; i < count; ++ i)
-        {
-            new(pData + i) T;
-        }
-        m_CurSize += count;
-        return pData;
-    }
-
-    HRESULT Add(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(const T *pVar, UINT 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(const T& var, UINT index)
-    {
-        D3DXASSERT(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(const T *pVar, UINT index, UINT count)
-    {
-        D3DXASSERT(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[](UINT index)
-    {
-        D3DXASSERT(index < m_CurSize);
-        return ((T*)m_pData)[index];
-    }
-
-    // Deletes element at index and shifts all other values down
-    void Delete(UINT index)
-    {
-        D3DXASSERT(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(UINT index)
-    {
-        D3DXASSERT(index < m_CurSize);
-
-        -- m_CurSize;
-        memcpy((T*)m_pData + index, (T*)m_pData + m_CurSize, sizeof(T));
-    }
-
-    inline UINT GetSize() const
-    {
-        return m_CurSize;
-    }
-
-    inline T* GetData() const
-    {
-        return (T*)m_pData;
-    }
-
-    UINT FindIndexOf(void *pEntry) const
-    {
-        UINT i;
-
-        for (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();
-        UINT i;
-
-        for (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()
-    {
-        UINT i;
-
-        // manually invoke destructor on all elements
-        for (i = 0; i < m_CurSize; ++ i)
-        {
-            SAFE_DELETE(((T**)m_pData)[i]);
-        }
-        m_CurSize = 0;
-        m_hLastError = S_OK;
-    }
-
-    void Delete(UINT index)
-    {
-        D3DXASSERT(index < m_CurSize);
-
-        SAFE_DELETE(((T**)m_pData)[index]);
-
-        CEffectVector<T*>::Delete(index);
-    }
-};
-
-
-//////////////////////////////////////////////////////////////////////////
-// Checked UINT, DWORD64
-// Use CheckedNumber only with UINT and DWORD64
-//////////////////////////////////////////////////////////////////////////
-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(T *pValue)
-    {
-        if (!m_bValid)
-        {
-            *pValue = -1;
-            return E_FAIL;
-        }
-
-        *pValue = m_Value;
-        return S_OK;
-    }
-};
-
-typedef CheckedNumber<UINT, _UI32_MAX> CCheckedDword;
-typedef CheckedNumber<DWORD64, _UI64_MAX> CCheckedDword64;
-
-
-//////////////////////////////////////////////////////////////////////////
-// Data Block Store - A linked list of allocations
-//////////////////////////////////////////////////////////////////////////
-
-class CDataBlock
-{
-protected:
-    UINT        m_size;
-    UINT        m_maxSize;
-    BYTE        *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(const void *pNewData, UINT bufferSize, CDataBlock **ppBlock);
-
-    // Allocate reserves bufferSize bytes of contiguous memory and returns a pointer to the user
-    void*   Allocate(UINT bufferSize, CDataBlock **ppBlock);
-
-    void    EnableAlignment();
-
-    CDataBlock();
-    ~CDataBlock();
-
-    friend class CDataBlockStore;
-};
-
-
-class CDataBlockStore
-{
-protected:
-    CDataBlock  *m_pFirst;
-    CDataBlock  *m_pLast;
-    UINT        m_Size;
-    UINT        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
-    UINT		m_cAllocations;
-#endif
-
-public:
-    HRESULT AddString(LPCSTR pString, UINT *pOffset);                          // Writes a null-terminated string to buffer
-    HRESULT AddData(const void *pNewData, UINT bufferSize, UINT *pOffset);     // Writes data block to buffer
-
-    void*   Allocate(UINT buffferSize);                                        // Memory allocator support
-    UINT    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(size_t s, CDataBlockStore &pAllocator)
-{
-    D3DXASSERT( s <= 0xffffffff );
-    return pAllocator.Allocate( (UINT)s );
-}
-
-static void __cdecl operator delete(void* p, CDataBlockStore &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 UINT ComputeHash(BYTE *pb, UINT cbToHash)
-{
-    UINT a;
-    UINT b;
-    UINT c;
-    UINT cbLeft;
-
-    cbLeft = cbToHash;
-
-    a = b = 0x9e3779b9; // the golden ratio; an arbitrary value
-    c = 0;
-
-    while (cbLeft >= 12)
-    {
-        UINT *pdw = reinterpret_cast<UINT *>(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+=((UINT) pb[10] << 24);
-    case 10: c+=((UINT) pb[9]  << 16);
-    case 9 : c+=((UINT) pb[8]  <<  8);
-        // the first byte of c is reserved for the length
-    case 8 : b+=((UINT) pb[7]  << 24);
-    case 7 : b+=((UINT) pb[6]  << 16);
-    case 6 : b+=((UINT) pb[5]  <<  8);
-    case 5 : b+=pb[4];
-    case 4 : a+=((UINT) pb[3]  << 24);
-    case 3 : a+=((UINT) pb[2]  << 16);
-    case 2 : a+=((UINT) pb[1]  <<  8);
-    case 1 : a+=pb[0];
-    }
-
-    HASH_MIX(a,b,c);
-
-    return c;
-}
-
-static UINT ComputeHashLower(BYTE *pb, UINT cbToHash)
-{
-    UINT a;
-    UINT b;
-    UINT c;
-    UINT cbLeft;
-
-    cbLeft = cbToHash;
-
-    a = b = 0x9e3779b9; // the golden ratio; an arbitrary value
-    c = 0;
-
-    while (cbLeft >= 12)
-    {
-        BYTE pbT[12];
-        for( UINT i = 0; i < 12; i++ )
-            pbT[i] = (BYTE)tolower(pb[i]);
-
-        UINT *pdw = reinterpret_cast<UINT *>(pbT);
-
-        a += pdw[0];
-        b += pdw[1];
-        c += pdw[2];
-
-        HASH_MIX(a,b,c);
-        pb += 12; 
-        cbLeft -= 12;
-    }
-
-    c += cbToHash;
-
-    BYTE pbT[12];
-    for( UINT i = 0; i < cbLeft; i++ )
-        pbT[i] = (BYTE)tolower(pb[i]);
-
-    switch(cbLeft) // all the case statements fall through
-    {
-    case 11: c+=((UINT) pbT[10] << 24);
-    case 10: c+=((UINT) pbT[9]  << 16);
-    case 9 : c+=((UINT) pbT[8]  <<  8);
-        // the first byte of c is reserved for the length
-    case 8 : b+=((UINT) pbT[7]  << 24);
-    case 7 : b+=((UINT) pbT[6]  << 16);
-    case 6 : b+=((UINT) pbT[5]  <<  8);
-    case 5 : b+=pbT[4];
-    case 4 : a+=((UINT) pbT[3]  << 24);
-    case 3 : a+=((UINT) pbT[2]  << 16);
-    case 2 : a+=((UINT) pbT[1]  <<  8);
-    case 1 : a+=pbT[0];
-    }
-
-    HASH_MIX(a,b,c);
-
-    return c;
-}
-
-
-static UINT ComputeHash(LPCSTR pString)
-{
-    return ComputeHash((BYTE*) pString, (UINT)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 UINT 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,
-};
-
-static const UINT c_NumPrimes = sizeof(c_PrimeSizes) / sizeof(UINT);
-
-template<typename T, BOOL (*pfnIsEqual)(const T &Data1, const T &Data2)>
-class CEffectHashTable
-{
-protected:
-
-    struct SHashEntry
-    {
-        UINT        Hash;
-        T           Data;
-        SHashEntry  *pNext;
-    };
-
-    // Array of hash entries
-    SHashEntry  **m_rgpHashEntries;
-    UINT        m_NumHashSlots;
-    UINT        m_NumEntries;
-    bool        m_bOwnHashEntryArray;
-
-public:
-    class CIterator
-    {
-        friend class CEffectHashTable;
-
-    protected:
-        SHashEntry **ppHashSlot;
-        SHashEntry *pHashEntry;
-
-    public:
-        T GetData()
-        {
-            D3DXASSERT(NULL != pHashEntry);
-            return pHashEntry->Data;
-        }
-
-        UINT GetHash()
-        {
-            D3DXASSERT(NULL != pHashEntry);
-            return pHashEntry->Hash;
-        }
-    };
-
-    CEffectHashTable()
-    {
-        m_rgpHashEntries = NULL;
-        m_NumHashSlots = 0;
-        m_NumEntries = 0;
-        m_bOwnHashEntryArray = false;
-    }
-
-    HRESULT Initialize(CEffectHashTable *pOther)
-    {
-        HRESULT hr = S_OK;
-        SHashEntry **rgpNewHashEntries = NULL;
-        SHashEntry ***rgppListEnds = NULL;
-        UINT i;
-        UINT valuesMigrated = 0;
-        UINT 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))
-        {
-            UINT 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;
-        }
-
-        D3DXASSERT(valuesMigrated == pOther->m_NumEntries);
-
-        m_rgpHashEntries = rgpNewHashEntries;
-        m_NumHashSlots = actualSize;
-        m_NumEntries = pOther->m_NumEntries;
-        m_bOwnHashEntryArray = true;
-        rgpNewHashEntries = NULL;
-
-lExit:
-        SAFE_DELETE_ARRAY( rgpNewHashEntries );
-        return hr;
-    }
-
-protected:
-    void CleanArray()
-    {
-        if (m_bOwnHashEntryArray)
-        {
-            SAFE_DELETE_ARRAY(m_rgpHashEntries);
-            m_bOwnHashEntryArray = false;
-        }
-    }
-
-public:
-    void Cleanup()
-    {
-        UINT i;
-        for (i = 0; i < m_NumHashSlots; ++ i)
-        {
-            SHashEntry *pCurrentEntry = m_rgpHashEntries[i];
-            SHashEntry *pTempEntry;
-            while (NULL != pCurrentEntry)
-            {
-                pTempEntry = pCurrentEntry->pNext;
-                SAFE_DELETE(pCurrentEntry);
-                pCurrentEntry = pTempEntry;
-                -- m_NumEntries;
-            }
-        }
-        CleanArray();
-        m_NumHashSlots = 0;
-        D3DXASSERT(m_NumEntries == 0);
-    }
-
-    ~CEffectHashTable()
-    {
-        Cleanup();
-    }
-
-    static UINT GetNextHashTableSize(__in UINT DesiredSize)
-    {
-        // figure out the next logical size to use
-        for (UINT i = 0; i < c_NumPrimes; ++ 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 UINT DesiredSize,
-                 __in UINT ProvidedArraySize = 0,
-                 __in_ecount_opt(ProvidedArraySize)
-                 void** ProvidedArray = NULL,
-                 __in bool OwnProvidedArray = false)
-    {
-        HRESULT hr = S_OK;
-        SHashEntry **rgpNewHashEntries = NULL;
-        SHashEntry ***rgppListEnds = NULL;
-        UINT valuesMigrated = 0;
-        UINT 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))
-        {
-            UINT 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;
-        }
-
-        D3DXASSERT(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;
-        }
-        
-        UINT i;
-        float variance = 0.0f;
-        float mean = (float)m_NumEntries / (float)m_NumHashSlots;
-        UINT unusedSlots = 0;
-
-        DPF(0, "Hash table slots: %d, Entries in table: %d", m_NumHashSlots, m_NumEntries);
-
-        for (i = 0; i < m_NumHashSlots; ++ i)
-        {
-            UINT entries = 0;
-            SHashEntry *pCurrentEntry = m_rgpHashEntries[i];
-
-            while (NULL != 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))
-                        {
-                            D3DXASSERT(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 /= 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(T Data, UINT Hash, CIterator *pIterator)
-    {
-        D3DXASSERT(m_NumHashSlots > 0);
-
-        UINT index = Hash % m_NumHashSlots;
-        SHashEntry *pEntry = m_rgpHashEntries[index];
-        while (NULL != 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(UINT Hash, CIterator *pIterator)
-    {
-        D3DXASSERT(m_NumHashSlots > 0);
-
-        UINT index = Hash % m_NumHashSlots;
-        SHashEntry *pEntry = m_rgpHashEntries[index];
-        while (NULL != 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(T Data, UINT Hash)
-    {
-        HRESULT hr = S_OK;
-
-        D3DXASSERT(m_NumHashSlots > 0);
-
-        SHashEntry *pHashEntry;
-        UINT 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(CIterator *pIterator)
-    {
-        SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
-        pIterator->ppHashSlot = m_rgpHashEntries;
-        while (pIterator->ppHashSlot < ppEnd)
-        {
-            if (NULL != *(pIterator->ppHashSlot))
-            {
-                pIterator->pHashEntry = *(pIterator->ppHashSlot);
-                return;
-            }
-            ++ pIterator->ppHashSlot;
-        }
-    }
-
-    BOOL PastEnd(CIterator *pIterator)
-    {
-        SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
-        D3DXASSERT(pIterator->ppHashSlot >= m_rgpHashEntries && pIterator->ppHashSlot <= ppEnd);
-        return (pIterator->ppHashSlot == ppEnd);
-    }
-
-    void GetNextEntry(CIterator *pIterator)
-    {
-        SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
-        D3DXASSERT(pIterator->ppHashSlot >= m_rgpHashEntries && pIterator->ppHashSlot <= ppEnd);
-        D3DXASSERT(NULL != pIterator->pHashEntry);
-
-        pIterator->pHashEntry = pIterator->pHashEntry->pNext;
-        if (NULL != pIterator->pHashEntry)
-        {
-            return;
-        }
-
-        ++ pIterator->ppHashSlot;
-        while (pIterator->ppHashSlot < ppEnd)
-        {
-            pIterator->pHashEntry = *(pIterator->ppHashSlot);
-            if (NULL != pIterator->pHashEntry)
-            {
-                return;
-            }
-            ++ pIterator->ppHashSlot;
-        }
-        // hit the end of the list, ppHashSlot == ppEnd
-    }
-
-    void RemoveEntry(CIterator *pIterator)
-    {
-        SHashEntry *pTemp;
-        SHashEntry **ppPrev;
-        SHashEntry **ppEnd = m_rgpHashEntries + m_NumHashSlots;
-
-        D3DXASSERT(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
-        D3DXASSERT(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 = NULL;
-    }
-
-    void Cleanup()
-    {
-        CleanArray();
-        m_NumHashSlots = 0;
-        m_NumEntries = 0;
-    }
-
-    ~CEffectHashTableWithPrivateHeap()
-    {
-        Cleanup();
-    }
-
-    // Call this only once
-    void SetPrivateHeap(CDataBlockStore *pPrivateHeap)
-    {
-        D3DXASSERT(NULL == m_pPrivateHeap);
-        m_pPrivateHeap = pPrivateHeap;
-    }
-
-    // Adds data at the specified hash slot without checking for existence
-    HRESULT AddValueWithHash(T Data, UINT Hash)
-    {
-        HRESULT hr = S_OK;
-
-        D3DXASSERT(NULL != m_pPrivateHeap);
-        D3DXASSERT(m_NumHashSlots > 0);
-
-        SHashEntry *pHashEntry;
-        UINT 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;
-    }
-};
diff --git a/sample/d3d11/Effects11/d3dx11dbg.cpp b/sample/d3d11/Effects11/d3dx11dbg.cpp
deleted file mode 100644
index 330e8d9..0000000
--- a/sample/d3d11/Effects11/d3dx11dbg.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-///////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       d3dx11dbg.cpp
-//  Content:    D3DX11 Effects debugging functions
-//
-///////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-
-
-#ifdef FXDPF
-
-//
-// DPF
-//
-
-void cdecl D3DXDebugPrintf(UINT lvl, LPCSTR szFormat, ...)
-{
-    static UINT uDebugLevel = (UINT) -1;
-
-    char strA[4096];
-    char strB[4096];
-
-    va_list ap;
-    va_start(ap, szFormat);
-    StringCchVPrintfA(strA, sizeof(strA), szFormat, ap);
-    strA[4095] = '\0';
-    va_end(ap);
-
-    StringCchPrintfA(strB, sizeof(strB), "Effects11: %s\r\n", strA);
-
-    strB[4095] = '\0';
-
-    OutputDebugStringA(strB);
-}
-#else
-// This is defined so warning LNK4211 is not generated (object file has no public symbols)
-void cdecl D3DXDebugPrintf(UINT lvl, LPCSTR szFormat, ...) {}
-#endif
-
-
-//
-// D3DXASSERT
-//
-
-#ifdef _DEBUG
-
-int WINAPI D3DXDebugAssert(LPCSTR szFile, int nLine, LPCSTR szCondition)
-{
-    char str[512];
-
-    // Print message to debug console
-    StringCchPrintfA(str, sizeof(str), "Assertion failure! (%s %d): %s\r\n", szFile, nLine, szCondition);
-    str[511] = 0;
-    OutputDebugStringA(str);
-
-    return 0;
-}
-#endif
-
diff --git a/sample/d3d11/Effects11/d3dxGlobal.cpp b/sample/d3d11/Effects11/d3dxGlobal.cpp
deleted file mode 100644
index 72f4efb..0000000
--- a/sample/d3d11/Effects11/d3dxGlobal.cpp
+++ /dev/null
@@ -1,351 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       d3dxGlobal.cpp
-//  Content:    D3DX11 Effects implementation for helper data structures
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "pchfx.h"
-#include <intsafe.h>
-
-namespace D3DX11Core
-{
-
-//////////////////////////////////////////////////////////////////////////
-// CMemoryStream - A class to simplify reading binary data
-//////////////////////////////////////////////////////////////////////////
-
-CMemoryStream::CMemoryStream()
-{
-    m_pData = NULL;
-    m_cbData = 0;
-    m_readPtr = 0;
-}
-
-CMemoryStream::~CMemoryStream()
-{
-}
-
-HRESULT CMemoryStream::SetData(const void *pData, SIZE_T size)
-{
-    m_pData = (BYTE*) pData;
-    m_cbData = size;
-    m_readPtr = 0;
-
-    return S_OK;
-}
-
-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);
-}
-
-HRESULT CMemoryStream::ReadAtOffset(SIZE_T offset, LPCSTR *ppString)
-{
-    if (offset >= m_cbData)
-        return E_FAIL;
-
-    m_readPtr = offset;
-    return Read(ppString);
-}
-
-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;
-}
-
-HRESULT CMemoryStream::Read(UINT *pDword)
-{
-    UINT *pTempDword;
-    HRESULT hr;
-
-    hr = Read((void**) &pTempDword, sizeof(UINT));
-    if (FAILED(hr))
-        return E_FAIL;
-
-    *pDword = *pTempDword;
-    return S_OK;
-}
-
-HRESULT CMemoryStream::Read(LPCSTR *ppString)
-{
-    SIZE_T iChar;
-
-    for(iChar=m_readPtr; 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(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 = NULL;
-    m_pNext = NULL;
-    m_IsAligned = FALSE;
-}
-
-CDataBlock::~CDataBlock()
-{
-    SAFE_DELETE_ARRAY(m_pData);
-    SAFE_DELETE(m_pNext);
-}
-
-void CDataBlock::EnableAlignment()
-{
-    m_IsAligned = TRUE;
-}
-
-HRESULT CDataBlock::AddData(const void *pvNewData, UINT bufferSize, CDataBlock **ppBlock)
-{
-    HRESULT hr = S_OK;
-    UINT bytesToCopy;
-    const BYTE *pNewData = (const BYTE*) pvNewData;
-
-    if (m_maxSize == 0)
-    {
-        // This is a brand new DataBlock, fill it up
-        m_maxSize = max(8192, bufferSize);
-
-        VN( m_pData = NEW BYTE[m_maxSize] );
-    }
-
-    D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
-
-    bytesToCopy = min(m_maxSize - m_size, bufferSize);
-    memcpy(m_pData + m_size, pNewData, bytesToCopy);
-    pNewData += bytesToCopy;
-    
-    if (m_IsAligned)
-    {
-        D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
-        m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
-    }
-    else
-    {
-        m_size += bytesToCopy;
-    }
-    
-    bufferSize -= bytesToCopy;
-    *ppBlock = this;
-
-    if (bufferSize != 0)
-    {
-        D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
-
-        // Couldn't fit all data into this block, spill over into next
-        VN( m_pNext = NEW CDataBlock() );
-        if (m_IsAligned)
-        {
-            m_pNext->EnableAlignment();
-        }
-        VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
-    }
-
-lExit:
-    return hr;
-}
-
-void* CDataBlock::Allocate(UINT bufferSize, CDataBlock **ppBlock)
-{
-    void *pRetValue;
-    UINT temp = m_size + bufferSize;
-
-    if (temp < m_size)
-        return NULL;
-
-    *ppBlock = this;
-
-    if (m_maxSize == 0)
-    {
-        // This is a brand new DataBlock, fill it up
-        m_maxSize = max(8192, bufferSize);
-
-        m_pData = NEW BYTE[m_maxSize];
-        if (!m_pData)
-            return NULL;
-        memset(m_pData, 0xDD, m_maxSize);
-    }
-    else if (temp > m_maxSize)
-    {
-        D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
-
-        // Couldn't fit data into this block, spill over into next
-        m_pNext = NEW CDataBlock();
-        if (!m_pNext)
-            return NULL;
-        if (m_IsAligned)
-        {
-            m_pNext->EnableAlignment();
-        }
-
-        return m_pNext->Allocate(bufferSize, ppBlock);
-    }
-
-    D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
-
-    pRetValue = m_pData + m_size;
-    if (m_IsAligned)
-    {
-        D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
-        m_size = AlignToPowerOf2(temp, c_DataAlignment);
-    }
-    else
-    {
-        m_size = temp;
-    }
-
-    return pRetValue;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-
-CDataBlockStore::CDataBlockStore()
-{
-    m_pFirst = NULL;
-    m_pLast = NULL;
-    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 = NULL;
-        delete pCurrent;
-    }
-
-    // m_pLast will be deleted automatically
-}
-
-void CDataBlockStore::EnableAlignment()
-{
-    m_IsAligned = TRUE;
-}
-
-HRESULT CDataBlockStore::AddString(LPCSTR pString, UINT *pOffset)
-{
-    size_t strSize = strlen(pString) + 1;
-    D3DXASSERT( strSize <= 0xffffffff );
-    return AddData(pString, (UINT)strSize, pOffset);
-}
-
-HRESULT CDataBlockStore::AddData(const void *pNewData, UINT bufferSize, UINT *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(UINT bufferSize)
-{
-    void *pRetValue = NULL;
-
-#if _DEBUG
-    m_cAllocations++;
-#endif
-
-    if (!m_pFirst)
-    {
-        m_pFirst = NEW CDataBlock();
-        if (!m_pFirst)
-            return NULL;
-
-        if (m_IsAligned)
-        {
-            m_pFirst->EnableAlignment();
-        }
-        m_pLast = m_pFirst;
-    }
-
-    if (FAILED(UIntAdd(m_Size, bufferSize, &m_Size)))
-        return NULL;
-
-    pRetValue = m_pLast->Allocate(bufferSize, &m_pLast);
-    if (!pRetValue)
-        return NULL;
-
-    return pRetValue;
-}
-
-UINT CDataBlockStore::GetSize()
-{
-    return m_Size;
-}
diff --git a/sample/d3d11/Effects11/pchfx.h b/sample/d3d11/Effects11/pchfx.h
deleted file mode 100644
index a374084..0000000
--- a/sample/d3d11/Effects11/pchfx.h
+++ /dev/null
@@ -1,44 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//  File:       pchfx.h
-//  Content:    D3D shader effects precompiled header
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef __D3DX11_PCHFX_H__
-#define __D3DX11_PCHFX_H__
-
-#define WIN32_LEAN_AND_MEAN
-
-#include "d3d11.h"
-#include "d3dx11.h"
-#undef DEFINE_GUID
-#include "INITGUID.h"
-#include "d3dx11effect.h"
-
-#define UNUSED -1
-
-//////////////////////////////////////////////////////////////////////////
-
-#define offsetof_fx( a, b ) (UINT)offsetof( a, b )
-
-#include "d3dxGlobal.h"
-
-#include <stddef.h>
-#include <strsafe.h>
-
-#include "Effect.h"
-#include "EffectStateBase11.h"
-#include "EffectLoad.h"
-
-#include "D3DCompiler.h"
-
-//////////////////////////////////////////////////////////////////////////
-
-namespace D3DX11Effects
-{
-} // end namespace D3DX11Effects
-
-#endif // __D3DX11_PCHFX_H__