ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xenia-canary/third_party/dxbc/d3d12TokenizedProgramFormat...

2613 lines
126 KiB
C++
Raw Permalink Blame History

#pragma once
// Xenia: removed winapifamily.h dependency.
// ----------------------------------------------------------------------------
//
// D3D11 Tokenized Program Format
//
// Copyright (c) Microsoft Corporation.
//
// ----------------------------------------------------------------------------
//
// High Level Goals
//
// - Serve as the runtime/DDI representation for all D3D11 tokenized code,
// for all classes of programs, including pixel program, vertex program,
// geometry program, etc.
//
// - Any information that HLSL needs to give to drivers is encoded in
// this token format in some form.
//
// - Enable common tools and source code for managing all tokenizable
// program formats.
//
// - Support extensible token definitions, allowing full customizations for
// specific program classes, while maintaining general conventions for all
// program models.
//
// - Binary backwards compatible with D3D10. Any token name that was originally
// defined with "D3D10" in it is unchanged; D3D11 only adds new tokens.
//
// ----------------------------------------------------------------------------
//
// Low Level Feature Summary
//
// - DWORD based tokens always, for simplicity
// - Opcode token is generally a single DWORD, though there is a bit indicating
// if extended information (extra DWORD(s)) are present
// - Operand tokens are a completely self contained, extensible format,
// with scalar and 4-vector data types as first class citizens, but
// allowance for extension to n-component vectors.
// - Initial operand token identifies register type, register file
// structure/dimensionality and mode of indexing for each dimension,
// and choice of component selection mechanism (i.e. mask vs. swizzle etc).
// - Optional additional extended operand tokens can defined things like
// modifiers (which are not needed by default).
// - Operand's immediate index value(s), if needed, appear as subsequent DWORD
// values, and if relative addressing is specified, an additional completely
// self contained operand definition appears nested in the token sequence.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Version Token (VerTok)
//
// [07:00] minor version number (0-255)
// [15:08] major version number (0-255)
// [31:16] D3D10_SB_TOKENIZED_PROGRAM_TYPE
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_TOKENIZED_PROGRAM_TYPE
{
D3D10_SB_PIXEL_SHADER = 0,
D3D10_SB_VERTEX_SHADER = 1,
D3D10_SB_GEOMETRY_SHADER = 2,
// D3D11 Shaders
D3D11_SB_HULL_SHADER = 3,
D3D11_SB_DOMAIN_SHADER = 4,
D3D11_SB_COMPUTE_SHADER = 5,
D3D11_SB_RESERVED0 = 0xFFF0
} D3D10_SB_TOKENIZED_PROGRAM_TYPE;
#define D3D10_SB_TOKENIZED_PROGRAM_TYPE_MASK 0xffff0000
#define D3D10_SB_TOKENIZED_PROGRAM_TYPE_SHIFT 16
// DECODER MACRO: Retrieve program type from version token
#define DECODE_D3D10_SB_TOKENIZED_PROGRAM_TYPE(VerTok) ((D3D10_SB_TOKENIZED_PROGRAM_TYPE)(((VerTok)&D3D10_SB_TOKENIZED_PROGRAM_TYPE_MASK)>>D3D10_SB_TOKENIZED_PROGRAM_TYPE_SHIFT))
#define D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_MASK 0x000000f0
#define D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_SHIFT 4
#define D3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSION_MASK 0x0000000f
// DECODER MACRO: Retrieve major version # from version token
#define DECODE_D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION(VerTok) (((VerTok)&D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_MASK)>>D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_SHIFT)
// DECODER MACRO: Retrieve minor version # from version token
#define DECODE_D3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSION(VerTok) ((VerTok)&D3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSION_MASK)
// ENCODER MACRO: Create complete VerTok
#define ENCODE_D3D10_SB_TOKENIZED_PROGRAM_VERSION_TOKEN(ProgType,MajorVer,MinorVer) ((((ProgType)<<D3D10_SB_TOKENIZED_PROGRAM_TYPE_SHIFT)&D3D10_SB_TOKENIZED_PROGRAM_TYPE_MASK)|\
((((MajorVer)<<D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_SHIFT)&D3D10_SB_TOKENIZED_PROGRAM_MAJOR_VERSION_MASK))|\
((MinorVer)&D3D10_SB_TOKENIZED_PROGRAM_MINOR_VERSION_MASK))
// ----------------------------------------------------------------------------
// Length Token (LenTok)
//
// Always follows VerTok
//
// [31:00] Unsigned integer count of number of
// DWORDs in program code, including version
// and length tokens. So the minimum value
// is 0x00000002 (if an empty program is ever
// valid).
//
// ----------------------------------------------------------------------------
// DECODER MACRO: Retrieve program length
#define DECODE_D3D10_SB_TOKENIZED_PROGRAM_LENGTH(LenTok) (LenTok)
// ENCODER MACRO: Create complete LenTok
#define ENCODE_D3D10_SB_TOKENIZED_PROGRAM_LENGTH(Length) (Length)
#define MAX_D3D10_SB_TOKENIZED_PROGRAM_LENGTH (0xffffffff)
// ----------------------------------------------------------------------------
// Opcode Format (OpcodeToken0)
//
// [10:00] D3D10_SB_OPCODE_TYPE
// if( [10:00] == D3D10_SB_OPCODE_CUSTOMDATA )
// {
// Token starts a custom-data block. See "Custom-Data Block Format".
// }
// else // standard opcode token
// {
// [23:11] Opcode-Specific Controls
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended opcode token.
// }
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_OPCODE_TYPE {
D3D10_SB_OPCODE_ADD ,
D3D10_SB_OPCODE_AND ,
D3D10_SB_OPCODE_BREAK ,
D3D10_SB_OPCODE_BREAKC ,
D3D10_SB_OPCODE_CALL ,
D3D10_SB_OPCODE_CALLC ,
D3D10_SB_OPCODE_CASE ,
D3D10_SB_OPCODE_CONTINUE ,
D3D10_SB_OPCODE_CONTINUEC ,
D3D10_SB_OPCODE_CUT ,
D3D10_SB_OPCODE_DEFAULT ,
D3D10_SB_OPCODE_DERIV_RTX ,
D3D10_SB_OPCODE_DERIV_RTY ,
D3D10_SB_OPCODE_DISCARD ,
D3D10_SB_OPCODE_DIV ,
D3D10_SB_OPCODE_DP2 ,
D3D10_SB_OPCODE_DP3 ,
D3D10_SB_OPCODE_DP4 ,
D3D10_SB_OPCODE_ELSE ,
D3D10_SB_OPCODE_EMIT ,
D3D10_SB_OPCODE_EMITTHENCUT ,
D3D10_SB_OPCODE_ENDIF ,
D3D10_SB_OPCODE_ENDLOOP ,
D3D10_SB_OPCODE_ENDSWITCH ,
D3D10_SB_OPCODE_EQ ,
D3D10_SB_OPCODE_EXP ,
D3D10_SB_OPCODE_FRC ,
D3D10_SB_OPCODE_FTOI ,
D3D10_SB_OPCODE_FTOU ,
D3D10_SB_OPCODE_GE ,
D3D10_SB_OPCODE_IADD ,
D3D10_SB_OPCODE_IF ,
D3D10_SB_OPCODE_IEQ ,
D3D10_SB_OPCODE_IGE ,
D3D10_SB_OPCODE_ILT ,
D3D10_SB_OPCODE_IMAD ,
D3D10_SB_OPCODE_IMAX ,
D3D10_SB_OPCODE_IMIN ,
D3D10_SB_OPCODE_IMUL ,
D3D10_SB_OPCODE_INE ,
D3D10_SB_OPCODE_INEG ,
D3D10_SB_OPCODE_ISHL ,
D3D10_SB_OPCODE_ISHR ,
D3D10_SB_OPCODE_ITOF ,
D3D10_SB_OPCODE_LABEL ,
D3D10_SB_OPCODE_LD ,
D3D10_SB_OPCODE_LD_MS ,
D3D10_SB_OPCODE_LOG ,
D3D10_SB_OPCODE_LOOP ,
D3D10_SB_OPCODE_LT ,
D3D10_SB_OPCODE_MAD ,
D3D10_SB_OPCODE_MIN ,
D3D10_SB_OPCODE_MAX ,
D3D10_SB_OPCODE_CUSTOMDATA ,
D3D10_SB_OPCODE_MOV ,
D3D10_SB_OPCODE_MOVC ,
D3D10_SB_OPCODE_MUL ,
D3D10_SB_OPCODE_NE ,
D3D10_SB_OPCODE_NOP ,
D3D10_SB_OPCODE_NOT ,
D3D10_SB_OPCODE_OR ,
D3D10_SB_OPCODE_RESINFO ,
D3D10_SB_OPCODE_RET ,
D3D10_SB_OPCODE_RETC ,
D3D10_SB_OPCODE_ROUND_NE ,
D3D10_SB_OPCODE_ROUND_NI ,
D3D10_SB_OPCODE_ROUND_PI ,
D3D10_SB_OPCODE_ROUND_Z ,
D3D10_SB_OPCODE_RSQ ,
D3D10_SB_OPCODE_SAMPLE ,
D3D10_SB_OPCODE_SAMPLE_C ,
D3D10_SB_OPCODE_SAMPLE_C_LZ ,
D3D10_SB_OPCODE_SAMPLE_L ,
D3D10_SB_OPCODE_SAMPLE_D ,
D3D10_SB_OPCODE_SAMPLE_B ,
D3D10_SB_OPCODE_SQRT ,
D3D10_SB_OPCODE_SWITCH ,
D3D10_SB_OPCODE_SINCOS ,
D3D10_SB_OPCODE_UDIV ,
D3D10_SB_OPCODE_ULT ,
D3D10_SB_OPCODE_UGE ,
D3D10_SB_OPCODE_UMUL ,
D3D10_SB_OPCODE_UMAD ,
D3D10_SB_OPCODE_UMAX ,
D3D10_SB_OPCODE_UMIN ,
D3D10_SB_OPCODE_USHR ,
D3D10_SB_OPCODE_UTOF ,
D3D10_SB_OPCODE_XOR ,
D3D10_SB_OPCODE_DCL_RESOURCE , // DCL* opcodes have
D3D10_SB_OPCODE_DCL_CONSTANT_BUFFER , // custom operand formats.
D3D10_SB_OPCODE_DCL_SAMPLER ,
D3D10_SB_OPCODE_DCL_INDEX_RANGE ,
D3D10_SB_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY ,
D3D10_SB_OPCODE_DCL_GS_INPUT_PRIMITIVE ,
D3D10_SB_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT ,
D3D10_SB_OPCODE_DCL_INPUT ,
D3D10_SB_OPCODE_DCL_INPUT_SGV ,
D3D10_SB_OPCODE_DCL_INPUT_SIV ,
D3D10_SB_OPCODE_DCL_INPUT_PS ,
D3D10_SB_OPCODE_DCL_INPUT_PS_SGV ,
D3D10_SB_OPCODE_DCL_INPUT_PS_SIV ,
D3D10_SB_OPCODE_DCL_OUTPUT ,
D3D10_SB_OPCODE_DCL_OUTPUT_SGV ,
D3D10_SB_OPCODE_DCL_OUTPUT_SIV ,
D3D10_SB_OPCODE_DCL_TEMPS ,
D3D10_SB_OPCODE_DCL_INDEXABLE_TEMP ,
D3D10_SB_OPCODE_DCL_GLOBAL_FLAGS ,
// -----------------------------------------------
// This marks the end of D3D10.0 opcodes
D3D10_SB_OPCODE_RESERVED0,
// ---------- DX 10.1 op codes---------------------
D3D10_1_SB_OPCODE_LOD,
D3D10_1_SB_OPCODE_GATHER4,
D3D10_1_SB_OPCODE_SAMPLE_POS,
D3D10_1_SB_OPCODE_SAMPLE_INFO,
// -----------------------------------------------
// This marks the end of D3D10.1 opcodes
D3D10_1_SB_OPCODE_RESERVED1,
// ---------- DX 11 op codes---------------------
D3D11_SB_OPCODE_HS_DECLS , // token marks beginning of HS sub-shader
D3D11_SB_OPCODE_HS_CONTROL_POINT_PHASE , // token marks beginning of HS sub-shader
D3D11_SB_OPCODE_HS_FORK_PHASE , // token marks beginning of HS sub-shader
D3D11_SB_OPCODE_HS_JOIN_PHASE , // token marks beginning of HS sub-shader
D3D11_SB_OPCODE_EMIT_STREAM ,
D3D11_SB_OPCODE_CUT_STREAM ,
D3D11_SB_OPCODE_EMITTHENCUT_STREAM ,
D3D11_SB_OPCODE_INTERFACE_CALL ,
D3D11_SB_OPCODE_BUFINFO ,
D3D11_SB_OPCODE_DERIV_RTX_COARSE ,
D3D11_SB_OPCODE_DERIV_RTX_FINE ,
D3D11_SB_OPCODE_DERIV_RTY_COARSE ,
D3D11_SB_OPCODE_DERIV_RTY_FINE ,
D3D11_SB_OPCODE_GATHER4_C ,
D3D11_SB_OPCODE_GATHER4_PO ,
D3D11_SB_OPCODE_GATHER4_PO_C ,
D3D11_SB_OPCODE_RCP ,
D3D11_SB_OPCODE_F32TOF16 ,
D3D11_SB_OPCODE_F16TOF32 ,
D3D11_SB_OPCODE_UADDC ,
D3D11_SB_OPCODE_USUBB ,
D3D11_SB_OPCODE_COUNTBITS ,
D3D11_SB_OPCODE_FIRSTBIT_HI ,
D3D11_SB_OPCODE_FIRSTBIT_LO ,
D3D11_SB_OPCODE_FIRSTBIT_SHI ,
D3D11_SB_OPCODE_UBFE ,
D3D11_SB_OPCODE_IBFE ,
D3D11_SB_OPCODE_BFI ,
D3D11_SB_OPCODE_BFREV ,
D3D11_SB_OPCODE_SWAPC ,
D3D11_SB_OPCODE_DCL_STREAM ,
D3D11_SB_OPCODE_DCL_FUNCTION_BODY ,
D3D11_SB_OPCODE_DCL_FUNCTION_TABLE ,
D3D11_SB_OPCODE_DCL_INTERFACE ,
D3D11_SB_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT ,
D3D11_SB_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT ,
D3D11_SB_OPCODE_DCL_TESS_DOMAIN ,
D3D11_SB_OPCODE_DCL_TESS_PARTITIONING ,
D3D11_SB_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE ,
D3D11_SB_OPCODE_DCL_HS_MAX_TESSFACTOR ,
D3D11_SB_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT ,
D3D11_SB_OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT ,
D3D11_SB_OPCODE_DCL_THREAD_GROUP ,
D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED ,
D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW ,
D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED,
D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW,
D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED,
D3D11_SB_OPCODE_DCL_RESOURCE_RAW ,
D3D11_SB_OPCODE_DCL_RESOURCE_STRUCTURED ,
D3D11_SB_OPCODE_LD_UAV_TYPED ,
D3D11_SB_OPCODE_STORE_UAV_TYPED ,
D3D11_SB_OPCODE_LD_RAW ,
D3D11_SB_OPCODE_STORE_RAW ,
D3D11_SB_OPCODE_LD_STRUCTURED ,
D3D11_SB_OPCODE_STORE_STRUCTURED ,
D3D11_SB_OPCODE_ATOMIC_AND ,
D3D11_SB_OPCODE_ATOMIC_OR ,
D3D11_SB_OPCODE_ATOMIC_XOR ,
D3D11_SB_OPCODE_ATOMIC_CMP_STORE ,
D3D11_SB_OPCODE_ATOMIC_IADD ,
D3D11_SB_OPCODE_ATOMIC_IMAX ,
D3D11_SB_OPCODE_ATOMIC_IMIN ,
D3D11_SB_OPCODE_ATOMIC_UMAX ,
D3D11_SB_OPCODE_ATOMIC_UMIN ,
D3D11_SB_OPCODE_IMM_ATOMIC_ALLOC ,
D3D11_SB_OPCODE_IMM_ATOMIC_CONSUME ,
D3D11_SB_OPCODE_IMM_ATOMIC_IADD ,
D3D11_SB_OPCODE_IMM_ATOMIC_AND ,
D3D11_SB_OPCODE_IMM_ATOMIC_OR ,
D3D11_SB_OPCODE_IMM_ATOMIC_XOR ,
D3D11_SB_OPCODE_IMM_ATOMIC_EXCH ,
D3D11_SB_OPCODE_IMM_ATOMIC_CMP_EXCH ,
D3D11_SB_OPCODE_IMM_ATOMIC_IMAX ,
D3D11_SB_OPCODE_IMM_ATOMIC_IMIN ,
D3D11_SB_OPCODE_IMM_ATOMIC_UMAX ,
D3D11_SB_OPCODE_IMM_ATOMIC_UMIN ,
D3D11_SB_OPCODE_SYNC ,
D3D11_SB_OPCODE_DADD ,
D3D11_SB_OPCODE_DMAX ,
D3D11_SB_OPCODE_DMIN ,
D3D11_SB_OPCODE_DMUL ,
D3D11_SB_OPCODE_DEQ ,
D3D11_SB_OPCODE_DGE ,
D3D11_SB_OPCODE_DLT ,
D3D11_SB_OPCODE_DNE ,
D3D11_SB_OPCODE_DMOV ,
D3D11_SB_OPCODE_DMOVC ,
D3D11_SB_OPCODE_DTOF ,
D3D11_SB_OPCODE_FTOD ,
D3D11_SB_OPCODE_EVAL_SNAPPED ,
D3D11_SB_OPCODE_EVAL_SAMPLE_INDEX ,
D3D11_SB_OPCODE_EVAL_CENTROID ,
D3D11_SB_OPCODE_DCL_GS_INSTANCE_COUNT ,
D3D11_SB_OPCODE_ABORT ,
D3D11_SB_OPCODE_DEBUG_BREAK ,
// -----------------------------------------------
// This marks the end of D3D11.0 opcodes
D3D11_SB_OPCODE_RESERVED0,
D3D11_1_SB_OPCODE_DDIV,
D3D11_1_SB_OPCODE_DFMA,
D3D11_1_SB_OPCODE_DRCP,
D3D11_1_SB_OPCODE_MSAD,
D3D11_1_SB_OPCODE_DTOI,
D3D11_1_SB_OPCODE_DTOU,
D3D11_1_SB_OPCODE_ITOD,
D3D11_1_SB_OPCODE_UTOD,
// -----------------------------------------------
// This marks the end of D3D11.1 opcodes
D3D11_1_SB_OPCODE_RESERVED0,
D3DWDDM1_3_SB_OPCODE_GATHER4_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_GATHER4_C_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_GATHER4_PO_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_GATHER4_PO_C_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_LD_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_LD_MS_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_LD_UAV_TYPED_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_LD_RAW_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_LD_STRUCTURED_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_L_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_C_LZ_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_CLAMP_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_B_CLAMP_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_D_CLAMP_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_SAMPLE_C_CLAMP_FEEDBACK,
D3DWDDM1_3_SB_OPCODE_CHECK_ACCESS_FULLY_MAPPED,
// -----------------------------------------------
// This marks the end of WDDM 1.3 opcodes
D3DWDDM1_3_SB_OPCODE_RESERVED0,
D3D10_SB_NUM_OPCODES // Should be the last entry
} D3D10_SB_OPCODE_TYPE;
#define D3D10_SB_OPCODE_TYPE_MASK 0x00007ff
// DECODER MACRO: Retrieve program opcode
#define DECODE_D3D10_SB_OPCODE_TYPE(OpcodeToken0) ((D3D10_SB_OPCODE_TYPE)((OpcodeToken0)&D3D10_SB_OPCODE_TYPE_MASK))
// ENCODER MACRO: Create the opcode-type portion of OpcodeToken0
#define ENCODE_D3D10_SB_OPCODE_TYPE(OpcodeName) ((OpcodeName)&D3D10_SB_OPCODE_TYPE_MASK)
#define D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_MASK 0x7f000000
#define D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_SHIFT 24
// DECODER MACRO: Retrieve instruction length
// in # of DWORDs including the opcode token(s).
// The range is 1-127.
#define DECODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH(OpcodeToken0) (((OpcodeToken0)&D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_MASK)>> D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_SHIFT)
// ENCODER MACRO: Store instruction length
// portion of OpcodeToken0, in # of DWORDs
// including the opcode token(s).
// Valid range is 1-127.
#define ENCODE_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH(Length) (((Length)<<D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_SHIFT)&D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH_MASK)
#define MAX_D3D10_SB_TOKENIZED_INSTRUCTION_LENGTH 127
#define D3D10_SB_INSTRUCTION_SATURATE_MASK 0x00002000
// DECODER MACRO: Check OpcodeToken0 to see if an instruction
// is to saturate the result [0..1]
// This flag is indicated by one of the bits in the
// opcode specific control range.
#define DECODE_IS_D3D10_SB_INSTRUCTION_SATURATE_ENABLED(OpcodeToken0) ((OpcodeToken0)&D3D10_SB_INSTRUCTION_SATURATE_MASK)
// ENCODER MACRO: Encode in OpcodeToken0 if instruction is to saturate the result.
#define ENCODE_D3D10_SB_INSTRUCTION_SATURATE(bSat) (((bSat)!=0)?D3D10_SB_INSTRUCTION_SATURATE_MASK:0)
// Boolean test for conditional instructions such as if (if_z or if_nz)
// This is part of the opcode specific control range.
typedef enum D3D10_SB_INSTRUCTION_TEST_BOOLEAN
{
D3D10_SB_INSTRUCTION_TEST_ZERO = 0,
D3D10_SB_INSTRUCTION_TEST_NONZERO = 1
} D3D10_SB_INSTRUCTION_TEST_BOOLEAN;
#define D3D10_SB_INSTRUCTION_TEST_BOOLEAN_MASK 0x00040000
#define D3D10_SB_INSTRUCTION_TEST_BOOLEAN_SHIFT 18
// DECODER MACRO: For an OpcodeToken0 for requires either a
// zero or non-zero test, determine which test was chosen.
#define DECODE_D3D10_SB_INSTRUCTION_TEST_BOOLEAN(OpcodeToken0) ((D3D10_SB_INSTRUCTION_TEST_BOOLEAN)(((OpcodeToken0)&D3D10_SB_INSTRUCTION_TEST_BOOLEAN_MASK)>>D3D10_SB_INSTRUCTION_TEST_BOOLEAN_SHIFT))
// ENCODER MACRO: Store "zero" or "nonzero" in the opcode
// specific control range of OpcodeToken0
#define ENCODE_D3D10_SB_INSTRUCTION_TEST_BOOLEAN(Boolean) (((Boolean)<<D3D10_SB_INSTRUCTION_TEST_BOOLEAN_SHIFT)&D3D10_SB_INSTRUCTION_TEST_BOOLEAN_MASK)
// Precise value mask (bits 19-22)
// This is part of the opcode specific control range.
// It's 1 bit per-channel of the output, for instructions with multiple
// output operands, it applies to that component in each operand. This
// uses the components defined in D3D10_SB_COMPONENT_NAME.
#define D3D11_SB_INSTRUCTION_PRECISE_VALUES_MASK 0x00780000
#define D3D11_SB_INSTRUCTION_PRECISE_VALUES_SHIFT 19
// DECODER MACRO: this macro extracts from OpcodeToken0 the 4 component
// (xyzw) mask, as a field of D3D10_SB_4_COMPONENT_[X|Y|Z|W] flags.
#define DECODE_D3D11_SB_INSTRUCTION_PRECISE_VALUES(OpcodeToken0) ((((OpcodeToken0)&D3D11_SB_INSTRUCTION_PRECISE_VALUES_MASK)>>D3D11_SB_INSTRUCTION_PRECISE_VALUES_SHIFT))
// ENCODER MACRO: Given a set of
// D3D10_SB_OPERAND_4_COMPONENT_[X|Y|Z|W] values
// or'd together, encode them in OpcodeToken0.
#define ENCODE_D3D11_SB_INSTRUCTION_PRECISE_VALUES(ComponentMask) (((ComponentMask)<<D3D11_SB_INSTRUCTION_PRECISE_VALUES_SHIFT)&D3D11_SB_INSTRUCTION_PRECISE_VALUES_MASK)
// resinfo instruction return type
typedef enum D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE
{
D3D10_SB_RESINFO_INSTRUCTION_RETURN_FLOAT = 0,
D3D10_SB_RESINFO_INSTRUCTION_RETURN_RCPFLOAT = 1,
D3D10_SB_RESINFO_INSTRUCTION_RETURN_UINT = 2
} D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE;
#define D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_MASK 0x00001800
#define D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_SHIFT 11
// DECODER MACRO: For an OpcodeToken0 for the resinfo instruction,
// determine the return type.
#define DECODE_D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE(OpcodeToken0) ((D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE)(((OpcodeToken0)&D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_MASK)>>D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_SHIFT))
// ENCODER MACRO: Encode the return type for the resinfo instruction
// in the opcode specific control range of OpcodeToken0
#define ENCODE_D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE(ReturnType) (((ReturnType)<<D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_SHIFT)&D3D10_SB_RESINFO_INSTRUCTION_RETURN_TYPE_MASK)
// sync instruction flags
#define D3D11_SB_SYNC_THREADS_IN_GROUP 0x00000800
#define D3D11_SB_SYNC_THREAD_GROUP_SHARED_MEMORY 0x00001000
#define D3D11_SB_SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GROUP 0x00002000
#define D3D11_SB_SYNC_UNORDERED_ACCESS_VIEW_MEMORY_GLOBAL 0x00004000
#define D3D11_SB_SYNC_FLAGS_MASK 0x00007800
// DECODER MACRO: Retrieve flags for sync instruction from OpcodeToken0.
#define DECODE_D3D11_SB_SYNC_FLAGS(OperandToken0) ((OperandToken0)&D3D11_SB_SYNC_FLAGS_MASK)
// ENCODER MACRO: Given a set of sync instruciton flags, encode them in OpcodeToken0.
#define ENCODE_D3D11_SB_SYNC_FLAGS(Flags) ((Flags)&D3D11_SB_SYNC_FLAGS_MASK)
#define D3D10_SB_OPCODE_EXTENDED_MASK 0x80000000
#define D3D10_SB_OPCODE_EXTENDED_SHIFT 31
// DECODER MACRO: Determine if the opcode is extended
// by an additional opcode token. Currently there are no
// extended opcodes.
#define DECODE_IS_D3D10_SB_OPCODE_EXTENDED(OpcodeToken0) (((OpcodeToken0)&D3D10_SB_OPCODE_EXTENDED_MASK)>> D3D10_SB_OPCODE_EXTENDED_SHIFT)
// ENCODER MACRO: Store in OpcodeToken0 whether the opcode is extended
// by an additional opcode token.
#define ENCODE_D3D10_SB_OPCODE_EXTENDED(bExtended) (((bExtended)!=0)?D3D10_SB_OPCODE_EXTENDED_MASK:0)
// ----------------------------------------------------------------------------
// Extended Opcode Format (OpcodeToken1)
//
// If bit31 of an opcode token is set, the
// opcode has an additional extended opcode token DWORD
// directly following OpcodeToken0. Other tokens
// expected for the opcode, such as the operand
// token(s) always follow
// OpcodeToken0 AND OpcodeToken1..n (extended
// opcode tokens, if present).
//
// [05:00] D3D10_SB_EXTENDED_OPCODE_TYPE
// [30:06] if([05:00] == D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS)
// {
// This custom opcode contains controls for SAMPLE.
// [08:06] Ignored, 0.
// [12:09] U texel immediate offset (4 bit 2's comp) (0 default)
// [16:13] V texel immediate offset (4 bit 2's comp) (0 default)
// [20:17] W texel immediate offset (4 bit 2's comp) (0 default)
// [30:14] Ignored, 0.
// }
// else if( [05:00] == D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM )
// {
// [10:06] D3D10_SB_RESOURCE_DIMENSION
// [22:11] When dimension is D3D11_SB_RESOURCE_DIMENSION_STRUCTURED_BUFFER this holds the buffer stride, otherwise 0
// [30:23] Ignored, 0.
// }
// else if( [05:00] == D3D11_SB_EXTENDED_OPCODE_RESOURCE_RETURN_TYPE )
// {
// [09:06] D3D10_SB_RESOURCE_RETURN_TYPE for component X
// [13:10] D3D10_SB_RESOURCE_RETURN_TYPE for component Y
// [17:14] D3D10_SB_RESOURCE_RETURN_TYPE for component Z
// [21:18] D3D10_SB_RESOURCE_RETURN_TYPE for component W
// [30:22] Ignored, 0.
// }
// else
// {
// [30:04] Ignored, 0.
// }
// [31] 0 normally. 1 there is another extended opcode. Any number
// of extended opcode tokens can be chained. It is possible that some extended
// opcode tokens could include multiple DWORDS - that is defined
// on a case by case basis.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_EXTENDED_OPCODE_TYPE
{
D3D10_SB_EXTENDED_OPCODE_EMPTY = 0,
D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS = 1,
D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM = 2,
D3D11_SB_EXTENDED_OPCODE_RESOURCE_RETURN_TYPE = 3,
} D3D10_SB_EXTENDED_OPCODE_TYPE;
#define D3D11_SB_MAX_SIMULTANEOUS_EXTENDED_OPCODES 3
#define D3D10_SB_EXTENDED_OPCODE_TYPE_MASK 0x0000003f
// DECODER MACRO: Given an extended opcode
// token (OpcodeToken1), figure out what type
// of token it is (from D3D10_SB_EXTENDED_OPCODE_TYPE enum)
// to be able to interpret the rest of the token's contents.
#define DECODE_D3D10_SB_EXTENDED_OPCODE_TYPE(OpcodeToken1) ((D3D10_SB_EXTENDED_OPCODE_TYPE)((OpcodeToken1)&D3D10_SB_EXTENDED_OPCODE_TYPE_MASK))
// ENCODER MACRO: Store extended opcode token
// type in OpcodeToken1.
#define ENCODE_D3D10_SB_EXTENDED_OPCODE_TYPE(ExtOpcodeType) ((ExtOpcodeType)&D3D10_SB_EXTENDED_OPCODE_TYPE_MASK)
typedef enum D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_COORD
{
D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_U = 0,
D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_V = 1,
D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_W = 2,
} D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_COORD;
#define D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_COORD_MASK (3)
#define D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord) (9+4*((Coord)&D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_COORD_MASK))
#define D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_MASK(Coord) (0x0000000f<<D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord))
// DECODER MACRO: Given an extended opcode token
// (OpcodeToken1), and extended token type ==
// D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS, determine the immediate
// texel address offset for u/v/w (D3D10_SB_ADDRESS_OFFSET_COORD)
// This macro returns a (signed) integer, by sign extending the
// decoded 4 bit 2's complement immediate value.
#define DECODE_IMMEDIATE_D3D10_SB_ADDRESS_OFFSET(Coord,OpcodeToken1) ((((OpcodeToken1)&D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_MASK(Coord))>>(D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord))))
// ENCODER MACRO: Store the immediate texel address offset
// for U or V or W Coord (D3D10_SB_ADDRESS_OFFSET_COORD) in an extended
// opcode token (OpcodeToken1) that has extended opcode
// type == D3D10_SB_EXTENDED_OPCODE_SAMPLE_CONTROLS (opcode type encoded separately)
// A 2's complement number is expected as input, from which the LSB 4 bits are extracted.
#define ENCODE_IMMEDIATE_D3D10_SB_ADDRESS_OFFSET(Coord,ImmediateOffset) (((ImmediateOffset)<<D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_SHIFT(Coord))&D3D10_SB_IMMEDIATE_ADDRESS_OFFSET_MASK(Coord))
#define D3D11_SB_EXTENDED_RESOURCE_DIMENSION_MASK 0x000007C0
#define D3D11_SB_EXTENDED_RESOURCE_DIMENSION_SHIFT 6
// DECODER MACRO: Given an extended resource declaration token,
// (D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM), determine the resource dimension
// (D3D10_SB_RESOURCE_DIMENSION enum)
#define DECODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION(OpcodeTokenN) ((D3D10_SB_RESOURCE_DIMENSION)(((OpcodeTokenN)&D3D11_SB_EXTENDED_RESOURCE_DIMENSION_MASK)>>D3D11_SB_EXTENDED_RESOURCE_DIMENSION_SHIFT))
// ENCODER MACRO: Store resource dimension
// (D3D10_SB_RESOURCE_DIMENSION enum) into a
// an extended resource declaration token (D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM)
#define ENCODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION(ResourceDim) (((ResourceDim)<<D3D11_SB_EXTENDED_RESOURCE_DIMENSION_SHIFT)&D3D11_SB_EXTENDED_RESOURCE_DIMENSION_MASK)
#define D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_MASK 0x007FF800
#define D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_SHIFT 11
// DECODER MACRO: Given an extended resource declaration token for a structured buffer,
// (D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM), determine the structure stride
// (12-bit unsigned integer)
#define DECODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE(OpcodeTokenN) (((OpcodeTokenN)&D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_MASK)>>D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_SHIFT)
// ENCODER MACRO: Store resource dimension structure stride
// (12-bit unsigned integer) into a
// an extended resource declaration token (D3D11_SB_EXTENDED_OPCODE_RESOURCE_DIM)
#define ENCODE_D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE(Stride) (((Stride)<<D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_SHIFT)&D3D11_SB_EXTENDED_RESOURCE_DIMENSION_STRUCTURE_STRIDE_MASK)
#define D3D10_SB_RESOURCE_RETURN_TYPE_MASK 0x0000000f
#define D3D10_SB_RESOURCE_RETURN_TYPE_NUMBITS 0x00000004
#define D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE_SHIFT 6
// DECODER MACRO: Get the resource return type for component (0-3) from
// an extended resource declaration token (D3D11_SB_EXTENDED_OPCODE_RESOURCE_RETURN_TYPE)
#define DECODE_D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE(OpcodeTokenN, Component) \
((D3D10_SB_RESOURCE_RETURN_TYPE)(((OpcodeTokenN) >> \
(Component * D3D10_SB_RESOURCE_RETURN_TYPE_NUMBITS + D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE_SHIFT))&D3D10_SB_RESOURCE_RETURN_TYPE_MASK))
// ENCODER MACRO: Generate a resource return type for a component in an extended
// resource delcaration token (D3D11_SB_EXTENDED_OPCODE_RESOURCE_RETURN_TYPE)
#define ENCODE_D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE(ReturnType, Component) \
(((ReturnType)&D3D10_SB_RESOURCE_RETURN_TYPE_MASK) << (Component * D3D10_SB_RESOURCE_RETURN_TYPE_NUMBITS + D3D11_SB_EXTENDED_RESOURCE_RETURN_TYPE_SHIFT))
// ----------------------------------------------------------------------------
// Custom-Data Block Format
//
// DWORD 0 (CustomDataDescTok):
// [10:00] == D3D10_SB_OPCODE_CUSTOMDATA
// [31:11] == D3D10_SB_CUSTOMDATA_CLASS
//
// DWORD 1:
// 32-bit unsigned integer count of number
// of DWORDs in custom-data block,
// including DWORD 0 and DWORD 1.
// So the minimum value is 0x00000002,
// meaning empty custom-data.
//
// Layout of custom-data contents, for the various meta-data classes,
// not defined in this file.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_CUSTOMDATA_CLASS
{
D3D10_SB_CUSTOMDATA_COMMENT = 0,
D3D10_SB_CUSTOMDATA_DEBUGINFO,
D3D10_SB_CUSTOMDATA_OPAQUE,
D3D10_SB_CUSTOMDATA_DCL_IMMEDIATE_CONSTANT_BUFFER,
D3D11_SB_CUSTOMDATA_SHADER_MESSAGE,
D3D11_SB_CUSTOMDATA_SHADER_CLIP_PLANE_CONSTANT_MAPPINGS_FOR_DX9,
} D3D10_SB_CUSTOMDATA_CLASS;
#define D3D10_SB_CUSTOMDATA_CLASS_MASK 0xfffff800
#define D3D10_SB_CUSTOMDATA_CLASS_SHIFT 11
// DECODER MACRO: Find out what class of custom-data is present.
// The contents of the custom-data block are defined
// for each class of custom-data.
#define DECODE_D3D10_SB_CUSTOMDATA_CLASS(CustomDataDescTok) ((D3D10_SB_CUSTOMDATA_CLASS)(((CustomDataDescTok)&D3D10_SB_CUSTOMDATA_CLASS_MASK)>>D3D10_SB_CUSTOMDATA_CLASS_SHIFT))
// ENCODER MACRO: Create complete CustomDataDescTok
#define ENCODE_D3D10_SB_CUSTOMDATA_CLASS(CustomDataClass) (ENCODE_D3D10_SB_OPCODE_TYPE(D3D10_SB_OPCODE_CUSTOMDATA)|(((CustomDataClass)<<D3D10_SB_CUSTOMDATA_CLASS_SHIFT)&D3D10_SB_CUSTOMDATA_CLASS_MASK))
// ----------------------------------------------------------------------------
// Instruction Operand Format (OperandToken0)
//
// [01:00] D3D10_SB_OPERAND_NUM_COMPONENTS
// [11:02] Component Selection
// if([01:00] == D3D10_SB_OPERAND_0_COMPONENT)
// [11:02] = Ignored, 0
// else if([01:00] == D3D10_SB_OPERAND_1_COMPONENT
// [11:02] = Ignored, 0
// else if([01:00] == D3D10_SB_OPERAND_4_COMPONENT
// {
// [03:02] = D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE
// if([03:02] == D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE)
// {
// [07:04] = D3D10_SB_OPERAND_4_COMPONENT_MASK
// [11:08] = Ignored, 0
// }
// else if([03:02] == D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MODE)
// {
// [11:04] = D3D10_SB_4_COMPONENT_SWIZZLE
// }
// else if([03:02] == D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE)
// {
// [05:04] = D3D10_SB_4_COMPONENT_NAME
// [11:06] = Ignored, 0
// }
// }
// else if([01:00] == D3D10_SB_OPERAND_N_COMPONENT)
// {
// Currently not defined.
// }
// [19:12] D3D10_SB_OPERAND_TYPE
// [21:20] D3D10_SB_OPERAND_INDEX_DIMENSION:
// Number of dimensions in the register
// file (NOT the # of dimensions in the
// individual register or memory
// resource being referenced).
// [24:22] if( [21:20] >= D3D10_SB_OPERAND_INDEX_1D )
// D3D10_SB_OPERAND_INDEX_REPRESENTATION for first operand index
// else
// Ignored, 0
// [27:25] if( [21:20] >= D3D10_SB_OPERAND_INDEX_2D )
// D3D10_SB_OPERAND_INDEX_REPRESENTATION for second operand index
// else
// Ignored, 0
// [30:28] if( [21:20] == D3D10_SB_OPERAND_INDEX_3D )
// D3D10_SB_OPERAND_INDEX_REPRESENTATION for third operand index
// else
// Ignored, 0
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description.
//
// ----------------------------------------------------------------------------
// Number of components in data vector referred to by operand.
typedef enum D3D10_SB_OPERAND_NUM_COMPONENTS
{
D3D10_SB_OPERAND_0_COMPONENT = 0,
D3D10_SB_OPERAND_1_COMPONENT = 1,
D3D10_SB_OPERAND_4_COMPONENT = 2,
D3D10_SB_OPERAND_N_COMPONENT = 3 // unused for now
} D3D10_SB_OPERAND_NUM_COMPONENTS;
#define D3D10_SB_OPERAND_NUM_COMPONENTS_MASK 0x00000003
// DECODER MACRO: Extract from OperandToken0 how many components
// the data vector referred to by the operand contains.
// (D3D10_SB_OPERAND_NUM_COMPONENTS enum)
#define DECODE_D3D10_SB_OPERAND_NUM_COMPONENTS(OperandToken0) ((D3D10_SB_OPERAND_NUM_COMPONENTS)((OperandToken0)&D3D10_SB_OPERAND_NUM_COMPONENTS_MASK))
// ENCODER MACRO: Define in OperandToken0 how many components
// the data vector referred to by the operand contains.
// (D3D10_SB_OPERAND_NUM_COMPONENTS enum).
#define ENCODE_D3D10_SB_OPERAND_NUM_COMPONENTS(NumComp) ((NumComp)&D3D10_SB_OPERAND_NUM_COMPONENTS_MASK)
typedef enum D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE
{
D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE = 0, // mask 4 components
D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MODE = 1, // swizzle 4 components
D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE = 2, // select 1 of 4 components
} D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE;
#define D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_MASK 0x0000000c
#define D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_SHIFT 2
// DECODER MACRO: For an operand representing 4component data,
// extract from OperandToken0 the method for selecting data from
// the 4 components (D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE).
#define DECODE_D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE(OperandToken0) ((D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE)(((OperandToken0)&D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_MASK)>>D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_SHIFT))
// ENCODER MACRO: For an operand representing 4component data,
// encode in OperandToken0 a value from D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE
#define ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE(SelectionMode) (((SelectionMode)<<D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_SHIFT)&D3D10_SB_OPERAND_4_COMPONENT_SELECTION_MODE_MASK)
typedef enum D3D10_SB_4_COMPONENT_NAME
{
D3D10_SB_4_COMPONENT_X = 0,
D3D10_SB_4_COMPONENT_Y = 1,
D3D10_SB_4_COMPONENT_Z = 2,
D3D10_SB_4_COMPONENT_W = 3,
D3D10_SB_4_COMPONENT_R = 0,
D3D10_SB_4_COMPONENT_G = 1,
D3D10_SB_4_COMPONENT_B = 2,
D3D10_SB_4_COMPONENT_A = 3
} D3D10_SB_4_COMPONENT_NAME;
#define D3D10_SB_4_COMPONENT_NAME_MASK 3
// MACROS FOR USE IN D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE:
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_MASK 0x000000f0
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_SHIFT 4
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_X 0x00000010
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_Y 0x00000020
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_Z 0x00000040
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_W 0x00000080
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_R D3D10_SB_OPERAND_4_COMPONENT_MASK_X
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_G D3D10_SB_OPERAND_4_COMPONENT_MASK_Y
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_B D3D10_SB_OPERAND_4_COMPONENT_MASK_Z
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_A D3D10_SB_OPERAND_4_COMPONENT_MASK_W
#define D3D10_SB_OPERAND_4_COMPONENT_MASK_ALL D3D10_SB_OPERAND_4_COMPONENT_MASK_MASK
// DECODER MACRO: When 4 component selection mode is
// D3D10_SB_OPERAND_4_COMPONENT_MASK_MODE, this macro
// extracts from OperandToken0 the 4 component (xyzw) mask,
// as a field of D3D10_SB_OPERAND_4_COMPONENT_MASK_[X|Y|Z|W] flags.
// Alternatively, the D3D10_SB_OPERAND_4_COMPONENT_MASK_[X|Y|Z|W] masks
// can be tested on OperandToken0 directly, without this macro.
#define DECODE_D3D10_SB_OPERAND_4_COMPONENT_MASK(OperandToken0) ((OperandToken0)&D3D10_SB_OPERAND_4_COMPONENT_MASK_MASK)
// ENCODER MACRO: Given a set of
// D3D10_SB_OPERAND_4_COMPONENT_MASK_[X|Y|Z|W] values
// or'd together, encode them in OperandToken0.
#define ENCODE_D3D10_SB_OPERAND_4_COMPONENT_MASK(ComponentMask) ((ComponentMask)&D3D10_SB_OPERAND_4_COMPONENT_MASK_MASK)
// ENCODER/DECODER MACRO: Given a D3D10_SB_4_COMPONENT_NAME,
// generate the 4-component mask for it.
// This can be used in loops that build masks or read masks.
// Alternatively, the D3D10_SB_OPERAND_4_COMPONENT_MASK_[X|Y|Z|W] masks
// can be used directly, without this macro.
#define D3D10_SB_OPERAND_4_COMPONENT_MASK(ComponentName) ((1<<(D3D10_SB_OPERAND_4_COMPONENT_MASK_SHIFT+ComponentName))&D3D10_SB_OPERAND_4_COMPONENT_MASK_MASK)
// MACROS FOR USE IN D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MODE:
#define D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MASK 0x00000ff0
#define D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SHIFT 4
// DECODER MACRO: When 4 component selection mode is
// D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MODE, this macro
// extracts from OperandToken0 the 4 component swizzle,
// as a field of D3D10_SB_OPERAND_4_COMPONENT_MASK_[X|Y|Z|W] flags.
#define DECODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(OperandToken0) ((OperandToken0)&D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_MASK)
// DECODER MACRO: Pass a D3D10_SB_4_COMPONENT_NAME as "DestComp" in following
// macro to extract, from OperandToken0 or from a decoded swizzle,
// the swizzle source component (D3D10_SB_4_COMPONENT_NAME enum):
#define DECODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SOURCE(OperandToken0,DestComp) ((D3D10_SB_4_COMPONENT_NAME)(((OperandToken0)>>(D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SHIFT+2*((DestComp)&D3D10_SB_4_COMPONENT_NAME_MASK)))&D3D10_SB_4_COMPONENT_NAME_MASK))
// ENCODER MACRO: Generate a 4 component swizzle given
// 4 D3D10_SB_4_COMPONENT_NAME source values for dest
// components x, y, z, w respectively.
#define ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(XSrc,YSrc,ZSrc,WSrc) ((((XSrc)&D3D10_SB_4_COMPONENT_NAME_MASK)| \
(((YSrc)&D3D10_SB_4_COMPONENT_NAME_MASK)<<2)| \
(((ZSrc)&D3D10_SB_4_COMPONENT_NAME_MASK)<<4)| \
(((WSrc)&D3D10_SB_4_COMPONENT_NAME_MASK)<<6) \
)<<D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE_SHIFT)
// ENCODER/DECODER MACROS: Various common swizzle patterns
// (noswizzle and replicate of each channels)
#define D3D10_SB_OPERAND_4_COMPONENT_NOSWIZZLE ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(D3D10_SB_4_COMPONENT_X,\
D3D10_SB_4_COMPONENT_Y,\
D3D10_SB_4_COMPONENT_Z,\
D3D10_SB_4_COMPONENT_W)
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEX ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(D3D10_SB_4_COMPONENT_X,\
D3D10_SB_4_COMPONENT_X,\
D3D10_SB_4_COMPONENT_X,\
D3D10_SB_4_COMPONENT_X)
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEY ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(D3D10_SB_4_COMPONENT_Y,\
D3D10_SB_4_COMPONENT_Y,\
D3D10_SB_4_COMPONENT_Y,\
D3D10_SB_4_COMPONENT_Y)
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEZ ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(D3D10_SB_4_COMPONENT_Z,\
D3D10_SB_4_COMPONENT_Z,\
D3D10_SB_4_COMPONENT_Z,\
D3D10_SB_4_COMPONENT_Z)
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEW ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SWIZZLE(D3D10_SB_4_COMPONENT_W,\
D3D10_SB_4_COMPONENT_W,\
D3D10_SB_4_COMPONENT_W,\
D3D10_SB_4_COMPONENT_W)
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATERED D3D10_SB_OPERAND_4_COMPONENT_REPLICATEX
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEGREEN D3D10_SB_OPERAND_4_COMPONENT_REPLICATEY
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEBLUE D3D10_SB_OPERAND_4_COMPONENT_REPLICATEZ
#define D3D10_SB_OPERAND_4_COMPONENT_REPLICATEALPHA D3D10_SB_OPERAND_4_COMPONENT_REPLICATEW
// MACROS FOR USE IN D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE:
#define D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MASK 0x00000030
#define D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_SHIFT 4
// DECODER MACRO: When 4 component selection mode is
// D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE, this macro
// extracts from OperandToken0 a D3D10_SB_4_COMPONENT_NAME
// which picks one of the 4 components.
#define DECODE_D3D10_SB_OPERAND_4_COMPONENT_SELECT_1(OperandToken0) ((D3D10_SB_4_COMPONENT_NAME)(((OperandToken0)&D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MASK)>>D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_SHIFT))
// ENCODER MACRO: Given a D3D10_SB_4_COMPONENT_NAME selecting
// a single component for D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MODE,
// encode it into OperandToken0
#define ENCODE_D3D10_SB_OPERAND_4_COMPONENT_SELECT_1(SelectedComp) (((SelectedComp)<<D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_SHIFT)&D3D10_SB_OPERAND_4_COMPONENT_SELECT_1_MASK)
// MACROS FOR DETERMINING OPERAND TYPE:
typedef enum D3D10_SB_OPERAND_TYPE
{
D3D10_SB_OPERAND_TYPE_TEMP = 0, // Temporary Register File
D3D10_SB_OPERAND_TYPE_INPUT = 1, // General Input Register File
D3D10_SB_OPERAND_TYPE_OUTPUT = 2, // General Output Register File
D3D10_SB_OPERAND_TYPE_INDEXABLE_TEMP = 3, // Temporary Register File (indexable)
D3D10_SB_OPERAND_TYPE_IMMEDIATE32 = 4, // 32bit/component immediate value(s)
// If for example, operand token bits
// [01:00]==D3D10_SB_OPERAND_4_COMPONENT,
// this means that the operand type:
// D3D10_SB_OPERAND_TYPE_IMMEDIATE32
// results in 4 additional 32bit
// DWORDS present for the operand.
D3D10_SB_OPERAND_TYPE_IMMEDIATE64 = 5, // 64bit/comp.imm.val(s)HI:LO
D3D10_SB_OPERAND_TYPE_SAMPLER = 6, // Reference to sampler state
D3D10_SB_OPERAND_TYPE_RESOURCE = 7, // Reference to memory resource (e.g. texture)
D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER= 8, // Reference to constant buffer
D3D10_SB_OPERAND_TYPE_IMMEDIATE_CONSTANT_BUFFER= 9, // Reference to immediate constant buffer
D3D10_SB_OPERAND_TYPE_LABEL = 10, // Label
D3D10_SB_OPERAND_TYPE_INPUT_PRIMITIVEID = 11, // Input primitive ID
D3D10_SB_OPERAND_TYPE_OUTPUT_DEPTH = 12, // Output Depth
D3D10_SB_OPERAND_TYPE_NULL = 13, // Null register, used to discard results of operations
// Below Are operands new in DX 10.1
D3D10_SB_OPERAND_TYPE_RASTERIZER = 14, // DX10.1 Rasterizer register, used to denote the depth/stencil and render target resources
D3D10_SB_OPERAND_TYPE_OUTPUT_COVERAGE_MASK = 15, // DX10.1 PS output MSAA coverage mask (scalar)
// Below Are operands new in DX 11
D3D11_SB_OPERAND_TYPE_STREAM = 16, // Reference to GS stream output resource
D3D11_SB_OPERAND_TYPE_FUNCTION_BODY = 17, // Reference to a function definition
D3D11_SB_OPERAND_TYPE_FUNCTION_TABLE = 18, // Reference to a set of functions used by a class
D3D11_SB_OPERAND_TYPE_INTERFACE = 19, // Reference to an interface
D3D11_SB_OPERAND_TYPE_FUNCTION_INPUT = 20, // Reference to an input parameter to a function
D3D11_SB_OPERAND_TYPE_FUNCTION_OUTPUT = 21, // Reference to an output parameter to a function
D3D11_SB_OPERAND_TYPE_OUTPUT_CONTROL_POINT_ID = 22, // HS Control Point phase input saying which output control point ID this is
D3D11_SB_OPERAND_TYPE_INPUT_FORK_INSTANCE_ID = 23, // HS Fork Phase input instance ID
D3D11_SB_OPERAND_TYPE_INPUT_JOIN_INSTANCE_ID = 24, // HS Join Phase input instance ID
D3D11_SB_OPERAND_TYPE_INPUT_CONTROL_POINT = 25, // HS Fork+Join, DS phase input control points (array of them)
D3D11_SB_OPERAND_TYPE_OUTPUT_CONTROL_POINT = 26, // HS Fork+Join phase output control points (array of them)
D3D11_SB_OPERAND_TYPE_INPUT_PATCH_CONSTANT = 27, // DS+HSJoin Input Patch Constants (array of them)
D3D11_SB_OPERAND_TYPE_INPUT_DOMAIN_POINT = 28, // DS Input Domain point
D3D11_SB_OPERAND_TYPE_THIS_POINTER = 29, // Reference to an interface this pointer
D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW = 30, // Reference to UAV u#
D3D11_SB_OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY = 31, // Reference to Thread Group Shared Memory g#
D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID = 32, // Compute Shader Thread ID
D3D11_SB_OPERAND_TYPE_INPUT_THREAD_GROUP_ID = 33, // Compute Shader Thread Group ID
D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP = 34, // Compute Shader Thread ID In Thread Group
D3D11_SB_OPERAND_TYPE_INPUT_COVERAGE_MASK = 35, // Pixel shader coverage mask input
D3D11_SB_OPERAND_TYPE_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, // Compute Shader Thread ID In Group Flattened to a 1D value.
D3D11_SB_OPERAND_TYPE_INPUT_GS_INSTANCE_ID = 37, // Input GS instance ID
D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL = 38, // Output Depth, forced to be greater than or equal than current depth
D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL = 39, // Output Depth, forced to be less than or equal to current depth
D3D11_SB_OPERAND_TYPE_CYCLE_COUNTER = 40, // Cycle counter
D3D11_SB_OPERAND_TYPE_OUTPUT_STENCIL_REF = 41, // DX11 PS output stencil reference (scalar)
D3D11_SB_OPERAND_TYPE_INNER_COVERAGE = 42, // DX11 PS input inner coverage (scalar)
} D3D10_SB_OPERAND_TYPE;
#define D3D10_SB_OPERAND_TYPE_MASK 0x000ff000
#define D3D10_SB_OPERAND_TYPE_SHIFT 12
// DECODER MACRO: Determine operand type from OperandToken0.
#define DECODE_D3D10_SB_OPERAND_TYPE(OperandToken0) ((D3D10_SB_OPERAND_TYPE)(((OperandToken0)&D3D10_SB_OPERAND_TYPE_MASK)>>D3D10_SB_OPERAND_TYPE_SHIFT))
// ENCODER MACRO: Store operand type in OperandToken0.
#define ENCODE_D3D10_SB_OPERAND_TYPE(OperandType) (((OperandType)<<D3D10_SB_OPERAND_TYPE_SHIFT)&D3D10_SB_OPERAND_TYPE_MASK)
typedef enum D3D10_SB_OPERAND_INDEX_DIMENSION
{
D3D10_SB_OPERAND_INDEX_0D = 0, // e.g. Position
D3D10_SB_OPERAND_INDEX_1D = 1, // Most common. e.g. Temp registers.
D3D10_SB_OPERAND_INDEX_2D = 2, // e.g. Geometry Program Input registers.
D3D10_SB_OPERAND_INDEX_3D = 3, // 3D rarely if ever used.
} D3D10_SB_OPERAND_INDEX_DIMENSION;
#define D3D10_SB_OPERAND_INDEX_DIMENSION_MASK 0x00300000
#define D3D10_SB_OPERAND_INDEX_DIMENSION_SHIFT 20
// DECODER MACRO: Determine operand index dimension from OperandToken0.
#define DECODE_D3D10_SB_OPERAND_INDEX_DIMENSION(OperandToken0) ((D3D10_SB_OPERAND_INDEX_DIMENSION)(((OperandToken0)&D3D10_SB_OPERAND_INDEX_DIMENSION_MASK)>>D3D10_SB_OPERAND_INDEX_DIMENSION_SHIFT))
// ENCODER MACRO: Store operand index dimension
// (D3D10_SB_OPERAND_INDEX_DIMENSION enum) in OperandToken0.
#define ENCODE_D3D10_SB_OPERAND_INDEX_DIMENSION(OperandIndexDim) (((OperandIndexDim)<<D3D10_SB_OPERAND_INDEX_DIMENSION_SHIFT)&D3D10_SB_OPERAND_INDEX_DIMENSION_MASK)
typedef enum D3D10_SB_OPERAND_INDEX_REPRESENTATION
{
D3D10_SB_OPERAND_INDEX_IMMEDIATE32 = 0, // Extra DWORD
D3D10_SB_OPERAND_INDEX_IMMEDIATE64 = 1, // 2 Extra DWORDs
// (HI32:LO32)
D3D10_SB_OPERAND_INDEX_RELATIVE = 2, // Extra operand
D3D10_SB_OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE = 3, // Extra DWORD followed by
// extra operand
D3D10_SB_OPERAND_INDEX_IMMEDIATE64_PLUS_RELATIVE = 4, // 2 Extra DWORDS
// (HI32:LO32) followed
// by extra operand
} D3D10_SB_OPERAND_INDEX_REPRESENTATION;
#define D3D10_SB_OPERAND_INDEX_REPRESENTATION_SHIFT(Dim) (22+3*((Dim)&3))
#define D3D10_SB_OPERAND_INDEX_REPRESENTATION_MASK(Dim) (0x3<<D3D10_SB_OPERAND_INDEX_REPRESENTATION_SHIFT(Dim))
// DECODER MACRO: Determine from OperandToken0 what representation
// an operand index is provided as (D3D10_SB_OPERAND_INDEX_REPRESENTATION enum),
// for index dimension [0], [1] or [2], depending on D3D10_SB_OPERAND_INDEX_DIMENSION.
#define DECODE_D3D10_SB_OPERAND_INDEX_REPRESENTATION(Dim,OperandToken0) ((D3D10_SB_OPERAND_INDEX_REPRESENTATION)(((OperandToken0)&D3D10_SB_OPERAND_INDEX_REPRESENTATION_MASK(Dim))>>D3D10_SB_OPERAND_INDEX_REPRESENTATION_SHIFT(Dim)))
// ENCODER MACRO: Store in OperandToken0 what representation
// an operand index is provided as (D3D10_SB_OPERAND_INDEX_REPRESENTATION enum),
// for index dimension [0], [1] or [2], depending on D3D10_SB_OPERAND_INDEX_DIMENSION.
#define ENCODE_D3D10_SB_OPERAND_INDEX_REPRESENTATION(Dim,IndexRepresentation) (((IndexRepresentation)<<D3D10_SB_OPERAND_INDEX_REPRESENTATION_SHIFT(Dim))&D3D10_SB_OPERAND_INDEX_REPRESENTATION_MASK(Dim))
#define D3D10_SB_OPERAND_EXTENDED_MASK 0x80000000
#define D3D10_SB_OPERAND_EXTENDED_SHIFT 31
// DECODER MACRO: Determine if the operand is extended
// by an additional opcode token.
#define DECODE_IS_D3D10_SB_OPERAND_EXTENDED(OperandToken0) (((OperandToken0)&D3D10_SB_OPERAND_EXTENDED_MASK)>>D3D10_SB_OPERAND_EXTENDED_SHIFT)
// ENCODER MACRO: Store in OperandToken0 whether the operand is extended
// by an additional operand token.
#define ENCODE_D3D10_SB_OPERAND_EXTENDED(bExtended) (((bExtended)!=0)?D3D10_SB_OPERAND_EXTENDED_MASK:0)
// ----------------------------------------------------------------------------
// Extended Instruction Operand Format (OperandToken1)
//
// If bit31 of an operand token is set, the
// operand has additional data in a second DWORD
// directly following OperandToken0. Other tokens
// expected for the operand, such as immmediate
// values or relative address operands (full
// operands in themselves) always follow
// OperandToken0 AND OperandToken1..n (extended
// operand tokens, if present).
//
// [05:00] D3D10_SB_EXTENDED_OPERAND_TYPE
// [16:06] if([05:00] == D3D10_SB_EXTENDED_OPERAND_MODIFIER)
// {
// [13:06] D3D10_SB_OPERAND_MODIFIER
// [16:14] Min Precision: D3D11_SB_OPERAND_MIN_PRECISION
// [17:17] Non-uniform: D3D12_SB_OPERAND_NON_UNIFORM
// }
// else
// {
// [17:06] Ignored, 0.
// }
// [30:18] Ignored, 0.
// [31] 0 normally. 1 if second order extended operand definition,
// meaning next DWORD contains yet ANOTHER extended operand
// description. Currently no second order extensions defined.
// This would be useful if a particular extended operand does
// not have enough space to store the required information in
// a single token and so is extended further.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_EXTENDED_OPERAND_TYPE
{
D3D10_SB_EXTENDED_OPERAND_EMPTY = 0, // Might be used if this
// enum is full and
// further extended opcode
// is needed.
D3D10_SB_EXTENDED_OPERAND_MODIFIER = 1,
} D3D10_SB_EXTENDED_OPERAND_TYPE;
#define D3D10_SB_EXTENDED_OPERAND_TYPE_MASK 0x0000003f
// DECODER MACRO: Given an extended operand
// token (OperandToken1), figure out what type
// of token it is (from D3D10_SB_EXTENDED_OPERAND_TYPE enum)
// to be able to interpret the rest of the token's contents.
#define DECODE_D3D10_SB_EXTENDED_OPERAND_TYPE(OperandToken1) ((D3D10_SB_EXTENDED_OPERAND_TYPE)((OperandToken1)&D3D10_SB_EXTENDED_OPERAND_TYPE_MASK))
// ENCODER MACRO: Store extended operand token
// type in OperandToken1.
#define ENCODE_D3D10_SB_EXTENDED_OPERAND_TYPE(ExtOperandType) ((ExtOperandType)&D3D10_SB_EXTENDED_OPERAND_TYPE_MASK)
typedef enum D3D10_SB_OPERAND_MODIFIER
{
D3D10_SB_OPERAND_MODIFIER_NONE = 0, // Nop. This is the implied
// default if the extended
// operand is not present for
// an operand for which source
// modifiers are meaningful
D3D10_SB_OPERAND_MODIFIER_NEG = 1, // Negate
D3D10_SB_OPERAND_MODIFIER_ABS = 2, // Absolute value, abs()
D3D10_SB_OPERAND_MODIFIER_ABSNEG = 3, // -abs()
} D3D10_SB_OPERAND_MODIFIER;
#define D3D10_SB_OPERAND_MODIFIER_MASK 0x00003fc0
#define D3D10_SB_OPERAND_MODIFIER_SHIFT 6
// DECODER MACRO: Given a D3D10_SB_EXTENDED_OPERAND_MODIFIER
// extended token (OperandToken1), determine the source modifier
// (D3D10_SB_OPERAND_MODIFIER enum)
#define DECODE_D3D10_SB_OPERAND_MODIFIER(OperandToken1) ((D3D10_SB_OPERAND_MODIFIER)(((OperandToken1)&D3D10_SB_OPERAND_MODIFIER_MASK)>>D3D10_SB_OPERAND_MODIFIER_SHIFT))
// ENCODER MACRO: Generate a complete source modifier extended token
// (OperandToken1), given D3D10_SB_OPERAND_MODIFIER enum (the
// ext. operand type is also set to D3D10_SB_EXTENDED_OPERAND_MODIFIER).
#define ENCODE_D3D10_SB_EXTENDED_OPERAND_MODIFIER(SourceMod) ((((SourceMod)<<D3D10_SB_OPERAND_MODIFIER_SHIFT)&D3D10_SB_OPERAND_MODIFIER_MASK)| \
ENCODE_D3D10_SB_EXTENDED_OPERAND_TYPE(D3D10_SB_EXTENDED_OPERAND_MODIFIER) | \
ENCODE_D3D10_SB_OPERAND_DOUBLE_EXTENDED(0))
// Min precision specifier for source/dest operands. This
// fits in the extended operand token field. Implementations are free to
// execute at higher precision than the min - details spec'ed elsewhere.
// This is part of the opcode specific control range.
typedef enum D3D11_SB_OPERAND_MIN_PRECISION
{
D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT = 0, // Default precision
// for the shader model
D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16 = 1, // Min 16 bit/component float
D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_2_8 = 2, // Min 10(2.8)bit/comp. float
D3D11_SB_OPERAND_MIN_PRECISION_SINT_16 = 4, // Min 16 bit/comp. signed integer
D3D11_SB_OPERAND_MIN_PRECISION_UINT_16 = 5, // Min 16 bit/comp. unsigned integer
} D3D11_SB_OPERAND_MIN_PRECISION;
#define D3D11_SB_OPERAND_MIN_PRECISION_MASK 0x0001C000
#define D3D11_SB_OPERAND_MIN_PRECISION_SHIFT 14
// DECODER MACRO: For an OperandToken1 that can specify
// a minimum precision for execution, find out what it is.
#define DECODE_D3D11_SB_OPERAND_MIN_PRECISION(OperandToken1) ((D3D11_SB_OPERAND_MIN_PRECISION)(((OperandToken1)& D3D11_SB_OPERAND_MIN_PRECISION_MASK)>> D3D11_SB_OPERAND_MIN_PRECISION_SHIFT))
// ENCODER MACRO: Encode minimum precision for execution
// into the extended operand token, OperandToken1
#define ENCODE_D3D11_SB_OPERAND_MIN_PRECISION(MinPrecision) (((MinPrecision)<< D3D11_SB_OPERAND_MIN_PRECISION_SHIFT)& D3D11_SB_OPERAND_MIN_PRECISION_MASK)
// Non-uniform extended operand modifier.
#define D3D12_SB_OPERAND_NON_UNIFORM_MASK 0x00020000
#define D3D12_SB_OPERAND_NON_UNIFORM_SHIFT 17
// DECODER MACRO: For an OperandToken1 that can specify a non-uniform operand
#define DECODE_D3D12_SB_OPERAND_NON_UNIFORM(OperandToken1) (((OperandToken1)& D3D12_SB_OPERAND_NON_UNIFORM_MASK)>> D3D12_SB_OPERAND_NON_UNIFORM_SHIFT)
// ENCODER MACRO: Encode non-uniform state into the extended operand token, OperandToken1
#define ENCODE_D3D12_SB_OPERAND_NON_UNIFORM(NonUniform) (((NonUniform)<< D3D12_SB_OPERAND_NON_UNIFORM_SHIFT)& D3D12_SB_OPERAND_NON_UNIFORM_MASK)
#define D3D10_SB_OPERAND_DOUBLE_EXTENDED_MASK 0x80000000
#define D3D10_SB_OPERAND_DOUBLE_EXTENDED_SHIFT 31
// DECODER MACRO: Determine if an extended operand token
// (OperandToken1) is further extended by yet another token
// (OperandToken2). Currently there are no secondary
// extended operand tokens.
#define DECODE_IS_D3D10_SB_OPERAND_DOUBLE_EXTENDED(OperandToken1) (((OperandToken1)&D3D10_SB_OPERAND_DOUBLE_EXTENDED_MASK)>>D3D10_SB_OPERAND_DOUBLE_EXTENDED_SHIFT)
// ENCODER MACRO: Store in OperandToken1 whether the operand is extended
// by an additional operand token. Currently there are no secondary
// extended operand tokens.
#define ENCODE_D3D10_SB_OPERAND_DOUBLE_EXTENDED(bExtended) (((bExtended)!=0)?D3D10_SB_OPERAND_DOUBLE_EXTENDED_MASK:0)
// ----------------------------------------------------------------------------
// Name Token (NameToken) (used in declaration statements)
//
// [15:00] D3D10_SB_NAME enumeration
// [31:16] Reserved, 0
//
// ----------------------------------------------------------------------------
#define D3D10_SB_NAME_MASK 0x0000ffff
// DECODER MACRO: Get the name from NameToken
#define DECODE_D3D10_SB_NAME(NameToken) ((D3D10_SB_NAME)((NameToken)&D3D10_SB_NAME_MASK))
// ENCODER MACRO: Generate a complete NameToken given a D3D10_SB_NAME
#define ENCODE_D3D10_SB_NAME(Name) ((Name)&D3D10_SB_NAME_MASK)
//---------------------------------------------------------------------
// Declaration Statements
//
// Declarations start with a standard opcode token,
// having opcode type being D3D10_SB_OPCODE_DCL*.
// Each particular declaration type has custom
// operand token(s), described below.
//---------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Global Flags Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_GLOBAL_FLAGS
// [11:11] Refactoring allowed if bit set.
// [12:12] Enable double precision float ops.
// [13:13] Force early depth-stencil test.
// [14:14] Enable RAW and structured buffers in non-CS 4.x shaders.
// [15:15] Skip optimizations of shader IL when translating to native code
// [16:16] Enable minimum-precision data types
// [17:17] Enable 11.1 double-precision floating-point instruction extensions
// [18:18] Enable 11.1 non-double instruction extensions
// [23:19] Reserved for future flags.
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by no operands.
//
// ----------------------------------------------------------------------------
#define D3D10_SB_GLOBAL_FLAG_REFACTORING_ALLOWED (1<<11)
#define D3D11_SB_GLOBAL_FLAG_ENABLE_DOUBLE_PRECISION_FLOAT_OPS (1<<12)
#define D3D11_SB_GLOBAL_FLAG_FORCE_EARLY_DEPTH_STENCIL (1<<13)
#define D3D11_SB_GLOBAL_FLAG_ENABLE_RAW_AND_STRUCTURED_BUFFERS (1<<14)
#define D3D11_1_SB_GLOBAL_FLAG_SKIP_OPTIMIZATION (1<<15)
#define D3D11_1_SB_GLOBAL_FLAG_ENABLE_MINIMUM_PRECISION (1<<16)
#define D3D11_1_SB_GLOBAL_FLAG_ENABLE_DOUBLE_EXTENSIONS (1<<17)
#define D3D11_1_SB_GLOBAL_FLAG_ENABLE_SHADER_EXTENSIONS (1<<18)
#define D3D12_SB_GLOBAL_FLAG_ALL_RESOURCES_BOUND (1<<19)
#define D3D10_SB_GLOBAL_FLAGS_MASK 0x00fff800
// DECODER MACRO: Get global flags
#define DECODE_D3D10_SB_GLOBAL_FLAGS(OpcodeToken0) ((OpcodeToken0)&D3D10_SB_GLOBAL_FLAGS_MASK)
// ENCODER MACRO: Encode global flags
#define ENCODE_D3D10_SB_GLOBAL_FLAGS(Flags) ((Flags)&D3D10_SB_GLOBAL_FLAGS_MASK)
// ----------------------------------------------------------------------------
// Resource Declaration (non multisampled)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_RESOURCE
// [15:11] D3D10_SB_RESOURCE_DIMENSION
// [23:16] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands on Shader Models 4.0 through 5.0:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// (2) a Resource Return Type token (ResourceReturnTypeToken)
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (t<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of resources in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the t# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (t<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of resource within space (may be dynamically indexed)
// (2) a Resource Return Type token (ResourceReturnTypeToken)
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
#define D3D10_SB_RESOURCE_DIMENSION_MASK 0x0000F800
#define D3D10_SB_RESOURCE_DIMENSION_SHIFT 11
// DECODER MACRO: Given a resource declaration token,
// (OpcodeToken0), determine the resource dimension
// (D3D10_SB_RESOURCE_DIMENSION enum)
#define DECODE_D3D10_SB_RESOURCE_DIMENSION(OpcodeToken0) ((D3D10_SB_RESOURCE_DIMENSION)(((OpcodeToken0)&D3D10_SB_RESOURCE_DIMENSION_MASK)>>D3D10_SB_RESOURCE_DIMENSION_SHIFT))
// ENCODER MACRO: Store resource dimension
// (D3D10_SB_RESOURCE_DIMENSION enum) into a
// a resource declaration token (OpcodeToken0)
#define ENCODE_D3D10_SB_RESOURCE_DIMENSION(ResourceDim) (((ResourceDim)<<D3D10_SB_RESOURCE_DIMENSION_SHIFT)&D3D10_SB_RESOURCE_DIMENSION_MASK)
// ----------------------------------------------------------------------------
// Resource Declaration (multisampled)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_RESOURCE (same opcode as non-multisampled case)
// [15:11] D3D10_SB_RESOURCE_DIMENSION (must be TEXTURE2DMS or TEXTURE2DMSARRAY)
// [22:16] Sample count 1...127. 0 is currently disallowed, though
// in future versions 0 could mean "configurable" sample count
// [23:23] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands on Shader Models 4.0 through 5.0:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// (2) a Resource Return Type token (ResourceReturnTypeToken)
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (t<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of resources in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the t# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (t<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of resource within space (may be dynamically indexed)
// (2) a Resource Return Type token (ResourceReturnTypeToken)
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
// use same macro for encoding/decoding resource dimension aas the non-msaa declaration
#define D3D10_SB_RESOURCE_SAMPLE_COUNT_MASK 0x07F0000
#define D3D10_SB_RESOURCE_SAMPLE_COUNT_SHIFT 16
// DECODER MACRO: Given a resource declaration token,
// (OpcodeToken0), determine the resource sample count (1..127)
#define DECODE_D3D10_SB_RESOURCE_SAMPLE_COUNT(OpcodeToken0) ((UINT)(((OpcodeToken0)&D3D10_SB_RESOURCE_SAMPLE_COUNT_MASK)>>D3D10_SB_RESOURCE_SAMPLE_COUNT_SHIFT))
// ENCODER MACRO: Store resource sample count up to 127 into a
// a resource declaration token (OpcodeToken0)
#define ENCODE_D3D10_SB_RESOURCE_SAMPLE_COUNT(SampleCount) (((SampleCount > 127 ? 127 : SampleCount)<<D3D10_SB_RESOURCE_SAMPLE_COUNT_SHIFT)&D3D10_SB_RESOURCE_SAMPLE_COUNT_MASK)
// ----------------------------------------------------------------------------
// Resource Return Type Token (ResourceReturnTypeToken) (used in resource
// declaration statements)
//
// [03:00] D3D10_SB_RESOURCE_RETURN_TYPE for component X
// [07:04] D3D10_SB_RESOURCE_RETURN_TYPE for component Y
// [11:08] D3D10_SB_RESOURCE_RETURN_TYPE for component Z
// [15:12] D3D10_SB_RESOURCE_RETURN_TYPE for component W
// [31:16] Reserved, 0
//
// ----------------------------------------------------------------------------
// DECODER MACRO: Get the resource return type for component (0-3) from
// ResourceReturnTypeToken
#define DECODE_D3D10_SB_RESOURCE_RETURN_TYPE(ResourceReturnTypeToken, Component) \
((D3D10_SB_RESOURCE_RETURN_TYPE)(((ResourceReturnTypeToken) >> \
(Component * D3D10_SB_RESOURCE_RETURN_TYPE_NUMBITS))&D3D10_SB_RESOURCE_RETURN_TYPE_MASK))
// ENCODER MACRO: Generate a resource return type for a component
#define ENCODE_D3D10_SB_RESOURCE_RETURN_TYPE(ReturnType, Component) \
(((ReturnType)&D3D10_SB_RESOURCE_RETURN_TYPE_MASK) << (Component * D3D10_SB_RESOURCE_RETURN_TYPE_NUMBITS))
// ----------------------------------------------------------------------------
// Sampler Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_SAMPLER
// [14:11] D3D10_SB_SAMPLER_MODE
// [23:15] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand on Shader Models 4.0 through 5.0:
// (1) Operand starting with OperandToken0, defining which sampler
// (D3D10_SB_OPERAND_TYPE_SAMPLER) register # is being declared.
//
// OpcodeToken0 is followed by 2 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// s# register (D3D10_SB_OPERAND_TYPE_SAMPLER) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (s<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of samplers in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the s# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (s<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of sampler within space (may be dynamically indexed)
// (2) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_SAMPLER_MODE
{
D3D10_SB_SAMPLER_MODE_DEFAULT = 0,
D3D10_SB_SAMPLER_MODE_COMPARISON = 1,
D3D10_SB_SAMPLER_MODE_MONO = 2,
} D3D10_SB_SAMPLER_MODE;
#define D3D10_SB_SAMPLER_MODE_MASK 0x00007800
#define D3D10_SB_SAMPLER_MODE_SHIFT 11
// DECODER MACRO: Find out if a Constant Buffer is going to be indexed or not
#define DECODE_D3D10_SB_SAMPLER_MODE(OpcodeToken0) ((D3D10_SB_SAMPLER_MODE)(((OpcodeToken0)&D3D10_SB_SAMPLER_MODE_MASK)>>D3D10_SB_SAMPLER_MODE_SHIFT))
// ENCODER MACRO: Generate a resource return type for a component
#define ENCODE_D3D10_SB_SAMPLER_MODE(SamplerMode) (((SamplerMode)<<D3D10_SB_SAMPLER_MODE_SHIFT)&D3D10_SB_SAMPLER_MODE_MASK)
// ----------------------------------------------------------------------------
// Input Register Declaration (see separate declarations for Pixel Shaders)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared,
// including writemask.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Input Register Declaration w/System Interpreted Value
// (see separate declarations for Pixel Shaders)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT_SIV
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared,
// including writemask. For Geometry Shaders, the input is
// v[vertex][attribute], and this declaration is only for which register
// on the attribute axis is being declared. The vertex axis value must
// be equal to the # of vertices in the current input primitive for the GS
// (i.e. 6 for triangle + adjacency).
// (2) a System Interpreted Value Name (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Input Register Declaration w/System Generated Value
// (available for all shaders incl. Pixel Shader, no interpolation mode needed)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT_SGV
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared,
// including writemask.
// (2) a System Generated Value Name (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Pixel Shader Input Register Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT_PS
// [14:11] D3D10_SB_INTERPOLATION_MODE
// [23:15] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared,
// including writemask.
//
// ----------------------------------------------------------------------------
#define D3D10_SB_INPUT_INTERPOLATION_MODE_MASK 0x00007800
#define D3D10_SB_INPUT_INTERPOLATION_MODE_SHIFT 11
// DECODER MACRO: Find out interpolation mode for the input register
#define DECODE_D3D10_SB_INPUT_INTERPOLATION_MODE(OpcodeToken0) ((D3D10_SB_INTERPOLATION_MODE)(((OpcodeToken0)&D3D10_SB_INPUT_INTERPOLATION_MODE_MASK)>>D3D10_SB_INPUT_INTERPOLATION_MODE_SHIFT))
// ENCODER MACRO: Encode interpolation mode for a register.
#define ENCODE_D3D10_SB_INPUT_INTERPOLATION_MODE(InterpolationMode) (((InterpolationMode)<<D3D10_SB_INPUT_INTERPOLATION_MODE_SHIFT)&D3D10_SB_INPUT_INTERPOLATION_MODE_MASK)
// ----------------------------------------------------------------------------
// Pixel Shader Input Register Declaration w/System Interpreted Value
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT_PS_SIV
// [14:11] D3D10_SB_INTERPOLATION_MODE
// [23:15] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared.
// (2) a System Interpreted Value Name (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Pixel Shader Input Register Declaration w/System Generated Value
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INPUT_PS_SGV
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) Operand, starting with OperandToken0, defining which input
// v# register (D3D10_SB_OPERAND_TYPE_INPUT) is being declared.
// (2) a System Generated Value Name (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Output Register Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_OUTPUT
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand:
// (1) Operand, starting with OperandToken0, defining which
// o# register (D3D10_SB_OPERAND_TYPE_OUTPUT) is being declared,
// including writemask.
// (in Pixel Shader, output can also be one of
// D3D10_SB_OPERAND_TYPE_OUTPUT_DEPTH,
// D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL, or
// D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL )
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Output Register Declaration w/System Interpreted Value
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_OUTPUT_SIV
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// o# register (D3D10_SB_OPERAND_TYPE_OUTPUT) is being declared,
// including writemask.
// (2) a System Interpreted Name token (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Output Register Declaration w/System Generated Value
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_OUTPUT_SGV
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// o# register (D3D10_SB_OPERAND_TYPE_OUTPUT) is being declared,
// including writemask.
// (2) a System Generated Name token (NameToken)
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Input or Output Register Indexing Range Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INDEX_RANGE
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// input (v#) or output (o#) register is having its array indexing range
// declared, including writemask. For Geometry Shader inputs,
// it is assumed that the vertex axis is always fully indexable,
// and 0 must be specified as the vertex# in this declaration, so that
// only the a range of attributes are having their index range defined.
//
// (2) a DWORD representing the count of registers starting from the one
// indicated in (1).
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Temp Register Declaration r0...r(n-1)
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_TEMPS
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand:
// (1) DWORD (unsigned int) indicating how many temps are being declared.
// i.e. 5 means r0...r4 are declared.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Indexable Temp Register (x#[size]) Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INDEXABLE_TEMP
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 3 DWORDs:
// (1) Register index (defines which x# register is declared)
// (2) Number of registers in this register bank
// (3) Number of components in the array (1-4). 1 means .x, 2 means .xy etc.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Constant Buffer Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_CONSTANT_BUFFER
// [11] D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN
// [23:12] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand on Shader Model 4.0 through 5.0:
// (1) Operand, starting with OperandToken0, defining which CB slot (cb#[size])
// is being declared. (operand type: D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER)
// The indexing dimension for the register must be
// D3D10_SB_OPERAND_INDEX_DIMENSION_2D, where the first index specifies
// which cb#[] is being declared, and the second (array) index specifies the size
// of the buffer, as a count of 32-bit*4 elements. (As opposed to when the
// cb#[] is used in shader instructions, and the array index represents which
// location in the constant buffer is being referenced.)
// If the size is specified as 0, the CB size is not known (any size CB
// can be bound to the slot).
//
// The order of constant buffer declarations in a shader indicates their
// relative priority from highest to lowest (hint to driver).
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) Operand, starting with OperandToken0, defining which CB range (ID and bounds)
// is being declared. (operand type: D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER)
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (cb<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of constant buffers in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the cb#[] is used in shader instructions: (cb<id>[<idx>][<loc>])
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of constant buffer within space (may be dynamically indexed)
// 3 <loc>: location of vector within constant buffer being referenced,
// which may also be dynamically indexed, with no access pattern flag required.
// (2) a DWORD indicating the size of the constant buffer as a count of 16-byte vectors.
// Each vector is 32-bit*4 elements == 128-bits == 16 bytes.
// If the size is specified as 0, the CB size is not known (any size CB
// can be bound to the slot).
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN
{
D3D10_SB_CONSTANT_BUFFER_IMMEDIATE_INDEXED = 0,
D3D10_SB_CONSTANT_BUFFER_DYNAMIC_INDEXED = 1
} D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN;
#define D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_MASK 0x00000800
#define D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_SHIFT 11
// DECODER MACRO: Find out if a Constant Buffer is going to be indexed or not
#define DECODE_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN(OpcodeToken0) ((D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN)(((OpcodeToken0)&D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_MASK)>>D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_SHIFT))
// ENCODER MACRO: Encode the access pattern for the Constant Buffer
#define ENCODE_D3D10_SB_D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN(AccessPattern) (((AccessPattern)<<D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_SHIFT)&D3D10_SB_CONSTANT_BUFFER_ACCESS_PATTERN_MASK)
// ----------------------------------------------------------------------------
// Immediate Constant Buffer Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_CUSTOMDATA
// [31:11] == D3D10_SB_CUSTOMDATA_DCL_IMMEDIATE_CONSTANT_BUFFER
//
// OpcodeToken0 is followed by:
// (1) DWORD indicating length of declaration, including OpcodeToken0.
// This length must = 2(for OpcodeToken0 and 1) + a multiple of 4
// (# of immediate constants)
// (2) Sequence of 4-tuples of DWORDs defining the Immediate Constant Buffer.
// The number of 4-tuples is (length above - 1) / 4
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Shader Message Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_CUSTOMDATA
// [31:11] == D3D11_SB_CUSTOMDATA_SHADER_MESSAGE
//
// OpcodeToken0 is followed by:
// (1) DWORD indicating length of declaration, including OpcodeToken0.
// (2) DWORD (D3D11_SB_SHADER_MESSAGE_ID) indicating shader message or error.
// (3) D3D11_SB_SHADER_MESSAGE_FORMAT indicating the convention for formatting the message.
// (4) DWORD indicating the number of characters in the string without the terminator.
// (5) DWORD indicating the number of operands.
// (6) DWORD indicating length of operands.
// (7) Encoded operands.
// (8) String with trailing zero, padded to a multiple of DWORDs.
// The string is in the given format and the operands given should
// be used for argument substitutions when formatting.
// ----------------------------------------------------------------------------
typedef enum D3D11_SB_SHADER_MESSAGE_ID
{
D3D11_SB_SHADER_MESSAGE_ID_MESSAGE = 0x00200102,
D3D11_SB_SHADER_MESSAGE_ID_ERROR = 0x00200103
} D3D11_SB_SHADER_MESSAGE_ID;
typedef enum D3D11_SB_SHADER_MESSAGE_FORMAT
{
// No formatting, just a text string. Operands are ignored.
D3D11_SB_SHADER_MESSAGE_FORMAT_ANSI_TEXT,
// Format string follows C/C++ printf conventions.
D3D11_SB_SHADER_MESSAGE_FORMAT_ANSI_PRINTF,
} D3D11_SB_SHADER_MESSAGE_FORMAT;
// ----------------------------------------------------------------------------
// Shader Clip Plane Constant Mappings for DX9 hardware
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_CUSTOMDATA
// [31:11] == D3D11_SB_CUSTOMDATA_SHADER_CLIP_PLANE_CONSTANT_MAPPINGS_FOR_DX9
//
// OpcodeToken0 is followed by:
// (1) DWORD indicating length of declaration, including OpcodeToken0.
// (2) DWORD indicating number of constant mappings (up to 6 mappings).
// (3+) Constant mapping tables in following format.
//
// struct _Clip_Plane_Constant_Mapping
// {
// WORD ConstantBufferIndex; // cb[n]
// WORD StartConstantElement; // starting index of cb[n][m]
// WORD ConstantElemntCount; // number of elements cb[n][m] ~ cb[n][m+l]
// WORD Reserved; //
// };
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Geometry Shader Input Primitive Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_GS_INPUT_PRIMITIVE
// [16:11] D3D10_SB_PRIMITIVE [not D3D10_SB_PRIMITIVE_TOPOLOGY]
// [23:17] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
#define D3D10_SB_GS_INPUT_PRIMITIVE_MASK 0x0001f800
#define D3D10_SB_GS_INPUT_PRIMITIVE_SHIFT 11
// DECODER MACRO: Given a primitive topology declaration,
// (OpcodeToken0), determine the primitive topology
// (D3D10_SB_PRIMITIVE enum)
#define DECODE_D3D10_SB_GS_INPUT_PRIMITIVE(OpcodeToken0) ((D3D10_SB_PRIMITIVE)(((OpcodeToken0)&D3D10_SB_GS_INPUT_PRIMITIVE_MASK)>>D3D10_SB_GS_INPUT_PRIMITIVE_SHIFT))
// ENCODER MACRO: Store primitive topology
// (D3D10_SB_PRIMITIVE enum) into a
// a primitive topology declaration token (OpcodeToken0)
#define ENCODE_D3D10_SB_GS_INPUT_PRIMITIVE(Prim) (((Prim)<<D3D10_SB_GS_INPUT_PRIMITIVE_SHIFT)&D3D10_SB_GS_INPUT_PRIMITIVE_MASK)
// ----------------------------------------------------------------------------
// Geometry Shader Output Topology Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY
// [17:11] D3D10_SB_PRIMITIVE_TOPOLOGY
// [23:18] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
#define D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_MASK 0x0001f800
#define D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_SHIFT 11
// DECODER MACRO: Given a primitive topology declaration,
// (OpcodeToken0), determine the primitive topology
// (D3D10_SB_PRIMITIVE_TOPOLOGY enum)
#define DECODE_D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY(OpcodeToken0) ((D3D10_SB_PRIMITIVE_TOPOLOGY)(((OpcodeToken0)&D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_MASK)>>D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_SHIFT))
// ENCODER MACRO: Store primitive topology
// (D3D10_SB_PRIMITIVE_TOPOLOGY enum) into a
// a primitive topology declaration token (OpcodeToken0)
#define ENCODE_D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY(PrimTopology) (((PrimTopology)<<D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_SHIFT)&D3D10_SB_GS_OUTPUT_PRIMITIVE_TOPOLOGY_MASK)
// ----------------------------------------------------------------------------
// Geometry Shader Maximum Output Vertex Count Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by a DWORD representing the
// maximum number of primitives that could be output
// by the Geometry Shader.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Geometry Shader Instance Count Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_GS_INSTANCE_COUNT
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by a UINT32 representing the
// number of instances of the geometry shader program to execute.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: HS/DS Input Control Point Count
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT
// [16:11] Control point count
// [23:17] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
#define D3D11_SB_INPUT_CONTROL_POINT_COUNT_MASK 0x0001f800
#define D3D11_SB_INPUT_CONTROL_POINT_COUNT_SHIFT 11
// DECODER MACRO: Given an input control point count declaration token,
// (OpcodeToken0), determine the control point count
#define DECODE_D3D11_SB_INPUT_CONTROL_POINT_COUNT(OpcodeToken0) ((UINT)(((OpcodeToken0)&D3D11_SB_INPUT_CONTROL_POINT_COUNT_MASK)>>D3D11_SB_INPUT_CONTROL_POINT_COUNT_SHIFT))
// ENCODER MACRO: Store input control point count into a declaration token
#define ENCODE_D3D11_SB_INPUT_CONTROL_POINT_COUNT(Count) (((Count)<<D3D11_SB_INPUT_CONTROL_POINT_COUNT_SHIFT)&D3D11_SB_INPUT_CONTROL_POINT_COUNT_MASK)
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: HS Output Control Point Count
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT
// [16:11] Control point count
// [23:17] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
#define D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_MASK 0x0001f800
#define D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_SHIFT 11
// DECODER MACRO: Given an output control point count declaration token,
// (OpcodeToken0), determine the control point count
#define DECODE_D3D11_SB_OUTPUT_CONTROL_POINT_COUNT(OpcodeToken0) ((UINT)(((OpcodeToken0)&D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_MASK)>>D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_SHIFT))
// ENCODER MACRO: Store output control point count into a declaration token
#define ENCODE_D3D11_SB_OUTPUT_CONTROL_POINT_COUNT(Count) (((Count)<<D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_SHIFT)&D3D11_SB_OUTPUT_CONTROL_POINT_COUNT_MASK)
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: Tessellator Domain
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_TESS_DOMAIN
// [12:11] Domain
// [23:13] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
typedef enum D3D11_SB_TESSELLATOR_DOMAIN
{
D3D11_SB_TESSELLATOR_DOMAIN_UNDEFINED = 0,
D3D11_SB_TESSELLATOR_DOMAIN_ISOLINE = 1,
D3D11_SB_TESSELLATOR_DOMAIN_TRI = 2,
D3D11_SB_TESSELLATOR_DOMAIN_QUAD = 3
} D3D11_SB_TESSELLATOR_DOMAIN;
#define D3D11_SB_TESS_DOMAIN_MASK 0x00001800
#define D3D11_SB_TESS_DOMAIN_SHIFT 11
// DECODER MACRO: Given a tessellator domain declaration,
// (OpcodeToken0), determine the domain
// (D3D11_SB_TESSELLATOR_DOMAIN enum)
#define DECODE_D3D11_SB_TESS_DOMAIN(OpcodeToken0) ((D3D11_SB_TESSELLATOR_DOMAIN)(((OpcodeToken0)&D3D11_SB_TESS_DOMAIN_MASK)>>D3D11_SB_TESS_DOMAIN_SHIFT))
// ENCODER MACRO: Store tessellator domain
// (D3D11_SB_TESSELLATOR_DOMAIN enum) into a
// a tessellator domain declaration token (OpcodeToken0)
#define ENCODE_D3D11_SB_TESS_DOMAIN(Domain) (((Domain)<<D3D11_SB_TESS_DOMAIN_SHIFT)&D3D11_SB_TESS_DOMAIN_MASK)
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: Tessellator Partitioning
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_TESS_PARTITIONING
// [13:11] Partitioning
// [23:14] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
typedef enum D3D11_SB_TESSELLATOR_PARTITIONING
{
D3D11_SB_TESSELLATOR_PARTITIONING_UNDEFINED = 0,
D3D11_SB_TESSELLATOR_PARTITIONING_INTEGER = 1,
D3D11_SB_TESSELLATOR_PARTITIONING_POW2 = 2,
D3D11_SB_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3,
D3D11_SB_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4
} D3D11_SB_TESSELLATOR_PARTITIONING;
#define D3D11_SB_TESS_PARTITIONING_MASK 0x00003800
#define D3D11_SB_TESS_PARTITIONING_SHIFT 11
// DECODER MACRO: Given a tessellator partitioning declaration,
// (OpcodeToken0), determine the domain
// (D3D11_SB_TESSELLATOR_PARTITIONING enum)
#define DECODE_D3D11_SB_TESS_PARTITIONING(OpcodeToken0) ((D3D11_SB_TESSELLATOR_PARTITIONING)(((OpcodeToken0)&D3D11_SB_TESS_PARTITIONING_MASK)>>D3D11_SB_TESS_PARTITIONING_SHIFT))
// ENCODER MACRO: Store tessellator partitioning
// (D3D11_SB_TESSELLATOR_PARTITIONING enum) into a
// a tessellator partitioning declaration token (OpcodeToken0)
#define ENCODE_D3D11_SB_TESS_PARTITIONING(Partitioning) (((Partitioning)<<D3D11_SB_TESS_PARTITIONING_SHIFT)&D3D11_SB_TESS_PARTITIONING_MASK)
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: Tessellator Output Primitive
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE
// [13:11] Output Primitive
// [23:14] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token. == 1
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// ----------------------------------------------------------------------------
typedef enum D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE
{
D3D11_SB_TESSELLATOR_OUTPUT_UNDEFINED = 0,
D3D11_SB_TESSELLATOR_OUTPUT_POINT = 1,
D3D11_SB_TESSELLATOR_OUTPUT_LINE = 2,
D3D11_SB_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3,
D3D11_SB_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4
} D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE;
#define D3D11_SB_TESS_OUTPUT_PRIMITIVE_MASK 0x00003800
#define D3D11_SB_TESS_OUTPUT_PRIMITIVE_SHIFT 11
// DECODER MACRO: Given a tessellator output primitive declaration,
// (OpcodeToken0), determine the domain
// (D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE enum)
#define DECODE_D3D11_SB_TESS_OUTPUT_PRIMITIVE(OpcodeToken0) ((D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE)(((OpcodeToken0)&D3D11_SB_TESS_OUTPUT_PRIMITIVE_MASK)>>D3D11_SB_TESS_OUTPUT_PRIMITIVE_SHIFT))
// ENCODER MACRO: Store tessellator output primitive
// (D3D11_SB_TESSELLATOR_OUTPUT_PRIMITIVE enum) into a
// a tessellator output primitive declaration token (OpcodeToken0)
#define ENCODE_D3D11_SB_TESS_OUTPUT_PRIMITIVE(OutputPrimitive) (((OutputPrimitive)<<D3D11_SB_TESS_OUTPUT_PRIMITIVE_SHIFT)&D3D11_SB_TESS_OUTPUT_PRIMITIVE_MASK)
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: Hull Shader Max Tessfactor
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_HS_MAX_TESSFACTOR
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by a float32 representing the
// maximum TessFactor.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Hull Shader Declaration Phase: Hull Shader Fork Phase Instance Count
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by a UINT32 representing the
// number of instances of the current fork phase program to execute.
//
// ----------------------------------------------------------------------------
typedef enum D3D10_SB_INTERPOLATION_MODE
{
D3D10_SB_INTERPOLATION_UNDEFINED = 0,
D3D10_SB_INTERPOLATION_CONSTANT = 1,
D3D10_SB_INTERPOLATION_LINEAR = 2,
D3D10_SB_INTERPOLATION_LINEAR_CENTROID = 3,
D3D10_SB_INTERPOLATION_LINEAR_NOPERSPECTIVE = 4,
D3D10_SB_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID = 5,
D3D10_SB_INTERPOLATION_LINEAR_SAMPLE = 6, // DX10.1
D3D10_SB_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE = 7, // DX10.1
} D3D10_SB_INTERPOLATION_MODE;
// Keep PRIMITIVE_TOPOLOGY values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D10_SB_PRIMITIVE_TOPOLOGY
{
D3D10_SB_PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
D3D10_SB_PRIMITIVE_TOPOLOGY_POINTLIST = 1,
D3D10_SB_PRIMITIVE_TOPOLOGY_LINELIST = 2,
D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
// 6 is reserved for legacy triangle fans
// Adjacency values should be equal to (0x8 & non-adjacency):
D3D10_SB_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
} D3D10_SB_PRIMITIVE_TOPOLOGY;
typedef enum D3D10_SB_PRIMITIVE
{
D3D10_SB_PRIMITIVE_UNDEFINED = 0,
D3D10_SB_PRIMITIVE_POINT = 1,
D3D10_SB_PRIMITIVE_LINE = 2,
D3D10_SB_PRIMITIVE_TRIANGLE = 3,
// Adjacency values should be equal to (0x4 & non-adjacency):
D3D10_SB_PRIMITIVE_LINE_ADJ = 6,
D3D10_SB_PRIMITIVE_TRIANGLE_ADJ = 7,
D3D11_SB_PRIMITIVE_1_CONTROL_POINT_PATCH = 8,
D3D11_SB_PRIMITIVE_2_CONTROL_POINT_PATCH = 9,
D3D11_SB_PRIMITIVE_3_CONTROL_POINT_PATCH = 10,
D3D11_SB_PRIMITIVE_4_CONTROL_POINT_PATCH = 11,
D3D11_SB_PRIMITIVE_5_CONTROL_POINT_PATCH = 12,
D3D11_SB_PRIMITIVE_6_CONTROL_POINT_PATCH = 13,
D3D11_SB_PRIMITIVE_7_CONTROL_POINT_PATCH = 14,
D3D11_SB_PRIMITIVE_8_CONTROL_POINT_PATCH = 15,
D3D11_SB_PRIMITIVE_9_CONTROL_POINT_PATCH = 16,
D3D11_SB_PRIMITIVE_10_CONTROL_POINT_PATCH = 17,
D3D11_SB_PRIMITIVE_11_CONTROL_POINT_PATCH = 18,
D3D11_SB_PRIMITIVE_12_CONTROL_POINT_PATCH = 19,
D3D11_SB_PRIMITIVE_13_CONTROL_POINT_PATCH = 20,
D3D11_SB_PRIMITIVE_14_CONTROL_POINT_PATCH = 21,
D3D11_SB_PRIMITIVE_15_CONTROL_POINT_PATCH = 22,
D3D11_SB_PRIMITIVE_16_CONTROL_POINT_PATCH = 23,
D3D11_SB_PRIMITIVE_17_CONTROL_POINT_PATCH = 24,
D3D11_SB_PRIMITIVE_18_CONTROL_POINT_PATCH = 25,
D3D11_SB_PRIMITIVE_19_CONTROL_POINT_PATCH = 26,
D3D11_SB_PRIMITIVE_20_CONTROL_POINT_PATCH = 27,
D3D11_SB_PRIMITIVE_21_CONTROL_POINT_PATCH = 28,
D3D11_SB_PRIMITIVE_22_CONTROL_POINT_PATCH = 29,
D3D11_SB_PRIMITIVE_23_CONTROL_POINT_PATCH = 30,
D3D11_SB_PRIMITIVE_24_CONTROL_POINT_PATCH = 31,
D3D11_SB_PRIMITIVE_25_CONTROL_POINT_PATCH = 32,
D3D11_SB_PRIMITIVE_26_CONTROL_POINT_PATCH = 33,
D3D11_SB_PRIMITIVE_27_CONTROL_POINT_PATCH = 34,
D3D11_SB_PRIMITIVE_28_CONTROL_POINT_PATCH = 35,
D3D11_SB_PRIMITIVE_29_CONTROL_POINT_PATCH = 36,
D3D11_SB_PRIMITIVE_30_CONTROL_POINT_PATCH = 37,
D3D11_SB_PRIMITIVE_31_CONTROL_POINT_PATCH = 38,
D3D11_SB_PRIMITIVE_32_CONTROL_POINT_PATCH = 39,
} D3D10_SB_PRIMITIVE;
typedef enum D3D10_SB_COMPONENT_MASK
{
D3D10_SB_COMPONENT_MASK_X = 1,
D3D10_SB_COMPONENT_MASK_Y = 2,
D3D10_SB_COMPONENT_MASK_Z = 4,
D3D10_SB_COMPONENT_MASK_W = 8,
D3D10_SB_COMPONENT_MASK_R = 1,
D3D10_SB_COMPONENT_MASK_G = 2,
D3D10_SB_COMPONENT_MASK_B = 4,
D3D10_SB_COMPONENT_MASK_A = 8,
D3D10_SB_COMPONENT_MASK_ALL = 15,
} D3D10_SB_COMPONENT_MASK;
typedef enum D3D10_SB_NAME
{
D3D10_SB_NAME_UNDEFINED = 0,
D3D10_SB_NAME_POSITION = 1,
D3D10_SB_NAME_CLIP_DISTANCE = 2,
D3D10_SB_NAME_CULL_DISTANCE = 3,
D3D10_SB_NAME_RENDER_TARGET_ARRAY_INDEX = 4,
D3D10_SB_NAME_VIEWPORT_ARRAY_INDEX = 5,
D3D10_SB_NAME_VERTEX_ID = 6,
D3D10_SB_NAME_PRIMITIVE_ID = 7,
D3D10_SB_NAME_INSTANCE_ID = 8,
D3D10_SB_NAME_IS_FRONT_FACE = 9,
D3D10_SB_NAME_SAMPLE_INDEX = 10,
// The following are added for D3D11
D3D11_SB_NAME_FINAL_QUAD_U_EQ_0_EDGE_TESSFACTOR = 11,
D3D11_SB_NAME_FINAL_QUAD_V_EQ_0_EDGE_TESSFACTOR = 12,
D3D11_SB_NAME_FINAL_QUAD_U_EQ_1_EDGE_TESSFACTOR = 13,
D3D11_SB_NAME_FINAL_QUAD_V_EQ_1_EDGE_TESSFACTOR = 14,
D3D11_SB_NAME_FINAL_QUAD_U_INSIDE_TESSFACTOR = 15,
D3D11_SB_NAME_FINAL_QUAD_V_INSIDE_TESSFACTOR = 16,
D3D11_SB_NAME_FINAL_TRI_U_EQ_0_EDGE_TESSFACTOR = 17,
D3D11_SB_NAME_FINAL_TRI_V_EQ_0_EDGE_TESSFACTOR = 18,
D3D11_SB_NAME_FINAL_TRI_W_EQ_0_EDGE_TESSFACTOR = 19,
D3D11_SB_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 20,
D3D11_SB_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 21,
D3D11_SB_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 22,
} D3D10_SB_NAME;
typedef enum D3D10_SB_RESOURCE_DIMENSION
{
D3D10_SB_RESOURCE_DIMENSION_UNKNOWN = 0,
D3D10_SB_RESOURCE_DIMENSION_BUFFER = 1,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE1D = 2,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE2D = 3,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE2DMS = 4,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE3D = 5,
D3D10_SB_RESOURCE_DIMENSION_TEXTURECUBE = 6,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE1DARRAY = 7,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE2DARRAY = 8,
D3D10_SB_RESOURCE_DIMENSION_TEXTURE2DMSARRAY = 9,
D3D10_SB_RESOURCE_DIMENSION_TEXTURECUBEARRAY = 10,
D3D11_SB_RESOURCE_DIMENSION_RAW_BUFFER = 11,
D3D11_SB_RESOURCE_DIMENSION_STRUCTURED_BUFFER = 12,
} D3D10_SB_RESOURCE_DIMENSION;
typedef enum D3D10_SB_RESOURCE_RETURN_TYPE
{
D3D10_SB_RETURN_TYPE_UNORM = 1,
D3D10_SB_RETURN_TYPE_SNORM = 2,
D3D10_SB_RETURN_TYPE_SINT = 3,
D3D10_SB_RETURN_TYPE_UINT = 4,
D3D10_SB_RETURN_TYPE_FLOAT = 5,
D3D10_SB_RETURN_TYPE_MIXED = 6,
D3D11_SB_RETURN_TYPE_DOUBLE = 7,
D3D11_SB_RETURN_TYPE_CONTINUED = 8,
D3D11_SB_RETURN_TYPE_UNUSED = 9,
} D3D10_SB_RESOURCE_RETURN_TYPE;
typedef enum D3D10_SB_REGISTER_COMPONENT_TYPE
{
D3D10_SB_REGISTER_COMPONENT_UNKNOWN = 0,
D3D10_SB_REGISTER_COMPONENT_UINT32 = 1,
D3D10_SB_REGISTER_COMPONENT_SINT32 = 2,
D3D10_SB_REGISTER_COMPONENT_FLOAT32 = 3
} D3D10_SB_REGISTER_COMPONENT_TYPE;
typedef enum D3D10_SB_INSTRUCTION_RETURN_TYPE
{
D3D10_SB_INSTRUCTION_RETURN_FLOAT = 0,
D3D10_SB_INSTRUCTION_RETURN_UINT = 1
} D3D10_SB_INSTRUCTION_RETURN_TYPE;
#define D3D10_SB_INSTRUCTION_RETURN_TYPE_MASK 0x00001800
#define D3D10_SB_INSTRUCTION_RETURN_TYPE_SHIFT 11
// DECODER MACRO: For an OpcodeToken0 with the return type
// determine the return type.
#define DECODE_D3D10_SB_INSTRUCTION_RETURN_TYPE(OpcodeToken0) ((D3D10_SB_INSTRUCTION_RETURN_TYPE)(((OpcodeToken0)&D3D10_SB_INSTRUCTION_RETURN_TYPE_MASK)>>D3D10_SB_INSTRUCTION_RETURN_TYPE_SHIFT))
// ENCODER MACRO: Encode the return type for instructions
// in the opcode specific control range of OpcodeToken0
#define ENCODE_D3D10_SB_INSTRUCTION_RETURN_TYPE(ReturnType) (((ReturnType)<<D3D10_SB_INSTRUCTION_RETURN_TYPE_SHIFT)&D3D10_SB_INSTRUCTION_RETURN_TYPE_MASK)
// ----------------------------------------------------------------------------
// Interface function body Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_FUNCTION_BODY
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. If it is extended, then
// it contains the actual instruction length in DWORDs, since
// it may not fit into 7 bits if enough operands are defined.
//
// OpcodeToken0 is followed by a DWORD that represents the function body
// identifier.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Interface function table Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_FUNCTION_TABLE
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. If it is extended, then
// it contains the actual instruction length in DWORDs, since
// it may not fit into 7 bits if enough functions are defined.
//
// OpcodeToken0 is followed by a DWORD that represents the function table
// identifier and another DWORD (TableLength) that gives the number of
// functions in the table.
//
// This is followed by TableLength DWORDs which are function body indices.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Interface Declaration
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_DCL_INTERFACE
// [11] 1 if the interface is indexed dynamically, 0 otherwise.
// [23:12] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. If it is extended, then
// it contains the actual instruction length in DWORDs, since
// it may not fit into 7 bits if enough types are used.
//
// OpcodeToken0 is followed by a DWORD that represents the interface
// identifier. Next is a DWORD that gives the expected function table
// length. Then another DWORD (OpcodeToken3) with the following layout:
//
// [15:00] TableLength, the number of types that implement this interface
// [31:16] ArrayLength, the number of interfaces that are defined in this array.
//
// This is followed by TableLength DWORDs which are function table
// identifiers, representing possible tables for a given interface.
//
// ----------------------------------------------------------------------------
#define D3D11_SB_INTERFACE_INDEXED_BIT_MASK 0x00000800
#define D3D11_SB_INTERFACE_INDEXED_BIT_SHIFT 11
#define D3D11_SB_INTERFACE_TABLE_LENGTH_MASK 0x0000ffff
#define D3D11_SB_INTERFACE_TABLE_LENGTH_SHIFT 0
#define D3D11_SB_INTERFACE_ARRAY_LENGTH_MASK 0xffff0000
#define D3D11_SB_INTERFACE_ARRAY_LENGTH_SHIFT 16
// get/set the indexed bit for an interface definition
#define DECODE_D3D11_SB_INTERFACE_INDEXED_BIT(OpcodeToken0) ((((OpcodeToken0)&D3D11_SB_INTERFACE_INDEXED_BIT_MASK)>>D3D11_SB_INTERFACE_INDEXED_BIT_SHIFT) ? true : false)
#define ENCODE_D3D11_SB_INTERFACE_INDEXED_BIT(IndexedBit) (((IndexedBit)<<D3D11_SB_INTERFACE_INDEXED_BIT_SHIFT)&D3D11_SB_INTERFACE_INDEXED_BIT_MASK)
// get/set the table length for an interface definition
#define DECODE_D3D11_SB_INTERFACE_TABLE_LENGTH(OpcodeToken0) ((UINT)(((OpcodeToken0)&D3D11_SB_INTERFACE_TABLE_LENGTH_MASK)>>D3D11_SB_INTERFACE_TABLE_LENGTH_SHIFT))
#define ENCODE_D3D11_SB_INTERFACE_TABLE_LENGTH(TableLength) (((TableLength)<<D3D11_SB_INTERFACE_TABLE_LENGTH_SHIFT)&D3D11_SB_INTERFACE_TABLE_LENGTH_MASK)
// get/set the array length for an interface definition
#define DECODE_D3D11_SB_INTERFACE_ARRAY_LENGTH(OpcodeToken0) ((UINT)(((OpcodeToken0)&D3D11_SB_INTERFACE_ARRAY_LENGTH_MASK)>>D3D11_SB_INTERFACE_ARRAY_LENGTH_SHIFT))
#define ENCODE_D3D11_SB_INTERFACE_ARRAY_LENGTH(ArrayLength) (((ArrayLength)<<D3D11_SB_INTERFACE_ARRAY_LENGTH_SHIFT)&D3D11_SB_INTERFACE_ARRAY_LENGTH_MASK)
// ----------------------------------------------------------------------------
// Interface call
//
// OpcodeToken0:
//
// [10:00] D3D10_SB_OPCODE_INTERFACE_CALL
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. If it is extended, then
// it contains the actual instruction length in DWORDs, since
// it may not fit into 7 bits if enough types are used.
//
// OpcodeToken0 is followed by a DWORD that gives the function index to
// call in the function table specified for the given interface.
// Next is the interface operand.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Thread Group Declaration (Compute Shader)
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_THREAD_GROUP
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. If it is extended, then
// it contains the actual instruction length in DWORDs, since
// it may not fit into 7 bits if enough types are used.
//
// OpcodeToken0 is followed by 3 DWORDs, the Thread Group dimensions as UINT32:
// x, y, z
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Typed Unordered Access View Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED
// [15:11] D3D10_SB_RESOURCE_DIMENSION
// [16:16] D3D11_SB_GLOBALLY_COHERENT_ACCESS or 0 (LOCALLY_COHERENT)
// [17:17] D3D11_SB_RASTERIZER_ORDERED_ACCESS or 0
// [23:18] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands on Shader Models 4.0 through 5.0:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is being declared.
// (2) a Resource Return Type token (ResourceReturnTypeToken)
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (u<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of UAV's in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the u# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (u<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of uav within space (may be dynamically indexed)
// (2) a Resource Return Type token (ResourceReturnTypeToken)
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
// UAV access scope flags
#define D3D11_SB_GLOBALLY_COHERENT_ACCESS 0x00010000
#define D3D11_SB_ACCESS_COHERENCY_MASK 0x00010000
// DECODER MACRO: Retrieve flags for sync instruction from OpcodeToken0.
#define DECODE_D3D11_SB_ACCESS_COHERENCY_FLAGS(OperandToken0) ((OperandToken0)&D3D11_SB_ACCESS_COHERENCY_MASK)
// ENCODER MACRO: Given a set of sync instruciton flags, encode them in OpcodeToken0.
#define ENCODE_D3D11_SB_ACCESS_COHERENCY_FLAGS(Flags) ((Flags)&D3D11_SB_ACCESS_COHERENCY_MASK)
// Additional UAV access flags
#define D3D11_SB_RASTERIZER_ORDERED_ACCESS 0x00020000
// Resource flags mask. Use to retrieve all resource flags, including the order preserving counter.
#define D3D11_SB_RESOURCE_FLAGS_MASK (D3D11_SB_GLOBALLY_COHERENT_ACCESS|D3D11_SB_RASTERIZER_ORDERED_ACCESS|D3D11_SB_UAV_HAS_ORDER_PRESERVING_COUNTER)
// DECODER MACRO: Retrieve UAV access flags for from OpcodeToken0.
#define DECODE_D3D11_SB_RESOURCE_FLAGS(OperandToken0) ((OperandToken0)&D3D11_SB_RESOURCE_FLAGS_MASK)
// ENCODER MACRO: Given UAV access flags, encode them in OpcodeToken0.
#define ENCODE_D3D11_SB_RESOURCE_FLAGS(Flags) ((Flags)&D3D11_SB_RESOURCE_FLAGS_MASK)
// ----------------------------------------------------------------------------
// Raw Unordered Access View Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW
// [15:11] Ignored, 0
// [16:16] D3D11_SB_GLOBALLY_COHERENT_ACCESS or 0 (LOCALLY_COHERENT)
// [17:17] D3D11_SB_RASTERIZER_ORDERED_ACCESS or 0
// [23:18] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand on Shader Models 4.0 through 5.0:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is being declared.
//
// OpcodeToken0 is followed by 2 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (u<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of UAV's in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the u# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (u<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of uav within space (may be dynamically indexed)
// (2) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Structured Unordered Access View Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED
// [15:11] Ignored, 0
// [16:16] D3D11_SB_GLOBALLY_COHERENT_ACCESS or 0 (LOCALLY_COHERENT)
// [17:17] D3D11_SB_RASTERIZER_ORDERED_ACCESS or 0
// [22:18] Ignored, 0
// [23:23] D3D11_SB_UAV_HAS_ORDER_PRESERVING_COUNTER or 0
//
// The presence of this flag means that if a UAV is bound to the
// corresponding slot, it must have been created with
// D3D11_BUFFER_UAV_FLAG_COUNTER at the API. Also, the shader
// can contain either imm_atomic_alloc or _consume instructions
// operating on the given UAV.
//
// If this flag is not present, the shader can still contain
// either imm_atomic_alloc or imm_atomic_consume instructions for
// this UAV. But if such instructions are present in this case,
// and a UAV is bound corresponding slot, it must have been created
// with the D3D11_BUFFER_UAV_FLAG_APPEND flag at the API.
// Append buffers have a counter as well, but values returned
// to the shader are only valid for the lifetime of the shader
// invocation.
//
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is
// being declared.
// (2) a DWORD indicating UINT32 byte stride
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// u# register (D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (u<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of UAV's in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the u# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (u<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of uav within space (may be dynamically indexed)
// (2) a DWORD indicating UINT32 byte stride
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
// UAV flags
#define D3D11_SB_UAV_HAS_ORDER_PRESERVING_COUNTER 0x00800000
#define D3D11_SB_UAV_FLAGS_MASK 0x00800000
// DECODER MACRO: Retrieve flags about UAV from OpcodeToken0.
#define DECODE_D3D11_SB_UAV_FLAGS(OperandToken0) ((OperandToken0)&D3D11_SB_UAV_FLAGS_MASK)
// ENCODER MACRO: Given a set of UAV flags, encode them in OpcodeToken0.
#define ENCODE_D3D11_SB_UAV_FLAGS(Flags) ((Flags)&D3D11_SB_UAV_FLAGS_MASK)
// ----------------------------------------------------------------------------
// Raw Thread Group Shared Memory Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// g# register (D3D11_SB_OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY) is being declared.
// (2) a DWORD indicating the element count, # of 32-bit scalars..
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Structured Thread Group Shared Memory Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 3 operands:
// (1) an operand, starting with OperandToken0, defining which
// g# register (D3D11_SB_OPERAND_TYPE_THREAD_GROUP_SHARED_MEMORY) is
// being declared.
// (2) a DWORD indicating UINT32 struct byte stride
// (3) a DWORD indicating UINT32 struct count
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Raw Shader Resource View Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_RESOURCE_RAW
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 1 operand:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
//
// OpcodeToken0 is followed by 2 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (t<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of resources in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the t# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (t<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of resource within space (may be dynamically indexed)
// (2) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Structured Shader Resource View Declaration
//
// OpcodeToken0:
//
// [10:00] D3D11_SB_OPCODE_DCL_RESOURCE_STRUCTURED
// [23:11] Ignored, 0
// [30:24] Instruction length in DWORDs including the opcode token.
// [31] 0 normally. 1 if extended operand definition, meaning next DWORD
// contains extended operand description. This dcl is currently not
// extended.
//
// OpcodeToken0 is followed by 2 operands:
// (1) an operand, starting with OperandToken0, defining which
// g# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is
// being declared.
// (2) a DWORD indicating UINT32 struct byte stride
//
// OpcodeToken0 is followed by 3 operands on Shader Model 5.1 and later:
// (1) an operand, starting with OperandToken0, defining which
// t# register (D3D10_SB_OPERAND_TYPE_RESOURCE) is being declared.
// The indexing dimension for the register must be D3D10_SB_OPERAND_INDEX_DIMENSION_3D,
// and the meaning of the index dimensions are as follows: (t<id>[<lbound>:<ubound>])
// 1 <id>: variable ID being declared
// 2 <lbound>: the lower bound of the range of resources in the space
// 3 <ubound>: the upper bound (inclusive) of this range
// As opposed to when the t# is used in shader instructions, where the register
// must be D3D10_SB_OPERAND_INDEX_DIMENSION_2D, and the meaning of the index
// dimensions are as follows: (t<id>[<idx>]):
// 1 <id>: variable ID being used (matches dcl)
// 2 <idx>: absolute index of resource within space (may be dynamically indexed)
// (2) a DWORD indicating UINT32 struct byte stride
// (3) a DWORD indicating the space index.
//
// ----------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink