Subversion Repositories Kolibri OS

{

    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;

    vs_1_1

    dcl_color      v1

    dcl_color1     v2

    dcl_fog        v3

    dcl_psize      v4

    dcl_texcoord   v5

    dcl_texcoord1  v6

    mov oD1,     v2

    mov oPts,    v4.x

    mov oT0,     v5

    mov oT1,     v6

{

    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

};

{

    "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

}

*/

{

   "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"

};

{

  u32_t minor: 8;

  u32_t major: 8;

  u32_t type :16;

}version_t;

{

  u32_t type:5;

  u32_t rsv :11;

  u32_t ind :4;

  u32_t rsv2:11;

  u32_t sign:1;

}usage_t;

{

  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;

{

  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;

u32_t  inp_mask;

{

    version_t *ver;

    {

        printf("vs_%d_%d\n\n",ver->major,ver->minor);

        if( parse_vs(vs11+1) )

            translate_vs(vs11+1);

    };

};

static char *txt_mod[2] = { "","_sat"};

{

  dst_t  *dst;

  src_t  *src;

  u32_t  wr;

  char   szwm[5];

  {

    op_type_t instr = *stream++ & 0xFFFF;

    {

      case D3DSIO_MOV:

        dst = (dst_t*)stream++;

        src = (src_t*)stream++;

        wr = dst->wr;

        {

           szswzl[i] = txt_swzl[swzl&3];

           swzl>>=2;

           if(wr & (1<

           szwm[j++] = txt_swzl[i];

        };

        szswzl[4] = 0;

        szwm[j] = 0;

        {

           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;

              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;

              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;

        parse_dcl(stream);

        stream+=2;

        break;

      case 0xFFFF:

        return 1;

        return 0;

    };

  };

};

{

  usage_t *usage;

  dst_t   *dst;

  int dsttype;

  char szwm[5];

  int i;

  u32_t wr;

  dst = (dst_t*)stream++;

  dsttype = (dst->typeh << 4) | dst->typel;

  wr = dst->wr;

  {

    if(wr & 1)

      szwm[i] = txt_swzl[i];

  };

  szwm[i] = 0;

         sztype[dsttype],dst->ind, szwm);

}

int translate_mov(const u32_t *stream);

{

  assign_outputs();

  {

    op_type_t instr = *stream++ & 0xFFFF;

    {

      case D3DSIO_MOV:

        translate_mov(stream);

        stream+=2;

        break;

      case D3DSIO_DCL:

        translate_dcl(stream);

        stream+=2;

        break;

      case 0xFFFF:

        return 1;

        return 0;

    };

  };

};

{

};

 * 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) */

/*@}*/

	(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))

{

/* this is in fact a NOP as the Mesa SWIZZLE_* are all identical to VSF_IN_COMPONENT_* */

	return swizzle;

}

{

	/* WRITEMASK_* is equivalent to VSF_FLAG_* */

	return mask & VSF_FLAG_ALL;

}

{

	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;

	}

}

{

  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];

        return vs_outputs[VS_OUT_TEX0+dst->ind];

      return dst->ind;

  }

}

{

	int i;

	int cur_reg = 0;

		vs_outputs[i] = -1;

		 vs_outputs[VS_OUT_POS] = cur_reg++;

	}

		 vs_outputs[VS_OUT_PSIZE] = cur_reg++;

	}

		 vs_outputs[VS_OUT_COL0] = cur_reg++;

	}

		 vs_outputs[VS_OUT_COL1] = vs_outputs[VS_OUT_COL0] + 1;           // ???

		 cur_reg = vs_outputs[VS_OUT_COL1] + 1;

	}

	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

		if (vs_out_written & (1 << i)) {

			  vs_outputs[i] = cur_reg++;

		}

	}

}

{

   src_t *src = (src_t*)stream++;

   int wr = dst->wr;

				     0,

				     0,

				     t_dst_index(dst),

				     (dst->wr),

				     t_dst_class(dst->typel));

//	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}

				     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);

}

 */

>