static void swapchain_cleanup(struct wined3d_swapchain *swapchain)
{
HRESULT hr;
UINT i;
TRACE("Destroying swapchain %p.\n", swapchain);
wined3d_swapchain_set_gamma_ramp(swapchain, 0, &swapchain->orig_gamma);
/* Release the swapchain's draw buffers. Make sure swapchain->back_buffers[0]
* is the last buffer to be destroyed, FindContext() depends on that. */
if (swapchain->front_buffer)
{
wined3d_texture_set_swapchain(swapchain->front_buffer, NULL);
if (wined3d_texture_decref(swapchain->front_buffer))
WARN("Something's still holding the front buffer (%p).\n", swapchain->front_buffer);
swapchain->front_buffer = NULL;
}
if (swapchain->back_buffers)
{
i = swapchain->desc.backbuffer_count;
while (i--)
{
wined3d_texture_set_swapchain(swapchain->back_buffers[i], NULL);
if (wined3d_texture_decref(swapchain->back_buffers[i]))
WARN("Something's still holding back buffer %u (%p).\n", i, swapchain->back_buffers[i]);
}
HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);
swapchain->back_buffers = NULL;
}
for (i = 0; i < swapchain->num_contexts; ++i)
{
context_destroy(swapchain->device, swapchain->context[i]);
}
HeapFree(GetProcessHeap(), 0, swapchain->context);
/* Restore the screen resolution if we rendered in fullscreen.
* This will restore the screen resolution to what it was before creating
* the swapchain. In case of d3d8 and d3d9 this will be the original
* desktop resolution. In case of d3d7 this will be a NOP because ddraw
* sets the resolution before starting up Direct3D, thus orig_width and
* orig_height will be equal to the modes in the presentation params. */
if (!swapchain->desc.windowed && swapchain->desc.auto_restore_display_mode)
{
if (FAILED(hr = wined3d_set_adapter_display_mode(swapchain->device->wined3d,
swapchain->device->adapter->ordinal, &swapchain->original_mode)))
ERR("Failed to restore display mode, hr %#x.\n", hr);
}
if (swapchain->backup_dc)
{
TRACE("Destroying backup wined3d window %p, dc %p.\n", swapchain->backup_wnd, swapchain->backup_dc);
wined3d_release_dc(swapchain->backup_wnd, swapchain->backup_dc);
DestroyWindow(swapchain->backup_wnd);
}
}
static ULONG volume_resource_decref(struct wined3d_resource *resource)
{
struct wined3d_volume *volume = volume_from_resource(resource);
TRACE("Forwarding to container %p.\n", volume->container);
return wined3d_texture_decref(volume->container);
}
ULONG CDECL wined3d_volume_decref(struct wined3d_volume *volume)
{
ULONG refcount;
if (volume->container)
{
TRACE("Forwarding to container %p.\n", volume->container);
return wined3d_texture_decref(volume->container);
}
refcount = InterlockedDecrement(&volume->resource.ref);
TRACE("%p decreasing refcount to %u.\n", volume, refcount);
if (!refcount)
{
if (volume->pbo)
wined3d_volume_free_pbo(volume);
resource_cleanup(&volume->resource);
volume->resource.parent_ops->wined3d_object_destroyed(volume->resource.parent);
HeapFree(GetProcessHeap(), 0, volume);
}
return refcount;
}
static ULONG WINAPI d3d8_surface_Release(IDirect3DSurface8 *iface)
{
struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
ULONG refcount;
TRACE("iface %p.\n", iface);
if (surface->texture)
{
TRACE("Forwarding to %p.\n", surface->texture);
return IDirect3DBaseTexture8_Release(&surface->texture->IDirect3DBaseTexture8_iface);
}
refcount = InterlockedDecrement(&surface->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
if (!refcount)
{
IDirect3DDevice8 *parent_device = surface->parent_device;
wined3d_mutex_lock();
if (surface->wined3d_rtv)
wined3d_rendertarget_view_decref(surface->wined3d_rtv);
wined3d_texture_decref(surface->wined3d_texture);
wined3d_mutex_unlock();
if (parent_device)
IDirect3DDevice8_Release(parent_device);
}
return refcount;
}
static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
{
struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
ULONG refcount = InterlockedDecrement(&texture->refcount);
TRACE("%p decreasing refcount to %u.\n", texture, refcount);
if (!refcount)
wined3d_texture_decref(texture->wined3d_texture);
return refcount;
}
static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
{
struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
ULONG refcount = InterlockedDecrement(&This->refcount);
TRACE("%p decreasing refcount to %u\n", This, refcount);
if (!refcount)
wined3d_texture_decref(This->wined3d_texture);
return refcount;
}
static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
{
struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
ULONG refcount = InterlockedDecrement(&This->refcount);
TRACE("%p decreasing refcount to %u\n", This, refcount);
if (!refcount)
{
ID3D10Device1 *device = This->device;
wined3d_texture_decref(This->wined3d_texture);
/* Release the device last, it may cause the wined3d device to be
* destroyed. */
ID3D10Device1_Release(device);
}
return refcount;
}
static ULONG WINAPI IDirect3DVolumeTexture8Impl_Release(IDirect3DVolumeTexture8 *iface)
{
IDirect3DVolumeTexture8Impl *This = impl_from_IDirect3DVolumeTexture8(iface);
ULONG ref = InterlockedDecrement(&This->ref);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (ref == 0) {
IDirect3DDevice8 *parentDevice = This->parentDevice;
wined3d_mutex_lock();
wined3d_texture_decref(This->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, as it may cause the device to be destroyed. */
IDirect3DDevice8_Release(parentDevice);
}
return ref;
}
static ULONG WINAPI d3d8_texture_3d_Release(IDirect3DVolumeTexture8 *iface)
{
struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
ULONG ref = InterlockedDecrement(&texture->refcount);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref)
{
IDirect3DDevice8 *parent_device = texture->parent_device;
wined3d_mutex_lock();
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, as it may cause the device to be destroyed. */
IDirect3DDevice8_Release(parent_device);
}
return ref;
}
static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface)
{
struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
ULONG refcount = InterlockedDecrement(&texture->refcount);
TRACE("%p decreasing refcount to %u.\n", texture, refcount);
if (!refcount)
{
ID3D11Device *device = texture->device;
wined3d_mutex_lock();
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, it may cause the wined3d device to be
* destroyed. */
ID3D11Device_Release(device);
}
return refcount;
}
static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface)
{
struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
ULONG ref = InterlockedDecrement(&texture->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref)
{
IDirect3DDevice9Ex *parent_device = texture->parent_device;
TRACE("Releasing child %p.\n", texture->wined3d_texture);
wined3d_mutex_lock();
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, as it may cause the device to be destroyed. */
IDirect3DDevice9Ex_Release(parent_device);
}
return ref;
}
static ULONG WINAPI d3d9_surface_Release(IDirect3DSurface9 *iface)
{
struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface);
ULONG refcount;
TRACE("iface %p.\n", iface);
if (surface->texture)
{
TRACE("Forwarding to %p.\n", surface->texture);
return IDirect3DBaseTexture9_Release(&surface->texture->IDirect3DBaseTexture9_iface);
}
if (!surface->resource.refcount)
{
ERR("Surface doesn't have any references.\n");
return 0;
}
refcount = InterlockedDecrement(&surface->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
if (!refcount)
{
IDirect3DDevice9Ex *parent_device = surface->parent_device;
wined3d_mutex_lock();
if (surface->wined3d_rtv)
wined3d_rendertarget_view_decref(surface->wined3d_rtv);
wined3d_texture_decref(surface->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, as it may cause the device to be destroyed. */
if (parent_device)
IDirect3DDevice9Ex_Release(parent_device);
}
return refcount;
}
static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface)
{
struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
ULONG ref = InterlockedDecrement(&texture->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref)
{
IDirect3DDevice8 *parent_device = texture->parent_device;
struct d3d8_surface *surface;
wined3d_mutex_lock();
LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d8_surface, rtv_entry)
{
wined3d_rendertarget_view_decref(surface->wined3d_rtv);
}
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
/* Release the device last, as it may cause the device to be destroyed. */
IDirect3DDevice8_Release(parent_device);
}
static HRESULT d3d_texture2d_init(struct d3d_texture2d *texture, struct d3d_device *device,
const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data)
{
struct wined3d_resource_desc wined3d_desc;
unsigned int levels;
HRESULT hr;
texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
texture->refcount = 1;
wined3d_mutex_lock();
wined3d_private_store_init(&texture->private_store);
texture->desc = *desc;
if (desc->ArraySize != 1)
FIXME("Array textures not implemented.\n");
if (desc->SampleDesc.Count > 1)
FIXME("Multisampled textures not implemented.\n");
wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);
wined3d_desc.pool = WINED3D_POOL_DEFAULT;
wined3d_desc.width = desc->Width;
wined3d_desc.height = desc->Height;
wined3d_desc.depth = 1;
wined3d_desc.size = 0;
levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
levels, 0, (struct wined3d_sub_resource_data *)data, texture,
&d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
{
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
wined3d_private_store_cleanup(&texture->private_store);
wined3d_mutex_unlock();
return hr;
}
texture->desc.MipLevels = levels;
if (desc->MipLevels == 1 && desc->ArraySize == 1)
{
IWineDXGIDevice *wine_device;
if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
(void **)&wine_device)))
{
ERR("Device should implement IWineDXGIDevice.\n");
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
return E_FAIL;
}
hr = IWineDXGIDevice_create_surface(wine_device, wined3d_texture_get_resource(texture->wined3d_texture),
0, NULL, (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
IWineDXGIDevice_Release(wine_device);
if (FAILED(hr))
{
ERR("Failed to create DXGI surface, returning %#x\n", hr);
texture->dxgi_surface = NULL;
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
return hr;
}
}
wined3d_mutex_unlock();
texture->device = &device->ID3D11Device_iface;
ID3D11Device_AddRef(texture->device);
return S_OK;
}
static HRESULT STDMETHODCALLTYPE dxgi_device_CreateSurface(IWineDXGIDevice *iface,
const DXGI_SURFACE_DESC *desc, UINT surface_count, DXGI_USAGE usage,
const DXGI_SHARED_RESOURCE *shared_resource, IDXGISurface **surface)
{
struct wined3d_device_parent *device_parent;
struct wined3d_resource_desc surface_desc;
IWineDXGIDeviceParent *dxgi_device_parent;
HRESULT hr;
UINT i;
UINT j;
TRACE("iface %p, desc %p, surface_count %u, usage %#x, shared_resource %p, surface %p\n",
iface, desc, surface_count, usage, shared_resource, surface);
hr = IWineDXGIDevice_QueryInterface(iface, &IID_IWineDXGIDeviceParent, (void **)&dxgi_device_parent);
if (FAILED(hr))
{
ERR("Device should implement IWineD3DDeviceParent\n");
return E_FAIL;
}
device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent);
FIXME("Implement DXGI<->wined3d usage conversion\n");
surface_desc.resource_type = WINED3D_RTYPE_SURFACE;
surface_desc.format = wined3dformat_from_dxgi_format(desc->Format);
wined3d_sample_desc_from_dxgi(&surface_desc.multisample_type,
&surface_desc.multisample_quality, &desc->SampleDesc);
surface_desc.usage = usage;
surface_desc.pool = WINED3D_POOL_DEFAULT;
surface_desc.width = desc->Width;
surface_desc.height = desc->Height;
surface_desc.depth = 1;
surface_desc.size = 0;
wined3d_mutex_lock();
memset(surface, 0, surface_count * sizeof(*surface));
for (i = 0; i < surface_count; ++i)
{
struct wined3d_texture *wined3d_texture;
IUnknown *parent;
if (FAILED(hr = device_parent->ops->create_swapchain_texture(device_parent,
NULL, &surface_desc, &wined3d_texture)))
{
ERR("Failed to create surface, hr %#x.\n", hr);
goto fail;
}
parent = wined3d_texture_get_parent(wined3d_texture);
hr = IUnknown_QueryInterface(parent, &IID_IDXGISurface, (void **)&surface[i]);
wined3d_texture_decref(wined3d_texture);
if (FAILED(hr))
{
ERR("Surface should implement IDXGISurface\n");
goto fail;
}
TRACE("Created IDXGISurface %p (%u/%u)\n", surface[i], i + 1, surface_count);
}
wined3d_mutex_unlock();
IWineDXGIDeviceParent_Release(dxgi_device_parent);
return S_OK;
fail:
wined3d_mutex_unlock();
for (j = 0; j < i; ++j)
{
IDXGISurface_Release(surface[i]);
}
IWineDXGIDeviceParent_Release(dxgi_device_parent);
return hr;
}
static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3d_device *device,
struct wined3d_swapchain_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_adapter *adapter = device->adapter;
struct wined3d_resource_desc texture_desc;
struct wined3d_surface *front_buffer;
BOOL displaymode_set = FALSE;
RECT client_rect;
HWND window;
HRESULT hr;
UINT i;
if (desc->backbuffer_count > 1)
{
FIXME("The application requested more than one back buffer, this is not properly supported.\n"
"Please configure the application to use double buffering (1 back buffer) if possible.\n");
}
if (device->wined3d->flags & WINED3D_NO3D)
swapchain->swapchain_ops = &swapchain_gdi_ops;
else
swapchain->swapchain_ops = &swapchain_gl_ops;
window = desc->device_window ? desc->device_window : device->create_parms.focus_window;
swapchain->device = device;
swapchain->parent = parent;
swapchain->parent_ops = parent_ops;
swapchain->ref = 1;
swapchain->win_handle = window;
swapchain->device_window = window;
if (FAILED(hr = wined3d_get_adapter_display_mode(device->wined3d,
adapter->ordinal, &swapchain->original_mode, NULL)))
{
ERR("Failed to get current display mode, hr %#x.\n", hr);
goto err;
}
GetClientRect(window, &client_rect);
if (desc->windowed
&& (!desc->backbuffer_width || !desc->backbuffer_height
|| desc->backbuffer_format == WINED3DFMT_UNKNOWN))
{
if (!desc->backbuffer_width)
{
desc->backbuffer_width = client_rect.right;
TRACE("Updating width to %u.\n", desc->backbuffer_width);
}
if (!desc->backbuffer_height)
{
desc->backbuffer_height = client_rect.bottom;
TRACE("Updating height to %u.\n", desc->backbuffer_height);
}
if (desc->backbuffer_format == WINED3DFMT_UNKNOWN)
{
desc->backbuffer_format = swapchain->original_mode.format_id;
TRACE("Updating format to %s.\n", debug_d3dformat(swapchain->original_mode.format_id));
}
}
swapchain->desc = *desc;
swapchain_update_render_to_fbo(swapchain);
TRACE("Creating front buffer.\n");
texture_desc.resource_type = WINED3D_RTYPE_TEXTURE;
texture_desc.format = swapchain->desc.backbuffer_format;
texture_desc.multisample_type = swapchain->desc.multisample_type;
texture_desc.multisample_quality = swapchain->desc.multisample_quality;
texture_desc.usage = 0;
texture_desc.pool = WINED3D_POOL_DEFAULT;
texture_desc.width = swapchain->desc.backbuffer_width;
texture_desc.height = swapchain->desc.backbuffer_height;
texture_desc.depth = 1;
texture_desc.size = 0;
if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent,
parent, &texture_desc, &swapchain->front_buffer)))
{
WARN("Failed to create front buffer, hr %#x.\n", hr);
goto err;
}
wined3d_texture_set_swapchain(swapchain->front_buffer, swapchain);
front_buffer = surface_from_resource(wined3d_texture_get_sub_resource(swapchain->front_buffer, 0));
if (!(device->wined3d->flags & WINED3D_NO3D))
{
surface_validate_location(front_buffer, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(front_buffer, ~WINED3D_LOCATION_DRAWABLE);
}
/* MSDN says we're only allowed a single fullscreen swapchain per device,
* so we should really check to see if there is a fullscreen swapchain
* already. Does a single head count as full screen? */
if (!desc->windowed)
{
/* Change the display settings */
swapchain->d3d_mode.width = desc->backbuffer_width;
swapchain->d3d_mode.height = desc->backbuffer_height;
swapchain->d3d_mode.format_id = desc->backbuffer_format;
swapchain->d3d_mode.refresh_rate = desc->refresh_rate;
swapchain->d3d_mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
if (FAILED(hr = wined3d_set_adapter_display_mode(device->wined3d, adapter->ordinal, &swapchain->d3d_mode)))
{
WARN("Failed to set display mode, hr %#x.\n", hr);
goto err;
}
displaymode_set = TRUE;
}
if (!(device->wined3d->flags & WINED3D_NO3D))
{
static const enum wined3d_format_id formats[] =
{
WINED3DFMT_D24_UNORM_S8_UINT,
WINED3DFMT_D32_UNORM,
WINED3DFMT_R24_UNORM_X8_TYPELESS,
WINED3DFMT_D16_UNORM,
WINED3DFMT_S1_UINT_D15_UNORM
};
const struct wined3d_gl_info *gl_info = &adapter->gl_info;
swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
if (!swapchain->context)
{
ERR("Failed to create the context array.\n");
hr = E_OUTOFMEMORY;
goto err;
}
swapchain->num_contexts = 1;
/* In WGL both color, depth and stencil are features of a pixel format. In case of D3D they are separate.
* You are able to add a depth + stencil surface at a later stage when you need it.
* In order to support this properly in WineD3D we need the ability to recreate the opengl context and
* drawable when this is required. This is very tricky as we need to reapply ALL opengl states for the new
* context, need torecreate shaders, textures and other resources.
*
* The context manager already takes care of the state problem and for the other tasks code from Reset
* can be used. These changes are way to risky during the 1.0 code freeze which is taking place right now.
* Likely a lot of other new bugs will be exposed. For that reason request a depth stencil surface all the
* time. It can cause a slight performance hit but fixes a lot of regressions. A fixme reminds of that this
* issue needs to be fixed. */
for (i = 0; i < (sizeof(formats) / sizeof(*formats)); i++)
{
swapchain->ds_format = wined3d_get_format(gl_info, formats[i]);
swapchain->context[0] = context_create(swapchain, front_buffer, swapchain->ds_format);
if (swapchain->context[0]) break;
TRACE("Depth stencil format %s is not supported, trying next format\n",
debug_d3dformat(formats[i]));
}
if (!swapchain->context[0])
{
WARN("Failed to create context.\n");
hr = WINED3DERR_NOTAVAILABLE;
goto err;
}
if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
&& (!desc->enable_auto_depth_stencil
|| swapchain->desc.auto_depth_stencil_format != swapchain->ds_format->id))
{
FIXME("Add OpenGL context recreation support to context_validate_onscreen_formats\n");
}
context_release(swapchain->context[0]);
}
if (swapchain->desc.backbuffer_count > 0)
{
swapchain->back_buffers = HeapAlloc(GetProcessHeap(), 0,
sizeof(*swapchain->back_buffers) * swapchain->desc.backbuffer_count);
if (!swapchain->back_buffers)
{
ERR("Failed to allocate backbuffer array memory.\n");
hr = E_OUTOFMEMORY;
goto err;
}
texture_desc.usage |= WINED3DUSAGE_RENDERTARGET;
for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
{
TRACE("Creating back buffer %u.\n", i);
if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent,
parent, &texture_desc, &swapchain->back_buffers[i])))
{
WARN("Failed to create back buffer %u, hr %#x.\n", i, hr);
swapchain->desc.backbuffer_count = i;
goto err;
}
wined3d_texture_set_swapchain(swapchain->back_buffers[i], swapchain);
}
}
/* Swapchains share the depth/stencil buffer, so only create a single depthstencil surface. */
if (desc->enable_auto_depth_stencil && !(device->wined3d->flags & WINED3D_NO3D))
{
TRACE("Creating depth/stencil buffer.\n");
if (!device->auto_depth_stencil_view)
{
struct wined3d_texture *ds;
struct wined3d_rendertarget_view_desc desc;
texture_desc.format = swapchain->desc.auto_depth_stencil_format;
texture_desc.usage = WINED3DUSAGE_DEPTHSTENCIL;
if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent,
device->device_parent, &texture_desc, &ds)))
{
WARN("Failed to create the auto depth/stencil surface, hr %#x.\n", hr);
goto err;
}
desc.format_id = ds->resource.format->id;
desc.u.texture.level_idx = 0;
desc.u.texture.layer_idx = 0;
desc.u.texture.layer_count = 1;
hr = wined3d_rendertarget_view_create(&desc, &ds->resource, NULL, &wined3d_null_parent_ops,
&device->auto_depth_stencil_view);
wined3d_texture_decref(ds);
if (FAILED(hr))
{
ERR("Failed to create rendertarget view, hr %#x.\n", hr);
goto err;
}
}
}
wined3d_swapchain_get_gamma_ramp(swapchain, &swapchain->orig_gamma);
return WINED3D_OK;
err:
if (displaymode_set)
{
if (FAILED(wined3d_set_adapter_display_mode(device->wined3d,
adapter->ordinal, &swapchain->original_mode)))
ERR("Failed to restore display mode.\n");
ClipCursor(NULL);
}
if (swapchain->back_buffers)
{
for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
{
if (swapchain->back_buffers[i])
{
wined3d_texture_set_swapchain(swapchain->back_buffers[i], NULL);
wined3d_texture_decref(swapchain->back_buffers[i]);
}
}
HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);
}
if (swapchain->context)
{
if (swapchain->context[0])
{
context_release(swapchain->context[0]);
context_destroy(device, swapchain->context[0]);
swapchain->num_contexts = 0;
}
HeapFree(GetProcessHeap(), 0, swapchain->context);
}
if (swapchain->front_buffer)
{
wined3d_texture_set_swapchain(swapchain->front_buffer, NULL);
wined3d_texture_decref(swapchain->front_buffer);
}
return hr;
}
static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT *src_rect_in,
const RECT *dst_rect_in, const RGNDATA *dirty_region, DWORD flags)
{
struct wined3d_surface *back_buffer = surface_from_resource(
wined3d_texture_get_sub_resource(swapchain->back_buffers[0], 0));
const struct wined3d_fb_state *fb = &swapchain->device->fb;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
struct wined3d_surface *front;
RECT src_rect, dst_rect;
BOOL render_to_fbo;
context = context_acquire(swapchain->device, back_buffer);
if (!context->valid)
{
context_release(context);
WARN("Invalid context, skipping present.\n");
return;
}
gl_info = context->gl_info;
if (swapchain->device->logo_texture)
{
struct wined3d_surface *src_surface = surface_from_resource(
wined3d_texture_get_sub_resource(swapchain->device->logo_texture, 0));
RECT rect = {0, 0, src_surface->resource.width, src_surface->resource.height};
/* Blit the logo into the upper left corner of the drawable. */
wined3d_surface_blt(back_buffer, &rect, src_surface, &rect, WINEDDBLT_ALPHATEST,
NULL, WINED3D_TEXF_POINT);
}
if (swapchain->device->bCursorVisible && swapchain->device->cursor_texture
&& !swapchain->device->hardwareCursor)
{
struct wined3d_surface *cursor = surface_from_resource(
wined3d_texture_get_sub_resource(swapchain->device->cursor_texture, 0));
RECT destRect =
{
swapchain->device->xScreenSpace - swapchain->device->xHotSpot,
swapchain->device->yScreenSpace - swapchain->device->yHotSpot,
swapchain->device->xScreenSpace + swapchain->device->cursorWidth - swapchain->device->xHotSpot,
swapchain->device->yScreenSpace + swapchain->device->cursorHeight - swapchain->device->yHotSpot,
};
RECT src_rect =
{
0, 0,
swapchain->device->cursor_texture->resource.width,
swapchain->device->cursor_texture->resource.height
};
const RECT clip_rect = {0, 0, back_buffer->resource.width, back_buffer->resource.height};
TRACE("Rendering the software cursor.\n");
if (swapchain->desc.windowed)
MapWindowPoints(NULL, swapchain->win_handle, (POINT *)&destRect, 2);
if (wined3d_clip_blit(&clip_rect, &destRect, &src_rect))
wined3d_surface_blt(back_buffer, &destRect, cursor, &src_rect, WINEDDBLT_ALPHATEST,
NULL, WINED3D_TEXF_POINT);
}
TRACE("Presenting HDC %p.\n", context->hdc);
render_to_fbo = swapchain->render_to_fbo;
if (src_rect_in)
{
src_rect = *src_rect_in;
if (!render_to_fbo && (src_rect.left || src_rect.top
|| src_rect.right != swapchain->desc.backbuffer_width
|| src_rect.bottom != swapchain->desc.backbuffer_height))
{
render_to_fbo = TRUE;
}
}
else
{
src_rect.left = 0;
src_rect.top = 0;
src_rect.right = swapchain->desc.backbuffer_width;
src_rect.bottom = swapchain->desc.backbuffer_height;
}
if (dst_rect_in)
dst_rect = *dst_rect_in;
else
GetClientRect(swapchain->win_handle, &dst_rect);
if (!render_to_fbo && (dst_rect.left || dst_rect.top
|| dst_rect.right != swapchain->desc.backbuffer_width
|| dst_rect.bottom != swapchain->desc.backbuffer_height))
render_to_fbo = TRUE;
/* Rendering to a window of different size, presenting partial rectangles,
* or rendering to a different window needs help from FBO_blit or a textured
* draw. Render the swapchain to a FBO in the future.
*
* Note that FBO_blit from the backbuffer to the frontbuffer cannot solve
* all these issues - this fails if the window is smaller than the backbuffer.
*/
if (!swapchain->render_to_fbo && render_to_fbo && wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{
surface_load_location(back_buffer, context, WINED3D_LOCATION_TEXTURE_RGB);
surface_invalidate_location(back_buffer, WINED3D_LOCATION_DRAWABLE);
swapchain->render_to_fbo = TRUE;
swapchain_update_draw_bindings(swapchain);
}
else
{
surface_load_location(back_buffer, context, back_buffer->container->resource.draw_binding);
}
if (swapchain->render_to_fbo)
{
static unsigned int once;
if (swapchain->desc.swap_effect == WINED3D_SWAP_EFFECT_FLIP && !once++)
FIXME("WINED3D_SWAP_EFFECT_FLIP not implemented.\n");
swapchain_blit(swapchain, context, &src_rect, &dst_rect);
}
if (swapchain->num_contexts > 1)
gl_info->gl_ops.gl.p_glFinish();
/* call wglSwapBuffers through the gl table to avoid confusing the Steam overlay */
gl_info->gl_ops.wgl.p_wglSwapBuffers(context->hdc); /* TODO: cycle through the swapchain buffers */
TRACE("SwapBuffers called, Starting new frame\n");
/* FPS support */
if (TRACE_ON(fps))
{
DWORD time = GetTickCount();
++swapchain->frames;
/* every 1.5 seconds */
if (time - swapchain->prev_time > 1500)
{
TRACE_(fps)("%p @ approx %.2ffps\n",
swapchain, 1000.0 * swapchain->frames / (time - swapchain->prev_time));
swapchain->prev_time = time;
swapchain->frames = 0;
}
}
front = surface_from_resource(wined3d_texture_get_sub_resource(swapchain->front_buffer, 0));
surface_validate_location(front, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(front, ~WINED3D_LOCATION_DRAWABLE);
/* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM
* and INTEXTURE copies can keep their old content if they have any defined content.
* If the swapeffect is COPY, the content remains the same.
*
* The FLIP swap effect is not implemented yet. We could mark WINED3D_LOCATION_DRAWABLE
* up to date and hope WGL flipped front and back buffers and read this data into
* the FBO. Don't bother about this for now. */
if (fb->depth_stencil)
{
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(ds, WINED3D_LOCATION_DISCARDED,
fb->depth_stencil->width, fb->depth_stencil->height);
if (ds == swapchain->device->onscreen_depth_stencil)
{
wined3d_texture_decref(swapchain->device->onscreen_depth_stencil->container);
swapchain->device->onscreen_depth_stencil = NULL;
}
}
}
context_release(context);
}
static ULONG texture_resource_decref(struct wined3d_resource *resource)
{
return wined3d_texture_decref(wined3d_texture_from_resource(resource));
}
ULONG CDECL wined3d_volume_decref(struct wined3d_volume *volume)
{
TRACE("Forwarding to container %p.\n", volume->container);
return wined3d_texture_decref(volume->container);
}
