| 0,0 → 1,566 |
|---|
| |
| typedef unsigned int u32_t; |
| |
| |
| typedef enum |
| { |
| VS_OUT_POS = 0, |
| VS_OUT_PSIZE, |
| VS_OUT_COL0, |
| VS_OUT_COL1, |
| VS_OUT_COL2, |
| VS_OUT_COL3, |
| VS_OUT_TEX0, |
| VS_OUT_TEX1, |
| VS_OUT_TEX2, |
| VS_OUT_TEX3, |
| VS_OUT_TEX4, |
| VS_OUT_TEX5, |
| VS_OUT_TEX6, |
| VS_OUT_TEX7, |
| VS_OUT_FOG, |
| VS_OUT_MAX = 0xFFFFFFFF |
| }v_out_t; |
| |
| |
| #if 0 |
| vs_1_1 |
| |
| dcl_position v0 |
| dcl_color v1 |
| dcl_color1 v2 |
| dcl_fog v3 |
| dcl_psize v4 |
| dcl_texcoord v5 |
| dcl_texcoord1 v6 |
| |
| mov oPos, v0 |
| |
| mov oD0, v1 |
| mov oD1, v2 |
| |
| mov oFog, v3.x |
| mov oPts, v4.x |
| mov oT0, v5 |
| mov oT1, v6 |
| |
| #endif |
| |
| const u32_t vs11[] = |
| { |
| 0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000001f, 0x8000000a, |
| 0x900f0001, 0x0000001f, 0x8001000a, 0x900f0002, 0x0000001f, 0x8000000b, |
| 0x900f0003, 0x0000001f, 0x80000004, 0x900f0004, 0x0000001f, 0x80000005, |
| 0x900f0005, 0x0000001f, 0x80010005, 0x900f0006, 0x00000001, 0xc00f0000, |
| 0x90e40000, 0x00000001, 0xd00f0000, 0x90e40001, 0x00000001, 0xd00f0001, |
| 0x90e40002, 0x00000001, 0xc00f0001, 0x90000003, 0x00000001, 0xc00f0002, |
| 0x90000004, 0x00000001, 0xe00f0000, 0x90e40005, 0x00000001, 0xe00f0001, |
| 0x90e40006, 0x0000ffff |
| }; |
| |
| char *sz_vs_command[] = |
| { |
| "nop", |
| "mov", |
| "add", |
| "sub", |
| "mad", |
| "mul", |
| "rcp", |
| "rsq", |
| "dp3", |
| "dp4", |
| "min", |
| "max", |
| "slt", |
| "sge", |
| "exp", |
| "log", |
| "lit", |
| "dst", |
| "lrp", |
| "frc", |
| "m4x4", |
| "m4x3", |
| "m3x4", |
| "m3x3", |
| "m3x2", |
| }; |
| |
| /* |
| char *sz_ps_command[] = |
| { |
| texcoord |
| texkill |
| tex |
| texbem |
| texbeml |
| texreg2ar |
| texreg2gb |
| texm3x2pad |
| texm3x3tex |
| texm3x3pad |
| texm3x3tex |
| texm3x3diff |
| texm3x3spec |
| texm3x3vspec |
| expp |
| logp |
| cnd |
| def |
| texreg2rgb |
| texdp3tex |
| texm3x2depth |
| texdp3 |
| texm3x3 |
| texdepth |
| cmp |
| bem |
| } |
| */ |
| |
| char *szusage[]= |
| { |
| "position", |
| "blendweight", |
| "blendindices", |
| "normal", |
| "psize", |
| "texcoord", |
| "tangent", |
| "binormal", |
| "tessfactor", |
| "positiont", |
| "color", |
| "fog", |
| "depth", |
| "sample" |
| }; |
| char *sztype[]= |
| { |
| "r", |
| "v", |
| "c" |
| "a", |
| "t", |
| "rasout", |
| "attrout", |
| "texcrdout", |
| "output", |
| "constint", |
| "colorout", |
| "depthout", |
| "sampler", |
| "const2", |
| "const3", |
| "const4", |
| "constbool", |
| "loop", |
| "tempfloat16", |
| "misctype", |
| "label", |
| "predicate" |
| }; |
| |
| |
| typedef struct |
| { |
| u32_t minor: 8; |
| u32_t major: 8; |
| u32_t type :16; |
| }version_t; |
| |
| typedef struct |
| { |
| u32_t type:5; |
| u32_t rsv :11; |
| u32_t ind :4; |
| u32_t rsv2:11; |
| u32_t sign:1; |
| }usage_t; |
| |
| typedef struct |
| { |
| u32_t ind :11; |
| u32_t typeh :2; |
| u32_t rsv :3; |
| u32_t wr :4; |
| u32_t mod :4; |
| u32_t scale :4; |
| u32_t typel :3; |
| u32_t sign :1; |
| }dst_t; |
| |
| typedef struct |
| { |
| u32_t ind :11; |
| u32_t rsv :5; |
| u32_t swzl :8; |
| u32_t mod :4; |
| u32_t typel :3; |
| u32_t sign :1; |
| }src_t; |
| |
| |
| int parse_vs(const u32_t *stream); |
| |
| static void assign_outputs(); |
| |
| int translate_vs(const u32_t *stream); |
| |
| |
| u32_t vs_out_written; |
| u32_t inp_mask; |
| |
| u32_t vs_outputs[16]; |
| |
| int main() |
| { |
| version_t *ver; |
| |
| ver = (version_t*)vs11; |
| |
| if(ver->type == 0xFFFE) |
| { |
| printf("vs_%d_%d\n\n",ver->major,ver->minor); |
| if( parse_vs(vs11+1) ) |
| translate_vs(vs11+1); |
| }; |
| |
| return 0; |
| }; |
| |
| static char txt_swzl[4] = {'x','y','z','w'}; |
| static char *txt_mod[2] = { "","_sat"}; |
| |
| int parse_vs(const u32_t *stream) |
| { |
| dst_t *dst; |
| src_t *src; |
| |
| u32_t swzl; |
| u32_t wr; |
| |
| char szswzl[5]; |
| char szwm[5]; |
| |
| int i,j; |
| |
| while(1) |
| { |
| op_type_t instr = *stream++ & 0xFFFF; |
| |
| switch( instr ) |
| { |
| case D3DSIO_MOV: |
| dst = (dst_t*)stream++; |
| src = (src_t*)stream++; |
| |
| swzl = src->swzl; |
| wr = dst->wr; |
| |
| for(i=0,j=0; i < 4; i++) |
| { |
| szswzl[i] = txt_swzl[swzl&3]; |
| swzl>>=2; |
| if(wr & (1<<i)) |
| szwm[j++] = txt_swzl[i]; |
| }; |
| szswzl[4] = 0; |
| szwm[j] = 0; |
| |
| switch(dst->typel) |
| { |
| case 4: // Rasterizer Register File |
| if(dst->ind == 0) |
| vs_out_written |= (1 << VS_OUT_POS); |
| else if (dst->ind == 1) |
| vs_out_written |= (1 << VS_OUT_FOG); |
| else if (dst->ind == 2) |
| vs_out_written |= (1 << VS_OUT_PSIZE); |
| else |
| printf("invalid raster register %d",dst->ind); |
| break; |
| |
| case 5: // Attribute Output Register File |
| if(dst->ind == 0) |
| vs_out_written |= (1 << VS_OUT_COL0); |
| else if (dst->ind == 1) |
| vs_out_written |= (1 << VS_OUT_COL1); |
| else |
| printf("invalid attribute register %d",dst->ind); |
| break; |
| |
| case 6: // Texture Coordinate Output Register File |
| if(dst->ind < 8) |
| vs_out_written |= (1 << (VS_OUT_TEX0+dst->ind)); |
| else |
| printf("invalid texture register %d",dst->ind); |
| }; |
| printf("%s%s %s%d.%s,\t %s%d.%s\n",sz_vs_command[instr],txt_mod[dst->mod], |
| sztype[dst->typel],dst->ind,szwm, |
| sztype[src->typel],src->ind,szswzl); |
| break; |
| |
| case D3DSIO_DCL: |
| parse_dcl(stream); |
| stream+=2; |
| break; |
| case 0xFFFF: |
| return 1; |
| |
| default: |
| return 0; |
| }; |
| }; |
| }; |
| |
| |
| int parse_dcl(const u32_t *stream) |
| { |
| usage_t *usage; |
| dst_t *dst; |
| int dsttype; |
| char szwm[5]; |
| int i; |
| u32_t wr; |
| |
| usage = (usage_t*)stream++; |
| dst = (dst_t*)stream++; |
| dsttype = (dst->typeh << 4) | dst->typel; |
| wr = dst->wr; |
| |
| for(i=0; wr; i++, wr>>=1) |
| { |
| if(wr & 1) |
| szwm[i] = txt_swzl[i]; |
| }; |
| szwm[i] = 0; |
| |
| printf("dcl_%s%d \t\t %s%d.%s\n",szusage[usage->type],usage->ind, |
| sztype[dsttype],dst->ind, szwm); |
| |
| return 2; |
| } |
| |
| |
| |
| int translate_dcl(const u32_t *stream); |
| int translate_mov(const u32_t *stream); |
| |
| int translate_vs(const u32_t *stream) |
| { |
| assign_outputs(); |
| |
| while(1) |
| { |
| op_type_t instr = *stream++ & 0xFFFF; |
| |
| switch( instr ) |
| { |
| case D3DSIO_MOV: |
| translate_mov(stream); |
| stream+=2; |
| break; |
| case D3DSIO_DCL: |
| translate_dcl(stream); |
| stream+=2; |
| break; |
| case 0xFFFF: |
| return 1; |
| |
| default: |
| return 0; |
| }; |
| }; |
| }; |
| |
| |
| int translate_dcl(const u32_t *stream) |
| { |
| |
| |
| |
| return 1; |
| }; |
| |
| u32_t inst[4]; |
| |
| #include "r300_vertprog.h" |
| |
| /** |
| * Swizzle indexes. |
| * Do not change! |
| */ |
| /*@{*/ |
| #define SWIZZLE_X 0 |
| #define SWIZZLE_Y 1 |
| #define SWIZZLE_Z 2 |
| #define SWIZZLE_W 3 |
| #define SWIZZLE_ZERO 4 /**< For SWZ instruction only */ |
| #define SWIZZLE_ONE 5 /**< For SWZ instruction only */ |
| #define SWIZZLE_NIL 7 /**< used during shader code gen (undefined value) */ |
| /*@}*/ |
| |
| #define __CONST(x, y) \ |
| (PVS_SRC_OPERAND(t_src_index(vp, &src[x]), \ |
| t_swizzle(y), \ |
| t_swizzle(y), \ |
| t_swizzle(y), \ |
| t_swizzle(y), \ |
| t_src_class(src[x].File), \ |
| VSF_FLAG_NONE) | (src[x].RelAddr << 4)) |
| |
| static unsigned long t_swizzle(u32_t swizzle) |
| { |
| /* this is in fact a NOP as the Mesa SWIZZLE_* are all identical to VSF_IN_COMPONENT_* */ |
| return swizzle; |
| } |
| |
| static unsigned long t_dst_mask(u32_t mask) |
| { |
| /* WRITEMASK_* is equivalent to VSF_FLAG_* */ |
| return mask & VSF_FLAG_ALL; |
| } |
| |
| static unsigned long t_dst_class(int file) |
| { |
| |
| switch (file) { |
| case 0: //D3DSPR_TEMP |
| return PVS_DST_REG_TEMPORARY; |
| case 3: //D3DSPR_ADDR |
| return PVS_DST_REG_A0; |
| case 4: //D3DSPR_RASTOUT |
| case 5: |
| case 6: //D3DSPR_TEXCRDOUT |
| return PVS_DST_REG_OUT; |
| |
| /* |
| case PROGRAM_INPUT: |
| case PROGRAM_LOCAL_PARAM: |
| case PROGRAM_ENV_PARAM: |
| case PROGRAM_NAMED_PARAM: |
| case PROGRAM_STATE_VAR: |
| case PROGRAM_WRITE_ONLY: |
| case PROGRAM_ADDRESS: |
| */ |
| default: |
| printf("problem in %s", __FUNCTION__); |
| return -1; |
| } |
| } |
| |
| static unsigned long t_dst_index(dst_t *dst) |
| { |
| switch(dst->typel) |
| { |
| case 4: |
| if(dst->ind == 0) |
| return vs_outputs[VS_OUT_POS]; |
| else if (dst->ind == 1) |
| return vs_outputs[VS_OUT_FOG]; |
| else if (dst->ind == 2) |
| return vs_outputs[VS_OUT_PSIZE]; |
| break; |
| case 5: |
| if(dst->ind == 0) |
| return vs_outputs[VS_OUT_COL0]; |
| else if (dst->ind == 1) |
| return vs_outputs[VS_OUT_COL1]; |
| |
| case 6: |
| return vs_outputs[VS_OUT_TEX0+dst->ind]; |
| |
| default: |
| return dst->ind; |
| } |
| } |
| |
| |
| static void assign_outputs() |
| { |
| int i; |
| int cur_reg = 0; |
| |
| for (i = 0; i < 16; i++) |
| vs_outputs[i] = -1; |
| |
| // assert(vs_out_written & (1 << VS_OUT_POS)); |
| |
| if (vs_out_written & (1 << VS_OUT_POS)) { |
| vs_outputs[VS_OUT_POS] = cur_reg++; |
| } |
| |
| if (vs_out_written & (1 << VS_OUT_PSIZE)) { |
| vs_outputs[VS_OUT_PSIZE] = cur_reg++; |
| } |
| |
| if (vs_out_written & (1 << VS_OUT_COL0)) { |
| vs_outputs[VS_OUT_COL0] = cur_reg++; |
| } |
| |
| if (vs_out_written & (1 << VS_OUT_COL1)) { |
| vs_outputs[VS_OUT_COL1] = vs_outputs[VS_OUT_COL0] + 1; // ??? |
| cur_reg = vs_outputs[VS_OUT_COL1] + 1; |
| } |
| |
| #if 0 |
| if (vp->key.OutputsWritten & (1 << VERT_RESULT_FOGC)) { //fog must be in |
| vp->outputs[VERT_RESULT_FOGC] = cur_reg++; //one of the color regs |
| } |
| #endif |
| |
| for (i = VS_OUT_TEX0; i <= VS_OUT_TEX7; i++) { |
| if (vs_out_written & (1 << i)) { |
| vs_outputs[i] = cur_reg++; |
| } |
| } |
| } |
| |
| |
| int translate_mov(const u32_t *stream) |
| { |
| |
| dst_t *dst = (dst_t*)stream++; |
| src_t *src = (src_t*)stream++; |
| |
| int swzl = src->swzl; |
| int wr = dst->wr; |
| |
| |
| inst[0] = PVS_OP_DST_OPERAND(VE_ADD, |
| 0, |
| 0, |
| t_dst_index(dst), |
| (dst->wr), |
| t_dst_class(dst->typel)); |
| |
| //inst[1] = t_src(vp, &src[0]); |
| // inst[2] = __CONST(0, SWIZZLE_ZERO); |
| //inst[3] = __CONST(0, SWIZZLE_ZERO); |
| printf("inst_0 %x\n", inst[0]); |
| return 1; |
| } |
| |
| /* |
| static GLuint *r300TranslateOpcodeMOV(struct r300_vertex_program *vp, |
| struct prog_instruction *vpi, |
| GLuint * inst, |
| struct prog_src_register src[3]) |
| { |
| //ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO} |
| |
| inst[0] = PVS_OP_DST_OPERAND(VE_ADD, |
| GL_FALSE, |
| GL_FALSE, |
| t_dst_index(vp, &vpi->DstReg), |
| t_dst_mask(vpi->DstReg.WriteMask), |
| t_dst_class(vpi->DstReg.File)); |
| inst[1] = t_src(vp, &src[0]); |
| inst[2] = __CONST(0, SWIZZLE_ZERO); |
| inst[3] = __CONST(0, SWIZZLE_ZERO); |
| |
| return inst; |
| } |
| */ |