[PATCH 4/5] wined3d: Get rid of the WINED3DTEXTUREOP typedef.
Henri Verbeet
hverbeet at codeweavers.com
Tue Jan 10 13:37:01 CST 2012
---
dlls/ddraw/device.c | 58 +++++------
dlls/wined3d/arb_program_shader.c | 144 ++++++++++++++-----------
dlls/wined3d/ati_fragment_shader.c | 193 +++++++++++++++++++---------------
dlls/wined3d/device.c | 30 +++---
dlls/wined3d/nvidia_texture_shader.c | 106 ++++++++++---------
dlls/wined3d/state.c | 141 +++++++++++++------------
dlls/wined3d/stateblock.c | 6 +-
dlls/wined3d/utils.c | 105 ++++++++++---------
dlls/wined3d/wined3d_private.h | 6 +-
include/wine/wined3d.h | 57 +++++-----
10 files changed, 445 insertions(+), 401 deletions(-)
diff --git a/dlls/ddraw/device.c b/dlls/ddraw/device.c
index c250190..9358e9d 100644
--- a/dlls/ddraw/device.c
+++ b/dlls/ddraw/device.c
@@ -2550,21 +2550,18 @@ IDirect3DDeviceImpl_3_GetRenderState(IDirect3DDevice3 *iface,
wined3d_device_get_texture_stage_state(This->wined3d_device, 0, WINED3D_TSS_ALPHA_ARG1, &alphaarg1);
wined3d_device_get_texture_stage_state(This->wined3d_device, 0, WINED3D_TSS_ALPHA_ARG2, &alphaarg2);
- if (colorop == WINED3DTOP_SELECTARG1 && colorarg1 == WINED3DTA_TEXTURE &&
- alphaop == WINED3DTOP_SELECTARG1 && alphaarg1 == WINED3DTA_TEXTURE)
- {
+ if (colorop == WINED3D_TOP_SELECT_ARG1 && colorarg1 == WINED3DTA_TEXTURE
+ && alphaop == WINED3D_TOP_SELECT_ARG1 && alphaarg1 == WINED3DTA_TEXTURE)
*lpdwRenderState = D3DTBLEND_DECAL;
- }
- else if (colorop == WINED3DTOP_SELECTARG1 && colorarg1 == WINED3DTA_TEXTURE &&
- alphaop == WINED3DTOP_MODULATE && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
- {
+ else if (colorop == WINED3D_TOP_SELECT_ARG1 && colorarg1 == WINED3DTA_TEXTURE
+ && alphaop == WINED3D_TOP_MODULATE
+ && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
*lpdwRenderState = D3DTBLEND_DECALALPHA;
- }
- else if (colorop == WINED3DTOP_MODULATE && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT &&
- alphaop == WINED3DTOP_MODULATE && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
- {
+ else if (colorop == WINED3D_TOP_MODULATE
+ && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT
+ && alphaop == WINED3D_TOP_MODULATE
+ && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
*lpdwRenderState = D3DTBLEND_MODULATEALPHA;
- }
else
{
struct wined3d_texture *tex = NULL;
@@ -2591,12 +2588,11 @@ IDirect3DDeviceImpl_3_GetRenderState(IDirect3DDevice3 *iface,
wined3d_texture_decref(tex);
}
- if (!(colorop == WINED3DTOP_MODULATE && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT &&
- alphaop == (tex_alpha ? WINED3DTOP_SELECTARG1 : WINED3DTOP_SELECTARG2) &&
- alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT))
- {
- ERR("Unexpected texture stage state setup, returning D3DTBLEND_MODULATE - likely erroneous\n");
- }
+ if (!(colorop == WINED3D_TOP_MODULATE
+ && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT
+ && alphaop == (tex_alpha ? WINED3D_TOP_SELECT_ARG1 : WINED3D_TOP_SELECT_ARG2)
+ && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT))
+ ERR("Unexpected texture stage state setup, returning D3DTBLEND_MODULATE - likely erroneous.\n");
*lpdwRenderState = D3DTBLEND_MODULATE;
}
@@ -2897,10 +2893,10 @@ IDirect3DDeviceImpl_3_SetRenderState(IDirect3DDevice3 *iface,
if (tex_alpha)
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG1);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
else
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG2);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
wined3d_device_set_texture_stage_state(This->wined3d_device,
@@ -2910,19 +2906,19 @@ IDirect3DDeviceImpl_3_SetRenderState(IDirect3DDevice3 *iface,
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_COLOR_OP, WINED3DTOP_MODULATE);
+ 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
break;
}
case D3DTBLEND_ADD:
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_COLOR_OP, WINED3DTOP_ADD);
+ 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_ADD);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG2);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
break;
@@ -2937,9 +2933,9 @@ IDirect3DDeviceImpl_3_SetRenderState(IDirect3DDevice3 *iface,
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_COLOR_OP, WINED3DTOP_MODULATE);
+ 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_MODULATE);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_MODULATE);
break;
case D3DTBLEND_COPY:
@@ -2949,20 +2945,20 @@ IDirect3DDeviceImpl_3_SetRenderState(IDirect3DDevice3 *iface,
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_COLOR_OP, WINED3DTOP_SELECTARG1);
+ 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_SELECT_ARG1);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG1);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
break;
case D3DTBLEND_DECALALPHA:
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_COLOR_OP, WINED3DTOP_BLENDTEXTUREALPHA);
+ 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_BLEND_TEXTURE_ALPHA);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG2);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
wined3d_device_set_texture_stage_state(This->wined3d_device,
0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
break;
@@ -4766,10 +4762,10 @@ IDirect3DDeviceImpl_3_SetTexture(IDirect3DDevice3 *iface,
/* Arg 1/2 are already set to WINED3DTA_TEXTURE/WINED3DTA_CURRENT in case of D3DTBLEND_MODULATE */
if (tex_alpha)
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG1);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
else
wined3d_device_set_texture_stage_state(This->wined3d_device,
- 0, WINED3D_TSS_ALPHA_OP, WINED3DTOP_SELECTARG2);
+ 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
}
wined3d_mutex_unlock();
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 3e55e83..68f8709 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -5881,22 +5881,24 @@ static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int sta
arg1 = get_argreg(buffer, 1, stage, dw_arg1);
arg2 = get_argreg(buffer, 2, stage, dw_arg2);
- switch(op) {
- case WINED3DTOP_DISABLE:
- if (!stage) shader_addline(buffer, "MOV %s%s, fragment.color.primary;\n", dstreg, dstmask);
+ switch (op)
+ {
+ case WINED3D_TOP_DISABLE:
+ if (!stage)
+ shader_addline(buffer, "MOV %s%s, fragment.color.primary;\n", dstreg, dstmask);
break;
- case WINED3DTOP_SELECTARG2:
+ case WINED3D_TOP_SELECT_ARG2:
arg1 = arg2;
/* FALLTHROUGH */
- case WINED3DTOP_SELECTARG1:
+ case WINED3D_TOP_SELECT_ARG1:
shader_addline(buffer, "MOV %s%s, %s;\n", dstreg, dstmask, arg1);
break;
- case WINED3DTOP_MODULATE4X:
+ case WINED3D_TOP_MODULATE_4X:
mul = 2;
/* FALLTHROUGH */
- case WINED3DTOP_MODULATE2X:
+ case WINED3D_TOP_MODULATE_2X:
mul *= 2;
if (!strcmp(dstreg, "result.color"))
{
@@ -5904,11 +5906,11 @@ static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int sta
mul_final_dest = TRUE;
}
/* FALLTHROUGH */
- case WINED3DTOP_MODULATE:
+ case WINED3D_TOP_MODULATE:
shader_addline(buffer, "MUL %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
break;
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD_SIGNED_2X:
mul = 2;
if (!strcmp(dstreg, "result.color"))
{
@@ -5916,41 +5918,41 @@ static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int sta
mul_final_dest = TRUE;
}
/* FALLTHROUGH */
- case WINED3DTOP_ADDSIGNED:
+ case WINED3D_TOP_ADD_SIGNED:
shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
arg2 = "arg2";
/* FALLTHROUGH */
- case WINED3DTOP_ADD:
+ case WINED3D_TOP_ADD:
shader_addline(buffer, "ADD_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
break;
- case WINED3DTOP_SUBTRACT:
+ case WINED3D_TOP_SUBTRACT:
shader_addline(buffer, "SUB_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
shader_addline(buffer, "SUB arg1, const.x, %s;\n", arg1);
shader_addline(buffer, "MAD_SAT %s%s, arg1, %s, %s;\n", dstreg, dstmask, arg2, arg1);
break;
- case WINED3DTOP_BLENDCURRENTALPHA:
+ case WINED3D_TOP_BLEND_CURRENT_ALPHA:
arg0 = get_argreg(buffer, 0, stage, WINED3DTA_CURRENT);
shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
break;
- case WINED3DTOP_BLENDFACTORALPHA:
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TFACTOR);
shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
break;
- case WINED3DTOP_BLENDTEXTUREALPHA:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
break;
- case WINED3DTOP_BLENDDIFFUSEALPHA:
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
arg0 = get_argreg(buffer, 0, stage, WINED3DTA_DIFFUSE);
shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
break;
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
shader_addline(buffer, "SUB arg0.w, const.x, %s.w;\n", arg0);
shader_addline(buffer, "MAD_SAT %s%s, %s, arg0.w, %s;\n", dstreg, dstmask, arg2, arg1);
@@ -5958,22 +5960,22 @@ static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int sta
/* D3DTOP_PREMODULATE ???? */
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
shader_addline(buffer, "SUB arg0.w, const.x, %s;\n", arg1);
shader_addline(buffer, "MAD_SAT %s%s, arg0.w, %s, %s;\n", dstreg, dstmask, arg2, arg1);
break;
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
shader_addline(buffer, "MAD_SAT %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg1);
break;
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
shader_addline(buffer, "SUB arg0, const.x, %s;\n", arg1);
shader_addline(buffer, "MAD_SAT %s%s, arg0, %s, %s.w;\n", dstreg, dstmask, arg2, arg1);
break;
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s.w;\n", dstreg, dstmask, arg1, arg2, arg1);
break;
- case WINED3DTOP_DOTPRODUCT3:
+ case WINED3D_TOP_DOTPRODUCT3:
mul = 4;
if (!strcmp(dstreg, "result.color"))
{
@@ -5985,17 +5987,17 @@ static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int sta
shader_addline(buffer, "DP3_SAT %s%s, arg1, arg2;\n", dstreg, dstmask);
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg0);
break;
- case WINED3DTOP_LERP:
+ case WINED3D_TOP_LERP:
/* The msdn is not quite right here */
shader_addline(buffer, "LRP %s%s, %s, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
break;
- case WINED3DTOP_BUMPENVMAP:
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
+ case WINED3D_TOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
/* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
break;
@@ -6029,8 +6031,10 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
GLint pos;
/* Find out which textures are read */
- for(stage = 0; stage < MAX_TEXTURES; stage++) {
- if(settings->op[stage].cop == WINED3DTOP_DISABLE) break;
+ for (stage = 0; stage < MAX_TEXTURES; ++stage)
+ {
+ if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
+ break;
arg0 = settings->op[stage].carg0 & WINED3DTA_SELECTMASK;
arg1 = settings->op[stage].carg1 & WINED3DTA_SELECTMASK;
arg2 = settings->op[stage].carg2 & WINED3DTA_SELECTMASK;
@@ -6038,17 +6042,23 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
if(arg1 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
if(arg2 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
- if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHA) tex_read[stage] = TRUE;
- if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHAPM) tex_read[stage] = TRUE;
- if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP) {
+ if (settings->op[stage].cop == WINED3D_TOP_BLEND_TEXTURE_ALPHA)
+ tex_read[stage] = TRUE;
+ if (settings->op[stage].cop == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM)
+ tex_read[stage] = TRUE;
+ if (settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP)
+ {
bump_used[stage] = TRUE;
tex_read[stage] = TRUE;
}
- if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
+ if (settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
+ {
bump_used[stage] = TRUE;
tex_read[stage] = TRUE;
luminance_used[stage] = TRUE;
- } else if(settings->op[stage].cop == WINED3DTOP_BLENDFACTORALPHA) {
+ }
+ else if (settings->op[stage].cop == WINED3D_TOP_BLEND_FACTOR_ALPHA)
+ {
tfactor_used = TRUE;
}
@@ -6061,7 +6071,8 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
tempreg_used = TRUE;
}
- if(settings->op[stage].aop == WINED3DTOP_DISABLE) continue;
+ if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
+ continue;
arg0 = settings->op[stage].aarg0 & WINED3DTA_SELECTMASK;
arg1 = settings->op[stage].aarg1 & WINED3DTA_SELECTMASK;
arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
@@ -6126,8 +6137,10 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
shader_addline(&buffer, "KIL fragment.texcoord[7];\n");
/* Generate texture sampling instructions) */
- for(stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3DTOP_DISABLE; stage++) {
- if(!tex_read[stage]) continue;
+ for (stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3D_TOP_DISABLE; ++stage)
+ {
+ if (!tex_read[stage])
+ continue;
switch(settings->op[stage].tex_type) {
case tex_1d: textype = "1D"; break;
@@ -6138,12 +6151,11 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
default: textype = "unexpected_textype"; break;
}
- if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP ||
- settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
+ if (settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP
+ || settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
sat = "";
- } else {
+ else
sat = "_SAT";
- }
if(settings->op[stage].projected == proj_none) {
instr = "TEX";
@@ -6155,9 +6167,10 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
instr = "TXP";
}
- if(stage > 0 &&
- (settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAP ||
- settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE)) {
+ if (stage > 0
+ && (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP
+ || settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE))
+ {
shader_addline(&buffer, "SWZ arg1, bumpmat%u, x, z, 0, 0;\n", stage - 1);
shader_addline(&buffer, "DP3 ret.x, arg1, tex%u;\n", stage - 1);
shader_addline(&buffer, "SWZ arg1, bumpmat%u, y, w, 0, 0;\n", stage - 1);
@@ -6179,8 +6192,9 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
}
shader_addline(&buffer, "%s%s tex%u, ret, texture[%u], %s;\n",
- instr, sat, stage, stage, textype);
- if(settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
+ instr, sat, stage, stage, textype);
+ if (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
+ {
shader_addline(&buffer, "MAD_SAT ret.x, tex%u.z, luminance%u.x, luminance%u.y;\n",
stage - 1, stage - 1, stage - 1);
shader_addline(&buffer, "MUL tex%u, tex%u, ret.x;\n", stage, stage);
@@ -6203,32 +6217,33 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con
/* Generate the main shader */
for (stage = 0; stage < MAX_TEXTURES; ++stage)
{
- if (settings->op[stage].cop == WINED3DTOP_DISABLE)
+ if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
{
- if (!stage) final_combiner_src = "fragment.color.primary";
+ if (!stage)
+ final_combiner_src = "fragment.color.primary";
break;
}
- if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
- settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
+ if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
+ && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
op_equal = settings->op[stage].carg1 == settings->op[stage].aarg1;
- } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
- settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
+ else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
+ && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
op_equal = settings->op[stage].carg1 == settings->op[stage].aarg2;
- } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
- settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
+ else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
+ && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
op_equal = settings->op[stage].carg2 == settings->op[stage].aarg1;
- } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
- settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
+ else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
+ && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
op_equal = settings->op[stage].carg2 == settings->op[stage].aarg2;
- } else {
- op_equal = settings->op[stage].aop == settings->op[stage].cop &&
- settings->op[stage].carg0 == settings->op[stage].aarg0 &&
- settings->op[stage].carg1 == settings->op[stage].aarg1 &&
- settings->op[stage].carg2 == settings->op[stage].aarg2;
- }
+ else
+ op_equal = settings->op[stage].aop == settings->op[stage].cop
+ && settings->op[stage].carg0 == settings->op[stage].aarg0
+ && settings->op[stage].carg1 == settings->op[stage].aarg1
+ && settings->op[stage].carg2 == settings->op[stage].aarg2;
- if(settings->op[stage].aop == WINED3DTOP_DISABLE) {
+ if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
+ {
gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
settings->op[stage].cop, settings->op[stage].carg0,
settings->op[stage].carg1, settings->op[stage].carg2);
@@ -6337,7 +6352,8 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
new_desc->num_textures_used = 0;
for (i = 0; i < gl_info->limits.texture_stages; ++i)
{
- if(settings.op[i].cop == WINED3DTOP_DISABLE) break;
+ if (settings.op[i].cop == WINED3D_TOP_DISABLE)
+ break;
new_desc->num_textures_used = i;
}
diff --git a/dlls/wined3d/ati_fragment_shader.c b/dlls/wined3d/ati_fragment_shader.c
index 77e9c90..f1bf231 100644
--- a/dlls/wined3d/ati_fragment_shader.c
+++ b/dlls/wined3d/ati_fragment_shader.c
@@ -321,10 +321,10 @@ static GLuint find_tmpreg(const struct texture_stage_op op[MAX_TEXTURES])
BOOL tex_used[MAX_TEXTURES];
memset(tex_used, 0, sizeof(tex_used));
- for(i = 0; i < MAX_TEXTURES; i++) {
- if(op[i].cop == WINED3DTOP_DISABLE) {
+ for (i = 0; i < MAX_TEXTURES; ++i)
+ {
+ if (op[i].cop == WINED3D_TOP_DISABLE)
break;
- }
if(lowest_read == -1 &&
(op[i].carg1 == WINED3DTA_TEMP || op[i].carg2 == WINED3DTA_TEMP || op[i].carg0 == WINED3DTA_TEMP ||
@@ -399,9 +399,11 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
/* Pass 1: Generate sampling instructions for perturbation maps */
for (stage = 0; stage < gl_info->limits.textures; ++stage)
{
- if(op[stage].cop == WINED3DTOP_DISABLE) break;
- if(op[stage].cop != WINED3DTOP_BUMPENVMAP &&
- op[stage].cop != WINED3DTOP_BUMPENVMAPLUMINANCE) continue;
+ if (op[stage].cop == WINED3D_TOP_DISABLE)
+ break;
+ if (op[stage].cop != WINED3D_TOP_BUMPENVMAP
+ && op[stage].cop != WINED3D_TOP_BUMPENVMAP_LUMINANCE)
+ continue;
TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
stage, stage);
@@ -428,9 +430,11 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
GLuint argmodextra_x, argmodextra_y;
struct color_fixup_desc fixup;
- if(op[stage].cop == WINED3DTOP_DISABLE) break;
- if(op[stage].cop != WINED3DTOP_BUMPENVMAP &&
- op[stage].cop != WINED3DTOP_BUMPENVMAPLUMINANCE) continue;
+ if (op[stage].cop == WINED3D_TOP_DISABLE)
+ break;
+ if (op[stage].cop != WINED3D_TOP_BUMPENVMAP
+ && op[stage].cop != WINED3D_TOP_BUMPENVMAP_LUMINANCE)
+ continue;
fixup = op[stage].color_fixup;
if (fixup.x_source != CHANNEL_SOURCE_X || fixup.y_source != CHANNEL_SOURCE_Y)
@@ -474,9 +478,8 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
/* Pass 3: Generate sampling instructions for regular textures */
for (stage = 0; stage < gl_info->limits.textures; ++stage)
{
- if(op[stage].cop == WINED3DTOP_DISABLE) {
+ if (op[stage].cop == WINED3D_TOP_DISABLE)
break;
- }
if(op[stage].projected == proj_none) {
swizzle = GL_SWIZZLE_STR_ATI;
@@ -486,17 +489,18 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
swizzle = GL_SWIZZLE_STQ_DQ_ATI;
}
- if((op[stage].carg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- (op[stage].carg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- (op[stage].carg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- (op[stage].aarg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- (op[stage].aarg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- (op[stage].aarg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
- op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHA) {
-
- if(stage > 0 &&
- (op[stage - 1].cop == WINED3DTOP_BUMPENVMAP ||
- op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE)) {
+ if ((op[stage].carg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || (op[stage].carg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || (op[stage].carg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || (op[stage].aarg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || (op[stage].aarg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || (op[stage].aarg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
+ || op[stage].cop == WINED3D_TOP_BLEND_TEXTURE_ALPHA)
+ {
+ if (stage > 0
+ && (op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP
+ || op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE))
+ {
TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_REG_%d_ATI, GL_SWIZZLE_STR_ATI)\n",
stage, stage);
GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage,
@@ -515,7 +519,7 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
/* Pass 4: Generate the arithmetic instructions */
for (stage = 0; stage < MAX_TEXTURES; ++stage)
{
- if (op[stage].cop == WINED3DTOP_DISABLE)
+ if (op[stage].cop == WINED3D_TOP_DISABLE)
{
if (!stage)
{
@@ -546,51 +550,52 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
argmodextra = GL_NONE;
extrarg = GL_NONE;
- switch(op[stage].cop) {
- case WINED3DTOP_SELECTARG2:
+ switch (op[stage].cop)
+ {
+ case WINED3D_TOP_SELECT_ARG2:
arg1 = arg2;
argmod1 = argmod2;
rep1 = rep2;
/* fall through */
- case WINED3DTOP_SELECTARG1:
+ case WINED3D_TOP_SELECT_ARG1:
wrap_op1(gl_info, GL_MOV_ATI, dstreg, GL_NONE, GL_NONE,
arg1, rep1, argmod1);
break;
- case WINED3DTOP_MODULATE4X:
+ case WINED3D_TOP_MODULATE_4X:
if(dstmod == GL_NONE) dstmod = GL_4X_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATE2X:
+ case WINED3D_TOP_MODULATE_2X:
if(dstmod == GL_NONE) dstmod = GL_2X_BIT_ATI;
dstmod |= GL_SATURATE_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATE:
+ case WINED3D_TOP_MODULATE:
wrap_op2(gl_info, GL_MUL_ATI, dstreg, GL_NONE, dstmod,
arg1, rep1, argmod1,
arg2, rep2, argmod2);
break;
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD_SIGNED_2X:
dstmod = GL_2X_BIT_ATI;
/* fall through */
- case WINED3DTOP_ADDSIGNED:
+ case WINED3D_TOP_ADD_SIGNED:
argmodextra = GL_BIAS_BIT_ATI;
/* fall through */
- case WINED3DTOP_ADD:
+ case WINED3D_TOP_ADD:
dstmod |= GL_SATURATE_BIT_ATI;
wrap_op2(gl_info, GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, dstmod,
arg1, rep1, argmod1,
arg2, rep2, argmodextra | argmod2);
break;
- case WINED3DTOP_SUBTRACT:
+ case WINED3D_TOP_SUBTRACT:
dstmod |= GL_SATURATE_BIT_ATI;
wrap_op2(gl_info, GL_SUB_ATI, dstreg, GL_NONE, dstmod,
arg1, rep1, argmod1,
arg2, rep2, argmod2);
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
/* Dst = arg1 + * arg2(1 -arg 1)
* = arg2 * (1 - arg1) + arg1
@@ -601,24 +606,28 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
arg1, rep1, argmod1);
break;
- case WINED3DTOP_BLENDCURRENTALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_CURRENT_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDFACTORALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDTEXTUREALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDDIFFUSEALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, NULL, -1);
wrap_op3(gl_info, GL_LERP_ATI, dstreg, GL_NONE, GL_NONE,
extrarg, GL_ALPHA, GL_NONE,
arg1, rep1, argmod1,
arg2, rep2, argmod2);
break;
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
arg0 = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_NONE, GL_NONE,
arg2, rep2, argmod2,
@@ -628,50 +637,52 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
/* D3DTOP_PREMODULATE ???? */
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
- if(!argmodextra) argmodextra = argmod1;
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
+ if (!argmodextra)
+ argmodextra = argmod1;
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
arg2, rep2, argmod2,
arg1, GL_ALPHA, argmodextra,
arg1, rep1, argmod1);
break;
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
- if(!argmodextra) argmodextra = argmod1;
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
+ if (!argmodextra)
+ argmodextra = argmod1;
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
arg2, rep2, argmod2,
arg1, rep1, argmodextra,
arg1, GL_ALPHA, argmod1);
break;
- case WINED3DTOP_DOTPRODUCT3:
+ case WINED3D_TOP_DOTPRODUCT3:
wrap_op2(gl_info, GL_DOT3_ATI, dstreg, GL_NONE, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI,
arg1, rep1, argmod1 | GL_BIAS_BIT_ATI,
arg2, rep2, argmod2 | GL_BIAS_BIT_ATI);
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
arg1, rep1, argmod1,
arg2, rep2, argmod2,
arg0, rep0, argmod0);
break;
- case WINED3DTOP_LERP:
+ case WINED3D_TOP_LERP:
wrap_op3(gl_info, GL_LERP_ATI, dstreg, GL_NONE, GL_NONE,
arg0, rep0, argmod0,
arg1, rep1, argmod1,
arg2, rep2, argmod2);
break;
- case WINED3DTOP_BUMPENVMAP:
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
+ case WINED3D_TOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
/* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
break;
@@ -685,8 +696,9 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
argmodextra = GL_NONE;
extrarg = GL_NONE;
- switch(op[stage].aop) {
- case WINED3DTOP_DISABLE:
+ switch (op[stage].aop)
+ {
+ case WINED3D_TOP_DISABLE:
/* Get the primary color to the output if on stage 0, otherwise leave register 0 untouched */
if (!stage)
{
@@ -695,49 +707,51 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
}
break;
- case WINED3DTOP_SELECTARG2:
+ case WINED3D_TOP_SELECT_ARG2:
arg1 = arg2;
argmod1 = argmod2;
/* fall through */
- case WINED3DTOP_SELECTARG1:
+ case WINED3D_TOP_SELECT_ARG1:
wrap_op1(gl_info, GL_MOV_ATI, dstreg, GL_ALPHA, GL_NONE,
arg1, GL_NONE, argmod1);
break;
- case WINED3DTOP_MODULATE4X:
- if(dstmod == GL_NONE) dstmod = GL_4X_BIT_ATI;
+ case WINED3D_TOP_MODULATE_4X:
+ if (dstmod == GL_NONE)
+ dstmod = GL_4X_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATE2X:
- if(dstmod == GL_NONE) dstmod = GL_2X_BIT_ATI;
+ case WINED3D_TOP_MODULATE_2X:
+ if (dstmod == GL_NONE)
+ dstmod = GL_2X_BIT_ATI;
dstmod |= GL_SATURATE_BIT_ATI;
/* fall through */
- case WINED3DTOP_MODULATE:
+ case WINED3D_TOP_MODULATE:
wrap_op2(gl_info, GL_MUL_ATI, dstreg, GL_ALPHA, dstmod,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmod2);
break;
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD_SIGNED_2X:
dstmod = GL_2X_BIT_ATI;
/* fall through */
- case WINED3DTOP_ADDSIGNED:
+ case WINED3D_TOP_ADD_SIGNED:
argmodextra = GL_BIAS_BIT_ATI;
/* fall through */
- case WINED3DTOP_ADD:
+ case WINED3D_TOP_ADD:
dstmod |= GL_SATURATE_BIT_ATI;
wrap_op2(gl_info, GL_ADD_ATI, dstreg, GL_ALPHA, dstmod,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmodextra | argmod2);
break;
- case WINED3DTOP_SUBTRACT:
+ case WINED3D_TOP_SUBTRACT:
dstmod |= GL_SATURATE_BIT_ATI;
wrap_op2(gl_info, GL_SUB_ATI, dstreg, GL_ALPHA, dstmod,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmod2);
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
/* Dst = arg1 + * arg2(1 -arg 1)
* = arg2 * (1 - arg1) + arg1
@@ -748,24 +762,28 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
arg1, GL_NONE, argmod1);
break;
- case WINED3DTOP_BLENDCURRENTALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_CURRENT_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDFACTORALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDTEXTUREALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
/* fall through */
- case WINED3DTOP_BLENDDIFFUSEALPHA:
- if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, NULL, -1);
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
+ if (extrarg == GL_NONE)
+ extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, NULL, -1);
wrap_op3(gl_info, GL_LERP_ATI, dstreg, GL_ALPHA, GL_NONE,
extrarg, GL_ALPHA, GL_NONE,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmod2);
break;
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
arg0 = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, NULL, -1);
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_ALPHA, GL_NONE,
arg2, GL_NONE, argmod2,
@@ -775,32 +793,32 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], con
/* D3DTOP_PREMODULATE ???? */
- case WINED3DTOP_DOTPRODUCT3:
+ case WINED3D_TOP_DOTPRODUCT3:
wrap_op2(gl_info, GL_DOT3_ATI, dstreg, GL_ALPHA, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI,
arg1, GL_NONE, argmod1 | GL_BIAS_BIT_ATI,
arg2, GL_NONE, argmod2 | GL_BIAS_BIT_ATI);
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
wrap_op3(gl_info, GL_MAD_ATI, dstreg, GL_ALPHA, GL_SATURATE_BIT_ATI,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmod2,
arg0, GL_NONE, argmod0);
break;
- case WINED3DTOP_LERP:
+ case WINED3D_TOP_LERP:
wrap_op3(gl_info, GL_LERP_ATI, dstreg, GL_ALPHA, GL_SATURATE_BIT_ATI,
arg1, GL_NONE, argmod1,
arg2, GL_NONE, argmod2,
arg0, GL_NONE, argmod0);
break;
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
- case WINED3DTOP_BUMPENVMAP:
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
+ case WINED3D_TOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
ERR("Application uses an invalid alpha operation\n");
break;
@@ -836,7 +854,8 @@ static void set_tex_op_atifs(struct wined3d_context *context, const struct wined
new_desc->num_textures_used = 0;
for (i = 0; i < gl_info->limits.texture_stages; ++i)
{
- if(settings.op[i].cop == WINED3DTOP_DISABLE) break;
+ if (settings.op[i].cop == WINED3D_TOP_DISABLE)
+ break;
new_desc->num_textures_used = i;
}
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index c01d53c..3551a14 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -2812,8 +2812,8 @@ static void device_update_fixed_function_usage_map(struct wined3d_device *device
for (i = 0; i < MAX_TEXTURES; ++i)
{
const struct wined3d_state *state = &device->stateBlock->state;
- WINED3DTEXTUREOP color_op = state->texture_states[i][WINED3D_TSS_COLOR_OP];
- WINED3DTEXTUREOP alpha_op = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
+ enum wined3d_texture_op color_op = state->texture_states[i][WINED3D_TSS_COLOR_OP];
+ enum wined3d_texture_op alpha_op = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
DWORD color_arg1 = state->texture_states[i][WINED3D_TSS_COLOR_ARG1] & WINED3DTA_SELECTMASK;
DWORD color_arg2 = state->texture_states[i][WINED3D_TSS_COLOR_ARG2] & WINED3DTA_SELECTMASK;
DWORD color_arg3 = state->texture_states[i][WINED3D_TSS_COLOR_ARG0] & WINED3DTA_SELECTMASK;
@@ -2821,22 +2821,22 @@ static void device_update_fixed_function_usage_map(struct wined3d_device *device
DWORD alpha_arg2 = state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] & WINED3DTA_SELECTMASK;
DWORD alpha_arg3 = state->texture_states[i][WINED3D_TSS_ALPHA_ARG0] & WINED3DTA_SELECTMASK;
- if (color_op == WINED3DTOP_DISABLE) {
- /* Not used, and disable higher stages */
+ /* Not used, and disable higher stages. */
+ if (color_op == WINED3D_TOP_DISABLE)
break;
- }
- if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
- || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
+ if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3D_TOP_SELECT_ARG2)
+ || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3D_TOP_SELECT_ARG1)
|| ((color_arg3 == WINED3DTA_TEXTURE)
- && (color_op == WINED3DTOP_MULTIPLYADD || color_op == WINED3DTOP_LERP))
- || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
- || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
+ && (color_op == WINED3D_TOP_MULTIPLY_ADD || color_op == WINED3D_TOP_LERP))
+ || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3D_TOP_SELECT_ARG2)
+ || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3D_TOP_SELECT_ARG1)
|| ((alpha_arg3 == WINED3DTA_TEXTURE)
- && (alpha_op == WINED3DTOP_MULTIPLYADD || alpha_op == WINED3DTOP_LERP)))
+ && (alpha_op == WINED3D_TOP_MULTIPLY_ADD || alpha_op == WINED3D_TOP_LERP)))
device->fixed_function_usage_map |= (1 << i);
- if ((color_op == WINED3DTOP_BUMPENVMAP || color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1)
+ if ((color_op == WINED3D_TOP_BUMPENVMAP || color_op == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
+ && i < MAX_TEXTURES - 1)
device->fixed_function_usage_map |= (1 << (i + 1));
}
}
@@ -3644,7 +3644,7 @@ HRESULT CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *devi
{
unsigned int i;
- if (value == WINED3DTOP_DISABLE && old_value != WINED3DTOP_DISABLE)
+ if (value == WINED3D_TOP_DISABLE && old_value != WINED3D_TOP_DISABLE)
{
/* Previously enabled stage disabled now. Make sure to dirtify
* all enabled stages above stage, they have to be disabled.
@@ -3658,7 +3658,7 @@ HRESULT CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *devi
device->stateBlock->state.lowest_disabled_stage = stage;
TRACE("New lowest disabled: %u.\n", stage);
}
- else if (value != WINED3DTOP_DISABLE && old_value == WINED3DTOP_DISABLE)
+ else if (value != WINED3D_TOP_DISABLE && old_value == WINED3D_TOP_DISABLE)
{
/* Previously disabled stage enabled. Stages above it may need
* enabling. Stage must be lowest_disabled_stage here, if it's
@@ -3670,7 +3670,7 @@ HRESULT CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *devi
* handled below. */
for (i = stage + 1; i < gl_info->limits.texture_stages; ++i)
{
- if (device->updateStateBlock->state.texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3DTOP_DISABLE)
+ if (device->updateStateBlock->state.texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
break;
TRACE("Additionally dirtifying stage %u due to enable.\n", i);
device_invalidate_state(device, STATE_TEXTURESTAGE(i, WINED3D_TSS_COLOR_OP));
diff --git a/dlls/wined3d/nvidia_texture_shader.c b/dlls/wined3d/nvidia_texture_shader.c
index 32c7716..dc3f8b9 100644
--- a/dlls/wined3d/nvidia_texture_shader.c
+++ b/dlls/wined3d/nvidia_texture_shader.c
@@ -34,8 +34,9 @@ static void nvts_activate_dimensions(const struct wined3d_state *state, DWORD st
{
BOOL bumpmap = FALSE;
- if (stage > 0 && (state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3DTOP_BUMPENVMAPLUMINANCE
- || state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3DTOP_BUMPENVMAP))
+ if (stage > 0
+ && (state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
+ || state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP))
{
bumpmap = TRUE;
context->texShaderBumpMap |= (1 << stage);
@@ -133,7 +134,7 @@ static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum*
}
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state, BOOL is_alpha,
- int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst)
+ int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst)
{
struct tex_op_args tex_op_args = {{0}, {0}, {0}};
GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
@@ -148,7 +149,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
if (is_invalid_op(state, stage, op, arg1, arg2, arg3))
{
arg1 = WINED3DTA_CURRENT;
- op = WINED3DTOP_SELECTARG1;
+ op = WINED3D_TOP_SELECT_ARG1;
}
get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
@@ -166,9 +167,9 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
}
/* This is called by a state handler which has the gl lock held and a context for the thread */
- switch(op)
+ switch (op)
{
- case WINED3DTOP_DISABLE:
+ case WINED3D_TOP_DISABLE:
/* Only for alpha */
if (!is_alpha)
ERR("Shouldn't be called for WINED3D_TSS_COLOR_OP (WINED3DTOP_DISABLE).\n");
@@ -183,16 +184,15 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_SELECTARG1:
- case WINED3DTOP_SELECTARG2:
+ case WINED3D_TOP_SELECT_ARG1:
+ case WINED3D_TOP_SELECT_ARG2:
/* Input, arg*1 */
- if (op == WINED3DTOP_SELECTARG1) {
+ if (op == WINED3D_TOP_SELECT_ARG1)
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
- } else {
+ else
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
- }
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
@@ -201,9 +201,9 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_MODULATE:
- case WINED3DTOP_MODULATE2X:
- case WINED3DTOP_MODULATE4X:
+ case WINED3D_TOP_MODULATE:
+ case WINED3D_TOP_MODULATE_2X:
+ case WINED3D_TOP_MODULATE_4X:
/* Input, arg1*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
@@ -211,21 +211,20 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
- if (op == WINED3DTOP_MODULATE) {
+ if (op == WINED3D_TOP_MODULATE)
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
- } else if (op == WINED3DTOP_MODULATE2X) {
+ else if (op == WINED3D_TOP_MODULATE_2X)
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
- } else if (op == WINED3DTOP_MODULATE4X) {
+ else if (op == WINED3D_TOP_MODULATE_4X)
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
- }
break;
- case WINED3DTOP_ADD:
- case WINED3DTOP_ADDSIGNED:
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD:
+ case WINED3D_TOP_ADD_SIGNED:
+ case WINED3D_TOP_ADD_SIGNED_2X:
/* Input, arg1*1+arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
@@ -237,19 +236,18 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
- if (op == WINED3DTOP_ADD) {
+ if (op == WINED3D_TOP_ADD)
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
- } else if (op == WINED3DTOP_ADDSIGNED) {
+ else if (op == WINED3D_TOP_ADD_SIGNED)
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
- } else if (op == WINED3DTOP_ADDSIGNED2X) {
+ else if (op == WINED3D_TOP_ADD_SIGNED_2X)
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
- }
break;
- case WINED3DTOP_SUBTRACT:
+ case WINED3D_TOP_SUBTRACT:
/* Input, arg1*1+-arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
@@ -265,7 +263,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
/* Input, arg1*1+(1-arg1)*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
@@ -281,24 +279,30 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_BLENDDIFFUSEALPHA:
- case WINED3DTOP_BLENDTEXTUREALPHA:
- case WINED3DTOP_BLENDFACTORALPHA:
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
- case WINED3DTOP_BLENDCURRENTALPHA:
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
+ case WINED3D_TOP_BLEND_CURRENT_ALPHA:
{
GLenum alpha_src = GL_PRIMARY_COLOR_NV;
- if (op == WINED3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
- else if (op == WINED3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
- else if (op == WINED3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
- else if (op == WINED3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
- else if (op == WINED3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
- else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
+ if (op == WINED3D_TOP_BLEND_DIFFUSE_ALPHA)
+ alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
+ else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA)
+ alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
+ else if (op == WINED3D_TOP_BLEND_FACTOR_ALPHA)
+ alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
+ else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM)
+ alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
+ else if (op == WINED3D_TOP_BLEND_CURRENT_ALPHA)
+ alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
+ else
+ FIXME("Unhandled texture op %s, shouldn't happen.\n", debug_d3dtop(op));
/* Input, arg1*alpha_src+arg2*(1-alpha_src) */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
- if (op == WINED3DTOP_BLENDTEXTUREALPHAPM)
+ if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM)
{
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
@@ -317,7 +321,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
break;
}
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
/* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
if (is_alpha)
ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEALPHA_ADDCOLOR).\n");
@@ -335,7 +339,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
/* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
if (is_alpha)
ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATECOLOR_ADDALPHA).\n");
@@ -353,7 +357,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
/* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
if (is_alpha)
ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR).\n");
@@ -371,7 +375,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
/* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
if (is_alpha)
ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA).\n");
@@ -389,7 +393,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_DOTPRODUCT3:
+ case WINED3D_TOP_DOTPRODUCT3:
/* Input, arg1 . arg2 */
/* FIXME: DX7 uses a different calculation? */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
@@ -402,7 +406,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
/* Input, arg3*1+arg1*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
@@ -418,7 +422,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_LERP:
+ case WINED3D_TOP_LERP:
/* Input, arg3*arg1+(1-arg3)*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
@@ -434,8 +438,8 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
- case WINED3DTOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
+ case WINED3D_TOP_BUMPENVMAP:
if (gl_info->supported[NV_TEXTURE_SHADER])
{
/* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
@@ -454,7 +458,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
}
default:
- FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
+ FIXME("Unhandled texture op: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d.\n",
stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
}
@@ -557,8 +561,8 @@ static void nvrc_colorop(struct wined3d_context *context, const struct wined3d_s
*/
if (gl_info->supported[NV_TEXTURE_SHADER2])
{
- BOOL usesBump = (state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3DTOP_BUMPENVMAPLUMINANCE
- || state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3DTOP_BUMPENVMAP);
+ BOOL usesBump = (state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
+ || state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP);
BOOL usedBump = !!(context->texShaderBumpMap & 1 << (stage + 1));
if (usesBump != usedBump)
{
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index ff25d1f..fcd88b0 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -2038,7 +2038,7 @@ static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* op
/* Setup the texture operations texture stage states */
static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
- BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
+ BOOL isAlpha, int Stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
{
GLenum src1, src2, src3;
GLenum opr1, opr2, opr3;
@@ -2092,7 +2092,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
if (is_invalid_op(state, Stage, op, arg1, arg2, arg3))
{
arg1 = WINED3DTA_CURRENT;
- op = WINED3DTOP_SELECTARG1;
+ op = WINED3D_TOP_SELECT_ARG1;
}
if (isAlpha && !state->textures[Stage] && arg1 == WINED3DTA_TEXTURE)
@@ -2122,8 +2122,9 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
src3_target = GL_SOURCE3_RGB_NV;
opr3_target = GL_OPERAND3_RGB_NV;
}
- switch (op) {
- case WINED3DTOP_DISABLE: /* Only for alpha */
+ switch (op)
+ {
+ case WINED3D_TOP_DISABLE: /* Only for alpha */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
@@ -2143,11 +2144,12 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
- case WINED3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
- case WINED3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
+ case WINED3D_TOP_SELECT_ARG1: /* = a1 * 1 + 0 * 0 */
+ case WINED3D_TOP_SELECT_ARG2: /* = a2 * 1 + 0 * 0 */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
- if (op == WINED3DTOP_SELECTARG1) {
+ if (op == WINED3D_TOP_SELECT_ARG1)
+ {
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
@@ -2172,7 +2174,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
- case WINED3DTOP_MODULATE:
+ case WINED3D_TOP_MODULATE:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2194,7 +2196,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATE2X:
+ case WINED3D_TOP_MODULATE_2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2216,7 +2218,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
- case WINED3DTOP_MODULATE4X:
+ case WINED3D_TOP_MODULATE_4X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2239,7 +2241,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
- case WINED3DTOP_ADD:
+ case WINED3D_TOP_ADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2262,7 +2264,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_ADDSIGNED:
+ case WINED3D_TOP_ADD_SIGNED:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2285,7 +2287,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD_SIGNED_2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2308,7 +2310,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2337,7 +2339,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDDIFFUSEALPHA:
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2359,7 +2361,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDTEXTUREALPHA:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2381,7 +2383,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDFACTORALPHA:
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2403,7 +2405,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2425,7 +2427,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
@@ -2451,7 +2453,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2477,7 +2479,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2505,7 +2507,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2537,7 +2539,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
@@ -2560,11 +2562,8 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BUMPENVMAP:
- {
- }
-
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
+ case WINED3D_TOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
default:
@@ -2580,7 +2579,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
Handled = TRUE; /* Again, assume handled */
switch (op) {
- case WINED3DTOP_DISABLE: /* Only for alpha */
+ case WINED3D_TOP_DISABLE: /* Only for alpha */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
@@ -2590,7 +2589,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_SELECTARG1:
+ case WINED3D_TOP_SELECT_ARG1:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2600,7 +2599,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_SELECTARG2:
+ case WINED3D_TOP_SELECT_ARG2:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
@@ -2610,7 +2609,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATE:
+ case WINED3D_TOP_MODULATE:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2624,7 +2623,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_MODULATE2X:
+ case WINED3D_TOP_MODULATE_2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2638,7 +2637,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
- case WINED3DTOP_MODULATE4X:
+ case WINED3D_TOP_MODULATE_4X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2652,7 +2651,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
- case WINED3DTOP_ADD:
+ case WINED3D_TOP_ADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2666,7 +2665,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_ADDSIGNED:
+ case WINED3D_TOP_ADD_SIGNED:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2680,7 +2679,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_ADDSIGNED2X:
+ case WINED3D_TOP_ADD_SIGNED_2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2694,7 +2693,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
- case WINED3DTOP_SUBTRACT:
+ case WINED3D_TOP_SUBTRACT:
if (gl_info->supported[ARB_TEXTURE_ENV_COMBINE])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
@@ -2714,7 +2713,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
}
break;
- case WINED3DTOP_BLENDDIFFUSEALPHA:
+ case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2732,7 +2731,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDTEXTUREALPHA:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2750,7 +2749,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDFACTORALPHA:
+ case WINED3D_TOP_BLEND_FACTOR_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2768,7 +2767,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_BLENDCURRENTALPHA:
+ case WINED3D_TOP_BLEND_CURRENT_ALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2786,7 +2785,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_DOTPRODUCT3:
+ case WINED3D_TOP_DOTPRODUCT3:
if (gl_info->supported[ARB_TEXTURE_ENV_DOT3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
@@ -2810,7 +2809,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_LERP:
+ case WINED3D_TOP_LERP:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
@@ -2828,7 +2827,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
- case WINED3DTOP_ADDSMOOTH:
+ case WINED3D_TOP_ADD_SMOOTH:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2856,7 +2855,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2878,7 +2877,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2906,7 +2905,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2934,7 +2933,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2962,7 +2961,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -2996,7 +2995,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_MULTIPLYADD:
+ case WINED3D_TOP_MULTIPLY_ADD:
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
{
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
@@ -3018,8 +3017,8 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
} else
Handled = FALSE;
break;
- case WINED3DTOP_BUMPENVMAPLUMINANCE:
- case WINED3DTOP_BUMPENVMAP:
+ case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
+ case WINED3D_TOP_BUMPENVMAP:
if (gl_info->supported[NV_TEXTURE_SHADER2])
{
/* Technically texture shader support without register combiners is possible, but not expected to occur
@@ -3043,18 +3042,20 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
op2 = state->texture_states[Stage][WINED3D_TSS_ALPHA_OP];
/* Note: If COMBINE4 in effect can't go back to combine! */
- switch (op2) {
- case WINED3DTOP_ADDSMOOTH:
- case WINED3DTOP_BLENDTEXTUREALPHAPM:
- case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
- case WINED3DTOP_MODULATECOLOR_ADDALPHA:
- case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
- case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
- case WINED3DTOP_MULTIPLYADD:
+ switch (op2)
+ {
+ case WINED3D_TOP_ADD_SMOOTH:
+ case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
+ case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
+ case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
+ case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
+ case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
+ case WINED3D_TOP_MULTIPLY_ADD:
/* Ignore those implemented in both cases */
- switch (op) {
- case WINED3DTOP_SELECTARG1:
- case WINED3DTOP_SELECTARG2:
+ switch (op)
+ {
+ case WINED3D_TOP_SELECT_ARG1:
+ case WINED3D_TOP_SELECT_ARG2:
combineOK = FALSE;
Handled = FALSE;
break;
@@ -3200,26 +3201,26 @@ void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *st
*
* What to do with multitexturing? So far no app has been found that uses color keying with
* multitexturing */
- if (op == WINED3DTOP_DISABLE)
+ if (op == WINED3D_TOP_DISABLE)
{
arg1 = WINED3DTA_TEXTURE;
- op = WINED3DTOP_SELECTARG1;
+ op = WINED3D_TOP_SELECT_ARG1;
}
- else if(op == WINED3DTOP_SELECTARG1 && arg1 != WINED3DTA_TEXTURE)
+ else if (op == WINED3D_TOP_SELECT_ARG1 && arg1 != WINED3DTA_TEXTURE)
{
if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
arg2 = WINED3DTA_TEXTURE;
- op = WINED3DTOP_MODULATE;
+ op = WINED3D_TOP_MODULATE;
}
else arg1 = WINED3DTA_TEXTURE;
}
- else if(op == WINED3DTOP_SELECTARG2 && arg2 != WINED3DTA_TEXTURE)
+ else if (op == WINED3D_TOP_SELECT_ARG2 && arg2 != WINED3DTA_TEXTURE)
{
if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
arg1 = WINED3DTA_TEXTURE;
- op = WINED3DTOP_MODULATE;
+ op = WINED3D_TOP_MODULATE;
}
else arg2 = WINED3DTA_TEXTURE;
}
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index fd03942..c1a863d 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -1072,7 +1072,7 @@ HRESULT CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblo
stateblock->device->stateBlock->state.lowest_disabled_stage = MAX_TEXTURES - 1;
for (i = 0; i < MAX_TEXTURES - 1; ++i)
{
- if (stateblock->device->stateBlock->state.texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3DTOP_DISABLE)
+ if (stateblock->device->stateBlock->state.texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
{
stateblock->device->stateBlock->state.lowest_disabled_stage = i;
break;
@@ -1254,10 +1254,10 @@ void stateblock_init_default_state(struct wined3d_stateblock *stateblock)
{
TRACE("Setting up default texture states for texture Stage %u.\n", i);
memcpy(&state->transforms[WINED3DTS_TEXTURE0 + i], identity, sizeof(identity));
- state->texture_states[i][WINED3D_TSS_COLOR_OP] = i ? WINED3DTOP_DISABLE : WINED3DTOP_MODULATE;
+ state->texture_states[i][WINED3D_TSS_COLOR_OP] = i ? WINED3D_TOP_DISABLE : WINED3D_TOP_MODULATE;
state->texture_states[i][WINED3D_TSS_COLOR_ARG1] = WINED3DTA_TEXTURE;
state->texture_states[i][WINED3D_TSS_COLOR_ARG2] = WINED3DTA_CURRENT;
- state->texture_states[i][WINED3D_TSS_ALPHA_OP] = i ? WINED3DTOP_DISABLE : WINED3DTOP_SELECTARG1;
+ state->texture_states[i][WINED3D_TSS_ALPHA_OP] = i ? WINED3D_TOP_DISABLE : WINED3D_TOP_SELECT_ARG1;
state->texture_states[i][WINED3D_TSS_ALPHA_ARG1] = WINED3DTA_TEXTURE;
state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] = WINED3DTA_CURRENT;
state->texture_states[i][WINED3D_TSS_BUMPENV_MAT00] = 0;
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 309f747..b3867a1 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -2227,38 +2227,40 @@ const char *debug_d3dtexturestate(enum wined3d_texture_stage_state state)
}
}
-const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
- switch (d3dtop) {
+const char *debug_d3dtop(enum wined3d_texture_op d3dtop)
+{
+ switch (d3dtop)
+ {
#define D3DTOP_TO_STR(u) case u: return #u
- D3DTOP_TO_STR(WINED3DTOP_DISABLE);
- D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
- D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
- D3DTOP_TO_STR(WINED3DTOP_MODULATE);
- D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
- D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
- D3DTOP_TO_STR(WINED3DTOP_ADD);
- D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
- D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
- D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
- D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
- D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
- D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
- D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
- D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
- D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
- D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
- D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
- D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
- D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
- D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
- D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
- D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
- D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
- D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
- D3DTOP_TO_STR(WINED3DTOP_LERP);
+ D3DTOP_TO_STR(WINED3D_TOP_DISABLE);
+ D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG1);
+ D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG2);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_2X);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_4X);
+ D3DTOP_TO_STR(WINED3D_TOP_ADD);
+ D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED);
+ D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED_2X);
+ D3DTOP_TO_STR(WINED3D_TOP_SUBTRACT);
+ D3DTOP_TO_STR(WINED3D_TOP_ADD_SMOOTH);
+ D3DTOP_TO_STR(WINED3D_TOP_BLEND_DIFFUSE_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_BLEND_FACTOR_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM);
+ D3DTOP_TO_STR(WINED3D_TOP_BLEND_CURRENT_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_PREMODULATE);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR);
+ D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA);
+ D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP);
+ D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP_LUMINANCE);
+ D3DTOP_TO_STR(WINED3D_TOP_DOTPRODUCT3);
+ D3DTOP_TO_STR(WINED3D_TOP_MULTIPLY_ADD);
+ D3DTOP_TO_STR(WINED3D_TOP_LERP);
#undef D3DTOP_TO_STR
default:
- FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
+ FIXME("Unrecognized texture op %#x.\n", d3dtop);
return "unrecognized";
}
}
@@ -2478,17 +2480,22 @@ const char *debug_surflocation(DWORD flag) {
}
BOOL is_invalid_op(const struct wined3d_state *state, int stage,
- WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
+ enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
{
- if (op == WINED3DTOP_DISABLE) return FALSE;
- if (state->textures[stage]) return FALSE;
+ if (op == WINED3D_TOP_DISABLE)
+ return FALSE;
+ if (state->textures[stage])
+ return FALSE;
if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
- && op != WINED3DTOP_SELECTARG2) return TRUE;
+ && op != WINED3D_TOP_SELECT_ARG2)
+ return TRUE;
if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
- && op != WINED3DTOP_SELECTARG1) return TRUE;
+ && op != WINED3D_TOP_SELECT_ARG1)
+ return TRUE;
if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
- && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
+ && (op == WINED3D_TOP_MULTIPLY_ADD || op == WINED3D_TOP_LERP))
+ return TRUE;
return FALSE;
}
@@ -2859,7 +2866,8 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
#define ARG1 0x01
#define ARG2 0x02
#define ARG0 0x04
- static const unsigned char args[WINED3DTOP_LERP + 1] = {
+ static const unsigned char args[WINED3D_TOP_LERP + 1] =
+ {
/* undefined */ 0,
/* D3DTOP_DISABLE */ 0,
/* D3DTOP_SELECTARG1 */ ARG1,
@@ -2899,10 +2907,10 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
const struct wined3d_texture *texture;
settings->op[i].padding = 0;
- if (state->texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3DTOP_DISABLE)
+ if (state->texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
{
- settings->op[i].cop = WINED3DTOP_DISABLE;
- settings->op[i].aop = WINED3DTOP_DISABLE;
+ settings->op[i].cop = WINED3D_TOP_DISABLE;
+ settings->op[i].aop = WINED3D_TOP_DISABLE;
settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
@@ -2958,10 +2966,11 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
carg0 = ARG_UNUSED;
carg2 = ARG_UNUSED;
carg1 = WINED3DTA_CURRENT;
- cop = WINED3DTOP_SELECTARG1;
+ cop = WINED3D_TOP_SELECT_ARG1;
}
- if(cop == WINED3DTOP_DOTPRODUCT3) {
+ if (cop == WINED3D_TOP_DOTPRODUCT3)
+ {
/* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
* the color result to the alpha component of the destination
*/
@@ -2990,26 +2999,26 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
{
- if (aop == WINED3DTOP_DISABLE)
+ if (aop == WINED3D_TOP_DISABLE)
{
aarg1 = WINED3DTA_TEXTURE;
- aop = WINED3DTOP_SELECTARG1;
+ aop = WINED3D_TOP_SELECT_ARG1;
}
- else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
+ else if (aop == WINED3D_TOP_SELECT_ARG1 && aarg1 != WINED3DTA_TEXTURE)
{
if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
aarg2 = WINED3DTA_TEXTURE;
- aop = WINED3DTOP_MODULATE;
+ aop = WINED3D_TOP_MODULATE;
}
else aarg1 = WINED3DTA_TEXTURE;
}
- else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
+ else if (aop == WINED3D_TOP_SELECT_ARG2 && aarg2 != WINED3DTA_TEXTURE)
{
if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
aarg1 = WINED3DTA_TEXTURE;
- aop = WINED3DTOP_MODULATE;
+ aop = WINED3D_TOP_MODULATE;
}
else aarg2 = WINED3DTA_TEXTURE;
}
@@ -3022,7 +3031,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
aarg0 = ARG_UNUSED;
aarg2 = ARG_UNUSED;
aarg1 = WINED3DTA_CURRENT;
- aop = WINED3DTOP_SELECTARG1;
+ aop = WINED3D_TOP_SELECT_ARG1;
}
if (carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index e9c6233..4fc6912 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2510,14 +2510,14 @@ const char *debug_fbostatus(GLenum status) DECLSPEC_HIDDEN;
const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN;
const char *debug_d3dbasis(WINED3DBASISTYPE basis) DECLSPEC_HIDDEN;
const char *debug_d3ddegree(enum wined3d_degree_type order) DECLSPEC_HIDDEN;
-const char *debug_d3dtop(WINED3DTEXTUREOP d3dtop) DECLSPEC_HIDDEN;
+const char *debug_d3dtop(enum wined3d_texture_op d3dtop) DECLSPEC_HIDDEN;
void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN;
const char *debug_surflocation(DWORD flag) DECLSPEC_HIDDEN;
BOOL is_invalid_op(const struct wined3d_state *state, int stage,
- WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN;
+ enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN;
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
- BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3,
+ BOOL is_alpha, int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3,
INT texture_idx, DWORD dst) DECLSPEC_HIDDEN;
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords,
BOOL transformed, enum wined3d_format_id coordtype, BOOL ffp_can_disable_proj) DECLSPEC_HIDDEN;
diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h
index 7b9b1ed..bfc14e3 100644
--- a/include/wine/wined3d.h
+++ b/include/wine/wined3d.h
@@ -582,36 +582,35 @@ enum wined3d_texture_transform_flags
WINED3D_TTFF_PROJECTED = 256,
};
-typedef enum _WINED3DTEXTUREOP
-{
- WINED3DTOP_DISABLE = 1,
- WINED3DTOP_SELECTARG1 = 2,
- WINED3DTOP_SELECTARG2 = 3,
- WINED3DTOP_MODULATE = 4,
- WINED3DTOP_MODULATE2X = 5,
- WINED3DTOP_MODULATE4X = 6,
- WINED3DTOP_ADD = 7,
- WINED3DTOP_ADDSIGNED = 8,
- WINED3DTOP_ADDSIGNED2X = 9,
- WINED3DTOP_SUBTRACT = 10,
- WINED3DTOP_ADDSMOOTH = 11,
- WINED3DTOP_BLENDDIFFUSEALPHA = 12,
- WINED3DTOP_BLENDTEXTUREALPHA = 13,
- WINED3DTOP_BLENDFACTORALPHA = 14,
- WINED3DTOP_BLENDTEXTUREALPHAPM = 15,
- WINED3DTOP_BLENDCURRENTALPHA = 16,
- WINED3DTOP_PREMODULATE = 17,
- WINED3DTOP_MODULATEALPHA_ADDCOLOR = 18,
- WINED3DTOP_MODULATECOLOR_ADDALPHA = 19,
- WINED3DTOP_MODULATEINVALPHA_ADDCOLOR = 20,
- WINED3DTOP_MODULATEINVCOLOR_ADDALPHA = 21,
- WINED3DTOP_BUMPENVMAP = 22,
- WINED3DTOP_BUMPENVMAPLUMINANCE = 23,
- WINED3DTOP_DOTPRODUCT3 = 24,
- WINED3DTOP_MULTIPLYADD = 25,
- WINED3DTOP_LERP = 26,
- WINED3DTOP_FORCE_DWORD = 0x7fffffff,
-} WINED3DTEXTUREOP;
+enum wined3d_texture_op
+{
+ WINED3D_TOP_DISABLE = 1,
+ WINED3D_TOP_SELECT_ARG1 = 2,
+ WINED3D_TOP_SELECT_ARG2 = 3,
+ WINED3D_TOP_MODULATE = 4,
+ WINED3D_TOP_MODULATE_2X = 5,
+ WINED3D_TOP_MODULATE_4X = 6,
+ WINED3D_TOP_ADD = 7,
+ WINED3D_TOP_ADD_SIGNED = 8,
+ WINED3D_TOP_ADD_SIGNED_2X = 9,
+ WINED3D_TOP_SUBTRACT = 10,
+ WINED3D_TOP_ADD_SMOOTH = 11,
+ WINED3D_TOP_BLEND_DIFFUSE_ALPHA = 12,
+ WINED3D_TOP_BLEND_TEXTURE_ALPHA = 13,
+ WINED3D_TOP_BLEND_FACTOR_ALPHA = 14,
+ WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM = 15,
+ WINED3D_TOP_BLEND_CURRENT_ALPHA = 16,
+ WINED3D_TOP_PREMODULATE = 17,
+ WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR = 18,
+ WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA = 19,
+ WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR = 20,
+ WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA = 21,
+ WINED3D_TOP_BUMPENVMAP = 22,
+ WINED3D_TOP_BUMPENVMAP_LUMINANCE = 23,
+ WINED3D_TOP_DOTPRODUCT3 = 24,
+ WINED3D_TOP_MULTIPLY_ADD = 25,
+ WINED3D_TOP_LERP = 26,
+};
typedef enum _WINED3DTEXTUREADDRESS
{
--
1.7.3.4
More information about the wine-patches
mailing list