[PATCH 5/5] wined3d: Get rid of the WINED3DRENDERSTATETYPE typedef.
Henri Verbeet
hverbeet at codeweavers.com
Mon Dec 19 14:00:09 CST 2011
---
dlls/d3d8/device.c | 8 +-
dlls/ddraw/device.c | 6 +-
dlls/ddraw/executebuffer.c | 2 +-
dlls/ddraw/vertexbuffer.c | 6 +-
dlls/wined3d/arb_program_shader.c | 53 ++--
dlls/wined3d/ati_fragment_shader.c | 22 +-
dlls/wined3d/context.c | 40 +-
dlls/wined3d/device.c | 34 +-
dlls/wined3d/drawprim.c | 24 +-
dlls/wined3d/nvidia_texture_shader.c | 21 +-
dlls/wined3d/shader.c | 14 +-
dlls/wined3d/state.c | 754 +++++++++++++++++-----------------
dlls/wined3d/stateblock.c | 430 ++++++++++----------
dlls/wined3d/surface.c | 18 +-
dlls/wined3d/swapchain.c | 10 +-
dlls/wined3d/utils.c | 276 +++++++-------
dlls/wined3d/wined3d_private.h | 2 +-
include/wine/wined3d.h | 265 ++++++------
18 files changed, 993 insertions(+), 992 deletions(-)
diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index 923046d..3fcc6b3 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
@@ -587,7 +587,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_Reset(IDirect3DDevice8 *iface,
hr = wined3d_device_reset(This->wined3d_device, &swapchain_desc, reset_enum_callback);
if (SUCCEEDED(hr))
{
- hr = wined3d_device_set_render_state(This->wined3d_device, WINED3DRS_POINTSIZE_MIN, 0);
+ hr = wined3d_device_set_render_state(This->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0);
This->lost = FALSE;
}
else
@@ -1439,7 +1439,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(IDirect3DDevice8 *ifac
switch (State)
{
case D3DRS_ZBIAS:
- hr = wined3d_device_set_render_state(This->wined3d_device, WINED3DRS_DEPTHBIAS, Value);
+ hr = wined3d_device_set_render_state(This->wined3d_device, WINED3D_RS_DEPTHBIAS, Value);
break;
default:
@@ -1462,7 +1462,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(IDirect3DDevice8 *ifac
switch (State)
{
case D3DRS_ZBIAS:
- hr = wined3d_device_get_render_state(This->wined3d_device, WINED3DRS_DEPTHBIAS, pValue);
+ hr = wined3d_device_get_render_state(This->wined3d_device, WINED3D_RS_DEPTHBIAS, pValue);
break;
default:
@@ -3112,7 +3112,7 @@ HRESULT device_init(IDirect3DDevice8Impl *device, IDirect3D8Impl *parent, struct
return hr;
}
- hr = wined3d_device_set_render_state(device->wined3d_device, WINED3DRS_POINTSIZE_MIN, 0);
+ hr = wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0);
wined3d_mutex_unlock();
if (FAILED(hr))
{
diff --git a/dlls/ddraw/device.c b/dlls/ddraw/device.c
index 4dc0125..ed0d567 100644
--- a/dlls/ddraw/device.c
+++ b/dlls/ddraw/device.c
@@ -2456,7 +2456,7 @@ static HRESULT IDirect3DDeviceImpl_7_GetRenderState(IDirect3DDevice7 *iface,
break;
case D3DRENDERSTATE_ZBIAS:
- hr = wined3d_device_get_render_state(This->wined3d_device, WINED3DRS_DEPTHBIAS, Value);
+ hr = wined3d_device_get_render_state(This->wined3d_device, WINED3D_RS_DEPTHBIAS, Value);
break;
default:
@@ -2765,7 +2765,7 @@ IDirect3DDeviceImpl_7_SetRenderState(IDirect3DDevice7 *iface,
break;
case D3DRENDERSTATE_ZBIAS:
- hr = wined3d_device_set_render_state(This->wined3d_device, WINED3DRS_DEPTHBIAS, Value);
+ hr = wined3d_device_set_render_state(This->wined3d_device, WINED3D_RS_DEPTHBIAS, Value);
break;
default:
@@ -6972,7 +6972,7 @@ HRESULT d3d_device_init(IDirect3DDeviceImpl *device, IDirectDrawImpl *ddraw, IDi
ddraw->d3ddevice = device;
- wined3d_device_set_render_state(ddraw->wined3d_device, WINED3DRS_ZENABLE,
+ wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_ZENABLE,
IDirect3DDeviceImpl_UpdateDepthStencil(device));
return D3D_OK;
diff --git a/dlls/ddraw/executebuffer.c b/dlls/ddraw/executebuffer.c
index 097046d..58b84d6 100644
--- a/dlls/ddraw/executebuffer.c
+++ b/dlls/ddraw/executebuffer.c
@@ -156,7 +156,7 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
/* IDirect3DDevices have color keying always enabled -
* enable it before drawing. This overwrites any ALPHA*
* render state. */
- wined3d_device_set_render_state(lpDevice->wined3d_device, WINED3DRS_COLORKEYENABLE, 1);
+ wined3d_device_set_render_state(lpDevice->wined3d_device, WINED3D_RS_COLORKEYENABLE, 1);
IDirect3DDevice7_DrawIndexedPrimitive(&lpDevice->IDirect3DDevice7_iface,
D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, tl_vx, 0, This->indices, count * 3, 0);
} break;
diff --git a/dlls/ddraw/vertexbuffer.c b/dlls/ddraw/vertexbuffer.c
index 3039816..1991a8d 100644
--- a/dlls/ddraw/vertexbuffer.c
+++ b/dlls/ddraw/vertexbuffer.c
@@ -335,9 +335,9 @@ static HRESULT WINAPI IDirect3DVertexBufferImpl_ProcessVertices(IDirect3DVertexB
* the vertex ops
*/
doClip = VertexOp & D3DVOP_CLIP ? TRUE : FALSE;
- wined3d_device_get_render_state(device_impl->wined3d_device, WINED3DRS_CLIPPING, (DWORD *)&oldClip);
+ wined3d_device_get_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, (DWORD *)&oldClip);
if (doClip != oldClip)
- wined3d_device_set_render_state(device_impl->wined3d_device, WINED3DRS_CLIPPING, doClip);
+ wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, doClip);
wined3d_device_set_stream_source(device_impl->wined3d_device,
0, Src->wineD3DVertexBuffer, 0, get_flexible_vertex_size(Src->fvf));
@@ -347,7 +347,7 @@ static HRESULT WINAPI IDirect3DVertexBufferImpl_ProcessVertices(IDirect3DVertexB
/* Restore the states if needed */
if (doClip != oldClip)
- wined3d_device_set_render_state(device_impl->wined3d_device, WINED3DRS_CLIPPING, oldClip);
+ wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, oldClip);
wined3d_mutex_unlock();
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 8b152d3..0099857 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -4476,8 +4476,8 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
* duplicate the shader than have a no-op KIL instruction in every shader
*/
if (!device->vs_clipping && use_vs(state)
- && state->render_states[WINED3DRS_CLIPPING]
- && state->render_states[WINED3DRS_CLIPPLANEENABLE])
+ && state->render_states[WINED3D_RS_CLIPPING]
+ && state->render_states[WINED3D_RS_CLIPPLANEENABLE])
args->clip = 1;
else
args->clip = 0;
@@ -4538,8 +4538,8 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
if (args->clip.boolclip.clip_texcoord)
{
- if (state->render_states[WINED3DRS_CLIPPING])
- args->clip.boolclip.clipplane_mask = (unsigned char)state->render_states[WINED3DRS_CLIPPLANEENABLE];
+ if (state->render_states[WINED3D_RS_CLIPPING])
+ args->clip.boolclip.clipplane_mask = (unsigned char)state->render_states[WINED3D_RS_CLIPPLANEENABLE];
/* clipplane_mask was set to 0 by setting boolclip_compare to 0 */
}
@@ -5673,7 +5673,7 @@ static void state_texfactor_arbfp(struct wined3d_context *context,
priv->highest_dirty_ps_const = max(priv->highest_dirty_ps_const, ARB_FFP_CONST_TFACTOR + 1);
}
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_TEXTUREFACTOR], col);
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col);
GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col));
checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col)");
}
@@ -5699,7 +5699,7 @@ static void state_arb_specularenable(struct wined3d_context *context,
priv->highest_dirty_ps_const = max(priv->highest_dirty_ps_const, ARB_FFP_CONST_SPECULAR_ENABLE + 1);
}
- if (state->render_states[WINED3DRS_SPECULARENABLE])
+ if (state->render_states[WINED3D_RS_SPECULARENABLE])
{
/* The specular color has no alpha */
col[0] = 1.0f; col[1] = 1.0f;
@@ -6301,7 +6301,7 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
TRACE("context %p, state %p, state_id %#x.\n", context, state, state_id);
- if (isStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE)))
+ if (isStateDirty(context, STATE_RENDER(WINED3D_RS_FOGENABLE)))
{
if (!use_pshader && device->shader_backend == &arb_program_shader_backend && context->last_was_pshader)
{
@@ -6311,8 +6311,8 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
{
set_bumpmat_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00));
}
- state_texfactor_arbfp(context, state, STATE_RENDER(WINED3DRS_TEXTUREFACTOR));
- state_arb_specularenable(context, state, STATE_RENDER(WINED3DRS_SPECULARENABLE));
+ state_texfactor_arbfp(context, state, STATE_RENDER(WINED3D_RS_TEXTUREFACTOR));
+ state_arb_specularenable(context, state, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
}
else if (use_pshader && !isStateDirty(context, context->state_table[STATE_VSHADER].representative))
{
@@ -6364,8 +6364,8 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
{
set_bumpmat_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00));
}
- state_texfactor_arbfp(context, state, STATE_RENDER(WINED3DRS_TEXTUREFACTOR));
- state_arb_specularenable(context, state, STATE_RENDER(WINED3DRS_SPECULARENABLE));
+ state_texfactor_arbfp(context, state, STATE_RENDER(WINED3D_RS_TEXTUREFACTOR));
+ state_arb_specularenable(context, state, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
}
context->last_was_pshader = FALSE;
} else {
@@ -6408,10 +6408,10 @@ static void state_arbfp_fog(struct wined3d_context *context, const struct wined3
if (!isStateDirty(context, STATE_PIXELSHADER))
fragment_prog_arbfp(context, state, state_id);
- if (!state->render_states[WINED3DRS_FOGENABLE])
+ if (!state->render_states[WINED3D_RS_FOGENABLE])
return;
- if (state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
+ if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3DFOG_NONE)
{
if (use_vs(state))
{
@@ -6419,7 +6419,7 @@ static void state_arbfp_fog(struct wined3d_context *context, const struct wined3
}
else
{
- if (state->render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw)
+ if (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw)
new_source = FOGSOURCE_COORD;
else
new_source = FOGSOURCE_FFP;
@@ -6433,7 +6433,7 @@ static void state_arbfp_fog(struct wined3d_context *context, const struct wined3
if (new_source != context->fog_source)
{
context->fog_source = new_source;
- state_fogstartend(context, state, STATE_RENDER(WINED3DRS_FOGSTART));
+ state_fogstartend(context, state, STATE_RENDER(WINED3D_RS_FOGSTART));
}
}
@@ -6443,8 +6443,9 @@ static void textransform(struct wined3d_context *context, const struct wined3d_s
fragment_prog_arbfp(context, state, state_id);
}
-static const struct StateEntryTemplate arbfp_fragmentstate_template[] = {
- {STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor_arbfp }, WINED3D_GL_EXT_NONE },
+static const struct StateEntryTemplate arbfp_fragmentstate_template[] =
+{
+ {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), state_texfactor_arbfp }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
@@ -6566,14 +6567,14 @@ static const struct StateEntryTemplate arbfp_fragmentstate_template[] = {
{STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
{STATE_PIXELSHADER, { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_arbfp_fog }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_arbfp_fog }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(0, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(1, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(2, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
@@ -6582,7 +6583,7 @@ static const struct StateEntryTemplate arbfp_fragmentstate_template[] = {
{STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(5, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(6, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(7, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_SPECULARENABLE), { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_arb_specularenable}, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_SPECULARENABLE), { STATE_RENDER(WINED3D_RS_SPECULARENABLE), state_arb_specularenable}, WINED3D_GL_EXT_NONE },
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
};
diff --git a/dlls/wined3d/ati_fragment_shader.c b/dlls/wined3d/ati_fragment_shader.c
index d550a04..16dc79d 100644
--- a/dlls/wined3d/ati_fragment_shader.c
+++ b/dlls/wined3d/ati_fragment_shader.c
@@ -867,8 +867,8 @@ static void state_texfactor_atifs(struct wined3d_context *context, const struct
{
const struct wined3d_gl_info *gl_info = context->gl_info;
float col[4];
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_TEXTUREFACTOR], col);
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col);
GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col));
checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col)");
}
@@ -934,20 +934,20 @@ static void atifs_apply_pixelshader(struct wined3d_context *context, const struc
static void atifs_srgbwriteenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SRGBWRITEENABLE])
+ if (state->render_states[WINED3D_RS_SRGBWRITEENABLE])
WARN("sRGB writes are not supported by this fragment pipe.\n");
}
static const struct StateEntryTemplate atifs_fragmentstate_template[] = {
- {STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor_atifs }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
- {STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), atifs_srgbwriteenable }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), state_texfactor_atifs }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
+ {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), atifs_srgbwriteenable }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index c567e01..0a1ebac 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -1780,44 +1780,44 @@ static void SetupForBlit(const struct wined3d_device *device, struct wined3d_con
/* Other misc states */
glDisable(GL_ALPHA_TEST);
checkGLcall("glDisable(GL_ALPHA_TEST)");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHATESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHATESTENABLE));
glDisable(GL_LIGHTING);
checkGLcall("glDisable GL_LIGHTING");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_LIGHTING));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_LIGHTING));
glDisable(GL_DEPTH_TEST);
checkGLcall("glDisable GL_DEPTH_TEST");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ZENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZENABLE));
glDisableWINE(GL_FOG);
checkGLcall("glDisable GL_FOG");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_FOGENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_FOGENABLE));
glDisable(GL_BLEND);
checkGLcall("glDisable GL_BLEND");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
glDisable(GL_CULL_FACE);
checkGLcall("glDisable GL_CULL_FACE");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_CULLMODE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_CULLMODE));
glDisable(GL_STENCIL_TEST);
checkGLcall("glDisable GL_STENCIL_TEST");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_STENCILENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_STENCILENABLE));
glDisable(GL_SCISSOR_TEST);
checkGLcall("glDisable GL_SCISSOR_TEST");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
if (gl_info->supported[ARB_POINT_SPRITE])
{
glDisable(GL_POINT_SPRITE_ARB);
checkGLcall("glDisable GL_POINT_SPRITE_ARB");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE));
}
glColorMask(GL_TRUE, GL_TRUE,GL_TRUE,GL_TRUE);
checkGLcall("glColorMask");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
if (gl_info->supported[EXT_SECONDARY_COLOR])
{
glDisable(GL_COLOR_SUM_EXT);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SPECULARENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
checkGLcall("glDisable(GL_COLOR_SUM_EXT)");
}
@@ -1837,7 +1837,7 @@ static void SetupForBlit(const struct wined3d_device *device, struct wined3d_con
glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)");
glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)");
glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_CLIPPING));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_CLIPPING));
set_blit_dimension(width, height);
device->frag_pipe->enable_extension(FALSE);
@@ -2206,8 +2206,8 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win
checkGLcall("glEnable GL_SCISSOR_TEST");
LEAVE_GL();
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
context_invalidate_state(context, STATE_SCISSORRECT);
return TRUE;
@@ -2351,7 +2351,7 @@ static void context_setup_target(struct wined3d_context *context, struct wined3d
* the alpha blend state changes with different render target formats. */
if (!context->current_rt)
{
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
}
else
{
@@ -2363,11 +2363,11 @@ static void context_setup_target(struct wined3d_context *context, struct wined3d
/* Disable blending when the alpha mask has changed and when a format doesn't support blending. */
if ((old->alpha_mask && !new->alpha_mask) || (!old->alpha_mask && new->alpha_mask)
|| !(new->flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
/* Update sRGB writing when switching between formats that do/do not support sRGB writing */
if ((old->flags & WINED3DFMT_FLAG_SRGB_WRITE) != (new->flags & WINED3DFMT_FLAG_SRGB_WRITE))
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SRGBWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
}
/* When switching away from an offscreen render target, and we're not
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index d6f7a98..00670e5 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -718,10 +718,10 @@ HRESULT device_clear_render_targets(struct wined3d_device *device, UINT rt_count
if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
{
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE));
}
glStencilMask(~0U);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
glClearStencil(stencil);
checkGLcall("glClearStencil");
clear_mask = clear_mask | GL_STENCIL_BUFFER_BIT;
@@ -732,7 +732,7 @@ HRESULT device_clear_render_targets(struct wined3d_device *device, UINT rt_count
surface_modify_location(fb->depth_stencil, fb->depth_stencil->draw_binding, TRUE);
glDepthMask(GL_TRUE);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZWRITEENABLE));
glClearDepth(depth);
checkGLcall("glClearDepth");
clear_mask = clear_mask | GL_DEPTH_BUFFER_BIT;
@@ -749,10 +749,10 @@ HRESULT device_clear_render_targets(struct wined3d_device *device, UINT rt_count
}
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
glClearColor(color->r, color->g, color->b, color->a);
checkGLcall("glClearColor");
clear_mask = clear_mask | GL_COLOR_BUFFER_BIT;
@@ -2419,7 +2419,7 @@ HRESULT CDECL wined3d_device_get_viewport(const struct wined3d_device *device, s
}
HRESULT CDECL wined3d_device_set_render_state(struct wined3d_device *device,
- WINED3DRENDERSTATETYPE state, DWORD value)
+ enum wined3d_render_state state, DWORD value)
{
DWORD old_value = device->stateBlock->state.render_states[state];
@@ -2445,7 +2445,7 @@ HRESULT CDECL wined3d_device_set_render_state(struct wined3d_device *device,
}
HRESULT CDECL wined3d_device_get_render_state(const struct wined3d_device *device,
- WINED3DRENDERSTATETYPE state, DWORD *value)
+ enum wined3d_render_state state, DWORD *value)
{
TRACE("device %p, state %s (%#x), value %p.\n", device, debug_d3drenderstate(state), state, value);
@@ -3227,7 +3227,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO
dest_conv = dest_conv_addr;
}
- if (device->stateBlock->state.render_states[WINED3DRS_CLIPPING])
+ if (device->stateBlock->state.render_states[WINED3D_RS_CLIPPING])
{
static BOOL warned = FALSE;
/*
@@ -4497,8 +4497,8 @@ HRESULT CDECL wined3d_device_validate_device(const struct wined3d_device *device
}
}
- if (state->render_states[WINED3DRS_ZENABLE] || state->render_states[WINED3DRS_ZWRITEENABLE] ||
- state->render_states[WINED3DRS_STENCILENABLE])
+ if (state->render_states[WINED3D_RS_ZENABLE] || state->render_states[WINED3D_RS_ZWRITEENABLE]
+ || state->render_states[WINED3D_RS_STENCILENABLE])
{
struct wined3d_surface *ds = device->fb.depth_stencil;
struct wined3d_surface *target = device->fb.render_targets[0];
@@ -4949,14 +4949,14 @@ HRESULT CDECL wined3d_device_set_depth_stencil(struct wined3d_device *device, st
if (!prev != !depth_stencil)
{
/* Swapping NULL / non NULL depth stencil affects the depth and tests */
- device_invalidate_state(device, STATE_RENDER(WINED3DRS_ZENABLE));
- device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILENABLE));
- device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
- device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
+ device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
+ device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
+ device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
+ device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
}
else if (prev && prev->resource.format->depth_size != depth_stencil->resource.format->depth_size)
{
- device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
+ device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
}
if (prev)
wined3d_surface_decref(prev);
diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c
index 716119e..f9116a0 100644
--- a/dlls/wined3d/drawprim.c
+++ b/dlls/wined3d/drawprim.c
@@ -143,10 +143,10 @@ static void drawStridedSlow(const struct wined3d_device *device, const struct wi
specular = element->data.addr;
/* special case where the fog density is stored in the specular alpha channel */
- if (state->render_states[WINED3DRS_FOGENABLE]
- && (state->render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE
+ if (state->render_states[WINED3D_RS_FOGENABLE]
+ && (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3DFOG_NONE
|| si->elements[WINED3D_FFP_POSITION].format->id == WINED3DFMT_R32G32B32A32_FLOAT)
- && state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
+ && state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3DFOG_NONE)
{
if (gl_info->supported[EXT_FOG_COORD])
{
@@ -583,7 +583,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
if (!index_count) return;
- if (state->render_states[WINED3DRS_COLORWRITEENABLE])
+ if (state->render_states[WINED3D_RS_COLORWRITEENABLE])
{
/* Invalidate the back buffer memory so LockRect will read it the next time */
for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
@@ -616,7 +616,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
* depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
* that we never copy the stencil data.*/
DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
- if (state->render_states[WINED3DRS_ZWRITEENABLE] || state->render_states[WINED3DRS_ZENABLE])
+ if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE])
{
struct wined3d_surface *ds = device->fb.depth_stencil;
RECT current_rect, draw_rect, r;
@@ -635,7 +635,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
if (!EqualRect(&r, &draw_rect))
surface_load_ds_location(ds, context, location);
- if (state->render_states[WINED3DRS_ZWRITEENABLE])
+ if (state->render_states[WINED3D_RS_ZWRITEENABLE])
{
surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);
surface_modify_location(ds, ds->draw_binding, TRUE);
@@ -653,7 +653,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
if ((!context->gl_info->supported[WINED3D_GL_VERSION_2_0]
|| (!glPointParameteri && !context->gl_info->supported[NV_POINT_SPRITE]))
&& context->render_offscreen
- && state->render_states[WINED3DRS_POINTSPRITEENABLE]
+ && state->render_states[WINED3D_RS_POINTSPRITEENABLE]
&& state->gl_primitive_type == GL_POINTS)
{
FIXME("Point sprite coordinate origin switching not supported.\n");
@@ -671,7 +671,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
if (!use_vs(state))
{
if (!stream_info->position_transformed && context->num_untracked_materials
- && state->render_states[WINED3DRS_LIGHTING])
+ && state->render_states[WINED3D_RS_LIGHTING])
{
static BOOL warned;
if (!warned) {
@@ -682,7 +682,7 @@ void drawPrimitive(struct wined3d_device *device, UINT index_count, UINT StartId
}
emulation = TRUE;
}
- else if (context->fog_coord && state->render_states[WINED3DRS_FOGENABLE])
+ else if (context->fog_coord && state->render_states[WINED3D_RS_FOGENABLE])
{
/* Either write a pipeline replacement shader or convert the specular alpha from unsigned byte
* to a float in the vertex buffer
@@ -875,7 +875,7 @@ HRESULT tesselate_rectpatch(struct wined3d_device *This, struct WineD3DRectPatch
*/
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_FILLMODE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_FILLMODE));
if (patch->has_normals)
{
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
@@ -887,7 +887,7 @@ HRESULT tesselate_rectpatch(struct wined3d_device *This, struct WineD3DRectPatch
checkGLcall("glEnable(GL_LIGHTING)");
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
checkGLcall("glLightModel for MODEL_AMBIENT");
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_AMBIENT));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_AMBIENT));
for (i = 3; i < context->gl_info->limits.lights; ++i)
{
@@ -919,7 +919,7 @@ HRESULT tesselate_rectpatch(struct wined3d_device *This, struct WineD3DRectPatch
checkGLcall("Setting up light 3");
context_invalidate_state(context, STATE_MATERIAL);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORVERTEX));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORVERTEX));
glDisable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
diff --git a/dlls/wined3d/nvidia_texture_shader.c b/dlls/wined3d/nvidia_texture_shader.c
index 96c7ed8..7cb47ee 100644
--- a/dlls/wined3d/nvidia_texture_shader.c
+++ b/dlls/wined3d/nvidia_texture_shader.c
@@ -612,7 +612,8 @@ static void nvrc_texfactor(struct wined3d_context *context, const struct wined3d
{
const struct wined3d_gl_info *gl_info = context->gl_info;
float col[4];
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_TEXTUREFACTOR], col);
+
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col);
GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
}
@@ -821,15 +822,15 @@ static const struct StateEntryTemplate nvrc_fragmentstate_template[] = {
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim }, NV_TEXTURE_SHADER2 },
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim }, NV_TEXTURE_SHADER2 },
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index 4823750..240ba8b 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -1709,10 +1709,10 @@ HRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *sh
void find_vs_compile_args(const struct wined3d_state *state,
const struct wined3d_shader *shader, struct vs_compile_args *args)
{
- args->fog_src = state->render_states[WINED3DRS_FOGTABLEMODE]
+ args->fog_src = state->render_states[WINED3D_RS_FOGTABLEMODE]
== WINED3DFOG_NONE ? VS_FOG_COORD : VS_FOG_Z;
- args->clip_enabled = state->render_states[WINED3DRS_CLIPPING]
- && state->render_states[WINED3DRS_CLIPPLANEENABLE];
+ args->clip_enabled = state->render_states[WINED3D_RS_CLIPPING]
+ && state->render_states[WINED3D_RS_CLIPPLANEENABLE];
args->swizzle_map = shader->device->strided_streams.swizzle_map;
}
@@ -1899,7 +1899,7 @@ void find_ps_compile_args(const struct wined3d_state *state,
UINT i;
memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set. */
- if (state->render_states[WINED3DRS_SRGBWRITEENABLE])
+ if (state->render_states[WINED3D_RS_SRGBWRITEENABLE])
{
const struct wined3d_surface *rt = state->fb->render_targets[0];
if (rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE) args->srgb_correction = 1;
@@ -1976,9 +1976,9 @@ void find_ps_compile_args(const struct wined3d_state *state,
else
{
args->vp_mode = vertexshader;
- if (state->render_states[WINED3DRS_FOGENABLE])
+ if (state->render_states[WINED3D_RS_FOGENABLE])
{
- switch (state->render_states[WINED3DRS_FOGTABLEMODE])
+ switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
{
case WINED3DFOG_NONE:
if (device->strided_streams.position_transformed || use_vs(state))
@@ -1987,7 +1987,7 @@ void find_ps_compile_args(const struct wined3d_state *state,
break;
}
- switch (state->render_states[WINED3DRS_FOGVERTEXMODE])
+ switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
{
case WINED3DFOG_NONE: /* Fall through. */
case WINED3DFOG_LINEAR: args->fog = FOG_LINEAR; break;
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 7820048..8727369 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -49,7 +49,7 @@ static void state_nop(struct wined3d_context *context, const struct wined3d_stat
static void state_fillmode(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- WINED3DFILLMODE mode = state->render_states[WINED3DRS_FILLMODE];
+ WINED3DFILLMODE mode = state->render_states[WINED3D_RS_FILLMODE];
switch (mode)
{
@@ -66,7 +66,7 @@ static void state_fillmode(struct wined3d_context *context, const struct wined3d
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
break;
default:
- FIXME("Unrecognized WINED3DRS_FILLMODE %d.\n", mode);
+ FIXME("Unrecognized WINED3D_RS_FILLMODE %d.\n", mode);
}
}
@@ -80,7 +80,7 @@ static void state_lighting(struct wined3d_context *context, const struct wined3d
if (isStateDirty(context, STATE_VDECL))
return;
- if (state->render_states[WINED3DRS_LIGHTING]
+ if (state->render_states[WINED3D_RS_LIGHTING]
&& !context->swapchain->device->strided_streams.position_transformed)
{
glEnable(GL_LIGHTING);
@@ -102,7 +102,7 @@ static void state_zenable(struct wined3d_context *context, const struct wined3d_
return;
}
- switch (state->render_states[WINED3DRS_ZENABLE])
+ switch (state->render_states[WINED3D_RS_ZENABLE])
{
case WINED3DZB_FALSE:
glDisable(GL_DEPTH_TEST);
@@ -119,7 +119,7 @@ static void state_zenable(struct wined3d_context *context, const struct wined3d_
break;
default:
FIXME("Unrecognized D3DZBUFFERTYPE value %#x.\n",
- state->render_states[WINED3DRS_ZENABLE]);
+ state->render_states[WINED3D_RS_ZENABLE]);
}
}
@@ -127,7 +127,7 @@ static void state_cullmode(struct wined3d_context *context, const struct wined3d
{
/* glFrontFace() is set in context.c at context init and on an
* offscreen / onscreen rendering switch. */
- switch (state->render_states[WINED3DRS_CULLMODE])
+ switch (state->render_states[WINED3D_RS_CULLMODE])
{
case WINED3DCULL_NONE:
glDisable(GL_CULL_FACE);
@@ -147,13 +147,13 @@ static void state_cullmode(struct wined3d_context *context, const struct wined3d
break;
default:
FIXME("Unrecognized/Unhandled WINED3DCULL value %#x.\n",
- state->render_states[WINED3DRS_CULLMODE]);
+ state->render_states[WINED3D_RS_CULLMODE]);
}
}
static void state_shademode(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- switch (state->render_states[WINED3DRS_SHADEMODE])
+ switch (state->render_states[WINED3D_RS_SHADEMODE])
{
case WINED3DSHADE_FLAT:
glShadeModel(GL_FLAT);
@@ -168,13 +168,13 @@ static void state_shademode(struct wined3d_context *context, const struct wined3
break;
default:
FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %#x.\n",
- state->render_states[WINED3DRS_SHADEMODE]);
+ state->render_states[WINED3D_RS_SHADEMODE]);
}
}
static void state_ditherenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_DITHERENABLE])
+ if (state->render_states[WINED3D_RS_DITHERENABLE])
{
glEnable(GL_DITHER);
checkGLcall("glEnable GL_DITHER");
@@ -190,7 +190,7 @@ static void state_zwritenable(struct wined3d_context *context, const struct wine
{
/* TODO: Test if in d3d z writing is enabled even if ZENABLE is off.
* If yes, this has to be merged with ZENABLE and ZFUNC. */
- if (state->render_states[WINED3DRS_ZWRITEENABLE])
+ if (state->render_states[WINED3D_RS_ZWRITEENABLE])
{
glDepthMask(1);
checkGLcall("glDepthMask(1)");
@@ -204,7 +204,7 @@ static void state_zwritenable(struct wined3d_context *context, const struct wine
static void state_zfunc(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- GLenum depth_func = CompareFunc(state->render_states[WINED3DRS_ZFUNC]);
+ GLenum depth_func = CompareFunc(state->render_states[WINED3D_RS_ZFUNC]);
if (!depth_func) return;
@@ -230,8 +230,8 @@ static void state_zfunc(struct wined3d_context *context, const struct wined3d_st
static void state_ambient(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
float col[4];
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_AMBIENT], col);
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_AMBIENT], col);
TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
checkGLcall("glLightModel for MODEL_AMBIENT");
@@ -269,18 +269,18 @@ static void state_blendop(struct wined3d_context *context, const struct wined3d_
GLenum blend_equation = GL_FUNC_ADD_EXT;
/* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
- if (state->render_states[WINED3DRS_BLENDOPALPHA]
+ if (state->render_states[WINED3D_RS_BLENDOPALPHA]
&& !gl_info->supported[EXT_BLEND_EQUATION_SEPARATE])
{
WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
return;
}
- blend_equation = gl_blend_op(state->render_states[WINED3DRS_BLENDOP]);
- blend_equation_alpha = gl_blend_op(state->render_states[WINED3DRS_BLENDOPALPHA]);
+ blend_equation = gl_blend_op(state->render_states[WINED3D_RS_BLENDOP]);
+ blend_equation_alpha = gl_blend_op(state->render_states[WINED3D_RS_BLENDOPALPHA]);
TRACE("blend_equation %#x, blend_equation_alpha %#x.\n", blend_equation, blend_equation_alpha);
- if (state->render_states[WINED3DRS_SEPARATEALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_SEPARATEALPHABLENDENABLE])
{
GL_EXTCALL(glBlendEquationSeparateEXT(blend_equation, blend_equation_alpha));
checkGLcall("glBlendEquationSeparateEXT");
@@ -343,9 +343,9 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
/* According to the red book, GL_LINE_SMOOTH needs GL_BLEND with specific
* blending parameters to work. */
- if (state->render_states[WINED3DRS_ALPHABLENDENABLE]
- || state->render_states[WINED3DRS_EDGEANTIALIAS]
- || state->render_states[WINED3DRS_ANTIALIASEDLINEENABLE])
+ if (state->render_states[WINED3D_RS_ALPHABLENDENABLE]
+ || state->render_states[WINED3D_RS_EDGEANTIALIAS]
+ || state->render_states[WINED3D_RS_ANTIALIASEDLINEENABLE])
{
/* Disable blending in all cases even without pixelshaders.
* With blending on we could face a big performance penalty.
@@ -370,7 +370,7 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
/* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
- d3d_blend = state->render_states[WINED3DRS_SRCBLEND];
+ d3d_blend = state->render_states[WINED3D_RS_SRCBLEND];
if (d3d_blend == WINED3D_BLEND_BOTHSRCALPHA)
{
srcBlend = GL_SRC_ALPHA;
@@ -384,20 +384,20 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
else
{
srcBlend = gl_blend_factor(d3d_blend, target->resource.format);
- dstBlend = gl_blend_factor(state->render_states[WINED3DRS_DESTBLEND],
+ dstBlend = gl_blend_factor(state->render_states[WINED3D_RS_DESTBLEND],
target->resource.format);
}
- if (state->render_states[WINED3DRS_EDGEANTIALIAS]
- || state->render_states[WINED3DRS_ANTIALIASEDLINEENABLE])
+ if (state->render_states[WINED3D_RS_EDGEANTIALIAS]
+ || state->render_states[WINED3D_RS_ANTIALIASEDLINEENABLE])
{
glEnable(GL_LINE_SMOOTH);
checkGLcall("glEnable(GL_LINE_SMOOTH)");
if(srcBlend != GL_SRC_ALPHA) {
- WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
+ WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
}
if(dstBlend != GL_ONE_MINUS_SRC_ALPHA && dstBlend != GL_ONE) {
- WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
+ WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
}
} else {
glDisable(GL_LINE_SMOOTH);
@@ -405,10 +405,10 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
}
/* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
- if (!isStateDirty(context, STATE_RENDER(WINED3DRS_BLENDOP)))
- state_blendop(context, state, STATE_RENDER(WINED3DRS_BLENDOPALPHA));
+ if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_BLENDOP)))
+ state_blendop(context, state, STATE_RENDER(WINED3D_RS_BLENDOPALPHA));
- if (state->render_states[WINED3DRS_SEPARATEALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_SEPARATEALPHABLENDENABLE])
{
GLenum srcBlendAlpha, dstBlendAlpha;
@@ -422,7 +422,7 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
/* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
- d3d_blend = state->render_states[WINED3DRS_SRCBLENDALPHA];
+ d3d_blend = state->render_states[WINED3D_RS_SRCBLENDALPHA];
if (d3d_blend == WINED3D_BLEND_BOTHSRCALPHA)
{
srcBlendAlpha = GL_SRC_ALPHA;
@@ -436,7 +436,7 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
else
{
srcBlendAlpha = gl_blend_factor(d3d_blend, target->resource.format);
- dstBlendAlpha = gl_blend_factor(state->render_states[WINED3DRS_DESTBLENDALPHA],
+ dstBlendAlpha = gl_blend_factor(state->render_states[WINED3D_RS_DESTBLENDALPHA],
target->resource.format);
}
@@ -449,8 +449,8 @@ static void state_blend(struct wined3d_context *context, const struct wined3d_st
}
/* Colorkey fixup for stage 0 alphaop depends on
- * WINED3DRS_ALPHABLENDENABLE state, so it may need updating. */
- if (state->render_states[WINED3DRS_COLORKEYENABLE])
+ * WINED3D_RS_ALPHABLENDENABLE state, so it may need updating. */
+ if (state->render_states[WINED3D_RS_COLORKEYENABLE])
context_apply_state(context, state, STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP));
}
@@ -464,8 +464,9 @@ static void state_blendfactor(struct wined3d_context *context, const struct wine
const struct wined3d_gl_info *gl_info = context->gl_info;
float col[4];
- TRACE("Setting blend factor to %#x.\n", state->render_states[WINED3DRS_BLENDFACTOR]);
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_BLENDFACTOR], col);
+ TRACE("Setting blend factor to %#x.\n", state->render_states[WINED3D_RS_BLENDFACTOR]);
+
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_BLENDFACTOR], col);
GL_EXTCALL(glBlendColorEXT (col[0],col[1],col[2],col[3]));
checkGLcall("glBlendColor");
}
@@ -481,7 +482,7 @@ static void state_alpha(struct wined3d_context *context, const struct wined3d_st
/* Find out if the texture on the first stage has a ckey set
* The alpha state func reads the texture settings, even though alpha and texture are not grouped
* together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
- * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
+ * used WINED3D_RS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
* in case it finds some texture+colorkeyenable combination which needs extra care.
*/
if (state->textures[0])
@@ -507,8 +508,8 @@ static void state_alpha(struct wined3d_context *context, const struct wined3d_st
context_apply_state(context, state, STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP));
context->last_was_ckey = enable_ckey;
- if (state->render_states[WINED3DRS_ALPHATESTENABLE]
- || (state->render_states[WINED3DRS_COLORKEYENABLE] && enable_ckey))
+ if (state->render_states[WINED3D_RS_ALPHATESTENABLE]
+ || (state->render_states[WINED3D_RS_COLORKEYENABLE] && enable_ckey))
{
glEnable(GL_ALPHA_TEST);
checkGLcall("glEnable GL_ALPHA_TEST");
@@ -521,15 +522,15 @@ static void state_alpha(struct wined3d_context *context, const struct wined3d_st
return;
}
- if (state->render_states[WINED3DRS_COLORKEYENABLE] && enable_ckey)
+ if (state->render_states[WINED3D_RS_COLORKEYENABLE] && enable_ckey)
{
glParm = GL_NOTEQUAL;
ref = 0.0f;
}
else
{
- ref = ((float)state->render_states[WINED3DRS_ALPHAREF]) / 255.0f;
- glParm = CompareFunc(state->render_states[WINED3DRS_ALPHAFUNC]);
+ ref = ((float)state->render_states[WINED3D_RS_ALPHAREF]) / 255.0f;
+ glParm = CompareFunc(state->render_states[WINED3D_RS_ALPHAFUNC]);
}
if(glParm) {
glAlphaFunc(glParm, ref);
@@ -566,7 +567,7 @@ static void state_clipping(struct wined3d_context *context, const struct wined3d
* conditions I got sick of tracking down. The shader state handler disables all clip planes because
* of that - don't do anything here and keep them disabled
*/
- if (state->render_states[WINED3DRS_CLIPPLANEENABLE])
+ if (state->render_states[WINED3D_RS_CLIPPLANEENABLE])
{
static BOOL warned = FALSE;
if(!warned) {
@@ -594,10 +595,10 @@ static void state_clipping(struct wined3d_context *context, const struct wined3d
/* If enabling / disabling all
* TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
*/
- if (state->render_states[WINED3DRS_CLIPPING])
+ if (state->render_states[WINED3D_RS_CLIPPING])
{
- enable = state->render_states[WINED3DRS_CLIPPLANEENABLE];
- disable = ~state->render_states[WINED3DRS_CLIPPLANEENABLE];
+ enable = state->render_states[WINED3D_RS_CLIPPLANEENABLE];
+ disable = ~state->render_states[WINED3D_RS_CLIPPLANEENABLE];
}
else
{
@@ -650,11 +651,11 @@ static void state_specularenable(struct wined3d_context *context, const struct w
*
* That's pretty much fine as it is, except for variable B, which needs to take
* either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
- * whether WINED3DRS_SPECULARENABLE is enabled or not.
+ * whether WINED3D_RS_SPECULARENABLE is enabled or not.
*/
TRACE("Setting specular enable state and materials\n");
- if (state->render_states[WINED3DRS_SPECULARENABLE])
+ if (state->render_states[WINED3D_RS_SPECULARENABLE])
{
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&state->material.specular);
checkGLcall("glMaterialfv");
@@ -745,14 +746,13 @@ static void state_texfactor(struct wined3d_context *context, const struct wined3
/* Note the texture color applies to all textures whereas
* GL_TEXTURE_ENV_COLOR applies to active only. */
float col[4];
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_TEXTUREFACTOR], col);
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col);
/* And now the default texture color as well */
for (i = 0; i < gl_info->limits.texture_stages; ++i)
{
- /* Note the WINED3DRS value applies to all textures, but GL has one
- * per texture, so apply it now ready to be used!
- */
+ /* Note the WINED3D_RS value applies to all textures, but GL has one
+ * per texture, so apply it now ready to be used! */
context_active_texture(context, gl_info, i);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
@@ -799,20 +799,20 @@ static void state_stencil(struct wined3d_context *context, const struct wined3d_
return;
}
- onesided_enable = state->render_states[WINED3DRS_STENCILENABLE];
- twosided_enable = state->render_states[WINED3DRS_TWOSIDEDSTENCILMODE];
- if (!(func = CompareFunc(state->render_states[WINED3DRS_STENCILFUNC])))
+ onesided_enable = state->render_states[WINED3D_RS_STENCILENABLE];
+ twosided_enable = state->render_states[WINED3D_RS_TWOSIDEDSTENCILMODE];
+ if (!(func = CompareFunc(state->render_states[WINED3D_RS_STENCILFUNC])))
func = GL_ALWAYS;
- if (!(func_ccw = CompareFunc(state->render_states[WINED3DRS_CCW_STENCILFUNC])))
+ if (!(func_ccw = CompareFunc(state->render_states[WINED3D_RS_CCW_STENCILFUNC])))
func_ccw = GL_ALWAYS;
- ref = state->render_states[WINED3DRS_STENCILREF];
- mask = state->render_states[WINED3DRS_STENCILMASK];
- stencilFail = StencilOp(state->render_states[WINED3DRS_STENCILFAIL]);
- depthFail = StencilOp(state->render_states[WINED3DRS_STENCILZFAIL]);
- stencilPass = StencilOp(state->render_states[WINED3DRS_STENCILPASS]);
- stencilFail_ccw = StencilOp(state->render_states[WINED3DRS_CCW_STENCILFAIL]);
- depthFail_ccw = StencilOp(state->render_states[WINED3DRS_CCW_STENCILZFAIL]);
- stencilPass_ccw = StencilOp(state->render_states[WINED3DRS_CCW_STENCILPASS]);
+ ref = state->render_states[WINED3D_RS_STENCILREF];
+ mask = state->render_states[WINED3D_RS_STENCILMASK];
+ stencilFail = StencilOp(state->render_states[WINED3D_RS_STENCILFAIL]);
+ depthFail = StencilOp(state->render_states[WINED3D_RS_STENCILZFAIL]);
+ stencilPass = StencilOp(state->render_states[WINED3D_RS_STENCILPASS]);
+ stencilFail_ccw = StencilOp(state->render_states[WINED3D_RS_CCW_STENCILFAIL]);
+ depthFail_ccw = StencilOp(state->render_states[WINED3D_RS_CCW_STENCILZFAIL]);
+ stencilPass_ccw = StencilOp(state->render_states[WINED3D_RS_CCW_STENCILPASS]);
TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
"GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
@@ -875,7 +875,7 @@ static void state_stencil(struct wined3d_context *context, const struct wined3d_
static void state_stencilwrite2s(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- DWORD mask = state->fb->depth_stencil ? state->render_states[WINED3DRS_STENCILWRITEMASK] : 0;
+ DWORD mask = state->fb->depth_stencil ? state->render_states[WINED3D_RS_STENCILWRITEMASK] : 0;
const struct wined3d_gl_info *gl_info = context->gl_info;
GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
@@ -889,7 +889,7 @@ static void state_stencilwrite2s(struct wined3d_context *context, const struct w
static void state_stencilwrite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- DWORD mask = state->fb->depth_stencil ? state->render_states[WINED3DRS_STENCILWRITEMASK] : 0;
+ DWORD mask = state->fb->depth_stencil ? state->render_states[WINED3D_RS_STENCILWRITEMASK] : 0;
glStencilMask(mask);
checkGLcall("glStencilMask");
@@ -901,11 +901,11 @@ static void state_fog_vertexpart(struct wined3d_context *context, const struct w
const struct wined3d_gl_info *gl_info = context->gl_info;
TRACE("context %p, state %p, state_id %#x.\n", context, state, state_id);
- if (!state->render_states[WINED3DRS_FOGENABLE])
+ if (!state->render_states[WINED3D_RS_FOGENABLE])
return;
/* Table fog on: Never use fog coords, and use per-fragment fog */
- if (state->render_states[WINED3DRS_FOGTABLEMODE] != WINED3DFOG_NONE)
+ if (state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3DFOG_NONE)
{
glHint(GL_FOG_HINT, GL_NICEST);
if(context->fog_coord) {
@@ -926,7 +926,7 @@ static void state_fog_vertexpart(struct wined3d_context *context, const struct w
/* Otherwise use per-vertex fog in any case */
glHint(GL_FOG_HINT, GL_FASTEST);
- if (state->render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw)
+ if (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw)
{
/* No fog at all, or transformed vertices: Use fog coord */
if(!context->fog_coord) {
@@ -944,7 +944,7 @@ static void state_fog_vertexpart(struct wined3d_context *context, const struct w
context->fog_coord = FALSE;
}
- if (state->render_states[WINED3DRS_RANGEFOGENABLE])
+ if (state->render_states[WINED3D_RS_RANGEFOGENABLE])
{
if (gl_info->supported[NV_FOG_DISTANCE])
{
@@ -984,9 +984,9 @@ void state_fogstartend(struct wined3d_context *context, const struct wined3d_sta
break;
case FOGSOURCE_FFP:
- tmpvalue.d = state->render_states[WINED3DRS_FOGSTART];
+ tmpvalue.d = state->render_states[WINED3D_RS_FOGSTART];
fogstart = tmpvalue.f;
- tmpvalue.d = state->render_states[WINED3DRS_FOGEND];
+ tmpvalue.d = state->render_states[WINED3D_RS_FOGEND];
fogend = tmpvalue.f;
/* In GL, fogstart == fogend disables fog, in D3D everything's fogged.*/
if(fogstart == fogend) {
@@ -1019,7 +1019,7 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
TRACE("context %p, state %p, state_id %#x.\n", context, state, state_id);
- if (!state->render_states[WINED3DRS_FOGENABLE])
+ if (!state->render_states[WINED3D_RS_FOGENABLE])
{
/* No fog? Disable it, and we're done :-) */
glDisableWINE(GL_FOG);
@@ -1073,7 +1073,7 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
/* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
* the system will apply only pixel(=table) fog effects."
*/
- if (state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
+ if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3DFOG_NONE)
{
if (use_vs(state))
{
@@ -1083,7 +1083,7 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
}
else
{
- switch (state->render_states[WINED3DRS_FOGVERTEXMODE])
+ switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
{
/* If processed vertices are used, fall through to the NONE case */
case WINED3DFOG_EXP:
@@ -1124,15 +1124,15 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
break;
default:
- FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %#x.\n",
- state->render_states[WINED3DRS_FOGVERTEXMODE]);
+ FIXME("Unexpected WINED3D_RS_FOGVERTEXMODE %#x.\n",
+ state->render_states[WINED3D_RS_FOGVERTEXMODE]);
new_source = FOGSOURCE_FFP; /* Make the compiler happy */
}
}
} else {
new_source = FOGSOURCE_FFP;
- switch (state->render_states[WINED3DRS_FOGTABLEMODE])
+ switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
{
case WINED3DFOG_EXP:
glFogi(GL_FOG_MODE, GL_EXP);
@@ -1151,8 +1151,8 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
case WINED3DFOG_NONE: /* Won't happen */
default:
- FIXME("Unexpected WINED3DRS_FOGTABLEMODE %#x.\n",
- state->render_states[WINED3DRS_FOGTABLEMODE]);
+ FIXME("Unexpected WINED3D_RS_FOGTABLEMODE %#x.\n",
+ state->render_states[WINED3D_RS_FOGTABLEMODE]);
}
}
@@ -1161,7 +1161,7 @@ void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_st
if (new_source != context->fog_source)
{
context->fog_source = new_source;
- state_fogstartend(context, state, STATE_RENDER(WINED3DRS_FOGSTART));
+ state_fogstartend(context, state, STATE_RENDER(WINED3D_RS_FOGSTART));
}
}
@@ -1169,7 +1169,7 @@ void state_fogcolor(struct wined3d_context *context, const struct wined3d_state
{
float col[4];
- D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_FOGCOLOR], col);
+ D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_FOGCOLOR], col);
glFogfv(GL_FOG_COLOR, &col[0]);
checkGLcall("glFog GL_FOG_COLOR");
}
@@ -1181,7 +1181,7 @@ void state_fogdensity(struct wined3d_context *context, const struct wined3d_stat
float f;
} tmpvalue;
- tmpvalue.d = state->render_states[WINED3DRS_FOGDENSITY];
+ tmpvalue.d = state->render_states[WINED3D_RS_FOGDENSITY];
glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
}
@@ -1201,55 +1201,55 @@ static void state_colormat(struct wined3d_context *context, const struct wined3d
context->num_untracked_materials = 0;
if ((device->strided_streams.use_map & (1 << WINED3D_FFP_DIFFUSE))
- && state->render_states[WINED3DRS_COLORVERTEX])
+ && state->render_states[WINED3D_RS_COLORVERTEX])
{
TRACE("diff %d, amb %d, emis %d, spec %d\n",
- state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE],
- state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE],
- state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE],
- state->render_states[WINED3DRS_SPECULARMATERIALSOURCE]);
+ state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE],
+ state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE],
+ state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE],
+ state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE]);
- if (state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
- if (state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
Parm = GL_AMBIENT_AND_DIFFUSE;
else
Parm = GL_DIFFUSE;
- if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
context->num_untracked_materials++;
}
- if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
}
- else if (state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ else if (state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
Parm = GL_AMBIENT;
- if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
context->num_untracked_materials++;
}
- if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
}
- else if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ else if (state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
Parm = GL_EMISSION;
- if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ if (state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
}
- else if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
+ else if (state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
{
Parm = GL_SPECULAR;
}
@@ -1294,7 +1294,7 @@ static void state_colormat(struct wined3d_context *context, const struct wined3d
case GL_SPECULAR:
/* Only change material color if specular is enabled, otherwise it is set to black */
- if (state->render_states[WINED3DRS_SPECULARENABLE])
+ if (state->render_states[WINED3D_RS_SPECULARENABLE])
{
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&state->material.specular);
checkGLcall("glMaterialfv");
@@ -1318,7 +1318,7 @@ static void state_linepattern(struct wined3d_context *context, const struct wine
DWORD d;
struct wined3d_line_pattern lp;
} tmppattern;
- tmppattern.d = state->render_states[WINED3DRS_LINEPATTERN];
+ tmppattern.d = state->render_states[WINED3D_RS_LINEPATTERN];
TRACE("Line pattern: repeat %d bits %x.\n", tmppattern.lp.repeat_factor, tmppattern.lp.line_pattern);
@@ -1345,7 +1345,7 @@ static void state_normalize(struct wined3d_context *context, const struct wined3
* from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
* by zero and is not properly defined in opengl, so avoid it
*/
- if (state->render_states[WINED3DRS_NORMALIZENORMALS]
+ if (state->render_states[WINED3D_RS_NORMALIZENORMALS]
&& (context->swapchain->device->strided_streams.use_map & (1 << WINED3D_FFP_NORMAL)))
{
glEnable(GL_NORMALIZE);
@@ -1365,15 +1365,15 @@ static void state_psizemin_w(struct wined3d_context *context, const struct wined
float f;
} tmpvalue;
- tmpvalue.d = state->render_states[WINED3DRS_POINTSIZE_MIN];
+ tmpvalue.d = state->render_states[WINED3D_RS_POINTSIZE_MIN];
if (tmpvalue.f != 1.0f)
{
- FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
+ FIXME("WINED3D_RS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
}
- tmpvalue.d = state->render_states[WINED3DRS_POINTSIZE_MAX];
+ tmpvalue.d = state->render_states[WINED3D_RS_POINTSIZE_MAX];
if (tmpvalue.f != 64.0f)
{
- FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
+ FIXME("WINED3D_RS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
}
}
@@ -1387,8 +1387,8 @@ static void state_psizemin_ext(struct wined3d_context *context, const struct win
float f;
} min, max;
- min.d = state->render_states[WINED3DRS_POINTSIZE_MIN];
- max.d = state->render_states[WINED3DRS_POINTSIZE_MAX];
+ min.d = state->render_states[WINED3D_RS_POINTSIZE_MIN];
+ max.d = state->render_states[WINED3D_RS_POINTSIZE_MAX];
/* Max point size trumps min point size */
if(min.f > max.f) {
@@ -1410,8 +1410,8 @@ static void state_psizemin_arb(struct wined3d_context *context, const struct win
float f;
} min, max;
- min.d = state->render_states[WINED3DRS_POINTSIZE_MIN];
- max.d = state->render_states[WINED3DRS_POINTSIZE_MAX];
+ min.d = state->render_states[WINED3D_RS_POINTSIZE_MIN];
+ max.d = state->render_states[WINED3D_RS_POINTSIZE_MAX];
/* Max point size trumps min point size */
if(min.f > max.f) {
@@ -1441,12 +1441,12 @@ static void state_pscale(struct wined3d_context *context, const struct wined3d_s
float f;
} pointSize, A, B, C;
- pointSize.d = state->render_states[WINED3DRS_POINTSIZE];
- A.d = state->render_states[WINED3DRS_POINTSCALE_A];
- B.d = state->render_states[WINED3DRS_POINTSCALE_B];
- C.d = state->render_states[WINED3DRS_POINTSCALE_C];
+ pointSize.d = state->render_states[WINED3D_RS_POINTSIZE];
+ A.d = state->render_states[WINED3D_RS_POINTSCALE_A];
+ B.d = state->render_states[WINED3D_RS_POINTSCALE_B];
+ C.d = state->render_states[WINED3D_RS_POINTSCALE_C];
- if (state->render_states[WINED3DRS_POINTSCALEENABLE])
+ if (state->render_states[WINED3D_RS_POINTSCALEENABLE])
{
DWORD h = state->viewport.height;
GLfloat scaleFactor;
@@ -1494,7 +1494,7 @@ static void state_pscale(struct wined3d_context *context, const struct wined3d_s
GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
}
- else if (state->render_states[WINED3DRS_POINTSCALEENABLE])
+ else if (state->render_states[WINED3D_RS_POINTSCALEENABLE])
{
WARN("POINT_PARAMETERS not supported in this version of opengl\n");
}
@@ -1505,15 +1505,15 @@ static void state_pscale(struct wined3d_context *context, const struct wined3d_s
static void state_debug_monitor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- WARN("token: %#x.\n", state->render_states[WINED3DRS_DEBUGMONITORTOKEN]);
+ WARN("token: %#x.\n", state->render_states[WINED3D_RS_DEBUGMONITORTOKEN]);
}
static void state_colorwrite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- DWORD mask0 = state->render_states[WINED3DRS_COLORWRITEENABLE];
- DWORD mask1 = state->render_states[WINED3DRS_COLORWRITEENABLE1];
- DWORD mask2 = state->render_states[WINED3DRS_COLORWRITEENABLE2];
- DWORD mask3 = state->render_states[WINED3DRS_COLORWRITEENABLE3];
+ DWORD mask0 = state->render_states[WINED3D_RS_COLORWRITEENABLE];
+ DWORD mask1 = state->render_states[WINED3D_RS_COLORWRITEENABLE1];
+ DWORD mask2 = state->render_states[WINED3D_RS_COLORWRITEENABLE2];
+ DWORD mask3 = state->render_states[WINED3D_RS_COLORWRITEENABLE3];
TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
mask0 & WINED3DCOLORWRITEENABLE_RED ? 1 : 0,
@@ -1529,7 +1529,7 @@ static void state_colorwrite(struct wined3d_context *context, const struct wined
if (!((mask1 == mask0 && mask2 == mask0 && mask3 == mask0)
|| (mask1 == 0xf && mask2 == 0xf && mask3 == 0xf)))
{
- FIXME("WINED3DRS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
+ FIXME("WINED3D_RS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
mask0, mask1, mask2, mask3);
FIXME("Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n");
}
@@ -1546,27 +1546,27 @@ static void set_color_mask(const struct wined3d_gl_info *gl_info, UINT index, DW
static void state_colorwrite0(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- set_color_mask(context->gl_info, 0, state->render_states[WINED3DRS_COLORWRITEENABLE]);
+ set_color_mask(context->gl_info, 0, state->render_states[WINED3D_RS_COLORWRITEENABLE]);
}
static void state_colorwrite1(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- set_color_mask(context->gl_info, 1, state->render_states[WINED3DRS_COLORWRITEENABLE1]);
+ set_color_mask(context->gl_info, 1, state->render_states[WINED3D_RS_COLORWRITEENABLE1]);
}
static void state_colorwrite2(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- set_color_mask(context->gl_info, 2, state->render_states[WINED3DRS_COLORWRITEENABLE2]);
+ set_color_mask(context->gl_info, 2, state->render_states[WINED3D_RS_COLORWRITEENABLE2]);
}
static void state_colorwrite3(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- set_color_mask(context->gl_info, 3, state->render_states[WINED3DRS_COLORWRITEENABLE3]);
+ set_color_mask(context->gl_info, 3, state->render_states[WINED3D_RS_COLORWRITEENABLE3]);
}
static void state_localviewer(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_LOCALVIEWER])
+ if (state->render_states[WINED3D_RS_LOCALVIEWER])
{
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
@@ -1578,7 +1578,7 @@ static void state_localviewer(struct wined3d_context *context, const struct wine
static void state_lastpixel(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_LASTPIXEL])
+ if (state->render_states[WINED3D_RS_LASTPIXEL])
{
TRACE("Last Pixel Drawing Enabled\n");
}
@@ -1599,7 +1599,7 @@ static void state_pointsprite_w(struct wined3d_context *context, const struct wi
static BOOL warned;
/* TODO: NV_POINT_SPRITE */
- if (!warned && state->render_states[WINED3DRS_POINTSPRITEENABLE])
+ if (!warned && state->render_states[WINED3D_RS_POINTSPRITEENABLE])
{
/* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
FIXME("Point sprites not supported\n");
@@ -1609,7 +1609,7 @@ static void state_pointsprite_w(struct wined3d_context *context, const struct wi
static void state_pointsprite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_POINTSPRITEENABLE])
+ if (state->render_states[WINED3D_RS_POINTSPRITEENABLE])
{
glEnable(GL_POINT_SPRITE_ARB);
checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
@@ -1621,34 +1621,34 @@ static void state_pointsprite(struct wined3d_context *context, const struct wine
static void state_wrap(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_WRAP0]
- || state->render_states[WINED3DRS_WRAP1]
- || state->render_states[WINED3DRS_WRAP2]
- || state->render_states[WINED3DRS_WRAP3]
- || state->render_states[WINED3DRS_WRAP4]
- || state->render_states[WINED3DRS_WRAP5]
- || state->render_states[WINED3DRS_WRAP6]
- || state->render_states[WINED3DRS_WRAP7]
- || state->render_states[WINED3DRS_WRAP8]
- || state->render_states[WINED3DRS_WRAP9]
- || state->render_states[WINED3DRS_WRAP10]
- || state->render_states[WINED3DRS_WRAP11]
- || state->render_states[WINED3DRS_WRAP12]
- || state->render_states[WINED3DRS_WRAP13]
- || state->render_states[WINED3DRS_WRAP14]
- || state->render_states[WINED3DRS_WRAP15])
- FIXME("(WINED3DRS_WRAP0) Texture wrapping not yet supported.\n");
+ if (state->render_states[WINED3D_RS_WRAP0]
+ || state->render_states[WINED3D_RS_WRAP1]
+ || state->render_states[WINED3D_RS_WRAP2]
+ || state->render_states[WINED3D_RS_WRAP3]
+ || state->render_states[WINED3D_RS_WRAP4]
+ || state->render_states[WINED3D_RS_WRAP5]
+ || state->render_states[WINED3D_RS_WRAP6]
+ || state->render_states[WINED3D_RS_WRAP7]
+ || state->render_states[WINED3D_RS_WRAP8]
+ || state->render_states[WINED3D_RS_WRAP9]
+ || state->render_states[WINED3D_RS_WRAP10]
+ || state->render_states[WINED3D_RS_WRAP11]
+ || state->render_states[WINED3D_RS_WRAP12]
+ || state->render_states[WINED3D_RS_WRAP13]
+ || state->render_states[WINED3D_RS_WRAP14]
+ || state->render_states[WINED3D_RS_WRAP15])
+ FIXME("(WINED3D_RS_WRAP0) Texture wrapping not yet supported.\n");
}
static void state_msaa_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_MULTISAMPLEANTIALIAS])
+ if (state->render_states[WINED3D_RS_MULTISAMPLEANTIALIAS])
WARN("Multisample antialiasing not supported by GL.\n");
}
static void state_msaa(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_MULTISAMPLEANTIALIAS])
+ if (state->render_states[WINED3D_RS_MULTISAMPLEANTIALIAS])
{
glEnable(GL_MULTISAMPLE_ARB);
checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
@@ -1660,7 +1660,7 @@ static void state_msaa(struct wined3d_context *context, const struct wined3d_sta
static void state_scissor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SCISSORTESTENABLE])
+ if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
{
glEnable(GL_SCISSOR_TEST);
checkGLcall("glEnable(GL_SCISSOR_TEST)");
@@ -1681,8 +1681,8 @@ static void state_scissor(struct wined3d_context *context, const struct wined3d_
* depth slope, and doesn't need to be scaled. */
static void state_depthbias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SLOPESCALEDEPTHBIAS]
- || state->render_states[WINED3DRS_DEPTHBIAS])
+ if (state->render_states[WINED3D_RS_SLOPESCALEDEPTHBIAS]
+ || state->render_states[WINED3D_RS_DEPTHBIAS])
{
const struct wined3d_surface *depth = state->fb->depth_stencil;
float scale;
@@ -1693,8 +1693,8 @@ static void state_depthbias(struct wined3d_context *context, const struct wined3
float f;
} scale_bias, const_bias;
- scale_bias.d = state->render_states[WINED3DRS_SLOPESCALEDEPTHBIAS];
- const_bias.d = state->render_states[WINED3DRS_DEPTHBIAS];
+ scale_bias.d = state->render_states[WINED3D_RS_SLOPESCALEDEPTHBIAS];
+ const_bias.d = state->render_states[WINED3D_RS_DEPTHBIAS];
glEnable(GL_POLYGON_OFFSET_FILL);
checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
@@ -1734,13 +1734,13 @@ static void state_depthbias(struct wined3d_context *context, const struct wined3
static void state_zvisible(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_ZVISIBLE])
- FIXME("WINED3DRS_ZVISIBLE not implemented.\n");
+ if (state->render_states[WINED3D_RS_ZVISIBLE])
+ FIXME("WINED3D_RS_ZVISIBLE not implemented.\n");
}
static void state_perspective(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_TEXTUREPERSPECTIVE])
+ if (state->render_states[WINED3D_RS_TEXTUREPERSPECTIVE])
{
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
@@ -1752,28 +1752,28 @@ static void state_perspective(struct wined3d_context *context, const struct wine
static void state_stippledalpha(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_STIPPLEDALPHA])
+ if (state->render_states[WINED3D_RS_STIPPLEDALPHA])
FIXME("Stippled Alpha not supported yet.\n");
}
static void state_antialias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_ANTIALIAS])
+ if (state->render_states[WINED3D_RS_ANTIALIAS])
FIXME("Antialias not supported yet.\n");
}
static void state_multisampmask(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_MULTISAMPLEMASK] != 0xffffffff)
- FIXME("WINED3DRS_MULTISAMPLEMASK %#x not yet implemented.\n",
- state->render_states[WINED3DRS_MULTISAMPLEMASK]);
+ if (state->render_states[WINED3D_RS_MULTISAMPLEMASK] != 0xffffffff)
+ FIXME("WINED3D_RS_MULTISAMPLEMASK %#x not yet implemented.\n",
+ state->render_states[WINED3D_RS_MULTISAMPLEMASK]);
}
static void state_patchedgestyle(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
- FIXME("WINED3DRS_PATCHEDGESTYLE %#x not yet implemented.\n",
- state->render_states[WINED3DRS_PATCHEDGESTYLE]);
+ if (state->render_states[WINED3D_RS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
+ FIXME("WINED3D_RS_PATCHEDGESTYLE %#x not yet implemented.\n",
+ state->render_states[WINED3D_RS_PATCHEDGESTYLE]);
}
static void state_patchsegments(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
@@ -1784,13 +1784,13 @@ static void state_patchsegments(struct wined3d_context *context, const struct wi
} tmpvalue;
tmpvalue.f = 1.0f;
- if (state->render_states[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
+ if (state->render_states[WINED3D_RS_PATCHSEGMENTS] != tmpvalue.d)
{
static BOOL displayed = FALSE;
- tmpvalue.d = state->render_states[WINED3DRS_PATCHSEGMENTS];
+ tmpvalue.d = state->render_states[WINED3D_RS_PATCHSEGMENTS];
if(!displayed)
- FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
+ FIXME("(WINED3D_RS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
displayed = TRUE;
}
@@ -1798,23 +1798,23 @@ static void state_patchsegments(struct wined3d_context *context, const struct wi
static void state_positiondegree(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_POSITIONDEGREE] != WINED3D_DEGREE_CUBIC)
- FIXME("WINED3DRS_POSITIONDEGREE %#x not yet implemented.\n",
- state->render_states[WINED3DRS_POSITIONDEGREE]);
+ if (state->render_states[WINED3D_RS_POSITIONDEGREE] != WINED3D_DEGREE_CUBIC)
+ FIXME("WINED3D_RS_POSITIONDEGREE %#x not yet implemented.\n",
+ state->render_states[WINED3D_RS_POSITIONDEGREE]);
}
static void state_normaldegree(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_NORMALDEGREE] != WINED3D_DEGREE_LINEAR)
- FIXME("WINED3DRS_NORMALDEGREE %#x not yet implemented.\n",
- state->render_states[WINED3DRS_NORMALDEGREE]);
+ if (state->render_states[WINED3D_RS_NORMALDEGREE] != WINED3D_DEGREE_LINEAR)
+ FIXME("WINED3D_RS_NORMALDEGREE %#x not yet implemented.\n",
+ state->render_states[WINED3D_RS_NORMALDEGREE]);
}
static void state_tessellation(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION])
- FIXME("WINED3DRS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
- state->render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
+ if (state->render_states[WINED3D_RS_ENABLEADAPTIVETESSELLATION])
+ FIXME("WINED3D_RS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
+ state->render_states[WINED3D_RS_ENABLEADAPTIVETESSELLATION]);
}
static void state_nvdb(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
@@ -1826,10 +1826,10 @@ static void state_nvdb(struct wined3d_context *context, const struct wined3d_sta
const struct wined3d_gl_info *gl_info = context->gl_info;
- if (state->render_states[WINED3DRS_ADAPTIVETESS_X] == WINED3DFMT_NVDB)
+ if (state->render_states[WINED3D_RS_ADAPTIVETESS_X] == WINED3DFMT_NVDB)
{
- zmin.d = state->render_states[WINED3DRS_ADAPTIVETESS_Z];
- zmax.d = state->render_states[WINED3DRS_ADAPTIVETESS_W];
+ zmin.d = state->render_states[WINED3D_RS_ADAPTIVETESS_Z];
+ zmax.d = state->render_states[WINED3D_RS_ADAPTIVETESS_W];
/* If zmin is larger than zmax INVALID_VALUE error is generated.
* In d3d9 test is not performed in this case*/
@@ -1850,96 +1850,96 @@ static void state_nvdb(struct wined3d_context *context, const struct wined3d_sta
checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
}
- state_tessellation(context, state, STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION));
+ state_tessellation(context, state, STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION));
}
static void state_wrapu(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_WRAPU])
- FIXME("Render state WINED3DRS_WRAPU not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_WRAPU])
+ FIXME("Render state WINED3D_RS_WRAPU not implemented yet.\n");
}
static void state_wrapv(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_WRAPV])
- FIXME("Render state WINED3DRS_WRAPV not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_WRAPV])
+ FIXME("Render state WINED3D_RS_WRAPV not implemented yet.\n");
}
static void state_monoenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_MONOENABLE])
- FIXME("Render state WINED3DRS_MONOENABLE not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_MONOENABLE])
+ FIXME("Render state WINED3D_RS_MONOENABLE not implemented yet.\n");
}
static void state_rop2(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_ROP2])
- FIXME("Render state WINED3DRS_ROP2 not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_ROP2])
+ FIXME("Render state WINED3D_RS_ROP2 not implemented yet.\n");
}
static void state_planemask(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_PLANEMASK])
- FIXME("Render state WINED3DRS_PLANEMASK not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_PLANEMASK])
+ FIXME("Render state WINED3D_RS_PLANEMASK not implemented yet.\n");
}
static void state_subpixel(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SUBPIXEL])
- FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_SUBPIXEL])
+ FIXME("Render state WINED3D_RS_SUBPIXEL not implemented yet.\n");
}
static void state_subpixelx(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SUBPIXELX])
- FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_SUBPIXELX])
+ FIXME("Render state WINED3D_RS_SUBPIXELX not implemented yet.\n");
}
static void state_stippleenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_STIPPLEENABLE])
- FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_STIPPLEENABLE])
+ FIXME("Render state WINED3D_RS_STIPPLEENABLE not implemented yet.\n");
}
static void state_mipmaplodbias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_MIPMAPLODBIAS])
- FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_MIPMAPLODBIAS])
+ FIXME("Render state WINED3D_RS_MIPMAPLODBIAS not implemented yet.\n");
}
static void state_anisotropy(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_ANISOTROPY])
- FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_ANISOTROPY])
+ FIXME("Render state WINED3D_RS_ANISOTROPY not implemented yet.\n");
}
static void state_flushbatch(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_FLUSHBATCH])
- FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_FLUSHBATCH])
+ FIXME("Render state WINED3D_RS_FLUSHBATCH not implemented yet.\n");
}
static void state_translucentsi(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_TRANSLUCENTSORTINDEPENDENT])
- FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_TRANSLUCENTSORTINDEPENDENT])
+ FIXME("Render state WINED3D_RS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
}
static void state_extents(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_EXTENTS])
- FIXME("Render state WINED3DRS_EXTENTS not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_EXTENTS])
+ FIXME("Render state WINED3D_RS_EXTENTS not implemented yet.\n");
}
static void state_ckeyblend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_COLORKEYBLENDENABLE])
- FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet.\n");
+ if (state->render_states[WINED3D_RS_COLORKEYBLENDENABLE])
+ FIXME("Render state WINED3D_RS_COLORKEYBLENDENABLE not implemented yet.\n");
}
static void state_swvp(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- if (state->render_states[WINED3DRS_SOFTWAREVERTEXPROCESSING])
+ if (state->render_states[WINED3D_RS_SOFTWAREVERTEXPROCESSING])
FIXME("Software vertex processing not implemented.\n");
}
@@ -3112,7 +3112,7 @@ void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *st
arg2 = state->texture_states[stage][WINED3DTSS_ALPHAARG2];
arg0 = state->texture_states[stage][WINED3DTSS_ALPHAARG0];
- if (state->render_states[WINED3DRS_COLORKEYENABLE] && !stage && state->textures[0])
+ if (state->render_states[WINED3D_RS_COLORKEYENABLE] && !stage && state->textures[0])
{
struct wined3d_texture *texture = state->textures[0];
GLenum texture_dimensions = texture->target;
@@ -3152,7 +3152,7 @@ void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *st
}
else if(op == WINED3DTOP_SELECTARG1 && arg1 != WINED3DTA_TEXTURE)
{
- if (state->render_states[WINED3DRS_ALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
arg2 = WINED3DTA_TEXTURE;
op = WINED3DTOP_MODULATE;
@@ -3161,7 +3161,7 @@ void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *st
}
else if(op == WINED3DTOP_SELECTARG2 && arg2 != WINED3DTA_TEXTURE)
{
- if (state->render_states[WINED3DRS_ALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
arg1 = WINED3DTA_TEXTURE;
op = WINED3DTOP_MODULATE;
@@ -3334,7 +3334,7 @@ static void tex_coordindex(struct wined3d_context *context, const struct wined3d
* FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
* eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
* means use the vertex position (camera-space) as the input texture coordinates
- * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
+ * for this texture stage, and the wrap mode set in the WINED3D_RS_WRAP1 render
* state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
* to the TEXCOORDINDEX value
*/
@@ -3576,11 +3576,11 @@ static void sampler(struct wined3d_context *context, const struct wined3d_state
if (!use_ps(state) && sampler < state->lowest_disabled_stage)
{
- if (state->render_states[WINED3DRS_COLORKEYENABLE] && !sampler)
+ if (state->render_states[WINED3D_RS_COLORKEYENABLE] && !sampler)
{
/* If color keying is enabled update the alpha test, it
* depends on the existence of a color key in stage 0. */
- state_alpha(context, state, WINED3DRS_COLORKEYENABLE);
+ state_alpha(context, state, WINED3D_RS_COLORKEYENABLE);
}
}
@@ -3593,11 +3593,11 @@ static void sampler(struct wined3d_context *context, const struct wined3d_state
if (sampler < state->lowest_disabled_stage)
{
/* TODO: What should I do with pixel shaders here ??? */
- if (state->render_states[WINED3DRS_COLORKEYENABLE] && !sampler)
+ if (state->render_states[WINED3D_RS_COLORKEYENABLE] && !sampler)
{
/* If color keying is enabled update the alpha test, it
* depends on the existence of a color key in stage 0. */
- state_alpha(context, state, WINED3DRS_COLORKEYENABLE);
+ state_alpha(context, state, WINED3D_RS_COLORKEYENABLE);
}
} /* Otherwise tex_colorop disables the stage */
context_bind_texture(context, GL_NONE, 0);
@@ -3780,7 +3780,7 @@ static void transform_worldex(struct wined3d_context *context, const struct wine
static void state_vertexblend_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- WINED3DVERTEXBLENDFLAGS f = state->render_states[WINED3DRS_VERTEXBLEND];
+ WINED3DVERTEXBLENDFLAGS f = state->render_states[WINED3D_RS_VERTEXBLEND];
static unsigned int once;
if (f == WINED3DVBF_DISABLE) return;
@@ -3791,7 +3791,7 @@ static void state_vertexblend_w(struct wined3d_context *context, const struct wi
static void state_vertexblend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- WINED3DVERTEXBLENDFLAGS val = state->render_states[WINED3DRS_VERTEXBLEND];
+ WINED3DVERTEXBLENDFLAGS val = state->render_states[WINED3D_RS_VERTEXBLEND];
struct wined3d_device *device = context->swapchain->device;
const struct wined3d_gl_info *gl_info = context->gl_info;
static unsigned int once;
@@ -3806,7 +3806,7 @@ static void state_vertexblend(struct wined3d_context *context, const struct wine
/* D3D adds one more matrix which has weight (1 - sum(weights)).
* This is enabled at context creation with enabling
* GL_WEIGHT_SUM_UNITY_ARB. */
- GL_EXTCALL(glVertexBlendARB(state->render_states[WINED3DRS_VERTEXBLEND] + 1));
+ GL_EXTCALL(glVertexBlendARB(state->render_states[WINED3D_RS_VERTEXBLEND] + 1));
if (!device->vertexBlendUsed)
{
@@ -4496,25 +4496,25 @@ static void vertexdeclaration(struct wined3d_context *context, const struct wine
if (transformed != wasrhw && !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))
&& !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW)))
transform_world(context, state, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)));
- if (!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX)))
- state_colormat(context, state, STATE_RENDER(WINED3DRS_COLORVERTEX));
- if (!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING)))
- state_lighting(context, state, STATE_RENDER(WINED3DRS_LIGHTING));
+ if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_COLORVERTEX)))
+ state_colormat(context, state, STATE_RENDER(WINED3D_RS_COLORVERTEX));
+ if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_LIGHTING)))
+ state_lighting(context, state, STATE_RENDER(WINED3D_RS_LIGHTING));
if (context->last_was_vshader)
{
updateFog = TRUE;
- if (!device->vs_clipping && !isStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE)))
- state_clipping(context, state, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE));
+ if (!device->vs_clipping && !isStateDirty(context, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE)))
+ state_clipping(context, state, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE));
for (i = 0; i < gl_info->limits.clipplanes; ++i)
{
clipplane(context, state, STATE_CLIPPLANE(i));
}
}
- if (!isStateDirty(context, STATE_RENDER(WINED3DRS_NORMALIZENORMALS)))
- state_normalize(context, state, STATE_RENDER(WINED3DRS_NORMALIZENORMALS));
+ if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS)))
+ state_normalize(context, state, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS));
}
else
{
@@ -4530,7 +4530,7 @@ static void vertexdeclaration(struct wined3d_context *context, const struct wine
checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
}
- if (!warned && state->render_states[WINED3DRS_CLIPPLANEENABLE])
+ if (!warned && state->render_states[WINED3D_RS_CLIPPLANEENABLE])
{
FIXME("Clipping not supported with vertex shaders\n");
warned = TRUE;
@@ -4577,7 +4577,7 @@ static void vertexdeclaration(struct wined3d_context *context, const struct wine
context->last_was_vshader = useVertexShaderFunction;
if (updateFog)
- context_apply_state(context, state, STATE_RENDER(WINED3DRS_FOGVERTEXMODE));
+ context_apply_state(context, state, STATE_RENDER(WINED3D_RS_FOGVERTEXMODE));
if (!useVertexShaderFunction)
{
@@ -4625,8 +4625,8 @@ static void viewport_vertexpart(struct wined3d_context *context, const struct wi
{
if (!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)))
transform_projection(context, state, STATE_TRANSFORM(WINED3DTS_PROJECTION));
- if (!isStateDirty(context, STATE_RENDER(WINED3DRS_POINTSCALEENABLE)))
- state_pscale(context, state, STATE_RENDER(WINED3DRS_POINTSCALEENABLE));
+ if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE)))
+ state_pscale(context, state, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE));
/* Update the position fixup. */
if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT))
shaderconstant(context, state, STATE_VERTEXSHADERCONSTANT);
@@ -4832,16 +4832,16 @@ static void psorigin(struct wined3d_context *context, const struct wined3d_state
}
const struct StateEntryTemplate misc_state_template[] = {
- { STATE_RENDER(WINED3DRS_SRCBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DESTBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_EDGEANTIALIAS), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SRCBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_BLENDOPALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SRCBLEND), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DESTBLEND), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_EDGEANTIALIAS), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ANTIALIASEDLINEENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SEPARATEALPHABLENDENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SRCBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DESTBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DESTBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_BLENDOPALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_STREAMSRC, { STATE_STREAMSRC, streamsrc }, WINED3D_GL_EXT_NONE },
{ STATE_VDECL, { STATE_VDECL, vdecl_miscpart }, WINED3D_GL_EXT_NONE },
{ STATE_FRONTFACE, { STATE_FRONTFACE, frontface }, WINED3D_GL_EXT_NONE },
@@ -4906,99 +4906,99 @@ const struct StateEntryTemplate misc_state_template[] = {
{ STATE_VIEWPORT, { STATE_VIEWPORT, viewport_miscpart }, WINED3D_GL_EXT_NONE },
{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, indexbuffer }, ARB_VERTEX_BUFFER_OBJECT },
{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, state_nop }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ANTIALIAS), { STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ZENABLE), { STATE_RENDER(WINED3DRS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAPU), { STATE_RENDER(WINED3DRS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAPV), { STATE_RENDER(WINED3DRS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FILLMODE), { STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SHADEMODE), { STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_LINEPATTERN), { STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MONOENABLE), { STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ROP2), { STATE_RENDER(WINED3DRS_ROP2), state_rop2 }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_PLANEMASK), { STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ZWRITEENABLE), { STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ALPHAREF), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ALPHAFUNC), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORKEYENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_LASTPIXEL), { STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CULLMODE), { STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ZFUNC), { STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DITHERENABLE), { STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SUBPIXEL), { STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SUBPIXELX), { STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STIPPLEDALPHA), { STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STIPPLEENABLE), { STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ANISOTROPY), { STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FLUSHBATCH), { STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILENABLE), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILREF), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILMASK), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite2s}, EXT_STENCIL_TWO_SIDE },
- { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CCW_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CCW_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CCW_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP0), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP1), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP2), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP3), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP4), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP5), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP6), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP7), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP8), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP9), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP10), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP11), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP12), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP13), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP14), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_WRAP15), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_EXTENTS), { STATE_RENDER(WINED3DRS_EXTENTS), state_extents }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING), { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING), state_swvp }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle}, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_PATCHSEGMENTS), { STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POSITIONDEGREE), { STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree}, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_NORMALDEGREE), { STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ADAPTIVETESS_X), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ADAPTIVETESS_W), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_nvdb }, EXT_DEPTH_BOUNDS_TEST },
- { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa }, ARB_MULTISAMPLE },
- { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_debug_monitor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite0 }, EXT_DRAW_BUFFERS2 },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop }, EXT_BLEND_MINMAX },
- { STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), state_colorwrite1 }, EXT_DRAW_BUFFERS2 },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), state_colorwrite2 }, EXT_DRAW_BUFFERS2 },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), state_colorwrite3 }, EXT_DRAW_BUFFERS2 },
- { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor }, EXT_BLEND_COLOR },
- { STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_ZVISIBLE), { STATE_RENDER(WINED3DRS_ZVISIBLE), state_zvisible }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ANTIALIAS), { STATE_RENDER(WINED3D_RS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), state_perspective }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ZENABLE), { STATE_RENDER(WINED3D_RS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAPU), { STATE_RENDER(WINED3D_RS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAPV), { STATE_RENDER(WINED3D_RS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FILLMODE), { STATE_RENDER(WINED3D_RS_FILLMODE), state_fillmode }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SHADEMODE), { STATE_RENDER(WINED3D_RS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_LINEPATTERN), { STATE_RENDER(WINED3D_RS_LINEPATTERN), state_linepattern }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MONOENABLE), { STATE_RENDER(WINED3D_RS_MONOENABLE), state_monoenable }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ROP2), { STATE_RENDER(WINED3D_RS_ROP2), state_rop2 }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_PLANEMASK), { STATE_RENDER(WINED3D_RS_PLANEMASK), state_planemask }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ZWRITEENABLE), { STATE_RENDER(WINED3D_RS_ZWRITEENABLE), state_zwritenable }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ALPHAREF), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ALPHAFUNC), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORKEYENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_LASTPIXEL), { STATE_RENDER(WINED3D_RS_LASTPIXEL), state_lastpixel }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CULLMODE), { STATE_RENDER(WINED3D_RS_CULLMODE), state_cullmode }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ZFUNC), { STATE_RENDER(WINED3D_RS_ZFUNC), state_zfunc }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DITHERENABLE), { STATE_RENDER(WINED3D_RS_DITHERENABLE), state_ditherenable }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SUBPIXEL), { STATE_RENDER(WINED3D_RS_SUBPIXEL), state_subpixel }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SUBPIXELX), { STATE_RENDER(WINED3D_RS_SUBPIXELX), state_subpixelx }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), state_stippledalpha }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STIPPLEENABLE), { STATE_RENDER(WINED3D_RS_STIPPLEENABLE), state_stippleenable }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), state_mipmaplodbias }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ANISOTROPY), { STATE_RENDER(WINED3D_RS_ANISOTROPY), state_anisotropy }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FLUSHBATCH), { STATE_RENDER(WINED3D_RS_FLUSHBATCH), state_flushbatch }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT),{ STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT),state_translucentsi }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILENABLE), { STATE_RENDER(WINED3D_RS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILZFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILPASS), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILFUNC), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILREF), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILMASK), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), state_stencilwrite2s}, EXT_STENCIL_TWO_SIDE },
+ { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), state_stencilwrite }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CCW_STENCILFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CCW_STENCILZFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CCW_STENCILPASS), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CCW_STENCILFUNC), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP0), { STATE_RENDER(WINED3D_RS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP1), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP2), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP3), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP4), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP5), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP6), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP7), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP8), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP9), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP10), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP11), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP12), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP13), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP14), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_WRAP15), { STATE_RENDER(WINED3D_RS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_EXTENTS), { STATE_RENDER(WINED3D_RS_EXTENTS), state_extents }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), state_ckeyblend }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), state_swvp }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), state_patchedgestyle}, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), state_patchsegments }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POSITIONDEGREE), { STATE_RENDER(WINED3D_RS_POSITIONDEGREE), state_positiondegree}, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_NORMALDEGREE), { STATE_RENDER(WINED3D_RS_NORMALDEGREE), state_normaldegree }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MINTESSELLATIONLEVEL), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MAXTESSELLATIONLEVEL), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_X), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Y), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Z), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_W), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),state_nvdb }, EXT_DEPTH_BOUNDS_TEST },
+ { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),state_tessellation }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_msaa }, ARB_MULTISAMPLE },
+ { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_msaa_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK), { STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK), state_multisampmask }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), state_debug_monitor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), state_colorwrite0 }, EXT_DRAW_BUFFERS2 },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_BLENDOP), { STATE_RENDER(WINED3D_RS_BLENDOP), state_blendop }, EXT_BLEND_MINMAX },
+ { STATE_RENDER(WINED3D_RS_BLENDOP), { STATE_RENDER(WINED3D_RS_BLENDOP), state_blendop_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE), { STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE), state_scissor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SLOPESCALEDEPTHBIAS), { STATE_RENDER(WINED3D_RS_DEPTHBIAS), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), state_colorwrite1 }, EXT_DRAW_BUFFERS2 },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), state_colorwrite2 }, EXT_DRAW_BUFFERS2 },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), state_colorwrite3 }, EXT_DRAW_BUFFERS2 },
+ { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_BLENDFACTOR), { STATE_RENDER(WINED3D_RS_BLENDFACTOR), state_blendfactor }, EXT_BLEND_COLOR },
+ { STATE_RENDER(WINED3D_RS_BLENDFACTOR), { STATE_RENDER(WINED3D_RS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DEPTHBIAS), { STATE_RENDER(WINED3D_RS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_ZVISIBLE), { STATE_RENDER(WINED3D_RS_ZVISIBLE), state_zvisible }, WINED3D_GL_EXT_NONE },
/* Samplers */
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler }, WINED3D_GL_EXT_NONE },
@@ -5030,8 +5030,8 @@ const struct StateEntryTemplate misc_state_template[] = {
const struct StateEntryTemplate ffp_vertexstate_template[] = {
{ STATE_VDECL, { STATE_VDECL, vertexdeclaration }, WINED3D_GL_EXT_NONE },
{ STATE_VSHADER, { STATE_VDECL, NULL }, WINED3D_GL_EXT_NONE },
- { STATE_MATERIAL, { STATE_RENDER(WINED3DRS_SPECULARENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SPECULARENABLE), { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
+ { STATE_MATERIAL, { STATE_RENDER(WINED3D_RS_SPECULARENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SPECULARENABLE), { STATE_RENDER(WINED3D_RS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
/* Clip planes */
{ STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane }, WINED3D_GL_EXT_NONE },
@@ -5360,38 +5360,38 @@ const struct StateEntryTemplate ffp_vertexstate_template[] = {
{ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
/* Fog */
- { STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_RANGEFOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CLIPPING), { STATE_RENDER(WINED3DRS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), { STATE_RENDER(WINED3DRS_CLIPPING), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_LIGHTING), { STATE_RENDER(WINED3DRS_LIGHTING), state_lighting }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_AMBIENT), { STATE_RENDER(WINED3DRS_AMBIENT), state_ambient }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_COLORVERTEX), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_LOCALVIEWER), { STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_NORMALIZENORMALS), { STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend }, ARB_VERTEX_BLEND },
- { STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSIZE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite }, ARB_POINT_SPRITE },
- { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite_w }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSCALE_A), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSCALE_B), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSCALE_C), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, ARB_POINT_PARAMETERS },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, EXT_POINT_PARAMETERS },
- { STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TWEENFACTOR), { STATE_RENDER(WINED3DRS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE), { STATE_RENDER(WINED3DRS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_RANGEFOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CLIPPING), { STATE_RENDER(WINED3D_RS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE), { STATE_RENDER(WINED3D_RS_CLIPPING), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_LIGHTING), { STATE_RENDER(WINED3D_RS_LIGHTING), state_lighting }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_AMBIENT), { STATE_RENDER(WINED3D_RS_AMBIENT), state_ambient }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_COLORVERTEX), { STATE_RENDER(WINED3D_RS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_LOCALVIEWER), { STATE_RENDER(WINED3D_RS_LOCALVIEWER), state_localviewer }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), state_normalize }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_VERTEXBLEND), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), state_vertexblend }, ARB_VERTEX_BLEND },
+ { STATE_RENDER(WINED3D_RS_VERTEXBLEND), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), state_vertexblend_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_pointsprite }, ARB_POINT_SPRITE },
+ { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_pointsprite_w }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSCALE_A), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSCALE_B), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSCALE_C), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, ARB_POINT_PARAMETERS },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, EXT_POINT_PARAMETERS },
+ { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TWEENFACTOR), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
/* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
* so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
@@ -5506,15 +5506,15 @@ static const struct StateEntryTemplate ffp_fragmentstate_template[] = {
{ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), state_texfactor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
+ { STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index e29bbdc..adea6bb 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -29,66 +29,66 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d);
static const DWORD pixel_states_render[] =
{
- WINED3DRS_ALPHABLENDENABLE,
- WINED3DRS_ALPHAFUNC,
- WINED3DRS_ALPHAREF,
- WINED3DRS_ALPHATESTENABLE,
- WINED3DRS_ANTIALIASEDLINEENABLE,
- WINED3DRS_BLENDFACTOR,
- WINED3DRS_BLENDOP,
- WINED3DRS_BLENDOPALPHA,
- WINED3DRS_CCW_STENCILFAIL,
- WINED3DRS_CCW_STENCILPASS,
- WINED3DRS_CCW_STENCILZFAIL,
- WINED3DRS_COLORWRITEENABLE,
- WINED3DRS_COLORWRITEENABLE1,
- WINED3DRS_COLORWRITEENABLE2,
- WINED3DRS_COLORWRITEENABLE3,
- WINED3DRS_DEPTHBIAS,
- WINED3DRS_DESTBLEND,
- WINED3DRS_DESTBLENDALPHA,
- WINED3DRS_DITHERENABLE,
- WINED3DRS_FILLMODE,
- WINED3DRS_FOGDENSITY,
- WINED3DRS_FOGEND,
- WINED3DRS_FOGSTART,
- WINED3DRS_LASTPIXEL,
- WINED3DRS_SCISSORTESTENABLE,
- WINED3DRS_SEPARATEALPHABLENDENABLE,
- WINED3DRS_SHADEMODE,
- WINED3DRS_SLOPESCALEDEPTHBIAS,
- WINED3DRS_SRCBLEND,
- WINED3DRS_SRCBLENDALPHA,
- WINED3DRS_SRGBWRITEENABLE,
- WINED3DRS_STENCILENABLE,
- WINED3DRS_STENCILFAIL,
- WINED3DRS_STENCILFUNC,
- WINED3DRS_STENCILMASK,
- WINED3DRS_STENCILPASS,
- WINED3DRS_STENCILREF,
- WINED3DRS_STENCILWRITEMASK,
- WINED3DRS_STENCILZFAIL,
- WINED3DRS_TEXTUREFACTOR,
- WINED3DRS_TWOSIDEDSTENCILMODE,
- WINED3DRS_WRAP0,
- WINED3DRS_WRAP1,
- WINED3DRS_WRAP10,
- WINED3DRS_WRAP11,
- WINED3DRS_WRAP12,
- WINED3DRS_WRAP13,
- WINED3DRS_WRAP14,
- WINED3DRS_WRAP15,
- WINED3DRS_WRAP2,
- WINED3DRS_WRAP3,
- WINED3DRS_WRAP4,
- WINED3DRS_WRAP5,
- WINED3DRS_WRAP6,
- WINED3DRS_WRAP7,
- WINED3DRS_WRAP8,
- WINED3DRS_WRAP9,
- WINED3DRS_ZENABLE,
- WINED3DRS_ZFUNC,
- WINED3DRS_ZWRITEENABLE,
+ WINED3D_RS_ALPHABLENDENABLE,
+ WINED3D_RS_ALPHAFUNC,
+ WINED3D_RS_ALPHAREF,
+ WINED3D_RS_ALPHATESTENABLE,
+ WINED3D_RS_ANTIALIASEDLINEENABLE,
+ WINED3D_RS_BLENDFACTOR,
+ WINED3D_RS_BLENDOP,
+ WINED3D_RS_BLENDOPALPHA,
+ WINED3D_RS_CCW_STENCILFAIL,
+ WINED3D_RS_CCW_STENCILPASS,
+ WINED3D_RS_CCW_STENCILZFAIL,
+ WINED3D_RS_COLORWRITEENABLE,
+ WINED3D_RS_COLORWRITEENABLE1,
+ WINED3D_RS_COLORWRITEENABLE2,
+ WINED3D_RS_COLORWRITEENABLE3,
+ WINED3D_RS_DEPTHBIAS,
+ WINED3D_RS_DESTBLEND,
+ WINED3D_RS_DESTBLENDALPHA,
+ WINED3D_RS_DITHERENABLE,
+ WINED3D_RS_FILLMODE,
+ WINED3D_RS_FOGDENSITY,
+ WINED3D_RS_FOGEND,
+ WINED3D_RS_FOGSTART,
+ WINED3D_RS_LASTPIXEL,
+ WINED3D_RS_SCISSORTESTENABLE,
+ WINED3D_RS_SEPARATEALPHABLENDENABLE,
+ WINED3D_RS_SHADEMODE,
+ WINED3D_RS_SLOPESCALEDEPTHBIAS,
+ WINED3D_RS_SRCBLEND,
+ WINED3D_RS_SRCBLENDALPHA,
+ WINED3D_RS_SRGBWRITEENABLE,
+ WINED3D_RS_STENCILENABLE,
+ WINED3D_RS_STENCILFAIL,
+ WINED3D_RS_STENCILFUNC,
+ WINED3D_RS_STENCILMASK,
+ WINED3D_RS_STENCILPASS,
+ WINED3D_RS_STENCILREF,
+ WINED3D_RS_STENCILWRITEMASK,
+ WINED3D_RS_STENCILZFAIL,
+ WINED3D_RS_TEXTUREFACTOR,
+ WINED3D_RS_TWOSIDEDSTENCILMODE,
+ WINED3D_RS_WRAP0,
+ WINED3D_RS_WRAP1,
+ WINED3D_RS_WRAP10,
+ WINED3D_RS_WRAP11,
+ WINED3D_RS_WRAP12,
+ WINED3D_RS_WRAP13,
+ WINED3D_RS_WRAP14,
+ WINED3D_RS_WRAP15,
+ WINED3D_RS_WRAP2,
+ WINED3D_RS_WRAP3,
+ WINED3D_RS_WRAP4,
+ WINED3D_RS_WRAP5,
+ WINED3D_RS_WRAP6,
+ WINED3D_RS_WRAP7,
+ WINED3D_RS_WRAP8,
+ WINED3D_RS_WRAP9,
+ WINED3D_RS_ZENABLE,
+ WINED3D_RS_ZFUNC,
+ WINED3D_RS_ZWRITEENABLE,
};
static const DWORD pixel_states_texture[] =
@@ -130,51 +130,51 @@ static const DWORD pixel_states_sampler[] =
static const DWORD vertex_states_render[] =
{
- WINED3DRS_ADAPTIVETESS_W,
- WINED3DRS_ADAPTIVETESS_X,
- WINED3DRS_ADAPTIVETESS_Y,
- WINED3DRS_ADAPTIVETESS_Z,
- WINED3DRS_AMBIENT,
- WINED3DRS_AMBIENTMATERIALSOURCE,
- WINED3DRS_CLIPPING,
- WINED3DRS_CLIPPLANEENABLE,
- WINED3DRS_COLORVERTEX,
- WINED3DRS_CULLMODE,
- WINED3DRS_DIFFUSEMATERIALSOURCE,
- WINED3DRS_EMISSIVEMATERIALSOURCE,
- WINED3DRS_ENABLEADAPTIVETESSELLATION,
- WINED3DRS_FOGCOLOR,
- WINED3DRS_FOGDENSITY,
- WINED3DRS_FOGENABLE,
- WINED3DRS_FOGEND,
- WINED3DRS_FOGSTART,
- WINED3DRS_FOGTABLEMODE,
- WINED3DRS_FOGVERTEXMODE,
- WINED3DRS_INDEXEDVERTEXBLENDENABLE,
- WINED3DRS_LIGHTING,
- WINED3DRS_LOCALVIEWER,
- WINED3DRS_MAXTESSELLATIONLEVEL,
- WINED3DRS_MINTESSELLATIONLEVEL,
- WINED3DRS_MULTISAMPLEANTIALIAS,
- WINED3DRS_MULTISAMPLEMASK,
- WINED3DRS_NORMALDEGREE,
- WINED3DRS_NORMALIZENORMALS,
- WINED3DRS_PATCHEDGESTYLE,
- WINED3DRS_POINTSCALE_A,
- WINED3DRS_POINTSCALE_B,
- WINED3DRS_POINTSCALE_C,
- WINED3DRS_POINTSCALEENABLE,
- WINED3DRS_POINTSIZE,
- WINED3DRS_POINTSIZE_MAX,
- WINED3DRS_POINTSIZE_MIN,
- WINED3DRS_POINTSPRITEENABLE,
- WINED3DRS_POSITIONDEGREE,
- WINED3DRS_RANGEFOGENABLE,
- WINED3DRS_SHADEMODE,
- WINED3DRS_SPECULARENABLE,
- WINED3DRS_SPECULARMATERIALSOURCE,
- WINED3DRS_TWEENFACTOR,
- WINED3DRS_VERTEXBLEND,
+ WINED3D_RS_ADAPTIVETESS_W,
+ WINED3D_RS_ADAPTIVETESS_X,
+ WINED3D_RS_ADAPTIVETESS_Y,
+ WINED3D_RS_ADAPTIVETESS_Z,
+ WINED3D_RS_AMBIENT,
+ WINED3D_RS_AMBIENTMATERIALSOURCE,
+ WINED3D_RS_CLIPPING,
+ WINED3D_RS_CLIPPLANEENABLE,
+ WINED3D_RS_COLORVERTEX,
+ WINED3D_RS_CULLMODE,
+ WINED3D_RS_DIFFUSEMATERIALSOURCE,
+ WINED3D_RS_EMISSIVEMATERIALSOURCE,
+ WINED3D_RS_ENABLEADAPTIVETESSELLATION,
+ WINED3D_RS_FOGCOLOR,
+ WINED3D_RS_FOGDENSITY,
+ WINED3D_RS_FOGENABLE,
+ WINED3D_RS_FOGEND,
+ WINED3D_RS_FOGSTART,
+ WINED3D_RS_FOGTABLEMODE,
+ WINED3D_RS_FOGVERTEXMODE,
+ WINED3D_RS_INDEXEDVERTEXBLENDENABLE,
+ WINED3D_RS_LIGHTING,
+ WINED3D_RS_LOCALVIEWER,
+ WINED3D_RS_MAXTESSELLATIONLEVEL,
+ WINED3D_RS_MINTESSELLATIONLEVEL,
+ WINED3D_RS_MULTISAMPLEANTIALIAS,
+ WINED3D_RS_MULTISAMPLEMASK,
+ WINED3D_RS_NORMALDEGREE,
+ WINED3D_RS_NORMALIZENORMALS,
+ WINED3D_RS_PATCHEDGESTYLE,
+ WINED3D_RS_POINTSCALE_A,
+ WINED3D_RS_POINTSCALE_B,
+ WINED3D_RS_POINTSCALE_C,
+ WINED3D_RS_POINTSCALEENABLE,
+ WINED3D_RS_POINTSIZE,
+ WINED3D_RS_POINTSIZE_MAX,
+ WINED3D_RS_POINTSIZE_MIN,
+ WINED3D_RS_POINTSPRITEENABLE,
+ WINED3D_RS_POSITIONDEGREE,
+ WINED3D_RS_RANGEFOGENABLE,
+ WINED3D_RS_SHADEMODE,
+ WINED3D_RS_SPECULARENABLE,
+ WINED3D_RS_SPECULARMATERIALSOURCE,
+ WINED3D_RS_TWEENFACTOR,
+ WINED3D_RS_VERTEXBLEND,
};
static const DWORD vertex_states_texture[] =
@@ -838,7 +838,7 @@ HRESULT CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
/* Render */
for (i = 0; i < stateblock->num_contained_render_states; ++i)
{
- WINED3DRENDERSTATETYPE rs = stateblock->contained_render_states[i];
+ enum wined3d_render_state rs = stateblock->contained_render_states[i];
TRACE("Updating render state %#x to %u.\n", rs, src_state->render_states[rs]);
@@ -1120,134 +1120,134 @@ void stateblock_init_default_state(struct wined3d_stateblock *stateblock)
TRACE("Render states\n");
/* Render states: */
if (device->auto_depth_stencil)
- state->render_states[WINED3DRS_ZENABLE] = WINED3DZB_TRUE;
+ state->render_states[WINED3D_RS_ZENABLE] = WINED3DZB_TRUE;
else
- state->render_states[WINED3DRS_ZENABLE] = WINED3DZB_FALSE;
- state->render_states[WINED3DRS_FILLMODE] = WINED3DFILL_SOLID;
- state->render_states[WINED3DRS_SHADEMODE] = WINED3DSHADE_GOURAUD;
+ state->render_states[WINED3D_RS_ZENABLE] = WINED3DZB_FALSE;
+ state->render_states[WINED3D_RS_FILLMODE] = WINED3DFILL_SOLID;
+ state->render_states[WINED3D_RS_SHADEMODE] = WINED3DSHADE_GOURAUD;
lp.lp.repeat_factor = 0;
lp.lp.line_pattern = 0;
- state->render_states[WINED3DRS_LINEPATTERN] = lp.d;
- state->render_states[WINED3DRS_ZWRITEENABLE] = TRUE;
- state->render_states[WINED3DRS_ALPHATESTENABLE] = FALSE;
- state->render_states[WINED3DRS_LASTPIXEL] = TRUE;
- state->render_states[WINED3DRS_SRCBLEND] = WINED3D_BLEND_ONE;
- state->render_states[WINED3DRS_DESTBLEND] = WINED3D_BLEND_ZERO;
- state->render_states[WINED3DRS_CULLMODE] = WINED3DCULL_CCW;
- state->render_states[WINED3DRS_ZFUNC] = WINED3DCMP_LESSEQUAL;
- state->render_states[WINED3DRS_ALPHAFUNC] = WINED3DCMP_ALWAYS;
- state->render_states[WINED3DRS_ALPHAREF] = 0;
- state->render_states[WINED3DRS_DITHERENABLE] = FALSE;
- state->render_states[WINED3DRS_ALPHABLENDENABLE] = FALSE;
- state->render_states[WINED3DRS_FOGENABLE] = FALSE;
- state->render_states[WINED3DRS_SPECULARENABLE] = FALSE;
- state->render_states[WINED3DRS_ZVISIBLE] = 0;
- state->render_states[WINED3DRS_FOGCOLOR] = 0;
- state->render_states[WINED3DRS_FOGTABLEMODE] = WINED3DFOG_NONE;
+ state->render_states[WINED3D_RS_LINEPATTERN] = lp.d;
+ state->render_states[WINED3D_RS_ZWRITEENABLE] = TRUE;
+ state->render_states[WINED3D_RS_ALPHATESTENABLE] = FALSE;
+ state->render_states[WINED3D_RS_LASTPIXEL] = TRUE;
+ state->render_states[WINED3D_RS_SRCBLEND] = WINED3D_BLEND_ONE;
+ state->render_states[WINED3D_RS_DESTBLEND] = WINED3D_BLEND_ZERO;
+ state->render_states[WINED3D_RS_CULLMODE] = WINED3DCULL_CCW;
+ state->render_states[WINED3D_RS_ZFUNC] = WINED3DCMP_LESSEQUAL;
+ state->render_states[WINED3D_RS_ALPHAFUNC] = WINED3DCMP_ALWAYS;
+ state->render_states[WINED3D_RS_ALPHAREF] = 0;
+ state->render_states[WINED3D_RS_DITHERENABLE] = FALSE;
+ state->render_states[WINED3D_RS_ALPHABLENDENABLE] = FALSE;
+ state->render_states[WINED3D_RS_FOGENABLE] = FALSE;
+ state->render_states[WINED3D_RS_SPECULARENABLE] = FALSE;
+ state->render_states[WINED3D_RS_ZVISIBLE] = 0;
+ state->render_states[WINED3D_RS_FOGCOLOR] = 0;
+ state->render_states[WINED3D_RS_FOGTABLEMODE] = WINED3DFOG_NONE;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_FOGSTART] = tmpfloat.d;
+ state->render_states[WINED3D_RS_FOGSTART] = tmpfloat.d;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_FOGEND] = tmpfloat.d;
+ state->render_states[WINED3D_RS_FOGEND] = tmpfloat.d;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_FOGDENSITY] = tmpfloat.d;
- state->render_states[WINED3DRS_EDGEANTIALIAS] = FALSE;
- state->render_states[WINED3DRS_RANGEFOGENABLE] = FALSE;
- state->render_states[WINED3DRS_STENCILENABLE] = FALSE;
- state->render_states[WINED3DRS_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_STENCILPASS] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_STENCILREF] = 0;
- state->render_states[WINED3DRS_STENCILMASK] = 0xffffffff;
- state->render_states[WINED3DRS_STENCILFUNC] = WINED3DCMP_ALWAYS;
- state->render_states[WINED3DRS_STENCILWRITEMASK] = 0xffffffff;
- state->render_states[WINED3DRS_TEXTUREFACTOR] = 0xffffffff;
- state->render_states[WINED3DRS_WRAP0] = 0;
- state->render_states[WINED3DRS_WRAP1] = 0;
- state->render_states[WINED3DRS_WRAP2] = 0;
- state->render_states[WINED3DRS_WRAP3] = 0;
- state->render_states[WINED3DRS_WRAP4] = 0;
- state->render_states[WINED3DRS_WRAP5] = 0;
- state->render_states[WINED3DRS_WRAP6] = 0;
- state->render_states[WINED3DRS_WRAP7] = 0;
- state->render_states[WINED3DRS_CLIPPING] = TRUE;
- state->render_states[WINED3DRS_LIGHTING] = TRUE;
- state->render_states[WINED3DRS_AMBIENT] = 0;
- state->render_states[WINED3DRS_FOGVERTEXMODE] = WINED3DFOG_NONE;
- state->render_states[WINED3DRS_COLORVERTEX] = TRUE;
- state->render_states[WINED3DRS_LOCALVIEWER] = TRUE;
- state->render_states[WINED3DRS_NORMALIZENORMALS] = FALSE;
- state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE] = WINED3DMCS_COLOR1;
- state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] = WINED3DMCS_COLOR2;
- state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] = WINED3DMCS_MATERIAL;
- state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] = WINED3DMCS_MATERIAL;
- state->render_states[WINED3DRS_VERTEXBLEND] = WINED3DVBF_DISABLE;
- state->render_states[WINED3DRS_CLIPPLANEENABLE] = 0;
- state->render_states[WINED3DRS_SOFTWAREVERTEXPROCESSING] = FALSE;
+ state->render_states[WINED3D_RS_FOGDENSITY] = tmpfloat.d;
+ state->render_states[WINED3D_RS_EDGEANTIALIAS] = FALSE;
+ state->render_states[WINED3D_RS_RANGEFOGENABLE] = FALSE;
+ state->render_states[WINED3D_RS_STENCILENABLE] = FALSE;
+ state->render_states[WINED3D_RS_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_STENCILPASS] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_STENCILREF] = 0;
+ state->render_states[WINED3D_RS_STENCILMASK] = 0xffffffff;
+ state->render_states[WINED3D_RS_STENCILFUNC] = WINED3DCMP_ALWAYS;
+ state->render_states[WINED3D_RS_STENCILWRITEMASK] = 0xffffffff;
+ state->render_states[WINED3D_RS_TEXTUREFACTOR] = 0xffffffff;
+ state->render_states[WINED3D_RS_WRAP0] = 0;
+ state->render_states[WINED3D_RS_WRAP1] = 0;
+ state->render_states[WINED3D_RS_WRAP2] = 0;
+ state->render_states[WINED3D_RS_WRAP3] = 0;
+ state->render_states[WINED3D_RS_WRAP4] = 0;
+ state->render_states[WINED3D_RS_WRAP5] = 0;
+ state->render_states[WINED3D_RS_WRAP6] = 0;
+ state->render_states[WINED3D_RS_WRAP7] = 0;
+ state->render_states[WINED3D_RS_CLIPPING] = TRUE;
+ state->render_states[WINED3D_RS_LIGHTING] = TRUE;
+ state->render_states[WINED3D_RS_AMBIENT] = 0;
+ state->render_states[WINED3D_RS_FOGVERTEXMODE] = WINED3DFOG_NONE;
+ state->render_states[WINED3D_RS_COLORVERTEX] = TRUE;
+ state->render_states[WINED3D_RS_LOCALVIEWER] = TRUE;
+ state->render_states[WINED3D_RS_NORMALIZENORMALS] = FALSE;
+ state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE] = WINED3DMCS_COLOR1;
+ state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE] = WINED3DMCS_COLOR2;
+ state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE] = WINED3DMCS_MATERIAL;
+ state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE] = WINED3DMCS_MATERIAL;
+ state->render_states[WINED3D_RS_VERTEXBLEND] = WINED3DVBF_DISABLE;
+ state->render_states[WINED3D_RS_CLIPPLANEENABLE] = 0;
+ state->render_states[WINED3D_RS_SOFTWAREVERTEXPROCESSING] = FALSE;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_POINTSIZE] = tmpfloat.d;
+ state->render_states[WINED3D_RS_POINTSIZE] = tmpfloat.d;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_POINTSIZE_MIN] = tmpfloat.d;
- state->render_states[WINED3DRS_POINTSPRITEENABLE] = FALSE;
- state->render_states[WINED3DRS_POINTSCALEENABLE] = FALSE;
+ state->render_states[WINED3D_RS_POINTSIZE_MIN] = tmpfloat.d;
+ state->render_states[WINED3D_RS_POINTSPRITEENABLE] = FALSE;
+ state->render_states[WINED3D_RS_POINTSCALEENABLE] = FALSE;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_POINTSCALE_A] = tmpfloat.d;
+ state->render_states[WINED3D_RS_POINTSCALE_A] = tmpfloat.d;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_POINTSCALE_B] = tmpfloat.d;
+ state->render_states[WINED3D_RS_POINTSCALE_B] = tmpfloat.d;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_POINTSCALE_C] = tmpfloat.d;
- state->render_states[WINED3DRS_MULTISAMPLEANTIALIAS] = TRUE;
- state->render_states[WINED3DRS_MULTISAMPLEMASK] = 0xffffffff;
- state->render_states[WINED3DRS_PATCHEDGESTYLE] = WINED3DPATCHEDGE_DISCRETE;
+ state->render_states[WINED3D_RS_POINTSCALE_C] = tmpfloat.d;
+ state->render_states[WINED3D_RS_MULTISAMPLEANTIALIAS] = TRUE;
+ state->render_states[WINED3D_RS_MULTISAMPLEMASK] = 0xffffffff;
+ state->render_states[WINED3D_RS_PATCHEDGESTYLE] = WINED3DPATCHEDGE_DISCRETE;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_PATCHSEGMENTS] = tmpfloat.d;
- state->render_states[WINED3DRS_DEBUGMONITORTOKEN] = 0xbaadcafe;
+ state->render_states[WINED3D_RS_PATCHSEGMENTS] = tmpfloat.d;
+ state->render_states[WINED3D_RS_DEBUGMONITORTOKEN] = 0xbaadcafe;
tmpfloat.f = gl_info->limits.pointsize_max;
- state->render_states[WINED3DRS_POINTSIZE_MAX] = tmpfloat.d;
- state->render_states[WINED3DRS_INDEXEDVERTEXBLENDENABLE] = FALSE;
- state->render_states[WINED3DRS_COLORWRITEENABLE] = 0x0000000f;
+ state->render_states[WINED3D_RS_POINTSIZE_MAX] = tmpfloat.d;
+ state->render_states[WINED3D_RS_INDEXEDVERTEXBLENDENABLE] = FALSE;
+ state->render_states[WINED3D_RS_COLORWRITEENABLE] = 0x0000000f;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_TWEENFACTOR] = tmpfloat.d;
- state->render_states[WINED3DRS_BLENDOP] = WINED3D_BLEND_OP_ADD;
- state->render_states[WINED3DRS_POSITIONDEGREE] = WINED3D_DEGREE_CUBIC;
- state->render_states[WINED3DRS_NORMALDEGREE] = WINED3D_DEGREE_LINEAR;
+ state->render_states[WINED3D_RS_TWEENFACTOR] = tmpfloat.d;
+ state->render_states[WINED3D_RS_BLENDOP] = WINED3D_BLEND_OP_ADD;
+ state->render_states[WINED3D_RS_POSITIONDEGREE] = WINED3D_DEGREE_CUBIC;
+ state->render_states[WINED3D_RS_NORMALDEGREE] = WINED3D_DEGREE_LINEAR;
/* states new in d3d9 */
- state->render_states[WINED3DRS_SCISSORTESTENABLE] = FALSE;
- state->render_states[WINED3DRS_SLOPESCALEDEPTHBIAS] = 0;
+ state->render_states[WINED3D_RS_SCISSORTESTENABLE] = FALSE;
+ state->render_states[WINED3D_RS_SLOPESCALEDEPTHBIAS] = 0;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_MINTESSELLATIONLEVEL] = tmpfloat.d;
- state->render_states[WINED3DRS_MAXTESSELLATIONLEVEL] = tmpfloat.d;
- state->render_states[WINED3DRS_ANTIALIASEDLINEENABLE] = FALSE;
+ state->render_states[WINED3D_RS_MINTESSELLATIONLEVEL] = tmpfloat.d;
+ state->render_states[WINED3D_RS_MAXTESSELLATIONLEVEL] = tmpfloat.d;
+ state->render_states[WINED3D_RS_ANTIALIASEDLINEENABLE] = FALSE;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_ADAPTIVETESS_X] = tmpfloat.d;
- state->render_states[WINED3DRS_ADAPTIVETESS_Y] = tmpfloat.d;
+ state->render_states[WINED3D_RS_ADAPTIVETESS_X] = tmpfloat.d;
+ state->render_states[WINED3D_RS_ADAPTIVETESS_Y] = tmpfloat.d;
tmpfloat.f = 1.0f;
- state->render_states[WINED3DRS_ADAPTIVETESS_Z] = tmpfloat.d;
+ state->render_states[WINED3D_RS_ADAPTIVETESS_Z] = tmpfloat.d;
tmpfloat.f = 0.0f;
- state->render_states[WINED3DRS_ADAPTIVETESS_W] = tmpfloat.d;
- state->render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION] = FALSE;
- state->render_states[WINED3DRS_TWOSIDEDSTENCILMODE] = FALSE;
- state->render_states[WINED3DRS_CCW_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_CCW_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_CCW_STENCILPASS] = WINED3DSTENCILOP_KEEP;
- state->render_states[WINED3DRS_CCW_STENCILFUNC] = WINED3DCMP_ALWAYS;
- state->render_states[WINED3DRS_COLORWRITEENABLE1] = 0x0000000f;
- state->render_states[WINED3DRS_COLORWRITEENABLE2] = 0x0000000f;
- state->render_states[WINED3DRS_COLORWRITEENABLE3] = 0x0000000f;
- state->render_states[WINED3DRS_BLENDFACTOR] = 0xFFFFFFFF;
- state->render_states[WINED3DRS_SRGBWRITEENABLE] = 0;
- state->render_states[WINED3DRS_DEPTHBIAS] = 0;
- state->render_states[WINED3DRS_WRAP8] = 0;
- state->render_states[WINED3DRS_WRAP9] = 0;
- state->render_states[WINED3DRS_WRAP10] = 0;
- state->render_states[WINED3DRS_WRAP11] = 0;
- state->render_states[WINED3DRS_WRAP12] = 0;
- state->render_states[WINED3DRS_WRAP13] = 0;
- state->render_states[WINED3DRS_WRAP14] = 0;
- state->render_states[WINED3DRS_WRAP15] = 0;
- state->render_states[WINED3DRS_SEPARATEALPHABLENDENABLE] = FALSE;
- state->render_states[WINED3DRS_SRCBLENDALPHA] = WINED3D_BLEND_ONE;
- state->render_states[WINED3DRS_DESTBLENDALPHA] = WINED3D_BLEND_ZERO;
- state->render_states[WINED3DRS_BLENDOPALPHA] = WINED3D_BLEND_OP_ADD;
+ state->render_states[WINED3D_RS_ADAPTIVETESS_W] = tmpfloat.d;
+ state->render_states[WINED3D_RS_ENABLEADAPTIVETESSELLATION] = FALSE;
+ state->render_states[WINED3D_RS_TWOSIDEDSTENCILMODE] = FALSE;
+ state->render_states[WINED3D_RS_CCW_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_CCW_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_CCW_STENCILPASS] = WINED3DSTENCILOP_KEEP;
+ state->render_states[WINED3D_RS_CCW_STENCILFUNC] = WINED3DCMP_ALWAYS;
+ state->render_states[WINED3D_RS_COLORWRITEENABLE1] = 0x0000000f;
+ state->render_states[WINED3D_RS_COLORWRITEENABLE2] = 0x0000000f;
+ state->render_states[WINED3D_RS_COLORWRITEENABLE3] = 0x0000000f;
+ state->render_states[WINED3D_RS_BLENDFACTOR] = 0xFFFFFFFF;
+ state->render_states[WINED3D_RS_SRGBWRITEENABLE] = 0;
+ state->render_states[WINED3D_RS_DEPTHBIAS] = 0;
+ state->render_states[WINED3D_RS_WRAP8] = 0;
+ state->render_states[WINED3D_RS_WRAP9] = 0;
+ state->render_states[WINED3D_RS_WRAP10] = 0;
+ state->render_states[WINED3D_RS_WRAP11] = 0;
+ state->render_states[WINED3D_RS_WRAP12] = 0;
+ state->render_states[WINED3D_RS_WRAP13] = 0;
+ state->render_states[WINED3D_RS_WRAP14] = 0;
+ state->render_states[WINED3D_RS_WRAP15] = 0;
+ state->render_states[WINED3D_RS_SEPARATEALPHABLENDENABLE] = FALSE;
+ state->render_states[WINED3D_RS_SRCBLENDALPHA] = WINED3D_BLEND_ONE;
+ state->render_states[WINED3D_RS_DESTBLENDALPHA] = WINED3D_BLEND_ZERO;
+ state->render_states[WINED3D_RS_BLENDOPALPHA] = WINED3D_BLEND_OP_ADD;
/* Texture Stage States - Put directly into state block, we will call function below */
for (i = 0; i < MAX_TEXTURES; ++i)
diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c
index bd45ae3..64dd24d 100644
--- a/dlls/wined3d/surface.c
+++ b/dlls/wined3d/surface.c
@@ -1077,21 +1077,21 @@ static void wined3d_surface_depth_blt_fbo(const struct wined3d_device *device, s
if (gl_mask & GL_DEPTH_BUFFER_BIT)
{
glDepthMask(GL_TRUE);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZWRITEENABLE));
}
if (gl_mask & GL_STENCIL_BUFFER_BIT)
{
if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
{
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE));
}
glStencilMask(~0U);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
}
glDisable(GL_SCISSOR_TEST);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom,
dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom, gl_mask, GL_NEAREST);
@@ -1206,13 +1206,13 @@ static void surface_blt_fbo(const struct wined3d_device *device, const WINED3DTE
context_invalidate_state(context, STATE_FRAMEBUFFER);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
glDisable(GL_SCISSOR_TEST);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
gl_info->fbo_ops.glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom,
dst_rect.left, dst_rect.top, dst_rect.right, dst_rect.bottom, GL_COLOR_BUFFER_BIT, gl_filter);
diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c
index 39886190..c64c5ef 100644
--- a/dlls/wined3d/swapchain.c
+++ b/dlls/wined3d/swapchain.c
@@ -327,13 +327,13 @@ static void swapchain_blit(const struct wined3d_swapchain *swapchain,
context_invalidate_state(context, STATE_FRAMEBUFFER);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
glDisable(GL_SCISSOR_TEST);
- context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
+ context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
/* Note that the texture is upside down */
gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom,
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index b4f4ff8..2063701 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -2016,137 +2016,137 @@ const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
}
}
-const char *debug_d3drenderstate(WINED3DRENDERSTATETYPE state)
+const char *debug_d3drenderstate(enum wined3d_render_state state)
{
switch (state)
{
#define D3DSTATE_TO_STR(u) case u: return #u
- D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS);
- D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE);
- D3DSTATE_TO_STR(WINED3DRS_WRAPU);
- D3DSTATE_TO_STR(WINED3DRS_WRAPV);
- D3DSTATE_TO_STR(WINED3DRS_ZENABLE);
- D3DSTATE_TO_STR(WINED3DRS_FILLMODE);
- D3DSTATE_TO_STR(WINED3DRS_SHADEMODE);
- D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN);
- D3DSTATE_TO_STR(WINED3DRS_MONOENABLE);
- D3DSTATE_TO_STR(WINED3DRS_ROP2);
- D3DSTATE_TO_STR(WINED3DRS_PLANEMASK);
- D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE);
- D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL);
- D3DSTATE_TO_STR(WINED3DRS_SRCBLEND);
- D3DSTATE_TO_STR(WINED3DRS_DESTBLEND);
- D3DSTATE_TO_STR(WINED3DRS_CULLMODE);
- D3DSTATE_TO_STR(WINED3DRS_ZFUNC);
- D3DSTATE_TO_STR(WINED3DRS_ALPHAREF);
- D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC);
- D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE);
- D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE);
- D3DSTATE_TO_STR(WINED3DRS_FOGENABLE);
- D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE);
- D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE);
- D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL);
- D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX);
- D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA);
- D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR);
- D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE);
- D3DSTATE_TO_STR(WINED3DRS_FOGSTART);
- D3DSTATE_TO_STR(WINED3DRS_FOGEND);
- D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY);
- D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS);
- D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE);
- D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS);
- D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE);
- D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY);
- D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH);
- D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
- D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE);
- D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL);
- D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL);
- D3DSTATE_TO_STR(WINED3DRS_STENCILPASS);
- D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC);
- D3DSTATE_TO_STR(WINED3DRS_STENCILREF);
- D3DSTATE_TO_STR(WINED3DRS_STENCILMASK);
- D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK);
- D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR);
- D3DSTATE_TO_STR(WINED3DRS_WRAP0);
- D3DSTATE_TO_STR(WINED3DRS_WRAP1);
- D3DSTATE_TO_STR(WINED3DRS_WRAP2);
- D3DSTATE_TO_STR(WINED3DRS_WRAP3);
- D3DSTATE_TO_STR(WINED3DRS_WRAP4);
- D3DSTATE_TO_STR(WINED3DRS_WRAP5);
- D3DSTATE_TO_STR(WINED3DRS_WRAP6);
- D3DSTATE_TO_STR(WINED3DRS_WRAP7);
- D3DSTATE_TO_STR(WINED3DRS_CLIPPING);
- D3DSTATE_TO_STR(WINED3DRS_LIGHTING);
- D3DSTATE_TO_STR(WINED3DRS_EXTENTS);
- D3DSTATE_TO_STR(WINED3DRS_AMBIENT);
- D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE);
- D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX);
- D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER);
- D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS);
- D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE);
- D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE);
- D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE);
- D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE);
- D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE);
- D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND);
- D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING);
- D3DSTATE_TO_STR(WINED3DRS_POINTSIZE);
- D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN);
- D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A);
- D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B);
- D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C);
- D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS);
- D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK);
- D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE);
- D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS);
- D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN);
- D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX);
- D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE);
- D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR);
- D3DSTATE_TO_STR(WINED3DRS_BLENDOP);
- D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE);
- D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE);
- D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE);
- D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS);
- D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL);
- D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL);
- D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X);
- D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y);
- D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z);
- D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W);
- D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
- D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE);
- D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL);
- D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL);
- D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS);
- D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC);
- D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1);
- D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2);
- D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3);
- D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR);
- D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE);
- D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS);
- D3DSTATE_TO_STR(WINED3DRS_WRAP8);
- D3DSTATE_TO_STR(WINED3DRS_WRAP9);
- D3DSTATE_TO_STR(WINED3DRS_WRAP10);
- D3DSTATE_TO_STR(WINED3DRS_WRAP11);
- D3DSTATE_TO_STR(WINED3DRS_WRAP12);
- D3DSTATE_TO_STR(WINED3DRS_WRAP13);
- D3DSTATE_TO_STR(WINED3DRS_WRAP14);
- D3DSTATE_TO_STR(WINED3DRS_WRAP15);
- D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE);
- D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA);
- D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA);
- D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA);
+ D3DSTATE_TO_STR(WINED3D_RS_ANTIALIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_TEXTUREPERSPECTIVE);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAPU);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAPV);
+ D3DSTATE_TO_STR(WINED3D_RS_ZENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_FILLMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_SHADEMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_LINEPATTERN);
+ D3DSTATE_TO_STR(WINED3D_RS_MONOENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_ROP2);
+ D3DSTATE_TO_STR(WINED3D_RS_PLANEMASK);
+ D3DSTATE_TO_STR(WINED3D_RS_ZWRITEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_ALPHATESTENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_LASTPIXEL);
+ D3DSTATE_TO_STR(WINED3D_RS_SRCBLEND);
+ D3DSTATE_TO_STR(WINED3D_RS_DESTBLEND);
+ D3DSTATE_TO_STR(WINED3D_RS_CULLMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_ZFUNC);
+ D3DSTATE_TO_STR(WINED3D_RS_ALPHAREF);
+ D3DSTATE_TO_STR(WINED3D_RS_ALPHAFUNC);
+ D3DSTATE_TO_STR(WINED3D_RS_DITHERENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_ALPHABLENDENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_SPECULARENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_ZVISIBLE);
+ D3DSTATE_TO_STR(WINED3D_RS_SUBPIXEL);
+ D3DSTATE_TO_STR(WINED3D_RS_SUBPIXELX);
+ D3DSTATE_TO_STR(WINED3D_RS_STIPPLEDALPHA);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGCOLOR);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGTABLEMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGSTART);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGEND);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGDENSITY);
+ D3DSTATE_TO_STR(WINED3D_RS_STIPPLEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_EDGEANTIALIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORKEYENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_MIPMAPLODBIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_RANGEFOGENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_ANISOTROPY);
+ D3DSTATE_TO_STR(WINED3D_RS_FLUSHBATCH);
+ D3DSTATE_TO_STR(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILFAIL);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILZFAIL);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILPASS);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILFUNC);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILREF);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILMASK);
+ D3DSTATE_TO_STR(WINED3D_RS_STENCILWRITEMASK);
+ D3DSTATE_TO_STR(WINED3D_RS_TEXTUREFACTOR);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP0);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP1);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP2);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP3);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP4);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP5);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP6);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP7);
+ D3DSTATE_TO_STR(WINED3D_RS_CLIPPING);
+ D3DSTATE_TO_STR(WINED3D_RS_LIGHTING);
+ D3DSTATE_TO_STR(WINED3D_RS_EXTENTS);
+ D3DSTATE_TO_STR(WINED3D_RS_AMBIENT);
+ D3DSTATE_TO_STR(WINED3D_RS_FOGVERTEXMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORVERTEX);
+ D3DSTATE_TO_STR(WINED3D_RS_LOCALVIEWER);
+ D3DSTATE_TO_STR(WINED3D_RS_NORMALIZENORMALS);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORKEYBLENDENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_DIFFUSEMATERIALSOURCE);
+ D3DSTATE_TO_STR(WINED3D_RS_SPECULARMATERIALSOURCE);
+ D3DSTATE_TO_STR(WINED3D_RS_AMBIENTMATERIALSOURCE);
+ D3DSTATE_TO_STR(WINED3D_RS_EMISSIVEMATERIALSOURCE);
+ D3DSTATE_TO_STR(WINED3D_RS_VERTEXBLEND);
+ D3DSTATE_TO_STR(WINED3D_RS_CLIPPLANEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_SOFTWAREVERTEXPROCESSING);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MIN);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSPRITEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSCALEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_A);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_B);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_C);
+ D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEANTIALIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEMASK);
+ D3DSTATE_TO_STR(WINED3D_RS_PATCHEDGESTYLE);
+ D3DSTATE_TO_STR(WINED3D_RS_PATCHSEGMENTS);
+ D3DSTATE_TO_STR(WINED3D_RS_DEBUGMONITORTOKEN);
+ D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MAX);
+ D3DSTATE_TO_STR(WINED3D_RS_INDEXEDVERTEXBLENDENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_TWEENFACTOR);
+ D3DSTATE_TO_STR(WINED3D_RS_BLENDOP);
+ D3DSTATE_TO_STR(WINED3D_RS_POSITIONDEGREE);
+ D3DSTATE_TO_STR(WINED3D_RS_NORMALDEGREE);
+ D3DSTATE_TO_STR(WINED3D_RS_SCISSORTESTENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_SLOPESCALEDEPTHBIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_ANTIALIASEDLINEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_MINTESSELLATIONLEVEL);
+ D3DSTATE_TO_STR(WINED3D_RS_MAXTESSELLATIONLEVEL);
+ D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_X);
+ D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Y);
+ D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Z);
+ D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_W);
+ D3DSTATE_TO_STR(WINED3D_RS_ENABLEADAPTIVETESSELLATION);
+ D3DSTATE_TO_STR(WINED3D_RS_TWOSIDEDSTENCILMODE);
+ D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFAIL);
+ D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILZFAIL);
+ D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILPASS);
+ D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFUNC);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE1);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE2);
+ D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE3);
+ D3DSTATE_TO_STR(WINED3D_RS_BLENDFACTOR);
+ D3DSTATE_TO_STR(WINED3D_RS_SRGBWRITEENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_DEPTHBIAS);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP8);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP9);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP10);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP11);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP12);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP13);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP14);
+ D3DSTATE_TO_STR(WINED3D_RS_WRAP15);
+ D3DSTATE_TO_STR(WINED3D_RS_SEPARATEALPHABLENDENABLE);
+ D3DSTATE_TO_STR(WINED3D_RS_SRCBLENDALPHA);
+ D3DSTATE_TO_STR(WINED3D_RS_DESTBLENDALPHA);
+ D3DSTATE_TO_STR(WINED3D_RS_BLENDOPALPHA);
#undef D3DSTATE_TO_STR
default:
FIXME("Unrecognized %u render state!\n", state);
@@ -2998,7 +2998,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
aarg0 = (args[aop] & ARG0) ? state->texture_states[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
}
- if (!i && state->textures[0] && state->render_states[WINED3DRS_COLORKEYENABLE])
+ if (!i && state->textures[0] && state->render_states[WINED3D_RS_COLORKEYENABLE])
{
GLenum texture_dimensions;
@@ -3018,7 +3018,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
}
else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
{
- if (state->render_states[WINED3DRS_ALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
aarg2 = WINED3DTA_TEXTURE;
aop = WINED3DTOP_MODULATE;
@@ -3027,7 +3027,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
}
else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
{
- if (state->render_states[WINED3DRS_ALPHABLENDENABLE])
+ if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
{
aarg1 = WINED3DTA_TEXTURE;
aop = WINED3DTOP_MODULATE;
@@ -3082,11 +3082,11 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
}
- if (!state->render_states[WINED3DRS_FOGENABLE])
+ if (!state->render_states[WINED3D_RS_FOGENABLE])
{
settings->fog = FOG_OFF;
}
- else if (state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
+ else if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3DFOG_NONE)
{
if (use_vs(state) || state->vertex_declaration->position_transformed)
{
@@ -3094,7 +3094,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
}
else
{
- switch (state->render_states[WINED3DRS_FOGVERTEXMODE])
+ switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
{
case WINED3DFOG_NONE:
case WINED3DFOG_LINEAR:
@@ -3111,7 +3111,7 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
}
else
{
- switch (state->render_states[WINED3DRS_FOGTABLEMODE])
+ switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
{
case WINED3DFOG_LINEAR:
settings->fog = FOG_LINEAR;
@@ -3124,15 +3124,15 @@ void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_s
break;
}
}
- if (state->render_states[WINED3DRS_SRGBWRITEENABLE]
+ if (state->render_states[WINED3D_RS_SRGBWRITEENABLE]
&& rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE)
{
settings->sRGB_write = 1;
} else {
settings->sRGB_write = 0;
}
- if (device->vs_clipping || !use_vs(state) || !state->render_states[WINED3DRS_CLIPPING]
- || !state->render_states[WINED3DRS_CLIPPLANEENABLE])
+ if (device->vs_clipping || !use_vs(state) || !state->render_states[WINED3D_RS_CLIPPING]
+ || !state->render_states[WINED3D_RS_CLIPPLANEENABLE])
{
/* No need to emulate clipplanes if GL supports native vertex shader clipping or if
* the fixed function vertex pipeline is used(which always supports clipplanes), or
@@ -3380,6 +3380,6 @@ void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect)
SetRect(rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
- if (state->render_states[WINED3DRS_SCISSORTESTENABLE])
+ if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
IntersectRect(rect, rect, &state->scissor_rect);
}
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index c8c7070..8206026 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2475,7 +2475,7 @@ const char *debug_d3dusagequery(DWORD usagequery) DECLSPEC_HIDDEN;
const char *debug_d3ddeclmethod(WINED3DDECLMETHOD method) DECLSPEC_HIDDEN;
const char *debug_d3ddeclusage(BYTE usage) DECLSPEC_HIDDEN;
const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type) DECLSPEC_HIDDEN;
-const char *debug_d3drenderstate(WINED3DRENDERSTATETYPE state) DECLSPEC_HIDDEN;
+const char *debug_d3drenderstate(enum wined3d_render_state state) DECLSPEC_HIDDEN;
const char *debug_d3dsamplerstate(DWORD state) DECLSPEC_HIDDEN;
const char *debug_d3dstate(DWORD state) DECLSPEC_HIDDEN;
const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) DECLSPEC_HIDDEN;
diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h
index ecb63a0..0bcbe08 100644
--- a/include/wine/wined3d.h
+++ b/include/wine/wined3d.h
@@ -252,137 +252,136 @@ enum wined3d_format_id
WINED3DFMT_FORCE_DWORD = 0xffffffff
};
-typedef enum _WINED3DRENDERSTATETYPE
-{
- WINED3DRS_ANTIALIAS = 2, /* d3d7 */
- WINED3DRS_TEXTUREPERSPECTIVE = 4, /* d3d7 */
- WINED3DRS_WRAPU = 5, /* d3d7 */
- WINED3DRS_WRAPV = 6, /* d3d7 */
- WINED3DRS_ZENABLE = 7,
- WINED3DRS_FILLMODE = 8,
- WINED3DRS_SHADEMODE = 9,
- WINED3DRS_LINEPATTERN = 10, /* d3d7, d3d8 */
- WINED3DRS_MONOENABLE = 11, /* d3d7 */
- WINED3DRS_ROP2 = 12, /* d3d7 */
- WINED3DRS_PLANEMASK = 13, /* d3d7 */
- WINED3DRS_ZWRITEENABLE = 14,
- WINED3DRS_ALPHATESTENABLE = 15,
- WINED3DRS_LASTPIXEL = 16,
- WINED3DRS_SRCBLEND = 19,
- WINED3DRS_DESTBLEND = 20,
- WINED3DRS_CULLMODE = 22,
- WINED3DRS_ZFUNC = 23,
- WINED3DRS_ALPHAREF = 24,
- WINED3DRS_ALPHAFUNC = 25,
- WINED3DRS_DITHERENABLE = 26,
- WINED3DRS_ALPHABLENDENABLE = 27,
- WINED3DRS_FOGENABLE = 28,
- WINED3DRS_SPECULARENABLE = 29,
- WINED3DRS_ZVISIBLE = 30, /* d3d7, d3d8 */
- WINED3DRS_SUBPIXEL = 31, /* d3d7 */
- WINED3DRS_SUBPIXELX = 32, /* d3d7 */
- WINED3DRS_STIPPLEDALPHA = 33, /* d3d7 */
- WINED3DRS_FOGCOLOR = 34,
- WINED3DRS_FOGTABLEMODE = 35,
- WINED3DRS_FOGSTART = 36,
- WINED3DRS_FOGEND = 37,
- WINED3DRS_FOGDENSITY = 38,
- WINED3DRS_STIPPLEENABLE = 39, /* d3d7 */
- WINED3DRS_EDGEANTIALIAS = 40, /* d3d7, d3d8 */
- WINED3DRS_COLORKEYENABLE = 41, /* d3d7 */
- WINED3DRS_MIPMAPLODBIAS = 46, /* d3d7 */
- WINED3DRS_RANGEFOGENABLE = 48,
- WINED3DRS_ANISOTROPY = 49, /* d3d7 */
- WINED3DRS_FLUSHBATCH = 50, /* d3d7 */
- WINED3DRS_TRANSLUCENTSORTINDEPENDENT = 51, /* d3d7 */
- WINED3DRS_STENCILENABLE = 52,
- WINED3DRS_STENCILFAIL = 53,
- WINED3DRS_STENCILZFAIL = 54,
- WINED3DRS_STENCILPASS = 55,
- WINED3DRS_STENCILFUNC = 56,
- WINED3DRS_STENCILREF = 57,
- WINED3DRS_STENCILMASK = 58,
- WINED3DRS_STENCILWRITEMASK = 59,
- WINED3DRS_TEXTUREFACTOR = 60,
- WINED3DRS_WRAP0 = 128,
- WINED3DRS_WRAP1 = 129,
- WINED3DRS_WRAP2 = 130,
- WINED3DRS_WRAP3 = 131,
- WINED3DRS_WRAP4 = 132,
- WINED3DRS_WRAP5 = 133,
- WINED3DRS_WRAP6 = 134,
- WINED3DRS_WRAP7 = 135,
- WINED3DRS_CLIPPING = 136,
- WINED3DRS_LIGHTING = 137,
- WINED3DRS_EXTENTS = 138, /* d3d7 */
- WINED3DRS_AMBIENT = 139,
- WINED3DRS_FOGVERTEXMODE = 140,
- WINED3DRS_COLORVERTEX = 141,
- WINED3DRS_LOCALVIEWER = 142,
- WINED3DRS_NORMALIZENORMALS = 143,
- WINED3DRS_COLORKEYBLENDENABLE = 144, /* d3d7 */
- WINED3DRS_DIFFUSEMATERIALSOURCE = 145,
- WINED3DRS_SPECULARMATERIALSOURCE = 146,
- WINED3DRS_AMBIENTMATERIALSOURCE = 147,
- WINED3DRS_EMISSIVEMATERIALSOURCE = 148,
- WINED3DRS_VERTEXBLEND = 151,
- WINED3DRS_CLIPPLANEENABLE = 152,
- WINED3DRS_SOFTWAREVERTEXPROCESSING = 153, /* d3d8 */
- WINED3DRS_POINTSIZE = 154,
- WINED3DRS_POINTSIZE_MIN = 155,
- WINED3DRS_POINTSPRITEENABLE = 156,
- WINED3DRS_POINTSCALEENABLE = 157,
- WINED3DRS_POINTSCALE_A = 158,
- WINED3DRS_POINTSCALE_B = 159,
- WINED3DRS_POINTSCALE_C = 160,
- WINED3DRS_MULTISAMPLEANTIALIAS = 161,
- WINED3DRS_MULTISAMPLEMASK = 162,
- WINED3DRS_PATCHEDGESTYLE = 163,
- WINED3DRS_PATCHSEGMENTS = 164, /* d3d8 */
- WINED3DRS_DEBUGMONITORTOKEN = 165,
- WINED3DRS_POINTSIZE_MAX = 166,
- WINED3DRS_INDEXEDVERTEXBLENDENABLE = 167,
- WINED3DRS_COLORWRITEENABLE = 168,
- WINED3DRS_TWEENFACTOR = 170,
- WINED3DRS_BLENDOP = 171,
- WINED3DRS_POSITIONDEGREE = 172,
- WINED3DRS_NORMALDEGREE = 173,
- WINED3DRS_SCISSORTESTENABLE = 174,
- WINED3DRS_SLOPESCALEDEPTHBIAS = 175,
- WINED3DRS_ANTIALIASEDLINEENABLE = 176,
- WINED3DRS_MINTESSELLATIONLEVEL = 178,
- WINED3DRS_MAXTESSELLATIONLEVEL = 179,
- WINED3DRS_ADAPTIVETESS_X = 180,
- WINED3DRS_ADAPTIVETESS_Y = 181,
- WINED3DRS_ADAPTIVETESS_Z = 182,
- WINED3DRS_ADAPTIVETESS_W = 183,
- WINED3DRS_ENABLEADAPTIVETESSELLATION = 184,
- WINED3DRS_TWOSIDEDSTENCILMODE = 185,
- WINED3DRS_CCW_STENCILFAIL = 186,
- WINED3DRS_CCW_STENCILZFAIL = 187,
- WINED3DRS_CCW_STENCILPASS = 188,
- WINED3DRS_CCW_STENCILFUNC = 189,
- WINED3DRS_COLORWRITEENABLE1 = 190,
- WINED3DRS_COLORWRITEENABLE2 = 191,
- WINED3DRS_COLORWRITEENABLE3 = 192,
- WINED3DRS_BLENDFACTOR = 193,
- WINED3DRS_SRGBWRITEENABLE = 194,
- WINED3DRS_DEPTHBIAS = 195,
- WINED3DRS_WRAP8 = 198,
- WINED3DRS_WRAP9 = 199,
- WINED3DRS_WRAP10 = 200,
- WINED3DRS_WRAP11 = 201,
- WINED3DRS_WRAP12 = 202,
- WINED3DRS_WRAP13 = 203,
- WINED3DRS_WRAP14 = 204,
- WINED3DRS_WRAP15 = 205,
- WINED3DRS_SEPARATEALPHABLENDENABLE = 206,
- WINED3DRS_SRCBLENDALPHA = 207,
- WINED3DRS_DESTBLENDALPHA = 208,
- WINED3DRS_BLENDOPALPHA = 209,
- WINED3DRS_FORCE_DWORD = 0x7fffffff
-} WINED3DRENDERSTATETYPE;
-#define WINEHIGHEST_RENDER_STATE WINED3DRS_BLENDOPALPHA
+enum wined3d_render_state
+{
+ WINED3D_RS_ANTIALIAS = 2, /* d3d7 */
+ WINED3D_RS_TEXTUREPERSPECTIVE = 4, /* d3d7 */
+ WINED3D_RS_WRAPU = 5, /* d3d7 */
+ WINED3D_RS_WRAPV = 6, /* d3d7 */
+ WINED3D_RS_ZENABLE = 7,
+ WINED3D_RS_FILLMODE = 8,
+ WINED3D_RS_SHADEMODE = 9,
+ WINED3D_RS_LINEPATTERN = 10, /* d3d7, d3d8 */
+ WINED3D_RS_MONOENABLE = 11, /* d3d7 */
+ WINED3D_RS_ROP2 = 12, /* d3d7 */
+ WINED3D_RS_PLANEMASK = 13, /* d3d7 */
+ WINED3D_RS_ZWRITEENABLE = 14,
+ WINED3D_RS_ALPHATESTENABLE = 15,
+ WINED3D_RS_LASTPIXEL = 16,
+ WINED3D_RS_SRCBLEND = 19,
+ WINED3D_RS_DESTBLEND = 20,
+ WINED3D_RS_CULLMODE = 22,
+ WINED3D_RS_ZFUNC = 23,
+ WINED3D_RS_ALPHAREF = 24,
+ WINED3D_RS_ALPHAFUNC = 25,
+ WINED3D_RS_DITHERENABLE = 26,
+ WINED3D_RS_ALPHABLENDENABLE = 27,
+ WINED3D_RS_FOGENABLE = 28,
+ WINED3D_RS_SPECULARENABLE = 29,
+ WINED3D_RS_ZVISIBLE = 30, /* d3d7, d3d8 */
+ WINED3D_RS_SUBPIXEL = 31, /* d3d7 */
+ WINED3D_RS_SUBPIXELX = 32, /* d3d7 */
+ WINED3D_RS_STIPPLEDALPHA = 33, /* d3d7 */
+ WINED3D_RS_FOGCOLOR = 34,
+ WINED3D_RS_FOGTABLEMODE = 35,
+ WINED3D_RS_FOGSTART = 36,
+ WINED3D_RS_FOGEND = 37,
+ WINED3D_RS_FOGDENSITY = 38,
+ WINED3D_RS_STIPPLEENABLE = 39, /* d3d7 */
+ WINED3D_RS_EDGEANTIALIAS = 40, /* d3d7, d3d8 */
+ WINED3D_RS_COLORKEYENABLE = 41, /* d3d7 */
+ WINED3D_RS_MIPMAPLODBIAS = 46, /* d3d7 */
+ WINED3D_RS_RANGEFOGENABLE = 48,
+ WINED3D_RS_ANISOTROPY = 49, /* d3d7 */
+ WINED3D_RS_FLUSHBATCH = 50, /* d3d7 */
+ WINED3D_RS_TRANSLUCENTSORTINDEPENDENT = 51, /* d3d7 */
+ WINED3D_RS_STENCILENABLE = 52,
+ WINED3D_RS_STENCILFAIL = 53,
+ WINED3D_RS_STENCILZFAIL = 54,
+ WINED3D_RS_STENCILPASS = 55,
+ WINED3D_RS_STENCILFUNC = 56,
+ WINED3D_RS_STENCILREF = 57,
+ WINED3D_RS_STENCILMASK = 58,
+ WINED3D_RS_STENCILWRITEMASK = 59,
+ WINED3D_RS_TEXTUREFACTOR = 60,
+ WINED3D_RS_WRAP0 = 128,
+ WINED3D_RS_WRAP1 = 129,
+ WINED3D_RS_WRAP2 = 130,
+ WINED3D_RS_WRAP3 = 131,
+ WINED3D_RS_WRAP4 = 132,
+ WINED3D_RS_WRAP5 = 133,
+ WINED3D_RS_WRAP6 = 134,
+ WINED3D_RS_WRAP7 = 135,
+ WINED3D_RS_CLIPPING = 136,
+ WINED3D_RS_LIGHTING = 137,
+ WINED3D_RS_EXTENTS = 138, /* d3d7 */
+ WINED3D_RS_AMBIENT = 139,
+ WINED3D_RS_FOGVERTEXMODE = 140,
+ WINED3D_RS_COLORVERTEX = 141,
+ WINED3D_RS_LOCALVIEWER = 142,
+ WINED3D_RS_NORMALIZENORMALS = 143,
+ WINED3D_RS_COLORKEYBLENDENABLE = 144, /* d3d7 */
+ WINED3D_RS_DIFFUSEMATERIALSOURCE = 145,
+ WINED3D_RS_SPECULARMATERIALSOURCE = 146,
+ WINED3D_RS_AMBIENTMATERIALSOURCE = 147,
+ WINED3D_RS_EMISSIVEMATERIALSOURCE = 148,
+ WINED3D_RS_VERTEXBLEND = 151,
+ WINED3D_RS_CLIPPLANEENABLE = 152,
+ WINED3D_RS_SOFTWAREVERTEXPROCESSING = 153, /* d3d8 */
+ WINED3D_RS_POINTSIZE = 154,
+ WINED3D_RS_POINTSIZE_MIN = 155,
+ WINED3D_RS_POINTSPRITEENABLE = 156,
+ WINED3D_RS_POINTSCALEENABLE = 157,
+ WINED3D_RS_POINTSCALE_A = 158,
+ WINED3D_RS_POINTSCALE_B = 159,
+ WINED3D_RS_POINTSCALE_C = 160,
+ WINED3D_RS_MULTISAMPLEANTIALIAS = 161,
+ WINED3D_RS_MULTISAMPLEMASK = 162,
+ WINED3D_RS_PATCHEDGESTYLE = 163,
+ WINED3D_RS_PATCHSEGMENTS = 164, /* d3d8 */
+ WINED3D_RS_DEBUGMONITORTOKEN = 165,
+ WINED3D_RS_POINTSIZE_MAX = 166,
+ WINED3D_RS_INDEXEDVERTEXBLENDENABLE = 167,
+ WINED3D_RS_COLORWRITEENABLE = 168,
+ WINED3D_RS_TWEENFACTOR = 170,
+ WINED3D_RS_BLENDOP = 171,
+ WINED3D_RS_POSITIONDEGREE = 172,
+ WINED3D_RS_NORMALDEGREE = 173,
+ WINED3D_RS_SCISSORTESTENABLE = 174,
+ WINED3D_RS_SLOPESCALEDEPTHBIAS = 175,
+ WINED3D_RS_ANTIALIASEDLINEENABLE = 176,
+ WINED3D_RS_MINTESSELLATIONLEVEL = 178,
+ WINED3D_RS_MAXTESSELLATIONLEVEL = 179,
+ WINED3D_RS_ADAPTIVETESS_X = 180,
+ WINED3D_RS_ADAPTIVETESS_Y = 181,
+ WINED3D_RS_ADAPTIVETESS_Z = 182,
+ WINED3D_RS_ADAPTIVETESS_W = 183,
+ WINED3D_RS_ENABLEADAPTIVETESSELLATION = 184,
+ WINED3D_RS_TWOSIDEDSTENCILMODE = 185,
+ WINED3D_RS_CCW_STENCILFAIL = 186,
+ WINED3D_RS_CCW_STENCILZFAIL = 187,
+ WINED3D_RS_CCW_STENCILPASS = 188,
+ WINED3D_RS_CCW_STENCILFUNC = 189,
+ WINED3D_RS_COLORWRITEENABLE1 = 190,
+ WINED3D_RS_COLORWRITEENABLE2 = 191,
+ WINED3D_RS_COLORWRITEENABLE3 = 192,
+ WINED3D_RS_BLENDFACTOR = 193,
+ WINED3D_RS_SRGBWRITEENABLE = 194,
+ WINED3D_RS_DEPTHBIAS = 195,
+ WINED3D_RS_WRAP8 = 198,
+ WINED3D_RS_WRAP9 = 199,
+ WINED3D_RS_WRAP10 = 200,
+ WINED3D_RS_WRAP11 = 201,
+ WINED3D_RS_WRAP12 = 202,
+ WINED3D_RS_WRAP13 = 203,
+ WINED3D_RS_WRAP14 = 204,
+ WINED3D_RS_WRAP15 = 205,
+ WINED3D_RS_SEPARATEALPHABLENDENABLE = 206,
+ WINED3D_RS_SRCBLENDALPHA = 207,
+ WINED3D_RS_DESTBLENDALPHA = 208,
+ WINED3D_RS_BLENDOPALPHA = 209,
+};
+#define WINEHIGHEST_RENDER_STATE WINED3D_RS_BLENDOPALPHA
enum wined3d_blend
{
@@ -2144,7 +2143,7 @@ HRESULT __cdecl wined3d_device_get_ps_consts_i(const struct wined3d_device *devi
HRESULT __cdecl wined3d_device_get_raster_status(const struct wined3d_device *device,
UINT swapchain_idx, struct wined3d_raster_status *raster_status);
HRESULT __cdecl wined3d_device_get_render_state(const struct wined3d_device *device,
- WINED3DRENDERSTATETYPE state, DWORD *value);
+ enum wined3d_render_state state, DWORD *value);
HRESULT __cdecl wined3d_device_get_render_target(const struct wined3d_device *device,
UINT render_target_idx, struct wined3d_surface **render_target);
HRESULT __cdecl wined3d_device_get_sampler_state(const struct wined3d_device *device,
@@ -2223,7 +2222,7 @@ HRESULT __cdecl wined3d_device_set_ps_consts_f(struct wined3d_device *device,
HRESULT __cdecl wined3d_device_set_ps_consts_i(struct wined3d_device *device,
UINT start_register, const int *constants, UINT vector4i_count);
HRESULT __cdecl wined3d_device_set_render_state(struct wined3d_device *device,
- WINED3DRENDERSTATETYPE state, DWORD value);
+ enum wined3d_render_state state, DWORD value);
HRESULT __cdecl wined3d_device_set_render_target(struct wined3d_device *device,
UINT render_target_idx, struct wined3d_surface *render_target, BOOL set_viewport);
HRESULT __cdecl wined3d_device_set_sampler_state(struct wined3d_device *device,
--
1.7.3.4
More information about the wine-patches
mailing list