mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-24 15:46:49 +03:00
567 lines
11 KiB
C++
567 lines
11 KiB
C++
|
|
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;
|
|
}
|
|
*/
|