From a7ded9a67d55116350b5ff3eb3827e8d7e9b93b2 Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Tue, 28 Sep 2010 12:00:24 +0200 Subject: [PATCH] wined3d: Pass a wined3d_state structure to use_ps(). --- dlls/wined3d/arb_program_shader.c | 62 ++++++++++++++++++++---------------- dlls/wined3d/ati_fragment_shader.c | 2 +- dlls/wined3d/device.c | 7 ++-- dlls/wined3d/drawprim.c | 25 ++++++++------- dlls/wined3d/nvidia_texture_shader.c | 9 +++--- dlls/wined3d/state.c | 54 +++++++++++++++++-------------- dlls/wined3d/wined3d_private.h | 4 +-- 7 files changed, 90 insertions(+), 73 deletions(-) diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c index d2d5bdb01a5..04be3315db5 100644 --- a/dlls/wined3d/arb_program_shader.c +++ b/dlls/wined3d/arb_program_shader.c @@ -4457,7 +4457,7 @@ static inline void find_arb_vs_compile_args(IWineD3DVertexShaderImpl *shader, IW find_vs_compile_args(shader, stateblock, &args->super); args->clip.boolclip_compare = 0; - if(use_ps(stateblock)) + if (use_ps(state)) { IWineD3DPixelShaderImpl *ps = state->pixel_shader; struct arb_pshader_private *shader_priv = ps->baseShader.backend_data; @@ -5533,45 +5533,50 @@ static void arbfp_get_caps(const struct wined3d_gl_info *gl_info, struct fragmen caps->MaxSimultaneousTextures = min(gl_info->limits.fragment_samplers, 8); } -static void state_texfactor_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void state_texfactor_arbfp(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; float col[4]; /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite * application provided constants */ - if(device->shader_backend == &arb_program_shader_backend) { - if (use_ps(stateblock)) return; + if (device->shader_backend == &arb_program_shader_backend) + { + if (use_ps(state)) return; context->pshader_const_dirty[ARB_FFP_CONST_TFACTOR] = 1; device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_TFACTOR + 1); } - D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_TEXTUREFACTOR], col); + D3DCOLORTOGLFLOAT4(state->render_states[WINED3DRS_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)"); } -static void state_arb_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void state_arb_specularenable(DWORD state_id, + IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; float col[4]; /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite * application provided constants */ - if(device->shader_backend == &arb_program_shader_backend) { - if (use_ps(stateblock)) return; + if (device->shader_backend == &arb_program_shader_backend) + { + if (use_ps(state)) return; context->pshader_const_dirty[ARB_FFP_CONST_SPECULAR_ENABLE] = 1; device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_SPECULAR_ENABLE + 1); } - if (stateblock->state.render_states[WINED3DRS_SPECULARENABLE]) + if (state->render_states[WINED3DRS_SPECULARENABLE]) { /* The specular color has no alpha */ col[0] = 1.0f; col[1] = 1.0f; @@ -5584,16 +5589,17 @@ static void state_arb_specularenable(DWORD state, IWineD3DStateBlockImpl *stateb checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_SPECULAR_ENABLE, col)"); } -static void set_bumpmat_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void set_bumpmat_arbfp(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { - DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); + DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; float mat[2][2]; - if (use_ps(stateblock)) + if (use_ps(state)) { - IWineD3DPixelShaderImpl *ps = stateblock->state.pixel_shader; + IWineD3DPixelShaderImpl *ps = state->pixel_shader; if (stage && (ps->baseShader.reg_maps.bumpmat & (1 << stage))) { /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled @@ -5612,25 +5618,26 @@ static void set_bumpmat_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, s device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_BUMPMAT(stage) + 1); } - mat[0][0] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT00]); - mat[0][1] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT01]); - mat[1][0] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT10]); - mat[1][1] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT11]); + mat[0][0] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVMAT00]); + mat[0][1] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVMAT01]); + mat[1][0] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVMAT10]); + mat[1][1] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVMAT11]); GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0])); checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0])"); } -static void tex_bumpenvlum_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void tex_bumpenvlum_arbfp(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { - DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); + DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; float param[4]; - if (use_ps(stateblock)) + if (use_ps(state)) { - IWineD3DPixelShaderImpl *ps = stateblock->state.pixel_shader; + IWineD3DPixelShaderImpl *ps = state->pixel_shader; if (stage && (ps->baseShader.reg_maps.luminanceparams & (1 << stage))) { /* The pixel shader has to know the luminance offset. Do a constants update if it @@ -5649,8 +5656,8 @@ static void tex_bumpenvlum_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_LUMINANCE(stage) + 1); } - param[0] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVLSCALE]); - param[1] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVLOFFSET]); + param[0] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVLSCALE]); + param[1] = *((float *)&state->texture_states[stage][WINED3DTSS_BUMPENVLOFFSET]); param[2] = 0.0f; param[3] = 0.0f; @@ -6149,18 +6156,19 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, IWi return ret; } -static void fragment_prog_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void fragment_prog_arbfp(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; struct shader_arb_priv *priv = device->fragment_priv; - BOOL use_vshader = use_vs(&stateblock->state); - BOOL use_pshader = use_ps(stateblock); + BOOL use_vshader = use_vs(state); + BOOL use_pshader = use_ps(state); struct ffp_frag_settings settings; const struct arbfp_ffp_desc *desc; unsigned int i; - TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context); + TRACE("state_id %#x, stateblock %p, context %p\n", state_id, stateblock, context); if(isStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE))) { if(!use_pshader && device->shader_backend == &arb_program_shader_backend && context->last_was_pshader) { diff --git a/dlls/wined3d/ati_fragment_shader.c b/dlls/wined3d/ati_fragment_shader.c index 5cecb7159d0..35838e18d73 100644 --- a/dlls/wined3d/ati_fragment_shader.c +++ b/dlls/wined3d/ati_fragment_shader.c @@ -893,7 +893,7 @@ static void atifs_apply_pixelshader(DWORD state_id, IWineD3DStateBlockImpl *stat IWineD3DDeviceImpl *device = stateblock->device; BOOL use_vshader = use_vs(state); - context->last_was_pshader = use_ps(stateblock); + context->last_was_pshader = use_ps(state); /* The ATIFS code does not support pixel shaders currently, but we have to provide a state handler * to call shader_select to select a vertex shader if one is applied because the vertex shader state * may defer calling the shader backend if the pshader state is dirty. diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 955f440c1e3..cf50ce8fad8 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -478,7 +478,7 @@ void device_preload_textures(IWineD3DDeviceImpl *device) } } - if (use_ps(stateblock)) + if (use_ps(state)) { for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) { @@ -3586,8 +3586,9 @@ static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps, const struct void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This) { const struct wined3d_gl_info *gl_info = &This->adapter->gl_info; - BOOL vs = use_vs(&This->stateBlock->state); - BOOL ps = use_ps(This->stateBlock); + const struct wined3d_state *state = &This->stateBlock->state; + BOOL vs = use_vs(state); + BOOL ps = use_ps(state); /* * Rules are: * -> Pixel shaders need a 1:1 map. In theory the shader input could be mapped too, but diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c index a98e9ed892f..2e032c34eae 100644 --- a/dlls/wined3d/drawprim.c +++ b/dlls/wined3d/drawprim.c @@ -69,9 +69,10 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context const DWORD *pIdxBufL = NULL; UINT vx_index; IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; - const struct wined3d_stream_state *streams = This->stateBlock->state.streams; - LONG SkipnStrides = startIdx + This->stateBlock->state.load_base_vertex_index; - BOOL pixelShader = use_ps(This->stateBlock); + const struct wined3d_state *state = &This->stateBlock->state; + const struct wined3d_stream_state *streams = state->streams; + LONG SkipnStrides = startIdx + state->load_base_vertex_index; + BOOL pixelShader = use_ps(state); BOOL specular_fog = FALSE; const BYTE *texCoords[WINED3DDP_MAXTEXCOORD]; const BYTE *diffuse = NULL, *specular = NULL, *normal = NULL, *position = NULL; @@ -91,7 +92,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context * supported or other reason), or with user pointer drawing idxData * will be non-NULL. */ if (!idxData) - idxData = buffer_get_sysmem(This->stateBlock->state.index_buffer, gl_info); + idxData = buffer_get_sysmem(state->index_buffer, gl_info); if (idxSize == 2) pIdxBufS = idxData; else pIdxBufL = idxData; @@ -139,10 +140,10 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context specular = element->data + streams[element->stream_idx].offset; /* special case where the fog density is stored in the specular alpha channel */ - if (This->stateBlock->state.render_states[WINED3DRS_FOGENABLE] - && (This->stateBlock->state.render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE + if (state->render_states[WINED3DRS_FOGENABLE] + && (state->render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || si->elements[WINED3D_FFP_POSITION].format->id == WINED3DFMT_R32G32B32A32_FLOAT) - && This->stateBlock->state.render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) + && state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) { if (gl_info->supported[EXT_FOG_COORD]) { @@ -169,7 +170,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context for (textureNo = 0; textureNo < texture_stages; ++textureNo) { - int coordIdx = This->stateBlock->state.texture_states[textureNo][WINED3DTSS_TEXCOORDINDEX]; + int coordIdx = state->texture_states[textureNo][WINED3DTSS_TEXCOORDINDEX]; DWORD texture_idx = This->texUnitMap[textureNo]; if (!gl_info->supported[ARB_MULTITEXTURE] && textureNo > 0) @@ -178,7 +179,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context continue; } - if (!pixelShader && !This->stateBlock->state.textures[textureNo]) continue; + if (!pixelShader && !state->textures[textureNo]) continue; if (texture_idx == WINED3D_UNMAPPED_STAGE) continue; @@ -225,9 +226,9 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context { /* Indexed so work out the number of strides to skip */ if (idxSize == 2) - SkipnStrides = pIdxBufS[startIdx + vx_index] + This->stateBlock->state.load_base_vertex_index; + SkipnStrides = pIdxBufS[startIdx + vx_index] + state->load_base_vertex_index; else - SkipnStrides = pIdxBufL[startIdx + vx_index] + This->stateBlock->state.load_base_vertex_index; + SkipnStrides = pIdxBufL[startIdx + vx_index] + state->load_base_vertex_index; } tmp_tex_mask = tex_mask; @@ -239,7 +240,7 @@ static void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context if (!(tmp_tex_mask & 1)) continue; - coord_idx = This->stateBlock->state.texture_states[texture][WINED3DTSS_TEXCOORDINDEX]; + coord_idx = state->texture_states[texture][WINED3DTSS_TEXCOORDINDEX]; ptr = texCoords[coord_idx] + (SkipnStrides * si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].stride); texture_idx = This->texUnitMap[texture]; diff --git a/dlls/wined3d/nvidia_texture_shader.c b/dlls/wined3d/nvidia_texture_shader.c index 0f1bbb1ab89..5fd8fea4d80 100644 --- a/dlls/wined3d/nvidia_texture_shader.c +++ b/dlls/wined3d/nvidia_texture_shader.c @@ -456,17 +456,18 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d } -static void nvrc_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void nvrc_colorop(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { - DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); + DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); BOOL tex_used = stateblock->device->fixed_function_usage_map & (1 << stage); DWORD mapped_stage = stateblock->device->texUnitMap[stage]; const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; - TRACE("Setting color op for stage %d\n", stage); + TRACE("Setting color op for stage %u.\n", stage); /* Using a pixel shader? Don't care for anything here, the shader applying does it */ - if (use_ps(stateblock)) return; + if (use_ps(state)) return; if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage); diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index 6c306543387..6a415eee807 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -1681,17 +1681,18 @@ static void state_pointsprite_w(DWORD state, IWineD3DStateBlockImpl *stateblock, } } -static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void state_pointsprite(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; - if (stateblock->state.render_states[WINED3DRS_POINTSPRITEENABLE]) + if (state->render_states[WINED3DRS_POINTSPRITEENABLE]) { static BOOL warned; if (gl_info->limits.point_sprite_units < gl_info->limits.textures && !warned) { - if (use_ps(stateblock) || stateblock->state.lowest_disabled_stage > gl_info->limits.point_sprite_units) + if (use_ps(state) || state->lowest_disabled_stage > gl_info->limits.point_sprite_units) { FIXME("The app uses point sprite texture coordinates on more units than supported by the driver\n"); warned = TRUE; @@ -3099,17 +3100,18 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined } -static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void tex_colorop(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { - DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); + DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); BOOL tex_used = stateblock->device->fixed_function_usage_map & (1 << stage); DWORD mapped_stage = stateblock->device->texUnitMap[stage]; const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; TRACE("Setting color op for stage %d\n", stage); /* Using a pixel shader? Don't care for anything here, the shader applying does it */ - if (use_ps(stateblock)) return; + if (use_ps(state)) return; if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage); @@ -3124,7 +3126,7 @@ static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct checkGLcall("glActiveTextureARB"); } - if (stage >= stateblock->state.lowest_disabled_stage) + if (stage >= state->lowest_disabled_stage) { TRACE("Stage disabled\n"); if (mapped_stage != WINED3D_UNMAPPED_STAGE) @@ -3152,13 +3154,13 @@ static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct /* The sampler will also activate the correct texture dimensions, so no * need to do it here if the sampler for this stage is dirty. */ if (!isStateDirty(context, STATE_SAMPLER(stage)) && tex_used) - texture_activate_dimensions(stateblock->state.textures[stage], gl_info); + texture_activate_dimensions(state->textures[stage], gl_info); - set_tex_op(gl_info, &stateblock->state, FALSE, stage, - stateblock->state.texture_states[stage][WINED3DTSS_COLOROP], - stateblock->state.texture_states[stage][WINED3DTSS_COLORARG1], - stateblock->state.texture_states[stage][WINED3DTSS_COLORARG2], - stateblock->state.texture_states[stage][WINED3DTSS_COLORARG0]); + set_tex_op(gl_info, state, FALSE, stage, + state->texture_states[stage][WINED3DTSS_COLOROP], + state->texture_states[stage][WINED3DTSS_COLORARG1], + state->texture_states[stage][WINED3DTSS_COLORARG2], + state->texture_states[stage][WINED3DTSS_COLORARG0]); } void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) @@ -3302,7 +3304,8 @@ static void transform_texture(DWORD state_id, IWineD3DStateBlockImpl *stateblock } /* NP2 texcoord fixup is implemented for pixelshaders so only enable the fixed-function-pipeline fixup via pow2Matrix when no PS is used. */ - if (!use_ps(stateblock)) { + if (!use_ps(state)) + { TRACE("Non power two matrix multiply fixup\n"); glMultMatrixf(state->textures[texUnit]->baseTexture.pow2Matrix); } @@ -3547,8 +3550,9 @@ static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock, stru } } -static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void shaderconstant(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them @@ -3559,7 +3563,7 @@ static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, stru return; } - device->shader_backend->shader_load_constants(context, use_ps(stateblock), use_vs(&stateblock->state)); + device->shader_backend->shader_load_constants(context, use_ps(state), use_vs(state)); } static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) @@ -3655,7 +3659,7 @@ static void sampler(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct w checkGLcall("glTexEnvi(GL_TEXTURE_LOD_BIAS_EXT, ...)"); } - if (!use_ps(stateblock) && sampler < state->lowest_disabled_stage) + if (!use_ps(state) && sampler < state->lowest_disabled_stage) { if (state->render_states[WINED3DRS_COLORKEYENABLE] && !sampler) { @@ -3671,7 +3675,7 @@ static void sampler(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct w { IWineD3DDeviceImpl *d3ddevice = stateblock->device; d3ddevice->shader_backend->shader_load_np2fixup_constants( - (IWineD3DDevice*)d3ddevice, use_ps(stateblock), use_vs(state)); + (IWineD3DDevice*)d3ddevice, use_ps(state), use_vs(state)); } } else if (mapped_stage < gl_info->limits.textures) @@ -3692,11 +3696,12 @@ static void sampler(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct w } } -void apply_pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +void apply_pixelshader(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { + const struct wined3d_state *state = &stateblock->state; IWineD3DDeviceImpl *device = stateblock->device; - BOOL use_vshader = use_vs(&stateblock->state); - BOOL use_pshader = use_ps(stateblock); + BOOL use_vshader = use_vs(state); + BOOL use_pshader = use_ps(state); unsigned int i; if (use_pshader) { @@ -4610,12 +4615,13 @@ static void streamsrc(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wi } } -static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) +static void vertexdeclaration(DWORD state_id, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_state *state = &stateblock->state; + BOOL useVertexShaderFunction = use_vs(state); + BOOL usePixelShaderFunction = use_ps(state); BOOL updateFog = FALSE; - BOOL useVertexShaderFunction = use_vs(&stateblock->state); - BOOL usePixelShaderFunction = use_ps(stateblock); IWineD3DDeviceImpl *device = stateblock->device; BOOL transformed; BOOL wasrhw = context->last_was_rhw; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index bb57127caa6..8adcc3501ef 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3026,9 +3026,9 @@ static inline BOOL use_vs(const struct wined3d_state *state) return state->vertex_shader && !state->vertex_declaration->position_transformed; } -static inline BOOL use_ps(IWineD3DStateBlockImpl *stateblock) +static inline BOOL use_ps(const struct wined3d_state *state) { - return !!stateblock->state.pixel_shader; + return !!state->pixel_shader; } /* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */ -- 2.11.4.GIT