diff options
Diffstat (limited to 'Runtime/GfxDevice/d3d11/D3D11ByteCode.h')
| -rw-r--r-- | Runtime/GfxDevice/d3d11/D3D11ByteCode.h | 856 |
1 files changed, 856 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/d3d11/D3D11ByteCode.h b/Runtime/GfxDevice/d3d11/D3D11ByteCode.h new file mode 100644 index 0000000..020a8c1 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/D3D11ByteCode.h @@ -0,0 +1,856 @@ +#pragma once + +#include "Runtime/Utilities/dynamic_array.h" + +struct _D3D11_SIGNATURE_PARAMETER_DESC; +typedef struct _D3D11_SIGNATURE_PARAMETER_DESC D3D11_SIGNATURE_PARAMETER_DESC; + + + +#define MAKE_FOURCC(a, b, c, d) ((UInt32)(UInt8)(a) | ((UInt32)(UInt8)(b) << 8) | ((UInt32)(UInt8)(c) << 16) | ((UInt32)(UInt8)(d) << 24 )) +#define kFOURCC_DXBC MAKE_FOURCC('D', 'X', 'B', 'C') + +// Reflection or debug information? stripped shaders don't have this chunk +#define kFOURCC_RDEF MAKE_FOURCC('R', 'D', 'E', 'F') +// Shader input signature +#define kFOURCC_ISGN MAKE_FOURCC('I', 'S', 'G', 'N') +// Shader output signature +#define kFOURCC_OSGN MAKE_FOURCC('O', 'S', 'G', 'N') +// Shader code +#define kFOURCC_SHDR MAKE_FOURCC('S', 'H', 'D', 'R') +#define kFOURCC_SHEX MAKE_FOURCC('S', 'H', 'E', 'X') +// Statistics? stripped shaders don't have this chunk +#define kFOURCC_STAT MAKE_FOURCC('S', 'T', 'A', 'T') +// Patch information? +#define kFOURCC_PCSG MAKE_FOURCC('P', 'C', 'S', 'G') +//FL 9.x SM 2.0 shader magic signature +#define kFOURCC_SM20 MAKE_FOURCC('A', 'o', 'n', '9') + + +struct DXBCChunkHeader +{ + unsigned fourcc; + unsigned size; +}; + + +struct DXBCContainer +{ + const void* data; + dynamic_array<DXBCChunkHeader*> chunks; +}; + +struct DXBCSignatureElement +{ + UInt32 name_offset; + UInt32 semantic_index; + UInt32 system_value_type; + UInt32 component_type; + UInt32 register_num; + UInt8 mask; + UInt8 read_write_mask; + UInt8 stream; + UInt8 unused; +}; + +struct DXBCChunkSig : public DXBCChunkHeader +{ + UInt32 count; + UInt32 unk8; // always has 8? + DXBCSignatureElement elements[1]; +}; + +struct DXBCChunkCode : public DXBCChunkHeader +{ + UInt32 version; + UInt32 length; // length in dword tokens +}; + +struct DXBCChunkSM20 : public DXBCChunkHeader +{ + UInt32 length; // length in bytes +}; + + +struct SM4TokInstruction +{ + // not an union directly because unions can't be inherited from + union + { + UInt32 dword; + // length and extended are always present, but they are only here to reduce duplication + struct + { + unsigned opcode : 11; + unsigned _11_23 : 13; + unsigned length : 7; + unsigned extended : 1; + }; + struct + { + unsigned opcode : 11; + unsigned resinfo_return_type : 2; + unsigned sat : 1; + unsigned _14_17 : 4; + unsigned test_nz : 1; // bit 18 + unsigned precise_mask : 4; + unsigned _23 : 1; + unsigned length : 7; + unsigned extended : 1; + } insn; + struct + { + unsigned opcode : 11; + unsigned threads_in_group : 1; + unsigned shared_memory : 1; + unsigned uav_group : 1; + unsigned uav_global : 1; + unsigned _15_17 : 3; + } sync; + struct + { + unsigned opcode : 11; + unsigned allow_refactoring : 1; + unsigned fp64 : 1; + unsigned early_depth_stencil : 1; + unsigned enable_raw_and_structured_in_non_cs : 1; + } dcl_global_flags; + struct + { + unsigned opcode : 11; + unsigned target : 5; + unsigned nr_samples : 7; + } dcl_resource; + struct + { + unsigned opcode : 11; + unsigned shadow : 1; + unsigned mono : 1; + } dcl_sampler; + struct + { + unsigned opcode : 11; + unsigned interpolation : 5; + } dcl_input_ps; + struct + { + unsigned opcode : 11; + unsigned dynamic : 1; + } dcl_constant_buffer; + struct + { + unsigned opcode : 11; + unsigned primitive : 6; + } dcl_gs_input_primitive; + struct + { + unsigned opcode : 11; + unsigned primitive_topology : 7; + } dcl_gs_output_primitive_topology; + struct + { + unsigned opcode : 11; + unsigned control_points : 6; + } dcl_input_control_point_count; + struct + { + unsigned opcode : 11; + unsigned control_points : 6; + } dcl_output_control_point_count; + struct + { + unsigned opcode : 11; + unsigned domain : 3; /* D3D_TESSELLATOR_DOMAIN */ + } dcl_tess_domain; + struct + { + unsigned opcode : 11; + unsigned partitioning : 3; /* D3D_TESSELLATOR_PARTITIONING */ + } dcl_tess_partitioning; + struct + { + unsigned opcode : 11; + unsigned primitive : 3; /* D3D_TESSELLATOR_OUTPUT_PRIMITIVE */ + } dcl_tess_output_primitive; + }; +}; + +union SM4TokInstructionEx +{ + UInt32 dword; + struct + { + unsigned type : 6; + unsigned _6_30 : 25; + unsigned extended :1; + }; + struct + { + unsigned type : 6; + unsigned _6_8 : 3; + int offset_u : 4; + int offset_v : 4; + int offset_w : 4; + } sample_controls; + struct + { + unsigned type : 6; + unsigned target : 5; + } resource_target; + struct + { + unsigned type : 6; + unsigned x : 4; + unsigned y : 4; + unsigned z : 4; + unsigned w : 4; + } resource_return_type; +}; + +struct SM4TokOperand +{ + union { + UInt32 dword; + struct { + unsigned comps_enum : 2; /* sm4_operands_comps */ + unsigned mode : 2; /* SM4OperMode */ + unsigned sel : 8; + unsigned file : 8; /* SM4RegFile */ + unsigned num_indices : 2; + unsigned index0_repr : 3; /* SM4OperIndexRepr */ + unsigned index1_repr : 3; /* SM4OperIndexRepr */ + unsigned index2_repr : 3; /* SM4OperIndexRepr */ + unsigned extended : 1; + }; + }; +}; + +struct SM2TokInstruction +{ + union + { + UInt32 dword; + struct + { + unsigned opcode : 16; + unsigned specific : 8; + unsigned length : 4; + unsigned predicated : 1; + unsigned _res0 : 1; + unsigned _res1 : 1; + unsigned _res2 : 1; + }; + struct + { + unsigned minor : 8; + unsigned major : 8; + unsigned _magic : 16; + } version; + }; +}; + +struct SM2TokDst +{ + union { + UInt32 dword; + struct { + unsigned reg_num : 11; + unsigned reg_type34 : 2; + unsigned _res0 : 1; + unsigned _res1 : 2; + unsigned write_mask : 4; + unsigned res_mod : 4; + unsigned shift_scl : 4; + unsigned reg_type02 : 3; + unsigned _one : 1; + }; + }; +}; + +void dxbc_create(struct DXBCChunkHeader** chunks, unsigned num_chunks, dynamic_array<UInt8>& out); + + +DXBCContainer* dxbc_parse(const void* data, int size); +DXBCChunkHeader* dxbc_find_chunk(const void* data, int size, unsigned fourcc); +void dxbc_print(const DXBCContainer* dxbc); +int dxbc_parse_signature(const DXBCChunkSig* sig, D3D11_SIGNATURE_PARAMETER_DESC** params); + + +enum SM2Opcode +{ + kSM2Op_NOP = 0, + kSM2Op_MOV , + kSM2Op_ADD , + kSM2Op_SUB , + kSM2Op_MAD , + kSM2Op_MUL , + kSM2Op_RCP , + kSM2Op_RSQ , + kSM2Op_DP3 , + kSM2Op_DP4 , + kSM2Op_MIN , + kSM2Op_MAX , + kSM2Op_SLT , + kSM2Op_SGE , + kSM2Op_EXP , + kSM2Op_LOG , + kSM2Op_LIT , + kSM2Op_DST , + kSM2Op_LRP , + kSM2Op_FRC , + kSM2Op_M4x4 , + kSM2Op_M4x3 , + kSM2Op_M3x4 , + kSM2Op_M3x3 , + kSM2Op_M3x2 , + kSM2Op_CALL , + kSM2Op_CALLNZ , + kSM2Op_LOOP , + kSM2Op_RET , + kSM2Op_ENDLOOP , + kSM2Op_LABEL , + kSM2Op_DCL , + kSM2Op_POW , + kSM2Op_CRS , + kSM2Op_SGN , + kSM2Op_ABS , + kSM2Op_NRM , + kSM2Op_SINCOS , + kSM2Op_REP , + kSM2Op_ENDREP , + kSM2Op_IF , + kSM2Op_IFC , + kSM2Op_ELSE , + kSM2Op_ENDIF , + kSM2Op_BREAK , + kSM2Op_BREAKC , + kSM2Op_MOVA , + kSM2Op_DEFB , + kSM2Op_DEFI , + + kSM2Op_TEXCOORD = 64, + kSM2Op_TEXKILL , + kSM2Op_TEX , + kSM2Op_TEXBEM , + kSM2Op_TEXBEML , + kSM2Op_TEXREG2AR , + kSM2Op_TEXREG2GB , + kSM2Op_TEXM3x2PAD , + kSM2Op_TEXM3x2TEX , + kSM2Op_TEXM3x3PAD , + kSM2Op_TEXM3x3TEX , + kSM2Op_RESERVED0 , + kSM2Op_TEXM3x3SPEC , + kSM2Op_TEXM3x3VSPEC , + kSM2Op_EXPP , + kSM2Op_LOGP , + kSM2Op_CND , + kSM2Op_DEF , + kSM2Op_TEXREG2RGB , + kSM2Op_TEXDP3TEX , + kSM2Op_TEXM3x2DEPTH , + kSM2Op_TEXDP3 , + kSM2Op_TEXM3x3 , + kSM2Op_TEXDEPTH , + kSM2Op_CMP , + kSM2Op_BEM , + kSM2Op_DP2ADD , + kSM2Op_DSX , + kSM2Op_DSY , + kSM2Op_TEXLDD , + kSM2Op_SETP , + kSM2Op_TEXLDL , + kSM2Op_BREAKP , + + kSM2Op_PHASE = 0xFFFD, + kSM2Op_COMMENT = 0xFFFE, + kSM2Op_END = 0xFFFF, +}; + +enum SM4ShaderType +{ + kSM4Shader_Pixel, + kSM4Shader_Vertex, +}; + +enum SM4Opcode +{ + kSM4Op_ADD, + kSM4Op_AND, + kSM4Op_BREAK, + kSM4Op_BREAKC, + kSM4Op_CALL, + kSM4Op_CALLC, + kSM4Op_CASE, + kSM4Op_CONTINUE, + kSM4Op_CONTINUEC, + kSM4Op_CUT, + kSM4Op_DEFAULT, + kSM4Op_DERIV_RTX, + kSM4Op_DERIV_RTY, + kSM4Op_DISCARD, + kSM4Op_DIV, + kSM4Op_DP2, + kSM4Op_DP3, + kSM4Op_DP4, + kSM4Op_ELSE, + kSM4Op_EMIT, + kSM4Op_EMITTHENCUT, + kSM4Op_ENDIF, + kSM4Op_ENDLOOP, + kSM4Op_ENDSWITCH, + kSM4Op_EQ, + kSM4Op_EXP, + kSM4Op_FRC, + kSM4Op_FTOI, + kSM4Op_FTOU, + kSM4Op_GE, + kSM4Op_IADD, + kSM4Op_IF, + kSM4Op_IEQ, + kSM4Op_IGE, + kSM4Op_ILT, + kSM4Op_IMAD, + kSM4Op_IMAX, + kSM4Op_IMIN, + kSM4Op_IMUL, + kSM4Op_INE, + kSM4Op_INEG, + kSM4Op_ISHL, + kSM4Op_ISHR, + kSM4Op_ITOF, + kSM4Op_LABEL, + kSM4Op_LD, + kSM4Op_LD_MS, + kSM4Op_LOG, + kSM4Op_LOOP, + kSM4Op_LT, + kSM4Op_MAD, + kSM4Op_MIN, + kSM4Op_MAX, + kSM4Op_CUSTOMDATA, + kSM4Op_MOV, + kSM4Op_MOVC, + kSM4Op_MUL, + kSM4Op_NE, + kSM4Op_NOP, + kSM4Op_NOT, + kSM4Op_OR, + kSM4Op_RESINFO, + kSM4Op_RET, + kSM4Op_RETC, + kSM4Op_ROUND_NE, + kSM4Op_ROUND_NI, + kSM4Op_ROUND_PI, + kSM4Op_ROUND_Z, + kSM4Op_RSQ, + kSM4Op_SAMPLE, + kSM4Op_SAMPLE_C, + kSM4Op_SAMPLE_C_LZ, + kSM4Op_SAMPLE_L, + kSM4Op_SAMPLE_D, + kSM4Op_SAMPLE_B, + kSM4Op_SQRT, + kSM4Op_SWITCH, + kSM4Op_SINCOS, + kSM4Op_UDIV, + kSM4Op_ULT, + kSM4Op_UGE, + kSM4Op_UMUL, + kSM4Op_UMAD, + kSM4Op_UMAX, + kSM4Op_UMIN, + kSM4Op_USHR, + kSM4Op_UTOF, + kSM4Op_XOR, + kSM4Op_DCL_RESOURCE, + kSM4Op_DCL_CONSTANT_BUFFER, + kSM4Op_DCL_SAMPLER, + kSM4Op_DCL_INDEX_RANGE, + kSM4Op_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY, + kSM4Op_DCL_GS_INPUT_PRIMITIVE, + kSM4Op_DCL_MAX_OUTPUT_VERTEX_COUNT, + kSM4Op_DCL_INPUT, + kSM4Op_DCL_INPUT_SGV, + kSM4Op_DCL_INPUT_SIV, + kSM4Op_DCL_INPUT_PS, + kSM4Op_DCL_INPUT_PS_SGV, + kSM4Op_DCL_INPUT_PS_SIV, + kSM4Op_DCL_OUTPUT, + kSM4Op_DCL_OUTPUT_SGV, + kSM4Op_DCL_OUTPUT_SIV, + kSM4Op_DCL_TEMPS, + kSM4Op_DCL_INDEXABLE_TEMP, + kSM4Op_DCL_GLOBAL_FLAGS, + kSM4Op_D3D10_COUNT, + kSM4Op_LOD, + kSM4Op_GATHER4, + kSM4Op_SAMPLE_POS, + kSM4Op_SAMPLE_INFO, + kSM4Op_D3D10_1_COUNT, + kSM4Op_HS_DECLS, + kSM4Op_HS_CONTROL_POINT_PHASE, + kSM4Op_HS_FORK_PHASE, + kSM4Op_HS_JOIN_PHASE, + kSM4Op_EMIT_STREAM, + kSM4Op_CUT_STREAM, + kSM4Op_EMITTHENCUT_STREAM, + kSM4Op_INTERFACE_CALL, + kSM4Op_BUFINFO, + kSM4Op_DERIV_RTX_COARSE, + kSM4Op_DERIV_RTX_FINE, + kSM4Op_DERIV_RTY_COARSE, + kSM4Op_DERIV_RTY_FINE, + kSM4Op_GATHER4_C, + kSM4Op_GATHER4_PO, + kSM4Op_GATHER4_PO_C, + kSM4Op_RCP, + kSM4Op_F32TOF16, + kSM4Op_F16TOF32, + kSM4Op_UADDC, + kSM4Op_USUBB, + kSM4Op_COUNTBITS, + kSM4Op_FIRSTBIT_HI, + kSM4Op_FIRSTBIT_LO, + kSM4Op_FIRSTBIT_SHI, + kSM4Op_UBFE, + kSM4Op_IBFE, + kSM4Op_BFI, + kSM4Op_BFREV, + kSM4Op_SWAPC, + kSM4Op_DCL_STREAM, + kSM4Op_DCL_FUNCTION_BODY, + kSM4Op_DCL_FUNCTION_TABLE, + kSM4Op_DCL_INTERFACE, + kSM4Op_DCL_INPUT_CONTROL_POINT_COUNT, + kSM4Op_DCL_OUTPUT_CONTROL_POINT_COUNT, + kSM4Op_DCL_TESS_DOMAIN, + kSM4Op_DCL_TESS_PARTITIONING, + kSM4Op_DCL_TESS_OUTPUT_PRIMITIVE, + kSM4Op_DCL_HS_MAX_TESSFACTOR, + kSM4Op_DCL_HS_FORK_PHASE_INSTANCE_COUNT, + kSM4Op_DCL_HS_JOIN_PHASE_INSTANCE_COUNT, + kSM4Op_DCL_THREAD_GROUP, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_TYPED, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_RAW, + kSM4Op_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED, + kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_RAW, + kSM4Op_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED, + kSM4Op_DCL_RESOURCE_RAW, + kSM4Op_DCL_RESOURCE_STRUCTURED, + kSM4Op_LD_UAV_TYPED, + kSM4Op_STORE_UAV_TYPED, + kSM4Op_LD_RAW, + kSM4Op_STORE_RAW, + kSM4Op_LD_STRUCTURED, + kSM4Op_STORE_STRUCTURED, + kSM4Op_ATOMIC_AND, + kSM4Op_ATOMIC_OR, + kSM4Op_ATOMIC_XOR, + kSM4Op_ATOMIC_CMP_STORE, + kSM4Op_ATOMIC_IADD, + kSM4Op_ATOMIC_IMAX, + kSM4Op_ATOMIC_IMIN, + kSM4Op_ATOMIC_UMAX, + kSM4Op_ATOMIC_UMIN, + kSM4Op_IMM_ATOMIC_ALLOC, + kSM4Op_IMM_ATOMIC_CONSUME, + kSM4Op_IMM_ATOMIC_IADD, + kSM4Op_IMM_ATOMIC_AND, + kSM4Op_IMM_ATOMIC_OR, + kSM4Op_IMM_ATOMIC_XOR, + kSM4Op_IMM_ATOMIC_EXCH, + kSM4Op_IMM_ATOMIC_CMP_EXCH, + kSM4Op_IMM_ATOMIC_IMAX, + kSM4Op_IMM_ATOMIC_IMIN, + kSM4Op_IMM_ATOMIC_UMAX, + kSM4Op_IMM_ATOMIC_UMIN, + kSM4Op_SYNC, + kSM4Op_DADD, + kSM4Op_DMAX, + kSM4Op_DMIN, + kSM4Op_DMUL, + kSM4Op_DEQ, + kSM4Op_DGE, + kSM4Op_DLT, + kSM4Op_DNE, + kSM4Op_DMOV, + kSM4Op_DMOVC, + kSM4Op_DTOF, + kSM4Op_FTOD, + kSM4Op_EVAL_SNAPPED, + kSM4Op_EVAL_SAMPLE_INDEX, + kSM4Op_EVAL_CENTROID, + kSM4Op_DCL_GS_INSTANCE_COUNT, + kSM4Op_COUNT +}; + + +enum SM4Interpolation +{ + kSM4Interp_UNDEFINED, + kSM4Interp_CONSTANT, + kSM4Interp_LINEAR, + kSM4Interp_LINEAR_CENTROID, + kSM4Interp_LINEAR_NOPERSPECTIVE, + kSM4Interp_LINEAR_NOPERSPECTIVE_CENTROID, + kSM4Interp_LINEAR_SAMPLE, + kSM4Interp_LINEAR_NOPERSPECTIVE_SAMPLE, + kSM4Interp_COUNT +}; + + +enum SM4OperCompnum +{ + kSM4OperComp0, + kSM4OperComp1, + kSM4OperComp4, + kSM4OperCompN, + kSM4OperComp, + kSM4OperCompCOUNT +}; + +enum SM4OperMode +{ + SM4_OPERAND_MODE_MASK, + SM4_OPERAND_MODE_SWIZZLE, + SM4_OPERAND_MODE_SCALAR, + SM4_OPERAND_MODE_, + SM4_OPERAND_MODE_COUNT +}; + +enum SM4OperIndexRepr +{ + SM4_OPERAND_INDEX_REPR_IMM32, + SM4_OPERAND_INDEX_REPR_IMM64, + SM4_OPERAND_INDEX_REPR_REG, + SM4_OPERAND_INDEX_REPR_REG_IMM32, + SM4_OPERAND_INDEX_REPR_REG_IMM64, + SM4_OPERAND_INDEX_REPR_COUNT +}; + + +enum SM4RegFile +{ + kSM4File_TEMP, + kSM4File_INPUT, + kSM4File_OUTPUT, + kSM4File_INDEXABLE_TEMP, + kSM4File_IMMEDIATE32, + kSM4File_IMMEDIATE64, + kSM4File_SAMPLER, + kSM4File_RESOURCE, + kSM4File_CONSTANT_BUFFER, + kSM4File_IMMEDIATE_CONSTANT_BUFFER, + kSM4File_LABEL, + kSM4File_INPUT_PRIMITIVEID, + kSM4File_OUTPUT_DEPTH, + kSM4File_NULL, + kSM4File_RASTERIZER, + kSM4File_OUTPUT_COVERAGE_MASK, + kSM4File_STREAM, + kSM4File_FUNCTION_BODY, + kSM4File_FUNCTION_TABLE, + kSM4File_INTERFACE, + kSM4File_FUNCTION_INPUT, + kSM4File_FUNCTION_OUTPUT, + kSM4File_OUTPUT_CONTROL_POINT_ID, + kSM4File_INPUT_FORK_INSTANCE_ID, + kSM4File_INPUT_JOIN_INSTANCE_ID, + kSM4File_INPUT_CONTROL_POINT, + kSM4File_OUTPUT_CONTROL_POINT, + kSM4File_INPUT_PATCH_CONSTANT, + kSM4File_INPUT_DOMAIN_POINT, + kSM4File_THIS_POINTER, + kSM4File_UNORDERED_ACCESS_VIEW, + kSM4File_THREAD_GROUP_SHARED_MEMORY, + kSM4File_INPUT_THREAD_ID, + kSM4File_INPUT_THREAD_GROUP_ID, + kSM4File_INPUT_THREAD_ID_IN_GROUP, + kSM4File_INPUT_COVERAGE_MASK, + kSM4File_INPUT_THREAD_ID_IN_GROUP_FLATTENED, + kSM4File_INPUT_GS_INSTANCE_ID, + kSM4File_OUTPUT_DEPTH_GREATER_EQUAL, + kSM4File_OUTPUT_DEPTH_LESS_EQUAL, + kSM4File_CYCLE_COUNTER, + kSM4File_COUNT +}; + + +extern const char* kSM4OpcodeNames[kSM4Op_COUNT]; + + +enum SM4Swizzle { + kSM4SwzNone = 0xE4, // 11.10.01.00 + kSM4SwzRepX = 0x00, // 00.00.00.00 + kSM4SwzRepY = 0x55, // 01.01.01.01 + kSM4SwzRepZ = 0xAA, // 10.10.10.10 + kSM4SwzRepW = 0xFF, // 11.11.11.11 + kSM4SwzXYZZ = 0xA4, // 10.10.01.00 + kSM4SwzXYYY = 0x54, // 01.01.01.00 + kSM4SwzXYXX = 0x04, // 00.00.01.00 + kSM4SwzXYXY = 0x44, // 01.00.01.00 + kSM4SwzZWZW = 0xEE, // 11.10.11.10 + kSM4SwzZWWW = 0xFE, // 11.11.11.10 + kSM4SwzYYYZ = 0x95, // 10.01.01.01 + kSM4SwzXYZX = 0x24, // 00.10.01.00 + kSM4SwzXYZY = 0x64, // 01.10.01.00 + kSM4SwzYZWY = 0x79, // 01.11.10.01 +}; + +enum SM4Target +{ + kSM4Target_UNKNOWN, + kSM4Target_BUFFER, + kSM4Target_TEXTURE1D, + kSM4Target_TEXTURE2D, + kSM4Target_TEXTURE2DMS, + kSM4Target_TEXTURE3D, + kSM4Target_TEXTURECUBE, + kSM4Target_TEXTURE1DARRAY, + kSM4Target_TEXTURE2DARRAY, + kSM4Target_TEXTURE2DMSARRAY, + kSM4Target_TEXTURECUBEARRAY, + kSM4Target_RAW_BUFFER, + kSM4Target_STRUCTURED_BUFFER, + kSM4Target_COUNT +}; + + +struct DXBCBuilder; +DXBCBuilder* dxb_create(int major, int minor, SM4ShaderType type); +void dxb_destroy(DXBCBuilder* b); + + +struct DXBCCodeBuilder; +DXBCCodeBuilder* dxb_get_code_builder(DXBCBuilder* b); +DXBCCodeBuilder* dxb_create_code(dynamic_array<UInt32>& destArray); +void dxb_destroy_code(DXBCCodeBuilder* b); + +// result must be free()'d +void* dxb_build (DXBCBuilder* b, size_t& outSize); + +void dxb_dcl_input (DXBCBuilder* b, const char* name, int index, int reg, int mask = 0xF); +void dxb_dcl_output (DXBCBuilder* b, const char* name, int index, int reg, int mask = 0xF); +void dxb_dcl_tex (DXBCBuilder* b, int index, SM4Target dim); +void dxb_dcl_cb (DXBCBuilder* b, int index, int size); + +void dxb_op (DXBCCodeBuilder* b, SM4Opcode op, bool sat); +void dxb_reg (DXBCCodeBuilder* b, char rchar, int reg, unsigned mask = 0xF); +void dxb_swz (DXBCCodeBuilder* b, char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false); +void dxb_float1 (DXBCCodeBuilder* b, float v); +void dxb_int1 (DXBCCodeBuilder* b, int i); +void dxb_float4 (DXBCCodeBuilder* b, float v0, float v1, float v2, float v3); + +//------------------------------------------------------------------------------------ +//SM 2.0 stuff +void dxb_dcl_input2 (DXBCBuilder* b, const char* name, int index, int reg, int mask); +void dxb_dcl_output2 (DXBCBuilder* b, const char* name, int index, int reg, int mask); +void dxb_dcl_tex2 (DXBCBuilder* b, int index, SM4Target dim); +void dxb_op2 (DXBCBuilder* b, SM2Opcode op, bool sat, int scratchTmpRegForSat = -1); +void dxb_reg2 (DXBCBuilder* b, char rchar, int reg, unsigned mask = 0xF); +void dxb_swz2 (DXBCBuilder* b, char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false); +int dxb_imm_f4 (DXBCBuilder* b, float v0, float v1, float v2, float v3); +SM2Opcode dxb_to_sm2 (SM4Opcode op); + + +struct DXBCBuilderStream +{ + //no shader builder and no auto SM20 code for raw code works + DXBCBuilderStream (DXBCCodeBuilder* b) : builder(NULL), bldcode(b), noSM2(true) { } + DXBCBuilderStream (DXBCBuilder* b) : builder(b), bldcode(dxb_get_code_builder(b)), noSM2(false) { } + + DXBCBuilderStream& op(SM4Opcode op) + { + dxb_op(bldcode, op, false); + if (!noSM2 && builder) + dxb_op2(builder, dxb_to_sm2(op), false); + return *this; + } + DXBCBuilderStream& op_sat(SM4Opcode op, int scratchTmpRegForSM2) + { + dxb_op(bldcode, op, true); + if (!noSM2 && builder) + dxb_op2(builder, dxb_to_sm2(op), true, scratchTmpRegForSM2); + return *this; + } + DXBCBuilderStream& reg (char rchar, int reg, unsigned mask = 0xF) + { + dxb_reg(bldcode, rchar, reg, mask); + if (!noSM2 && builder) + dxb_reg2(builder, rchar, reg, mask); + return *this; + } + DXBCBuilderStream& swz (char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false) + { + dxb_swz(bldcode, rchar, reg, swiz, neg); + if (!noSM2 && builder) + dxb_swz2(builder, rchar, reg, swiz, neg); + return *this; + } + DXBCBuilderStream& float1 (float v) + { + dxb_float1(bldcode, v); + + if (!noSM2 && builder) + { + const int reg = dxb_imm_f4 (builder, v, v, v, v); + dxb_swz2(builder, 'c', reg, kSM4SwzRepX); + } + return *this; + } + // float1 constant for SM2 only + DXBCBuilderStream& float1_2 (float v) + { + if (builder) + { + const int reg = dxb_imm_f4 (builder, v, v, v, v); + dxb_swz2(builder, 'c', reg, kSM4SwzRepX); + } + return *this; + } + DXBCBuilderStream& float4 (float v0, float v1, float v2, float v3) + { + dxb_float4(bldcode, v0, v1, v2, v3); + + if (!noSM2 && builder) + { + const int reg = dxb_imm_f4 (builder, v0, v1, v2, v3); + dxb_swz2(builder, 'c', reg); + } + return *this; + } + + + //------------------------------------------------------------------------------------ + //SM 2.0 stuff + + DXBCBuilderStream& op2(SM2Opcode op) + { + dxb_op2(builder, op, false); + return *this; + } + DXBCBuilderStream& reg2 (char rchar, int reg, unsigned mask = 0xF) + { + dxb_reg2(builder, rchar, reg, mask); + return *this; + } + DXBCBuilderStream& swz2 (char rchar, int reg, unsigned swiz = kSM4SwzNone, bool neg=false) + { + dxb_swz2(builder, rchar, reg, swiz, neg); + return *this; + } + void noAutoSM2(bool _noSM2=true) + { + noSM2 = _noSM2; + } + void autoSM2() + { + noSM2 = false; + } + + DXBCBuilder* builder; + DXBCCodeBuilder* bldcode; + bool noSM2; +}; + |