From 3082c1a9de14e9c21c4f93331b6d595bbca00e34 Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Mon, 19 Dec 2011 21:00:09 +0100 Subject: [PATCH] wined3d: Get rid of the WINED3DRENDERSTATETYPE typedef. --- 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 923046ddc87..3fcc6b32903 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 4dc0125d164..ed0d567df85 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 097046d5888..58b84d683bf 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 30398167caa..1991a8d9509 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 8b152d321b3..00998572d65 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 d550a04c3a4..16dc79d162f 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 c567e01ff40..0a1ebac6def 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 d6f7a98f473..00670e594a2 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 716119e47a0..f9116a04ad8 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 96c7ed8c357..7cb47ee1198 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 482375009e0..240ba8b67bd 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 7820048bf8e..872736926f3 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 e29bbdce992..adea6bb651a 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 bd45ae3e000..64dd24d119f 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 398861909dc..c64c5ef9344 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 b4f4ff87557..206370186c2 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 c8c7070d94c..82060268443 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 ecb63a02aa7..0bcbe082705 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, -- 2.11.4.GIT