|
|
/**
|
|
|
* MojoShader; generate shader programs from bytecode of compiled
|
|
|
* Direct3D shaders.
|
|
|
*
|
|
|
* Please see the file LICENSE.txt in the source's root directory.
|
|
|
*
|
|
|
* This file written by Ryan C. Gordon.
|
|
|
*/
|
|
|
|
|
|
#define __MOJOSHADER_INTERNAL__ 1
|
|
|
#include "mojoshader_profile.h"
|
|
|
|
|
|
#pragma GCC visibility push(hidden)
|
|
|
|
|
|
#if SUPPORT_PROFILE_D3D
|
|
|
|
|
|
const char *make_D3D_srcarg_string_in_buf(Context *ctx,
|
|
|
const SourceArgInfo *arg,
|
|
|
char *buf, size_t buflen)
|
|
|
{
|
|
|
const char *premod_str = "";
|
|
|
const char *postmod_str = "";
|
|
|
switch (arg->src_mod)
|
|
|
{
|
|
|
case SRCMOD_NEGATE:
|
|
|
premod_str = "-";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_BIASNEGATE:
|
|
|
premod_str = "-";
|
|
|
// fall through.
|
|
|
case SRCMOD_BIAS:
|
|
|
postmod_str = "_bias";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_SIGNNEGATE:
|
|
|
premod_str = "-";
|
|
|
// fall through.
|
|
|
case SRCMOD_SIGN:
|
|
|
postmod_str = "_bx2";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_COMPLEMENT:
|
|
|
premod_str = "1-";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_X2NEGATE:
|
|
|
premod_str = "-";
|
|
|
// fall through.
|
|
|
case SRCMOD_X2:
|
|
|
postmod_str = "_x2";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_DZ:
|
|
|
postmod_str = "_dz";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_DW:
|
|
|
postmod_str = "_dw";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_ABSNEGATE:
|
|
|
premod_str = "-";
|
|
|
// fall through.
|
|
|
case SRCMOD_ABS:
|
|
|
postmod_str = "_abs";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_NOT:
|
|
|
premod_str = "!";
|
|
|
break;
|
|
|
|
|
|
case SRCMOD_NONE:
|
|
|
case SRCMOD_TOTAL:
|
|
|
break; // stop compiler whining.
|
|
|
} // switch
|
|
|
|
|
|
|
|
|
char regnum_str[16];
|
|
|
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype,
|
|
|
arg->regnum, regnum_str,
|
|
|
sizeof (regnum_str));
|
|
|
|
|
|
if (regtype_str == NULL)
|
|
|
{
|
|
|
fail(ctx, "Unknown source register type.");
|
|
|
*buf = '\0';
|
|
|
return buf;
|
|
|
} // if
|
|
|
|
|
|
const char *rel_lbracket = "";
|
|
|
const char *rel_rbracket = "";
|
|
|
char rel_swizzle[4] = { '\0' };
|
|
|
char rel_regnum_str[16] = { '\0' };
|
|
|
const char *rel_regtype_str = "";
|
|
|
if (arg->relative)
|
|
|
{
|
|
|
if (arg->relative_regtype == REG_TYPE_LOOP)
|
|
|
{
|
|
|
rel_swizzle[0] = '\0';
|
|
|
rel_swizzle[1] = '\0';
|
|
|
rel_swizzle[2] = '\0';
|
|
|
} // if
|
|
|
else
|
|
|
{
|
|
|
rel_swizzle[0] = '.';
|
|
|
rel_swizzle[1] = swizzle_channels[arg->relative_component];
|
|
|
rel_swizzle[2] = '\0';
|
|
|
} // else
|
|
|
|
|
|
rel_lbracket = "[";
|
|
|
rel_rbracket = "]";
|
|
|
rel_regtype_str = get_D3D_register_string(ctx, arg->relative_regtype,
|
|
|
arg->relative_regnum,
|
|
|
rel_regnum_str,
|
|
|
sizeof (rel_regnum_str));
|
|
|
|
|
|
if (regtype_str == NULL)
|
|
|
{
|
|
|
fail(ctx, "Unknown relative source register type.");
|
|
|
*buf = '\0';
|
|
|
return buf;
|
|
|
} // if
|
|
|
} // if
|
|
|
|
|
|
char swizzle_str[6];
|
|
|
size_t i = 0;
|
|
|
const int scalar = isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum);
|
|
|
if (!scalar && !no_swizzle(arg->swizzle))
|
|
|
{
|
|
|
swizzle_str[i++] = '.';
|
|
|
swizzle_str[i++] = swizzle_channels[arg->swizzle_x];
|
|
|
swizzle_str[i++] = swizzle_channels[arg->swizzle_y];
|
|
|
swizzle_str[i++] = swizzle_channels[arg->swizzle_z];
|
|
|
swizzle_str[i++] = swizzle_channels[arg->swizzle_w];
|
|
|
|
|
|
// .xyzz is the same as .xyz, .z is the same as .zzzz, etc.
|
|
|
while (swizzle_str[i-1] == swizzle_str[i-2])
|
|
|
i--;
|
|
|
} // if
|
|
|
swizzle_str[i] = '\0';
|
|
|
assert(i < sizeof (swizzle_str));
|
|
|
|
|
|
// !!! FIXME: c12[a0.x] actually needs to be c[a0.x + 12]
|
|
|
snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s%s",
|
|
|
premod_str, regtype_str, regnum_str, postmod_str,
|
|
|
rel_lbracket, rel_regtype_str, rel_regnum_str, rel_swizzle,
|
|
|
rel_rbracket, swizzle_str);
|
|
|
// !!! FIXME: make sure the scratch buffer was large enough.
|
|
|
return buf;
|
|
|
} // make_D3D_srcarg_string_in_buf
|
|
|
|
|
|
|
|
|
const char *make_D3D_destarg_string(Context *ctx, char *buf,
|
|
|
const size_t buflen)
|
|
|
{
|
|
|
const DestArgInfo *arg = &ctx->dest_arg;
|
|
|
|
|
|
const char *result_shift_str = "";
|
|
|
switch (arg->result_shift)
|
|
|
{
|
|
|
case 0x1: result_shift_str = "_x2"; break;
|
|
|
case 0x2: result_shift_str = "_x4"; break;
|
|
|
case 0x3: result_shift_str = "_x8"; break;
|
|
|
case 0xD: result_shift_str = "_d8"; break;
|
|
|
case 0xE: result_shift_str = "_d4"; break;
|
|
|
case 0xF: result_shift_str = "_d2"; break;
|
|
|
} // switch
|
|
|
|
|
|
const char *sat_str = (arg->result_mod & MOD_SATURATE) ? "_sat" : "";
|
|
|
const char *pp_str = (arg->result_mod & MOD_PP) ? "_pp" : "";
|
|
|
const char *cent_str = (arg->result_mod & MOD_CENTROID) ? "_centroid" : "";
|
|
|
|
|
|
char regnum_str[16];
|
|
|
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype,
|
|
|
arg->regnum, regnum_str,
|
|
|
sizeof (regnum_str));
|
|
|
if (regtype_str == NULL)
|
|
|
{
|
|
|
fail(ctx, "Unknown destination register type.");
|
|
|
*buf = '\0';
|
|
|
return buf;
|
|
|
} // if
|
|
|
|
|
|
char writemask_str[6];
|
|
|
size_t i = 0;
|
|
|
const int scalar = isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum);
|
|
|
if (!scalar && !writemask_xyzw(arg->writemask))
|
|
|
{
|
|
|
writemask_str[i++] = '.';
|
|
|
if (arg->writemask0) writemask_str[i++] = 'x';
|
|
|
if (arg->writemask1) writemask_str[i++] = 'y';
|
|
|
if (arg->writemask2) writemask_str[i++] = 'z';
|
|
|
if (arg->writemask3) writemask_str[i++] = 'w';
|
|
|
} // if
|
|
|
writemask_str[i] = '\0';
|
|
|
assert(i < sizeof (writemask_str));
|
|
|
|
|
|
const char *pred_left = "";
|
|
|
const char *pred_right = "";
|
|
|
char pred[32] = { '\0' };
|
|
|
if (ctx->predicated)
|
|
|
{
|
|
|
pred_left = "(";
|
|
|
pred_right = ") ";
|
|
|
make_D3D_srcarg_string_in_buf(ctx, &ctx->predicate_arg,
|
|
|
pred, sizeof (pred));
|
|
|
} // if
|
|
|
|
|
|
// may turn out something like "_x2_sat_pp_centroid (!p0.x) r0.xyzw" ...
|
|
|
snprintf(buf, buflen, "%s%s%s%s %s%s%s%s%s%s",
|
|
|
result_shift_str, sat_str, pp_str, cent_str,
|
|
|
pred_left, pred, pred_right,
|
|
|
regtype_str, regnum_str, writemask_str);
|
|
|
// !!! FIXME: make sure the scratch buffer was large enough.
|
|
|
return buf;
|
|
|
} // make_D3D_destarg_string
|
|
|
|
|
|
|
|
|
const char *make_D3D_srcarg_string(Context *ctx, const size_t idx,
|
|
|
char *buf, size_t buflen)
|
|
|
{
|
|
|
if (idx >= STATICARRAYLEN(ctx->source_args))
|
|
|
{
|
|
|
fail(ctx, "Too many source args");
|
|
|
*buf = '\0';
|
|
|
return buf;
|
|
|
} // if
|
|
|
|
|
|
const SourceArgInfo *arg = &ctx->source_args[idx];
|
|
|
return make_D3D_srcarg_string_in_buf(ctx, arg, buf, buflen);
|
|
|
} // make_D3D_srcarg_string
|
|
|
|
|
|
const char *get_D3D_const_array_varname(Context *ctx, int base, int size)
|
|
|
{
|
|
|
char buf[64];
|
|
|
snprintf(buf, sizeof (buf), "c_array_%d_%d", base, size);
|
|
|
return StrDup(ctx, buf);
|
|
|
} // get_D3D_const_array_varname
|
|
|
|
|
|
|
|
|
void emit_D3D_start(Context *ctx, const char *profilestr)
|
|
|
{
|
|
|
const uint major = (uint) ctx->major_ver;
|
|
|
const uint minor = (uint) ctx->minor_ver;
|
|
|
char minor_str[16];
|
|
|
|
|
|
ctx->ignores_ctab = 1;
|
|
|
|
|
|
if (minor == 0xFF)
|
|
|
strcpy(minor_str, "sw");
|
|
|
else if ((major > 1) && (minor == 1))
|
|
|
strcpy(minor_str, "x"); // for >= SM2, apparently this is "x". Weird.
|
|
|
else
|
|
|
snprintf(minor_str, sizeof (minor_str), "%u", (uint) minor);
|
|
|
|
|
|
output_line(ctx, "%s_%u_%s", ctx->shader_type_str, major, minor_str);
|
|
|
} // emit_D3D_start
|
|
|
|
|
|
|
|
|
void emit_D3D_end(Context *ctx)
|
|
|
{
|
|
|
output_line(ctx, "end");
|
|
|
} // emit_D3D_end
|
|
|
|
|
|
|
|
|
void emit_D3D_phase(Context *ctx)
|
|
|
{
|
|
|
output_line(ctx, "phase");
|
|
|
} // emit_D3D_phase
|
|
|
|
|
|
|
|
|
void emit_D3D_finalize(Context *ctx)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_finalize
|
|
|
|
|
|
|
|
|
void emit_D3D_global(Context *ctx, RegisterType regtype, int regnum)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_global
|
|
|
|
|
|
|
|
|
void emit_D3D_array(Context *ctx, VariableList *var)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_array
|
|
|
|
|
|
|
|
|
void emit_D3D_const_array(Context *ctx, const ConstantsList *clist,
|
|
|
int base, int size)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_const_array
|
|
|
|
|
|
|
|
|
void emit_D3D_uniform(Context *ctx, RegisterType regtype, int regnum,
|
|
|
const VariableList *var)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_uniform
|
|
|
|
|
|
|
|
|
void emit_D3D_sampler(Context *ctx, int s, TextureType ttype, int tb)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_sampler
|
|
|
|
|
|
|
|
|
void emit_D3D_attribute(Context *ctx, RegisterType regtype, int regnum,
|
|
|
MOJOSHADER_usage usage, int index, int wmask,
|
|
|
int flags)
|
|
|
{
|
|
|
// no-op.
|
|
|
} // emit_D3D_attribute
|
|
|
|
|
|
|
|
|
void emit_D3D_RESERVED(Context *ctx)
|
|
|
{
|
|
|
// do nothing; fails in the state machine.
|
|
|
} // emit_D3D_RESERVED
|
|
|
|
|
|
|
|
|
// Generic D3D opcode emitters. A list of macros generate all the entry points
|
|
|
// that call into these...
|
|
|
|
|
|
char *lowercase(char *dst, const char *src)
|
|
|
{
|
|
|
int i = 0;
|
|
|
do
|
|
|
{
|
|
|
const char ch = src[i];
|
|
|
dst[i] = (((ch >= 'A') && (ch <= 'Z')) ? (ch - ('A' - 'a')) : ch);
|
|
|
} while (src[i++]);
|
|
|
return dst;
|
|
|
} // lowercase
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_d(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char dst[64]; make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s%s", ctx->coissue ? "+" : "", opcode, dst);
|
|
|
} // emit_D3D_opcode_d
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_s(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s %s", ctx->coissue ? "+" : "", opcode, src0);
|
|
|
} // emit_D3D_opcode_s
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_ss(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
char src1[64]; make_D3D_srcarg_string(ctx, 1, src1, sizeof (src1));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s %s, %s", ctx->coissue ? "+" : "", opcode, src0, src1);
|
|
|
} // emit_D3D_opcode_ss
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_ds(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char dst[64]; make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s%s, %s", ctx->coissue ? "+" : "", opcode, dst, src0);
|
|
|
} // emit_D3D_opcode_ds
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_dss(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char dst[64]; make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
char src1[64]; make_D3D_srcarg_string(ctx, 1, src1, sizeof (src1));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s%s, %s, %s", ctx->coissue ? "+" : "",
|
|
|
opcode, dst, src0, src1);
|
|
|
} // emit_D3D_opcode_dss
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_dsss(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char dst[64]; make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
char src1[64]; make_D3D_srcarg_string(ctx, 1, src1, sizeof (src1));
|
|
|
char src2[64]; make_D3D_srcarg_string(ctx, 2, src2, sizeof (src2));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s%s, %s, %s, %s", ctx->coissue ? "+" : "",
|
|
|
opcode, dst, src0, src1, src2);
|
|
|
} // emit_D3D_opcode_dsss
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode_dssss(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
char dst[64]; make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
char src0[64]; make_D3D_srcarg_string(ctx, 0, src0, sizeof (src0));
|
|
|
char src1[64]; make_D3D_srcarg_string(ctx, 1, src1, sizeof (src1));
|
|
|
char src2[64]; make_D3D_srcarg_string(ctx, 2, src2, sizeof (src2));
|
|
|
char src3[64]; make_D3D_srcarg_string(ctx, 3, src3, sizeof (src3));
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx,"%s%s%s, %s, %s, %s, %s", ctx->coissue ? "+" : "",
|
|
|
opcode, dst, src0, src1, src2, src3);
|
|
|
} // emit_D3D_opcode_dssss
|
|
|
|
|
|
|
|
|
void emit_D3D_opcode(Context *ctx, const char *opcode)
|
|
|
{
|
|
|
opcode = lowercase((char *) alloca(strlen(opcode) + 1), opcode);
|
|
|
output_line(ctx, "%s%s", ctx->coissue ? "+" : "", opcode);
|
|
|
} // emit_D3D_opcode
|
|
|
|
|
|
|
|
|
#define EMIT_D3D_OPCODE_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_D_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_d(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_S_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_s(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_SS_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_ss(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_DS_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_ds(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_DSS_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_dss(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_DSSS_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_dsss(ctx, #op); \
|
|
|
}
|
|
|
#define EMIT_D3D_OPCODE_DSSSS_FUNC(op) \
|
|
|
void emit_D3D_##op(Context *ctx) { \
|
|
|
emit_D3D_opcode_dssss(ctx, #op); \
|
|
|
}
|
|
|
|
|
|
EMIT_D3D_OPCODE_FUNC(NOP)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(MOV)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(ADD)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(SUB)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(MAD)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(MUL)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(RCP)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(RSQ)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(DP3)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(DP4)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(MIN)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(MAX)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(SLT)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(SGE)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(EXP)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(LOG)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(LIT)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(DST)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(LRP)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(FRC)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(M4X4)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(M4X3)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(M3X4)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(M3X3)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(M3X2)
|
|
|
EMIT_D3D_OPCODE_S_FUNC(CALL)
|
|
|
EMIT_D3D_OPCODE_SS_FUNC(CALLNZ)
|
|
|
EMIT_D3D_OPCODE_SS_FUNC(LOOP)
|
|
|
EMIT_D3D_OPCODE_FUNC(RET)
|
|
|
EMIT_D3D_OPCODE_FUNC(ENDLOOP)
|
|
|
EMIT_D3D_OPCODE_S_FUNC(LABEL)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(POW)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(CRS)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(SGN)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(ABS)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(NRM)
|
|
|
EMIT_D3D_OPCODE_S_FUNC(REP)
|
|
|
EMIT_D3D_OPCODE_FUNC(ENDREP)
|
|
|
EMIT_D3D_OPCODE_S_FUNC(IF)
|
|
|
EMIT_D3D_OPCODE_FUNC(ELSE)
|
|
|
EMIT_D3D_OPCODE_FUNC(ENDIF)
|
|
|
EMIT_D3D_OPCODE_FUNC(BREAK)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(MOVA)
|
|
|
EMIT_D3D_OPCODE_D_FUNC(TEXKILL)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXBEM)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXBEML)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2AR)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2GB)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2PAD)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2TEX)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3PAD)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3TEX)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(TEXM3X3SPEC)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3VSPEC)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(EXPP)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(LOGP)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(CND)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2RGB)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3TEX)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2DEPTH)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3)
|
|
|
EMIT_D3D_OPCODE_D_FUNC(TEXDEPTH)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(CMP)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(BEM)
|
|
|
EMIT_D3D_OPCODE_DSSS_FUNC(DP2ADD)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(DSX)
|
|
|
EMIT_D3D_OPCODE_DS_FUNC(DSY)
|
|
|
EMIT_D3D_OPCODE_DSSSS_FUNC(TEXLDD)
|
|
|
EMIT_D3D_OPCODE_DSS_FUNC(TEXLDL)
|
|
|
EMIT_D3D_OPCODE_S_FUNC(BREAKP)
|
|
|
|
|
|
// special cases for comparison opcodes...
|
|
|
const char *get_D3D_comparison_string(Context *ctx)
|
|
|
{
|
|
|
const char *comps[] = {
|
|
|
"", "_gt", "_eq", "_ge", "_lt", "_ne", "_le"
|
|
|
};
|
|
|
|
|
|
if (ctx->instruction_controls >= STATICARRAYLEN(comps))
|
|
|
{
|
|
|
fail(ctx, "unknown comparison control");
|
|
|
return "";
|
|
|
} // if
|
|
|
|
|
|
return comps[ctx->instruction_controls];
|
|
|
} // get_D3D_comparison_string
|
|
|
|
|
|
void emit_D3D_BREAKC(Context *ctx)
|
|
|
{
|
|
|
char op[16];
|
|
|
snprintf(op, sizeof (op), "break%s", get_D3D_comparison_string(ctx));
|
|
|
emit_D3D_opcode_ss(ctx, op);
|
|
|
} // emit_D3D_BREAKC
|
|
|
|
|
|
void emit_D3D_IFC(Context *ctx)
|
|
|
{
|
|
|
char op[16];
|
|
|
snprintf(op, sizeof (op), "if%s", get_D3D_comparison_string(ctx));
|
|
|
emit_D3D_opcode_ss(ctx, op);
|
|
|
} // emit_D3D_IFC
|
|
|
|
|
|
void emit_D3D_SETP(Context *ctx)
|
|
|
{
|
|
|
char op[16];
|
|
|
snprintf(op, sizeof (op), "setp%s", get_D3D_comparison_string(ctx));
|
|
|
emit_D3D_opcode_dss(ctx, op);
|
|
|
} // emit_D3D_SETP
|
|
|
|
|
|
void emit_D3D_DEF(Context *ctx)
|
|
|
{
|
|
|
char dst[64];
|
|
|
make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
const float *val = (const float *) ctx->dwords; // !!! FIXME: could be int?
|
|
|
char val0[32];
|
|
|
char val1[32];
|
|
|
char val2[32];
|
|
|
char val3[32];
|
|
|
floatstr(ctx, val0, sizeof (val0), val[0], 0);
|
|
|
floatstr(ctx, val1, sizeof (val1), val[1], 0);
|
|
|
floatstr(ctx, val2, sizeof (val2), val[2], 0);
|
|
|
floatstr(ctx, val3, sizeof (val3), val[3], 0);
|
|
|
output_line(ctx, "def%s, %s, %s, %s, %s", dst, val0, val1, val2, val3);
|
|
|
} // emit_D3D_DEF
|
|
|
|
|
|
void emit_D3D_DEFI(Context *ctx)
|
|
|
{
|
|
|
char dst[64];
|
|
|
make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
const int32 *x = (const int32 *) ctx->dwords;
|
|
|
output_line(ctx, "defi%s, %d, %d, %d, %d", dst,
|
|
|
(int) x[0], (int) x[1], (int) x[2], (int) x[3]);
|
|
|
} // emit_D3D_DEFI
|
|
|
|
|
|
void emit_D3D_DEFB(Context *ctx)
|
|
|
{
|
|
|
char dst[64];
|
|
|
make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
output_line(ctx, "defb%s, %s", dst, ctx->dwords[0] ? "true" : "false");
|
|
|
} // emit_D3D_DEFB
|
|
|
|
|
|
|
|
|
static const char *usagestrs[] = {
|
|
|
"_position", "_blendweight", "_blendindices", "_normal", "_psize",
|
|
|
"_texcoord", "_tangent", "_binormal", "_tessfactor", "_positiont",
|
|
|
"_color", "_fog", "_depth", "_sample"
|
|
|
};
|
|
|
|
|
|
void emit_D3D_DCL(Context *ctx)
|
|
|
{
|
|
|
char dst[64];
|
|
|
make_D3D_destarg_string(ctx, dst, sizeof (dst));
|
|
|
const DestArgInfo *arg = &ctx->dest_arg;
|
|
|
const char *usage_str = "";
|
|
|
char index_str[16] = { '\0' };
|
|
|
|
|
|
if (arg->regtype == REG_TYPE_SAMPLER)
|
|
|
{
|
|
|
switch ((const TextureType) ctx->dwords[0])
|
|
|
{
|
|
|
case TEXTURE_TYPE_2D: usage_str = "_2d"; break;
|
|
|
case TEXTURE_TYPE_CUBE: usage_str = "_cube"; break;
|
|
|
case TEXTURE_TYPE_VOLUME: usage_str = "_volume"; break;
|
|
|
default: fail(ctx, "unknown sampler texture type"); return;
|
|
|
} // switch
|
|
|
} // if
|
|
|
|
|
|
else if (arg->regtype == REG_TYPE_MISCTYPE)
|
|
|
{
|
|
|
switch ((const MiscTypeType) arg->regnum)
|
|
|
{
|
|
|
case MISCTYPE_TYPE_POSITION:
|
|
|
case MISCTYPE_TYPE_FACE:
|
|
|
usage_str = ""; // just become "dcl vFace" or whatever.
|
|
|
break;
|
|
|
default: fail(ctx, "unknown misc register type"); return;
|
|
|
} // switch
|
|
|
} // else if
|
|
|
|
|
|
else
|
|
|
{
|
|
|
const uint32 usage = ctx->dwords[0];
|
|
|
const uint32 index = ctx->dwords[1];
|
|
|
usage_str = usagestrs[usage];
|
|
|
if (index != 0)
|
|
|
snprintf(index_str, sizeof (index_str), "%u", (uint) index);
|
|
|
} // else
|
|
|
|
|
|
output_line(ctx, "dcl%s%s%s", usage_str, index_str, dst);
|
|
|
} // emit_D3D_DCL
|
|
|
|
|
|
|
|
|
void emit_D3D_TEXCRD(Context *ctx)
|
|
|
{
|
|
|
// this opcode looks and acts differently depending on the shader model.
|
|
|
if (shader_version_atleast(ctx, 1, 4))
|
|
|
emit_D3D_opcode_ds(ctx, "texcrd");
|
|
|
else
|
|
|
emit_D3D_opcode_d(ctx, "texcoord");
|
|
|
} // emit_D3D_TEXCOORD
|
|
|
|
|
|
void emit_D3D_TEXLD(Context *ctx)
|
|
|
{
|
|
|
// this opcode looks and acts differently depending on the shader model.
|
|
|
if (shader_version_atleast(ctx, 2, 0))
|
|
|
{
|
|
|
if (ctx->instruction_controls == CONTROL_TEXLD)
|
|
|
emit_D3D_opcode_dss(ctx, "texld");
|
|
|
else if (ctx->instruction_controls == CONTROL_TEXLDP)
|
|
|
emit_D3D_opcode_dss(ctx, "texldp");
|
|
|
else if (ctx->instruction_controls == CONTROL_TEXLDB)
|
|
|
emit_D3D_opcode_dss(ctx, "texldb");
|
|
|
} // if
|
|
|
|
|
|
else if (shader_version_atleast(ctx, 1, 4))
|
|
|
{
|
|
|
emit_D3D_opcode_ds(ctx, "texld");
|
|
|
} // else if
|
|
|
|
|
|
else
|
|
|
{
|
|
|
emit_D3D_opcode_d(ctx, "tex");
|
|
|
} // else
|
|
|
} // emit_D3D_TEXLD
|
|
|
|
|
|
void emit_D3D_SINCOS(Context *ctx)
|
|
|
{
|
|
|
// this opcode needs extra registers for sm2 and lower.
|
|
|
if (!shader_version_atleast(ctx, 3, 0))
|
|
|
emit_D3D_opcode_dsss(ctx, "sincos");
|
|
|
else
|
|
|
emit_D3D_opcode_ds(ctx, "sincos");
|
|
|
} // emit_D3D_SINCOS
|
|
|
|
|
|
#endif // SUPPORT_PROFILE_D3D
|
|
|
|
|
|
#pragma GCC visibility pop
|
|
|
|
