[PATCH v3 3/3] wined3d: Fully move the depth buffer enable state to wined3d_depth_stencil_state.
Zebediah Figura
z.figura12 at gmail.com
Thu Sep 24 22:43:13 CDT 2020
Signed-off-by: Zebediah Figura <z.figura12 at gmail.com>
---
dlls/d3d11/device.c | 2 --
dlls/wined3d/adapter_vk.c | 31 +++++++++++------------
dlls/wined3d/context_gl.c | 2 +-
dlls/wined3d/context_vk.c | 13 ++++++++--
dlls/wined3d/cs.c | 2 +-
dlls/wined3d/device.c | 46 +++++++++++++++++++++++++++++++++-
dlls/wined3d/directx.c | 1 -
dlls/wined3d/state.c | 39 +---------------------------
dlls/wined3d/utils.c | 4 +--
dlls/wined3d/wined3d_private.h | 3 ++-
10 files changed, 78 insertions(+), 65 deletions(-)
diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c
index 055e243a439..ca9975d6a22 100644
--- a/dlls/d3d11/device.c
+++ b/dlls/d3d11/device.c
@@ -726,7 +726,6 @@ static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetBlendState(ID3D11Devi
static void set_default_depth_stencil_state(struct wined3d_device *wined3d_device)
{
- wined3d_device_set_render_state(wined3d_device, WINED3D_RS_ZENABLE, TRUE);
wined3d_device_set_render_state(wined3d_device, WINED3D_RS_ZWRITEENABLE, D3D11_DEPTH_WRITE_MASK_ALL);
wined3d_device_set_render_state(wined3d_device, WINED3D_RS_ZFUNC, WINED3D_CMP_LESS);
wined3d_device_set_render_state(wined3d_device, WINED3D_RS_STENCILENABLE, FALSE);
@@ -759,7 +758,6 @@ static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetDepthStencilState(ID3
front = &desc->FrontFace;
back = &desc->BackFace;
- wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, desc->DepthEnable);
if (desc->DepthEnable)
{
wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZWRITEENABLE, desc->DepthWriteMask);
diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c
index f3a8d8f89db..7b0c0c89897 100644
--- a/dlls/wined3d/adapter_vk.c
+++ b/dlls/wined3d/adapter_vk.c
@@ -100,16 +100,15 @@ static const struct wined3d_state_entry_template misc_state_template_vk[] =
{STATE_INDEXBUFFER, {STATE_INDEXBUFFER, state_nop}},
{STATE_RENDER(WINED3D_RS_ANTIALIAS), {STATE_RENDER(WINED3D_RS_ANTIALIAS), state_nop}},
{STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), {STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), state_nop}},
- {STATE_RENDER(WINED3D_RS_ZENABLE), {STATE_RENDER(WINED3D_RS_ZENABLE), state_nop}},
{STATE_RENDER(WINED3D_RS_WRAPU), {STATE_RENDER(WINED3D_RS_WRAPU), state_nop}},
{STATE_RENDER(WINED3D_RS_WRAPV), {STATE_RENDER(WINED3D_RS_WRAPV), state_nop}},
{STATE_RENDER(WINED3D_RS_LINEPATTERN), {STATE_RENDER(WINED3D_RS_LINEPATTERN), state_nop}},
{STATE_RENDER(WINED3D_RS_MONOENABLE), {STATE_RENDER(WINED3D_RS_MONOENABLE), state_nop}},
{STATE_RENDER(WINED3D_RS_ROP2), {STATE_RENDER(WINED3D_RS_ROP2), state_nop}},
{STATE_RENDER(WINED3D_RS_PLANEMASK), {STATE_RENDER(WINED3D_RS_PLANEMASK), state_nop}},
- {STATE_RENDER(WINED3D_RS_ZWRITEENABLE), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
+ {STATE_RENDER(WINED3D_RS_ZWRITEENABLE), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE), state_nop}},
{STATE_RENDER(WINED3D_RS_LASTPIXEL), {STATE_RENDER(WINED3D_RS_LASTPIXEL), state_nop}},
- {STATE_RENDER(WINED3D_RS_ZFUNC), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
+ {STATE_RENDER(WINED3D_RS_ZFUNC), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
{STATE_RENDER(WINED3D_RS_DITHERENABLE), {STATE_RENDER(WINED3D_RS_DITHERENABLE), state_nop}},
{STATE_RENDER(WINED3D_RS_SUBPIXEL), {STATE_RENDER(WINED3D_RS_SUBPIXEL), state_nop}},
{STATE_RENDER(WINED3D_RS_SUBPIXELX), {STATE_RENDER(WINED3D_RS_SUBPIXELX), state_nop}},
@@ -119,19 +118,19 @@ static const struct wined3d_state_entry_template misc_state_template_vk[] =
{STATE_RENDER(WINED3D_RS_ANISOTROPY), {STATE_RENDER(WINED3D_RS_ANISOTROPY), state_nop}},
{STATE_RENDER(WINED3D_RS_FLUSHBATCH), {STATE_RENDER(WINED3D_RS_FLUSHBATCH), state_nop}},
{STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT), {STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT), state_nop}},
- {STATE_RENDER(WINED3D_RS_STENCILENABLE), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILFAIL), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILZFAIL), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILPASS), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILFUNC), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILREF), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILMASK), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_BACK_STENCILFAIL), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_BACK_STENCILZFAIL), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_BACK_STENCILPASS), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
- {STATE_RENDER(WINED3D_RS_BACK_STENCILFUNC), {STATE_RENDER(WINED3D_RS_ZENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILENABLE), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILFAIL), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILZFAIL), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILPASS), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILFUNC), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILREF), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILMASK), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_BACK_STENCILFAIL), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_BACK_STENCILZFAIL), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_BACK_STENCILPASS), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
+ {STATE_RENDER(WINED3D_RS_BACK_STENCILFUNC), {STATE_RENDER(WINED3D_RS_ZWRITEENABLE)}},
{STATE_RENDER(WINED3D_RS_WRAP0), {STATE_RENDER(WINED3D_RS_WRAP0), state_nop}},
{STATE_RENDER(WINED3D_RS_WRAP1), {STATE_RENDER(WINED3D_RS_WRAP0)}},
{STATE_RENDER(WINED3D_RS_WRAP2), {STATE_RENDER(WINED3D_RS_WRAP0)}},
diff --git a/dlls/wined3d/context_gl.c b/dlls/wined3d/context_gl.c
index e3eae3aab58..186d70b45ad 100644
--- a/dlls/wined3d/context_gl.c
+++ b/dlls/wined3d/context_gl.c
@@ -2818,7 +2818,7 @@ void wined3d_context_gl_apply_blit_state(struct wined3d_context_gl *context_gl,
context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHATESTENABLE));
}
gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_TEST);
- context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZENABLE));
+ context_invalidate_state(context, STATE_DEPTH_STENCIL);
gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
gl_info->gl_ops.gl.p_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
context_invalidate_state(context, STATE_BLEND);
diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c
index a4f5f317f1f..356fec27a78 100644
--- a/dlls/wined3d/context_vk.c
+++ b/dlls/wined3d/context_vk.c
@@ -2034,10 +2034,19 @@ static bool wined3d_context_vk_update_graphics_pipeline_key(struct wined3d_conte
update = true;
}
- if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_RENDER(WINED3D_RS_ZENABLE))
+ if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_DEPTH_STENCIL)
|| wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER))
{
- key->ds_desc.depthTestEnable = !!state->render_states[WINED3D_RS_ZENABLE];
+ const struct wined3d_depth_stencil_state *d = state->depth_stencil_state;
+
+ if (d)
+ {
+ key->ds_desc.depthTestEnable = d->desc.depth;
+ }
+ else
+ {
+ key->ds_desc.depthTestEnable = VK_TRUE;
+ }
key->ds_desc.depthWriteEnable = !!state->render_states[WINED3D_RS_ZWRITEENABLE];
key->ds_desc.depthCompareOp = vk_compare_op_from_wined3d(state->render_states[WINED3D_RS_ZFUNC]);
key->ds_desc.stencilTestEnable = state->fb.depth_stencil && state->render_states[WINED3D_RS_STENCILENABLE];
diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c
index d6a78cc5d65..6509887afa9 100644
--- a/dlls/wined3d/cs.c
+++ b/dlls/wined3d/cs.c
@@ -1226,7 +1226,7 @@ static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const
if (!prev != !op->view)
{
/* Swapping NULL / non NULL depth stencil affects the depth and tests */
- device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
+ device_invalidate_state(device, STATE_DEPTH_STENCIL);
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
device_invalidate_state(device, STATE_RASTERIZER);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index a59a1efeab7..38b488cba81 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -3576,10 +3576,10 @@ static void wined3d_device_set_texture(struct wined3d_device *device,
void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device,
struct wined3d_stateblock *stateblock)
{
+ BOOL set_blend_state = FALSE, set_depth_stencil_state = FALSE, set_rasterizer_state = FALSE;
const struct wined3d_stateblock_state *state = &stateblock->stateblock_state;
const struct wined3d_saved_states *changed = &stateblock->changed;
const unsigned int word_bit_count = sizeof(DWORD) * CHAR_BIT;
- BOOL set_blend_state = FALSE, set_rasterizer_state = FALSE;
unsigned int i, j, start, idx;
struct wined3d_range range;
uint32_t map;
@@ -3684,6 +3684,10 @@ void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device,
set_blend_state = TRUE;
break;
+ case WINED3D_RS_ZENABLE:
+ set_depth_stencil_state = TRUE;
+ break;
+
case WINED3D_RS_FILLMODE:
case WINED3D_RS_CULLMODE:
case WINED3D_RS_SLOPESCALEDEPTHBIAS:
@@ -3812,6 +3816,46 @@ void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device,
}
}
+ if (set_depth_stencil_state)
+ {
+ struct wined3d_depth_stencil_state *depth_stencil_state;
+ struct wined3d_depth_stencil_state_desc desc;
+ struct wine_rb_entry *entry;
+
+ memset(&desc, 0, sizeof(desc));
+ switch (state->rs[WINED3D_RS_ZENABLE])
+ {
+ case WINED3D_ZB_FALSE:
+ desc.depth = FALSE;
+ break;
+
+ case WINED3D_ZB_USEW:
+ FIXME("W buffer is not well handled.\n");
+ case WINED3D_ZB_TRUE:
+ desc.depth = TRUE;
+ break;
+
+ default:
+ FIXME("Unrecognized depth buffer type %#x.\n", state->rs[WINED3D_RS_ZENABLE]);
+ }
+
+ if ((entry = wine_rb_get(&device->depth_stencil_states, &desc)))
+ {
+ depth_stencil_state = WINE_RB_ENTRY_VALUE(entry, struct wined3d_depth_stencil_state, entry);
+ wined3d_device_set_depth_stencil_state(device, depth_stencil_state);
+ }
+ else if (SUCCEEDED(wined3d_depth_stencil_state_create(device, &desc, NULL,
+ &wined3d_null_parent_ops, &depth_stencil_state)))
+ {
+ wined3d_device_set_depth_stencil_state(device, depth_stencil_state);
+ if (wine_rb_put(&device->depth_stencil_states, &desc, &depth_stencil_state->entry) == -1)
+ {
+ ERR("Failed to insert depth/stencil state.\n");
+ wined3d_depth_stencil_state_decref(depth_stencil_state);
+ }
+ }
+ }
+
for (i = 0; i < ARRAY_SIZE(changed->textureState); ++i)
{
map = changed->textureState[i];
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index cd05c264645..fced1eb110c 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -2422,7 +2422,6 @@ static const struct wined3d_state_entry_template misc_state_template_no3d[] =
{STATE_INDEXBUFFER, {STATE_VDECL}},
{STATE_RENDER(WINED3D_RS_ANTIALIAS), {STATE_VDECL}},
{STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), {STATE_VDECL}},
- {STATE_RENDER(WINED3D_RS_ZENABLE), {STATE_VDECL}},
{STATE_RENDER(WINED3D_RS_WRAPU), {STATE_VDECL}},
{STATE_RENDER(WINED3D_RS_WRAPV), {STATE_VDECL}},
{STATE_RENDER(WINED3D_RS_LINEPATTERN), {STATE_VDECL}},
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index ac3afe881d6..d77722c00d4 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -291,42 +291,6 @@ static void state_lighting(struct wined3d_context *context, const struct wined3d
}
}
-static void state_zenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
-{
- enum wined3d_depth_buffer_type zenable = state->render_states[WINED3D_RS_ZENABLE];
- const struct wined3d_gl_info *gl_info = wined3d_context_gl(context)->gl_info;
-
- /* No z test without depth stencil buffers */
- if (!state->fb.depth_stencil)
- {
- TRACE("No Z buffer - disabling depth test\n");
- zenable = WINED3D_ZB_FALSE;
- }
-
- switch (zenable)
- {
- case WINED3D_ZB_FALSE:
- gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_TEST);
- checkGLcall("glDisable GL_DEPTH_TEST");
- break;
- case WINED3D_ZB_TRUE:
- gl_info->gl_ops.gl.p_glEnable(GL_DEPTH_TEST);
- checkGLcall("glEnable GL_DEPTH_TEST");
- break;
- case WINED3D_ZB_USEW:
- gl_info->gl_ops.gl.p_glEnable(GL_DEPTH_TEST);
- checkGLcall("glEnable GL_DEPTH_TEST");
- FIXME("W buffer is not well handled\n");
- break;
- default:
- FIXME("Unrecognized depth buffer type %#x.\n", zenable);
- break;
- }
-
- if (context->last_was_rhw && !isStateDirty(context, STATE_TRANSFORM(WINED3D_TS_PROJECTION)))
- context_apply_state(context, state, STATE_TRANSFORM(WINED3D_TS_PROJECTION));
-}
-
static void cullmode(const struct wined3d_rasterizer_state *r, const struct wined3d_gl_info *gl_info)
{
enum wined3d_cull mode = r ? r->desc.cull_mode : WINED3D_CULL_BACK;
@@ -4780,7 +4744,6 @@ const struct wined3d_state_entry_template misc_state_template_gl[] =
{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, state_nop }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ANTIALIAS), { STATE_RENDER(WINED3D_RS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), state_nop }, WINED3D_GL_EXT_NONE },
- { STATE_RENDER(WINED3D_RS_ZENABLE), { STATE_RENDER(WINED3D_RS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_WRAPU), { STATE_RENDER(WINED3D_RS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_WRAPV), { STATE_RENDER(WINED3D_RS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_LINEPATTERN), { STATE_RENDER(WINED3D_RS_LINEPATTERN), state_linepattern }, WINED3D_GL_LEGACY_CONTEXT },
@@ -5605,7 +5568,7 @@ static void validate_state_table(struct wined3d_state_entry *state_table)
{
{ 1, 1},
{ 3, 3},
- { 8, 8},
+ { 7, 8},
{ 17, 22},
{ 27, 27},
{ 40, 40},
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 8d790c52945..01a838db897 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -5446,8 +5446,8 @@ void get_projection_matrix(const struct wined3d_context *context, const struct w
float y_offset = flip
? (center_offset - (2.0f * y) - h) / h
: (center_offset - (2.0f * y) - h) / -h;
- enum wined3d_depth_buffer_type zenable = state->fb.depth_stencil ?
- state->render_states[WINED3D_RS_ZENABLE] : WINED3D_ZB_FALSE;
+ bool zenable = state->fb.depth_stencil ?
+ (state->depth_stencil_state ? state->depth_stencil_state->desc.depth : true) : false;
float z_scale = zenable ? clip_control ? 1.0f : 2.0f : 0.0f;
float z_offset = zenable ? clip_control ? 0.0f : -1.0f : 0.0f;
const struct wined3d_matrix projection =
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 177d4d01337..da3974973a1 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -3643,7 +3643,8 @@ struct wined3d_state
static inline bool wined3d_state_uses_depth_buffer(const struct wined3d_state *state)
{
- return state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE];
+ return state->render_states[WINED3D_RS_ZWRITEENABLE]
+ || !state->depth_stencil_state || state->depth_stencil_state->desc.depth;
}
struct wined3d_dummy_textures
--
2.28.0
More information about the wine-devel
mailing list