[PATCH v2 1/6] wined3d: Access device state through its pointer.
Rémi Bernon
rbernon at codeweavers.com
Thu Feb 18 12:42:13 CST 2021
Signed-off-by: Rémi Bernon <rbernon at codeweavers.com>
---
So I dropped the previous first and last patches, as they weren't really
needed after all, and so I got more room to send the full d3d11 state
swap implementation.
Supersedes: 200145-200148
dlls/wined3d/device.c | 389 ++++++++++++++++++++++++++---------------
dlls/wined3d/texture.c | 3 +-
2 files changed, 247 insertions(+), 145 deletions(-)
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 1fd5f4b012e..44941539940 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -1083,6 +1083,7 @@ HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, str
{
static const struct wined3d_color black = {0.0f, 0.0f, 0.0f, 0.0f};
const struct wined3d_swapchain_desc *swapchain_desc;
+ struct wined3d_state *state = &device->state;
DWORD clear_flags = 0;
unsigned int i;
HRESULT hr;
@@ -1101,11 +1102,11 @@ HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, str
}
device->swapchains[0] = swapchain;
- for (i = 0; i < ARRAY_SIZE(device->state.fb.render_targets); ++i)
- if (device->state.fb.render_targets[i])
- wined3d_rtv_bind_count_dec(device->state.fb.render_targets[i]);
+ for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i)
+ if (state->fb.render_targets[i])
+ wined3d_rtv_bind_count_dec(state->fb.render_targets[i]);
- memset(device->state.fb.render_targets, 0, sizeof(device->state.fb.render_targets));
+ memset(state->fb.render_targets, 0, sizeof(state->fb.render_targets));
if (FAILED(hr = device->adapter->adapter_ops->adapter_init_3d(device)))
goto err_out;
device->d3d_initialized = TRUE;
@@ -1187,6 +1188,7 @@ static void device_free_depth_stencil_state(struct wine_rb_entry *entry, void *c
void wined3d_device_uninit_3d(struct wined3d_device *device)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_resource *resource, *cursor;
struct wined3d_rendertarget_view *view;
struct wined3d_texture *texture;
@@ -1217,7 +1219,7 @@ void wined3d_device_uninit_3d(struct wined3d_device *device)
}
wined3d_cs_emit_reset_state(device->cs);
- state_cleanup(&device->state);
+ state_cleanup(state);
for (i = 0; i < device->adapter->d3d_info.limits.max_rt_count; ++i)
{
wined3d_device_set_rendertarget_view(device, i, NULL, FALSE);
@@ -1237,11 +1239,11 @@ void wined3d_device_uninit_3d(struct wined3d_device *device)
device->adapter->adapter_ops->adapter_uninit_3d(device);
device->d3d_initialized = FALSE;
- if ((view = device->state.fb.depth_stencil))
+ if ((view = state->fb.depth_stencil))
{
TRACE("Releasing depth/stencil view %p.\n", view);
- device->state.fb.depth_stencil = NULL;
+ state->fb.depth_stencil = NULL;
wined3d_rendertarget_view_decref(view);
}
@@ -1261,8 +1263,8 @@ void wined3d_device_uninit_3d(struct wined3d_device *device)
heap_free(device->swapchains);
device->swapchains = NULL;
- memset(&device->state, 0, sizeof(device->state));
- state_init(&device->state, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
+ memset(state, 0, sizeof(*state));
+ state_init(state, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
}
/* Enables thread safety in the wined3d device and its resources. Called by DirectDraw
@@ -1298,6 +1300,7 @@ UINT CDECL wined3d_device_get_available_texture_mem(const struct wined3d_device
void CDECL wined3d_device_set_stream_output(struct wined3d_device *device, UINT idx,
struct wined3d_buffer *buffer, UINT offset)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_stream_output *stream;
struct wined3d_buffer *prev_buffer;
@@ -1309,7 +1312,7 @@ void CDECL wined3d_device_set_stream_output(struct wined3d_device *device, UINT
return;
}
- stream = &device->state.stream_output[idx];
+ stream = &state->stream_output[idx];
prev_buffer = stream->buffer;
if (buffer)
@@ -1324,6 +1327,8 @@ void CDECL wined3d_device_set_stream_output(struct wined3d_device *device, UINT
struct wined3d_buffer * CDECL wined3d_device_get_stream_output(struct wined3d_device *device,
UINT idx, UINT *offset)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, idx %u, offset %p.\n", device, idx, offset);
if (idx >= WINED3D_MAX_STREAM_OUTPUT_BUFFERS)
@@ -1333,13 +1338,14 @@ struct wined3d_buffer * CDECL wined3d_device_get_stream_output(struct wined3d_de
}
if (offset)
- *offset = device->state.stream_output[idx].offset;
- return device->state.stream_output[idx].buffer;
+ *offset = state->stream_output[idx].offset;
+ return state->stream_output[idx].buffer;
}
HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UINT stream_idx,
struct wined3d_buffer *buffer, UINT offset, UINT stride)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_stream_state *stream;
struct wined3d_buffer *prev_buffer;
@@ -1357,7 +1363,7 @@ HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UI
return WINED3DERR_INVALIDCALL;
}
- stream = &device->state.streams[stream_idx];
+ stream = &state->streams[stream_idx];
prev_buffer = stream->buffer;
if (prev_buffer == buffer
@@ -1383,6 +1389,7 @@ HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UI
HRESULT CDECL wined3d_device_get_stream_source(const struct wined3d_device *device,
UINT stream_idx, struct wined3d_buffer **buffer, UINT *offset, UINT *stride)
{
+ const struct wined3d_state *state = &device->state;
const struct wined3d_stream_state *stream;
TRACE("device %p, stream_idx %u, buffer %p, offset %p, stride %p.\n",
@@ -1394,7 +1401,7 @@ HRESULT CDECL wined3d_device_get_stream_source(const struct wined3d_device *devi
return WINED3DERR_INVALIDCALL;
}
- stream = &device->state.streams[stream_idx];
+ stream = &state->streams[stream_idx];
*buffer = stream->buffer;
if (offset)
*offset = stream->offset;
@@ -1405,12 +1412,13 @@ HRESULT CDECL wined3d_device_get_stream_source(const struct wined3d_device *devi
static void wined3d_device_set_stream_source_freq(struct wined3d_device *device, UINT stream_idx, UINT divider)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_stream_state *stream;
UINT old_flags, old_freq;
TRACE("device %p, stream_idx %u, divider %#x.\n", device, stream_idx, divider);
- stream = &device->state.streams[stream_idx];
+ stream = &state->streams[stream_idx];
old_flags = stream->flags;
old_freq = stream->frequency;
@@ -1423,6 +1431,8 @@ static void wined3d_device_set_stream_source_freq(struct wined3d_device *device,
static void wined3d_device_set_transform(struct wined3d_device *device,
enum wined3d_transform_state d3dts, const struct wined3d_matrix *matrix)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, state %s, matrix %p.\n",
device, debug_d3dtstype(d3dts), matrix);
TRACE("%.8e %.8e %.8e %.8e\n", matrix->_11, matrix->_12, matrix->_13, matrix->_14);
@@ -1436,13 +1446,13 @@ static void wined3d_device_set_transform(struct wined3d_device *device,
* tend towards setting the same matrix repeatedly for some reason.
*
* From here on we assume that the new matrix is different, wherever it matters. */
- if (!memcmp(&device->state.transforms[d3dts], matrix, sizeof(*matrix)))
+ if (!memcmp(&state->transforms[d3dts], matrix, sizeof(*matrix)))
{
TRACE("The application is setting the same matrix over again.\n");
return;
}
- device->state.transforms[d3dts] = *matrix;
+ state->transforms[d3dts] = *matrix;
wined3d_cs_emit_set_transform(device->cs, d3dts, matrix);
}
@@ -1464,12 +1474,13 @@ static void wined3d_device_get_transform(const struct wined3d_device *device,
static void wined3d_device_set_light(struct wined3d_device *device,
UINT light_idx, const struct wined3d_light *light)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_light_info *object = NULL;
float rho;
TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
- if (FAILED(wined3d_light_state_set_light(&device->state.light_state, light_idx, light, &object)))
+ if (FAILED(wined3d_light_state_set_light(&state->light_state, light_idx, light, &object)))
return;
/* Initialize the object. */
@@ -1563,30 +1574,33 @@ static void wined3d_device_set_light(struct wined3d_device *device,
static void wined3d_device_set_light_enable(struct wined3d_device *device, UINT light_idx, BOOL enable)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_light_info *light_info;
TRACE("device %p, light_idx %u, enable %#x.\n", device, light_idx, enable);
/* Special case - enabling an undefined light creates one with a strict set of parameters. */
- if (!(light_info = wined3d_light_state_get_light(&device->state.light_state, light_idx)))
+ if (!(light_info = wined3d_light_state_get_light(&state->light_state, light_idx)))
{
TRACE("Light enabled requested but light not defined, so defining one!\n");
wined3d_device_set_light(device, light_idx, &WINED3D_default_light);
- if (!(light_info = wined3d_light_state_get_light(&device->state.light_state, light_idx)))
+ if (!(light_info = wined3d_light_state_get_light(&state->light_state, light_idx)))
{
FIXME("Adding default lights has failed dismally\n");
return;
}
}
- wined3d_light_state_enable_light(&device->state.light_state, &device->adapter->d3d_info, light_info, enable);
+ wined3d_light_state_enable_light(&state->light_state, &device->adapter->d3d_info, light_info, enable);
wined3d_cs_emit_set_light_enable(device->cs, light_idx, enable);
}
static HRESULT wined3d_device_set_clip_plane(struct wined3d_device *device,
UINT plane_idx, const struct wined3d_vec4 *plane)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
if (plane_idx >= device->adapter->d3d_info.limits.max_clip_distances)
@@ -1595,13 +1609,13 @@ static HRESULT wined3d_device_set_clip_plane(struct wined3d_device *device,
return WINED3DERR_INVALIDCALL;
}
- if (!memcmp(&device->state.clip_planes[plane_idx], plane, sizeof(*plane)))
+ if (!memcmp(&state->clip_planes[plane_idx], plane, sizeof(*plane)))
{
TRACE("Application is setting old values over, nothing to do.\n");
return WINED3D_OK;
}
- device->state.clip_planes[plane_idx] = *plane;
+ state->clip_planes[plane_idx] = *plane;
wined3d_cs_emit_set_clip_plane(device->cs, plane_idx, plane);
@@ -1632,15 +1646,18 @@ HRESULT CDECL wined3d_device_get_clip_status(const struct wined3d_device *device
static void wined3d_device_set_material(struct wined3d_device *device, const struct wined3d_material *material)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, material %p.\n", device, material);
- device->state.material = *material;
+ state->material = *material;
wined3d_cs_emit_set_material(device->cs, material);
}
void CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
struct wined3d_buffer *buffer, enum wined3d_format_id format_id, unsigned int offset)
{
+ struct wined3d_state *state = &device->state;
enum wined3d_format_id prev_format;
struct wined3d_buffer *prev_buffer;
unsigned int prev_offset;
@@ -1648,18 +1665,18 @@ void CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
TRACE("device %p, buffer %p, format %s, offset %u.\n",
device, buffer, debug_d3dformat(format_id), offset);
- prev_buffer = device->state.index_buffer;
- prev_format = device->state.index_format;
- prev_offset = device->state.index_offset;
+ prev_buffer = state->index_buffer;
+ prev_format = state->index_format;
+ prev_offset = state->index_offset;
if (prev_buffer == buffer && prev_format == format_id && prev_offset == offset)
return;
if (buffer)
wined3d_buffer_incref(buffer);
- device->state.index_buffer = buffer;
- device->state.index_format = format_id;
- device->state.index_offset = offset;
+ state->index_buffer = buffer;
+ state->index_format = format_id;
+ state->index_offset = offset;
wined3d_cs_emit_set_index_buffer(device->cs, buffer, format_id, offset);
if (prev_buffer)
wined3d_buffer_decref(prev_buffer);
@@ -1668,24 +1685,29 @@ void CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
struct wined3d_buffer * CDECL wined3d_device_get_index_buffer(const struct wined3d_device *device,
enum wined3d_format_id *format, unsigned int *offset)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p, format %p, offset %p.\n", device, format, offset);
- *format = device->state.index_format;
+ *format = state->index_format;
if (offset)
- *offset = device->state.index_offset;
- return device->state.index_buffer;
+ *offset = state->index_offset;
+ return state->index_buffer;
}
void CDECL wined3d_device_set_base_vertex_index(struct wined3d_device *device, INT base_index)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, base_index %d.\n", device, base_index);
- device->state.base_vertex_index = base_index;
+ state->base_vertex_index = base_index;
}
void CDECL wined3d_device_set_viewports(struct wined3d_device *device, unsigned int viewport_count,
const struct wined3d_viewport *viewports)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, viewport_count %u, viewports %p.\n", device, viewport_count, viewports);
@@ -1697,10 +1719,10 @@ void CDECL wined3d_device_set_viewports(struct wined3d_device *device, unsigned
}
if (viewport_count)
- memcpy(device->state.viewports, viewports, viewport_count * sizeof(*viewports));
+ memcpy(state->viewports, viewports, viewport_count * sizeof(*viewports));
else
- memset(device->state.viewports, 0, sizeof(device->state.viewports));
- device->state.viewport_count = viewport_count;
+ memset(state->viewports, 0, sizeof(state->viewports));
+ state->viewport_count = viewport_count;
wined3d_cs_emit_set_viewports(device->cs, viewport_count, viewports);
}
@@ -1708,15 +1730,16 @@ void CDECL wined3d_device_set_viewports(struct wined3d_device *device, unsigned
void CDECL wined3d_device_get_viewports(const struct wined3d_device *device, unsigned int *viewport_count,
struct wined3d_viewport *viewports)
{
+ const struct wined3d_state *state = &device->state;
unsigned int count;
TRACE("device %p, viewport_count %p, viewports %p.\n", device, viewport_count, viewports);
- count = viewport_count ? min(*viewport_count, device->state.viewport_count) : 1;
+ count = viewport_count ? min(*viewport_count, state->viewport_count) : 1;
if (count && viewports)
- memcpy(viewports, device->state.viewports, count * sizeof(*viewports));
+ memcpy(viewports, state->viewports, count * sizeof(*viewports));
if (viewport_count)
- *viewport_count = device->state.viewport_count;
+ *viewport_count = state->viewport_count;
}
static void resolve_depth_buffer(struct wined3d_device *device)
@@ -1796,26 +1819,29 @@ void CDECL wined3d_device_set_depth_stencil_state(struct wined3d_device *device,
struct wined3d_depth_stencil_state * CDECL wined3d_device_get_depth_stencil_state(const struct wined3d_device *device, unsigned int *stencil_ref)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p, stencil_ref %p.\n", device, stencil_ref);
- *stencil_ref = device->state.stencil_ref;
- return device->state.depth_stencil_state;
+ *stencil_ref = state->stencil_ref;
+ return state->depth_stencil_state;
}
void CDECL wined3d_device_set_rasterizer_state(struct wined3d_device *device,
struct wined3d_rasterizer_state *rasterizer_state)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_rasterizer_state *prev;
TRACE("device %p, rasterizer_state %p.\n", device, rasterizer_state);
- prev = device->state.rasterizer_state;
+ prev = state->rasterizer_state;
if (prev == rasterizer_state)
return;
if (rasterizer_state)
wined3d_rasterizer_state_incref(rasterizer_state);
- device->state.rasterizer_state = rasterizer_state;
+ state->rasterizer_state = rasterizer_state;
wined3d_cs_emit_set_rasterizer_state(device->cs, rasterizer_state);
if (prev)
wined3d_rasterizer_state_decref(prev);
@@ -1823,9 +1849,11 @@ void CDECL wined3d_device_set_rasterizer_state(struct wined3d_device *device,
struct wined3d_rasterizer_state * CDECL wined3d_device_get_rasterizer_state(struct wined3d_device *device)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.rasterizer_state;
+ return state->rasterizer_state;
}
void CDECL wined3d_device_set_render_state(struct wined3d_device *device,
@@ -1880,6 +1908,7 @@ static void wined3d_device_set_sampler_state(struct wined3d_device *device,
void CDECL wined3d_device_set_scissor_rects(struct wined3d_device *device, unsigned int rect_count,
const RECT *rects)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, rect_count %u, rects %p.\n", device, rect_count, rects);
@@ -1889,39 +1918,41 @@ void CDECL wined3d_device_set_scissor_rects(struct wined3d_device *device, unsig
TRACE("%u: %s\n", i, wine_dbgstr_rect(&rects[i]));
}
- if (device->state.scissor_rect_count == rect_count
- && !memcmp(device->state.scissor_rects, rects, rect_count * sizeof(*rects)))
+ if (state->scissor_rect_count == rect_count
+ && !memcmp(state->scissor_rects, rects, rect_count * sizeof(*rects)))
{
TRACE("App is setting the old scissor rectangles over, nothing to do.\n");
return;
}
if (rect_count)
- memcpy(device->state.scissor_rects, rects, rect_count * sizeof(*rects));
+ memcpy(state->scissor_rects, rects, rect_count * sizeof(*rects));
else
- memset(device->state.scissor_rects, 0, sizeof(device->state.scissor_rects));
- device->state.scissor_rect_count = rect_count;
+ memset(state->scissor_rects, 0, sizeof(state->scissor_rects));
+ state->scissor_rect_count = rect_count;
wined3d_cs_emit_set_scissor_rects(device->cs, rect_count, rects);
}
void CDECL wined3d_device_get_scissor_rects(const struct wined3d_device *device, unsigned int *rect_count, RECT *rects)
{
+ const struct wined3d_state *state = &device->state;
unsigned int count;
TRACE("device %p, rect_count %p, rects %p.\n", device, rect_count, rects);
- count = rect_count ? min(*rect_count, device->state.scissor_rect_count) : 1;
+ count = rect_count ? min(*rect_count, state->scissor_rect_count) : 1;
if (count && rects)
- memcpy(rects, device->state.scissor_rects, count * sizeof(*rects));
+ memcpy(rects, state->scissor_rects, count * sizeof(*rects));
if (rect_count)
- *rect_count = device->state.scissor_rect_count;
+ *rect_count = state->scissor_rect_count;
}
void CDECL wined3d_device_set_vertex_declaration(struct wined3d_device *device,
struct wined3d_vertex_declaration *declaration)
{
- struct wined3d_vertex_declaration *prev = device->state.vertex_declaration;
+ struct wined3d_state *state = &device->state;
+ struct wined3d_vertex_declaration *prev = state->vertex_declaration;
TRACE("device %p, declaration %p.\n", device, declaration);
@@ -1930,7 +1961,7 @@ void CDECL wined3d_device_set_vertex_declaration(struct wined3d_device *device,
if (declaration)
wined3d_vertex_declaration_incref(declaration);
- device->state.vertex_declaration = declaration;
+ state->vertex_declaration = declaration;
wined3d_cs_emit_set_vertex_declaration(device->cs, declaration);
if (prev)
wined3d_vertex_declaration_decref(prev);
@@ -1938,14 +1969,17 @@ void CDECL wined3d_device_set_vertex_declaration(struct wined3d_device *device,
struct wined3d_vertex_declaration * CDECL wined3d_device_get_vertex_declaration(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.vertex_declaration;
+ return state->vertex_declaration;
}
void CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
- struct wined3d_shader *prev = device->state.shader[WINED3D_SHADER_TYPE_VERTEX];
+ struct wined3d_state *state = &device->state;
+ struct wined3d_shader *prev = state->shader[WINED3D_SHADER_TYPE_VERTEX];
TRACE("device %p, shader %p.\n", device, shader);
@@ -1954,7 +1988,7 @@ void CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struc
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_VERTEX] = shader;
+ state->shader[WINED3D_SHADER_TYPE_VERTEX] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_VERTEX, shader);
if (prev)
wined3d_shader_decref(prev);
@@ -1962,14 +1996,17 @@ void CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struc
struct wined3d_shader * CDECL wined3d_device_get_vertex_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_VERTEX];
+ return state->shader[WINED3D_SHADER_TYPE_VERTEX];
}
void CDECL wined3d_device_set_constant_buffer(struct wined3d_device *device,
enum wined3d_shader_type type, UINT idx, struct wined3d_buffer *buffer)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_buffer *prev;
TRACE("device %p, type %#x, idx %u, buffer %p.\n", device, type, idx, buffer);
@@ -1980,13 +2017,13 @@ void CDECL wined3d_device_set_constant_buffer(struct wined3d_device *device,
return;
}
- prev = device->state.cb[type][idx];
+ prev = state->cb[type][idx];
if (buffer == prev)
return;
if (buffer)
wined3d_buffer_incref(buffer);
- device->state.cb[type][idx] = buffer;
+ state->cb[type][idx] = buffer;
wined3d_cs_emit_set_constant_buffer(device->cs, type, idx, buffer);
if (prev)
wined3d_buffer_decref(prev);
@@ -1995,6 +2032,8 @@ void CDECL wined3d_device_set_constant_buffer(struct wined3d_device *device,
struct wined3d_buffer * CDECL wined3d_device_get_constant_buffer(const struct wined3d_device *device,
enum wined3d_shader_type shader_type, unsigned int idx)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p, shader_type %#x, idx %u.\n", device, shader_type, idx);
if (idx >= MAX_CONSTANT_BUFFERS)
@@ -2003,12 +2042,13 @@ struct wined3d_buffer * CDECL wined3d_device_get_constant_buffer(const struct wi
return NULL;
}
- return device->state.cb[shader_type][idx];
+ return state->cb[shader_type][idx];
}
static void wined3d_device_set_shader_resource_view(struct wined3d_device *device,
enum wined3d_shader_type type, UINT idx, struct wined3d_shader_resource_view *view)
{
+ struct wined3d_state *state = &device->state;
const struct wined3d_rendertarget_view *dsv;
struct wined3d_shader_resource_view *prev;
@@ -2018,12 +2058,12 @@ static void wined3d_device_set_shader_resource_view(struct wined3d_device *devic
return;
}
- prev = device->state.shader_resource_view[type][idx];
+ prev = state->shader_resource_view[type][idx];
if (view == prev)
return;
if (view && (wined3d_is_srv_rtv_bound(view)
- || ((dsv = device->state.fb.depth_stencil)
+ || ((dsv = state->fb.depth_stencil)
&& dsv->resource == view->resource && wined3d_dsv_srv_conflict(dsv, view->format))))
{
WARN("Application is trying to bind resource which is attached as render target.\n");
@@ -2036,7 +2076,7 @@ static void wined3d_device_set_shader_resource_view(struct wined3d_device *devic
wined3d_srv_bind_count_inc(view);
}
- device->state.shader_resource_view[type][idx] = view;
+ state->shader_resource_view[type][idx] = view;
wined3d_cs_emit_set_shader_resource_view(device->cs, type, idx, view);
if (prev)
{
@@ -2056,13 +2096,15 @@ void CDECL wined3d_device_set_vs_resource_view(struct wined3d_device *device,
static struct wined3d_shader_resource_view *wined3d_device_get_shader_resource_view(
const struct wined3d_device *device, enum wined3d_shader_type shader_type, unsigned int idx)
{
+ const struct wined3d_state *state = &device->state;
+
if (idx >= MAX_SHADER_RESOURCE_VIEWS)
{
WARN("Invalid view index %u.\n", idx);
return NULL;
}
- return device->state.shader_resource_view[shader_type][idx];
+ return state->shader_resource_view[shader_type][idx];
}
struct wined3d_shader_resource_view * CDECL wined3d_device_get_vs_resource_view(const struct wined3d_device *device,
@@ -2076,6 +2118,7 @@ struct wined3d_shader_resource_view * CDECL wined3d_device_get_vs_resource_view(
static void wined3d_device_set_sampler(struct wined3d_device *device,
enum wined3d_shader_type type, UINT idx, struct wined3d_sampler *sampler)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_sampler *prev;
if (idx >= MAX_SAMPLER_OBJECTS)
@@ -2084,13 +2127,13 @@ static void wined3d_device_set_sampler(struct wined3d_device *device,
return;
}
- prev = device->state.sampler[type][idx];
+ prev = state->sampler[type][idx];
if (sampler == prev)
return;
if (sampler)
wined3d_sampler_incref(sampler);
- device->state.sampler[type][idx] = sampler;
+ state->sampler[type][idx] = sampler;
wined3d_cs_emit_set_sampler(device->cs, type, idx, sampler);
if (prev)
wined3d_sampler_decref(prev);
@@ -2106,13 +2149,15 @@ void CDECL wined3d_device_set_vs_sampler(struct wined3d_device *device, UINT idx
static struct wined3d_sampler *wined3d_device_get_sampler(const struct wined3d_device *device,
enum wined3d_shader_type shader_type, unsigned int idx)
{
+ const struct wined3d_state *state = &device->state;
+
if (idx >= MAX_SAMPLER_OBJECTS)
{
WARN("Invalid sampler index %u.\n", idx);
return NULL;
}
- return device->state.sampler[shader_type][idx];
+ return state->sampler[shader_type][idx];
}
struct wined3d_sampler * CDECL wined3d_device_get_vs_sampler(const struct wined3d_device *device, UINT idx)
@@ -2125,12 +2170,13 @@ struct wined3d_sampler * CDECL wined3d_device_get_vs_sampler(const struct wined3
static void wined3d_device_set_vs_consts_b(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const BOOL *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.vs_consts_b[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->vs_consts_b[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2143,12 +2189,13 @@ static void wined3d_device_set_vs_consts_b(struct wined3d_device *device,
static void wined3d_device_set_vs_consts_i(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.vs_consts_i[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->vs_consts_i[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2161,12 +2208,13 @@ static void wined3d_device_set_vs_consts_i(struct wined3d_device *device,
static void wined3d_device_set_vs_consts_f(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.vs_consts_f[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->vs_consts_f[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2178,7 +2226,8 @@ static void wined3d_device_set_vs_consts_f(struct wined3d_device *device,
void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
- struct wined3d_shader *prev = device->state.shader[WINED3D_SHADER_TYPE_PIXEL];
+ struct wined3d_state *state = &device->state;
+ struct wined3d_shader *prev = state->shader[WINED3D_SHADER_TYPE_PIXEL];
TRACE("device %p, shader %p.\n", device, shader);
@@ -2187,7 +2236,7 @@ void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_PIXEL] = shader;
+ state->shader[WINED3D_SHADER_TYPE_PIXEL] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_PIXEL, shader);
if (prev)
wined3d_shader_decref(prev);
@@ -2195,9 +2244,11 @@ void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct
struct wined3d_shader * CDECL wined3d_device_get_pixel_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_PIXEL];
+ return state->shader[WINED3D_SHADER_TYPE_PIXEL];
}
void CDECL wined3d_device_set_ps_resource_view(struct wined3d_device *device,
@@ -2233,12 +2284,13 @@ struct wined3d_sampler * CDECL wined3d_device_get_ps_sampler(const struct wined3
static void wined3d_device_set_ps_consts_b(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const BOOL *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.ps_consts_b[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->ps_consts_b[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2251,12 +2303,13 @@ static void wined3d_device_set_ps_consts_b(struct wined3d_device *device,
static void wined3d_device_set_ps_consts_i(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.ps_consts_i[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->ps_consts_i[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2269,12 +2322,13 @@ static void wined3d_device_set_ps_consts_i(struct wined3d_device *device,
static void wined3d_device_set_ps_consts_f(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
{
+ struct wined3d_state *state = &device->state;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- memcpy(&device->state.ps_consts_f[start_idx], constants, count * sizeof(*constants));
+ memcpy(&state->ps_consts_f[start_idx], constants, count * sizeof(*constants));
if (TRACE_ON(d3d))
{
for (i = 0; i < count; ++i)
@@ -2286,16 +2340,17 @@ static void wined3d_device_set_ps_consts_f(struct wined3d_device *device,
void CDECL wined3d_device_set_hull_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_shader *prev;
TRACE("device %p, shader %p.\n", device, shader);
- prev = device->state.shader[WINED3D_SHADER_TYPE_HULL];
+ prev = state->shader[WINED3D_SHADER_TYPE_HULL];
if (shader == prev)
return;
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_HULL] = shader;
+ state->shader[WINED3D_SHADER_TYPE_HULL] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_HULL, shader);
if (prev)
wined3d_shader_decref(prev);
@@ -2303,9 +2358,11 @@ void CDECL wined3d_device_set_hull_shader(struct wined3d_device *device, struct
struct wined3d_shader * CDECL wined3d_device_get_hull_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_HULL];
+ return state->shader[WINED3D_SHADER_TYPE_HULL];
}
void CDECL wined3d_device_set_hs_resource_view(struct wined3d_device *device,
@@ -2341,16 +2398,17 @@ struct wined3d_sampler * CDECL wined3d_device_get_hs_sampler(const struct wined3
void CDECL wined3d_device_set_domain_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_shader *prev;
TRACE("device %p, shader %p.\n", device, shader);
- prev = device->state.shader[WINED3D_SHADER_TYPE_DOMAIN];
+ prev = state->shader[WINED3D_SHADER_TYPE_DOMAIN];
if (shader == prev)
return;
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_DOMAIN] = shader;
+ state->shader[WINED3D_SHADER_TYPE_DOMAIN] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_DOMAIN, shader);
if (prev)
wined3d_shader_decref(prev);
@@ -2358,9 +2416,11 @@ void CDECL wined3d_device_set_domain_shader(struct wined3d_device *device, struc
struct wined3d_shader * CDECL wined3d_device_get_domain_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_DOMAIN];
+ return state->shader[WINED3D_SHADER_TYPE_DOMAIN];
}
void CDECL wined3d_device_set_ds_resource_view(struct wined3d_device *device,
@@ -2396,7 +2456,8 @@ struct wined3d_sampler * CDECL wined3d_device_get_ds_sampler(const struct wined3
void CDECL wined3d_device_set_geometry_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
- struct wined3d_shader *prev = device->state.shader[WINED3D_SHADER_TYPE_GEOMETRY];
+ struct wined3d_state *state = &device->state;
+ struct wined3d_shader *prev = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
TRACE("device %p, shader %p.\n", device, shader);
@@ -2404,7 +2465,7 @@ void CDECL wined3d_device_set_geometry_shader(struct wined3d_device *device, str
return;
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_GEOMETRY] = shader;
+ 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);
@@ -2412,9 +2473,11 @@ void CDECL wined3d_device_set_geometry_shader(struct wined3d_device *device, str
struct wined3d_shader * CDECL wined3d_device_get_geometry_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_GEOMETRY];
+ return state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
}
void CDECL wined3d_device_set_gs_resource_view(struct wined3d_device *device,
@@ -2449,16 +2512,17 @@ struct wined3d_sampler * CDECL wined3d_device_get_gs_sampler(const struct wined3
void CDECL wined3d_device_set_compute_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_shader *prev;
TRACE("device %p, shader %p.\n", device, shader);
- prev = device->state.shader[WINED3D_SHADER_TYPE_COMPUTE];
+ prev = state->shader[WINED3D_SHADER_TYPE_COMPUTE];
if (shader == prev)
return;
if (shader)
wined3d_shader_incref(shader);
- device->state.shader[WINED3D_SHADER_TYPE_COMPUTE] = shader;
+ state->shader[WINED3D_SHADER_TYPE_COMPUTE] = shader;
wined3d_cs_emit_set_shader(device->cs, WINED3D_SHADER_TYPE_COMPUTE, shader);
if (prev)
wined3d_shader_decref(prev);
@@ -2466,9 +2530,11 @@ void CDECL wined3d_device_set_compute_shader(struct wined3d_device *device, stru
struct wined3d_shader * CDECL wined3d_device_get_compute_shader(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.shader[WINED3D_SHADER_TYPE_COMPUTE];
+ return state->shader[WINED3D_SHADER_TYPE_COMPUTE];
}
void CDECL wined3d_device_set_cs_resource_view(struct wined3d_device *device,
@@ -2506,6 +2572,7 @@ static void wined3d_device_set_pipeline_unordered_access_view(struct wined3d_dev
enum wined3d_pipeline pipeline, unsigned int idx, struct wined3d_unordered_access_view *uav,
unsigned int initial_count)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_unordered_access_view *prev;
if (idx >= MAX_UNORDERED_ACCESS_VIEWS)
@@ -2514,13 +2581,13 @@ static void wined3d_device_set_pipeline_unordered_access_view(struct wined3d_dev
return;
}
- prev = device->state.unordered_access_view[pipeline][idx];
+ prev = state->unordered_access_view[pipeline][idx];
if (uav == prev && initial_count == ~0u)
return;
if (uav)
wined3d_unordered_access_view_incref(uav);
- device->state.unordered_access_view[pipeline][idx] = uav;
+ state->unordered_access_view[pipeline][idx] = uav;
wined3d_cs_emit_set_unordered_access_view(device->cs, pipeline, idx, uav, initial_count);
if (prev)
wined3d_unordered_access_view_decref(prev);
@@ -2529,13 +2596,15 @@ static void wined3d_device_set_pipeline_unordered_access_view(struct wined3d_dev
static struct wined3d_unordered_access_view *wined3d_device_get_pipeline_unordered_access_view(
const struct wined3d_device *device, enum wined3d_pipeline pipeline, unsigned int idx)
{
+ const struct wined3d_state *state = &device->state;
+
if (idx >= MAX_UNORDERED_ACCESS_VIEWS)
{
WARN("Invalid UAV index %u.\n", idx);
return NULL;
}
- return device->state.unordered_access_view[pipeline][idx];
+ return state->unordered_access_view[pipeline][idx];
}
void CDECL wined3d_device_set_cs_uav(struct wined3d_device *device, unsigned int idx,
@@ -3557,18 +3626,19 @@ static void wined3d_device_set_texture_stage_state(struct wined3d_device *device
static void wined3d_device_set_texture(struct wined3d_device *device,
UINT stage, struct wined3d_texture *texture)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_texture *prev;
TRACE("device %p, stage %u, texture %p.\n", device, stage, texture);
/* Windows accepts overflowing this array... we do not. */
- if (stage >= ARRAY_SIZE(device->state.textures))
+ if (stage >= ARRAY_SIZE(state->textures))
{
WARN("Ignoring invalid stage %u.\n", stage);
return;
}
- prev = device->state.textures[stage];
+ prev = state->textures[stage];
TRACE("Previous texture %p.\n", prev);
if (texture == prev)
@@ -3578,7 +3648,7 @@ static void wined3d_device_set_texture(struct wined3d_device *device,
}
TRACE("Setting new texture to %p.\n", texture);
- device->state.textures[stage] = texture;
+ state->textures[stage] = texture;
if (texture)
wined3d_texture_incref(texture);
@@ -4047,6 +4117,8 @@ HRESULT CDECL wined3d_device_end_scene(struct wined3d_device *device)
HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_count,
const RECT *rects, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, rect_count %u, rects %p, flags %#x, color %s, depth %.8e, stencil %u.\n",
device, rect_count, rects, flags, debug_color(color), depth, stencil);
@@ -4058,7 +4130,7 @@ HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_cou
if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
{
- struct wined3d_rendertarget_view *ds = device->state.fb.depth_stencil;
+ struct wined3d_rendertarget_view *ds = state->fb.depth_stencil;
if (!ds)
{
WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
@@ -4067,8 +4139,8 @@ HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_cou
}
else if (flags & WINED3DCLEAR_TARGET)
{
- if (ds->width < device->state.fb.render_targets[0]->width
- || ds->height < device->state.fb.render_targets[0]->height)
+ if (ds->width < state->fb.render_targets[0]->width
+ || ds->height < state->fb.render_targets[0]->height)
{
WARN("Silently ignoring depth and target clear with mismatching sizes\n");
return WINED3D_OK;
@@ -4084,18 +4156,19 @@ HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_cou
void CDECL wined3d_device_set_predication(struct wined3d_device *device,
struct wined3d_query *predicate, BOOL value)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_query *prev;
TRACE("device %p, predicate %p, value %#x.\n", device, predicate, value);
- prev = device->state.predicate;
+ prev = state->predicate;
if (predicate)
{
FIXME("Predicated rendering not implemented.\n");
wined3d_query_incref(predicate);
}
- device->state.predicate = predicate;
- device->state.predicate_value = value;
+ state->predicate = predicate;
+ state->predicate_value = value;
wined3d_cs_emit_set_predication(device->cs, predicate, value);
if (prev)
wined3d_query_decref(prev);
@@ -4103,11 +4176,13 @@ void CDECL wined3d_device_set_predication(struct wined3d_device *device,
struct wined3d_query * CDECL wined3d_device_get_predication(struct wined3d_device *device, BOOL *value)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, value %p.\n", device, value);
if (value)
- *value = device->state.predicate_value;
- return device->state.predicate;
+ *value = state->predicate_value;
+ return state->predicate;
}
void CDECL wined3d_device_dispatch_compute(struct wined3d_device *device,
@@ -4130,32 +4205,38 @@ void CDECL wined3d_device_dispatch_compute_indirect(struct wined3d_device *devic
void CDECL wined3d_device_set_primitive_type(struct wined3d_device *device,
enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, primitive_type %s, patch_vertex_count %u.\n",
device, debug_d3dprimitivetype(primitive_type), patch_vertex_count);
- device->state.primitive_type = primitive_type;
- device->state.patch_vertex_count = patch_vertex_count;
+ state->primitive_type = primitive_type;
+ state->patch_vertex_count = patch_vertex_count;
}
void CDECL wined3d_device_get_primitive_type(const struct wined3d_device *device,
enum wined3d_primitive_type *primitive_type, unsigned int *patch_vertex_count)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p, primitive_type %p, patch_vertex_count %p.\n",
device, primitive_type, patch_vertex_count);
- *primitive_type = device->state.primitive_type;
+ *primitive_type = state->primitive_type;
if (patch_vertex_count)
- *patch_vertex_count = device->state.patch_vertex_count;
+ *patch_vertex_count = state->patch_vertex_count;
TRACE("Returning %s.\n", debug_d3dprimitivetype(*primitive_type));
}
HRESULT CDECL wined3d_device_draw_primitive(struct wined3d_device *device, UINT start_vertex, UINT vertex_count)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count);
- wined3d_cs_emit_draw(device->cs, device->state.primitive_type,
- device->state.patch_vertex_count, 0, start_vertex, vertex_count, 0, 0, false);
+ wined3d_cs_emit_draw(device->cs, state->primitive_type,
+ state->patch_vertex_count, 0, start_vertex, vertex_count, 0, 0, false);
return WINED3D_OK;
}
@@ -4163,27 +4244,33 @@ HRESULT CDECL wined3d_device_draw_primitive(struct wined3d_device *device, UINT
void CDECL wined3d_device_draw_primitive_instanced(struct wined3d_device *device,
UINT start_vertex, UINT vertex_count, UINT start_instance, UINT instance_count)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, start_vertex %u, vertex_count %u, start_instance %u, instance_count %u.\n",
device, start_vertex, vertex_count, start_instance, instance_count);
- wined3d_cs_emit_draw(device->cs, device->state.primitive_type, device->state.patch_vertex_count,
+ wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count,
0, start_vertex, vertex_count, start_instance, instance_count, false);
}
void CDECL wined3d_device_draw_primitive_instanced_indirect(struct wined3d_device *device,
struct wined3d_buffer *buffer, unsigned int offset)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
- wined3d_cs_emit_draw_indirect(device->cs, device->state.primitive_type,
- device->state.patch_vertex_count, buffer, offset, false);
+ wined3d_cs_emit_draw_indirect(device->cs, state->primitive_type,
+ state->patch_vertex_count, buffer, offset, false);
}
HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *device, UINT start_idx, UINT index_count)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, start_idx %u, index_count %u.\n", device, start_idx, index_count);
- if (!device->state.index_buffer)
+ if (!state->index_buffer)
{
/* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
* without an index buffer set. (The first time at least...)
@@ -4193,8 +4280,8 @@ HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *devic
return WINED3DERR_INVALIDCALL;
}
- wined3d_cs_emit_draw(device->cs, device->state.primitive_type, device->state.patch_vertex_count,
- device->state.base_vertex_index, start_idx, index_count, 0, 0, true);
+ wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count,
+ state->base_vertex_index, start_idx, index_count, 0, 0, true);
return WINED3D_OK;
}
@@ -4202,20 +4289,24 @@ HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *devic
void CDECL wined3d_device_draw_indexed_primitive_instanced(struct wined3d_device *device,
UINT start_idx, UINT index_count, UINT start_instance, UINT instance_count)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, start_idx %u, index_count %u, start_instance %u, instance_count %u.\n",
device, start_idx, index_count, start_instance, instance_count);
- wined3d_cs_emit_draw(device->cs, device->state.primitive_type, device->state.patch_vertex_count,
- device->state.base_vertex_index, start_idx, index_count, start_instance, instance_count, true);
+ wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count,
+ state->base_vertex_index, start_idx, index_count, start_instance, instance_count, true);
}
void CDECL wined3d_device_draw_indexed_primitive_instanced_indirect(struct wined3d_device *device,
struct wined3d_buffer *buffer, unsigned int offset)
{
+ struct wined3d_state *state = &device->state;
+
TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
- wined3d_cs_emit_draw_indirect(device->cs, device->state.primitive_type,
- device->state.patch_vertex_count, buffer, offset, true);
+ wined3d_cs_emit_draw_indirect(device->cs, state->primitive_type,
+ state->patch_vertex_count, buffer, offset, true);
}
HRESULT CDECL wined3d_device_update_texture(struct wined3d_device *device,
@@ -4418,8 +4509,8 @@ HRESULT CDECL wined3d_device_validate_device(const struct wined3d_device *device
if (wined3d_state_uses_depth_buffer(state)
|| (state->depth_stencil_state && state->depth_stencil_state->desc.stencil))
{
- struct wined3d_rendertarget_view *rt = device->state.fb.render_targets[0];
- struct wined3d_rendertarget_view *ds = device->state.fb.depth_stencil;
+ struct wined3d_rendertarget_view *rt = state->fb.render_targets[0];
+ struct wined3d_rendertarget_view *ds = state->fb.depth_stencil;
if (ds && rt && (ds->width < rt->width || ds->height < rt->height))
{
@@ -4956,6 +5047,7 @@ void CDECL wined3d_device_clear_unordered_access_view_uint(struct wined3d_device
struct wined3d_rendertarget_view * CDECL wined3d_device_get_rendertarget_view(const struct wined3d_device *device,
unsigned int view_idx)
{
+ const struct wined3d_state *state = &device->state;
unsigned int max_rt_count;
TRACE("device %p, view_idx %u.\n", device, view_idx);
@@ -4967,19 +5059,23 @@ struct wined3d_rendertarget_view * CDECL wined3d_device_get_rendertarget_view(co
return NULL;
}
- return device->state.fb.render_targets[view_idx];
+ return state->fb.render_targets[view_idx];
}
struct wined3d_rendertarget_view * CDECL wined3d_device_get_depth_stencil_view(const struct wined3d_device *device)
{
+ const struct wined3d_state *state = &device->state;
+
TRACE("device %p.\n", device);
- return device->state.fb.depth_stencil;
+ return state->fb.depth_stencil;
}
static void wined3d_unbind_srv_for_rtv(struct wined3d_device *device,
const struct wined3d_rendertarget_view *view, BOOL dsv)
{
+ struct wined3d_state *state = &device->state;
+
if (view && wined3d_is_rtv_srv_bound(view))
{
const struct wined3d_resource *resource = view->resource;
@@ -4990,7 +5086,7 @@ static void wined3d_unbind_srv_for_rtv(struct wined3d_device *device,
for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
for (j = 0; j < MAX_SHADER_RESOURCE_VIEWS; ++j)
- if ((srv = device->state.shader_resource_view[i][j]) && srv->resource == resource
+ if ((srv = state->shader_resource_view[i][j]) && srv->resource == resource
&& ((!dsv && wined3d_is_srv_rtv_bound(srv))
|| (dsv && wined3d_dsv_srv_conflict(view, srv->format))))
wined3d_device_set_shader_resource_view(device, i, j, NULL);
@@ -5000,6 +5096,7 @@ static void wined3d_unbind_srv_for_rtv(struct wined3d_device *device,
HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device,
unsigned int view_idx, struct wined3d_rendertarget_view *view, BOOL set_viewport)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_rendertarget_view *prev;
unsigned int max_rt_count;
@@ -5040,7 +5137,7 @@ HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device
wined3d_cs_emit_set_scissor_rects(device->cs, 1, state->scissor_rects);
}
- prev = device->state.fb.render_targets[view_idx];
+ prev = state->fb.render_targets[view_idx];
if (view == prev)
return WINED3D_OK;
@@ -5049,7 +5146,7 @@ HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device
wined3d_rendertarget_view_incref(view);
wined3d_rtv_bind_count_inc(view);
}
- device->state.fb.render_targets[view_idx] = view;
+ state->fb.render_targets[view_idx] = view;
wined3d_cs_emit_set_rendertarget_view(device->cs, view_idx, view);
/* Release after the assignment, to prevent device_resource_released()
* from seeing the surface as still in use. */
@@ -5067,6 +5164,7 @@ HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device
HRESULT CDECL wined3d_device_set_depth_stencil_view(struct wined3d_device *device,
struct wined3d_rendertarget_view *view)
{
+ struct wined3d_state *state = &device->state;
struct wined3d_rendertarget_view *prev;
TRACE("device %p, view %p.\n", device, view);
@@ -5078,14 +5176,14 @@ HRESULT CDECL wined3d_device_set_depth_stencil_view(struct wined3d_device *devic
return WINED3DERR_INVALIDCALL;
}
- prev = device->state.fb.depth_stencil;
+ prev = state->fb.depth_stencil;
if (prev == view)
{
TRACE("Trying to do a NOP SetRenderTarget operation.\n");
return WINED3D_OK;
}
- if ((device->state.fb.depth_stencil = view))
+ if ((state->fb.depth_stencil = view))
wined3d_rendertarget_view_incref(view);
wined3d_cs_emit_set_depth_stencil_view(device->cs, view);
if (prev)
@@ -5341,6 +5439,7 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
struct wined3d_swapchain_state *swapchain_state;
struct wined3d_swapchain_desc *current_desc;
+ struct wined3d_state *state = &device->state;
struct wined3d_resource *resource, *cursor;
struct wined3d_rendertarget_view *view;
struct wined3d_swapchain *swapchain;
@@ -5374,7 +5473,7 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
wined3d_texture_decref(device->cursor_texture);
device->cursor_texture = NULL;
}
- state_unbind_resources(&device->state);
+ state_unbind_resources(state);
}
for (i = 0; i < d3d_info->limits.max_rt_count; ++i)
@@ -5584,7 +5683,7 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
{
TRACE("Resetting state.\n");
wined3d_cs_emit_reset_state(device->cs);
- state_cleanup(&device->state);
+ state_cleanup(state);
LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
{
@@ -5594,8 +5693,8 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
device->adapter->adapter_ops->adapter_uninit_3d(device);
- memset(&device->state, 0, sizeof(device->state));
- state_init(&device->state, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
+ memset(state, 0, sizeof(*state));
+ state_init(state, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
device_init_swapchain_state(device, swapchain);
if (wined3d_settings.logo)
@@ -5695,18 +5794,19 @@ static void device_resource_remove(struct wined3d_device *device, struct wined3d
void device_resource_released(struct wined3d_device *device, struct wined3d_resource *resource)
{
enum wined3d_resource_type type = resource->type;
+ struct wined3d_state *state = &device->state;
struct wined3d_rendertarget_view *rtv;
unsigned int i;
TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type));
- for (i = 0; i < ARRAY_SIZE(device->state.fb.render_targets); ++i)
+ for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i)
{
- if ((rtv = device->state.fb.render_targets[i]) && rtv->resource == resource)
+ if ((rtv = state->fb.render_targets[i]) && rtv->resource == resource)
ERR("Resource %p is still in use as render target %u.\n", resource, i);
}
- if ((rtv = device->state.fb.depth_stencil) && rtv->resource == resource)
+ if ((rtv = state->fb.depth_stencil) && rtv->resource == resource)
ERR("Resource %p is still in use as depth/stencil buffer.\n", resource);
switch (type)
@@ -5716,10 +5816,10 @@ void device_resource_released(struct wined3d_device *device, struct wined3d_reso
case WINED3D_RTYPE_TEXTURE_3D:
for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
{
- if (&device->state.textures[i]->resource == resource)
+ if (&state->textures[i]->resource == resource)
{
ERR("Texture resource %p is still in use, stage %u.\n", resource, i);
- device->state.textures[i] = NULL;
+ state->textures[i] = NULL;
}
}
break;
@@ -5727,17 +5827,17 @@ void device_resource_released(struct wined3d_device *device, struct wined3d_reso
case WINED3D_RTYPE_BUFFER:
for (i = 0; i < WINED3D_MAX_STREAMS; ++i)
{
- if (&device->state.streams[i].buffer->resource == resource)
+ if (&state->streams[i].buffer->resource == resource)
{
ERR("Buffer resource %p is still in use, stream %u.\n", resource, i);
- device->state.streams[i].buffer = NULL;
+ state->streams[i].buffer = NULL;
}
}
- if (&device->state.index_buffer->resource == resource)
+ if (&state->index_buffer->resource == resource)
{
ERR("Buffer resource %p is still in use as index buffer.\n", resource);
- device->state.index_buffer = NULL;
+ state->index_buffer = NULL;
}
break;
@@ -5852,6 +5952,7 @@ HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined
struct wined3d_adapter *adapter = wined3d->adapters[adapter_idx];
const struct wined3d_fragment_pipe_ops *fragment_pipeline;
const struct wined3d_vertex_pipe_ops *vertex_pipeline;
+ struct wined3d_state *state = &device->state;
unsigned int i;
HRESULT hr;
@@ -5902,14 +6003,14 @@ HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined
return hr;
}
- state_init(&device->state, &adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
+ state_init(state, &adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
device->max_frame_latency = 3;
if (!(device->cs = wined3d_cs_create(device)))
{
WARN("Failed to create command stream.\n");
- state_cleanup(&device->state);
+ state_cleanup(state);
hr = E_FAIL;
goto err;
}
diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c
index f4f929db2ca..40b25c6f229 100644
--- a/dlls/wined3d/texture.c
+++ b/dlls/wined3d/texture.c
@@ -1602,6 +1602,7 @@ DWORD CDECL wined3d_texture_set_lod(struct wined3d_texture *texture, DWORD lod)
if (texture->lod != lod)
{
struct wined3d_device *device = resource->device;
+ struct wined3d_state *state = &device->state;
wined3d_resource_wait_idle(resource);
texture->lod = lod;
@@ -1610,7 +1611,7 @@ DWORD CDECL wined3d_texture_set_lod(struct wined3d_texture *texture, DWORD lod)
wined3d_texture_gl(texture)->texture_srgb.base_level = ~0u;
if (resource->bind_count)
wined3d_cs_emit_set_sampler_state(device->cs, texture->sampler, WINED3D_SAMP_MAX_MIP_LEVEL,
- device->state.sampler_states[texture->sampler][WINED3D_SAMP_MAX_MIP_LEVEL]);
+ state->sampler_states[texture->sampler][WINED3D_SAMP_MAX_MIP_LEVEL]);
}
return old;
--
2.30.0
More information about the wine-devel
mailing list