| /* |
| * 2D Surface implementation without OpenGL |
| * |
| * Copyright 1997-2000 Marcus Meissner |
| * Copyright 1998-2000 Lionel Ulmer |
| * Copyright 2000-2001 TransGaming Technologies Inc. |
| * Copyright 2002-2005 Jason Edmeades |
| * Copyright 2002-2003 Raphael Junqueira |
| * Copyright 2004 Christian Costa |
| * Copyright 2005 Oliver Stieber |
| * Copyright 2006-2008 Stefan Dösinger |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| #include "wined3d_private.h" |
| |
| #include <assert.h> |
| #include <stdio.h> |
| |
| /* Use the d3d_surface debug channel to have one channel for all surfaces */ |
| WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface); |
| WINE_DECLARE_DEBUG_CHANNEL(fps); |
| |
| /***************************************************************************** |
| * x11_copy_to_screen |
| * |
| * Helper function that blts the front buffer contents to the target window |
| * |
| * Params: |
| * This: Surface to copy from |
| * rc: Rectangle to copy |
| * |
| *****************************************************************************/ |
| static void |
| x11_copy_to_screen(IWineD3DSurfaceImpl *This, |
| LPRECT rc) |
| { |
| if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) |
| { |
| POINT offset = {0,0}; |
| HWND hDisplayWnd; |
| HDC hDisplayDC; |
| HDC hSurfaceDC = 0; |
| RECT drawrect; |
| TRACE("(%p)->(%p): Copying to screen\n", This, rc); |
| |
| hSurfaceDC = This->hDC; |
| |
| hDisplayWnd = This->resource.wineD3DDevice->ddraw_window; |
| hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE); |
| if(rc) |
| { |
| TRACE(" copying rect (%d,%d)->(%d,%d), offset (%d,%d)\n", |
| rc->left, rc->top, rc->right, rc->bottom, offset.x, offset.y); |
| } |
| |
| /* Front buffer coordinates are screen coordinates. Map them to the destination |
| * window if not fullscreened |
| */ |
| if(!This->resource.wineD3DDevice->ddraw_fullscreen) { |
| ClientToScreen(hDisplayWnd, &offset); |
| } |
| #if 0 |
| /* FIXME: this doesn't work... if users really want to run |
| * X in 8bpp, then we need to call directly into display.drv |
| * (or Wine's equivalent), and force a private colormap |
| * without default entries. */ |
| if (This->palette) { |
| SelectPalette(hDisplayDC, This->palette->hpal, FALSE); |
| RealizePalette(hDisplayDC); /* sends messages => deadlocks */ |
| } |
| #endif |
| drawrect.left = 0; |
| drawrect.right = This->currentDesc.Width; |
| drawrect.top = 0; |
| drawrect.bottom = This->currentDesc.Height; |
| |
| #if 0 |
| /* TODO: Support clippers */ |
| if (This->clipper) |
| { |
| RECT xrc; |
| HWND hwnd = ((IWineD3DClipperImpl *) This->clipper)->hWnd; |
| if (hwnd && GetClientRect(hwnd,&xrc)) |
| { |
| OffsetRect(&xrc,offset.x,offset.y); |
| IntersectRect(&drawrect,&drawrect,&xrc); |
| } |
| } |
| #endif |
| if (rc) |
| { |
| IntersectRect(&drawrect,&drawrect,rc); |
| } |
| else |
| { |
| /* Only use this if the caller did not pass a rectangle, since |
| * due to double locking this could be the wrong one ... |
| */ |
| if (This->lockedRect.left != This->lockedRect.right) |
| { |
| IntersectRect(&drawrect,&drawrect,&This->lockedRect); |
| } |
| } |
| |
| BitBlt(hDisplayDC, |
| drawrect.left-offset.x, drawrect.top-offset.y, |
| drawrect.right-drawrect.left, drawrect.bottom-drawrect.top, |
| hSurfaceDC, |
| drawrect.left, drawrect.top, |
| SRCCOPY); |
| ReleaseDC(hDisplayWnd, hDisplayDC); |
| } |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::Release, GDI version |
| * |
| * In general a normal COM Release method, but the GDI version doesn't have |
| * to destroy all the GL things. |
| * |
| *****************************************************************************/ |
| ULONG WINAPI IWineGDISurfaceImpl_Release(IWineD3DSurface *iface) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| ULONG ref = InterlockedDecrement(&This->resource.ref); |
| TRACE("(%p) : Releasing from %d\n", This, ref + 1); |
| if (ref == 0) { |
| IWineD3DDeviceImpl *device = This->resource.wineD3DDevice; |
| TRACE("(%p) : cleaning up\n", This); |
| |
| if(This->Flags & SFLAG_DIBSECTION) { |
| /* Release the DC */ |
| SelectObject(This->hDC, This->dib.holdbitmap); |
| DeleteDC(This->hDC); |
| /* Release the DIB section */ |
| DeleteObject(This->dib.DIBsection); |
| This->dib.bitmap_data = NULL; |
| This->resource.allocatedMemory = NULL; |
| } |
| if(This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem(iface, NULL); |
| |
| HeapFree(GetProcessHeap(), 0, This->palette9); |
| |
| IWineD3DResourceImpl_CleanUp((IWineD3DResource *)iface); |
| if(iface == device->ddraw_primary) |
| device->ddraw_primary = NULL; |
| |
| if(This->overlay_dest) { |
| list_remove(&This->overlay_entry); |
| } |
| |
| TRACE("(%p) Released\n", This); |
| HeapFree(GetProcessHeap(), 0, This); |
| |
| } |
| return ref; |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::PreLoad, GDI version |
| * |
| * This call is unsupported on GDI surfaces, if it's called something went |
| * wrong in the parent library. Write an informative warning |
| * |
| *****************************************************************************/ |
| static void WINAPI |
| IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface) |
| { |
| ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface); |
| ERR("(%p): Most likely the parent library did something wrong.\n", iface); |
| ERR("(%p): Please report to wine-devel\n", iface); |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::UnLoad, GDI version |
| * |
| * This call is unsupported on GDI surfaces, if it's called something went |
| * wrong in the parent library. Write an informative warning. |
| * |
| *****************************************************************************/ |
| static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface) |
| { |
| ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface); |
| ERR("(%p): Most likely the parent library did something wrong.\n", iface); |
| ERR("(%p): Please report to wine-devel\n", iface); |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::LockRect, GDI version |
| * |
| * Locks the surface and returns a pointer to the surface memory |
| * |
| * Params: |
| * pLockedRect: Address to return the locking info at |
| * pRect: Rectangle to lock |
| * Flags: Some flags |
| * |
| * Returns: |
| * WINED3D_OK on success |
| * WINED3DERR_INVALIDCALL on errors |
| * |
| *****************************************************************************/ |
| static HRESULT WINAPI |
| IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface, |
| WINED3DLOCKED_RECT* pLockedRect, |
| CONST RECT* pRect, |
| DWORD Flags) |
| { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| |
| /* Already locked? */ |
| if(This->Flags & SFLAG_LOCKED) |
| { |
| ERR("(%p) Surface already locked\n", This); |
| /* What should I return here? */ |
| return WINED3DERR_INVALIDCALL; |
| } |
| This->Flags |= SFLAG_LOCKED; |
| |
| if(!This->resource.allocatedMemory) { |
| /* This happens on gdi surfaces if the application set a user pointer and resets it. |
| * Recreate the DIB section |
| */ |
| IWineD3DBaseSurfaceImpl_CreateDIBSection(iface); |
| This->resource.allocatedMemory = This->dib.bitmap_data; |
| } |
| |
| return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags); |
| } |
| |
| /***************************************************************************** |
| * 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; |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::Flip, GDI version |
| * |
| * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by |
| * the parent library. This implementation changes the data pointers of the |
| * surfaces and copies the new front buffer content to the screen |
| * |
| * Params: |
| * override: Flipping target(e.g. back buffer) |
| * |
| * Returns: |
| * WINED3D_OK on success |
| * |
| *****************************************************************************/ |
| static HRESULT WINAPI |
| IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface, |
| IWineD3DSurface *override, |
| DWORD Flags) |
| { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; |
| IWineD3DSurfaceImpl *Target = (IWineD3DSurfaceImpl *) override; |
| TRACE("(%p)->(%p,%x)\n", This, override, Flags); |
| |
| TRACE("(%p) Flipping to surface %p\n", This, Target); |
| |
| if(Target == NULL) |
| { |
| ERR("(%p): Can't flip without a target\n", This); |
| return WINED3DERR_INVALIDCALL; |
| } |
| |
| /* Flip the DC */ |
| { |
| HDC tmp; |
| tmp = This->hDC; |
| This->hDC = Target->hDC; |
| Target->hDC = tmp; |
| } |
| |
| /* Flip the DIBsection */ |
| { |
| HBITMAP tmp; |
| tmp = This->dib.DIBsection; |
| This->dib.DIBsection = Target->dib.DIBsection; |
| Target->dib.DIBsection = tmp; |
| } |
| |
| /* Flip the surface data */ |
| { |
| void* tmp; |
| |
| tmp = This->dib.bitmap_data; |
| This->dib.bitmap_data = Target->dib.bitmap_data; |
| Target->dib.bitmap_data = tmp; |
| |
| tmp = This->resource.allocatedMemory; |
| This->resource.allocatedMemory = Target->resource.allocatedMemory; |
| Target->resource.allocatedMemory = tmp; |
| |
| if(This->resource.heapMemory) { |
| ERR("GDI Surface %p has heap memory allocated\n", This); |
| } |
| if(Target->resource.heapMemory) { |
| ERR("GDI Surface %p has heap memory allocated\n", Target); |
| } |
| } |
| |
| /* client_memory should not be different, but just in case */ |
| { |
| BOOL tmp; |
| tmp = This->dib.client_memory; |
| This->dib.client_memory = Target->dib.client_memory; |
| Target->dib.client_memory = tmp; |
| } |
| |
| /* 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 */ |
| x11_copy_to_screen(This, NULL); |
| |
| /* 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; |
| } |
| } |
| |
| return WINED3D_OK; |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::LoadTexture, GDI version |
| * |
| * This is mutually unsupported by GDI surfaces |
| * |
| * Returns: |
| * D3DERR_INVALIDCALL |
| * |
| *****************************************************************************/ |
| HRESULT WINAPI |
| IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) |
| { |
| ERR("Unsupported on X11 surfaces\n"); |
| return WINED3DERR_INVALIDCALL; |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::SaveSnapshot, GDI version |
| * |
| * This method writes the surface's contents to the in tga format to the |
| * file specified in filename. |
| * |
| * Params: |
| * filename: File to write to |
| * |
| * Returns: |
| * WINED3DERR_INVALIDCALL if the file couldn't be opened |
| * WINED3D_OK on success |
| * |
| *****************************************************************************/ |
| static int get_shift(DWORD color_mask) { |
| int shift = 0; |
| while (color_mask > 0xFF) { |
| color_mask >>= 1; |
| shift += 1; |
| } |
| while ((color_mask & 0x80) == 0) { |
| color_mask <<= 1; |
| shift -= 1; |
| } |
| return shift; |
| } |
| |
| |
| HRESULT WINAPI |
| IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, |
| const char* filename) |
| { |
| FILE* f = NULL; |
| UINT y = 0, x = 0; |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| static char *output = NULL; |
| static int size = 0; |
| const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(This->resource.format, NULL, NULL); |
| |
| if (This->pow2Width > size) { |
| output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3); |
| size = This->pow2Width; |
| } |
| |
| |
| f = fopen(filename, "w+"); |
| if (NULL == f) { |
| ERR("opening of %s failed with\n", filename); |
| return WINED3DERR_INVALIDCALL; |
| } |
| fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height); |
| |
| if (This->resource.format == WINED3DFMT_P8) { |
| unsigned char table[256][3]; |
| int i; |
| |
| if (This->palette == NULL) { |
| fclose(f); |
| return WINED3DERR_INVALIDCALL; |
| } |
| for (i = 0; i < 256; i++) { |
| table[i][0] = This->palette->palents[i].peRed; |
| table[i][1] = This->palette->palents[i].peGreen; |
| table[i][2] = This->palette->palents[i].peBlue; |
| } |
| for (y = 0; y < This->pow2Height; y++) { |
| unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface)); |
| for (x = 0; x < This->pow2Width; x++) { |
| unsigned char color = *src; |
| src += 1; |
| |
| output[3 * x + 0] = table[color][0]; |
| output[3 * x + 1] = table[color][1]; |
| output[3 * x + 2] = table[color][2]; |
| } |
| fwrite(output, 3 * This->pow2Width, 1, f); |
| } |
| } else { |
| int red_shift, green_shift, blue_shift, pix_width, alpha_shift; |
| |
| pix_width = This->bytesPerPixel; |
| |
| red_shift = get_shift(formatEntry->redMask); |
| green_shift = get_shift(formatEntry->greenMask); |
| blue_shift = get_shift(formatEntry->blueMask); |
| alpha_shift = get_shift(formatEntry->alphaMask); |
| |
| for (y = 0; y < This->pow2Height; y++) { |
| unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface)); |
| for (x = 0; x < This->pow2Width; x++) { |
| unsigned int color; |
| unsigned int comp; |
| int i; |
| |
| color = 0; |
| for (i = 0; i < pix_width; i++) { |
| color |= src[i] << (8 * i); |
| } |
| src += 1 * pix_width; |
| |
| comp = color & formatEntry->redMask; |
| output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift; |
| comp = color & formatEntry->greenMask; |
| output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift; |
| comp = color & formatEntry->alphaMask; |
| output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift; |
| } |
| fwrite(output, 3 * This->pow2Width, 1, f); |
| } |
| } |
| fclose(f); |
| return WINED3D_OK; |
| } |
| |
| HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| WINED3DLOCKED_RECT lock; |
| HRESULT hr; |
| RGBQUAD col[256]; |
| |
| TRACE("(%p)->(%p)\n",This,pHDC); |
| |
| if(This->Flags & SFLAG_USERPTR) { |
| ERR("Not supported on surfaces with an application-provided surfaces\n"); |
| return WINEDDERR_NODC; |
| } |
| |
| /* Give more detailed info for ddraw */ |
| if (This->Flags & SFLAG_DCINUSE) |
| return WINEDDERR_DCALREADYCREATED; |
| |
| /* Can't GetDC if the surface is locked */ |
| if (This->Flags & SFLAG_LOCKED) |
| return WINED3DERR_INVALIDCALL; |
| |
| memset(&lock, 0, sizeof(lock)); /* To be sure */ |
| |
| /* Should have a DIB section already */ |
| |
| /* Lock the surface */ |
| hr = IWineD3DSurface_LockRect(iface, |
| &lock, |
| NULL, |
| 0); |
| if(FAILED(hr)) { |
| ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr); |
| /* keep the dib section */ |
| return hr; |
| } |
| |
| if(This->resource.format == WINED3DFMT_P8 || |
| This->resource.format == WINED3DFMT_A8P8) { |
| unsigned int n; |
| PALETTEENTRY *pal = NULL; |
| |
| if(This->palette) { |
| pal = This->palette->palents; |
| } else { |
| IWineD3DSurfaceImpl *dds_primary = (IWineD3DSurfaceImpl *)This->resource.wineD3DDevice->ddraw_primary; |
| if (dds_primary && dds_primary->palette) |
| pal = dds_primary->palette->palents; |
| } |
| |
| if (pal) { |
| for (n=0; n<256; n++) { |
| col[n].rgbRed = pal[n].peRed; |
| col[n].rgbGreen = pal[n].peGreen; |
| col[n].rgbBlue = pal[n].peBlue; |
| col[n].rgbReserved = 0; |
| } |
| SetDIBColorTable(This->hDC, 0, 256, col); |
| } |
| } |
| |
| *pHDC = This->hDC; |
| TRACE("returning %p\n",*pHDC); |
| This->Flags |= SFLAG_DCINUSE; |
| |
| return WINED3D_OK; |
| } |
| |
| HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| |
| TRACE("(%p)->(%p)\n",This,hDC); |
| |
| if (!(This->Flags & SFLAG_DCINUSE)) |
| return WINED3DERR_INVALIDCALL; |
| |
| if (This->hDC !=hDC) { |
| WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC); |
| return WINED3DERR_INVALIDCALL; |
| } |
| |
| /* we locked first, so unlock now */ |
| IWineD3DSurface_UnlockRect(iface); |
| |
| This->Flags &= ~SFLAG_DCINUSE; |
| |
| return WINED3D_OK; |
| } |
| |
| HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; |
| RGBQUAD col[256]; |
| IWineD3DPaletteImpl *pal = This->palette; |
| unsigned int n; |
| TRACE("(%p)\n", This); |
| |
| if (!pal) return WINED3D_OK; |
| |
| if(This->Flags & SFLAG_DIBSECTION) { |
| TRACE("(%p): Updating the hdc's palette\n", This); |
| for (n=0; n<256; n++) { |
| col[n].rgbRed = pal->palents[n].peRed; |
| col[n].rgbGreen = pal->palents[n].peGreen; |
| col[n].rgbBlue = pal->palents[n].peBlue; |
| col[n].rgbReserved = 0; |
| } |
| SetDIBColorTable(This->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. */ |
| if(This == (IWineD3DSurfaceImpl *) This->resource.wineD3DDevice->ddraw_primary) |
| x11_copy_to_screen(This, NULL); |
| |
| return WINED3D_OK; |
| } |
| |
| /***************************************************************************** |
| * IWineD3DSurface::PrivateSetup, GDI version |
| * |
| * Initializes the GDI surface, aka creates the DIB section we render to |
| * The DIB section creation is done by calling GetDC, which will create the |
| * section and releasing the dc to allow the app to use it. The dib section |
| * will stay until the surface is released |
| * |
| * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes |
| * are set to the real sizes to save memory. The NONPOW2 flag is unset to |
| * avoid confusion in the shared surface code. |
| * |
| * Returns: |
| * WINED3D_OK on success |
| * The return values of called methods on failure |
| * |
| *****************************************************************************/ |
| HRESULT WINAPI |
| IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface) |
| { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; |
| |
| if(This->resource.usage & WINED3DUSAGE_OVERLAY) |
| { |
| ERR("(%p) Overlays not yet supported by GDI surfaces\n", This); |
| return WINED3DERR_INVALIDCALL; |
| } |
| /* Sysmem textures have memory already allocated - |
| * release it, this avoids an unnecessary memcpy |
| */ |
| HeapFree(GetProcessHeap(), 0, This->resource.heapMemory); |
| This->resource.allocatedMemory = NULL; |
| This->resource.heapMemory = NULL; |
| |
| /* We don't mind the nonpow2 stuff in GDI */ |
| This->pow2Width = This->currentDesc.Width; |
| This->pow2Height = This->currentDesc.Height; |
| |
| IWineD3DBaseSurfaceImpl_CreateDIBSection(iface); |
| This->resource.allocatedMemory = This->dib.bitmap_data; |
| |
| return WINED3D_OK; |
| } |
| |
| void WINAPI IWineGDISurfaceImpl_SetGlTextureDesc(IWineD3DSurface *iface, UINT textureName, int target) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| |
| /* Ignore 0 textureName and target. D3D textures can be created with gdi surfaces as plain |
| * containers, but they're useless until the app creates a d3d device from a d3d point of |
| * view, it's not an implementation limitation. This avoids false warnings when the texture |
| * is destroyed and sets the description back to 0/0 |
| */ |
| if(textureName != 0 || target != 0) { |
| FIXME("(%p) : Should not be called on a GDI surface. textureName %u, target %i\n", This, textureName, target); |
| DebugBreak(); |
| } |
| } |
| |
| void WINAPI IWineGDISurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; |
| FIXME("(%p) : Should not be called on a GDI surface\n", This); |
| *glDescription = NULL; |
| } |
| |
| HRESULT WINAPI IWineGDISurfaceImpl_AddDirtyRect(IWineD3DSurface *iface, CONST RECT* pDirtyRect) { |
| /* GDI surface data can only be in one location, the system memory dib section. So they are |
| * always clean by definition. |
| */ |
| TRACE("No dirtification in GDI surfaces\n"); |
| return WINED3D_OK; |
| } |
| |
| HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) { |
| IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; |
| |
| /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */ |
| if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) { |
| ERR("Not supported on render targets\n"); |
| return WINED3DERR_INVALIDCALL; |
| } |
| |
| if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) { |
| WARN("Surface is locked or the HDC is in use\n"); |
| return WINED3DERR_INVALIDCALL; |
| } |
| |
| if(Mem && Mem != This->resource.allocatedMemory) { |
| void *release = NULL; |
| |
| /* Do I have to copy the old surface content? */ |
| if(This->Flags & SFLAG_DIBSECTION) { |
| /* Release the DC. No need to hold the critical section for the update |
| * Thread because this thread runs only on front buffers, but this method |
| * fails for render targets in the check above. |
| */ |
| SelectObject(This->hDC, This->dib.holdbitmap); |
| DeleteDC(This->hDC); |
| /* Release the DIB section */ |
| DeleteObject(This->dib.DIBsection); |
| This->dib.bitmap_data = NULL; |
| This->resource.allocatedMemory = NULL; |
| This->hDC = NULL; |
| This->Flags &= ~SFLAG_DIBSECTION; |
| } else if(!(This->Flags & SFLAG_USERPTR)) { |
| release = This->resource.allocatedMemory; |
| } |
| This->resource.allocatedMemory = Mem; |
| This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM; |
| |
| /* Now free the old memory if any */ |
| HeapFree(GetProcessHeap(), 0, release); |
| } else if(This->Flags & SFLAG_USERPTR) { |
| /* LockRect and GetDC will re-create the dib section and allocated memory */ |
| This->resource.allocatedMemory = NULL; |
| This->Flags &= ~SFLAG_USERPTR; |
| } |
| return WINED3D_OK; |
| } |
| |
| /*************************** |
| * |
| ***************************/ |
| static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) { |
| TRACE("(%p)->(%s, %s)\n", iface, |
| flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE", |
| persistent ? "TRUE" : "FALSE"); |
| /* GDI surfaces can be in system memory only */ |
| if(flag != SFLAG_INSYSMEM) { |
| ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture"); |
| } |
| } |
| |
| static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) { |
| if(flag != SFLAG_INSYSMEM) { |
| ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable"); |
| } else { |
| TRACE("Surface requested in surface memory\n"); |
| } |
| return WINED3D_OK; |
| } |
| |
| static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) { |
| return SURFACE_GDI; |
| } |
| |
| static HRESULT WINAPI IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface *iface) { |
| FIXME("GDI surfaces can't draw overlays yet\n"); |
| return E_FAIL; |
| } |
| |
| /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions, |
| * only IWineD3DBaseSurface and IWineGDISurface ones. |
| */ |
| const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl = |
| { |
| /* IUnknown */ |
| IWineD3DBaseSurfaceImpl_QueryInterface, |
| IWineD3DBaseSurfaceImpl_AddRef, |
| IWineGDISurfaceImpl_Release, |
| /* IWineD3DResource */ |
| IWineD3DBaseSurfaceImpl_GetParent, |
| IWineD3DBaseSurfaceImpl_GetDevice, |
| IWineD3DBaseSurfaceImpl_SetPrivateData, |
| IWineD3DBaseSurfaceImpl_GetPrivateData, |
| IWineD3DBaseSurfaceImpl_FreePrivateData, |
| IWineD3DBaseSurfaceImpl_SetPriority, |
| IWineD3DBaseSurfaceImpl_GetPriority, |
| IWineGDISurfaceImpl_PreLoad, |
| IWineGDISurfaceImpl_UnLoad, |
| IWineD3DBaseSurfaceImpl_GetType, |
| /* IWineD3DSurface */ |
| IWineD3DBaseSurfaceImpl_GetContainer, |
| IWineD3DBaseSurfaceImpl_GetDesc, |
| IWineGDISurfaceImpl_LockRect, |
| IWineGDISurfaceImpl_UnlockRect, |
| IWineGDISurfaceImpl_GetDC, |
| IWineGDISurfaceImpl_ReleaseDC, |
| IWineGDISurfaceImpl_Flip, |
| IWineD3DBaseSurfaceImpl_Blt, |
| IWineD3DBaseSurfaceImpl_GetBltStatus, |
| IWineD3DBaseSurfaceImpl_GetFlipStatus, |
| IWineD3DBaseSurfaceImpl_IsLost, |
| IWineD3DBaseSurfaceImpl_Restore, |
| IWineD3DBaseSurfaceImpl_BltFast, |
| IWineD3DBaseSurfaceImpl_GetPalette, |
| IWineD3DBaseSurfaceImpl_SetPalette, |
| IWineGDISurfaceImpl_RealizePalette, |
| IWineD3DBaseSurfaceImpl_SetColorKey, |
| IWineD3DBaseSurfaceImpl_GetPitch, |
| IWineGDISurfaceImpl_SetMem, |
| IWineD3DBaseSurfaceImpl_SetOverlayPosition, |
| IWineD3DBaseSurfaceImpl_GetOverlayPosition, |
| IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder, |
| IWineD3DBaseSurfaceImpl_UpdateOverlay, |
| IWineD3DBaseSurfaceImpl_SetClipper, |
| IWineD3DBaseSurfaceImpl_GetClipper, |
| /* Internal use: */ |
| IWineGDISurfaceImpl_AddDirtyRect, |
| IWineGDISurfaceImpl_LoadTexture, |
| IWineD3DBaseSurfaceImpl_BindTexture, |
| IWineGDISurfaceImpl_SaveSnapshot, |
| IWineD3DBaseSurfaceImpl_SetContainer, |
| IWineGDISurfaceImpl_SetGlTextureDesc, |
| IWineGDISurfaceImpl_GetGlDesc, |
| IWineD3DSurfaceImpl_GetData, |
| IWineD3DBaseSurfaceImpl_SetFormat, |
| IWineGDISurfaceImpl_PrivateSetup, |
| IWineGDISurfaceImpl_ModifyLocation, |
| IWineGDISurfaceImpl_LoadLocation, |
| IWineGDISurfaceImpl_GetImplType, |
| IWineGDISurfaceImpl_DrawOverlay |
| }; |
