ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Use rendertarget views for depth/stencil buffers instead of surfaces. 

I don't think the difference between d3d10 depth/stencil and rendertarget
views is large enough to justify a separate type. Unfortunately that does make
the name "wined3d_rendertarget_view" slightly awkward.
This commit is contained in:
Henri Verbeet 2014-08-22 12:32:01 +02:00 committed by Alexandre Julliard
parent 9f9731410b
commit 07985a8c38
14 changed files with 181 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
dlls/d3d8/device.c
View File

@ -1127,7 +1127,7 @@ static HRESULT WINAPI d3d8_device_SetRenderTarget(IDirect3DDevice8 *iface,
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_surface *rt_impl = unsafe_impl_from_IDirect3DSurface8(render_target);
struct d3d8_surface *ds_impl = unsafe_impl_from_IDirect3DSurface8(depth_stencil);
struct wined3d_surface *original_ds = NULL;
struct wined3d_rendertarget_view *original_dsv;
HRESULT hr = D3D_OK;
TRACE("iface %p, render_target %p, depth_stencil %p.\n", iface, render_target, depth_stencil);
@ -1168,11 +1168,12 @@ static HRESULT WINAPI d3d8_device_SetRenderTarget(IDirect3DDevice8 *iface,
}
}
original_ds = wined3d_device_get_depth_stencil(device->wined3d_device);
wined3d_device_set_depth_stencil(device->wined3d_device, ds_impl ? ds_impl->wined3d_surface : NULL);
original_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device);
wined3d_device_set_depth_stencil_view(device->wined3d_device,
ds_impl ? d3d8_surface_get_rendertarget_view(ds_impl) : NULL);
if (render_target && FAILED(hr = wined3d_device_set_rendertarget_view(device->wined3d_device, 0,
d3d8_surface_get_rendertarget_view(rt_impl), TRUE)))
wined3d_device_set_depth_stencil(device->wined3d_device, original_ds);
wined3d_device_set_depth_stencil_view(device->wined3d_device, original_dsv);
wined3d_mutex_unlock();
@ -1215,7 +1216,7 @@ static HRESULT WINAPI d3d8_device_GetRenderTarget(IDirect3DDevice8 *iface, IDire
static HRESULT WINAPI d3d8_device_GetDepthStencilSurface(IDirect3DDevice8 *iface, IDirect3DSurface8 **depth_stencil)
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct wined3d_surface *wined3d_surface;
struct wined3d_rendertarget_view *wined3d_dsv;
struct d3d8_surface *surface_impl;
HRESULT hr = D3D_OK;
@ -1225,9 +1226,11 @@ static HRESULT WINAPI d3d8_device_GetDepthStencilSurface(IDirect3DDevice8 *iface
return D3DERR_INVALIDCALL;
wined3d_mutex_lock();
if ((wined3d_surface = wined3d_device_get_depth_stencil(device->wined3d_device)))
if ((wined3d_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device)))
{
surface_impl = wined3d_surface_get_parent(wined3d_surface);
/* We want the sub resource parent here, since the view itself may be
* internal to wined3d and may not have a parent. */
surface_impl = wined3d_rendertarget_view_get_sub_resource_parent(wined3d_dsv);
*depth_stencil = &surface_impl->IDirect3DSurface8_iface;
IDirect3DSurface8_AddRef(*depth_stencil);
}

11
dlls/d3d9/device.c
View File

@ -1397,7 +1397,8 @@ static HRESULT WINAPI d3d9_device_SetDepthStencilSurface(IDirect3DDevice9Ex *ifa
TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil);
wined3d_mutex_lock();
wined3d_device_set_depth_stencil(device->wined3d_device, ds_impl ? ds_impl->wined3d_surface : NULL);
wined3d_device_set_depth_stencil_view(device->wined3d_device,
ds_impl ? d3d9_surface_get_rendertarget_view(ds_impl) : NULL);
wined3d_mutex_unlock();
return D3D_OK;
@ -1406,7 +1407,7 @@ static HRESULT WINAPI d3d9_device_SetDepthStencilSurface(IDirect3DDevice9Ex *ifa
static HRESULT WINAPI d3d9_device_GetDepthStencilSurface(IDirect3DDevice9Ex *iface, IDirect3DSurface9 **depth_stencil)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
struct wined3d_surface *wined3d_surface;
struct wined3d_rendertarget_view *wined3d_dsv;
struct d3d9_surface *surface_impl;
HRESULT hr = D3D_OK;
@ -1416,9 +1417,11 @@ static HRESULT WINAPI d3d9_device_GetDepthStencilSurface(IDirect3DDevice9Ex *ifa
return D3DERR_INVALIDCALL;
wined3d_mutex_lock();
if ((wined3d_surface = wined3d_device_get_depth_stencil(device->wined3d_device)))
if ((wined3d_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device)))
{
surface_impl = wined3d_surface_get_parent(wined3d_surface);
/* We want the sub resource parent here, since the view itself may be
* internal to wined3d and may not have a parent. */
surface_impl = wined3d_rendertarget_view_get_sub_resource_parent(wined3d_dsv);
*depth_stencil = &surface_impl->IDirect3DSurface9_iface;
IDirect3DSurface9_AddRef(*depth_stencil);
}

13
dlls/ddraw/ddraw.c
View File

@ -767,9 +767,8 @@ static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
static HRESULT ddraw_set_cooperative_level(struct ddraw *ddraw, HWND window,
DWORD cooplevel, BOOL restore_mode_on_normal)
{
struct wined3d_rendertarget_view *rtv = NULL;
struct wined3d_rendertarget_view *rtv = NULL, *dsv = NULL;
struct wined3d_stateblock *stateblock;
struct wined3d_surface *ds = NULL;
BOOL restore_state = FALSE;
HRESULT hr;
@ -926,8 +925,8 @@ static HRESULT ddraw_set_cooperative_level(struct ddraw *ddraw, HWND window,
else if (rtv)
wined3d_rendertarget_view_incref(rtv);
if ((ds = wined3d_device_get_depth_stencil(ddraw->wined3d_device)))
wined3d_surface_incref(ds);
if ((dsv = wined3d_device_get_depth_stencil_view(ddraw->wined3d_device)))
wined3d_rendertarget_view_incref(dsv);
}
ddraw_destroy_swapchain(ddraw);
@ -938,10 +937,10 @@ static HRESULT ddraw_set_cooperative_level(struct ddraw *ddraw, HWND window,
if (restore_state)
{
if (ds)
if (dsv)
{
wined3d_device_set_depth_stencil(ddraw->wined3d_device, ds);
wined3d_surface_decref(ds);
wined3d_device_set_depth_stencil_view(ddraw->wined3d_device, dsv);
wined3d_rendertarget_view_decref(dsv);
}
if (rtv)

6
dlls/ddraw/device.c
View File

@ -6759,13 +6759,13 @@ enum wined3d_depth_buffer_type d3d_device_update_depth_stencil(struct d3d_device
if (!depthStencil)
{
TRACE("Setting wined3d depth stencil to NULL\n");
wined3d_device_set_depth_stencil(device->wined3d_device, NULL);
wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
return WINED3D_ZB_FALSE;
}
dsi = impl_from_IDirectDrawSurface7(depthStencil);
TRACE("Setting wined3d depth stencil to %p (wined3d %p)\n", dsi, dsi->wined3d_surface);
wined3d_device_set_depth_stencil(device->wined3d_device, dsi->wined3d_surface);
wined3d_device_set_depth_stencil_view(device->wined3d_device,
ddraw_surface_get_rendertarget_view(dsi));
IDirectDrawSurface7_Release(depthStencil);
return WINED3D_ZB_TRUE;

14
dlls/wined3d/context.c
View File

@ -2201,13 +2201,13 @@ static BOOL match_depth_stencil_format(const struct wined3d_format *existing,
/* The caller provides a context */
static void context_validate_onscreen_formats(struct wined3d_context *context,
const struct wined3d_surface *depth_stencil)
const struct wined3d_rendertarget_view *depth_stencil)
{
/* Onscreen surfaces are always in a swapchain */
struct wined3d_swapchain *swapchain = context->current_rt->container->swapchain;
if (context->render_offscreen || !depth_stencil) return;
if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->resource.format)) return;
if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->format)) return;
/* TODO: If the requested format would satisfy the needs of the existing one(reverse match),
* or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new
@ -2280,8 +2280,8 @@ void context_apply_blit_state(struct wined3d_context *context, const struct wine
context_invalidate_state(context, STATE_FRAMEBUFFER);
}
static BOOL context_validate_rt_config(UINT rt_count,
struct wined3d_rendertarget_view * const *rts, const struct wined3d_surface *ds)
static BOOL context_validate_rt_config(UINT rt_count, struct wined3d_rendertarget_view * const *rts,
const struct wined3d_rendertarget_view *ds)
{
unsigned int i;
@ -2329,7 +2329,8 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win
context->blit_targets[i] = NULL;
++i;
}
context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, fb->depth_stencil,
context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets,
wined3d_rendertarget_view_get_surface(fb->depth_stencil),
rt_count ? rts[0]->resource->draw_binding : WINED3D_LOCATION_TEXTURE_RGB);
}
else
@ -2446,7 +2447,8 @@ void context_state_fb(struct wined3d_context *context, const struct wined3d_stat
{
context->blit_targets[i] = wined3d_rendertarget_view_get_surface(fb->render_targets[i]);
}
context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, fb->depth_stencil,
context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets,
wined3d_rendertarget_view_get_surface(fb->depth_stencil),
fb->render_targets[0]->resource->draw_binding);
}
}

39
dlls/wined3d/cs.c
View File

@ -32,7 +32,7 @@ enum wined3d_cs_op
WINED3D_CS_OP_SET_VIEWPORT,
WINED3D_CS_OP_SET_SCISSOR_RECT,
WINED3D_CS_OP_SET_RENDERTARGET_VIEW,
WINED3D_CS_OP_SET_DEPTH_STENCIL,
WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
WINED3D_CS_OP_SET_VERTEX_DECLARATION,
WINED3D_CS_OP_SET_STREAM_SOURCE,
WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
@ -102,10 +102,10 @@ struct wined3d_cs_set_rendertarget_view
struct wined3d_rendertarget_view *view;
};
struct wined3d_cs_set_depth_stencil
struct wined3d_cs_set_depth_stencil_view
{
enum wined3d_cs_op opcode;
struct wined3d_surface *depth_stencil;
struct wined3d_rendertarget_view *view;
};
struct wined3d_cs_set_vertex_declaration
@ -367,20 +367,21 @@ void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int v
cs->ops->submit(cs);
}
static void wined3d_cs_exec_set_depth_stencil(struct wined3d_cs *cs, const void *data)
static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
{
const struct wined3d_cs_set_depth_stencil *op = data;
const struct wined3d_cs_set_depth_stencil_view *op = data;
struct wined3d_device *device = cs->device;
struct wined3d_surface *prev;
struct wined3d_rendertarget_view *prev;
if ((prev = cs->state.fb->depth_stencil))
{
if (device->swapchains[0]->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| prev->flags & SFLAG_DISCARD)
struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
if (prev_surface && (device->swapchains[0]->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| prev_surface->flags & SFLAG_DISCARD))
{
surface_modify_ds_location(prev, WINED3D_LOCATION_DISCARDED,
prev->resource.width, prev->resource.height);
if (prev == device->onscreen_depth_stencil)
surface_modify_ds_location(prev_surface, WINED3D_LOCATION_DISCARDED, prev->width, prev->height);
if (prev_surface == device->onscreen_depth_stencil)
{
wined3d_surface_decref(device->onscreen_depth_stencil);
device->onscreen_depth_stencil = NULL;
@ -388,9 +389,9 @@ static void wined3d_cs_exec_set_depth_stencil(struct wined3d_cs *cs, const void
}
}
cs->fb.depth_stencil = op->depth_stencil;
cs->fb.depth_stencil = op->view;
if (!prev != !op->depth_stencil)
if (!prev != !op->view)
{
/* Swapping NULL / non NULL depth stencil affects the depth and tests */
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
@ -398,7 +399,7 @@ static void wined3d_cs_exec_set_depth_stencil(struct wined3d_cs *cs, const void
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
}
else if (prev && prev->resource.format->depth_size != op->depth_stencil->resource.format->depth_size)
else if (prev && prev->format->depth_size != op->view->format->depth_size)
{
device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
}
@ -406,13 +407,13 @@ static void wined3d_cs_exec_set_depth_stencil(struct wined3d_cs *cs, const void
device_invalidate_state(device, STATE_FRAMEBUFFER);
}
void wined3d_cs_emit_set_depth_stencil(struct wined3d_cs *cs, struct wined3d_surface *depth_stencil)
void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
{
struct wined3d_cs_set_depth_stencil *op;
struct wined3d_cs_set_depth_stencil_view *op;
op = cs->ops->require_space(cs, sizeof(*op));
op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL;
op->depth_stencil = depth_stencil;
op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
op->view = view;
cs->ops->submit(cs);
}
@ -852,7 +853,7 @@ static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void
/* WINED3D_CS_OP_SET_VIEWPORT */ wined3d_cs_exec_set_viewport,
/* WINED3D_CS_OP_SET_SCISSOR_RECT */ wined3d_cs_exec_set_scissor_rect,
/* WINED3D_CS_OP_SET_RENDERTARGET_VIEW */ wined3d_cs_exec_set_rendertarget_view,
/* WINED3D_CS_OP_SET_DEPTH_STENCIL */ wined3d_cs_exec_set_depth_stencil,
/* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW */ wined3d_cs_exec_set_depth_stencil_view,
/* WINED3D_CS_OP_SET_VERTEX_DECLARATION */ wined3d_cs_exec_set_vertex_declaration,
/* WINED3D_CS_OP_SET_STREAM_SOURCE */ wined3d_cs_exec_set_stream_source,
/* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq,

151
dlls/wined3d/device.c
View File

@ -287,6 +287,8 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c
float depth, DWORD stencil)
{
struct wined3d_surface *target = rt_count ? wined3d_rendertarget_view_get_surface(fb->render_targets[0]) : NULL;
struct wined3d_surface *depth_stencil = fb->depth_stencil
? wined3d_rendertarget_view_get_surface(fb->depth_stencil) : NULL;
const RECT *clear_rect = (rect_count > 0 && rects) ? (const RECT *)rects : NULL;
const struct wined3d_gl_info *gl_info;
UINT drawable_width, drawable_height;
@ -331,18 +333,17 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c
else
{
render_offscreen = TRUE;
drawable_width = fb->depth_stencil->pow2Width;
drawable_height = fb->depth_stencil->pow2Height;
drawable_width = depth_stencil->pow2Width;
drawable_height = depth_stencil->pow2Height;
}
if (flags & WINED3DCLEAR_ZBUFFER)
{
DWORD location = render_offscreen ? fb->depth_stencil->container->resource.draw_binding
: WINED3D_LOCATION_DRAWABLE;
DWORD location = render_offscreen ? fb->depth_stencil->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
if (!render_offscreen && fb->depth_stencil != device->onscreen_depth_stencil)
device_switch_onscreen_ds(device, context, fb->depth_stencil);
prepare_ds_clear(fb->depth_stencil, context, location,
if (!render_offscreen && depth_stencil != device->onscreen_depth_stencil)
device_switch_onscreen_ds(device, context, depth_stencil);
prepare_ds_clear(depth_stencil, context, location,
draw_rect, rect_count, clear_rect, &ds_rect);
}
@ -370,10 +371,9 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c
if (flags & WINED3DCLEAR_ZBUFFER)
{
DWORD location = render_offscreen ? fb->depth_stencil->container->resource.draw_binding
: WINED3D_LOCATION_DRAWABLE;
DWORD location = render_offscreen ? fb->depth_stencil->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
surface_modify_ds_location(fb->depth_stencil, location, ds_rect.right, ds_rect.bottom);
surface_modify_ds_location(depth_stencil, location, ds_rect.right, ds_rect.bottom);
gl_info->gl_ops.gl.p_glDepthMask(GL_TRUE);
context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZWRITEENABLE));
@ -857,7 +857,7 @@ static void device_init_swapchain_state(struct wined3d_device *device, struct wi
wined3d_device_set_rendertarget_view(device, 0, device->back_buffer_view, TRUE);
}
wined3d_device_set_depth_stencil(device, ds_enable ? device->auto_depth_stencil : NULL);
wined3d_device_set_depth_stencil_view(device, ds_enable ? device->auto_depth_stencil_view : NULL);
wined3d_device_set_render_state(device, WINED3D_RS_ZENABLE, ds_enable);
}
@ -1074,20 +1074,21 @@ HRESULT CDECL wined3d_device_uninit_3d(struct wined3d_device *device)
if (device->fb.depth_stencil)
{
surface = device->fb.depth_stencil;
struct wined3d_rendertarget_view *view = device->fb.depth_stencil;
TRACE("Releasing depth/stencil buffer %p.\n", surface);
TRACE("Releasing depth/stencil view %p.\n", view);
device->fb.depth_stencil = NULL;
wined3d_surface_decref(surface);
wined3d_rendertarget_view_decref(view);
}
if (device->auto_depth_stencil)
if (device->auto_depth_stencil_view)
{
surface = device->auto_depth_stencil;
device->auto_depth_stencil = NULL;
if (wined3d_surface_decref(surface))
FIXME("Something's still holding the auto depth stencil buffer (%p).\n", surface);
struct wined3d_rendertarget_view *view = device->auto_depth_stencil_view;
device->auto_depth_stencil_view = NULL;
if (wined3d_rendertarget_view_decref(view))
ERR("Something's still holding the auto depth/stencil view (%p).\n", view);
}
for (i = 0; i < gl_info->limits.buffers; ++i)
@ -1907,8 +1908,7 @@ static void resolve_depth_buffer(struct wined3d_state *state)
|| !(texture->resource.format->flags & WINED3DFMT_FLAG_DEPTH))
return;
surface = surface_from_resource(texture->sub_resources[0]);
depth_stencil = state->fb->depth_stencil;
if (!depth_stencil)
if (!(depth_stencil = wined3d_rendertarget_view_get_surface(state->fb->depth_stencil)))
return;
wined3d_surface_blt(surface, NULL, depth_stencil, NULL, 0, NULL, WINED3D_TEXF_POINT);
@ -3218,7 +3218,7 @@ HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_cou
if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
{
struct wined3d_surface *ds = device->fb.depth_stencil;
struct wined3d_rendertarget_view *ds = device->fb.depth_stencil;
if (!ds)
{
WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
@ -3227,8 +3227,8 @@ HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_cou
}
else if (flags & WINED3DCLEAR_TARGET)
{
if (ds->resource.width < device->fb.render_targets[0]->width
|| ds->resource.height < device->fb.render_targets[0]->height)
if (ds->width < device->fb.render_targets[0]->width
|| ds->height < device->fb.render_targets[0]->height)
{
WARN("Silently ignoring depth and target clear with mismatching sizes\n");
return WINED3D_OK;
@ -3547,9 +3547,9 @@ HRESULT CDECL wined3d_device_validate_device(const struct wined3d_device *device
|| state->render_states[WINED3D_RS_STENCILENABLE])
{
struct wined3d_rendertarget_view *rt = device->fb.render_targets[0];
struct wined3d_surface *ds = device->fb.depth_stencil;
struct wined3d_rendertarget_view *ds = device->fb.depth_stencil;
if(ds && rt && (ds->resource.width < rt->width || ds->resource.height < rt->height))
if (ds && rt && (ds->width < rt->width || ds->height < rt->height))
{
WARN("Depth stencil is smaller than the color buffer, returning D3DERR_CONFLICTINGRENDERSTATE\n");
return WINED3DERR_CONFLICTINGRENDERSTATE;
@ -3796,7 +3796,7 @@ struct wined3d_rendertarget_view * CDECL wined3d_device_get_rendertarget_view(co
return device->fb.render_targets[view_idx];
}
struct wined3d_surface * CDECL wined3d_device_get_depth_stencil(const struct wined3d_device *device)
struct wined3d_rendertarget_view * CDECL wined3d_device_get_depth_stencil_view(const struct wined3d_device *device)
{
TRACE("device %p.\n", device);
@ -3862,25 +3862,24 @@ HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device
return WINED3D_OK;
}
void CDECL wined3d_device_set_depth_stencil(struct wined3d_device *device, struct wined3d_surface *depth_stencil)
void CDECL wined3d_device_set_depth_stencil_view(struct wined3d_device *device, struct wined3d_rendertarget_view *view)
{
struct wined3d_surface *prev = device->fb.depth_stencil;
struct wined3d_rendertarget_view *prev;
TRACE("device %p, depth_stencil %p, old depth_stencil %p.\n",
device, depth_stencil, prev);
TRACE("device %p, view %p.\n", device, view);
if (prev == depth_stencil)
prev = device->fb.depth_stencil;
if (prev == view)
{
TRACE("Trying to do a NOP SetRenderTarget operation.\n");
return;
}
device->fb.depth_stencil = depth_stencil;
if (depth_stencil)
wined3d_surface_incref(depth_stencil);
wined3d_cs_emit_set_depth_stencil(device->cs, depth_stencil);
if ((device->fb.depth_stencil = view))
wined3d_rendertarget_view_incref(view);
wined3d_cs_emit_set_depth_stencil_view(device->cs, view);
if (prev)
wined3d_surface_decref(prev);
wined3d_rendertarget_view_decref(prev);
}
static struct wined3d_texture *wined3d_device_create_cursor_texture(struct wined3d_device *device,
@ -4258,7 +4257,7 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
wined3d_device_set_rendertarget_view(device, i, NULL, FALSE);
}
}
wined3d_device_set_depth_stencil(device, NULL);
wined3d_device_set_depth_stencil_view(device, NULL);
if (device->onscreen_depth_stencil)
{
@ -4325,35 +4324,6 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
wined3d_swapchain_set_window(swapchain, NULL);
}
if (swapchain_desc->enable_auto_depth_stencil && !device->auto_depth_stencil)
{
struct wined3d_resource_desc surface_desc;
TRACE("Creating the depth stencil buffer\n");
surface_desc.resource_type = WINED3D_RTYPE_SURFACE;
surface_desc.format = swapchain_desc->auto_depth_stencil_format;
surface_desc.multisample_type = swapchain_desc->multisample_type;
surface_desc.multisample_quality = swapchain_desc->multisample_quality;
surface_desc.usage = WINED3DUSAGE_DEPTHSTENCIL;
surface_desc.pool = WINED3D_POOL_DEFAULT;
surface_desc.width = swapchain_desc->backbuffer_width;
surface_desc.height = swapchain_desc->backbuffer_height;
surface_desc.depth = 1;
surface_desc.size = 0;
if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent,
device->device_parent, &surface_desc, &device->auto_depth_stencil)))
{
ERR("Failed to create the depth stencil buffer, hr %#x.\n", hr);
return WINED3DERR_INVALIDCALL;
}
}
/* Reset the depth stencil */
if (swapchain_desc->enable_auto_depth_stencil)
wined3d_device_set_depth_stencil(device, device->auto_depth_stencil);
if (mode)
{
DisplayModeChanged = TRUE;
@ -4440,13 +4410,48 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
swapchain->desc.multisample_type, swapchain->desc.multisample_quality, NULL, 0)))
return hr;
}
if (device->auto_depth_stencil)
}
if (device->auto_depth_stencil_view)
{
wined3d_rendertarget_view_decref(device->auto_depth_stencil_view);
device->auto_depth_stencil_view = NULL;
}
if (swapchain->desc.enable_auto_depth_stencil)
{
struct wined3d_resource_desc surface_desc;
struct wined3d_surface *surface;
TRACE("Creating the depth stencil buffer\n");
surface_desc.resource_type = WINED3D_RTYPE_SURFACE;
surface_desc.format = swapchain->desc.auto_depth_stencil_format;
surface_desc.multisample_type = swapchain->desc.multisample_type;
surface_desc.multisample_quality = swapchain->desc.multisample_quality;
surface_desc.usage = WINED3DUSAGE_DEPTHSTENCIL;
surface_desc.pool = WINED3D_POOL_DEFAULT;
surface_desc.width = swapchain->desc.backbuffer_width;
surface_desc.height = swapchain->desc.backbuffer_height;
surface_desc.depth = 1;
surface_desc.size = 0;
if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent,
device->device_parent, &surface_desc, &surface)))
{
if (FAILED(hr = wined3d_surface_update_desc(device->auto_depth_stencil, swapchain->desc.backbuffer_width,
swapchain->desc.backbuffer_height, device->auto_depth_stencil->resource.format->id,
swapchain->desc.multisample_type, swapchain->desc.multisample_quality, NULL, 0)))
return hr;
ERR("Failed to create the auto depth/stencil surface, hr %#x.\n", hr);
return WINED3DERR_INVALIDCALL;
}
hr = wined3d_rendertarget_view_create_from_surface(surface,
NULL, &wined3d_null_parent_ops, &device->auto_depth_stencil_view);
wined3d_surface_decref(surface);
if (FAILED(hr))
{
ERR("Failed to create rendertarget view, hr %#x.\n", hr);
return hr;
}
wined3d_device_set_depth_stencil_view(device, device->auto_depth_stencil_view);
}
if (device->back_buffer_view)
@ -4659,7 +4664,7 @@ void device_resource_released(struct wined3d_device *device, struct wined3d_reso
}
}
if (device->fb.depth_stencil == surface)
if (wined3d_rendertarget_view_get_surface(device->fb.depth_stencil) == surface)
{
ERR("Surface %p is still in use as depth/stencil buffer.\n", surface);
device->fb.depth_stencil = NULL;

6
dlls/wined3d/drawprim.c
View File

@ -638,11 +638,11 @@ void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_co
* Z-compare function into account, but we could skip loading the
* depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
* that we never copy the stencil data.*/
DWORD location = context->render_offscreen ? device->fb.depth_stencil->container->resource.draw_binding
DWORD location = context->render_offscreen ? device->fb.depth_stencil->resource->draw_binding
: WINED3D_LOCATION_DRAWABLE;
if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE])
{
struct wined3d_surface *ds = device->fb.depth_stencil;
struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(device->fb.depth_stencil);
RECT current_rect, draw_rect, r;
if (!context->render_offscreen && ds != device->onscreen_depth_stencil)
@ -670,7 +670,7 @@ void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_co
if (device->fb.depth_stencil && state->render_states[WINED3D_RS_ZWRITEENABLE])
{
struct wined3d_surface *ds = device->fb.depth_stencil;
struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(device->fb.depth_stencil);
DWORD location = context->render_offscreen ? ds->container->resource.draw_binding : WINED3D_LOCATION_DRAWABLE;
surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);

4
dlls/wined3d/state.c
View File

@ -1765,7 +1765,7 @@ static void state_depthbias(struct wined3d_context *context, const struct wined3
if (state->render_states[WINED3D_RS_SLOPESCALEDEPTHBIAS]
|| state->render_states[WINED3D_RS_DEPTHBIAS])
{
const struct wined3d_surface *depth = state->fb->depth_stencil;
const struct wined3d_rendertarget_view *depth = state->fb->depth_stencil;
float scale;
union
@ -1790,7 +1790,7 @@ static void state_depthbias(struct wined3d_context *context, const struct wined3
{
if (depth)
{
const struct wined3d_format *fmt = depth->resource.format;
const struct wined3d_format *fmt = depth->format;
scale = powf(2, fmt->depth_size) - 1;
TRACE("Depth format %s, using depthbias scale of %.8e.\n",
debug_d3dformat(fmt->id), scale);

19
dlls/wined3d/surface.c
View File

@ -4923,13 +4923,22 @@ static HRESULT ffp_blit_color_fill(struct wined3d_device *device, struct wined3d
return WINED3D_OK;
}
static HRESULT ffp_blit_depth_fill(struct wined3d_device *device,
struct wined3d_surface *surface, const RECT *rect, float depth)
static HRESULT ffp_blit_depth_fill(struct wined3d_device *device, struct wined3d_surface *dst_surface,
const RECT *dst_rect, float depth)
{
const RECT draw_rect = {0, 0, surface->resource.width, surface->resource.height};
struct wined3d_fb_state fb = {NULL, surface};
const RECT draw_rect = {0, 0, dst_surface->resource.width, dst_surface->resource.height};
struct wined3d_fb_state fb = {NULL, NULL};
HRESULT hr;
device_clear_render_targets(device, 0, &fb, 1, rect, &draw_rect, WINED3DCLEAR_ZBUFFER, 0, depth, 0);
if (FAILED(hr = wined3d_rendertarget_view_create_from_surface(dst_surface,
NULL, &wined3d_null_parent_ops, &fb.depth_stencil)))
{
ERR("Failed to create rendertarget view, hr %#x.\n", hr);
return hr;
}
device_clear_render_targets(device, 0, &fb, 1, dst_rect, &draw_rect, WINED3DCLEAR_ZBUFFER, 0, depth, 0);
wined3d_rendertarget_view_decref(fb.depth_stencil);
return WINED3D_OK;
}

30
dlls/wined3d/swapchain.c
View File

@ -597,13 +597,14 @@ static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT
if (fb->depth_stencil)
{
if (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| fb->depth_stencil->flags & SFLAG_DISCARD)
struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(fb->depth_stencil);
if (ds && (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| ds->flags & SFLAG_DISCARD))
{
surface_modify_ds_location(fb->depth_stencil, WINED3D_LOCATION_DISCARDED,
fb->depth_stencil->resource.width,
fb->depth_stencil->resource.height);
if (fb->depth_stencil == swapchain->device->onscreen_depth_stencil)
surface_modify_ds_location(ds, WINED3D_LOCATION_DISCARDED,
fb->depth_stencil->width, fb->depth_stencil->height);
if (ds == swapchain->device->onscreen_depth_stencil)
{
wined3d_surface_decref(swapchain->device->onscreen_depth_stencil);
swapchain->device->onscreen_depth_stencil = NULL;
@ -982,15 +983,26 @@ static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3
if (desc->enable_auto_depth_stencil && !(device->wined3d->flags & WINED3D_NO3D))
{
TRACE("Creating depth/stencil buffer.\n");
if (!device->auto_depth_stencil)
if (!device->auto_depth_stencil_view)
{
struct wined3d_surface *ds;
surface_desc.format = swapchain->desc.auto_depth_stencil_format;
surface_desc.usage = WINED3DUSAGE_DEPTHSTENCIL;
if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent,
device->device_parent, &surface_desc, &device->auto_depth_stencil)))
device->device_parent, &surface_desc, &ds)))
{
WARN("Failed to create the auto depth stencil, hr %#x.\n", hr);
WARN("Failed to create the auto depth/stencil surface, hr %#x.\n", hr);
goto err;
}
hr = wined3d_rendertarget_view_create_from_surface(ds,
NULL, &wined3d_null_parent_ops, &device->auto_depth_stencil_view);
wined3d_surface_decref(ds);
if (FAILED(hr))
{
ERR("Failed to create rendertarget view, hr %#x.\n", hr);
goto err;
}
}

4
dlls/wined3d/wined3d.spec
View File

@ -53,7 +53,7 @@
@ cdecl wined3d_device_get_clip_plane(ptr long ptr)
@ cdecl wined3d_device_get_clip_status(ptr ptr)
@ cdecl wined3d_device_get_creation_parameters(ptr ptr)
@ cdecl wined3d_device_get_depth_stencil(ptr)
@ cdecl wined3d_device_get_depth_stencil_view(ptr)
@ cdecl wined3d_device_get_device_caps(ptr ptr)
@ cdecl wined3d_device_get_display_mode(ptr long ptr ptr)
@ cdecl wined3d_device_get_front_buffer_data(ptr long ptr)
@ -110,7 +110,7 @@
@ cdecl wined3d_device_set_clip_status(ptr ptr)
@ cdecl wined3d_device_set_cursor_position(ptr long long long)
@ cdecl wined3d_device_set_cursor_properties(ptr long long ptr)
@ cdecl wined3d_device_set_depth_stencil(ptr ptr)
@ cdecl wined3d_device_set_depth_stencil_view(ptr ptr)
@ cdecl wined3d_device_set_dialog_box_mode(ptr long)
@ cdecl wined3d_device_set_gamma_ramp(ptr long long ptr)
@ cdecl wined3d_device_set_geometry_shader(ptr ptr)

7
dlls/wined3d/wined3d_private.h
View File

@ -1176,7 +1176,7 @@ struct wined3d_context
struct wined3d_fb_state
{
struct wined3d_rendertarget_view **render_targets;
struct wined3d_surface *depth_stencil;
struct wined3d_rendertarget_view *depth_stencil;
};
typedef void (*APPLYSTATEFUNC)(struct wined3d_context *ctx, const struct wined3d_state *state, DWORD state_id);
@ -1955,7 +1955,7 @@ struct wined3d_device
/* Render Target Support */
struct wined3d_fb_state fb;
struct wined3d_surface *onscreen_depth_stencil;
struct wined3d_surface *auto_depth_stencil;
struct wined3d_rendertarget_view *auto_depth_stencil_view;
/* For rendering to a texture using glCopyTexImage */
GLuint depth_blt_texture;
@ -2506,7 +2506,8 @@ 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_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
UINT cb_idx, struct wined3d_buffer *buffer) 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_depth_stencil_view(struct wined3d_cs *cs,
struct wined3d_rendertarget_view *view) 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;

5
include/wine/wined3d.h
View File

@ -2122,7 +2122,7 @@ HRESULT __cdecl wined3d_device_get_clip_status(const struct wined3d_device *devi
struct wined3d_clip_status *clip_status);
void __cdecl wined3d_device_get_creation_parameters(const struct wined3d_device *device,
struct wined3d_device_creation_parameters *creation_parameters);
struct wined3d_surface * __cdecl wined3d_device_get_depth_stencil(const struct wined3d_device *device);
struct wined3d_rendertarget_view * __cdecl wined3d_device_get_depth_stencil_view(const struct wined3d_device *device);
HRESULT __cdecl wined3d_device_get_device_caps(const struct wined3d_device *device, WINED3DCAPS *caps);
HRESULT __cdecl wined3d_device_get_display_mode(const struct wined3d_device *device, UINT swapchain_idx,
struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation);
@ -2210,7 +2210,8 @@ void __cdecl wined3d_device_set_cursor_position(struct wined3d_device *device,
int x_screen_space, int y_screen_space, DWORD flags);
HRESULT __cdecl wined3d_device_set_cursor_properties(struct wined3d_device *device,
UINT x_hotspot, UINT y_hotspot, struct wined3d_surface *cursor_surface);
void __cdecl wined3d_device_set_depth_stencil(struct wined3d_device *device, struct wined3d_surface *depth_stencil);
void __cdecl wined3d_device_set_depth_stencil_view(struct wined3d_device *device,
struct wined3d_rendertarget_view *view);
HRESULT __cdecl wined3d_device_set_dialog_box_mode(struct wined3d_device *device, BOOL enable_dialogs);
void __cdecl wined3d_device_set_gamma_ramp(const struct wined3d_device *device,
UINT swapchain_idx, DWORD flags, const struct wined3d_gamma_ramp *ramp);