"coefdiv.x" /* 15 (d2) */
};
-static void shader_arb_get_write_mask(const SHADER_OPCODE_ARG *arg, const DWORD param, char *write_mask)
+static void shader_arb_get_write_mask(const struct wined3d_shader_instruction *ins,
+ const DWORD param, char *write_mask)
{
char *ptr = write_mask;
- char vshader = shader_is_vshader_version(arg->reg_maps->shader_version);
+ char vshader = shader_is_vshader_version(ins->reg_maps->shader_version);
if(vshader && shader_get_regtype(param) == WINED3DSPR_ADDR) {
*ptr++ = '.';
}
/* TODO: merge with pixel shader */
-static void vshader_program_add_param(const SHADER_OPCODE_ARG *arg, const DWORD param, BOOL is_input, char *hwLine)
+static void vshader_program_add_param(const struct wined3d_shader_instruction *ins,
+ const DWORD param, BOOL is_input, char *hwLine)
{
- IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) arg->shader;
+ IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)ins->shader;
/* oPos, oFog and oPts in D3D */
static const char * const hwrastout_reg_names[] = { "TMP_OUT", "result.fogcoord", "result.pointsize" };
if (!is_input) {
char write_mask[6];
- shader_arb_get_write_mask(arg, param, write_mask);
+ shader_arb_get_write_mask(ins, param, write_mask);
strcat(hwLine, write_mask);
} else {
char swizzle[6];
}
}
-static void shader_hw_sample(const SHADER_OPCODE_ARG *arg, DWORD sampler_idx, const char *dst_str,
- const char *coord_reg, BOOL projected, BOOL bias)
+static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD sampler_idx,
+ const char *dst_str, const char *coord_reg, BOOL projected, BOOL bias)
{
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
const char *tex_type;
- IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) arg->shader;
+ IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->shader;
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
switch(sampler_type) {
shader_addline(buffer, "TEX %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
}
- if(shader_is_pshader_version(arg->reg_maps->shader_version)) {
- IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) arg->shader;
- gen_color_correction(buffer, dst_str, arg->dst & WINED3DSP_WRITEMASK_ALL, "one", "coefmul.x",
+ if (shader_is_pshader_version(ins->reg_maps->shader_version))
+ {
+ IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *)ins->shader;
+ gen_color_correction(buffer, dst_str, ins->dst & WINED3DSP_WRITEMASK_ALL, "one", "coefmul.x",
ps->cur_args->color_fixup[sampler_idx]);
}
}
regstr, write_mask, regstr, shift_tab[shift]);
}
-static void pshader_hw_bem(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_bem(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
-
- SHADER_BUFFER* buffer = arg->buffer;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[2][50];
char dst_wmask[20];
- DWORD sampler_code = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_code = ins->dst & WINED3DSP_REGNUM_MASK;
BOOL has_bumpmat = FALSE;
int i;
}
}
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
strcat(dst_name, dst_wmask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name[0]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[1], 1, src_name[1]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[1], 1, src_name[1]);
if(has_bumpmat) {
/* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed */
}
}
-static void pshader_hw_cnd(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- BOOL sat = (arg->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
- DWORD shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = (ins->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = (ins->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
/* FIXME: support output modifiers */
/* Handle output register */
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
/* Generate input register names (with modifiers) */
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name[0]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[1], 1, src_name[1]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[2], 2, src_name[2]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[1], 1, src_name[1]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[2], 2, src_name[2]);
/* The coissue flag changes the semantic of the cnd instruction in <= 1.3 shaders */
- if (arg->reg_maps->shader_version <= WINED3DPS_VERSION(1, 3) && arg->coissue)
+ if (ins->reg_maps->shader_version <= WINED3DPS_VERSION(1, 3) && ins->coissue)
{
shader_addline(buffer, "MOV%s %s%s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask, src_name[1]);
} else {
pshader_gen_output_modifier_line(buffer, FALSE, dst_wmask, shift, dst_name);
}
-static void pshader_hw_cmp(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_cmp(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- DWORD shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (arg->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = (ins->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = (ins->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
/* FIXME: support output modifiers */
/* Handle output register */
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
/* Generate input register names (with modifiers) */
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name[0]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[1], 1, src_name[1]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[2], 2, src_name[2]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[1], 1, src_name[1]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[2], 2, src_name[2]);
shader_addline(buffer, "CMP%s %s%s, %s, %s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask,
src_name[0], src_name[2], src_name[1]);
/** Process the WINED3DSIO_DP2ADD instruction in ARB.
* dst = dot2(src0, src1) + src2 */
-static void pshader_hw_dp2add(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_dp2add(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_wmask[20];
char dst_name[50];
char src_name[3][50];
- DWORD shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (arg->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = (ins->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = (ins->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name[0]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[1], 1, src_name[1]);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[2], 2, src_name[2]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name[0]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[1], 1, src_name[1]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[2], 2, src_name[2]);
/* Emulate a DP2 with a DP3 and 0.0 */
shader_addline(buffer, "MOV TMP, %s;\n", src_name[0]);
}
/* Map the opcode 1-to-1 to the GL code */
-static void shader_hw_map2gl(const SHADER_OPCODE_ARG *arg)
+static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
{
- CONST SHADER_OPCODE* curOpcode = arg->opcode;
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD dst = arg->dst;
- const DWORD *src = arg->src;
+ CONST SHADER_OPCODE *curOpcode = ins->opcode;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD dst = ins->dst;
+ const DWORD *src = ins->src;
const char *instruction;
char arguments[256];
unsigned int i;
break;
}
- if (shader_is_pshader_version(arg->reg_maps->shader_version))
+ if (shader_is_pshader_version(ins->reg_maps->shader_version))
{
/* Output token related */
char output_rname[256];
/* Generate input register names (with modifiers) */
for (i = 1; i < curOpcode->num_params; ++i)
- pshader_gen_input_modifier_line(arg->shader, buffer, src[i-1], i-1, operands[i]);
+ pshader_gen_input_modifier_line(ins->shader, buffer, src[i-1], i-1, operands[i]);
/* Handle output register */
- pshader_get_register_name(arg->shader, dst, output_rname);
+ pshader_get_register_name(ins->shader, dst, output_rname);
strcpy(operands[0], output_rname);
- shader_arb_get_write_mask(arg, dst, output_wmask);
+ shader_arb_get_write_mask(ins, dst, output_wmask);
strcat(operands[0], output_wmask);
arguments[0] = '\0';
arguments[0] = '\0';
if (curOpcode->num_params > 0)
{
- vshader_program_add_param(arg, dst, FALSE, arguments);
+ vshader_program_add_param(ins, dst, FALSE, arguments);
for (i = 1; i < curOpcode->num_params; ++i)
{
strcat(arguments, ",");
- vshader_program_add_param(arg, src[i-1], TRUE, arguments);
+ vshader_program_add_param(ins, src[i-1], TRUE, arguments);
}
}
shader_addline(buffer, "%s%s;\n", instruction, arguments);
}
}
-static void shader_hw_mov(const SHADER_OPCODE_ARG *arg)
+static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
{
- IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl*)arg->shader;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
- if ((WINED3DSHADER_VERSION_MAJOR(arg->reg_maps->shader_version) == 1
- && !shader_is_pshader_version(arg->reg_maps->shader_version)
- && shader_get_regtype(arg->dst) == WINED3DSPR_ADDR)
- || arg->opcode->opcode == WINED3DSIO_MOVA)
+ if ((WINED3DSHADER_VERSION_MAJOR(ins->reg_maps->shader_version) == 1
+ && !shader_is_pshader_version(ins->reg_maps->shader_version)
+ && shader_get_regtype(ins->dst) == WINED3DSPR_ADDR)
+ || ins->opcode->opcode == WINED3DSIO_MOVA)
{
- SHADER_BUFFER *buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char src0_param[256];
- if (arg->opcode->opcode == WINED3DSIO_MOVA)
+ if (ins->opcode->opcode == WINED3DSIO_MOVA)
FIXME("mova should round\n");
src0_param[0] = '\0';
if (((IWineD3DVertexShaderImpl *)shader)->rel_offset)
{
- vshader_program_add_param(arg, arg->src[0], TRUE, src0_param);
+ vshader_program_add_param(ins, ins->src[0], TRUE, src0_param);
shader_addline(buffer, "ADD TMP.x, %s, helper_const.z;\n", src0_param);
shader_addline(buffer, "ARL A0.x, TMP.x;\n");
}
* with more than one component. Thus replicate the first source argument over all
* 4 components. For example, .xyzw -> .x (or better: .xxxx), .zwxy -> .z, etc)
*/
- DWORD parm = arg->src[0] & ~(WINED3DVS_SWIZZLE_MASK);
- if((arg->src[0] & WINED3DVS_X_W) == WINED3DVS_X_W)
+ DWORD parm = ins->src[0] & ~(WINED3DVS_SWIZZLE_MASK);
+ if((ins->src[0] & WINED3DVS_X_W) == WINED3DVS_X_W)
parm |= WINED3DVS_X_W | WINED3DVS_Y_W | WINED3DVS_Z_W | WINED3DVS_W_W;
- else if((arg->src[0] & WINED3DVS_X_Z) == WINED3DVS_X_Z)
+ else if((ins->src[0] & WINED3DVS_X_Z) == WINED3DVS_X_Z)
parm |= WINED3DVS_X_Z | WINED3DVS_Y_Z | WINED3DVS_Z_Z | WINED3DVS_W_Z;
- else if((arg->src[0] & WINED3DVS_X_Y) == WINED3DVS_X_Y)
+ else if((ins->src[0] & WINED3DVS_X_Y) == WINED3DVS_X_Y)
parm |= WINED3DVS_X_Y | WINED3DVS_Y_Y | WINED3DVS_Z_Y | WINED3DVS_W_Y;
- else if((arg->src[0] & WINED3DVS_X_X) == WINED3DVS_X_X)
+ else if((ins->src[0] & WINED3DVS_X_X) == WINED3DVS_X_X)
parm |= WINED3DVS_X_X | WINED3DVS_Y_X | WINED3DVS_Z_X | WINED3DVS_W_X;
- vshader_program_add_param(arg, parm, TRUE, src0_param);
+ vshader_program_add_param(ins, parm, TRUE, src0_param);
shader_addline(buffer, "ARL A0.x, %s;\n", src0_param);
}
}
else
{
- shader_hw_map2gl(arg);
+ shader_hw_map2gl(ins);
}
}
-static void pshader_hw_texkill(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
{
- DWORD shader_version = arg->reg_maps->shader_version;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD shader_version = ins->reg_maps->shader_version;
+ SHADER_BUFFER *buffer = ins->buffer;
char reg_dest[40];
/* No swizzles are allowed in d3d's texkill. PS 1.x ignores the 4th component as documented,
* but >= 2.0 honors it(undocumented, but tested by the d3d9 testsuit)
*/
- pshader_get_register_name(arg->shader, arg->dst, reg_dest);
+ pshader_get_register_name(ins->shader, ins->dst, reg_dest);
if (shader_version >= WINED3DPS_VERSION(2,0))
{
}
}
-static void pshader_hw_tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
- DWORD dst = arg->dst;
- const DWORD *src = arg->src;
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD shader_version = arg->reg_maps->shader_version;
+ DWORD dst = ins->dst;
+ const DWORD *src = ins->src;
+ SHADER_BUFFER* buffer = ins->buffer;
+ DWORD shader_version = ins->reg_maps->shader_version;
BOOL projected = FALSE, bias = FALSE;
char reg_dest[40];
/* All versions have a destination register */
reg_dest_code = dst & WINED3DSP_REGNUM_MASK;
- pshader_get_register_name(arg->shader, dst, reg_dest);
+ pshader_get_register_name(ins->shader, dst, reg_dest);
/* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */
if (shader_version < WINED3DPS_VERSION(1,4))
strcpy(reg_coord, reg_dest);
else
- pshader_gen_input_modifier_line(arg->shader, buffer, src[0], 0, reg_coord);
+ pshader_gen_input_modifier_line(ins->shader, buffer, src[0], 0, reg_coord);
/* 1.0-1.4: Use destination register number as texture code.
2.0+: Use provided sampler number as texure code. */
}
else if (shader_version < WINED3DPS_VERSION(2,0))
{
- DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
+ DWORD src_mod = ins->src[0] & WINED3DSP_SRCMOD_MASK;
if (src_mod == WINED3DSPSM_DZ) {
projected = TRUE;
} else if(src_mod == WINED3DSPSM_DW) {
projected = TRUE;
}
} else {
- if (arg->flags & WINED3DSI_TEXLD_PROJECT) projected = TRUE;
- if (arg->flags & WINED3DSI_TEXLD_BIAS) bias = TRUE;
+ if (ins->flags & WINED3DSI_TEXLD_PROJECT) projected = TRUE;
+ if (ins->flags & WINED3DSI_TEXLD_BIAS) bias = TRUE;
}
- shader_hw_sample(arg, reg_sampler_code, reg_dest, reg_coord, projected, bias);
+ shader_hw_sample(ins, reg_sampler_code, reg_dest, reg_coord, projected, bias);
}
-static void pshader_hw_texcoord(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
{
- DWORD dst = arg->dst;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD dst = ins->dst;
+ SHADER_BUFFER *buffer = ins->buffer;
char tmp[20];
- shader_arb_get_write_mask(arg, dst, tmp);
- if (arg->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
+ shader_arb_get_write_mask(ins, dst, tmp);
+ if (ins->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
{
DWORD reg = dst & WINED3DSP_REGNUM_MASK;
shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg);
DWORD reg1 = dst & WINED3DSP_REGNUM_MASK;
char reg_src[40];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, reg_src);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, reg_src);
shader_addline(buffer, "MOV R%u%s, %s;\n", reg1, tmp, reg_src);
}
}
-static void pshader_hw_texreg2ar(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texreg2ar(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ SHADER_BUFFER *buffer = ins->buffer;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD flags;
- DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD reg1 = ins->dst & WINED3DSP_REGNUM_MASK;
char dst_str[8];
char src_str[50];
sprintf(dst_str, "T%u", reg1);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_str);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_str);
shader_addline(buffer, "MOV TMP.x, %s.w;\n", src_str);
shader_addline(buffer, "MOV TMP.y, %s.x;\n", src_str);
flags = reg1 < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg1][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
- shader_hw_sample(arg, reg1, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg1, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
}
-static void pshader_hw_texreg2gb(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texreg2gb(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
- DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD reg1 = ins->dst & WINED3DSP_REGNUM_MASK;
char dst_str[8];
char src_str[50];
sprintf(dst_str, "T%u", reg1);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_str);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_str);
shader_addline(buffer, "MOV TMP.x, %s.y;\n", src_str);
shader_addline(buffer, "MOV TMP.y, %s.z;\n", src_str);
- shader_hw_sample(arg, reg1, dst_str, "TMP", FALSE, FALSE);
+ shader_hw_sample(ins, reg1, dst_str, "TMP", FALSE, FALSE);
}
-static void pshader_hw_texreg2rgb(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texreg2rgb(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD reg1 = ins->dst & WINED3DSP_REGNUM_MASK;
char dst_str[8];
char src_str[50];
sprintf(dst_str, "T%u", reg1);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_str);
- shader_hw_sample(arg, reg1, dst_str, src_str, FALSE, FALSE);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_str);
+ shader_hw_sample(ins, reg1, dst_str, src_str, FALSE, FALSE);
}
-static void pshader_hw_texbem(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texbem(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
BOOL has_bumpmat = FALSE;
BOOL has_luminance = FALSE;
int i;
- DWORD dst = arg->dst;
- DWORD src = arg->src[0] & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD dst = ins->dst;
+ DWORD src = ins->src[0] & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER* buffer = ins->buffer;
char reg_coord[40];
DWORD reg_dest_code;
/* All versions have a destination register */
reg_dest_code = dst & WINED3DSP_REGNUM_MASK;
/* Can directly use the name because texbem is only valid for <= 1.3 shaders */
- pshader_get_register_name(arg->shader, dst, reg_coord);
+ pshader_get_register_name(ins->shader, dst, reg_coord);
for(i = 0; i < This->numbumpenvmatconsts; i++) {
if (This->bumpenvmatconst[i].const_num != WINED3D_CONST_NUM_UNUSED
shader_addline(buffer, "ADD TMP.xy, TMP, %s;\n", reg_coord);
}
- shader_hw_sample(arg, reg_dest_code, reg_coord, "TMP", FALSE, FALSE);
+ shader_hw_sample(ins, reg_dest_code, reg_coord, "TMP", FALSE, FALSE);
- if(arg->opcode->opcode == WINED3DSIO_TEXBEML && has_luminance) {
+ if (ins->opcode->opcode == WINED3DSIO_TEXBEML && has_luminance)
+ {
shader_addline(buffer, "MAD TMP, T%u.z, luminance%d.x, luminance%d.y;\n",
src, reg_dest_code, reg_dest_code);
shader_addline(buffer, "MUL %s, %s, TMP;\n", reg_coord, reg_coord);
tf = 0;
}
/* Without a bump matrix loaded, just sample with the unmodified coordinates */
- shader_hw_sample(arg, reg_dest_code, reg_coord, reg_coord, tf & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg_dest_code, reg_coord, reg_coord, tf & WINED3DTTFF_PROJECTED, FALSE);
}
}
-static void pshader_hw_texm3x2pad(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x2pad(const struct wined3d_shader_instruction *ins)
{
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
char src0_name[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.x, T%u, %s;\n", reg, src0_name);
}
-static void pshader_hw_texm3x2tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x2tex(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD flags;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_str[8];
char src0_name[50];
sprintf(dst_str, "T%u", reg);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.y, T%u, %s;\n", reg, src0_name);
flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
- shader_hw_sample(arg, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
}
-static void pshader_hw_texm3x3pad(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x3pad(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
char src0_name[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.%c, T%u, %s;\n", 'x' + current_state->current_row, reg, src0_name);
current_state->texcoord_w[current_state->current_row++] = reg;
}
-static void pshader_hw_texm3x3tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x3tex(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD flags;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
char dst_str[8];
char src0_name[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
/* Sample the texture using the calculated coordinates */
sprintf(dst_str, "T%u", reg);
flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
- shader_hw_sample(arg, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
current_state->current_row = 0;
}
-static void pshader_hw_texm3x3vspec(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x3vspec(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD flags;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
char dst_str[8];
char src0_name[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
/* Construct the eye-ray vector from w coordinates */
/* Sample the texture using the calculated coordinates */
sprintf(dst_str, "T%u", reg);
flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
- shader_hw_sample(arg, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
current_state->current_row = 0;
}
-static void pshader_hw_texm3x3spec(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x3spec(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD flags;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- DWORD reg3 = arg->src[1] & WINED3DSP_REGNUM_MASK;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ DWORD reg3 = ins->src[1] & WINED3DSP_REGNUM_MASK;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_str[8];
char src0_name[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0_name);
shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
/* Calculate reflection vector.
/* Sample the texture using the calculated coordinates */
sprintf(dst_str, "T%u", reg);
flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
- shader_hw_sample(arg, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
+ shader_hw_sample(ins, reg, dst_str, "TMP", flags & WINED3DTTFF_PROJECTED, FALSE);
current_state->current_row = 0;
}
-static void pshader_hw_texdepth(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texdepth(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
/* texdepth has an implicit destination, the fragment depth value. It's only parameter,
* parameter. According to the msdn, this must be register r5, but let's keep it more flexible
* here
*/
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
/* According to the msdn, the source register(must be r5) is unusable after
* the texdepth instruction, so we're free to modify it
/** Process the WINED3DSIO_TEXDP3TEX instruction in ARB:
* Take a 3-component dot product of the TexCoord[dstreg] and src,
* then perform a 1D texture lookup from stage dstregnum, place into dst. */
-static void pshader_hw_texdp3tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texdp3tex(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
char src0[50];
char dst_str[8];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
shader_addline(buffer, "MOV TMP, 0.0;\n");
shader_addline(buffer, "DP3 TMP.x, T%u, %s;\n", sampler_idx, src0);
sprintf(dst_str, "T%u", sampler_idx);
- shader_hw_sample(arg, sampler_idx, dst_str, "TMP", FALSE /* Only one coord, can't be projected */, FALSE);
+ shader_hw_sample(ins, sampler_idx, dst_str, "TMP", FALSE /* Only one coord, can't be projected */, FALSE);
}
/** Process the WINED3DSIO_TEXDP3 instruction in ARB:
* Take a 3-component dot product of the TexCoord[dstreg] and src. */
-static void pshader_hw_texdp3(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texdp3(const struct wined3d_shader_instruction *ins)
{
char src0[50];
char dst_str[50];
char dst_mask[6];
- DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD dstreg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
/* Handle output register */
- pshader_get_register_name(arg->shader, arg->dst, dst_str);
- shader_arb_get_write_mask(arg, arg->dst, dst_mask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_str);
+ shader_arb_get_write_mask(ins, ins->dst, dst_mask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
shader_addline(buffer, "DP3 %s%s, T%u, %s;\n", dst_str, dst_mask, dstreg, src0);
/* TODO: Handle output modifiers */
/** Process the WINED3DSIO_TEXM3X3 instruction in ARB
* Perform the 3rd row of a 3x3 matrix multiply */
-static void pshader_hw_texm3x3(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x3(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_str[50];
char dst_mask[6];
char src0[50];
- DWORD dst_reg = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD dst_reg = ins->dst & WINED3DSP_REGNUM_MASK;
- pshader_get_register_name(arg->shader, arg->dst, dst_str);
- shader_arb_get_write_mask(arg, arg->dst, dst_mask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_str);
+ shader_arb_get_write_mask(ins, ins->dst, dst_mask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", dst_reg, src0);
shader_addline(buffer, "MOV %s%s, TMP;\n", dst_str, dst_mask);
* Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
* depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
*/
-static void pshader_hw_texm3x2depth(const SHADER_OPCODE_ARG *arg)
+static void pshader_hw_texm3x2depth(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD dst_reg = arg->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD dst_reg = ins->dst & WINED3DSP_REGNUM_MASK;
char src0[50];
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src0);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src0);
shader_addline(buffer, "DP3 TMP.y, T%u, %s;\n", dst_reg, src0);
/* How to deal with the special case dst_name.g == 0? if r != 0, then
/** Handles transforming all WINED3DSIO_M?x? opcodes for
Vertex/Pixel shaders to ARB_vertex_program codes */
-static void shader_hw_mnxn(const SHADER_OPCODE_ARG *arg)
+static void shader_hw_mnxn(const struct wined3d_shader_instruction *ins)
{
int i;
int nComponents = 0;
- SHADER_OPCODE_ARG tmpArg;
- IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)arg->shader;
+ struct wined3d_shader_instruction tmp_ins;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
const SHADER_OPCODE *opcode_table = shader->baseShader.shader_ins;
- DWORD shader_version = arg->reg_maps->shader_version;
+ DWORD shader_version = ins->reg_maps->shader_version;
- memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
+ memset(&tmp_ins, 0, sizeof(tmp_ins));
/* Set constants for the temporary argument */
- tmpArg.shader = arg->shader;
- tmpArg.buffer = arg->buffer;
- tmpArg.src[0] = arg->src[0];
- tmpArg.src_addr[0] = arg->src_addr[0];
- tmpArg.src_addr[1] = arg->src_addr[1];
- tmpArg.reg_maps = arg->reg_maps;
-
- switch(arg->opcode->opcode) {
+ tmp_ins.shader = ins->shader;
+ tmp_ins.buffer = ins->buffer;
+ tmp_ins.src[0] = ins->src[0];
+ tmp_ins.src_addr[0] = ins->src_addr[0];
+ tmp_ins.src_addr[1] = ins->src_addr[1];
+ tmp_ins.reg_maps = ins->reg_maps;
+
+ switch(ins->opcode->opcode)
+ {
case WINED3DSIO_M4x4:
nComponents = 4;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
break;
case WINED3DSIO_M4x3:
nComponents = 3;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
break;
case WINED3DSIO_M3x4:
nComponents = 4;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
case WINED3DSIO_M3x3:
nComponents = 3;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
case WINED3DSIO_M3x2:
nComponents = 2;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
default:
break;
}
for (i = 0; i < nComponents; i++) {
- tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
- tmpArg.src[1] = arg->src[1]+i;
- shader_hw_map2gl(&tmpArg);
+ tmp_ins.dst = ((ins->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
+ tmp_ins.src[1] = ins->src[1]+i;
+ shader_hw_map2gl(&tmp_ins);
}
}
-static void vshader_hw_rsq_rcp(const SHADER_OPCODE_ARG *arg)
+static void vshader_hw_rsq_rcp(const struct wined3d_shader_instruction *ins)
{
- CONST SHADER_OPCODE* curOpcode = arg->opcode;
- SHADER_BUFFER* buffer = arg->buffer;
- DWORD dst = arg->dst;
- DWORD src = arg->src[0];
+ CONST SHADER_OPCODE *curOpcode = ins->opcode;
+ SHADER_BUFFER *buffer = ins->buffer;
+ DWORD dst = ins->dst;
+ DWORD src = ins->src[0];
DWORD swizzle = (src & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
const char *instruction;
}
strcpy(tmpLine, instruction);
- vshader_program_add_param(arg, dst, FALSE, tmpLine); /* Destination */
+ vshader_program_add_param(ins, dst, FALSE, tmpLine); /* Destination */
strcat(tmpLine, ",");
- vshader_program_add_param(arg, src, TRUE, tmpLine);
+ vshader_program_add_param(ins, src, TRUE, tmpLine);
if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) == swizzle) {
/* Dx sdk says .x is used if no swizzle is given, but our test shows that
* .w is used
shader_addline(buffer, "%s;\n", tmpLine);
}
-static void shader_hw_nrm(const SHADER_OPCODE_ARG *arg)
+static void shader_hw_nrm(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[50];
char dst_wmask[20];
- DWORD shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (arg->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = (ins->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = (ins->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name);
shader_addline(buffer, "DP3 TMP, %s, %s;\n", src_name, src_name);
shader_addline(buffer, "RSQ TMP, TMP.x;\n");
/* dst.w = src[0].w * 1 / (src.x^2 + src.y^2 + src.z^2)^(1/2) according to msdn*/
pshader_gen_output_modifier_line(buffer, FALSE, dst_wmask, shift, dst_name);
}
-static void shader_hw_sincos(const SHADER_OPCODE_ARG *arg)
+static void shader_hw_sincos(const struct wined3d_shader_instruction *ins)
{
/* This instruction exists in ARB, but the d3d instruction takes two extra parameters which
* must contain fixed constants. So we need a separate function to filter those constants and
* can't use map2gl
*/
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
char dst_name[50];
char src_name[50];
char dst_wmask[20];
- DWORD shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
- BOOL sat = (arg->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
+ DWORD shift = (ins->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
+ BOOL sat = (ins->dst & WINED3DSP_DSTMOD_MASK) & WINED3DSPDM_SATURATE;
- pshader_get_register_name(arg->shader, arg->dst, dst_name);
- shader_arb_get_write_mask(arg, arg->dst, dst_wmask);
+ pshader_get_register_name(ins->shader, ins->dst, dst_name);
+ shader_arb_get_write_mask(ins, ins->dst, dst_wmask);
- pshader_gen_input_modifier_line(arg->shader, buffer, arg->src[0], 0, src_name);
+ pshader_gen_input_modifier_line(ins->shader, buffer, ins->src[0], 0, src_name);
shader_addline(buffer, "SCS%s %s%s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask,
src_name);
****************************************************************************/
/* Prototypes */
-static void shader_glsl_add_src_param(const SHADER_OPCODE_ARG *arg, const DWORD param,
+static void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins, const DWORD param,
const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param);
/** Used for opcode modifiers - They multiply the result by the specified amount */
/** Writes the GLSL variable name that corresponds to the register that the
* DX opcode parameter is trying to access */
static void shader_glsl_get_register_name(const DWORD param, const DWORD addr_token,
- char *regstr, BOOL *is_color, const SHADER_OPCODE_ARG *arg)
+ char *regstr, BOOL *is_color, const struct wined3d_shader_instruction *ins)
{
/* oPos, oFog and oPts in D3D */
static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
DWORD reg = param & WINED3DSP_REGNUM_MASK;
DWORD regtype = shader_get_regtype(param);
- IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
+ IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
const WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
DWORD shader_version = This->baseShader.reg_maps.shader_version;
if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
glsl_src_param_t rel_param;
- shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
+ shader_glsl_add_src_param(ins, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
/* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
* operation there
if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 2)
{
glsl_src_param_t rel_param;
- shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
+ shader_glsl_add_src_param(ins, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
if(reg) {
sprintf(tmpStr, "%cC[%s + %u]", prefix, rel_param.param_str, reg);
} else {
/* From a given parameter token, generate the corresponding GLSL string.
* Also, return the actual register name and swizzle in case the
* caller needs this information as well. */
-static void shader_glsl_add_src_param(const SHADER_OPCODE_ARG *arg, const DWORD param,
- const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param)
+static void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins,
+ const DWORD param, const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param)
{
BOOL is_color = FALSE;
char swizzle_str[6];
src_param->param_str[0] = '\0';
swizzle_str[0] = '\0';
- shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, arg);
+ shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, ins);
shader_glsl_get_swizzle(param, is_color, mask, swizzle_str);
shader_glsl_gen_modifier(param, src_param->reg_name, swizzle_str, src_param->param_str);
/* From a given parameter token, generate the corresponding GLSL string.
* Also, return the actual register name and swizzle in case the
* caller needs this information as well. */
-static DWORD shader_glsl_add_dst_param(const SHADER_OPCODE_ARG* arg, const DWORD param,
- const DWORD addr_token, glsl_dst_param_t *dst_param)
+static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins,
+ const DWORD param, const DWORD addr_token, glsl_dst_param_t *dst_param)
{
BOOL is_color = FALSE;
dst_param->mask_str[0] = '\0';
dst_param->reg_name[0] = '\0';
- shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, arg);
+ shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, ins);
return shader_glsl_get_write_mask(param, dst_param->mask_str);
}
/* Append the destination part of the instruction to the buffer, return the effective write mask */
-static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer, const SHADER_OPCODE_ARG *arg, const DWORD param)
+static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer,
+ const struct wined3d_shader_instruction *ins, const DWORD param)
{
glsl_dst_param_t dst_param;
DWORD mask;
int shift;
- mask = shader_glsl_add_dst_param(arg, param, arg->dst_addr, &dst_param);
+ mask = shader_glsl_add_dst_param(ins, param, ins->dst_addr, &dst_param);
if(mask) {
shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
}
/* Append the destination part of the instruction to the buffer, return the effective write mask */
-static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, const SHADER_OPCODE_ARG *arg)
+static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, const struct wined3d_shader_instruction *ins)
{
- return shader_glsl_append_dst_ext(buffer, arg, arg->dst);
+ return shader_glsl_append_dst_ext(buffer, ins, ins->dst);
}
/** Process GLSL instruction modifiers */
-void shader_glsl_add_instruction_modifiers(const SHADER_OPCODE_ARG* arg)
+void shader_glsl_add_instruction_modifiers(const struct wined3d_shader_instruction *ins)
{
- DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK;
-
- if (arg->opcode->dst_token && mask != 0) {
+ DWORD mask = ins->dst & WINED3DSP_DSTMOD_MASK;
+
+ if (ins->opcode->dst_token && mask)
+ {
glsl_dst_param_t dst_param;
- shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
+ shader_glsl_add_dst_param(ins, ins->dst, 0, &dst_param);
if (mask & WINED3DSPDM_SATURATE) {
/* _SAT means to clamp the value of the register to between 0 and 1 */
- shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
+ shader_addline(ins->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
}
if (mask & WINED3DSPDM_MSAMPCENTROID) {
if (sign_fixup) strcat(arguments, " * 2.0 - 1.0");
}
-static void shader_glsl_color_correction(const struct SHADER_OPCODE_ARG *arg, struct color_fixup_desc fixup)
+static void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)
{
unsigned int mask_size, remaining;
glsl_dst_param_t dst_param;
if (fixup.y_sign_fixup || fixup.y_source != CHANNEL_SOURCE_Y) mask |= WINED3DSP_WRITEMASK_1;
if (fixup.z_sign_fixup || fixup.z_source != CHANNEL_SOURCE_Z) mask |= WINED3DSP_WRITEMASK_2;
if (fixup.w_sign_fixup || fixup.w_source != CHANNEL_SOURCE_W) mask |= WINED3DSP_WRITEMASK_3;
- mask &= arg->dst;
+ mask &= ins->dst;
if (!mask) return; /* Nothing to do */
shader_glsl_get_write_mask(mask, dst_param.mask_str);
dst_param.reg_name[0] = '\0';
- shader_glsl_get_register_name(arg->dst, arg->dst_addr, dst_param.reg_name, &dummy, arg);
+ shader_glsl_get_register_name(ins->dst, ins->dst_addr, dst_param.reg_name, &dummy, ins);
arguments[0] = '\0';
remaining = mask_size;
if (mask_size > 1)
{
- shader_addline(arg->buffer, "%s%s = vec%u(%s);\n",
+ shader_addline(ins->buffer, "%s%s = vec%u(%s);\n",
dst_param.reg_name, dst_param.mask_str, mask_size, arguments);
}
else
{
- shader_addline(arg->buffer, "%s%s = %s;\n", dst_param.reg_name, dst_param.mask_str, arguments);
+ shader_addline(ins->buffer, "%s%s = %s;\n", dst_param.reg_name, dst_param.mask_str, arguments);
}
}
-static void PRINTF_ATTR(6, 7) shader_glsl_gen_sample_code(const SHADER_OPCODE_ARG *arg,
+static void PRINTF_ATTR(6, 7) shader_glsl_gen_sample_code(const struct wined3d_shader_instruction *ins,
DWORD sampler, const glsl_sample_function_t *sample_function, DWORD swizzle,
const char *bias, const char *coord_reg_fmt, ...)
{
BOOL rect_fixup = FALSE;
va_list args;
- shader_glsl_get_swizzle(swizzle, FALSE, arg->dst, dst_swizzle);
+ shader_glsl_get_swizzle(swizzle, FALSE, ins->dst, dst_swizzle);
- if(shader_is_pshader_version(arg->reg_maps->shader_version)) {
- IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) arg->shader;
+ if (shader_is_pshader_version(ins->reg_maps->shader_version))
+ {
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
fixup = This->cur_args->color_fixup[sampler];
sampler_base = "Psampler";
fixup = COLOR_FIXUP_IDENTITY; /* FIXME: Vshader color fixup */
}
- shader_glsl_append_dst(arg->buffer, arg);
+ shader_glsl_append_dst(ins->buffer, ins);
- shader_addline(arg->buffer, "%s(%s%u, ", sample_function->name, sampler_base, sampler);
+ shader_addline(ins->buffer, "%s(%s%u, ", sample_function->name, sampler_base, sampler);
va_start(args, coord_reg_fmt);
- shader_vaddline(arg->buffer, coord_reg_fmt, args);
+ shader_vaddline(ins->buffer, coord_reg_fmt, args);
va_end(args);
if(bias) {
- shader_addline(arg->buffer, ", %s)%s);\n", bias, dst_swizzle);
+ shader_addline(ins->buffer, ", %s)%s);\n", bias, dst_swizzle);
} else {
if (rect_fixup) {
- shader_addline(arg->buffer, " * PsamplerRectFixup%u)%s);\n", sampler, dst_swizzle);
+ shader_addline(ins->buffer, " * PsamplerRectFixup%u)%s);\n", sampler, dst_swizzle);
} else {
- shader_addline(arg->buffer, ")%s);\n", dst_swizzle);
+ shader_addline(ins->buffer, ")%s);\n", dst_swizzle);
}
}
if(!is_identity_fixup(fixup)) {
- shader_glsl_color_correction(arg, fixup);
+ shader_glsl_color_correction(ins, fixup);
}
}
****************************************************************************/
/* Generate GLSL arithmetic functions (dst = src1 + src2) */
-static void shader_glsl_arith(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_arith(const struct wined3d_shader_instruction *ins)
{
- CONST SHADER_OPCODE* curOpcode = arg->opcode;
- SHADER_BUFFER* buffer = arg->buffer;
+ CONST SHADER_OPCODE* curOpcode = ins->opcode;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD write_mask;
break;
}
- write_mask = shader_glsl_append_dst(buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
+ write_mask = shader_glsl_append_dst(buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
shader_addline(buffer, "%s %c %s);\n", src0_param.param_str, op, src1_param.param_str);
}
/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
-static void shader_glsl_mov(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
DWORD write_mask;
- write_mask = shader_glsl_append_dst(buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
+ write_mask = shader_glsl_append_dst(buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src0_param);
/* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
* shader versions WINED3DSIO_MOVA is used for this. */
- if ((WINED3DSHADER_VERSION_MAJOR(arg->reg_maps->shader_version) == 1
- && !shader_is_pshader_version(arg->reg_maps->shader_version)
- && shader_get_regtype(arg->dst) == WINED3DSPR_ADDR))
+ if ((WINED3DSHADER_VERSION_MAJOR(ins->reg_maps->shader_version) == 1
+ && !shader_is_pshader_version(ins->reg_maps->shader_version)
+ && shader_get_regtype(ins->dst) == WINED3DSPR_ADDR))
{
/* This is a simple floor() */
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
} else {
shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
}
- } else if(arg->opcode->opcode == WINED3DSIO_MOVA) {
+ }
+ else if(ins->opcode->opcode == WINED3DSIO_MOVA)
+ {
/* We need to *round* to the nearest int here. */
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
if (mask_size > 1) {
}
/* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
-static void shader_glsl_dot(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_dot(const struct wined3d_shader_instruction *ins)
{
- CONST SHADER_OPCODE* curOpcode = arg->opcode;
- SHADER_BUFFER* buffer = arg->buffer;
+ CONST SHADER_OPCODE *curOpcode = ins->opcode;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD dst_write_mask, src_write_mask;
unsigned int dst_size = 0;
- dst_write_mask = shader_glsl_append_dst(buffer, arg);
+ dst_write_mask = shader_glsl_append_dst(buffer, ins);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
/* dp3 works on vec3, dp4 on vec4 */
src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
}
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_write_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_write_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], src_write_mask, &src1_param);
if (dst_size > 1) {
shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
/* Note that this instruction has some restrictions. The destination write mask
* can't contain the w component, and the source swizzles have to be .xyzw */
-static void shader_glsl_cross(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_cross(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
char dst_mask[6];
- shader_glsl_get_write_mask(arg->dst, dst_mask);
- shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
- shader_addline(arg->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
+ shader_glsl_get_write_mask(ins->dst, dst_mask);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], src_mask, &src1_param);
+ shader_addline(ins->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
}
/* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
* Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
* GLSL uses the value as-is. */
-static void shader_glsl_pow(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_pow(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER *buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD dst_write_mask;
unsigned int dst_size;
- dst_write_mask = shader_glsl_append_dst(buffer, arg);
+ dst_write_mask = shader_glsl_append_dst(buffer, ins);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
if (dst_size > 1) {
shader_addline(buffer, "vec%d(pow(abs(%s), %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
/* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
* Src0 is a scalar. Note that D3D uses the absolute of src0, while
* GLSL uses the value as-is. */
-static void shader_glsl_log(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_log(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER *buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
DWORD dst_write_mask;
unsigned int dst_size;
- dst_write_mask = shader_glsl_append_dst(buffer, arg);
+ dst_write_mask = shader_glsl_append_dst(buffer, ins);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
if (dst_size > 1) {
shader_addline(buffer, "vec%d(log2(abs(%s))));\n", dst_size, src0_param.param_str);
}
/* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
-static void shader_glsl_map2gl(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_map2gl(const struct wined3d_shader_instruction *ins)
{
- CONST SHADER_OPCODE* curOpcode = arg->opcode;
- SHADER_BUFFER* buffer = arg->buffer;
+ CONST SHADER_OPCODE *curOpcode = ins->opcode;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src_param;
const char *instruction;
DWORD write_mask;
break;
}
- write_mask = shader_glsl_append_dst(buffer, arg);
+ write_mask = shader_glsl_append_dst(buffer, ins);
shader_addline(buffer, "%s(", instruction);
if (curOpcode->num_params > 0) {
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src_param);
shader_addline(buffer, "%s", src_param.param_str);
for (i = 2; i < curOpcode->num_params; ++i) {
- shader_glsl_add_src_param(arg, arg->src[i-1], arg->src_addr[i-1], write_mask, &src_param);
+ shader_glsl_add_src_param(ins, ins->src[i-1], ins->src_addr[i-1], write_mask, &src_param);
shader_addline(buffer, ", %s", src_param.param_str);
}
}
* For 2.0 shaders, just do this (honoring writemask and swizzle):
* dst = 2^src; (partial precision is allowed, but optional)
*/
-static void shader_glsl_expp(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_expp(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src_param);
- if (arg->reg_maps->shader_version < WINED3DPS_VERSION(2,0))
+ if (ins->reg_maps->shader_version < WINED3DPS_VERSION(2,0))
{
char dst_mask[6];
- shader_addline(arg->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
- shader_addline(arg->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
- shader_addline(arg->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
- shader_addline(arg->buffer, "tmp0.w = 1.0;\n");
+ shader_addline(ins->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
+ shader_addline(ins->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
+ shader_addline(ins->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
+ shader_addline(ins->buffer, "tmp0.w = 1.0;\n");
- shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_get_write_mask(arg->dst, dst_mask);
- shader_addline(arg->buffer, "tmp0%s);\n", dst_mask);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_get_write_mask(ins->dst, dst_mask);
+ shader_addline(ins->buffer, "tmp0%s);\n", dst_mask);
} else {
DWORD write_mask;
unsigned int mask_size;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
mask_size = shader_glsl_get_write_mask_size(write_mask);
if (mask_size > 1) {
- shader_addline(arg->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
+ shader_addline(ins->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
} else {
- shader_addline(arg->buffer, "exp2(%s));\n", src_param.param_str);
+ shader_addline(ins->buffer, "exp2(%s));\n", src_param.param_str);
}
}
}
/** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
-static void shader_glsl_rcp(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_rcp(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src_param;
DWORD write_mask;
unsigned int mask_size;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
if (mask_size > 1) {
- shader_addline(arg->buffer, "vec%d(1.0 / %s));\n", mask_size, src_param.param_str);
+ shader_addline(ins->buffer, "vec%d(1.0 / %s));\n", mask_size, src_param.param_str);
} else {
- shader_addline(arg->buffer, "1.0 / %s);\n", src_param.param_str);
+ shader_addline(ins->buffer, "1.0 / %s);\n", src_param.param_str);
}
}
-static void shader_glsl_rsq(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_rsq(const struct wined3d_shader_instruction *ins)
{
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src_param;
DWORD write_mask;
unsigned int mask_size;
- write_mask = shader_glsl_append_dst(buffer, arg);
+ write_mask = shader_glsl_append_dst(buffer, ins);
mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
if (mask_size > 1) {
shader_addline(buffer, "vec%d(inversesqrt(%s)));\n", mask_size, src_param.param_str);
}
/** Process signed comparison opcodes in GLSL. */
-static void shader_glsl_compare(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_compare(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD write_mask;
unsigned int mask_size;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
if (mask_size > 1) {
const char *compare;
- switch(arg->opcode->opcode) {
+ switch(ins->opcode->opcode)
+ {
case WINED3DSIO_SLT: compare = "lessThan"; break;
case WINED3DSIO_SGE: compare = "greaterThanEqual"; break;
default: compare = "";
- FIXME("Can't handle opcode %s\n", arg->opcode->name);
+ FIXME("Can't handle opcode %s\n", ins->opcode->name);
}
- shader_addline(arg->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
+ shader_addline(ins->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
src0_param.param_str, src1_param.param_str);
} else {
- switch(arg->opcode->opcode) {
+ switch(ins->opcode->opcode)
+ {
case WINED3DSIO_SLT:
/* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
* to return 0.0 but step returns 1.0 because step is not < x
* issue. Playing with not() is not possible either because not() does not accept
* a scalar.
*/
- shader_addline(arg->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
+ shader_addline(ins->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
break;
case WINED3DSIO_SGE:
/* Here we can use the step() function and safe a conditional */
- shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
+ shader_addline(ins->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
break;
default:
- FIXME("Can't handle opcode %s\n", arg->opcode->name);
+ FIXME("Can't handle opcode %s\n", ins->opcode->name);
}
}
}
/** Process CMP instruction in GLSL (dst = src0 >= 0.0 ? src1 : src2), per channel */
-static void shader_glsl_cmp(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_cmp(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
char mask_char[6];
BOOL temp_destination = FALSE;
- if(shader_is_scalar(arg->src[0])) {
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ if (shader_is_scalar(ins->src[0]))
+ {
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
- shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
+ shader_addline(ins->buffer, "%s >= 0.0 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
} else {
- DWORD src0reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
- DWORD src1reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
- DWORD src2reg = arg->src[2] & WINED3DSP_REGNUM_MASK;
- DWORD src0regtype = shader_get_regtype(arg->src[0]);
- DWORD src1regtype = shader_get_regtype(arg->src[1]);
- DWORD src2regtype = shader_get_regtype(arg->src[2]);
- DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
- DWORD dstregtype = shader_get_regtype(arg->dst);
+ DWORD src0reg = ins->src[0] & WINED3DSP_REGNUM_MASK;
+ DWORD src1reg = ins->src[1] & WINED3DSP_REGNUM_MASK;
+ DWORD src2reg = ins->src[2] & WINED3DSP_REGNUM_MASK;
+ DWORD src0regtype = shader_get_regtype(ins->src[0]);
+ DWORD src1regtype = shader_get_regtype(ins->src[1]);
+ DWORD src2regtype = shader_get_regtype(ins->src[2]);
+ DWORD dstreg = ins->dst & WINED3DSP_REGNUM_MASK;
+ DWORD dstregtype = shader_get_regtype(ins->dst);
/* Cycle through all source0 channels */
for (i=0; i<4; i++) {
write_mask = 0;
/* Find the destination channels which use the current source0 channel */
for (j=0; j<4; j++) {
- if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
+ if (((ins->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2 * j)) & 0x3) == i)
+ {
write_mask |= WINED3DSP_WRITEMASK_0 << j;
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
(src1reg == dstreg && src1regtype == dstregtype) ||
(src2reg == dstreg && src2regtype == dstregtype)) {
- write_mask = shader_glsl_get_write_mask(arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask), mask_char);
+ write_mask = shader_glsl_get_write_mask(ins->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask), mask_char);
if (!write_mask) continue;
- shader_addline(arg->buffer, "tmp0%s = (", mask_char);
+ shader_addline(ins->buffer, "tmp0%s = (", mask_char);
temp_destination = TRUE;
} else {
- write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
+ write_mask = shader_glsl_append_dst_ext(ins->buffer, ins,
+ ins->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
if (!write_mask) continue;
}
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], cmp_channel, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
- shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
+ shader_addline(ins->buffer, "%s >= 0.0 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
if(temp_destination) {
- shader_glsl_get_write_mask(arg->dst, mask_char);
- shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst);
- shader_addline(arg->buffer, "tmp0%s);\n", mask_char);
+ shader_glsl_get_write_mask(ins->dst, mask_char);
+ shader_glsl_append_dst_ext(ins->buffer, ins, ins->dst);
+ shader_addline(ins->buffer, "tmp0%s);\n", mask_char);
}
}
/** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
/* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
* the compare is done per component of src0. */
-static void shader_glsl_cnd(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_cnd(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD write_mask, cmp_channel = 0;
unsigned int i, j;
- if (arg->reg_maps->shader_version < WINED3DPS_VERSION(1, 4))
+ if (ins->reg_maps->shader_version < WINED3DPS_VERSION(1, 4))
{
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
/* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
- if (arg->coissue)
+ if (ins->coissue)
{
- shader_addline(arg->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
+ shader_addline(ins->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
} else {
- shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
+ shader_addline(ins->buffer, "%s > 0.5 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
return;
write_mask = 0;
/* Find the destination channels which use the current source0 channel */
for (j=0; j<4; j++) {
- if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
+ if (((ins->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2 * j)) & 0x3) == i)
+ {
write_mask |= WINED3DSP_WRITEMASK_0 << j;
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
}
- write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
+ write_mask = shader_glsl_append_dst_ext(ins->buffer, ins, ins->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
if (!write_mask) continue;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], cmp_channel, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
- shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
+ shader_addline(ins->buffer, "%s > 0.5 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
}
/** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
-static void shader_glsl_mad(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_mad(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
DWORD write_mask;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
- shader_addline(arg->buffer, "(%s * %s) + %s);\n",
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
+ shader_addline(ins->buffer, "(%s * %s) + %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
/** Handles transforming all WINED3DSIO_M?x? opcodes for
Vertex shaders to GLSL codes */
-static void shader_glsl_mnxn(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_mnxn(const struct wined3d_shader_instruction *ins)
{
- IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)arg->shader;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
const SHADER_OPCODE *opcode_table = shader->baseShader.shader_ins;
- DWORD shader_version = arg->reg_maps->shader_version;
+ DWORD shader_version = ins->reg_maps->shader_version;
int i;
int nComponents = 0;
- SHADER_OPCODE_ARG tmpArg;
-
- memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
+ struct wined3d_shader_instruction tmp_ins;
+
+ memset(&tmp_ins, 0, sizeof(tmp_ins));
/* Set constants for the temporary argument */
- tmpArg.shader = arg->shader;
- tmpArg.buffer = arg->buffer;
- tmpArg.src[0] = arg->src[0];
- tmpArg.src_addr[0] = arg->src_addr[0];
- tmpArg.src_addr[1] = arg->src_addr[1];
- tmpArg.reg_maps = arg->reg_maps;
-
- switch(arg->opcode->opcode) {
+ tmp_ins.shader = ins->shader;
+ tmp_ins.buffer = ins->buffer;
+ tmp_ins.src[0] = ins->src[0];
+ tmp_ins.src_addr[0] = ins->src_addr[0];
+ tmp_ins.src_addr[1] = ins->src_addr[1];
+ tmp_ins.reg_maps = ins->reg_maps;
+
+ switch(ins->opcode->opcode)
+ {
case WINED3DSIO_M4x4:
nComponents = 4;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
break;
case WINED3DSIO_M4x3:
nComponents = 3;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP4);
break;
case WINED3DSIO_M3x4:
nComponents = 4;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
case WINED3DSIO_M3x3:
nComponents = 3;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
case WINED3DSIO_M3x2:
nComponents = 2;
- tmpArg.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
+ tmp_ins.opcode = shader_get_opcode(opcode_table, shader_version, WINED3DSIO_DP3);
break;
default:
break;
}
- for (i = 0; i < nComponents; i++) {
- tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
- tmpArg.src[1] = arg->src[1]+i;
- shader_glsl_dot(&tmpArg);
+ for (i = 0; i < nComponents; ++i)
+ {
+ tmp_ins.dst = ((ins->dst) & ~WINED3DSP_WRITEMASK_ALL) | (WINED3DSP_WRITEMASK_0 << i);
+ tmp_ins.src[1] = ins->src[1] + i;
+ shader_glsl_dot(&tmp_ins);
}
}
blend factor. Equation: (dst = src2 + src0 * (src1 - src2))
This is equivalent to mix(src2, src1, src0);
*/
-static void shader_glsl_lrp(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_lrp(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
DWORD write_mask;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], write_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], write_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2], write_mask, &src2_param);
- shader_addline(arg->buffer, "mix(%s, %s, %s));\n",
+ shader_addline(ins->buffer, "mix(%s, %s, %s));\n",
src2_param.param_str, src1_param.param_str, src0_param.param_str);
}
* dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
* where src.w is clamped at +- 128
*/
-static void shader_glsl_lit(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_lit(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src3_param;
char dst_mask[6];
- shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_get_write_mask(arg->dst, dst_mask);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_get_write_mask(ins->dst, dst_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src3_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &src3_param);
/* The sdk specifies the instruction like this
* dst.x = 1.0;
* which sets dst.z to 0. If y > 0, but x = 0.0, we get pow(y * 0.0, power), which results in 0 too.
* if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to
*/
- shader_addline(arg->buffer, "vec4(1.0, max(%s, 0.0), pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
- src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
+ shader_addline(ins->buffer,
+ "vec4(1.0, max(%s, 0.0), pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
+ src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
}
/** Process the WINED3DSIO_DST instruction in GLSL:
* dst.z = src0.z
* dst.w = src1.w
*/
-static void shader_glsl_dst(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_dst(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0y_param;
glsl_src_param_t src0z_param;
glsl_src_param_t src1w_param;
char dst_mask[6];
- shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_get_write_mask(arg->dst, dst_mask);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_get_write_mask(ins->dst, dst_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_1, &src1y_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_3, &src1w_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_1, &src1y_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_3, &src1w_param);
- shader_addline(arg->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
+ shader_addline(ins->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
}
* dst.z = dst.z
* dst.w = dst.w
*/
-static void shader_glsl_sincos(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_sincos(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
DWORD write_mask;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
switch (write_mask) {
case WINED3DSP_WRITEMASK_0:
- shader_addline(arg->buffer, "cos(%s));\n", src0_param.param_str);
+ shader_addline(ins->buffer, "cos(%s));\n", src0_param.param_str);
break;
case WINED3DSP_WRITEMASK_1:
- shader_addline(arg->buffer, "sin(%s));\n", src0_param.param_str);
+ shader_addline(ins->buffer, "sin(%s));\n", src0_param.param_str);
break;
case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
- shader_addline(arg->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
+ shader_addline(ins->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
break;
default:
* Need to use a temporary variable for this operation.
*/
/* FIXME: I don't think nested loops will work correctly this way. */
-static void shader_glsl_loop(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src1_param;
- IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
- DWORD regtype = shader_get_regtype(arg->src[1]);
- DWORD reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
+ DWORD regtype = shader_get_regtype(ins->src[1]);
+ DWORD reg = ins->src[1] & WINED3DSP_REGNUM_MASK;
const DWORD *control_values = NULL;
const local_constant *constant;
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
/* Try to hardcode the loop control parameters if possible. Direct3D 9 class hardware doesn't support real
* varying indexing, but Microsoft designed this feature for Shader model 2.x+. If the loop control is
if(control_values) {
if(control_values[2] > 0) {
- shader_addline(arg->buffer, "for (aL%u = %d; aL%u < (%d * %d + %d); aL%u += %d) {\n",
- shader->baseShader.cur_loop_depth, control_values[1],
- shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
- shader->baseShader.cur_loop_depth, control_values[2]);
+ shader_addline(ins->buffer, "for (aL%u = %d; aL%u < (%d * %d + %d); aL%u += %d) {\n",
+ shader->baseShader.cur_loop_depth, control_values[1],
+ shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
+ shader->baseShader.cur_loop_depth, control_values[2]);
} else if(control_values[2] == 0) {
- shader_addline(arg->buffer, "for (aL%u = %d, tmpInt%u = 0; tmpInt%u < %d; tmpInt%u++) {\n",
- shader->baseShader.cur_loop_depth, control_values[1], shader->baseShader.cur_loop_depth,
- shader->baseShader.cur_loop_depth, control_values[0],
- shader->baseShader.cur_loop_depth);
+ shader_addline(ins->buffer, "for (aL%u = %d, tmpInt%u = 0; tmpInt%u < %d; tmpInt%u++) {\n",
+ shader->baseShader.cur_loop_depth, control_values[1], shader->baseShader.cur_loop_depth,
+ shader->baseShader.cur_loop_depth, control_values[0],
+ shader->baseShader.cur_loop_depth);
} else {
- shader_addline(arg->buffer, "for (aL%u = %d; aL%u > (%d * %d + %d); aL%u += %d) {\n",
- shader->baseShader.cur_loop_depth, control_values[1],
- shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
- shader->baseShader.cur_loop_depth, control_values[2]);
+ shader_addline(ins->buffer, "for (aL%u = %d; aL%u > (%d * %d + %d); aL%u += %d) {\n",
+ shader->baseShader.cur_loop_depth, control_values[1],
+ shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
+ shader->baseShader.cur_loop_depth, control_values[2]);
}
} else {
- shader_addline(arg->buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
- shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
- src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
- shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
+ shader_addline(ins->buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
+ shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
+ src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
+ shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
}
shader->baseShader.cur_loop_depth++;
shader->baseShader.cur_loop_regno++;
}
-static void shader_glsl_end(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_end(const struct wined3d_shader_instruction *ins)
{
- IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
- shader_addline(arg->buffer, "}\n");
+ shader_addline(ins->buffer, "}\n");
- if(arg->opcode->opcode == WINED3DSIO_ENDLOOP) {
+ if (ins->opcode->opcode == WINED3DSIO_ENDLOOP)
+ {
shader->baseShader.cur_loop_depth--;
shader->baseShader.cur_loop_regno--;
}
- if(arg->opcode->opcode == WINED3DSIO_ENDREP) {
+
+ if (ins->opcode->opcode == WINED3DSIO_ENDREP)
+ {
shader->baseShader.cur_loop_depth--;
}
}
-static void shader_glsl_rep(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_rep(const struct wined3d_shader_instruction *ins)
{
- IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
+ IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->shader;
glsl_src_param_t src0_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_addline(arg->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
- shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
- src0_param.param_str, shader->baseShader.cur_loop_depth);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_addline(ins->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
+ shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
+ src0_param.param_str, shader->baseShader.cur_loop_depth);
shader->baseShader.cur_loop_depth++;
}
-static void shader_glsl_if(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_if(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_addline(arg->buffer, "if (%s) {\n", src0_param.param_str);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_addline(ins->buffer, "if (%s) {\n", src0_param.param_str);
}
-static void shader_glsl_ifc(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_ifc(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
- shader_addline(arg->buffer, "if (%s %s %s) {\n",
- src0_param.param_str, shader_get_comp_op(arg->flags), src1_param.param_str);
+ shader_addline(ins->buffer, "if (%s %s %s) {\n",
+ src0_param.param_str, shader_get_comp_op(ins->flags), src1_param.param_str);
}
-static void shader_glsl_else(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_else(const struct wined3d_shader_instruction *ins)
{
- shader_addline(arg->buffer, "} else {\n");
+ shader_addline(ins->buffer, "} else {\n");
}
-static void shader_glsl_break(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_break(const struct wined3d_shader_instruction *ins)
{
- shader_addline(arg->buffer, "break;\n");
+ shader_addline(ins->buffer, "break;\n");
}
/* FIXME: According to MSDN the compare is done per component. */
-static void shader_glsl_breakc(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_breakc(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
- shader_addline(arg->buffer, "if (%s %s %s) break;\n",
- src0_param.param_str, shader_get_comp_op(arg->flags), src1_param.param_str);
+ shader_addline(ins->buffer, "if (%s %s %s) break;\n",
+ src0_param.param_str, shader_get_comp_op(ins->flags), src1_param.param_str);
}
-static void shader_glsl_label(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_label(const struct wined3d_shader_instruction *ins)
{
- DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
- shader_addline(arg->buffer, "}\n");
- shader_addline(arg->buffer, "void subroutine%u () {\n", snum);
+ DWORD snum = (ins->src[0]) & WINED3DSP_REGNUM_MASK;
+ shader_addline(ins->buffer, "}\n");
+ shader_addline(ins->buffer, "void subroutine%u () {\n", snum);
}
-static void shader_glsl_call(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_call(const struct wined3d_shader_instruction *ins)
{
- DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
- shader_addline(arg->buffer, "subroutine%u();\n", snum);
+ DWORD snum = (ins->src[0]) & WINED3DSP_REGNUM_MASK;
+ shader_addline(ins->buffer, "subroutine%u();\n", snum);
}
-static void shader_glsl_callnz(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_callnz(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src1_param;
- DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
- shader_addline(arg->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, snum);
+ DWORD snum = (ins->src[0]) & WINED3DSP_REGNUM_MASK;
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
+ shader_addline(ins->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, snum);
}
/*********************************************
* Pixel Shader Specific Code begins here
********************************************/
-static void pshader_glsl_tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_tex(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
- DWORD shader_version = arg->reg_maps->shader_version;
+ DWORD shader_version = ins->reg_maps->shader_version;
glsl_sample_function_t sample_function;
DWORD sample_flags = 0;
DWORD sampler_type;
/* 1.0-1.4: Use destination register as sampler source.
* 2.0+: Use provided sampler source. */
- if (shader_version < WINED3DPS_VERSION(2,0)) sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
- else sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
- sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ if (shader_version < WINED3DPS_VERSION(2,0)) sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
+ else sampler_idx = ins->src[1] & WINED3DSP_REGNUM_MASK;
+ sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
if (shader_version < WINED3DPS_VERSION(1,4))
{
}
else if (shader_version < WINED3DPS_VERSION(2,0))
{
- DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
+ DWORD src_mod = ins->src[0] & WINED3DSP_SRCMOD_MASK;
if (src_mod == WINED3DSPSM_DZ) {
sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
mask = WINED3DSP_WRITEMASK_3;
}
} else {
- if (arg->flags & WINED3DSI_TEXLD_PROJECT)
+ if (ins->flags & WINED3DSI_TEXLD_PROJECT)
{
/* ps 2.0 texldp instruction always divides by the fourth component. */
sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
mask |= sample_function.coord_mask;
if (shader_version < WINED3DPS_VERSION(2,0)) swizzle = WINED3DVS_NOSWIZZLE;
- else swizzle = arg->src[1] & WINED3DSP_SWIZZLE_MASK;
+ else swizzle = ins->src[1] & WINED3DSP_SWIZZLE_MASK;
/* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */
{
char coord_mask[6];
shader_glsl_get_write_mask(mask, coord_mask);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, swizzle, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL,
"T%u%s", sampler_idx, coord_mask);
} else {
glsl_src_param_t coord_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], mask, &coord_param);
- if (arg->flags & WINED3DSI_TEXLD_BIAS)
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], mask, &coord_param);
+ if (ins->flags & WINED3DSI_TEXLD_BIAS)
{
glsl_src_param_t bias;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &bias);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, swizzle, bias.param_str,
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &bias);
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, bias.param_str,
"%s", coord_param.param_str);
} else {
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, swizzle, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL,
"%s", coord_param.param_str);
}
}
}
-static void shader_glsl_texldl(const SHADER_OPCODE_ARG *arg)
+static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
{
- IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*)arg->shader;
+ IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
glsl_sample_function_t sample_function;
glsl_src_param_t coord_param, lod_param;
DWORD sample_flags = WINED3D_GLSL_SAMPLE_LOD;
DWORD sampler_type;
DWORD sampler_idx;
- DWORD swizzle = arg->src[1] & WINED3DSP_SWIZZLE_MASK;
+ DWORD swizzle = ins->src[1] & WINED3DSP_SWIZZLE_MASK;
- sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
- sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ sampler_idx = ins->src[1] & WINED3DSP_REGNUM_MASK;
+ sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
if(deviceImpl->stateBlock->textures[sampler_idx] &&
IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
sample_flags |= WINED3D_GLSL_SAMPLE_RECT;
}
shader_glsl_get_sample_function(sampler_type, sample_flags, &sample_function);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &coord_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], sample_function.coord_mask, &coord_param);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &lod_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &lod_param);
- if (shader_is_pshader_version(arg->reg_maps->shader_version))
+ if (shader_is_pshader_version(ins->reg_maps->shader_version))
{
/* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
* However, they seem to work just fine in fragment shaders as well. */
WARN("Using %s in fragment shader.\n", sample_function.name);
}
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, swizzle, lod_param.param_str,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, lod_param.param_str,
"%s", coord_param.param_str);
}
-static void pshader_glsl_texcoord(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texcoord(const struct wined3d_shader_instruction *ins)
{
/* FIXME: Make this work for more than just 2D textures */
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
DWORD write_mask;
char dst_mask[6];
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
shader_glsl_get_write_mask(write_mask, dst_mask);
- if (arg->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
+ if (ins->reg_maps->shader_version != WINED3DPS_VERSION(1,4))
{
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n", reg, dst_mask);
} else {
- DWORD reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
- DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
+ DWORD reg = ins->src[0] & WINED3DSP_REGNUM_MASK;
+ DWORD src_mod = ins->src[0] & WINED3DSP_SRCMOD_MASK;
char dst_swizzle[6];
- shader_glsl_get_swizzle(arg->src[0], FALSE, write_mask, dst_swizzle);
+ shader_glsl_get_swizzle(ins->src[0], FALSE, write_mask, dst_swizzle);
if (src_mod == WINED3DSPSM_DZ) {
glsl_src_param_t div_param;
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &div_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_2, &div_param);
if (mask_size > 1) {
shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
} else if (src_mod == WINED3DSPSM_DW) {
glsl_src_param_t div_param;
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &div_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_3, &div_param);
if (mask_size > 1) {
shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
/** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
* Take a 3-component dot product of the TexCoord[dstreg] and src,
* then perform a 1D texture lookup from stage dstregnum, place into dst. */
-static void pshader_glsl_texdp3tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texdp3tex(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_sample_function_t sample_function;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
UINT mask_size;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
/* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
* scalar, and projected sampling would require 4.
switch(mask_size)
{
case 1:
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"dot(gl_TexCoord[%u].xyz, %s)", sampler_idx, src0_param.param_str);
break;
case 2:
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0)", sampler_idx, src0_param.param_str);
break;
case 3:
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0)", sampler_idx, src0_param.param_str);
break;
/** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
* Take a 3-component dot product of the TexCoord[dstreg] and src. */
-static void pshader_glsl_texdp3(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texdp3(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
- DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD dstreg = ins->dst & WINED3DSP_REGNUM_MASK;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
DWORD dst_mask;
unsigned int mask_size;
- dst_mask = shader_glsl_append_dst(arg->buffer, arg);
+ dst_mask = shader_glsl_append_dst(ins->buffer, ins);
mask_size = shader_glsl_get_write_mask_size(dst_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
if (mask_size > 1) {
- shader_addline(arg->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
+ shader_addline(ins->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
} else {
- shader_addline(arg->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
+ shader_addline(ins->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
}
}
/** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
* Calculate the depth as dst.x / dst.y */
-static void pshader_glsl_texdepth(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texdepth(const struct wined3d_shader_instruction *ins)
{
glsl_dst_param_t dst_param;
- shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
+ shader_glsl_add_dst_param(ins, ins->dst, 0, &dst_param);
/* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
* Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
* too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
* >= 1.0 or < 0.0
*/
- shader_addline(arg->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n", dst_param.reg_name, dst_param.reg_name);
+ shader_addline(ins->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n",
+ dst_param.reg_name, dst_param.reg_name);
}
/** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
* Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
* depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
*/
-static void pshader_glsl_texm3x2depth(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x2depth(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD dstreg = ins->dst & WINED3DSP_REGNUM_MASK;
glsl_src_param_t src0_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
- shader_addline(arg->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
- shader_addline(arg->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
+ shader_addline(ins->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
+ shader_addline(ins->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
}
/** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
* Calculate the 1st of a 2-row matrix multiplication. */
-static void pshader_glsl_texm3x2pad(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x2pad(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
}
/** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
* Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
-static void pshader_glsl_texm3x3pad(const SHADER_OPCODE_ARG* arg)
+static void pshader_glsl_texm3x3pad(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *shader = (IWineD3DPixelShaderImpl *)ins->shader;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
glsl_src_param_t src0_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + current_state->current_row, reg, src0_param.param_str);
current_state->texcoord_w[current_state->current_row++] = reg;
}
-static void pshader_glsl_texm3x2tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x2tex(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
glsl_src_param_t src0_param;
- DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
/* Sample the texture using the calculated coordinates */
- shader_glsl_gen_sample_code(arg, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xy");
+ shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xy");
}
/** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
* Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
-static void pshader_glsl_texm3x3tex(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x3tex(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
glsl_src_param_t src0_param;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
- DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
- shader_addline(arg->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
+ shader_addline(ins->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
/* Sample the texture using the calculated coordinates */
- shader_glsl_gen_sample_code(arg, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
+ shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
current_state->current_row = 0;
}
/** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
* Perform the 3rd row of a 3x3 matrix multiply */
-static void pshader_glsl_texm3x3(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x3(const struct wined3d_shader_instruction *ins)
{
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
glsl_src_param_t src0_param;
char dst_mask[6];
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
- shader_glsl_append_dst(arg->buffer, arg);
- shader_glsl_get_write_mask(arg->dst, dst_mask);
- shader_addline(arg->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_glsl_get_write_mask(ins->dst, dst_mask);
+ shader_addline(ins->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
current_state->current_row = 0;
}
/** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
* Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
-static void pshader_glsl_texm3x3spec(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x3spec(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
+ IWineD3DPixelShaderImpl *shader = (IWineD3DPixelShaderImpl *)ins->shader;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
- SHADER_BUFFER* buffer = arg->buffer;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
- DWORD stype = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD stype = ins->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1], src_mask, &src1_param);
/* Perform the last matrix multiply operation */
shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
shader_glsl_get_sample_function(stype, 0, &sample_function);
/* Sample the texture */
- shader_glsl_gen_sample_code(arg, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
+ shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
current_state->current_row = 0;
}
/** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
* Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
-static void pshader_glsl_texm3x3vspec(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texm3x3vspec(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
- DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
- SHADER_BUFFER* buffer = arg->buffer;
+ IWineD3DPixelShaderImpl *shader = (IWineD3DPixelShaderImpl *)ins->shader;
+ DWORD reg = ins->dst & WINED3DSP_REGNUM_MASK;
+ SHADER_BUFFER *buffer = ins->buffer;
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
glsl_src_param_t src0_param;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
- DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], src_mask, &src0_param);
/* Perform the last matrix multiply operation */
shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
/* Sample the texture using the calculated coordinates */
- shader_glsl_gen_sample_code(arg, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
+ shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DVS_NOSWIZZLE, NULL, "tmp0.xyz");
current_state->current_row = 0;
}
* Apply a fake bump map transform.
* texbem is pshader <= 1.3 only, this saves a few version checks
*/
-static void pshader_glsl_texbem(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texbem(const struct wined3d_shader_instruction *ins)
{
- IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
+ IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
glsl_sample_function_t sample_function;
glsl_src_param_t coord_param;
DWORD flags;
char coord_mask[6];
- sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
+ sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
- sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
mask = sample_function.coord_mask;
case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
}
shader_glsl_get_write_mask(div_mask, coord_div_mask);
- shader_addline(arg->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
+ shader_addline(ins->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
}
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &coord_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0],
+ WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &coord_param);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s", sampler_idx, coord_mask, sampler_idx,
coord_param.param_str, coord_mask);
- if(arg->opcode->opcode == WINED3DSIO_TEXBEML) {
+ if (ins->opcode->opcode == WINED3DSIO_TEXBEML)
+ {
glsl_src_param_t luminance_param;
glsl_dst_param_t dst_param;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
- shader_glsl_add_dst_param(arg, arg->dst, arg->dst_addr, &dst_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
+ shader_glsl_add_dst_param(ins, ins->dst, ins->dst_addr, &dst_param);
- shader_addline(arg->buffer, "%s%s *= (%s * luminancescale%d + luminanceoffset%d);\n",
- dst_param.reg_name, dst_param.mask_str,
- luminance_param.param_str, sampler_idx, sampler_idx);
+ shader_addline(ins->buffer, "%s%s *= (%s * luminancescale%d + luminanceoffset%d);\n",
+ dst_param.reg_name, dst_param.mask_str,
+ luminance_param.param_str, sampler_idx, sampler_idx);
}
}
-static void pshader_glsl_bem(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_bem(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param, src1_param;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0],
+ WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1],
+ WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
- shader_glsl_append_dst(arg->buffer, arg);
- shader_addline(arg->buffer, "%s + bumpenvmat%d * %s);\n",
- src0_param.param_str, sampler_idx, src1_param.param_str);
+ shader_glsl_append_dst(ins->buffer, ins);
+ shader_addline(ins->buffer, "%s + bumpenvmat%d * %s);\n",
+ src0_param.param_str, sampler_idx, src1_param.param_str);
}
/** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
* Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
-static void pshader_glsl_texreg2ar(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texreg2ar(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
- DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"%s.wx", src0_param.reg_name);
}
/** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
* Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
-static void pshader_glsl_texreg2gb(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texreg2gb(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
- DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"%s.yz", src0_param.reg_name);
}
/** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
* Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
-static void pshader_glsl_texreg2rgb(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texreg2rgb(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
- DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
- DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
+ DWORD sampler_idx = ins->dst & WINED3DSP_REGNUM_MASK;
+ DWORD sampler_type = ins->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, 0, &sample_function);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0], sample_function.coord_mask, &src0_param);
- shader_glsl_gen_sample_code(arg, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
+ shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DVS_NOSWIZZLE, NULL,
"%s", src0_param.param_str);
}
/** Process the WINED3DSIO_TEXKILL instruction in GLSL.
* If any of the first 3 components are < 0, discard this pixel */
-static void pshader_glsl_texkill(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_texkill(const struct wined3d_shader_instruction *ins)
{
glsl_dst_param_t dst_param;
/* The argument is a destination parameter, and no writemasks are allowed */
- shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
- if ((arg->reg_maps->shader_version >= WINED3DPS_VERSION(2,0)))
+ shader_glsl_add_dst_param(ins, ins->dst, 0, &dst_param);
+ if ((ins->reg_maps->shader_version >= WINED3DPS_VERSION(2,0)))
{
/* 2.0 shaders compare all 4 components in texkill */
- shader_addline(arg->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
+ shader_addline(ins->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
} else {
/* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
* instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
* 4 components are defined, only the first 3 are used
*/
- shader_addline(arg->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
+ shader_addline(ins->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
}
}
/** Process the WINED3DSIO_DP2ADD instruction in GLSL.
* dst = dot2(src0, src1) + src2 */
-static void pshader_glsl_dp2add(const SHADER_OPCODE_ARG *arg)
+static void pshader_glsl_dp2add(const struct wined3d_shader_instruction *ins)
{
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD write_mask;
unsigned int mask_size;
- write_mask = shader_glsl_append_dst(arg->buffer, arg);
+ write_mask = shader_glsl_append_dst(ins->buffer, ins);
mask_size = shader_glsl_get_write_mask_size(write_mask);
- shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
- shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
- shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], WINED3DSP_WRITEMASK_0, &src2_param);
+ shader_glsl_add_src_param(ins, ins->src[0], ins->src_addr[0],
+ WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
+ shader_glsl_add_src_param(ins, ins->src[1], ins->src_addr[1],
+ WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
+ shader_glsl_add_src_param(ins, ins->src[2], ins->src_addr[2],
+ WINED3DSP_WRITEMASK_0, &src2_param);
if (mask_size > 1) {
- shader_addline(arg->buffer, "vec%d(dot(%s, %s) + %s));\n", mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
+ shader_addline(ins->buffer, "vec%d(dot(%s, %s) + %s));\n",
+ mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
} else {
- shader_addline(arg->buffer, "dot(%s, %s) + %s);\n", src0_param.param_str, src1_param.param_str, src2_param.param_str);
+ shader_addline(ins->buffer, "dot(%s, %s) + %s);\n",
+ src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
}
projects / wine / commitdiff
