/////////////////////////////////////////////////////////////////////////////// // // // ShaderBinary.h // // Copyright (C) Microsoft Corporation. All rights reserved. // // This file is distributed under the University of Illinois Open Source // // License. See LICENSE.TXT for details. // // // // Vertex shader binary format parsing and encoding. // // // /////////////////////////////////////////////////////////////////////////////// #pragma once //has dependencies on D3D10TokenizedProgramFormat.hpp! make sure to include that too! typedef UINT CShaderToken; //***************************************************************************** // // GetNumVertices // // Returns the number of vertices in a complete primitive // //***************************************************************************** inline UINT GetNumVertices( D3D10_SB_PRIMITIVE PrimType ) { switch( PrimType ) { case D3D10_SB_PRIMITIVE_POINT: return 1; case D3D10_SB_PRIMITIVE_LINE: return 2; case D3D10_SB_PRIMITIVE_TRIANGLE: return 3; case D3D10_SB_PRIMITIVE_LINE_ADJ: return 4; case D3D10_SB_PRIMITIVE_TRIANGLE_ADJ: return 6; case D3D11_SB_PRIMITIVE_1_CONTROL_POINT_PATCH: return 1; case D3D11_SB_PRIMITIVE_2_CONTROL_POINT_PATCH: return 2; case D3D11_SB_PRIMITIVE_3_CONTROL_POINT_PATCH: return 3; case D3D11_SB_PRIMITIVE_4_CONTROL_POINT_PATCH: return 4; case D3D11_SB_PRIMITIVE_5_CONTROL_POINT_PATCH: return 5; case D3D11_SB_PRIMITIVE_6_CONTROL_POINT_PATCH: return 6; case D3D11_SB_PRIMITIVE_7_CONTROL_POINT_PATCH: return 7; case D3D11_SB_PRIMITIVE_8_CONTROL_POINT_PATCH: return 8; case D3D11_SB_PRIMITIVE_9_CONTROL_POINT_PATCH: return 9; case D3D11_SB_PRIMITIVE_10_CONTROL_POINT_PATCH: return 10; case D3D11_SB_PRIMITIVE_11_CONTROL_POINT_PATCH: return 11; case D3D11_SB_PRIMITIVE_12_CONTROL_POINT_PATCH: return 12; case D3D11_SB_PRIMITIVE_13_CONTROL_POINT_PATCH: return 13; case D3D11_SB_PRIMITIVE_14_CONTROL_POINT_PATCH: return 14; case D3D11_SB_PRIMITIVE_15_CONTROL_POINT_PATCH: return 15; case D3D11_SB_PRIMITIVE_16_CONTROL_POINT_PATCH: return 16; case D3D11_SB_PRIMITIVE_17_CONTROL_POINT_PATCH: return 17; case D3D11_SB_PRIMITIVE_18_CONTROL_POINT_PATCH: return 18; case D3D11_SB_PRIMITIVE_19_CONTROL_POINT_PATCH: return 19; case D3D11_SB_PRIMITIVE_20_CONTROL_POINT_PATCH: return 20; case D3D11_SB_PRIMITIVE_21_CONTROL_POINT_PATCH: return 21; case D3D11_SB_PRIMITIVE_22_CONTROL_POINT_PATCH: return 22; case D3D11_SB_PRIMITIVE_23_CONTROL_POINT_PATCH: return 23; case D3D11_SB_PRIMITIVE_24_CONTROL_POINT_PATCH: return 24; case D3D11_SB_PRIMITIVE_25_CONTROL_POINT_PATCH: return 25; case D3D11_SB_PRIMITIVE_26_CONTROL_POINT_PATCH: return 26; case D3D11_SB_PRIMITIVE_27_CONTROL_POINT_PATCH: return 27; case D3D11_SB_PRIMITIVE_28_CONTROL_POINT_PATCH: return 28; case D3D11_SB_PRIMITIVE_29_CONTROL_POINT_PATCH: return 29; case D3D11_SB_PRIMITIVE_30_CONTROL_POINT_PATCH: return 30; case D3D11_SB_PRIMITIVE_31_CONTROL_POINT_PATCH: return 31; case D3D11_SB_PRIMITIVE_32_CONTROL_POINT_PATCH: return 32; default: return 0; } } /*==========================================================================; * * D3D10ShaderBinary namespace * * File: ShaderBinary.h * Content: Vertex shader assembler support * ***************************************************************************/ namespace D3D10ShaderBinary { const UINT MAX_INSTRUCTION_LENGTH = 128; const UINT D3D10_SB_MAX_INSTRUCTION_OPERANDS = 8; const UINT D3D11_SB_MAX_CALL_OPERANDS = 0x10000; const UINT D3D11_SB_MAX_NUM_TYPES = 0x10000; typedef enum D3D10_SB_OPCODE_CLASS { D3D10_SB_FLOAT_OP, D3D10_SB_INT_OP, D3D10_SB_UINT_OP, D3D10_SB_BIT_OP, D3D10_SB_FLOW_OP, D3D10_SB_TEX_OP, D3D10_SB_DCL_OP, D3D11_SB_ATOMIC_OP, D3D11_SB_MEM_OP, D3D11_SB_DOUBLE_OP, D3D11_SB_FLOAT_TO_DOUBLE_OP, D3D11_SB_DOUBLE_TO_FLOAT_OP, D3D11_SB_DEBUG_OP, } D3D10_SB_OPCODE_CLASS; struct CInstructionInfo { void Set (BYTE NumOperands, LPCSTR Name, D3D10_SB_OPCODE_CLASS OpClass, BYTE InPrecisionFromOutMask) { m_NumOperands = NumOperands; m_InPrecisionFromOutMask = InPrecisionFromOutMask; StringCchCopyA(m_Name, sizeof(m_Name), Name); m_OpClass = OpClass; } char m_Name[64]; BYTE m_NumOperands; BYTE m_InPrecisionFromOutMask; D3D10_SB_OPCODE_CLASS m_OpClass; }; extern CInstructionInfo g_InstructionInfo[D3D10_SB_NUM_OPCODES]; UINT GetNumInstructionOperands(D3D10_SB_OPCODE_TYPE OpCode); void InitInstructionInfo(); //***************************************************************************** // // class COperandIndex // // Represents a dimension index of an operand // //***************************************************************************** class COperandIndex { public: COperandIndex() : m_bExtendedOperand(FALSE) {} // Value for the immediate index type union { UINT m_RegIndex; UINT m_RegIndexA[2]; INT64 m_RegIndex64; }; // Data for the relative index type D3D10_SB_OPERAND_TYPE m_RelRegType; D3D10_SB_4_COMPONENT_NAME m_ComponentName; D3D10_SB_OPERAND_INDEX_DIMENSION m_IndexDimension; BOOL m_bExtendedOperand; D3D11_SB_OPERAND_MIN_PRECISION m_MinPrecision; BOOL m_Nonuniform; D3D10_SB_EXTENDED_OPERAND_TYPE m_ExtendedOperandType; // First index of the relative register union { UINT m_RelIndex; UINT m_RelIndexA[2]; INT64 m_RelIndex64; }; // Second index of the relative register union { UINT m_RelIndex1; UINT m_RelIndexA1[2]; INT64 m_RelIndex641; }; void SetMinPrecision(D3D11_SB_OPERAND_MIN_PRECISION MinPrec) { m_MinPrecision = MinPrec; if( MinPrec != D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) { m_bExtendedOperand = true; m_ExtendedOperandType = D3D10_SB_EXTENDED_OPERAND_MODIFIER; // piggybacking on modifier token for minprecision } } void SetNonuniformIndex(bool bNonuniform = false) { m_Nonuniform = bNonuniform; if(bNonuniform) { m_bExtendedOperand = true; m_ExtendedOperandType = D3D10_SB_EXTENDED_OPERAND_MODIFIER; } } }; enum MinPrecQuantizeFunctionIndex // Used by reference rasterizer (IHVs can ignore) { MinPrecFuncDefault = 0, MinPrecFunc2_8, MinPrecFunc16, MinPrecFuncUint16, MinPrecFuncInt16, }; //***************************************************************************** // // class COperandBase // // A base class for shader instruction operands // //***************************************************************************** class COperandBase { public: COperandBase() {Clear();} COperandBase(const COperandBase & Op) { memcpy(this, &Op, sizeof(*this)); } D3D10_SB_OPERAND_TYPE OperandType() const {return m_Type;} const COperandIndex* OperandIndex(UINT Index) const {return &m_Index[Index];} D3D10_SB_OPERAND_INDEX_REPRESENTATION OperandIndexType(UINT Index) const {return m_IndexType[Index];} D3D10_SB_OPERAND_INDEX_DIMENSION OperandIndexDimension() const {return m_IndexDimension;} D3D10_SB_OPERAND_NUM_COMPONENTS NumComponents() const {return m_NumComponents;} // Get the register index for a given dimension UINT RegIndex(UINT Dimension = 0) const {return m_Index[Dimension].m_RegIndex;} // Get the register index from the lowest dimension UINT RegIndexForMinorDimension() const { switch (m_IndexDimension) { default: case D3D10_SB_OPERAND_INDEX_1D: return RegIndex(0); case D3D10_SB_OPERAND_INDEX_2D: return RegIndex(1); case D3D10_SB_OPERAND_INDEX_3D: return RegIndex(2); } } // Get the write mask UINT WriteMask() const {return m_WriteMask;} // Get the swizzle UINT SwizzleComponent(UINT index) const {return m_Swizzle[index];} // Get immediate 32 bit value UINT Imm32() const {return m_Value[0];} void SetModifier(D3D10_SB_OPERAND_MODIFIER Modifier) { m_Modifier = Modifier; if (Modifier != D3D10_SB_OPERAND_MODIFIER_NONE) { m_bExtendedOperand = true; m_ExtendedOperandType = D3D10_SB_EXTENDED_OPERAND_MODIFIER; } } void SetMinPrecision(D3D11_SB_OPERAND_MIN_PRECISION MinPrec) { m_MinPrecision = MinPrec; if( m_MinPrecision != D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) { m_bExtendedOperand = true; m_ExtendedOperandType = D3D10_SB_EXTENDED_OPERAND_MODIFIER; // reusing same extended operand token as modifiers. } } void SetNonuniform(bool bNonuniform = false) { m_Nonuniform = bNonuniform; if(bNonuniform) { m_bExtendedOperand = true; m_ExtendedOperandType = D3D10_SB_EXTENDED_OPERAND_MODIFIER; } } D3D10_SB_OPERAND_MODIFIER Modifier() const {return m_Modifier;} void SetSwizzle(BYTE SwizzleX=D3D10_SB_4_COMPONENT_X, BYTE SwizzleY=D3D10_SB_4_COMPONENT_Y, BYTE SwizzleZ=D3D10_SB_4_COMPONENT_Z, BYTE SwizzleW=D3D10_SB_4_COMPONENT_W) { m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MODE; m_Swizzle[0] = SwizzleX; m_Swizzle[1] = SwizzleY; m_Swizzle[2] = SwizzleZ; m_Swizzle[3] = SwizzleW; } void SelectComponent(D3D10_SB_4_COMPONENT_NAME ComponentName=D3D10_SB_4_COMPONENT_X) { m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE; m_ComponentName = ComponentName; } void SetMask(UINT Mask=D3D10_SB_OPERAND_4_COMPONENT_MASK_ALL) { m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE; m_WriteMask = Mask; } void SetIndex(UINT Dim, UINT Imm32) { m_IndexType[Dim] = D3D10_SB_OPERAND_INDEX_IMMEDIATE32; m_Index[Dim].m_RegIndex = Imm32; } void SetIndex( UINT Dim, UINT Offset, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex0, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_IndexType[Dim] = D3D10_SB_OPERAND_INDEX_IMMEDIATE32; if (Offset == 0) m_IndexType[Dim] = D3D10_SB_OPERAND_INDEX_RELATIVE; else m_IndexType[Dim] = D3D10_SB_OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE; m_Index[Dim].m_RegIndex = Offset; // immediate offset, such as the 3 in cb0[x1[2].x + 3] or cb0[r1.x + 3] m_Index[Dim].m_RelRegType = RelRegType; if( RelRegType == D3D10_SB_OPERAND_TYPE_INDEXABLE_TEMP ) m_Index[Dim].m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; else m_Index[Dim].m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; m_Index[Dim].m_RelIndex = RelRegIndex0; // relative register index, such as the 1 in cb0[x1[2].x + 3] or cb0[r1.x + 3] m_Index[Dim].m_RelIndex1 = RelRegIndex1; // relative register second dimension index, such as the 2 in cb0[x1[2].x + 3] m_Index[Dim].m_ComponentName = RelComponentName; m_Index[Dim].SetMinPrecision(RelRegMinPrecision); } public: //esp in the unions...it's just redundant to not directly access things void Clear() { memset(this, 0, sizeof(*this)); } MinPrecQuantizeFunctionIndex m_MinPrecQuantizeFunctionIndex; // used by ref for low precision (IHVs can ignore) D3D10_SB_OPERAND_TYPE m_Type; COperandIndex m_Index[3]; D3D10_SB_OPERAND_NUM_COMPONENTS m_NumComponents; D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE m_ComponentSelection; BOOL m_bExtendedOperand; D3D10_SB_OPERAND_MODIFIER m_Modifier; D3D11_SB_OPERAND_MIN_PRECISION m_MinPrecision; BOOL m_Nonuniform; D3D10_SB_EXTENDED_OPERAND_TYPE m_ExtendedOperandType; union { UINT m_WriteMask; BYTE m_Swizzle[4]; }; D3D10_SB_4_COMPONENT_NAME m_ComponentName; union { UINT m_Value[4]; float m_Valuef[4]; INT64 m_Value64[2]; double m_Valued[2]; }; struct { D3D10_SB_OPERAND_INDEX_REPRESENTATION m_IndexType[3]; D3D10_SB_OPERAND_INDEX_DIMENSION m_IndexDimension; #pragma warning(suppress: 4201) // Warning about nameless structure. }; friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; friend class COperand; friend class COperandDst; }; //***************************************************************************** // // class COperand // // Encapsulates a source operand in shader instructions // //***************************************************************************** class COperand: public COperandBase { public: COperand(): COperandBase() {} COperand(UINT Imm32): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_WriteMask = 0; m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value[0] = Imm32; m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; } COperand(int Imm32): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_WriteMask = 0; m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value[0] = Imm32; m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; } COperand(float Imm32): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_WriteMask = 0; m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Valuef[0] = Imm32; m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; } COperand(INT64 Imm64): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_WriteMask = 0; m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE64; m_bExtendedOperand = FALSE; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value64[0] = Imm64; m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; } COperand(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_Type = Type; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_0_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } // Immediate constant COperand(float v1, float v2, float v3, float v4): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Valuef[0] = v1; m_Valuef[1] = v2; m_Valuef[2] = v3; m_Valuef[3] = v4; } // Immediate constant COperand(double v1, double v2): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE64; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Valued[0] = v1; m_Valued[1] = v2; } // Immediate constant COperand(float v1, float v2, float v3, float v4, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Valuef[0] = v1; m_Valuef[1] = v2; m_Valuef[2] = v3; m_Valuef[3] = v4; } // Immediate constant COperand(int v1, int v2, int v3, int v4): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value[0] = v1; m_Value[1] = v2; m_Value[2] = v3; m_Value[3] = v4; } // Immediate constant COperand(int v1, int v2, int v3, int v4, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE32; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value[0] = v1; m_Value[1] = v2; m_Value[2] = v3; m_Value[3] = v4; } COperand(INT64 v1, INT64 v2): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = D3D10_SB_OPERAND_TYPE_IMMEDIATE64; m_bExtendedOperand = FALSE; m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Value64[0] = v1; m_Value64[1] = v2; } COperand(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } // Used for operands without indices COperand(D3D10_SB_OPERAND_TYPE Type, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Type = Type; m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; if( (Type == D3D10_SB_OPERAND_TYPE_INPUT_PRIMITIVEID) || (Type == D3D11_SB_OPERAND_TYPE_OUTPUT_CONTROL_POINT_ID) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_COVERAGE_MASK) || (Type == D3D11_SB_OPERAND_TYPE_INNER_COVERAGE) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_GS_INSTANCE_ID) ) { m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; } else if( (Type == D3D11_SB_OPERAND_TYPE_INPUT_DOMAIN_POINT) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_THREAD_GROUP_ID) || (Type == D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP) || (Type == D3D11_SB_OPERAND_TYPE_CYCLE_COUNTER) ) { m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; } else { m_NumComponents = D3D10_SB_OPERAND_0_COMPONENT; } } // source operand with relative addressing COperand(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_0_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, 0xFFFFFFFF, RelComponentName, RelRegMinPrecision); } friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; }; //***************************************************************************** // // class COperand4 // // Encapsulates a source operand with 4 components in shader instructions // //***************************************************************************** class COperand4: public COperandBase { public: COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D10_SB_4_COMPONENT_NAME Component, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE; m_ComponentName = Component; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } // single component select on reg, 1D indexing on address COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D10_SB_4_COMPONENT_NAME Component, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE; m_ComponentName = Component; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, 0xFFFFFFFF, RelComponentName, RelRegMinPrecision); } // 4-component source operand with relative addressing COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, 0xFFFFFFFF, RelComponentName, RelRegMinPrecision); } // 4-component source operand with relative addressing COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, RelRegIndex1, RelComponentName, RelRegMinPrecision); } COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } // 4-component source operand with relative addressing COperand4(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, RelRegIndex1, RelComponentName, RelRegMinPrecision); } friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; }; //***************************************************************************** // // class COperandDst // // Encapsulates a destination operand in shader instructions // //***************************************************************************** class COperandDst: public COperandBase { public: COperandDst(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetMask(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } COperandDst(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetMask(WriteMask); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex); } COperandDst(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, UINT WriteMask, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelRegMinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) :COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetMask(WriteMask); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_1D; SetIndex(0, RegIndex, RelRegType, RelRegIndex, RelRegIndex1, RelComponentName, RelRegMinPrecision); } COperandDst(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex, UINT WriteMask, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, UINT, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg1MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE; m_WriteMask = WriteMask; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex); SetIndex(1, RelRegIndex, RelRegType, RelRegIndex1, 0, RelComponentName, RelReg1MinPrecision); } // 2D dst (e.g. for GS input decl) COperandDst(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1,UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE; m_WriteMask = WriteMask; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1); } // Used for operands without indices COperandDst(D3D10_SB_OPERAND_TYPE Type, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { switch( Type ) { case D3D10_SB_OPERAND_TYPE_OUTPUT_DEPTH: case D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL: case D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL: case D3D11_SB_OPERAND_TYPE_OUTPUT_STENCIL_REF: m_NumComponents = D3D10_SB_OPERAND_1_COMPONENT; break; default: m_NumComponents = D3D10_SB_OPERAND_0_COMPONENT; break; } m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); } COperandDst(UINT WriteMask, D3D10_SB_OPERAND_TYPE Type, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() // param order disambiguates from another constructor. { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE; m_WriteMask = WriteMask; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_0D; } friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; }; //***************************************************************************** // // class COperand2D // // Encapsulates 2 dimensional source operand with 4 components in shader instructions // //***************************************************************************** class COperand2D: public COperandBase { public: COperand2D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1); } COperand2D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, D3D10_SB_4_COMPONENT_NAME Component, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; m_ComponentSelection = D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE; m_ComponentName = Component; m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1); } // 2-dimensional 4-component operand with relative addressing the second index // For example: // c2[x12[3].w + 7] // Type = c // RelRegType = x // RegIndex0 = 2 // RegIndex1 = 7 // RelRegIndex = 12 // RelRegIndex1 = 3 // RelComponentName = w // COperand2D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, UINT RelRegIndex1, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg1MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1, RelRegType, RelRegIndex, RelRegIndex1, RelComponentName, RelReg1MinPrecision); } // 2-dimensional 4-component operand with relative addressing a second index // For example: // c2[r12.y + 7] // Type = c // RelRegType = r // RegIndex0 = 2 // RegIndex1 = 7 // RelRegIndex = 12 // RelRegIndex1 = 3 // RelComponentName = y // COperand2D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, D3D10_SB_OPERAND_TYPE RelRegType, UINT RelRegIndex, D3D10_SB_4_COMPONENT_NAME RelComponentName, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg1MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1, RelRegType, RelRegIndex, 0, RelComponentName, RelReg1MinPrecision); } // 2-dimensional 4-component operand with relative addressing both operands COperand2D(D3D10_SB_OPERAND_TYPE Type, BOOL bIndexRelative0, BOOL bIndexRelative1, UINT RegIndex0, UINT RegIndex1, D3D10_SB_OPERAND_TYPE RelRegType0, UINT RelRegIndex0, UINT RelRegIndex10, D3D10_SB_4_COMPONENT_NAME RelComponentName0, D3D10_SB_OPERAND_TYPE RelRegType1, UINT RelRegIndex1, UINT RelRegIndex11, D3D10_SB_4_COMPONENT_NAME RelComponentName1, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg0MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg1MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; if (bIndexRelative0) SetIndex(0, RegIndex0, RelRegType0, RelRegIndex0, RelRegIndex10, RelComponentName0, RelReg0MinPrecision); else SetIndex(0, RegIndex0); if (bIndexRelative1) SetIndex(1, RegIndex1, RelRegType1, RelRegIndex1, RelRegIndex11, RelComponentName1, RelReg1MinPrecision); else SetIndex(1, RegIndex1); } COperand2D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT): COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1); } // 2-dimensional 4-component operand with relative addressing and swizzle COperand2D(D3D10_SB_OPERAND_TYPE Type, BYTE SwizzleX, BYTE SwizzleY, BYTE SwizzleZ, BYTE SwizzleW, BOOL bIndexRelative0, BOOL bIndexRelative1, UINT RegIndex0, D3D10_SB_OPERAND_TYPE RelRegType0, UINT RelRegIndex0, UINT RelRegIndex10, D3D10_SB_4_COMPONENT_NAME RelComponentName0, UINT RegIndex1, D3D10_SB_OPERAND_TYPE RelRegType1, UINT RelRegIndex1, UINT RelRegIndex11, D3D10_SB_4_COMPONENT_NAME RelComponentName1, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg0MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT, D3D11_SB_OPERAND_MIN_PRECISION RelReg1MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT ) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(SwizzleX, SwizzleY, SwizzleZ, SwizzleW); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_2D; if (bIndexRelative0) SetIndex(0, RegIndex0, RelRegType0, RelRegIndex0, RelRegIndex10, RelComponentName0, RelReg0MinPrecision); else SetIndex(0, RegIndex0); if (bIndexRelative1) SetIndex(1, RegIndex1, RelRegType1, RelRegIndex1, RelRegIndex11, RelComponentName1, RelReg1MinPrecision); else SetIndex(1, RegIndex1); } friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; }; class COperand3D: public COperandBase { public: COperand3D(D3D10_SB_OPERAND_TYPE Type, UINT RegIndex0, UINT RegIndex1, UINT RegIndex2, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) : COperandBase() { m_Modifier = D3D10_SB_OPERAND_MODIFIER_NONE; SetSwizzle(); m_Type = Type; m_bExtendedOperand = FALSE; SetMinPrecision(MinPrecision); m_NumComponents = D3D10_SB_OPERAND_4_COMPONENT; m_IndexDimension = D3D10_SB_OPERAND_INDEX_3D; SetIndex(0, RegIndex0); SetIndex(1, RegIndex1); SetIndex(2, RegIndex2); } friend class CShaderAsm; friend class CShaderCodeParser; friend class CInstruction; }; //***************************************************************************** // // CInstruction // //***************************************************************************** // Structures for additional per-instruction fields unioned in CInstruction. // These structures don't contain ALL info used by the particular instruction, // only additional info not already in CInstruction. Some instructions don't // need such structures because CInstruction already has the correct data // fields. struct CGlobalFlagsDecl { UINT Flags; }; struct CInputSystemInterpretedValueDecl { D3D10_SB_NAME Name; }; struct CInputSystemGeneratedValueDecl { D3D10_SB_NAME Name; }; struct CInputPSDecl { D3D10_SB_INTERPOLATION_MODE InterpolationMode; }; struct CInputPSSystemInterpretedValueDecl { D3D10_SB_NAME Name; D3D10_SB_INTERPOLATION_MODE InterpolationMode; }; struct CInputPSSystemGeneratedValueDecl { D3D10_SB_NAME Name; D3D10_SB_INTERPOLATION_MODE InterpolationMode; }; struct COutputSystemInterpretedValueDecl { D3D10_SB_NAME Name; }; struct COutputSystemGeneratedValueDecl { D3D10_SB_NAME Name; }; struct CIndexRangeDecl { UINT RegCount; }; struct CResourceDecl { D3D10_SB_RESOURCE_DIMENSION Dimension; D3D10_SB_RESOURCE_RETURN_TYPE ReturnType[4]; UINT SampleCount; UINT Space; }; struct CConstantBufferDecl { D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN AccessPattern; UINT Size; UINT Space; }; struct COutputTopologyDecl { D3D10_SB_PRIMITIVE_TOPOLOGY Topology; }; struct CInputPrimitiveDecl { D3D10_SB_PRIMITIVE Primitive; }; struct CGSMaxOutputVertexCountDecl { UINT MaxOutputVertexCount; }; struct CGSInstanceCountDecl { UINT InstanceCount; }; struct CSamplerDecl { D3D10_SB_SAMPLER_MODE SamplerMode; UINT Space; }; struct CStreamDecl { UINT Stream; }; struct CTempsDecl { UINT NumTemps; }; struct CIndexableTempDecl { UINT IndexableTempNumber; UINT NumRegisters; UINT Mask; // .x, .xy, .xzy or .xyzw (D3D10_SB_OPERAND_4_COMPONENT_MASK_* ) }; struct CHSDSInputControlPointCountDecl { UINT InputControlPointCount; }; struct CHSOutputControlPointCountDecl { UINT OutputControlPointCount; }; struct CTessellatorDomainDecl { D3D11_SB_TESSELLATOR_DOMAIN TessellatorDomain; }; struct CTessellatorPartitioningDecl { D3D11_SB_TESSELLATOR_PARTITIONING TessellatorPartitioning; }; struct CTessellatorOutputPrimitiveDecl { D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE TessellatorOutputPrimitive; }; struct CHSMaxTessFactorDecl { float MaxTessFactor; }; struct CHSForkPhaseInstanceCountDecl { UINT InstanceCount; }; struct CHSJoinPhaseInstanceCountDecl { UINT InstanceCount; }; struct CShaderMessage { D3D11_SB_SHADER_MESSAGE_ID MessageID; D3D11_SB_SHADER_MESSAGE_FORMAT FormatStyle; PCSTR pFormatString; UINT NumOperands; COperandBase* pOperands; }; struct CCustomData { D3D10_SB_CUSTOMDATA_CLASS Type; UINT DataSizeInBytes; void* pData; union { CShaderMessage ShaderMessage; }; }; struct CFunctionTableDecl { UINT FunctionTableNumber; UINT TableLength; UINT* pFunctionIdentifiers; }; struct CInterfaceDecl { WORD InterfaceNumber; WORD ArrayLength; UINT ExpectedTableSize; UINT TableLength; UINT* pFunctionTableIdentifiers; bool bDynamicallyIndexed; }; struct CFunctionBodyDecl { UINT FunctionBodyNumber; }; struct CInterfaceCall { UINT FunctionIndex; COperandBase* pInterfaceOperand; }; struct CThreadGroupDeclaration { UINT x; UINT y; UINT z; }; struct CTypedUAVDeclaration { D3D10_SB_RESOURCE_DIMENSION Dimension; D3D10_SB_RESOURCE_RETURN_TYPE ReturnType[4]; UINT Flags; UINT Space; }; struct CStructuredUAVDeclaration { UINT ByteStride; UINT Flags; UINT Space; }; struct CRawUAVDeclaration { UINT Flags; UINT Space; }; struct CRawTGSMDeclaration { UINT ByteCount; }; struct CStructuredTGSMDeclaration { UINT StructByteStride; UINT StructCount; }; struct CRawSRVDeclaration { UINT Space; }; struct CStructuredSRVDeclaration { UINT ByteStride; UINT Space; }; struct CSyncFlags { bool bThreadsInGroup; bool bThreadGroupSharedMemory; bool bUnorderedAccessViewMemoryGlobal; bool bUnorderedAccessViewMemoryGroup; // exclusive to global }; class CInstruction { protected: static const UINT MAX_PRIVATE_DATA_COUNT = 2; public: CInstruction():m_OpCode(D3D10_SB_OPCODE_ADD) { Clear(); } CInstruction(D3D10_SB_OPCODE_TYPE OpCode) { Clear(); m_OpCode = OpCode; m_NumOperands = 0; m_ExtendedOpCodeCount = 0; } CInstruction(D3D10_SB_OPCODE_TYPE OpCode, COperandBase& Operand0, D3D10_SB_INSTRUCTION_TEST_BOOLEAN Test) { Clear(); m_OpCode = OpCode; m_NumOperands = 1; m_ExtendedOpCodeCount = 0; m_Test = Test; m_Operands[0] = Operand0; } CInstruction(D3D10_SB_OPCODE_TYPE OpCode, COperandBase& Operand0, COperandBase& Operand1) { Clear(); m_OpCode = OpCode; m_NumOperands = 2; m_ExtendedOpCodeCount = 0; m_Operands[0] = Operand0; m_Operands[1] = Operand1; } CInstruction(D3D10_SB_OPCODE_TYPE OpCode, COperandBase& Operand0, COperandBase& Operand1, COperandBase& Operand2) { Clear(); m_OpCode = OpCode; m_NumOperands = 3; m_ExtendedOpCodeCount = 0; m_Operands[0] = Operand0; m_Operands[1] = Operand1; m_Operands[2] = Operand2; } CInstruction(D3D10_SB_OPCODE_TYPE OpCode, COperandBase& Operand0, COperandBase& Operand1, COperandBase& Operand2, COperandBase& Operand3) { Clear(); m_OpCode = OpCode; m_NumOperands = 4; m_ExtendedOpCodeCount = 0; m_Operands[0] = Operand0; m_Operands[1] = Operand1; m_Operands[2] = Operand2; m_Operands[3] = Operand3; memset(m_TexelOffset, 0, sizeof(m_TexelOffset)); } void ClearAllocations() { if (m_OpCode == D3D10_SB_OPCODE_CUSTOMDATA) { free(m_CustomData.pData); if (m_CustomData.Type == D3D11_SB_CUSTOMDATA_SHADER_MESSAGE) { free(m_CustomData.ShaderMessage.pOperands); } } else if( m_OpCode == D3D11_SB_OPCODE_DCL_FUNCTION_TABLE ) { free(m_FunctionTableDecl.pFunctionIdentifiers); } else if( m_OpCode == D3D11_SB_OPCODE_DCL_INTERFACE ) { free(m_InterfaceDecl.pFunctionTableIdentifiers); } } void Clear(bool bIncludeCustomData = false) { if( bIncludeCustomData ) // don't need to do this on initial constructor, only if recycling the object. { ClearAllocations(); } memset (this, 0, sizeof(*this)); } ~CInstruction() { ClearAllocations(); } const COperandBase& Operand(UINT Index) const {return m_Operands[Index];} D3D10_SB_OPCODE_TYPE OpCode() const {return m_OpCode;} void SetNumOperands(UINT NumOperands) {m_NumOperands = NumOperands;} UINT NumOperands() const {return m_NumOperands;} void SetTest(D3D10_SB_INSTRUCTION_TEST_BOOLEAN Test) {m_Test = Test;} void SetPreciseMask(UINT PreciseMask) {m_PreciseMask = PreciseMask;} D3D10_SB_INSTRUCTION_TEST_BOOLEAN Test() const {return m_Test;} void SetTexelOffset( const INT8 texelOffset[3] ) { m_OpCodeEx[m_ExtendedOpCodeCount++] = D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS; memcpy(m_TexelOffset, texelOffset,sizeof(m_TexelOffset)); } void SetTexelOffset( INT8 x, INT8 y, INT8 z) { m_OpCodeEx[m_ExtendedOpCodeCount++] = D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS; m_TexelOffset[0] = x; m_TexelOffset[1] = y; m_TexelOffset[2] = z; } void SetResourceDim(D3D10_SB_RESOURCE_DIMENSION Dim, D3D10_SB_RESOURCE_RETURN_TYPE RetType[4], UINT StructureStride) { m_OpCodeEx[m_ExtendedOpCodeCount++] = D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM; m_OpCodeEx[m_ExtendedOpCodeCount++] = D3D11_SB_EXTENDED_OPCODE_RESOURCE_RETURN_TYPE; m_ResourceDimEx = Dim; m_ResourceDimStructureStrideEx = StructureStride; memcpy(m_ResourceReturnTypeEx, RetType,4*sizeof(D3D10_SB_RESOURCE_RETURN_TYPE)); } BOOL Disassemble(__out_ecount(StringSize) LPSTR pString, UINT StringSize); // Private data is used by D3D runtime void SetPrivateData(UINT Value, UINT index = 0) { if (index < MAX_PRIVATE_DATA_COUNT) { m_PrivateData[index] = Value; } } UINT PrivateData(UINT index = 0) const { if (index >= MAX_PRIVATE_DATA_COUNT) return 0xFFFFFFFF; return m_PrivateData[index]; } // Get the precise mask UINT GetPreciseMask() const {return m_PreciseMask;} D3D10_SB_OPCODE_TYPE m_OpCode; COperandBase m_Operands[D3D10_SB_MAX_INSTRUCTION_OPERANDS]; UINT m_NumOperands; UINT m_ExtendedOpCodeCount; UINT m_PreciseMask; D3D10_SB_EXTENDED_OPCODE_TYPE m_OpCodeEx[D3D11_SB_MAX_SIMULTANEOUS_EXTENDED_OPCODES]; INT8 m_TexelOffset[3]; // for extended opcode only D3D10_SB_RESOURCE_DIMENSION m_ResourceDimEx; // for extended opcode only UINT m_ResourceDimStructureStrideEx; // for extended opcode only D3D10_SB_RESOURCE_RETURN_TYPE m_ResourceReturnTypeEx[4]; // for extended opcode only BOOL m_bNonuniformResourceIndex; // for extended opcode only BOOL m_bNonuniformSamplerIndex; // for extended opcode only UINT m_PrivateData[MAX_PRIVATE_DATA_COUNT]; BOOL m_bSaturate; union // extra info needed by some instructions { CInputSystemInterpretedValueDecl m_InputDeclSIV; CInputSystemGeneratedValueDecl m_InputDeclSGV; CInputPSDecl m_InputPSDecl; CInputPSSystemInterpretedValueDecl m_InputPSDeclSIV; CInputPSSystemGeneratedValueDecl m_InputPSDeclSGV; COutputSystemInterpretedValueDecl m_OutputDeclSIV; COutputSystemGeneratedValueDecl m_OutputDeclSGV; CIndexRangeDecl m_IndexRangeDecl; CResourceDecl m_ResourceDecl; CConstantBufferDecl m_ConstantBufferDecl; CInputPrimitiveDecl m_InputPrimitiveDecl; COutputTopologyDecl m_OutputTopologyDecl; CGSMaxOutputVertexCountDecl m_GSMaxOutputVertexCountDecl; CGSInstanceCountDecl m_GSInstanceCountDecl; CSamplerDecl m_SamplerDecl; CStreamDecl m_StreamDecl; CTempsDecl m_TempsDecl; CIndexableTempDecl m_IndexableTempDecl; CGlobalFlagsDecl m_GlobalFlagsDecl; CCustomData m_CustomData; CInterfaceDecl m_InterfaceDecl; CFunctionTableDecl m_FunctionTableDecl; CFunctionBodyDecl m_FunctionBodyDecl; CInterfaceCall m_InterfaceCall; D3D10_SB_INSTRUCTION_TEST_BOOLEAN m_Test; D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE m_ResInfoReturnType; D3D10_SB_INSTRUCTION_RETURN_TYPE m_InstructionReturnType; CHSDSInputControlPointCountDecl m_InputControlPointCountDecl; CHSOutputControlPointCountDecl m_OutputControlPointCountDecl; CTessellatorDomainDecl m_TessellatorDomainDecl; CTessellatorPartitioningDecl m_TessellatorPartitioningDecl; CTessellatorOutputPrimitiveDecl m_TessellatorOutputPrimitiveDecl; CHSMaxTessFactorDecl m_HSMaxTessFactorDecl; CHSForkPhaseInstanceCountDecl m_HSForkPhaseInstanceCountDecl; CHSJoinPhaseInstanceCountDecl m_HSJoinPhaseInstanceCountDecl; CThreadGroupDeclaration m_ThreadGroupDecl; CTypedUAVDeclaration m_TypedUAVDecl; CStructuredUAVDeclaration m_StructuredUAVDecl; CRawUAVDeclaration m_RawUAVDecl; CStructuredTGSMDeclaration m_StructuredTGSMDecl; CRawSRVDeclaration m_RawSRVDecl; CStructuredSRVDeclaration m_StructuredSRVDecl; CRawTGSMDeclaration m_RawTGSMDecl; CSyncFlags m_SyncFlags; }; }; // **************************************************************************** // // class CShaderAsm // // The class is used to build a binary representation of a shader. // Usage scenario: // 1. Call Init with the initial internal buffer size in UINTs. The // internal buffer will grow if needed // 2. Call StartShader() // 3. Call Emit*() functions to assemble a shader // 4. Call EndShader() // 5. Call GetShader() to get the binary representation // // // **************************************************************************** class CShaderAsm { public: CShaderAsm(): m_dwFunc(NULL), m_Index(0), m_StartOpIndex(0), m_BufferSize(0) { Init(1024); }; ~CShaderAsm() { free(m_dwFunc); }; // Initializes the object with the initial buffer size in UINTs HRESULT Init(UINT BufferSize) { if( BufferSize >= UINT( -1 ) / sizeof( UINT ) ) { return E_OUTOFMEMORY; } m_dwFunc = (UINT*)malloc(BufferSize*sizeof(UINT)); if (m_dwFunc == NULL) { return E_OUTOFMEMORY; } m_BufferSize = BufferSize; Reset(); return S_OK; } UINT* GetShader() {return m_dwFunc;} UINT ShaderSizeInDWORDs() {return m_Index;} UINT ShaderSizeInBytes() {return ShaderSizeInDWORDs() * sizeof(*m_dwFunc);} UINT LastInstOffsetInDWORDs() {return m_StartOpIndex;} UINT LastInstOffsetInBytes() {return LastInstOffsetInDWORDs() * sizeof(*m_dwFunc);} // This function should be called to mark the start of a shader void StartShader(D3D10_SB_TOKENIZED_PROGRAM_TYPE ShaderType, UINT vermajor,UINT verminor) { Reset(); UINT Token = ENCODE_D3D10_SB_TOKENIZED_PROGRAM_VERSION_TOKEN(ShaderType, vermajor, verminor); OPCODE(Token); OPCODE(0); // Reserve space for length } // Should be called at the end of the shader void EndShader() { if (1 < m_BufferSize) m_dwFunc[1] = ENCODE_D3D10_SB_TOKENIZED_PROGRAM_LENGTH(m_Index); } // Emit a resource declaration void EmitResourceDecl(D3D10_SB_RESOURCE_DIMENSION Dimension, UINT TRegIndex, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_RESOURCE) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) ); EmitOperand(COperand(D3D10_SB_OPERAND_TYPE_RESOURCE, TRegIndex)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); ENDINSTRUCTION(); } // Emit D3D12 resource declaration void EmitIndexableResourceDecl(UINT uTable, UINT uTableLB, UINT uTableUB, D3D10_SB_RESOURCE_DIMENSION Dimension, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_RESOURCE) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) ); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_RESOURCE, uTable, uTableLB, uTableUB)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); FUNC(uSpace); ENDINSTRUCTION(); } // Emit a resource declaration (multisampled) void EmitResourceMSDecl(D3D10_SB_RESOURCE_DIMENSION Dimension, UINT TRegIndex, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW, UINT SampleCount) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_RESOURCE) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) | ENCODE_D3D10_SB_RESOURCE_SAMPLE_COUNT(SampleCount)); EmitOperand(COperand(D3D10_SB_OPERAND_TYPE_RESOURCE, TRegIndex)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); ENDINSTRUCTION(); } // Emit D3D12 resource declaration (multisampled) void EmitIndexableResourceMSDecl(UINT uTable, UINT uTableLB, UINT uTableUB, D3D10_SB_RESOURCE_DIMENSION Dimension, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW, UINT SampleCount, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_RESOURCE) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) | ENCODE_D3D10_SB_RESOURCE_SAMPLE_COUNT(SampleCount)); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_RESOURCE, uTable, uTableLB, uTableUB)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); FUNC(uSpace); ENDINSTRUCTION(); } // Emit a sampler declaration void EmitSamplerDecl(UINT SRegIndex, D3D10_SB_SAMPLER_MODE Mode) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_SAMPLER) | ENCODE_D3D10_SB_SAMPLER_MODE(Mode) ); EmitOperand(COperand(D3D10_SB_OPERAND_TYPE_SAMPLER, SRegIndex)); ENDINSTRUCTION(); } // Emit D3D12 sampler declaration void EmitIndexableSamplerDecl(UINT uTable, UINT uTableLB, UINT uTableUB, D3D10_SB_SAMPLER_MODE Mode, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_SAMPLER) | ENCODE_D3D10_SB_SAMPLER_MODE(Mode) ); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_SAMPLER, uTable, uTableLB, uTableUB)); FUNC(uSpace); ENDINSTRUCTION(); } // Emit a stream declaration void EmitStreamDecl(UINT SRegIndex) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_STREAM) ); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_STREAM, SRegIndex)); ENDINSTRUCTION(); } // Emit an input declaration void EmitInputDecl(D3D10_SB_OPERAND_TYPE RegType, UINT RegIndex, UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(RegType, RegIndex, WriteMask, MinPrecision)); ENDINSTRUCTION(); } void EmitInputDecl2D(D3D10_SB_OPERAND_TYPE RegType, UINT RegIndex, UINT RegIndex2, UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(RegType, RegIndex, RegIndex2, WriteMask, MinPrecision)); ENDINSTRUCTION(); } // Emit an input declaration for a system interpreted value void EmitInputSystemInterpretedValueDecl(D3D10_SB_OPERAND_TYPE RegType, UINT RegIndex, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_SIV)); EmitOperand(COperandDst(RegType, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } void EmitInputSystemInterpretedValueDecl2D(UINT RegIndex, UINT RegIndex2, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_SIV)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, RegIndex2, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit an input declaration for a system generated value void EmitInputSystemGeneratedValueDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_SGV)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } void EmitInputSystemGeneratedValueDecl2D(UINT RegIndex, UINT RegIndex2, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_SGV)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, RegIndex2, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit a PS input declaration void EmitPSInputDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_INTERPOLATION_MODE Mode, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_PS) | ENCODE_D3D10_SB_INPUT_INTERPOLATION_MODE(Mode)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, WriteMask, MinPrecision)); ENDINSTRUCTION(); } // Emit a PS input declaration for a system interpreted value void EmitPSInputSystemInterpretedValueDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_INTERPOLATION_MODE Mode, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_PS_SIV) | ENCODE_D3D10_SB_INPUT_INTERPOLATION_MODE(Mode)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit a PS input declaration for a system generated value void EmitPSInputSystemGeneratedValueDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_INTERPOLATION_MODE Mode, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT_PS_SGV) | ENCODE_D3D10_SB_INPUT_INTERPOLATION_MODE(Mode)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit input coverage mask declaration void EmitInputCoverageMaskDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_INPUT_COVERAGE_MASK, MinPrecision)); ENDINSTRUCTION(); } // Emit inner coverage declaration void EmitInnerCoverageDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_INNER_COVERAGE, MinPrecision)); ENDINSTRUCTION(); } // Emit cycle counter decl void EmitCycleCounterDecl(UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(WriteMask,D3D11_SB_OPERAND_TYPE_CYCLE_COUNTER)); ENDINSTRUCTION(); } // Emit input primitive id declaration void EmitInputPrimIdDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT_PRIMITIVEID, MinPrecision)); ENDINSTRUCTION(); } // Emit input domain point declaration void EmitInputDomainPointDecl(UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(WriteMask,D3D11_SB_OPERAND_TYPE_INPUT_DOMAIN_POINT, MinPrecision)); ENDINSTRUCTION(); } // Emit and oDepth declaration void EmitODepthDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT_DEPTH, MinPrecision)); ENDINSTRUCTION(); } // Emit and oDepthGE declaration void EmitODepthDeclGE(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL, MinPrecision)); ENDINSTRUCTION(); } // Emit and oDepthLE declaration void EmitODepthDeclLE(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL, MinPrecision)); ENDINSTRUCTION(); } // Emit an oMask declaration void EmitOMaskDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT_COVERAGE_MASK, MinPrecision)); ENDINSTRUCTION(); } // Emit an oStencilRef declaration void EmitOStencilRefDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_OUTPUT_STENCIL_REF, MinPrecision)); ENDINSTRUCTION(); } // Emit an output declaration void EmitOutputDecl(UINT RegIndex, UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT, RegIndex, WriteMask, MinPrecision)); ENDINSTRUCTION(); } // Emit an output declaration for a system interpreted value void EmitOutputSystemInterpretedValueDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT_SIV)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit an output declaration for a system generated value void EmitOutputSystemGeneratedValueDecl(UINT RegIndex, UINT WriteMask, D3D10_SB_NAME Name, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_OUTPUT_SGV)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT, RegIndex, WriteMask, MinPrecision)); FUNC(ENCODE_D3D10_SB_NAME(Name)); ENDINSTRUCTION(); } // Emit an input register indexing range declaration void EmitInputIndexingRangeDecl(UINT RegIndex, UINT Count, UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEX_RANGE)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, WriteMask)); FUNC((UINT)Count); ENDINSTRUCTION(); } // 2D indexing range decl (indexing is for second dimension) void EmitInputIndexingRangeDecl2D(UINT RegIndex, UINT RegIndex2Min, UINT Reg2Count, UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEX_RANGE)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_INPUT, RegIndex, RegIndex2Min, WriteMask)); FUNC((UINT)Reg2Count); ENDINSTRUCTION(); } // Emit an output register indexing range declaration void EmitOutputIndexingRangeDecl(UINT RegIndex, UINT Count, UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEX_RANGE)); EmitOperand(COperandDst(D3D10_SB_OPERAND_TYPE_OUTPUT, RegIndex, WriteMask)); FUNC((UINT)Count); ENDINSTRUCTION(); } // Emit indexing range decl taking reg type as parameter // (for things other than plain input or output regs) void EmitIndexingRangeDecl(D3D10_SB_OPERAND_TYPE RegType, UINT RegIndex, UINT Count, UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEX_RANGE)); EmitOperand(COperandDst(RegType, RegIndex, WriteMask)); FUNC((UINT)Count); ENDINSTRUCTION(); } // 2D indexing range decl (indexing is for second dimension) // Emit indexing range decl taking reg type as parameter // (for things other than plain input or output regs) void EmitIndexingRangeDecl2D(D3D10_SB_OPERAND_TYPE RegType, UINT RegIndex, UINT RegIndex2Min, UINT Reg2Count, UINT WriteMask) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEX_RANGE)); EmitOperand(COperandDst(RegType, RegIndex, RegIndex2Min, WriteMask)); FUNC((UINT)Reg2Count); ENDINSTRUCTION(); } // Emit a temp registers ( r0...r(n-1) ) declaration void EmitTempsDecl(UINT NumTemps) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_TEMPS)); FUNC((UINT)NumTemps); ENDINSTRUCTION(); } // Emit an indexable temp register (x#) declaration void EmitIndexableTempDecl(UINT TempNumber, UINT RegCount, UINT ComponentCount ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INDEXABLE_TEMP)); FUNC((UINT)TempNumber); FUNC((UINT)RegCount); FUNC((UINT)ComponentCount); ENDINSTRUCTION(); } // Emit a constant buffer (cb#) declaration void EmitConstantBufferDecl(UINT RegIndex, UINT Size, // size 0 means unknown/any size D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN AccessPattern) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_CONSTANT_BUFFER) | ENCODE_D3D10_SB_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN(AccessPattern)); EmitOperand(COperand2D(D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER, RegIndex, Size)); ENDINSTRUCTION(); } // Emit D3D12 constant buffer (cb#) declaration. void EmitIndexableConstantBufferDecl(UINT uCBufferVarIndex, UINT uLB, UINT uUB, UINT Size, // size 0 means unknown/any size D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN AccessPattern, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE( ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_CONSTANT_BUFFER) | ENCODE_D3D10_SB_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN(AccessPattern) ); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER, uCBufferVarIndex, uLB, uUB)); FUNC(Size); FUNC(uSpace); ENDINSTRUCTION(); } // Emit Immediate Constant Buffer (icb) declaration void EmitImmediateConstantBufferDecl(UINT Num4Tuples, const UINT* pImmediateConstantBufferData) { m_bExecutableInstruction = FALSE; EmitCustomData( D3D10_SB_CUSTOMDATA_DCL_IMMEDIATE_CONSTANT_BUFFER, 4*Num4Tuples /*2 UINTS will be added during encoding */, pImmediateConstantBufferData); } // Emit a GS input primitive declaration void EmitGSInputPrimitiveDecl(D3D10_SB_PRIMITIVE Primitive) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_GS_INPUT_PRIMITIVE) | ENCODE_D3D10_SB_GS_INPUT_PRIMITIVE(Primitive)); ENDINSTRUCTION(); } // Emit a GS output topology declaration void EmitGSOutputTopologyDecl(D3D10_SB_PRIMITIVE_TOPOLOGY Topology) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY) | ENCODE_D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY(Topology)); ENDINSTRUCTION(); } // Emit GS Maximum Output Vertex Count declaration void EmitGSMaxOutputVertexCountDecl(UINT Count) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT)); FUNC((UINT)Count); ENDINSTRUCTION(); } // Emit input GS instance count declaration void EmitInputGSInstanceCountDecl( UINT Instances ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_GS_INSTANCE_COUNT)); FUNC(Instances); ENDINSTRUCTION(); } // Emit input GS instance ID declaration void EmitInputGSInstanceIDDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_INPUT_GS_INSTANCE_ID, MinPrecision)); ENDINSTRUCTION(); } // Emit global flags declaration void EmitGlobalFlagsDecl(UINT Flags) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_GLOBAL_FLAGS) | ENCODE_D3D10_SB_GLOBAL_FLAGS(Flags)); ENDINSTRUCTION(); } // Emit interface function body declaration void EmitFunctionBodyDecl(UINT uFunctionID) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_FUNCTION_BODY)); FUNC(uFunctionID); ENDINSTRUCTION(); } void EmitFunctionTableDecl(UINT uFunctionTableID, UINT uTableSize, UINT *pTableEntries) { m_bExecutableInstruction = FALSE; bool bExtended = (3 + uTableSize) > MAX_INSTRUCTION_LENGTH; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_FUNCTION_TABLE) | ENCODE_D3D10_SB_OPCODE_EXTENDED(bExtended)); if( bExtended ) FUNC(0); FUNC(uFunctionTableID); FUNC(uTableSize); if( m_Index + uTableSize >= m_BufferSize ) { Reserve(uTableSize); } memcpy(&m_dwFunc[m_Index],pTableEntries,sizeof(UINT)*uTableSize); m_Index += uTableSize; ENDLONGINSTRUCTION(bExtended); } void EmitInterfaceDecl(UINT uInterfaceID, bool bDynamicIndexed, UINT uArrayLength, UINT uExpectedTableSize, __in_range(0, D3D11_SB_MAX_NUM_TYPES) UINT uNumTypes, __in_ecount(uNumTypes) UINT *pTableEntries) { m_bExecutableInstruction = FALSE; bool bExtended = (4 + uNumTypes) > MAX_INSTRUCTION_LENGTH; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_INTERFACE) | ENCODE_D3D11_SB_INTERFACE_INDEXED_BIT(bDynamicIndexed) | ENCODE_D3D10_SB_OPCODE_EXTENDED(bExtended)); if( bExtended ) FUNC(0); FUNC(uInterfaceID); FUNC(uExpectedTableSize); FUNC(ENCODE_D3D11_SB_INTERFACE_TABLE_LENGTH(uNumTypes) | ENCODE_D3D11_SB_INTERFACE_ARRAY_LENGTH(uArrayLength)); if( m_Index + uNumTypes >= m_BufferSize ) { Reserve(uNumTypes); } memcpy(&m_dwFunc[m_Index],pTableEntries,sizeof(UINT)*uNumTypes); m_Index += uNumTypes; ENDLONGINSTRUCTION(bExtended); } void EmitInterfaceCall(COperandBase &InterfaceOperand, UINT uFunctionIndex) { m_bExecutableInstruction = TRUE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_INTERFACE_CALL)); FUNC(uFunctionIndex); EmitOperand(InterfaceOperand); ENDINSTRUCTION(); } void EmitInputControlPointCountDecl(UINT Count) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT) | ENCODE_D3D11_SB_INPUT_CONTROL_POINT_COUNT(Count)); ENDINSTRUCTION(); } void EmitOutputControlPointCountDecl(UINT Count) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT) | ENCODE_D3D11_SB_OUTPUT_CONTROL_POINT_COUNT(Count)); ENDINSTRUCTION(); } void EmitTessellatorDomainDecl(D3D11_SB_TESSELLATOR_DOMAIN Domain) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_TESS_DOMAIN) | ENCODE_D3D11_SB_TESS_DOMAIN(Domain)); ENDINSTRUCTION(); } void EmitTessellatorPartitioningDecl(D3D11_SB_TESSELLATOR_PARTITIONING Partitioning) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_TESS_PARTITIONING) | ENCODE_D3D11_SB_TESS_PARTITIONING(Partitioning)); ENDINSTRUCTION(); } void EmitTessellatorOutputPrimitiveDecl(D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE OutputPrimitive) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE) | ENCODE_D3D11_SB_TESS_OUTPUT_PRIMITIVE(OutputPrimitive)); ENDINSTRUCTION(); } void EmitHSMaxTessFactorDecl(float MaxTessFactor) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_HS_MAX_TESSFACTOR)); UINT uTemp = *(UINT*)&MaxTessFactor; FUNC(uTemp); ENDINSTRUCTION(); } void EmitHSForkPhaseInstanceCountDecl(UINT InstanceCount) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT)); FUNC(InstanceCount); ENDINSTRUCTION(); } void EmitHSJoinPhaseInstanceCountDecl(UINT InstanceCount) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT)); FUNC(InstanceCount); ENDINSTRUCTION(); } void EmitHSBeginPhase(D3D10_SB_OPCODE_TYPE Phase) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(Phase)); ENDINSTRUCTION(); } void EmitInputOutputControlPointIDDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_OUTPUT_CONTROL_POINT_ID, MinPrecision)); ENDINSTRUCTION(); } void EmitInputForkInstanceIDDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_INPUT_FORK_INSTANCE_ID, MinPrecision)); ENDINSTRUCTION(); } void EmitInputJoinInstanceIDDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_INPUT_JOIN_INSTANCE_ID, MinPrecision)); ENDINSTRUCTION(); } void EmitThreadGroupDecl(UINT x, UINT y, UINT z) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_THREAD_GROUP)); FUNC(x); FUNC(y); FUNC(z); ENDINSTRUCTION(); } void EmitInputThreadIDDecl(UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(WriteMask, D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID, MinPrecision)); ENDINSTRUCTION(); } void EmitInputThreadGroupIDDecl(UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(WriteMask, D3D11_SB_OPERAND_TYPE_INPUT_THREAD_GROUP_ID, MinPrecision)); ENDINSTRUCTION(); } void EmitInputThreadIDInGroupDecl(UINT WriteMask, D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(WriteMask, D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP, MinPrecision)); ENDINSTRUCTION(); } void EmitInputThreadIDInGroupFlattenedDecl(D3D11_SB_OPERAND_MIN_PRECISION MinPrecision = D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_DCL_INPUT)); EmitOperand(COperandDst(D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED, MinPrecision)); ENDINSTRUCTION(); } void EmitTypedUnorderedAccessViewDecl(D3D10_SB_RESOURCE_DIMENSION Dimension, UINT URegIndex, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW, UINT Flags) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) | ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, URegIndex)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); ENDINSTRUCTION(); } // Emit D3D12 UAV declaration. void EmitIndexableTypedUnorderedAccessViewDecl(UINT uTable, UINT uTableLB, UINT uTableUB, D3D10_SB_RESOURCE_DIMENSION Dimension, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForX, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForY, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForZ, D3D10_SB_RESOURCE_RETURN_TYPE ReturnTypeForW, UINT Flags, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED) | ENCODE_D3D10_SB_RESOURCE_DIMENSION(Dimension) | ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand3D(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, uTable, uTableLB, uTableUB)); FUNC(ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForX, 0) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForY, 1) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForZ, 2) | ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnTypeForW, 3)); FUNC(uSpace); ENDINSTRUCTION(); } void EmitRawUnorderedAccessViewDecl(UINT URegIndex, UINT Flags) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW) | ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, URegIndex)); ENDINSTRUCTION(); } // Emit D3D12 raw UAV declaration. void EmitIndexableRawUnorderedAccessViewDecl(UINT uTable, UINT uTableLB, UINT uTableUB, UINT Flags, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW) | ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand3D(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, uTable, uTableLB, uTableUB)); FUNC(uSpace); ENDINSTRUCTION(); } void EmitStructuredUnorderedAccessViewDecl(UINT URegIndex, UINT ByteStride, UINT Flags ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED)| ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, URegIndex)); FUNC(ByteStride); ENDINSTRUCTION(); } // Emit D3D12 structured UAV declaration. void EmitIndexableStructuredUnorderedAccessViewDecl(UINT uTable, UINT uTableLB, UINT uTableUB, UINT ByteStride, UINT Flags, UINT uSpace ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED)| ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags)); EmitOperand(COperand3D(D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW, uTable, uTableLB, uTableUB)); FUNC(ByteStride); FUNC(uSpace); ENDINSTRUCTION(); } void EmitRawThreadGroupSharedMemoryDecl(UINT GRegIndex, UINT ByteCount ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY, GRegIndex)); FUNC(ByteCount); ENDINSTRUCTION(); } void EmitStructuredThreadGroupSharedMemoryDecl(UINT GRegIndex, UINT ByteStride, UINT StructCount ) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED)); EmitOperand(COperand(D3D11_SB_OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY, GRegIndex)); FUNC(ByteStride); FUNC(StructCount); ENDINSTRUCTION(); } void EmitRawShaderResourceViewDecl(UINT TRegIndex) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_RESOURCE_RAW)); EmitOperand(COperand(D3D10_SB_OPERAND_TYPE_RESOURCE, TRegIndex)); ENDINSTRUCTION(); } // Emit D3D12 byte address buffer declaration void EmitIndexableRawShaderResourceViewDecl(UINT uTable, UINT uTableLB, UINT uTableUB, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_RESOURCE_RAW)); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_RESOURCE, uTable, uTableLB, uTableUB)); FUNC(uSpace); ENDINSTRUCTION(); } void EmitStructuredShaderResourceViewDecl(UINT TRegIndex, UINT ByteStride) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_RESOURCE_STRUCTURED)); EmitOperand(COperand(D3D10_SB_OPERAND_TYPE_RESOURCE, TRegIndex)); FUNC(ByteStride); ENDINSTRUCTION(); } // Emit D3D12 structured buffer declaration void EmitIndexableStructuredShaderResourceViewDecl(UINT uTable, UINT uTableLB, UINT uTableUB, UINT ByteStride, UINT uSpace) { m_bExecutableInstruction = FALSE; OPCODE(ENCODE_D3D10_SB_OPCODE_TYPE(D3D11_SB_OPCODE_DCL_RESOURCE_STRUCTURED)); EmitOperand(COperand3D(D3D10_SB_OPERAND_TYPE_RESOURCE, uTable, uTableLB, uTableUB)); FUNC(ByteStride); FUNC(uSpace); ENDINSTRUCTION(); } // Emit an instruction. Custom-data is not handled by this function. void EmitInstruction(const CInstruction& instruction); // Emit an operand void EmitOperand(const COperandBase& operand); // Emit an instruction without operands void Emit(UINT OpCode) { OPCODE(OpCode); ENDINSTRUCTION(); } void StartComplexEmit(UINT OpCode, UINT ReserveCount = MAX_INSTRUCTION_LENGTH) { OPCODE(OpCode); Reserve(ReserveCount); } void AddComplexEmit(UINT Data) { FUNC(Data); } void EndComplexEmit(bool bPatchLength = false) { ENDLONGINSTRUCTION(bPatchLength, !bPatchLength); } UINT GetComplexEmitPosition() { return m_Index; } void UpdateComplexEmitPosition(UINT Pos, UINT Data) { if (Pos < m_BufferSize) { m_dwFunc[Pos] = Data; } } void EmitCustomData( D3D10_SB_CUSTOMDATA_CLASS CustomDataClass, UINT SizeInUINTs /*2 UINTS will be added during encoding */, const UINT* pCustomData) { UINT FullSizeInUINTs = SizeInUINTs + 2; // include opcode and size if( FullSizeInUINTs < SizeInUINTs || FullSizeInUINTs + m_Index < FullSizeInUINTs ) // check for overflow { throw E_FAIL; } if( m_Index + FullSizeInUINTs >= m_BufferSize ) // If custom data is going to overflow the buffer, reserve more memory { Reserve(FullSizeInUINTs); } __analysis_assume(m_Index + FullSizeInUINTs < m_BufferSize); // Otherwise there's a bug in Reserve() m_dwFunc[m_Index++] = ENCODE_D3D10_SB_CUSTOMDATA_CLASS(CustomDataClass); m_dwFunc[m_Index++] = FullSizeInUINTs; memcpy(&m_dwFunc[m_Index],pCustomData,sizeof(UINT)*SizeInUINTs); m_Index += SizeInUINTs; if (m_Index >= m_BufferSize) // If custom data is exactly fully filled the buffer, reserve more memory { Reserve(1024); } } // Returns number of executable instructions in the current shader UINT GetNumExecutableInstructions() {return m_NumExecutableInstructions;} protected: void OPCODE(UINT x) { if (m_Index < m_BufferSize) { m_dwFunc[m_Index] = x; m_StartOpIndex = m_Index++; } if (m_Index >= m_BufferSize) Reserve(1024); } // Should be called after end of each instruction void ENDINSTRUCTION() { if (m_StartOpIndex < m_Index) { m_dwFunc[m_StartOpIndex] |= ENCODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH(m_Index - m_StartOpIndex); Reserve(MAX_INSTRUCTION_LENGTH); m_StatementIndex++; if (m_bExecutableInstruction) m_NumExecutableInstructions++; m_bExecutableInstruction = true; } } void ENDLONGINSTRUCTION(bool bExtendedLength, bool bBaseLength = true) { if (m_StartOpIndex < m_Index) { if (bBaseLength) { m_dwFunc[m_StartOpIndex] |= ENCODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH(m_Index - m_StartOpIndex); } if( bExtendedLength ) { __analysis_assume(m_StartOpIndex + 1 < m_Index); m_dwFunc[m_StartOpIndex + 1] = m_Index - m_StartOpIndex; } Reserve(MAX_INSTRUCTION_LENGTH); m_StatementIndex++; if (m_bExecutableInstruction) m_NumExecutableInstructions++; m_bExecutableInstruction = true; } } void FUNC(UINT x) { if (m_Index < m_BufferSize) m_dwFunc[m_Index++] = x; if (m_Index >= m_BufferSize) Reserve(1024); } // Prepare assembler for a new shader void Reset() { m_Index = 0; m_StartOpIndex = 0; m_StatementIndex = 1; m_NumExecutableInstructions = 0; m_bExecutableInstruction = TRUE; } // Reserve SizeInUINTs UINTs in the m_dwFunc array void Reserve(UINT SizeInUINTs) { // The following overflow check may be sligltly over-cautious when (m_Index + SizeInUINTs < m_BufferSize), // but this only matters when m_BufferSize cannot be grown one more step without overflowing. UINT NewSize = m_BufferSize + SizeInUINTs + 1024; if( m_Index > m_BufferSize || // invalid state (m_BufferSize + SizeInUINTs) < m_BufferSize || // overflow with adding SizeInUINTs NewSize < (m_BufferSize + SizeInUINTs) ) // overflow with adding 1024 { throw E_FAIL; } if (m_BufferSize < (m_Index + SizeInUINTs)) { UINT* pNewBuffer = (UINT*)malloc(NewSize*sizeof(UINT)); if (pNewBuffer == NULL) { throw E_OUTOFMEMORY; } memcpy(pNewBuffer, m_dwFunc, sizeof(UINT)*m_Index); free(m_dwFunc); m_dwFunc = pNewBuffer; m_BufferSize = NewSize; } } // Buffer where the binary representation is built __field_ecount_part(m_BufferSize, m_Index) UINT* m_dwFunc; // Index where to place the next token in the m_dwFunc array UINT m_Index; // Index of the start of the current instruction in the m_dwFunc array UINT m_StartOpIndex; // Current buffer size in UINTs UINT m_BufferSize; // Current statement index of the current vertex shader UINT m_StatementIndex; // Number of executable instructions in the shader UINT m_NumExecutableInstructions; // "true" when the current instruction is executable bool m_bExecutableInstruction; }; //***************************************************************************** // // CShaderCodeParser // //***************************************************************************** class CShaderCodeParser { public: CShaderCodeParser(): m_pCurrentToken(NULL), m_pShaderCode(NULL), m_pShaderEndToken(NULL) { InitInstructionInfo(); } CShaderCodeParser(CONST CShaderToken* pBuffer): m_pCurrentToken(NULL), m_pShaderCode(NULL), m_pShaderEndToken(NULL) { InitInstructionInfo(); SetShader(pBuffer); } ~CShaderCodeParser() {} void SetShader(CONST CShaderToken* pBuffer); void ParseInstruction(CInstruction* pInstruction); void ParseIndex(COperandIndex* pOperandIndex, D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType); void ParseOperand(COperandBase* pOperand); BOOL EndOfShader() {return m_pCurrentToken >= m_pShaderEndToken;} D3D10_SB_TOKENIZED_PROGRAM_TYPE ShaderType(); UINT ShaderMinorVersion(); UINT ShaderMajorVersion(); UINT ShaderLengthInTokens(); UINT CurrentTokenOffset(); UINT CurrentTokenOffsetInBytes() { return CurrentTokenOffset() * sizeof(CShaderToken); } void SetCurrentTokenOffset(UINT Offset); CONST CShaderToken* ParseOperandAt(COperandBase* pOperand, CONST CShaderToken* pBuffer, CONST CShaderToken* pBufferEnd) { CShaderToken* pCurTok = m_pCurrentToken; CShaderToken* pEndTok = m_pShaderEndToken; CShaderToken* pRet; m_pCurrentToken = (CShaderToken*)pBuffer; m_pShaderEndToken = (CShaderToken*)pBufferEnd; ParseOperand(pOperand); pRet = m_pCurrentToken; m_pCurrentToken = pCurTok; m_pShaderEndToken = pEndTok; return pRet; } protected: CShaderToken* m_pCurrentToken; CShaderToken* m_pShaderCode; // Points to the last token of the current shader CShaderToken* m_pShaderEndToken; }; }; // name space D3D10ShaderBinary