static HRESULT WINAPI IWineGDISurfaceImpl_Unmap(IWineD3DSurface *iface)
{
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
TRACE("(%p)\n", This);
if (!(This->Flags & SFLAG_LOCKED))
{
WARN("Trying to unmap unmapped surfaces %p.\n", iface);
return WINEDDERR_NOTLOCKED;
}
/* Tell the swapchain to update the screen */
if (This->container.type == WINED3D_CONTAINER_SWAPCHAIN)
{
IWineD3DSwapChainImpl *swapchain = This->container.u.swapchain;
if (This == swapchain->front_buffer)
{
x11_copy_to_screen(swapchain, &This->lockedRect);
}
}
This->Flags &= ~SFLAG_LOCKED;
memset(&This->lockedRect, 0, sizeof(RECT));
return WINED3D_OK;
}
static void swapchain_gdi_present(struct wined3d_swapchain *swapchain, const RECT *src_rect_in,
const RECT *dst_rect_in, const RGNDATA *dirty_region, DWORD flags,
struct wined3d_surface *depth_stencil)
{
struct wined3d_surface *front, *back;
front = swapchain->front_buffer;
back = swapchain->back_buffers[0];
/* Flip the DC. */
{
HDC tmp;
tmp = front->hDC;
front->hDC = back->hDC;
back->hDC = tmp;
}
/* Flip the DIBsection. */
{
HBITMAP tmp;
tmp = front->dib.DIBsection;
front->dib.DIBsection = back->dib.DIBsection;
back->dib.DIBsection = tmp;
}
/* Flip the surface data. */
{
void *tmp;
tmp = front->resource.bitmap_data;
front->resource.bitmap_data = back->resource.bitmap_data;
back->resource.bitmap_data = tmp;
if (front->resource.heap_memory)
ERR("GDI Surface %p has heap memory allocated.\n", front);
if (back->resource.heap_memory)
ERR("GDI Surface %p has heap memory allocated.\n", back);
}
/* FPS support */
if (TRACE_ON(fps))
{
static LONG prev_time, frames;
DWORD time = GetTickCount();
++frames;
/* every 1.5 seconds */
if (time - prev_time > 1500)
{
TRACE_(fps)("@ approx %.2ffps\n", 1000.0 * frames / (time - prev_time));
prev_time = time;
frames = 0;
}
}
x11_copy_to_screen(swapchain, NULL);
}
/*****************************************************************************
* IWineD3DSurface::UnlockRect, GDI version
*
* Unlocks a surface. This implementation doesn't do much, except updating
* the window if the front buffer is unlocked
*
* Returns:
* WINED3D_OK on success
* WINED3DERR_INVALIDCALL on failure
*
*****************************************************************************/
static HRESULT WINAPI
IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
{
IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
TRACE("(%p)\n", This);
if (!(This->Flags & SFLAG_LOCKED))
{
WARN("trying to Unlock an unlocked surf@%p\n", This);
return WINED3DERR_INVALIDCALL;
}
/* Can be useful for debugging */
#if 0
{
static unsigned int gen = 0;
char buffer[4096];
++gen;
if ((gen % 10) == 0) {
snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
}
/*
* debugging crash code
if (gen == 250) {
void** test = NULL;
*test = 0;
}
*/
}
#endif
/* Update the screen */
if(This == (IWineD3DSurfaceImpl *) dev->ddraw_primary)
{
x11_copy_to_screen(This, &This->lockedRect);
}
This->Flags &= ~SFLAG_LOCKED;
memset(&This->lockedRect, 0, sizeof(RECT));
return WINED3D_OK;
}
static void gdi_surface_realize_palette(IWineD3DSurfaceImpl *surface)
{
struct wined3d_palette *palette = surface->palette;
TRACE("surface %p.\n", surface);
if (!palette) return;
if (surface->flags & SFLAG_DIBSECTION)
{
RGBQUAD col[256];
unsigned int i;
TRACE("Updating the DC's palette.\n");
for (i = 0; i < 256; ++i)
{
col[i].rgbRed = palette->palents[i].peRed;
col[i].rgbGreen = palette->palents[i].peGreen;
col[i].rgbBlue = palette->palents[i].peBlue;
col[i].rgbReserved = 0;
}
SetDIBColorTable(surface->hDC, 0, 256, col);
}
/* Update the image because of the palette change. Some games like e.g.
* Red Alert call SetEntries a lot to implement fading. */
/* Tell the swapchain to update the screen. */
if (surface->container.type == WINED3D_CONTAINER_SWAPCHAIN)
{
IWineD3DSwapChainImpl *swapchain = surface->container.u.swapchain;
if (surface == swapchain->front_buffer)
{
x11_copy_to_screen(swapchain, NULL);
}
}
}
static HRESULT swapchain_gdi_present(struct wined3d_swapchain *swapchain, const RECT *src_rect_in,
const RECT *dst_rect_in, const RGNDATA *dirty_region, DWORD flags)
{
struct wined3d_surface *front, *back;
if (!swapchain->back_buffers)
{
WARN("Swapchain doesn't have a backbuffer, returning WINED3DERR_INVALIDCALL\n");
return WINED3DERR_INVALIDCALL;
}
front = swapchain->front_buffer;
back = swapchain->back_buffers[0];
/* Flip the DC. */
{
HDC tmp;
tmp = front->hDC;
front->hDC = back->hDC;
back->hDC = tmp;
}
/* Flip the DIBsection. */
{
HBITMAP tmp;
tmp = front->dib.DIBsection;
front->dib.DIBsection = back->dib.DIBsection;
back->dib.DIBsection = tmp;
}
/* Flip the surface data. */
{
void *tmp;
tmp = front->dib.bitmap_data;
front->dib.bitmap_data = back->dib.bitmap_data;
back->dib.bitmap_data = tmp;
tmp = front->resource.allocatedMemory;
front->resource.allocatedMemory = back->resource.allocatedMemory;
back->resource.allocatedMemory = tmp;
if (front->resource.heapMemory)
ERR("GDI Surface %p has heap memory allocated.\n", front);
if (back->resource.heapMemory)
ERR("GDI Surface %p has heap memory allocated.\n", back);
}
/* FPS support */
if (TRACE_ON(fps))
{
static LONG prev_time, frames;
DWORD time = GetTickCount();
++frames;
/* every 1.5 seconds */
if (time - prev_time > 1500)
{
TRACE_(fps)("@ approx %.2ffps\n", 1000.0 * frames / (time - prev_time));
prev_time = time;
frames = 0;
}
}
x11_copy_to_screen(swapchain, NULL);
return WINED3D_OK;
}
static HRESULT WINAPI IWineGDISwapChainImpl_Present(IWineD3DSwapChain *iface,
const RECT *pSourceRect, const RECT *pDestRect, HWND hDestWindowOverride,
const RGNDATA *pDirtyRegion, DWORD flags)
{
IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *) iface;
IWineD3DSurfaceImpl *front, *back;
if (!This->back_buffers)
{
WARN("Swapchain doesn't have a backbuffer, returning WINED3DERR_INVALIDCALL\n");
return WINED3DERR_INVALIDCALL;
}
front = This->front_buffer;
back = This->back_buffers[0];
/* Flip the DC */
{
HDC tmp;
tmp = front->hDC;
front->hDC = back->hDC;
back->hDC = tmp;
}
/* Flip the DIBsection */
{
HBITMAP tmp;
tmp = front->dib.DIBsection;
front->dib.DIBsection = back->dib.DIBsection;
back->dib.DIBsection = tmp;
}
/* Flip the surface data */
{
void* tmp;
tmp = front->dib.bitmap_data;
front->dib.bitmap_data = back->dib.bitmap_data;
back->dib.bitmap_data = tmp;
tmp = front->resource.allocatedMemory;
front->resource.allocatedMemory = back->resource.allocatedMemory;
back->resource.allocatedMemory = tmp;
if(front->resource.heapMemory) {
ERR("GDI Surface %p has heap memory allocated\n", front);
}
if(back->resource.heapMemory) {
ERR("GDI Surface %p has heap memory allocated\n", back);
}
}
/* client_memory should not be different, but just in case */
{
BOOL tmp;
tmp = front->dib.client_memory;
front->dib.client_memory = back->dib.client_memory;
back->dib.client_memory = tmp;
}
/* FPS support */
if (TRACE_ON(fps))
{
static LONG prev_time, frames;
DWORD time = GetTickCount();
frames++;
/* every 1.5 seconds */
if (time - prev_time > 1500) {
TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
prev_time = time;
frames = 0;
}
}
x11_copy_to_screen(This, NULL);
return WINED3D_OK;
}
