Skip to content

W
wine-cw
Commit c228ffba authored by Henri Verbeet's avatar Henri Verbeet Committed by Alexandre Julliard
Browse files
Options

wined3d: Unify shader binding points.

parent b4e4831d
Hide whitespace changes
Inline Side-by-side
Showing with 84 additions and 133 deletions
dlls/wined3d/arb_program_shader.c
View file @ c228ffba
......@@ -657,7 +657,9 @@ static void shader_arb_load_constants_internal(struct shader_arb_priv *priv,
if (!from_shader_select)
{
const struct wined3d_shader *vshader = state->vertex_shader, *pshader = state->pixel_shader;
const struct wined3d_shader *vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
const struct wined3d_shader *pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
if (vshader
&& (vshader->reg_maps.boolean_constants
|| (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]
......@@ -691,7 +693,7 @@ static void shader_arb_load_constants_internal(struct shader_arb_priv *priv,
if (useVertexShader)
{
struct wined3d_shader *vshader = state->vertex_shader;
const struct wined3d_shader *vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
const struct arb_vs_compiled_shader *gl_shader = priv->compiled_vprog;
/* Load DirectX 9 float constants for vertex shader */
......@@ -702,7 +704,7 @@ static void shader_arb_load_constants_internal(struct shader_arb_priv *priv,
if (usePixelShader)
{
struct wined3d_shader *pshader = state->pixel_shader;
const struct wined3d_shader *pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
const struct arb_ps_compiled_shader *gl_shader = priv->compiled_fprog;
UINT rt_height = state->fb->render_targets[0]->resource.height;
......@@ -4586,7 +4588,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
args->clip.boolclip_compare = 0;
if (use_ps(state))
{
const struct wined3d_shader *ps = state->pixel_shader;
const struct wined3d_shader *ps = state->shader[WINED3D_SHADER_TYPE_PIXEL];
const struct arb_pshader_private *shader_priv = ps->backend_data;
args->ps_signature = shader_priv->input_signature_idx;
......@@ -4658,7 +4660,7 @@ static void shader_arb_select(void *shader_priv, struct wined3d_context *context
/* Deal with pixel shaders first so the vertex shader arg function has the input signature ready */
if (use_ps(state))
{
struct wined3d_shader *ps = state->pixel_shader;
struct wined3d_shader *ps = state->shader[WINED3D_SHADER_TYPE_PIXEL];
struct arb_ps_compile_args compile_args;
struct arb_ps_compiled_shader *compiled;
......@@ -4725,7 +4727,7 @@ static void shader_arb_select(void *shader_priv, struct wined3d_context *context
if (use_vs(state))
{
struct wined3d_shader *vs = state->vertex_shader;
struct wined3d_shader *vs = state->shader[WINED3D_SHADER_TYPE_VERTEX];
struct arb_vs_compile_args compile_args;
struct arb_vs_compiled_shader *compiled;
const struct wined3d_shader_signature_element *ps_input_sig;
......@@ -4739,7 +4741,7 @@ static void shader_arb_select(void *shader_priv, struct wined3d_context *context
if (compile_args.ps_signature == ~0U)
ps_input_sig = NULL;
else
ps_input_sig = state->pixel_shader->input_signature;
ps_input_sig = state->shader[WINED3D_SHADER_TYPE_PIXEL]->input_signature;
compiled = find_arb_vshader(vs, context->gl_info, context->stream_info.use_map,
&compile_args, ps_input_sig);
......
dlls/wined3d/context.c
View file @ c228ffba
......@@ -2291,7 +2291,7 @@ static DWORD find_draw_buffers_mask(const struct wined3d_context *context, const
{
const struct wined3d_state *state = &device->state;
struct wined3d_surface **rts = state->fb->render_targets;
struct wined3d_shader *ps = state->pixel_shader;
struct wined3d_shader *ps = state->shader[WINED3D_SHADER_TYPE_PIXEL];
DWORD rt_mask, rt_mask_bits;
unsigned int i;
......@@ -2468,7 +2468,7 @@ static void context_map_fixed_function_samplers(struct wined3d_context *context,
static void context_map_psamplers(struct wined3d_context *context, const struct wined3d_state *state)
{
const enum wined3d_sampler_texture_type *sampler_type =
state->pixel_shader->reg_maps.sampler_type;
state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.sampler_type;
unsigned int i;
const struct wined3d_d3d_info *d3d_info = context->d3d_info;
......@@ -2515,7 +2515,7 @@ static BOOL context_unit_free_for_vs(const struct wined3d_context *context,
static void context_map_vsamplers(struct wined3d_context *context, BOOL ps, const struct wined3d_state *state)
{
const enum wined3d_sampler_texture_type *vshader_sampler_type =
state->vertex_shader->reg_maps.sampler_type;
state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.sampler_type;
const enum wined3d_sampler_texture_type *pshader_sampler_type = NULL;
const struct wined3d_gl_info *gl_info = context->gl_info;
int start = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers) - 1;
......@@ -2525,7 +2525,7 @@ static void context_map_vsamplers(struct wined3d_context *context, BOOL ps, cons
{
/* Note that we only care if a sampler is sampled or not, not the sampler's specific type.
* Otherwise we'd need to call shader_update_samplers() here for 1.x pixelshaders. */
pshader_sampler_type = state->pixel_shader->reg_maps.sampler_type;
pshader_sampler_type = state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.sampler_type;
}
for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
......@@ -2627,17 +2627,14 @@ void context_stream_info_from_declaration(struct wined3d_context *context,
{
/* We need to deal with frequency data! */
struct wined3d_vertex_declaration *declaration = state->vertex_declaration;
BOOL use_vshader;
BOOL use_vshader = use_vs(state);
unsigned int i;
WORD map;
stream_info->use_map = 0;
stream_info->swizzle_map = 0;
stream_info->all_vbo = 1;
/* Check for transformed vertices, disable vertex shader if present. */
stream_info->position_transformed = declaration->position_transformed;
use_vshader = state->vertex_shader && !declaration->position_transformed;
/* Translate the declaration into strided data. */
for (i = 0; i < declaration->element_count; ++i)
......@@ -2686,7 +2683,7 @@ void context_stream_info_from_declaration(struct wined3d_context *context,
/* TODO: Assuming vertexdeclarations are usually used with the
* same or a similar shader, it might be worth it to store the
* last used output slot and try that one first. */
stride_used = vshader_get_input(state->vertex_shader,
stride_used = vshader_get_input(state->shader[WINED3D_SHADER_TYPE_VERTEX],
element->usage, element->usage_idx, &idx);
}
else
......@@ -2774,7 +2771,7 @@ static void context_update_stream_info(struct wined3d_context *context, const st
TRACE("============================= Vertex Declaration =============================\n");
context_stream_info_from_declaration(context, state, stream_info);
if (state->vertex_shader && !stream_info->position_transformed)
if (use_vs(state))
{
if (state->vertex_declaration->half_float_conv_needed && !stream_info->all_vbo)
{
......@@ -2826,7 +2823,7 @@ static void context_preload_textures(struct wined3d_context *context, const stru
{
for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
{
if (state->vertex_shader->reg_maps.sampler_type[i])
if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.sampler_type[i])
context_preload_texture(context, state, MAX_FRAGMENT_SAMPLERS + i);
}
}
......@@ -2835,7 +2832,7 @@ static void context_preload_textures(struct wined3d_context *context, const stru
{
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
{
if (state->pixel_shader->reg_maps.sampler_type[i])
if (state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.sampler_type[i])
context_preload_texture(context, state, i);
}
}
......
dlls/wined3d/cs.c
View file @ c228ffba
......@@ -38,9 +38,7 @@ enum wined3d_cs_op
WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
WINED3D_CS_OP_SET_INDEX_BUFFER,
WINED3D_CS_OP_SET_TEXTURE,
WINED3D_CS_OP_SET_VERTEX_SHADER,
WINED3D_CS_OP_SET_GEOMETRY_SHADER,
WINED3D_CS_OP_SET_PIXEL_SHADER,
WINED3D_CS_OP_SET_SHADER,
WINED3D_CS_OP_SET_RENDER_STATE,
WINED3D_CS_OP_SET_TEXTURE_STATE,
WINED3D_CS_OP_SET_SAMPLER_STATE,
......@@ -146,6 +144,7 @@ struct wined3d_cs_set_texture
struct wined3d_cs_set_shader
{
enum wined3d_cs_op opcode;
enum wined3d_shader_type type;
struct wined3d_shader *shader;
};
......@@ -563,58 +562,21 @@ void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined
cs->ops->submit(cs);
}
static void wined3d_cs_exec_set_vertex_shader(struct wined3d_cs *cs, const void *data)
static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
{
const struct wined3d_cs_set_shader *op = data;
cs->state.vertex_shader = op->shader;
device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX));
cs->state.shader[op->type] = op->shader;
device_invalidate_state(cs->device, STATE_SHADER(op->type));
}
void wined3d_cs_emit_set_vertex_shader(struct wined3d_cs *cs, struct wined3d_shader *shader)
void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
{
struct wined3d_cs_set_shader *op;
op = cs->ops->require_space(cs, sizeof(*op));
op->opcode = WINED3D_CS_OP_SET_VERTEX_SHADER;
op->shader = shader;
cs->ops->submit(cs);
}
static void wined3d_cs_exec_set_geometry_shader(struct wined3d_cs *cs, const void *data)
{
const struct wined3d_cs_set_shader *op = data;
cs->state.geometry_shader = op->shader;
device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY));
}
void wined3d_cs_emit_set_geometry_shader(struct wined3d_cs *cs, struct wined3d_shader *shader)
{
struct wined3d_cs_set_shader *op;
op = cs->ops->require_space(cs, sizeof(*op));
op->opcode = WINED3D_CS_OP_SET_GEOMETRY_SHADER;
op->shader = shader;
cs->ops->submit(cs);
}
static void wined3d_cs_exec_set_pixel_shader(struct wined3d_cs *cs, const void *data)
{
const struct wined3d_cs_set_shader *op = data;
cs->state.pixel_shader = op->shader;
device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
}
void wined3d_cs_emit_set_pixel_shader(struct wined3d_cs *cs, struct wined3d_shader *shader)
{
struct wined3d_cs_set_shader *op;
op = cs->ops->require_space(cs, sizeof(*op));
op->opcode = WINED3D_CS_OP_SET_PIXEL_SHADER;
op->opcode = WINED3D_CS_OP_SET_SHADER;
op->type = type;
op->shader = shader;
cs->ops->submit(cs);
......@@ -759,9 +721,7 @@ static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void
/* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq,
/* WINED3D_CS_OP_SET_INDEX_BUFFER */ wined3d_cs_exec_set_index_buffer,
/* WINED3D_CS_OP_SET_TEXTURE */ wined3d_cs_exec_set_texture,
/* WINED3D_CS_OP_SET_VERTEX_SHADER */ wined3d_cs_exec_set_vertex_shader,
/* WINED3D_CS_OP_SET_GEOMETRY_SHADER */ wined3d_cs_exec_set_geometry_shader,
/* WINED3D_CS_OP_SET_PIXEL_SHADER */ wined3d_cs_exec_set_pixel_shader,
/* WINED3D_CS_OP_SET_SHADER */ wined3d_cs_exec_set_shader,
/* WINED3D_CS_OP_SET_RENDER_STATE */ wined3d_cs_exec_set_render_state,
/* WINED3D_CS_OP_SET_TEXTURE_STATE */ wined3d_cs_exec_set_texture_state,
/* WINED3D_CS_OP_SET_SAMPLER_STATE */ wined3d_cs_exec_set_sampler_state,
......
dlls/wined3d/device.c
View file @ c228ffba
......@@ -2060,7 +2060,7 @@ struct wined3d_vertex_declaration * CDECL wined3d_device_get_vertex_declaration(
void CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
struct wined3d_shader *prev = device->update_state->vertex_shader;
struct wined3d_shader *prev = device->update_state->shader[WINED3D_SHADER_TYPE_VERTEX];
TRACE("device %p, shader %p.\n", device, shader);
......@@ -2072,9 +2072,9 @@ void CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struc
if (shader)
wined3d_shader_incref(shader);
device->update_state->vertex_shader = shader;
device->update_state->shader[WINED3D_SHADER_TYPE_VERTEX] = shader;
if (!device->recording)
wined3d_cs_emit_set_vertex_shader(device->cs, shader);
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_VERTEX, shader);
if (prev)
wined3d_shader_decref(prev);
}
......@@ -2083,7 +2083,7 @@ struct wined3d_shader * CDECL wined3d_device_get_vertex_shader(const struct wine
{
TRACE("device %p.\n", device);
return device->state.vertex_shader;
return device->state.shader[WINED3D_SHADER_TYPE_VERTEX];
}
void CDECL wined3d_device_set_vs_cb(struct wined3d_device *device, UINT idx, struct wined3d_buffer *buffer)
......@@ -2328,7 +2328,7 @@ HRESULT CDECL wined3d_device_get_vs_consts_f(const struct wined3d_device *device
void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
struct wined3d_shader *prev = device->update_state->pixel_shader;
struct wined3d_shader *prev = device->update_state->shader[WINED3D_SHADER_TYPE_PIXEL];
TRACE("device %p, shader %p.\n", device, shader);
......@@ -2340,9 +2340,9 @@ void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct
if (shader)
wined3d_shader_incref(shader);
device->update_state->pixel_shader = shader;
device->update_state->shader[WINED3D_SHADER_TYPE_PIXEL] = shader;
if (!device->recording)
wined3d_cs_emit_set_pixel_shader(device->cs, shader);
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_PIXEL, shader);
if (prev)
wined3d_shader_decref(prev);
}
......@@ -2351,7 +2351,7 @@ struct wined3d_shader * CDECL wined3d_device_get_pixel_shader(const struct wined
{
TRACE("device %p.\n", device);
return device->state.pixel_shader;
return device->state.shader[WINED3D_SHADER_TYPE_PIXEL];
}
void CDECL wined3d_device_set_ps_cb(struct wined3d_device *device, UINT idx, struct wined3d_buffer *buffer)
......@@ -2586,7 +2586,7 @@ HRESULT CDECL wined3d_device_get_ps_consts_f(const struct wined3d_device *device
void CDECL wined3d_device_set_geometry_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
struct wined3d_shader *prev = device->update_state->geometry_shader;
struct wined3d_shader *prev = device->update_state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
TRACE("device %p, shader %p.\n", device, shader);
......@@ -2594,8 +2594,8 @@ void CDECL wined3d_device_set_geometry_shader(struct wined3d_device *device, str
return;
if (shader)
wined3d_shader_incref(shader);
device->update_state->geometry_shader = shader;
wined3d_cs_emit_set_geometry_shader(device->cs, shader);
device->update_state->shader[WINED3D_SHADER_TYPE_GEOMETRY] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_GEOMETRY, shader);
if (prev)
wined3d_shader_decref(prev);
}
......@@ -2604,7 +2604,7 @@ struct wined3d_shader * CDECL wined3d_device_get_geometry_shader(const struct wi
{
TRACE("device %p.\n", device);
return device->state.geometry_shader;
return device->state.shader[WINED3D_SHADER_TYPE_GEOMETRY];
}
void CDECL wined3d_device_set_gs_cb(struct wined3d_device *device, UINT idx, struct wined3d_buffer *buffer)
......@@ -2984,10 +2984,10 @@ HRESULT CDECL wined3d_device_process_vertices(struct wined3d_device *device,
context = context_acquire(device, NULL);
gl_info = context->gl_info;
vs = state->vertex_shader;
state->vertex_shader = NULL;
vs = state->shader[WINED3D_SHADER_TYPE_VERTEX];
state->shader[WINED3D_SHADER_TYPE_VERTEX] = NULL;
context_stream_info_from_declaration(context, state, &stream_info);
state->vertex_shader = vs;
state->shader[WINED3D_SHADER_TYPE_VERTEX] = vs;
/* We can't convert FROM a VBO, and vertex buffers used to source into
* process_vertices() are unlikely to ever be used for drawing. Release
......
dlls/wined3d/glsl_shader.c
View file @ c228ffba
......@@ -761,8 +761,8 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
const struct wined3d_state *state)
{
const struct glsl_context_data *ctx_data = context->shader_backend_data;
const struct wined3d_shader *vshader = state->vertex_shader;
const struct wined3d_shader *pshader = state->pixel_shader;
const struct wined3d_shader *vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
const struct wined3d_shader *pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
const struct wined3d_gl_info *gl_info = context->gl_info;
struct shader_glsl_priv *priv = shader_priv;
float position_fixup[4];
......@@ -5791,8 +5791,8 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
if (use_vs(state))
{
vshader = state->vertex_shader;
gshader = state->geometry_shader;
vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
gshader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
if (!(context->shader_update_mask & (1 << WINED3D_SHADER_TYPE_GEOMETRY))
&& ctx_data->glsl_program->gs.id)
......@@ -5804,13 +5804,13 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
else if (use_vs(state))
{
struct vs_compile_args vs_compile_args;
vshader = state->vertex_shader;
vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
find_vs_compile_args(state, vshader, context->stream_info.swizzle_map, &vs_compile_args);
vs_id = find_glsl_vshader(context, &priv->shader_buffer, vshader, &vs_compile_args);
vs_list = &vshader->linked_programs;
if ((gshader = state->geometry_shader))
if ((gshader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY]))
gs_id = find_glsl_geometry_shader(context, &priv->shader_buffer, gshader);
}
else if (priv->vertex_pipe == &glsl_vertex_pipe)
......@@ -5830,12 +5830,12 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
ps_list = &ctx_data->glsl_program->ps.shader_entry;
if (use_ps(state))
pshader = state->pixel_shader;
pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
}
else if (use_ps(state))
{
struct ps_compile_args ps_compile_args;
pshader = state->pixel_shader;
pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
find_ps_compile_args(state, pshader, context->stream_info.position_transformed, &ps_compile_args, gl_info);
ps_id = find_glsl_pshader(context, &priv->shader_buffer,
pshader, &ps_compile_args, &np2fixup_info);
......
dlls/wined3d/shader.c
View file @ c228ffba
......@@ -2057,7 +2057,7 @@ void find_ps_compile_args(const struct wined3d_state *state, const struct wined3
{
DWORD tex_transform = flags & ~WINED3D_TTFF_PROJECTED;
if (!state->vertex_shader)
if (!state->shader[WINED3D_SHADER_TYPE_VERTEX])
{
unsigned int j;
unsigned int index = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
......
dlls/wined3d/state.c
View file @ c228ffba
......@@ -4075,7 +4075,7 @@ static void load_numbered_arrays(struct wined3d_context *context,
{
if (context->numbered_array_mask & (1 << i))
unload_numbered_array(context, i);
if (state->vertex_shader->reg_maps.input_registers & (1 << i))
if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.input_registers & (1 << i))
GL_EXTCALL(glVertexAttrib4fARB(i, 0.0f, 0.0f, 0.0f, 0.0f));
continue;
}
......@@ -4632,8 +4632,8 @@ void vertexdeclaration(struct wined3d_context *context, const struct wined3d_sta
transform_texture(context, state, STATE_TEXTURESTAGE(i, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS));
}
if (use_ps(state) && state->pixel_shader->reg_maps.shader_version.major == 1
&& state->pixel_shader->reg_maps.shader_version.minor <= 3)
if (use_ps(state) && state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.major == 1
&& state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.minor <= 3)
context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
}
......
dlls/wined3d/stateblock.c
View file @ c228ffba
......@@ -504,10 +504,13 @@ void state_unbind_resources(struct wined3d_state *state)
wined3d_buffer_decref(buffer);
}
if ((shader = state->vertex_shader))
for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
{
state->vertex_shader = NULL;
wined3d_shader_decref(shader);
if ((shader = state->shader[i]))
{
state->shader[i] = NULL;
wined3d_shader_decref(shader);
}
}
for (i = 0; i < MAX_CONSTANT_BUFFERS; ++i)
......@@ -528,12 +531,6 @@ void state_unbind_resources(struct wined3d_state *state)
}
}
if ((shader = state->geometry_shader))
{
state->geometry_shader = NULL;
wined3d_shader_decref(shader);
}
for (i = 0; i < MAX_CONSTANT_BUFFERS; ++i)
{
if ((buffer = state->gs_cb[i]))
......@@ -552,12 +549,6 @@ void state_unbind_resources(struct wined3d_state *state)
}
}
if ((shader = state->pixel_shader))
{
state->pixel_shader = NULL;
wined3d_shader_decref(shader);
}
for (i = 0; i < MAX_SAMPLER_OBJECTS; ++i)
{
if ((sampler = state->ps_sampler[i]))
......@@ -686,16 +677,18 @@ void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
TRACE("Capturing state %p.\n", src_state);
if (stateblock->changed.vertexShader && stateblock->state.vertex_shader != src_state->vertex_shader)
if (stateblock->changed.vertexShader && stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX]
!= src_state->shader[WINED3D_SHADER_TYPE_VERTEX])
{
TRACE("Updating vertex shader from %p to %p\n",
stateblock->state.vertex_shader, src_state->vertex_shader);
stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX],
src_state->shader[WINED3D_SHADER_TYPE_VERTEX]);
if (src_state->vertex_shader)
wined3d_shader_incref(src_state->vertex_shader);
if (stateblock->state.vertex_shader)
wined3d_shader_decref(stateblock->state.vertex_shader);
stateblock->state.vertex_shader = src_state->vertex_shader;
if (src_state->shader[WINED3D_SHADER_TYPE_VERTEX])
wined3d_shader_incref(src_state->shader[WINED3D_SHADER_TYPE_VERTEX]);
if (stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX])
wined3d_shader_decref(stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX]);
stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX] = src_state->shader[WINED3D_SHADER_TYPE_VERTEX];
}
/* Vertex shader float constants. */
......@@ -950,13 +943,14 @@ void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
stateblock->state.sampler_states[stage][state] = src_state->sampler_states[stage][state];
}
if (stateblock->changed.pixelShader && stateblock->state.pixel_shader != src_state->pixel_shader)
if (stateblock->changed.pixelShader && stateblock->state.shader[WINED3D_SHADER_TYPE_PIXEL]
!= src_state->shader[WINED3D_SHADER_TYPE_PIXEL])
{
if (src_state->pixel_shader)
wined3d_shader_incref(src_state->pixel_shader);
if (stateblock->state.pixel_shader)
wined3d_shader_decref(stateblock->state.pixel_shader);
stateblock->state.pixel_shader = src_state->pixel_shader;
if (src_state->shader[WINED3D_SHADER_TYPE_PIXEL])
wined3d_shader_incref(src_state->shader[WINED3D_SHADER_TYPE_PIXEL]);
if (stateblock->state.shader[WINED3D_SHADER_TYPE_PIXEL])
wined3d_shader_decref(stateblock->state.shader[WINED3D_SHADER_TYPE_PIXEL]);
stateblock->state.shader[WINED3D_SHADER_TYPE_PIXEL] = src_state->shader[WINED3D_SHADER_TYPE_PIXEL];
}
wined3d_state_record_lights(&stateblock->state, src_state);
......@@ -991,7 +985,7 @@ void CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock)
TRACE("Applying stateblock %p to device %p.\n", stateblock, device);
if (stateblock->changed.vertexShader)
wined3d_device_set_vertex_shader(device, stateblock->state.vertex_shader);
wined3d_device_set_vertex_shader(device, stateblock->state.shader[WINED3D_SHADER_TYPE_VERTEX]);
/* Vertex Shader Constants. */
for (i = 0; i < stateblock->num_contained_vs_consts_f; ++i)
......@@ -1013,7 +1007,7 @@ void CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock)
apply_lights(device, &stateblock->state);
if (stateblock->changed.pixelShader)
wined3d_device_set_pixel_shader(device, stateblock->state.pixel_shader);
wined3d_device_set_pixel_shader(device, stateblock->state.shader[WINED3D_SHADER_TYPE_PIXEL]);
/* Pixel Shader Constants. */
for (i = 0; i < stateblock->num_contained_ps_consts_f; ++i)
......
dlls/wined3d/wined3d_private.h
View file @ c228ffba
......@@ -1817,18 +1817,17 @@ struct wined3d_state
INT load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
GLenum gl_primitive_type;
struct wined3d_shader *vertex_shader;
struct wined3d_shader *shader[WINED3D_SHADER_TYPE_COUNT];
struct wined3d_buffer *vs_cb[MAX_CONSTANT_BUFFERS];
struct wined3d_sampler *vs_sampler[MAX_SAMPLER_OBJECTS];
BOOL vs_consts_b[MAX_CONST_B];
INT vs_consts_i[MAX_CONST_I * 4];
float *vs_consts_f;
struct wined3d_shader *geometry_shader;
struct wined3d_buffer *gs_cb[MAX_CONSTANT_BUFFERS];
struct wined3d_sampler *gs_sampler[MAX_SAMPLER_OBJECTS];
struct wined3d_shader *pixel_shader;
struct wined3d_buffer *ps_cb[MAX_CONSTANT_BUFFERS];
struct wined3d_sampler *ps_sampler[MAX_SAMPLER_OBJECTS];
BOOL ps_consts_b[MAX_CONST_B];
......@@ -2482,11 +2481,9 @@ void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *sw
void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx,
const struct wined3d_vec4 *plane) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_depth_stencil(struct wined3d_cs *cs, struct wined3d_surface *depth_stencil) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_geometry_shader(struct wined3d_cs *cs, struct wined3d_shader *shader) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_pixel_shader(struct wined3d_cs *cs, struct wined3d_shader *shader) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs,
enum wined3d_render_state state, DWORD value) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_render_target(struct wined3d_cs *cs, UINT render_target_idx,
......@@ -2494,6 +2491,8 @@ void wined3d_cs_emit_set_render_target(struct wined3d_cs *cs, UINT render_target
void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
enum wined3d_sampler_state state, DWORD value) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type,
struct wined3d_shader *shader) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
struct wined3d_buffer *buffer, UINT offset, UINT stride) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx,
......@@ -2505,7 +2504,6 @@ void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform
const struct wined3d_matrix *matrix) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs,
struct wined3d_vertex_declaration *declaration) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_vertex_shader(struct wined3d_cs *cs, struct wined3d_shader *shader) DECLSPEC_HIDDEN;
void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport) DECLSPEC_HIDDEN;
/* Direct3D terminology with little modifications. We do not have an issued state
......@@ -3043,12 +3041,12 @@ static inline BOOL use_vs(const struct wined3d_state *state)
{
/* Check state->vertex_declaration to allow this to be used before the
* stream info is validated, for example in device_update_tex_unit_map(). */
return state->vertex_shader && !state->vertex_declaration->position_transformed;
return state->shader[WINED3D_SHADER_TYPE_VERTEX] && !state->vertex_declaration->position_transformed;
}
static inline BOOL use_ps(const struct wined3d_state *state)
{
return !!state->pixel_shader;
return !!state->shader[WINED3D_SHADER_TYPE_PIXEL];
}
static inline void context_apply_state(struct wined3d_context *context,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment