kookroach/game-physics
1
0
Fork 0
Code Issues 8 Pull Requests Packages Projects 1 Releases Wiki Activity

template project, first version

Browse Source
This commit is contained in:
rachelchu
2017-10-11 15:01:05 +02:00
commit 8e902224cf
794 changed files with 326190 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

679
Effects11/Binary/EffectBinaryFormat.h Normal file
View File

@@ -0,0 +1,679 @@
//--------------------------------------------------------------------------------------
// File: EffectBinaryFormat.h
//
// Direct3D11 Effects Binary Format
// This is the binary file interface shared between the Effects
// compiler and runtime.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#pragma once
namespace D3DX11Effects
{
//////////////////////////////////////////////////////////////////////////
// Version Control
//////////////////////////////////////////////////////////////////////////
#define D3DX11_FXL_VERSION(_Major,_Minor) (('F' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))
struct EVersionTag
{
const char* m_pName;
DWORD m_Version;
uint32_t m_Tag;
};
// versions must be listed in ascending order
static const EVersionTag g_EffectVersions[] =
{
{ "fx_4_0", D3DX11_FXL_VERSION(4,0), 0xFEFF1001 },
{ "fx_4_1", D3DX11_FXL_VERSION(4,1), 0xFEFF1011 },
{ "fx_5_0", D3DX11_FXL_VERSION(5,0), 0xFEFF2001 },
};
//////////////////////////////////////////////////////////////////////////
// Reflection & Type structures
//////////////////////////////////////////////////////////////////////////
// Enumeration of the possible left-hand side values of an assignment,
// divided up categorically by the type of block they may appear in
enum ELhsType
{
ELHS_Invalid,
// Pass block assignment types
ELHS_PixelShaderBlock, // SBlock *pValue points to the block to apply
ELHS_VertexShaderBlock,
ELHS_GeometryShaderBlock,
ELHS_RenderTargetView,
ELHS_DepthStencilView,
ELHS_RasterizerBlock,
ELHS_DepthStencilBlock,
ELHS_BlendBlock,
ELHS_GenerateMips, // This is really a call to D3D::GenerateMips
// Various SAssignment.Value.*
ELHS_DS_StencilRef, // SAssignment.Value.pdValue
ELHS_B_BlendFactor, // D3D11_BLEND_CONFIG.BlendFactor, points to a float4
ELHS_B_SampleMask, // D3D11_BLEND_CONFIG.SampleMask
ELHS_GeometryShaderSO, // When setting SO assignments, GeometryShaderSO precedes the actual GeometryShader assn
ELHS_ComputeShaderBlock,
ELHS_HullShaderBlock,
ELHS_DomainShaderBlock,
// Rasterizer
ELHS_FillMode = 0x20000,
ELHS_CullMode,
ELHS_FrontCC,
ELHS_DepthBias,
ELHS_DepthBiasClamp,
ELHS_SlopeScaledDepthBias,
ELHS_DepthClipEnable,
ELHS_ScissorEnable,
ELHS_MultisampleEnable,
ELHS_AntialiasedLineEnable,
// Sampler
ELHS_Filter = 0x30000,
ELHS_AddressU,
ELHS_AddressV,
ELHS_AddressW,
ELHS_MipLODBias,
ELHS_MaxAnisotropy,
ELHS_ComparisonFunc,
ELHS_BorderColor,
ELHS_MinLOD,
ELHS_MaxLOD,
ELHS_Texture,
// DepthStencil
ELHS_DepthEnable = 0x40000,
ELHS_DepthWriteMask,
ELHS_DepthFunc,
ELHS_StencilEnable,
ELHS_StencilReadMask,
ELHS_StencilWriteMask,
ELHS_FrontFaceStencilFailOp,
ELHS_FrontFaceStencilDepthFailOp,
ELHS_FrontFaceStencilPassOp,
ELHS_FrontFaceStencilFunc,
ELHS_BackFaceStencilFailOp,
ELHS_BackFaceStencilDepthFailOp,
ELHS_BackFaceStencilPassOp,
ELHS_BackFaceStencilFunc,
// BlendState
ELHS_AlphaToCoverage = 0x50000,
ELHS_BlendEnable,
ELHS_SrcBlend,
ELHS_DestBlend,
ELHS_BlendOp,
ELHS_SrcBlendAlpha,
ELHS_DestBlendAlpha,
ELHS_BlendOpAlpha,
ELHS_RenderTargetWriteMask,
};
enum EBlockType
{
EBT_Invalid,
EBT_DepthStencil,
EBT_Blend,
EBT_Rasterizer,
EBT_Sampler,
EBT_Pass
};
enum EVarType
{
EVT_Invalid,
EVT_Numeric,
EVT_Object,
EVT_Struct,
EVT_Interface,
};
enum EScalarType
{
EST_Invalid,
EST_Float,
EST_Int,
EST_UInt,
EST_Bool,
EST_Count
};
enum ENumericLayout
{
ENL_Invalid,
ENL_Scalar,
ENL_Vector,
ENL_Matrix,
ENL_Count
};
enum EObjectType
{
EOT_Invalid,
EOT_String,
EOT_Blend,
EOT_DepthStencil,
EOT_Rasterizer,
EOT_PixelShader,
EOT_VertexShader,
EOT_GeometryShader, // Regular geometry shader
EOT_GeometryShaderSO, // Geometry shader with a attached StreamOut decl
EOT_Texture,
EOT_Texture1D,
EOT_Texture1DArray,
EOT_Texture2D,
EOT_Texture2DArray,
EOT_Texture2DMS,
EOT_Texture2DMSArray,
EOT_Texture3D,
EOT_TextureCube,
EOT_ConstantBuffer,
EOT_RenderTargetView,
EOT_DepthStencilView,
EOT_Sampler,
EOT_Buffer,
EOT_TextureCubeArray,
EOT_Count,
EOT_PixelShader5,
EOT_VertexShader5,
EOT_GeometryShader5,
EOT_ComputeShader5,
EOT_HullShader5,
EOT_DomainShader5,
EOT_RWTexture1D,
EOT_RWTexture1DArray,
EOT_RWTexture2D,
EOT_RWTexture2DArray,
EOT_RWTexture3D,
EOT_RWBuffer,
EOT_ByteAddressBuffer,
EOT_RWByteAddressBuffer,
EOT_StructuredBuffer,
EOT_RWStructuredBuffer,
EOT_RWStructuredBufferAlloc,
EOT_RWStructuredBufferConsume,
EOT_AppendStructuredBuffer,
EOT_ConsumeStructuredBuffer,
};
inline bool IsObjectTypeHelper(EVarType InVarType,
EObjectType InObjType,
EObjectType TargetObjType)
{
return (InVarType == EVT_Object) && (InObjType == TargetObjType);
}
inline bool IsSamplerHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && (InObjType == EOT_Sampler);
}
inline bool IsStateBlockObjectHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && ((InObjType == EOT_Blend) || (InObjType == EOT_DepthStencil) || (InObjType == EOT_Rasterizer) || IsSamplerHelper(InVarType, InObjType));
}
inline bool IsShaderHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && ((InObjType == EOT_VertexShader) ||
(InObjType == EOT_VertexShader5) ||
(InObjType == EOT_HullShader5) ||
(InObjType == EOT_DomainShader5) ||
(InObjType == EOT_ComputeShader5) ||
(InObjType == EOT_GeometryShader) ||
(InObjType == EOT_GeometryShaderSO) ||
(InObjType == EOT_GeometryShader5) ||
(InObjType == EOT_PixelShader) ||
(InObjType == EOT_PixelShader5));
}
inline bool IsShader5Helper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && ((InObjType == EOT_VertexShader5) ||
(InObjType == EOT_HullShader5) ||
(InObjType == EOT_DomainShader5) ||
(InObjType == EOT_ComputeShader5) ||
(InObjType == EOT_GeometryShader5) ||
(InObjType == EOT_PixelShader5));
}
inline bool IsInterfaceHelper(EVarType InVarType, EObjectType InObjType)
{
UNREFERENCED_PARAMETER(InObjType);
return (InVarType == EVT_Interface);
}
inline bool IsShaderResourceHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && ((InObjType == EOT_Texture) ||
(InObjType == EOT_Texture1D) ||
(InObjType == EOT_Texture1DArray) ||
(InObjType == EOT_Texture2D) ||
(InObjType == EOT_Texture2DArray) ||
(InObjType == EOT_Texture2DMS) ||
(InObjType == EOT_Texture2DMSArray) ||
(InObjType == EOT_Texture3D) ||
(InObjType == EOT_TextureCube) ||
(InObjType == EOT_TextureCubeArray) ||
(InObjType == EOT_Buffer) ||
(InObjType == EOT_StructuredBuffer) ||
(InObjType == EOT_ByteAddressBuffer));
}
inline bool IsUnorderedAccessViewHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) &&
((InObjType == EOT_RWTexture1D) ||
(InObjType == EOT_RWTexture1DArray) ||
(InObjType == EOT_RWTexture2D) ||
(InObjType == EOT_RWTexture2DArray) ||
(InObjType == EOT_RWTexture3D) ||
(InObjType == EOT_RWBuffer) ||
(InObjType == EOT_RWByteAddressBuffer) ||
(InObjType == EOT_RWStructuredBuffer) ||
(InObjType == EOT_RWStructuredBufferAlloc) ||
(InObjType == EOT_RWStructuredBufferConsume) ||
(InObjType == EOT_AppendStructuredBuffer) ||
(InObjType == EOT_ConsumeStructuredBuffer));
}
inline bool IsRenderTargetViewHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && (InObjType == EOT_RenderTargetView);
}
inline bool IsDepthStencilViewHelper(EVarType InVarType,
EObjectType InObjType)
{
return (InVarType == EVT_Object) && (InObjType == EOT_DepthStencilView);
}
inline bool IsObjectAssignmentHelper(ELhsType LhsType)
{
switch(LhsType)
{
case ELHS_VertexShaderBlock:
case ELHS_HullShaderBlock:
case ELHS_DepthStencilView:
case ELHS_GeometryShaderBlock:
case ELHS_PixelShaderBlock:
case ELHS_ComputeShaderBlock:
case ELHS_DepthStencilBlock:
case ELHS_RasterizerBlock:
case ELHS_BlendBlock:
case ELHS_Texture:
case ELHS_RenderTargetView:
case ELHS_DomainShaderBlock:
return true;
}
return false;
}
// Effect file format structures /////////////////////////////////////////////
// File format:
// File header (SBinaryHeader Header)
// Unstructured data block (uint8_t[Header.cbUnstructured))
// Structured data block
// ConstantBuffer (SBinaryConstantBuffer CB) * Header.Effect.cCBs
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Variable data (SBinaryNumericVariable Var) * (CB.cVariables)
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Object variables (SBinaryObjectVariable Var) * (Header.cObjectVariables) *this structure is variable sized
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Interface variables (SBinaryInterfaceVariable Var) * (Header.cInterfaceVariables) *this structure is variable sized
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Groups (SBinaryGroup Group) * Header.cGroups
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Techniques (SBinaryTechnique Technique) * Group.cTechniques
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Pass (SBinaryPass Pass) * Technique.cPasses
// uint32_t NumAnnotations
// Annotation data (SBinaryAnnotation) * (NumAnnotations) *this structure is variable sized
// Pass assignments (SBinaryAssignment) * Pass.cAssignments
struct SBinaryHeader
{
struct SVarCounts
{
uint32_t cCBs;
uint32_t cNumericVariables;
uint32_t cObjectVariables;
};
uint32_t Tag; // should be equal to c_EffectFileTag
// this is used to identify ASCII vs Binary files
SVarCounts Effect;
SVarCounts Pool;
uint32_t cTechniques;
uint32_t cbUnstructured;
uint32_t cStrings;
uint32_t cShaderResources;
uint32_t cDepthStencilBlocks;
uint32_t cBlendStateBlocks;
uint32_t cRasterizerStateBlocks;
uint32_t cSamplers;
uint32_t cRenderTargetViews;
uint32_t cDepthStencilViews;
uint32_t cTotalShaders;
uint32_t cInlineShaders; // of the aforementioned shaders, the number that are defined inline within pass blocks
inline bool RequiresPool() const
{
return (Pool.cCBs != 0) ||
(Pool.cNumericVariables != 0) ||
(Pool.cObjectVariables != 0);
}
};
struct SBinaryHeader5 : public SBinaryHeader
{
uint32_t cGroups;
uint32_t cUnorderedAccessViews;
uint32_t cInterfaceVariables;
uint32_t cInterfaceVariableElements;
uint32_t cClassInstanceElements;
};
// Constant buffer definition
struct SBinaryConstantBuffer
{
// private flags
static const uint32_t c_IsTBuffer = (1 << 0);
static const uint32_t c_IsSingle = (1 << 1);
uint32_t oName; // Offset to constant buffer name
uint32_t Size; // Size, in bytes
uint32_t Flags;
uint32_t cVariables; // # of variables inside this buffer
uint32_t ExplicitBindPoint; // Defined if the effect file specifies a bind point using the register keyword
// otherwise, -1
};
struct SBinaryAnnotation
{
uint32_t oName; // Offset to variable name
uint32_t oType; // Offset to type information (SBinaryType)
// For numeric annotations:
// uint32_t oDefaultValue; // Offset to default initializer value
//
// For string annotations:
// uint32_t oStringOffsets[Elements]; // Elements comes from the type data at oType
};
struct SBinaryNumericVariable
{
uint32_t oName; // Offset to variable name
uint32_t oType; // Offset to type information (SBinaryType)
uint32_t oSemantic; // Offset to semantic information
uint32_t Offset; // Offset in parent constant buffer
uint32_t oDefaultValue; // Offset to default initializer value
uint32_t Flags; // Explicit bind point
};
struct SBinaryInterfaceVariable
{
uint32_t oName; // Offset to variable name
uint32_t oType; // Offset to type information (SBinaryType)
uint32_t oDefaultValue; // Offset to default initializer array (SBinaryInterfaceInitializer[Elements])
uint32_t Flags;
};
struct SBinaryInterfaceInitializer
{
uint32_t oInstanceName;
uint32_t ArrayIndex;
};
struct SBinaryObjectVariable
{
uint32_t oName; // Offset to variable name
uint32_t oType; // Offset to type information (SBinaryType)
uint32_t oSemantic; // Offset to semantic information
uint32_t ExplicitBindPoint; // Used when a variable has been explicitly bound (register(XX)). -1 if not
// Initializer data:
//
// The type structure pointed to by oType gives you Elements,
// VarType (must be EVT_Object), and ObjectType
//
// For ObjectType == EOT_Blend, EOT_DepthStencil, EOT_Rasterizer, EOT_Sampler
// struct
// {
// uint32_t cAssignments;
// SBinaryAssignment Assignments[cAssignments];
// } Blocks[Elements]
//
// For EObjectType == EOT_Texture*, EOT_Buffer
// <nothing>
//
// For EObjectType == EOT_*Shader, EOT_String
// uint32_t oData[Elements]; // offsets to a shader data block or a nullptr-terminated string
//
// For EObjectType == EOT_GeometryShaderSO
// SBinaryGSSOInitializer[Elements]
//
// For EObjectType == EOT_*Shader5
// SBinaryShaderData5[Elements]
};
struct SBinaryGSSOInitializer
{
uint32_t oShader; // Offset to shader bytecode data block
uint32_t oSODecl; // Offset to StreamOutput decl string
};
struct SBinaryShaderData5
{
uint32_t oShader; // Offset to shader bytecode data block
uint32_t oSODecls[4]; // Offset to StreamOutput decl strings
uint32_t cSODecls; // Count of valid oSODecls entries.
uint32_t RasterizedStream; // Which stream is used for rasterization
uint32_t cInterfaceBindings; // Count of interface bindings.
uint32_t oInterfaceBindings; // Offset to SBinaryInterfaceInitializer[cInterfaceBindings].
};
struct SBinaryType
{
uint32_t oTypeName; // Offset to friendly type name ("float4", "VS_OUTPUT")
EVarType VarType; // Numeric, Object, or Struct
uint32_t Elements; // # of array elements (0 for non-arrays)
uint32_t TotalSize; // Size in bytes; not necessarily Stride * Elements for arrays
// because of possible gap left in final register
uint32_t Stride; // If an array, this is the spacing between elements.
// For unpacked arrays, always divisible by 16-bytes (1 register).
// No support for packed arrays
uint32_t PackedSize; // Size, in bytes, of this data typed when fully packed
struct SBinaryMember
{
uint32_t oName; // Offset to structure member name ("m_pFoo")
uint32_t oSemantic; // Offset to semantic ("POSITION0")
uint32_t Offset; // Offset, in bytes, relative to start of parent structure
uint32_t oType; // Offset to member's type descriptor
};
// the data that follows depends on the VarType:
// Numeric: SType::SNumericType
// Object: EObjectType
// Struct:
// struct
// {
// uint32_t cMembers;
// SBinaryMembers Members[cMembers];
// } MemberInfo
// struct
// {
// uint32_t oBaseClassType; // Offset to type information (SBinaryType)
// uint32_t cInterfaces;
// uint32_t oInterfaceTypes[cInterfaces];
// } SBinaryTypeInheritance
// Interface: (nothing)
};
struct SBinaryNumericType
{
ENumericLayout NumericLayout : 3; // scalar (1x1), vector (1xN), matrix (NxN)
EScalarType ScalarType : 5; // float32, int32, int8, etc.
uint32_t Rows : 3; // 1 <= Rows <= 4
uint32_t Columns : 3; // 1 <= Columns <= 4
uint32_t IsColumnMajor : 1; // applies only to matrices
uint32_t IsPackedArray : 1; // if this is an array, indicates whether elements should be greedily packed
};
struct SBinaryTypeInheritance
{
uint32_t oBaseClass; // Offset to base class type info or 0 if no base class.
uint32_t cInterfaces;
// Followed by uint32_t[cInterfaces] with offsets to the type
// info of each interface.
};
struct SBinaryGroup
{
uint32_t oName;
uint32_t cTechniques;
};
struct SBinaryTechnique
{
uint32_t oName;
uint32_t cPasses;
};
struct SBinaryPass
{
uint32_t oName;
uint32_t cAssignments;
};
enum ECompilerAssignmentType
{
ECAT_Invalid, // Assignment-specific data (always in the unstructured blob)
ECAT_Constant, // -N SConstant structures
ECAT_Variable, // -nullptr terminated string with variable name ("foo")
ECAT_ConstIndex, // -SConstantIndex structure
ECAT_VariableIndex, // -SVariableIndex structure
ECAT_ExpressionIndex, // -SIndexedObjectExpression structure
ECAT_Expression, // -Data block containing FXLVM code
ECAT_InlineShader, // -Data block containing shader
ECAT_InlineShader5, // -Data block containing shader with extended 5.0 data (SBinaryShaderData5)
};
struct SBinaryAssignment
{
uint32_t iState; // index into g_lvGeneral
uint32_t Index; // the particular index to assign to (see g_lvGeneral to find the # of valid indices)
ECompilerAssignmentType AssignmentType;
uint32_t oInitializer; // Offset of assignment-specific data
struct SConstantIndex
{
uint32_t oArrayName;
uint32_t Index;
};
struct SVariableIndex
{
uint32_t oArrayName;
uint32_t oIndexVarName;
};
struct SIndexedObjectExpression
{
uint32_t oArrayName;
uint32_t oCode;
};
struct SInlineShader
{
uint32_t oShader;
uint32_t oSODecl;
};
};
struct SBinaryConstant
{
EScalarType Type;
union
{
BOOL bValue;
INT iValue;
float fValue;
};
};
static_assert( sizeof(SBinaryHeader) == 76, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryHeader::SVarCounts) == 12, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryHeader5) == 96, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryConstantBuffer) == 20, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAnnotation) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryNumericVariable) == 24, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryInterfaceVariable) == 16, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryInterfaceInitializer) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryObjectVariable) == 16, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryGSSOInitializer) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryShaderData5) == 36, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryType) == 24, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryType::SBinaryMember) == 16, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryNumericType) == 4, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryTypeInheritance) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryGroup) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryTechnique) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryPass) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAssignment) == 16, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAssignment::SConstantIndex) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAssignment::SVariableIndex) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAssignment::SIndexedObjectExpression) == 8, "FX11 binary size mismatch" );
static_assert( sizeof(SBinaryAssignment::SInlineShader) == 8, "FX11 binary size mismatch" );
} // end namespace D3DX11Effects

55
Effects11/Binary/EffectStateBase11.h Normal file
View File

@@ -0,0 +1,55 @@
//--------------------------------------------------------------------------------------
// File: EffectStateBase11.h
//
// Direct3D 11 Effects States Header
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#pragma once
namespace D3DX11Effects
{
//////////////////////////////////////////////////////////////////////////
// Effect HLSL states and late resolve lists
//////////////////////////////////////////////////////////////////////////
struct RValue
{
const char *m_pName;
uint32_t m_Value;
};
#define RVALUE_END() { nullptr, 0U }
#define RVALUE_ENTRY(prefix, x) { #x, (uint32_t)prefix##x }
enum ELhsType : int;
struct LValue
{
const char *m_pName; // name of the LHS side of expression
EBlockType m_BlockType; // type of block it can appear in
D3D_SHADER_VARIABLE_TYPE m_Type; // data type allows
uint32_t m_Cols; // number of [m_Type]'s required (1 for a scalar, 4 for a vector)
uint32_t m_Indices; // max index allowable (if LHS is an array; otherwise this is 1)
bool m_VectorScalar; // can be both vector and scalar (setting as a scalar sets all m_Indices values simultaneously)
const RValue *m_pRValue; // pointer to table of allowable RHS "late resolve" values
ELhsType m_LhsType; // ELHS_* enum value that corresponds to this entry
uint32_t m_Offset; // offset into the given block type where this value should be written
uint32_t m_Stride; // for vectors, byte stride between two consecutive values. if 0, m_Type's size is used
};
#define LVALUE_END() { nullptr, D3D_SVT_UINT, 0, 0, 0, nullptr }
extern const LValue g_lvGeneral[];
extern const uint32_t g_lvGeneralCount;
} // end namespace D3DX11Effects

241
Effects11/Binary/EffectStates11.h Normal file
View File

@@ -0,0 +1,241 @@
//--------------------------------------------------------------------------------------
// File: EffectStates11.h
//
// Direct3D 11 Effects States Header
// This file defines properties of states which can appear in
// state blocks and pass blocks.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#pragma once
#include "EffectStateBase11.h"
namespace D3DX11Effects
{
//////////////////////////////////////////////////////////////////////////
// Effect HLSL late resolve lists (state values)
//////////////////////////////////////////////////////////////////////////
static const RValue g_rvNULL[] =
{
{ "nullptr", 0 },
RVALUE_END()
};
static const RValue g_rvBOOL[] =
{
{ "false", 0 },
{ "true", 1 },
RVALUE_END()
};
static const RValue g_rvDEPTH_WRITE_MASK[] =
{
{ "ZERO", D3D11_DEPTH_WRITE_MASK_ZERO },
{ "ALL", D3D11_DEPTH_WRITE_MASK_ALL },
RVALUE_END()
};
static const RValue g_rvFILL[] =
{
{ "WIREFRAME", D3D11_FILL_WIREFRAME },
{ "SOLID", D3D11_FILL_SOLID },
RVALUE_END()
};
static const RValue g_rvFILTER[] =
{
RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_POINT_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_POINT_MAG_LINEAR_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_POINT_MAG_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_LINEAR_MAG_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_LINEAR_MAG_POINT_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_LINEAR_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, MIN_MAG_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, ANISOTROPIC ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_POINT_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_POINT_MAG_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_LINEAR_MAG_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_LINEAR_MIP_POINT ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_MIN_MAG_MIP_LINEAR ),
RVALUE_ENTRY(D3D11_FILTER_, COMPARISON_ANISOTROPIC ),
RVALUE_END()
};
static const RValue g_rvBLEND[] =
{
{ "ZERO", D3D11_BLEND_ZERO },
{ "ONE", D3D11_BLEND_ONE },
{ "SRC_COLOR", D3D11_BLEND_SRC_COLOR },
{ "INV_SRC_COLOR", D3D11_BLEND_INV_SRC_COLOR },
{ "SRC_ALPHA", D3D11_BLEND_SRC_ALPHA },
{ "INV_SRC_ALPHA", D3D11_BLEND_INV_SRC_ALPHA },
{ "DEST_ALPHA", D3D11_BLEND_DEST_ALPHA },
{ "INV_DEST_ALPHA", D3D11_BLEND_INV_DEST_ALPHA },
{ "DEST_COLOR", D3D11_BLEND_DEST_COLOR },
{ "INV_DEST_COLOR", D3D11_BLEND_INV_DEST_COLOR },
{ "SRC_ALPHA_SAT", D3D11_BLEND_SRC_ALPHA_SAT },
{ "BLEND_FACTOR", D3D11_BLEND_BLEND_FACTOR },
{ "INV_BLEND_FACTOR", D3D11_BLEND_INV_BLEND_FACTOR },
{ "SRC1_COLOR", D3D11_BLEND_SRC1_COLOR },
{ "INV_SRC1_COLOR", D3D11_BLEND_INV_SRC1_COLOR },
{ "SRC1_ALPHA", D3D11_BLEND_SRC1_ALPHA },
{ "INV_SRC1_ALPHA", D3D11_BLEND_INV_SRC1_ALPHA },
RVALUE_END()
};
static const RValue g_rvTADDRESS[] =
{
{ "CLAMP", D3D11_TEXTURE_ADDRESS_CLAMP },
{ "WRAP", D3D11_TEXTURE_ADDRESS_WRAP },
{ "MIRROR", D3D11_TEXTURE_ADDRESS_MIRROR },
{ "BORDER", D3D11_TEXTURE_ADDRESS_BORDER },
{ "MIRROR_ONCE", D3D11_TEXTURE_ADDRESS_MIRROR_ONCE },
RVALUE_END()
};
static const RValue g_rvCULL[] =
{
{ "NONE", D3D11_CULL_NONE },
{ "FRONT", D3D11_CULL_FRONT },
{ "BACK", D3D11_CULL_BACK },
RVALUE_END()
};
static const RValue g_rvCMP[] =
{
{ "NEVER", D3D11_COMPARISON_NEVER },
{ "LESS", D3D11_COMPARISON_LESS },
{ "EQUAL", D3D11_COMPARISON_EQUAL },
{ "LESS_EQUAL", D3D11_COMPARISON_LESS_EQUAL },
{ "GREATER", D3D11_COMPARISON_GREATER },
{ "NOT_EQUAL", D3D11_COMPARISON_NOT_EQUAL },
{ "GREATER_EQUAL", D3D11_COMPARISON_GREATER_EQUAL },
{ "ALWAYS", D3D11_COMPARISON_ALWAYS },
RVALUE_END()
};
static const RValue g_rvSTENCILOP[] =
{
{ "KEEP", D3D11_STENCIL_OP_KEEP },
{ "ZERO", D3D11_STENCIL_OP_ZERO },
{ "REPLACE", D3D11_STENCIL_OP_REPLACE },
{ "INCR_SAT", D3D11_STENCIL_OP_INCR_SAT },
{ "DECR_SAT", D3D11_STENCIL_OP_DECR_SAT },
{ "INVERT", D3D11_STENCIL_OP_INVERT },
{ "INCR", D3D11_STENCIL_OP_INCR },
{ "DECR", D3D11_STENCIL_OP_DECR },
RVALUE_END()
};
static const RValue g_rvBLENDOP[] =
{
{ "ADD", D3D11_BLEND_OP_ADD },
{ "SUBTRACT", D3D11_BLEND_OP_SUBTRACT },
{ "REV_SUBTRACT", D3D11_BLEND_OP_REV_SUBTRACT },
{ "MIN", D3D11_BLEND_OP_MIN },
{ "MAX", D3D11_BLEND_OP_MAX },
RVALUE_END()
};
//////////////////////////////////////////////////////////////////////////
// Effect HLSL states
//////////////////////////////////////////////////////////////////////////
#define strideof( s, m ) offsetof_fx(s,m[1]) - offsetof_fx(s,m[0])
const LValue g_lvGeneral[] =
{
// RObjects
{ "RasterizerState", EBT_Pass, D3D_SVT_RASTERIZER, 1, 1, false, nullptr, ELHS_RasterizerBlock, offsetof_fx(SPassBlock, BackingStore.pRasterizerBlock), 0 },
{ "DepthStencilState", EBT_Pass, D3D_SVT_DEPTHSTENCIL, 1, 1, false, nullptr, ELHS_DepthStencilBlock, offsetof_fx(SPassBlock, BackingStore.pDepthStencilBlock), 0 },
{ "BlendState", EBT_Pass, D3D_SVT_BLEND, 1, 1, false, nullptr, ELHS_BlendBlock, offsetof_fx(SPassBlock, BackingStore.pBlendBlock), 0 },
{ "RenderTargetView", EBT_Pass, D3D_SVT_RENDERTARGETVIEW, 1, 8, false, nullptr, ELHS_RenderTargetView, offsetof_fx(SPassBlock, BackingStore.pRenderTargetViews), 0 },
{ "DepthStencilView", EBT_Pass, D3D_SVT_DEPTHSTENCILVIEW, 1, 8, false, nullptr, ELHS_DepthStencilView, offsetof_fx(SPassBlock, BackingStore.pDepthStencilView), 0 },
{ "GenerateMips", EBT_Pass, D3D_SVT_TEXTURE, 1, 1, false, nullptr, ELHS_GenerateMips, 0, 0 },
// Shaders
{ "VertexShader", EBT_Pass, D3D_SVT_VERTEXSHADER, 1, 1, false, g_rvNULL, ELHS_VertexShaderBlock, offsetof_fx(SPassBlock, BackingStore.pVertexShaderBlock), 0 },
{ "PixelShader", EBT_Pass, D3D_SVT_PIXELSHADER, 1, 1, false, g_rvNULL, ELHS_PixelShaderBlock, offsetof_fx(SPassBlock, BackingStore.pPixelShaderBlock), 0 },
{ "GeometryShader", EBT_Pass, D3D_SVT_GEOMETRYSHADER, 1, 1, false, g_rvNULL, ELHS_GeometryShaderBlock, offsetof_fx(SPassBlock, BackingStore.pGeometryShaderBlock), 0 },
// RObject config assignments
{ "DS_StencilRef", EBT_Pass, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_DS_StencilRef, offsetof_fx(SPassBlock, BackingStore.StencilRef), 0 },
{ "AB_BlendFactor", EBT_Pass, D3D_SVT_FLOAT, 4, 1, false, nullptr, ELHS_B_BlendFactor, offsetof_fx(SPassBlock, BackingStore.BlendFactor), 0 },
{ "AB_SampleMask", EBT_Pass, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_B_SampleMask, offsetof_fx(SPassBlock, BackingStore.SampleMask), 0 },
{ "FillMode", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, g_rvFILL, ELHS_FillMode, offsetof_fx(SRasterizerBlock, BackingStore.FillMode), 0 },
{ "CullMode", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, g_rvCULL, ELHS_CullMode, offsetof_fx(SRasterizerBlock, BackingStore.CullMode), 0 },
{ "FrontCounterClockwise", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_FrontCC, offsetof_fx(SRasterizerBlock, BackingStore.FrontCounterClockwise), 0 },
{ "DepthBias", EBT_Rasterizer, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_DepthBias, offsetof_fx(SRasterizerBlock, BackingStore.DepthBias), 0 },
{ "DepthBiasClamp", EBT_Rasterizer, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_DepthBiasClamp, offsetof_fx(SRasterizerBlock, BackingStore.DepthBiasClamp), 0 },
{ "SlopeScaledDepthBias", EBT_Rasterizer, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_SlopeScaledDepthBias, offsetof_fx(SRasterizerBlock, BackingStore.SlopeScaledDepthBias), 0 },
{ "DepthClipEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_DepthClipEnable, offsetof_fx(SRasterizerBlock, BackingStore.DepthClipEnable), 0 },
{ "ScissorEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_ScissorEnable, offsetof_fx(SRasterizerBlock, BackingStore.ScissorEnable), 0 },
{ "MultisampleEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_MultisampleEnable, offsetof_fx(SRasterizerBlock, BackingStore.MultisampleEnable), 0 },
{ "AntialiasedLineEnable", EBT_Rasterizer, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_AntialiasedLineEnable, offsetof_fx(SRasterizerBlock, BackingStore.AntialiasedLineEnable), 0 },
{ "DepthEnable", EBT_DepthStencil, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_DepthEnable, offsetof_fx(SDepthStencilBlock, BackingStore.DepthEnable), 0 },
{ "DepthWriteMask", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvDEPTH_WRITE_MASK, ELHS_DepthWriteMask, offsetof_fx(SDepthStencilBlock, BackingStore.DepthWriteMask), 0 },
{ "DepthFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_DepthFunc, offsetof_fx(SDepthStencilBlock, BackingStore.DepthFunc), 0 },
{ "StencilEnable", EBT_DepthStencil, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_StencilEnable, offsetof_fx(SDepthStencilBlock, BackingStore.StencilEnable), 0 },
{ "StencilReadMask", EBT_DepthStencil, D3D_SVT_UINT8, 1, 1, false, nullptr, ELHS_StencilReadMask, offsetof_fx(SDepthStencilBlock, BackingStore.StencilReadMask), 0 },
{ "StencilWriteMask", EBT_DepthStencil, D3D_SVT_UINT8, 1, 1, false, nullptr, ELHS_StencilWriteMask, offsetof_fx(SDepthStencilBlock, BackingStore.StencilWriteMask), 0 },
{ "FrontFaceStencilFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilFailOp, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFailOp), 0 },
{ "FrontFaceStencilDepthFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilDepthFailOp), 0 },
{ "FrontFaceStencilPass", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_FrontFaceStencilPassOp, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilPassOp), 0 },
{ "FrontFaceStencilFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_FrontFaceStencilFunc, offsetof_fx(SDepthStencilBlock, BackingStore.FrontFace.StencilFunc), 0 },
{ "BackFaceStencilFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilFailOp, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFailOp), 0 },
{ "BackFaceStencilDepthFail", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilDepthFailOp,offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilDepthFailOp), 0 },
{ "BackFaceStencilPass", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvSTENCILOP, ELHS_BackFaceStencilPassOp, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilPassOp), 0 },
{ "BackFaceStencilFunc", EBT_DepthStencil, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_BackFaceStencilFunc, offsetof_fx(SDepthStencilBlock, BackingStore.BackFace.StencilFunc), 0 },
{ "AlphaToCoverageEnable", EBT_Blend, D3D_SVT_BOOL, 1, 1, false, g_rvBOOL, ELHS_AlphaToCoverage, offsetof_fx(SBlendBlock, BackingStore.AlphaToCoverageEnable), 0 },
{ "BlendEnable", EBT_Blend, D3D_SVT_BOOL, 1, 8, false, g_rvBOOL, ELHS_BlendEnable, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendEnable), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "SrcBlend", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_SrcBlend, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlend), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "DestBlend", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_DestBlend, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlend), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "BlendOp", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLENDOP, ELHS_BlendOp, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOp), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "SrcBlendAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_SrcBlendAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].SrcBlendAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "DestBlendAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLEND, ELHS_DestBlendAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].DestBlendAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "BlendOpAlpha", EBT_Blend, D3D_SVT_UINT, 1, 8, true, g_rvBLENDOP, ELHS_BlendOpAlpha, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].BlendOpAlpha), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "RenderTargetWriteMask", EBT_Blend, D3D_SVT_UINT8, 1, 8, false, nullptr, ELHS_RenderTargetWriteMask, offsetof_fx(SBlendBlock, BackingStore.RenderTarget[0].RenderTargetWriteMask), strideof(SBlendBlock, BackingStore.RenderTarget) },
{ "Filter", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvFILTER, ELHS_Filter, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.Filter), 0 },
{ "AddressU", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressU, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressU), 0 },
{ "AddressV", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressV, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressV), 0 },
{ "AddressW", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvTADDRESS, ELHS_AddressW, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.AddressW), 0 },
{ "MipLODBias", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MipLODBias, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MipLODBias), 0 },
{ "MaxAnisotropy", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, nullptr, ELHS_MaxAnisotropy, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxAnisotropy), 0 },
{ "ComparisonFunc", EBT_Sampler, D3D_SVT_UINT, 1, 1, false, g_rvCMP, ELHS_ComparisonFunc, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.ComparisonFunc), 0 },
{ "BorderColor", EBT_Sampler, D3D_SVT_FLOAT, 4, 1, false, nullptr, ELHS_BorderColor, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.BorderColor), 0 },
{ "MinLOD", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MinLOD, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MinLOD), 0 },
{ "MaxLOD", EBT_Sampler, D3D_SVT_FLOAT, 1, 1, false, nullptr, ELHS_MaxLOD, offsetof_fx(SSamplerBlock, BackingStore.SamplerDesc.MaxLOD), 0 },
{ "Texture", EBT_Sampler, D3D_SVT_TEXTURE, 1, 1, false, g_rvNULL, ELHS_Texture, offsetof_fx(SSamplerBlock, BackingStore.pTexture), 0 },
// D3D11
{ "HullShader", EBT_Pass, D3D11_SVT_HULLSHADER, 1, 1, false, g_rvNULL, ELHS_HullShaderBlock, offsetof_fx(SPassBlock, BackingStore.pHullShaderBlock), 0 },
{ "DomainShader", EBT_Pass, D3D11_SVT_DOMAINSHADER, 1, 1, false, g_rvNULL, ELHS_DomainShaderBlock, offsetof_fx(SPassBlock, BackingStore.pDomainShaderBlock), 0 },
{ "ComputeShader", EBT_Pass, D3D11_SVT_COMPUTESHADER, 1, 1, false, g_rvNULL, ELHS_ComputeShaderBlock, offsetof_fx(SPassBlock, BackingStore.pComputeShaderBlock), 0 },
};
#define NUM_STATES (sizeof(g_lvGeneral) / sizeof(LValue))
#define MAX_VECTOR_SCALAR_INDEX 8
const uint32_t g_lvGeneralCount = NUM_STATES;
} // end namespace D3DX11Effects

319
Effects11/Binary/SOParser.h Normal file
View File

@@ -0,0 +1,319 @@
//--------------------------------------------------------------------------------------
// File: SOParser.h
//
// Direct3D 11 Effects Stream Out Decl Parser
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#pragma once
#include <stdio.h>
#include <string.h>
namespace D3DX11Effects
{
//////////////////////////////////////////////////////////////////////////
// CSOParser
//////////////////////////////////////////////////////////////////////////
class CSOParser
{
CEffectVector<D3D11_SO_DECLARATION_ENTRY> m_vDecls; // Set of parsed decl entries
D3D11_SO_DECLARATION_ENTRY m_newEntry; // Currently parsing entry
LPSTR m_SemanticString[D3D11_SO_BUFFER_SLOT_COUNT]; // Copy of strings
static const size_t MAX_ERROR_SIZE = 254;
char m_pError[ MAX_ERROR_SIZE + 1 ]; // Error buffer
public:
CSOParser()
{
ZeroMemory(&m_newEntry, sizeof(m_newEntry));
ZeroMemory(m_SemanticString, sizeof(m_SemanticString));
m_pError[0] = 0;
}
~CSOParser()
{
for( size_t Stream = 0; Stream < D3D11_SO_STREAM_COUNT; ++Stream )
{
SAFE_DELETE_ARRAY( m_SemanticString[Stream] );
}
}
// Parse a single string, assuming stream 0
HRESULT Parse( _In_z_ LPCSTR pString )
{
m_vDecls.Clear();
return Parse( 0, pString );
}
// Parse all 4 streams
HRESULT Parse( _In_z_ LPSTR pStreams[D3D11_SO_STREAM_COUNT] )
{
HRESULT hr = S_OK;
m_vDecls.Clear();
for( uint32_t iDecl=0; iDecl < D3D11_SO_STREAM_COUNT; ++iDecl )
{
hr = Parse( iDecl, pStreams[iDecl] );
if( FAILED(hr) )
{
char str[16];
sprintf_s( str, 16, " in stream %u.", iDecl );
str[15] = 0;
strcat_s( m_pError, MAX_ERROR_SIZE, str );
return hr;
}
}
return hr;
}
// Return resulting declarations
D3D11_SO_DECLARATION_ENTRY *GetDeclArray()
{
return &m_vDecls[0];
}
char* GetErrorString()
{
return m_pError;
}
uint32_t GetDeclCount() const
{
return m_vDecls.GetSize();
}
// Return resulting buffer strides
void GetStrides( uint32_t strides[4] )
{
size_t len = GetDeclCount();
strides[0] = strides[1] = strides[2] = strides[3] = 0;
for( size_t i=0; i < len; i++ )
{
strides[m_vDecls[i].OutputSlot] += m_vDecls[i].ComponentCount * sizeof(float);
}
}
protected:
// Parse a single string "[<slot> :] <semantic>[<index>][.<mask>]; [[<slot> :] <semantic>[<index>][.<mask>][;]]"
HRESULT Parse( _In_ uint32_t Stream, _In_z_ LPCSTR pString )
{
HRESULT hr = S_OK;
m_pError[0] = 0;
if( pString == nullptr )
return S_OK;
uint32_t len = (uint32_t)strlen( pString );
if( len == 0 )
return S_OK;
SAFE_DELETE_ARRAY( m_SemanticString[Stream] );
VN( m_SemanticString[Stream] = new char[len + 1] );
strcpy_s( m_SemanticString[Stream], len + 1, pString );
LPSTR pSemantic = m_SemanticString[Stream];
while( true )
{
// Each decl entry is delimited by a semi-colon
LPSTR pSemi = strchr( pSemantic, ';' );
// strip leading and trailing spaces
LPSTR pEnd;
if( pSemi != nullptr )
{
*pSemi = '\0';
pEnd = pSemi - 1;
}
else
{
pEnd = pSemantic + strlen( pSemantic );
}
while( isspace( (unsigned char)*pSemantic ) )
pSemantic++;
while( pEnd > pSemantic && isspace( (unsigned char)*pEnd ) )
{
*pEnd = '\0';
pEnd--;
}
if( *pSemantic != '\0' )
{
VH( AddSemantic( pSemantic ) );
m_newEntry.Stream = Stream;
VH( m_vDecls.Add( m_newEntry ) );
}
if( pSemi == nullptr )
break;
pSemantic = pSemi + 1;
}
lExit:
return hr;
}
// Parse a single decl "[<slot> :] <semantic>[<index>][.<mask>]"
HRESULT AddSemantic( _Inout_z_ LPSTR pSemantic )
{
HRESULT hr = S_OK;
assert( pSemantic );
ZeroMemory( &m_newEntry, sizeof(m_newEntry) );
VH( ConsumeOutputSlot( &pSemantic ) );
VH( ConsumeRegisterMask( pSemantic ) );
VH( ConsumeSemanticIndex( pSemantic ) );
// pSenantic now contains only the SemanticName (all other fields were consumed)
if( strcmp( "$SKIP", pSemantic ) != 0 )
{
m_newEntry.SemanticName = pSemantic;
}
lExit:
return hr;
}
// Parse optional mask "[.<mask>]"
HRESULT ConsumeRegisterMask( _Inout_z_ LPSTR pSemantic )
{
HRESULT hr = S_OK;
const char *pFullMask1 = "xyzw";
const char *pFullMask2 = "rgba";
size_t stringLength;
size_t startComponent = 0;
LPCSTR p;
assert( pSemantic );
pSemantic = strchr( pSemantic, '.' );
if( pSemantic == nullptr )
{
m_newEntry.ComponentCount = 4;
return S_OK;
}
*pSemantic = '\0';
pSemantic++;
stringLength = strlen( pSemantic );
p = strstr(pFullMask1, pSemantic );
if( p )
{
startComponent = (uint32_t)( p - pFullMask1 );
}
else
{
p = strstr( pFullMask2, pSemantic );
if( p )
startComponent = (uint32_t)( p - pFullMask2 );
else
{
sprintf_s( m_pError, MAX_ERROR_SIZE, "ID3D11Effect::ParseSODecl - invalid mask declaration '%s'", pSemantic );
VH( E_FAIL );
}
}
if( stringLength == 0 )
stringLength = 4;
m_newEntry.StartComponent = (uint8_t)startComponent;
m_newEntry.ComponentCount = (uint8_t)stringLength;
lExit:
return hr;
}
// Parse optional output slot "[<slot> :]"
HRESULT ConsumeOutputSlot( _Inout_z_ LPSTR* ppSemantic )
{
assert( ppSemantic && *ppSemantic );
_Analysis_assume_( ppSemantic && *ppSemantic );
HRESULT hr = S_OK;
LPSTR pColon = strchr( *ppSemantic, ':' );
if( pColon == nullptr )
return S_OK;
if( pColon == *ppSemantic )
{
strcpy_s( m_pError, MAX_ERROR_SIZE,
"ID3D11Effect::ParseSODecl - Invalid output slot" );
VH( E_FAIL );
}
*pColon = '\0';
int outputSlot = atoi( *ppSemantic );
if( outputSlot < 0 || outputSlot > 255 )
{
strcpy_s( m_pError, MAX_ERROR_SIZE,
"ID3D11Effect::ParseSODecl - Invalid output slot" );
VH( E_FAIL );
}
m_newEntry.OutputSlot = (uint8_t)outputSlot;
while( *ppSemantic < pColon )
{
if( !isdigit( (unsigned char)**ppSemantic ) )
{
sprintf_s( m_pError, MAX_ERROR_SIZE, "ID3D11Effect::ParseSODecl - Non-digit '%c' in output slot", **ppSemantic );
VH( E_FAIL );
}
(*ppSemantic)++;
}
// skip the colon (which is now '\0')
(*ppSemantic)++;
while( isspace( (unsigned char)**ppSemantic ) )
(*ppSemantic)++;
lExit:
return hr;
}
// Parse optional index "[<index>]"
HRESULT ConsumeSemanticIndex( _Inout_z_ LPSTR pSemantic )
{
assert( pSemantic );
uint32_t uLen = (uint32_t)strlen( pSemantic );
// Grab semantic index
while( uLen > 0 && isdigit( (unsigned char)pSemantic[uLen - 1] ) )
uLen--;
if( isdigit( (unsigned char)pSemantic[uLen] ) )
{
m_newEntry.SemanticIndex = atoi( pSemantic + uLen );
pSemantic[uLen] = '\0';
}
else
{
m_newEntry.SemanticIndex = 0;
}
return S_OK;
}
};
} // end namespace D3DX11Effects