2 * 2D Surface implementation without OpenGL
4 * Copyright 1997-2000 Marcus Meissner
5 * Copyright 1998-2000 Lionel Ulmer
6 * Copyright 2000-2001 TransGaming Technologies Inc.
7 * Copyright 2002-2005 Jason Edmeades
8 * Copyright 2002-2003 Raphael Junqueira
9 * Copyright 2004 Christian Costa
10 * Copyright 2005 Oliver Stieber
11 * Copyright 2006-2008 Stefan Dösinger
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "wine/port.h"
30 #include "wined3d_private.h"
34 /* Use the d3d_surface debug channel to have one channel for all surfaces */
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
37 void surface_gdi_cleanup(IWineD3DSurfaceImpl
*This
)
39 TRACE("(%p) : Cleaning up.\n", This
);
41 if (This
->Flags
& SFLAG_DIBSECTION
)
44 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
46 /* Release the DIB section. */
47 DeleteObject(This
->dib
.DIBsection
);
48 This
->dib
.bitmap_data
= NULL
;
49 This
->resource
.allocatedMemory
= NULL
;
52 if (This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem((IWineD3DSurface
*)This
, NULL
);
53 if (This
->overlay_dest
) list_remove(&This
->overlay_entry
);
55 HeapFree(GetProcessHeap(), 0, This
->palette9
);
57 resource_cleanup((IWineD3DResource
*)This
);
60 /*****************************************************************************
61 * IWineD3DSurface::Release, GDI version
63 * In general a normal COM Release method, but the GDI version doesn't have
64 * to destroy all the GL things.
66 *****************************************************************************/
67 static ULONG WINAPI
IWineGDISurfaceImpl_Release(IWineD3DSurface
*iface
) {
68 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
69 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
70 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
74 surface_gdi_cleanup(This
);
76 TRACE("(%p) Released.\n", This
);
77 HeapFree(GetProcessHeap(), 0, This
);
83 /*****************************************************************************
84 * IWineD3DSurface::PreLoad, GDI version
86 * This call is unsupported on GDI surfaces, if it's called something went
87 * wrong in the parent library. Write an informative warning
89 *****************************************************************************/
91 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface
*iface
)
93 ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface
);
94 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
95 ERR("(%p): Please report to wine-devel\n", iface
);
98 /*****************************************************************************
99 * IWineD3DSurface::UnLoad, GDI version
101 * This call is unsupported on GDI surfaces, if it's called something went
102 * wrong in the parent library. Write an informative warning.
104 *****************************************************************************/
105 static void WINAPI
IWineGDISurfaceImpl_UnLoad(IWineD3DSurface
*iface
)
107 ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface
);
108 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
109 ERR("(%p): Please report to wine-devel\n", iface
);
112 /*****************************************************************************
113 * IWineD3DSurface::LockRect, GDI version
115 * Locks the surface and returns a pointer to the surface memory
118 * pLockedRect: Address to return the locking info at
119 * pRect: Rectangle to lock
123 * WINED3D_OK on success
124 * WINED3DERR_INVALIDCALL on errors
126 *****************************************************************************/
127 static HRESULT WINAPI
128 IWineGDISurfaceImpl_LockRect(IWineD3DSurface
*iface
,
129 WINED3DLOCKED_RECT
* pLockedRect
,
133 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
135 /* Already locked? */
136 if(This
->Flags
& SFLAG_LOCKED
)
138 WARN("(%p) Surface already locked\n", This
);
139 /* What should I return here? */
140 return WINED3DERR_INVALIDCALL
;
142 This
->Flags
|= SFLAG_LOCKED
;
144 if(!This
->resource
.allocatedMemory
) {
145 /* This happens on gdi surfaces if the application set a user pointer and resets it.
146 * Recreate the DIB section
148 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
149 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
152 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
155 /*****************************************************************************
156 * IWineD3DSurface::UnlockRect, GDI version
158 * Unlocks a surface. This implementation doesn't do much, except updating
159 * the window if the front buffer is unlocked
162 * WINED3D_OK on success
163 * WINED3DERR_INVALIDCALL on failure
165 *****************************************************************************/
166 static HRESULT WINAPI
167 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface
*iface
)
169 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
170 IWineD3DSwapChainImpl
*swapchain
= NULL
;
171 TRACE("(%p)\n", This
);
173 if (!(This
->Flags
& SFLAG_LOCKED
))
175 WARN("trying to Unlock an unlocked surf@%p\n", This
);
176 return WINEDDERR_NOTLOCKED
;
179 /* Can be useful for debugging */
182 static unsigned int gen
= 0;
185 if ((gen
% 10) == 0) {
186 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
187 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
190 * debugging crash code
199 /* Tell the swapchain to update the screen */
200 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
202 x11_copy_to_screen(swapchain
, &This
->lockedRect
);
203 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
206 This
->Flags
&= ~SFLAG_LOCKED
;
207 memset(&This
->lockedRect
, 0, sizeof(RECT
));
211 /*****************************************************************************
212 * IWineD3DSurface::Flip, GDI version
214 * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
215 * the parent library. This implementation changes the data pointers of the
216 * surfaces and copies the new front buffer content to the screen
219 * override: Flipping target(e.g. back buffer)
222 * WINED3D_OK on success
224 *****************************************************************************/
225 static HRESULT WINAPI
226 IWineGDISurfaceImpl_Flip(IWineD3DSurface
*iface
,
227 IWineD3DSurface
*override
,
230 IWineD3DSwapChainImpl
*swapchain
= NULL
;
233 if(FAILED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
235 ERR("Flipped surface is not on a swapchain\n");
236 return WINEDDERR_NOTFLIPPABLE
;
239 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
240 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
244 /*****************************************************************************
245 * IWineD3DSurface::LoadTexture, GDI version
247 * This is mutually unsupported by GDI surfaces
252 *****************************************************************************/
253 static HRESULT WINAPI
254 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
)
256 ERR("Unsupported on X11 surfaces\n");
257 return WINED3DERR_INVALIDCALL
;
260 /*****************************************************************************
261 * IWineD3DSurface::SaveSnapshot, GDI version
263 * This method writes the surface's contents to the in tga format to the
264 * file specified in filename.
267 * filename: File to write to
270 * WINED3DERR_INVALIDCALL if the file couldn't be opened
271 * WINED3D_OK on success
273 *****************************************************************************/
274 static int get_shift(DWORD color_mask
) {
276 while (color_mask
> 0xFF) {
280 while ((color_mask
& 0x80) == 0) {
288 static HRESULT WINAPI
289 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
,
290 const char* filename
)
294 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
295 static char *output
= NULL
;
296 static UINT size
= 0;
297 const struct GlPixelFormatDesc
*format_desc
= This
->resource
.format_desc
;
299 if (This
->pow2Width
> size
) {
300 output
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->pow2Width
* 3);
301 size
= This
->pow2Width
;
305 f
= fopen(filename
, "w+");
307 ERR("opening of %s failed with\n", filename
);
308 return WINED3DERR_INVALIDCALL
;
310 fprintf(f
, "P6\n%d %d\n255\n", This
->pow2Width
, This
->pow2Height
);
312 if (This
->resource
.format_desc
->format
== WINED3DFMT_P8
)
314 unsigned char table
[256][3];
317 if (This
->palette
== NULL
) {
319 return WINED3DERR_INVALIDCALL
;
321 for (i
= 0; i
< 256; i
++) {
322 table
[i
][0] = This
->palette
->palents
[i
].peRed
;
323 table
[i
][1] = This
->palette
->palents
[i
].peGreen
;
324 table
[i
][2] = This
->palette
->palents
[i
].peBlue
;
326 for (y
= 0; y
< This
->pow2Height
; y
++) {
327 unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
328 for (x
= 0; x
< This
->pow2Width
; x
++) {
329 unsigned char color
= *src
;
332 output
[3 * x
+ 0] = table
[color
][0];
333 output
[3 * x
+ 1] = table
[color
][1];
334 output
[3 * x
+ 2] = table
[color
][2];
336 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
339 int red_shift
, green_shift
, blue_shift
, pix_width
, alpha_shift
;
341 pix_width
= format_desc
->byte_count
;
343 red_shift
= get_shift(format_desc
->red_mask
);
344 green_shift
= get_shift(format_desc
->green_mask
);
345 blue_shift
= get_shift(format_desc
->blue_mask
);
346 alpha_shift
= get_shift(format_desc
->alpha_mask
);
348 for (y
= 0; y
< This
->pow2Height
; y
++) {
349 const unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
350 for (x
= 0; x
< This
->pow2Width
; x
++) {
356 for (i
= 0; i
< pix_width
; i
++) {
357 color
|= src
[i
] << (8 * i
);
359 src
+= 1 * pix_width
;
361 comp
= color
& format_desc
->red_mask
;
362 output
[3 * x
+ 0] = red_shift
> 0 ? comp
>> red_shift
: comp
<< -red_shift
;
363 comp
= color
& format_desc
->green_mask
;
364 output
[3 * x
+ 1] = green_shift
> 0 ? comp
>> green_shift
: comp
<< -green_shift
;
365 comp
= color
& format_desc
->alpha_mask
;
366 output
[3 * x
+ 2] = alpha_shift
> 0 ? comp
>> alpha_shift
: comp
<< -alpha_shift
;
368 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
375 static HRESULT WINAPI
IWineGDISurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
376 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
377 WINED3DLOCKED_RECT lock
;
381 TRACE("(%p)->(%p)\n",This
,pHDC
);
383 if(This
->Flags
& SFLAG_USERPTR
) {
384 ERR("Not supported on surfaces with an application-provided surfaces\n");
385 return WINEDDERR_NODC
;
388 /* Give more detailed info for ddraw */
389 if (This
->Flags
& SFLAG_DCINUSE
)
390 return WINEDDERR_DCALREADYCREATED
;
392 /* Can't GetDC if the surface is locked */
393 if (This
->Flags
& SFLAG_LOCKED
)
394 return WINED3DERR_INVALIDCALL
;
396 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
398 /* Should have a DIB section already */
400 /* Lock the surface */
401 hr
= IWineD3DSurface_LockRect(iface
,
406 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
407 /* keep the dib section */
411 if (This
->resource
.format_desc
->format
== WINED3DFMT_P8
412 || This
->resource
.format_desc
->format
== WINED3DFMT_A8P8
)
415 const PALETTEENTRY
*pal
= NULL
;
418 pal
= This
->palette
->palents
;
420 IWineD3DSurfaceImpl
*dds_primary
;
421 IWineD3DSwapChainImpl
*swapchain
;
422 swapchain
= (IWineD3DSwapChainImpl
*)This
->resource
.wineD3DDevice
->swapchains
[0];
423 dds_primary
= (IWineD3DSurfaceImpl
*)swapchain
->frontBuffer
;
424 if (dds_primary
&& dds_primary
->palette
)
425 pal
= dds_primary
->palette
->palents
;
429 for (n
=0; n
<256; n
++) {
430 col
[n
].rgbRed
= pal
[n
].peRed
;
431 col
[n
].rgbGreen
= pal
[n
].peGreen
;
432 col
[n
].rgbBlue
= pal
[n
].peBlue
;
433 col
[n
].rgbReserved
= 0;
435 SetDIBColorTable(This
->hDC
, 0, 256, col
);
440 TRACE("returning %p\n",*pHDC
);
441 This
->Flags
|= SFLAG_DCINUSE
;
446 static HRESULT WINAPI
IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
447 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
449 TRACE("(%p)->(%p)\n",This
,hDC
);
451 if (!(This
->Flags
& SFLAG_DCINUSE
))
452 return WINEDDERR_NODC
;
454 if (This
->hDC
!=hDC
) {
455 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
456 return WINEDDERR_NODC
;
459 /* we locked first, so unlock now */
460 IWineD3DSurface_UnlockRect(iface
);
462 This
->Flags
&= ~SFLAG_DCINUSE
;
467 static HRESULT WINAPI
IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
468 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
470 IWineD3DPaletteImpl
*pal
= This
->palette
;
472 IWineD3DSwapChainImpl
*swapchain
;
473 TRACE("(%p)\n", This
);
475 if (!pal
) return WINED3D_OK
;
477 if(This
->Flags
& SFLAG_DIBSECTION
) {
478 TRACE("(%p): Updating the hdc's palette\n", This
);
479 for (n
=0; n
<256; n
++) {
480 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
481 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
482 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
483 col
[n
].rgbReserved
= 0;
485 SetDIBColorTable(This
->hDC
, 0, 256, col
);
488 /* Update the image because of the palette change. Some games like e.g Red Alert
489 call SetEntries a lot to implement fading. */
490 /* Tell the swapchain to update the screen */
491 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
493 x11_copy_to_screen(swapchain
, NULL
);
494 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
500 /*****************************************************************************
501 * IWineD3DSurface::PrivateSetup, GDI version
503 * Initializes the GDI surface, aka creates the DIB section we render to
504 * The DIB section creation is done by calling GetDC, which will create the
505 * section and releasing the dc to allow the app to use it. The dib section
506 * will stay until the surface is released
508 * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
509 * are set to the real sizes to save memory. The NONPOW2 flag is unset to
510 * avoid confusion in the shared surface code.
513 * WINED3D_OK on success
514 * The return values of called methods on failure
516 *****************************************************************************/
517 static HRESULT WINAPI
518 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
)
520 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
522 if(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
)
524 ERR("(%p) Overlays not yet supported by GDI surfaces\n", This
);
525 return WINED3DERR_INVALIDCALL
;
527 /* Sysmem textures have memory already allocated -
528 * release it, this avoids an unnecessary memcpy
530 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
531 This
->resource
.allocatedMemory
= NULL
;
532 This
->resource
.heapMemory
= NULL
;
534 /* We don't mind the nonpow2 stuff in GDI */
535 This
->pow2Width
= This
->currentDesc
.Width
;
536 This
->pow2Height
= This
->currentDesc
.Height
;
538 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
539 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
544 static void WINAPI
IWineGDISurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
545 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
546 FIXME("(%p) : Should not be called on a GDI surface\n", This
);
547 *glDescription
= NULL
;
550 static HRESULT WINAPI
IWineGDISurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
551 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
553 /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
554 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
555 ERR("Not supported on render targets\n");
556 return WINED3DERR_INVALIDCALL
;
559 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
560 WARN("Surface is locked or the HDC is in use\n");
561 return WINED3DERR_INVALIDCALL
;
564 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
565 void *release
= NULL
;
567 /* Do I have to copy the old surface content? */
568 if(This
->Flags
& SFLAG_DIBSECTION
) {
569 /* Release the DC. No need to hold the critical section for the update
570 * Thread because this thread runs only on front buffers, but this method
571 * fails for render targets in the check above.
573 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
575 /* Release the DIB section */
576 DeleteObject(This
->dib
.DIBsection
);
577 This
->dib
.bitmap_data
= NULL
;
578 This
->resource
.allocatedMemory
= NULL
;
580 This
->Flags
&= ~SFLAG_DIBSECTION
;
581 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
582 release
= This
->resource
.allocatedMemory
;
584 This
->resource
.allocatedMemory
= Mem
;
585 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
587 /* Now free the old memory if any */
588 HeapFree(GetProcessHeap(), 0, release
);
589 } else if(This
->Flags
& SFLAG_USERPTR
) {
590 /* LockRect and GetDC will re-create the dib section and allocated memory */
591 This
->resource
.allocatedMemory
= NULL
;
592 This
->Flags
&= ~SFLAG_USERPTR
;
597 /***************************
599 ***************************/
600 static void WINAPI
IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
601 TRACE("(%p)->(%s, %s)\n", iface
,
602 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
603 persistent
? "TRUE" : "FALSE");
604 /* GDI surfaces can be in system memory only */
605 if(flag
!= SFLAG_INSYSMEM
) {
606 ERR("GDI Surface requested in gl %s memory\n", flag
== SFLAG_INDRAWABLE
? "drawable" : "texture");
610 static HRESULT WINAPI
IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
611 if(flag
!= SFLAG_INSYSMEM
) {
612 ERR("GDI Surface requested to be copied to gl %s\n", flag
== SFLAG_INTEXTURE
? "texture" : "drawable");
614 TRACE("Surface requested in surface memory\n");
619 static WINED3DSURFTYPE WINAPI
IWineGDISurfaceImpl_GetImplType(IWineD3DSurface
*iface
) {
623 static HRESULT WINAPI
IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface
*iface
) {
624 FIXME("GDI surfaces can't draw overlays yet\n");
628 /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
629 * only IWineD3DBaseSurface and IWineGDISurface ones.
631 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl
=
634 IWineD3DBaseSurfaceImpl_QueryInterface
,
635 IWineD3DBaseSurfaceImpl_AddRef
,
636 IWineGDISurfaceImpl_Release
,
637 /* IWineD3DResource */
638 IWineD3DBaseSurfaceImpl_GetParent
,
639 IWineD3DBaseSurfaceImpl_GetDevice
,
640 IWineD3DBaseSurfaceImpl_SetPrivateData
,
641 IWineD3DBaseSurfaceImpl_GetPrivateData
,
642 IWineD3DBaseSurfaceImpl_FreePrivateData
,
643 IWineD3DBaseSurfaceImpl_SetPriority
,
644 IWineD3DBaseSurfaceImpl_GetPriority
,
645 IWineGDISurfaceImpl_PreLoad
,
646 IWineGDISurfaceImpl_UnLoad
,
647 IWineD3DBaseSurfaceImpl_GetType
,
648 /* IWineD3DSurface */
649 IWineD3DBaseSurfaceImpl_GetContainer
,
650 IWineD3DBaseSurfaceImpl_GetDesc
,
651 IWineGDISurfaceImpl_LockRect
,
652 IWineGDISurfaceImpl_UnlockRect
,
653 IWineGDISurfaceImpl_GetDC
,
654 IWineGDISurfaceImpl_ReleaseDC
,
655 IWineGDISurfaceImpl_Flip
,
656 IWineD3DBaseSurfaceImpl_Blt
,
657 IWineD3DBaseSurfaceImpl_GetBltStatus
,
658 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
659 IWineD3DBaseSurfaceImpl_IsLost
,
660 IWineD3DBaseSurfaceImpl_Restore
,
661 IWineD3DBaseSurfaceImpl_BltFast
,
662 IWineD3DBaseSurfaceImpl_GetPalette
,
663 IWineD3DBaseSurfaceImpl_SetPalette
,
664 IWineGDISurfaceImpl_RealizePalette
,
665 IWineD3DBaseSurfaceImpl_SetColorKey
,
666 IWineD3DBaseSurfaceImpl_GetPitch
,
667 IWineGDISurfaceImpl_SetMem
,
668 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
669 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
670 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
671 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
672 IWineD3DBaseSurfaceImpl_SetClipper
,
673 IWineD3DBaseSurfaceImpl_GetClipper
,
675 IWineGDISurfaceImpl_LoadTexture
,
676 IWineD3DBaseSurfaceImpl_BindTexture
,
677 IWineGDISurfaceImpl_SaveSnapshot
,
678 IWineD3DBaseSurfaceImpl_SetContainer
,
679 IWineGDISurfaceImpl_GetGlDesc
,
680 IWineD3DBaseSurfaceImpl_GetData
,
681 IWineD3DBaseSurfaceImpl_SetFormat
,
682 IWineGDISurfaceImpl_PrivateSetup
,
683 IWineGDISurfaceImpl_ModifyLocation
,
684 IWineGDISurfaceImpl_LoadLocation
,
685 IWineGDISurfaceImpl_GetImplType
,
686 IWineGDISurfaceImpl_DrawOverlay