#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. // // ----------------------------------------------------------------------------