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"
35 /* Use the d3d_surface debug channel to have one channel for all surfaces */
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
38 void surface_gdi_cleanup(IWineD3DSurfaceImpl
*This
)
40 TRACE("(%p) : Cleaning up.\n", This
);
42 if (This
->Flags
& SFLAG_DIBSECTION
)
45 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
47 /* Release the DIB section. */
48 DeleteObject(This
->dib
.DIBsection
);
49 This
->dib
.bitmap_data
= NULL
;
50 This
->resource
.allocatedMemory
= NULL
;
53 if (This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem((IWineD3DSurface
*)This
, NULL
);
54 if (This
->overlay_dest
) list_remove(&This
->overlay_entry
);
56 HeapFree(GetProcessHeap(), 0, This
->palette9
);
58 resource_cleanup((IWineD3DResource
*)This
);
61 /*****************************************************************************
62 * IWineD3DSurface::Release, GDI version
64 * In general a normal COM Release method, but the GDI version doesn't have
65 * to destroy all the GL things.
67 *****************************************************************************/
68 static ULONG WINAPI
IWineGDISurfaceImpl_Release(IWineD3DSurface
*iface
) {
69 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
70 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
71 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
75 surface_gdi_cleanup(This
);
77 TRACE("(%p) Released.\n", This
);
78 HeapFree(GetProcessHeap(), 0, This
);
84 /*****************************************************************************
85 * IWineD3DSurface::PreLoad, GDI version
87 * This call is unsupported on GDI surfaces, if it's called something went
88 * wrong in the parent library. Write an informative warning
90 *****************************************************************************/
92 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface
*iface
)
94 ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface
);
95 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
96 ERR("(%p): Please report to wine-devel\n", iface
);
99 /*****************************************************************************
100 * IWineD3DSurface::UnLoad, GDI version
102 * This call is unsupported on GDI surfaces, if it's called something went
103 * wrong in the parent library. Write an informative warning.
105 *****************************************************************************/
106 static void WINAPI
IWineGDISurfaceImpl_UnLoad(IWineD3DSurface
*iface
)
108 ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface
);
109 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
110 ERR("(%p): Please report to wine-devel\n", iface
);
113 /*****************************************************************************
114 * IWineD3DSurface::LockRect, GDI version
116 * Locks the surface and returns a pointer to the surface memory
119 * pLockedRect: Address to return the locking info at
120 * pRect: Rectangle to lock
124 * WINED3D_OK on success
125 * WINED3DERR_INVALIDCALL on errors
127 *****************************************************************************/
128 static HRESULT WINAPI
129 IWineGDISurfaceImpl_LockRect(IWineD3DSurface
*iface
,
130 WINED3DLOCKED_RECT
* pLockedRect
,
134 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
136 /* Already locked? */
137 if(This
->Flags
& SFLAG_LOCKED
)
139 WARN("(%p) Surface already locked\n", This
);
140 /* What should I return here? */
141 return WINED3DERR_INVALIDCALL
;
143 This
->Flags
|= SFLAG_LOCKED
;
145 if(!This
->resource
.allocatedMemory
) {
146 /* This happens on gdi surfaces if the application set a user pointer and resets it.
147 * Recreate the DIB section
149 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
150 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
153 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
156 /*****************************************************************************
157 * IWineD3DSurface::UnlockRect, GDI version
159 * Unlocks a surface. This implementation doesn't do much, except updating
160 * the window if the front buffer is unlocked
163 * WINED3D_OK on success
164 * WINED3DERR_INVALIDCALL on failure
166 *****************************************************************************/
167 static HRESULT WINAPI
168 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface
*iface
)
170 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
171 IWineD3DSwapChainImpl
*swapchain
= NULL
;
172 TRACE("(%p)\n", This
);
174 if (!(This
->Flags
& SFLAG_LOCKED
))
176 WARN("trying to Unlock an unlocked surf@%p\n", This
);
177 return WINEDDERR_NOTLOCKED
;
180 /* Can be useful for debugging */
183 static unsigned int gen
= 0;
186 if ((gen
% 10) == 0) {
187 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
188 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
191 * debugging crash code
200 /* Tell the swapchain to update the screen */
201 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
203 x11_copy_to_screen(swapchain
, &This
->lockedRect
);
204 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
207 This
->Flags
&= ~SFLAG_LOCKED
;
208 memset(&This
->lockedRect
, 0, sizeof(RECT
));
212 /*****************************************************************************
213 * IWineD3DSurface::Flip, GDI version
215 * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
216 * the parent library. This implementation changes the data pointers of the
217 * surfaces and copies the new front buffer content to the screen
220 * override: Flipping target(e.g. back buffer)
223 * WINED3D_OK on success
225 *****************************************************************************/
226 static HRESULT WINAPI
227 IWineGDISurfaceImpl_Flip(IWineD3DSurface
*iface
,
228 IWineD3DSurface
*override
,
231 IWineD3DSwapChainImpl
*swapchain
= NULL
;
234 if(FAILED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
236 ERR("Flipped surface is not on a swapchain\n");
237 return WINEDDERR_NOTFLIPPABLE
;
240 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
241 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
245 /*****************************************************************************
246 * IWineD3DSurface::LoadTexture, GDI version
248 * This is mutually unsupported by GDI surfaces
253 *****************************************************************************/
254 static HRESULT WINAPI
255 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
)
257 ERR("Unsupported on X11 surfaces\n");
258 return WINED3DERR_INVALIDCALL
;
261 /*****************************************************************************
262 * IWineD3DSurface::SaveSnapshot, GDI version
264 * This method writes the surface's contents to the in tga format to the
265 * file specified in filename.
268 * filename: File to write to
271 * WINED3DERR_INVALIDCALL if the file couldn't be opened
272 * WINED3D_OK on success
274 *****************************************************************************/
275 static int get_shift(DWORD color_mask
) {
277 while (color_mask
> 0xFF) {
281 while ((color_mask
& 0x80) == 0) {
289 static HRESULT WINAPI
290 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
,
291 const char* filename
)
295 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
296 static char *output
= NULL
;
297 static UINT size
= 0;
298 const struct GlPixelFormatDesc
*format_desc
= This
->resource
.format_desc
;
300 if (This
->pow2Width
> size
) {
301 output
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->pow2Width
* 3);
302 size
= This
->pow2Width
;
306 f
= fopen(filename
, "w+");
308 ERR("opening of %s failed with\n", filename
);
309 return WINED3DERR_INVALIDCALL
;
311 fprintf(f
, "P6\n%d %d\n255\n", This
->pow2Width
, This
->pow2Height
);
313 if (This
->resource
.format_desc
->format
== WINED3DFMT_P8
)
315 unsigned char table
[256][3];
318 if (This
->palette
== NULL
) {
320 return WINED3DERR_INVALIDCALL
;
322 for (i
= 0; i
< 256; i
++) {
323 table
[i
][0] = This
->palette
->palents
[i
].peRed
;
324 table
[i
][1] = This
->palette
->palents
[i
].peGreen
;
325 table
[i
][2] = This
->palette
->palents
[i
].peBlue
;
327 for (y
= 0; y
< This
->pow2Height
; y
++) {
328 unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
329 for (x
= 0; x
< This
->pow2Width
; x
++) {
330 unsigned char color
= *src
;
333 output
[3 * x
+ 0] = table
[color
][0];
334 output
[3 * x
+ 1] = table
[color
][1];
335 output
[3 * x
+ 2] = table
[color
][2];
337 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
340 int red_shift
, green_shift
, blue_shift
, pix_width
, alpha_shift
;
342 pix_width
= format_desc
->byte_count
;
344 red_shift
= get_shift(format_desc
->red_mask
);
345 green_shift
= get_shift(format_desc
->green_mask
);
346 blue_shift
= get_shift(format_desc
->blue_mask
);
347 alpha_shift
= get_shift(format_desc
->alpha_mask
);
349 for (y
= 0; y
< This
->pow2Height
; y
++) {
350 const unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
351 for (x
= 0; x
< This
->pow2Width
; x
++) {
357 for (i
= 0; i
< pix_width
; i
++) {
358 color
|= src
[i
] << (8 * i
);
360 src
+= 1 * pix_width
;
362 comp
= color
& format_desc
->red_mask
;
363 output
[3 * x
+ 0] = red_shift
> 0 ? comp
>> red_shift
: comp
<< -red_shift
;
364 comp
= color
& format_desc
->green_mask
;
365 output
[3 * x
+ 1] = green_shift
> 0 ? comp
>> green_shift
: comp
<< -green_shift
;
366 comp
= color
& format_desc
->alpha_mask
;
367 output
[3 * x
+ 2] = alpha_shift
> 0 ? comp
>> alpha_shift
: comp
<< -alpha_shift
;
369 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
376 static HRESULT WINAPI
IWineGDISurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
377 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
378 WINED3DLOCKED_RECT lock
;
382 TRACE("(%p)->(%p)\n",This
,pHDC
);
384 if(This
->Flags
& SFLAG_USERPTR
) {
385 ERR("Not supported on surfaces with an application-provided surfaces\n");
386 return WINEDDERR_NODC
;
389 /* Give more detailed info for ddraw */
390 if (This
->Flags
& SFLAG_DCINUSE
)
391 return WINEDDERR_DCALREADYCREATED
;
393 /* Can't GetDC if the surface is locked */
394 if (This
->Flags
& SFLAG_LOCKED
)
395 return WINED3DERR_INVALIDCALL
;
397 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
399 /* Should have a DIB section already */
401 /* Lock the surface */
402 hr
= IWineD3DSurface_LockRect(iface
,
407 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
408 /* keep the dib section */
412 if (This
->resource
.format_desc
->format
== WINED3DFMT_P8
413 || This
->resource
.format_desc
->format
== WINED3DFMT_A8P8
)
416 const PALETTEENTRY
*pal
= NULL
;
419 pal
= This
->palette
->palents
;
421 IWineD3DSurfaceImpl
*dds_primary
;
422 IWineD3DSwapChainImpl
*swapchain
;
423 swapchain
= (IWineD3DSwapChainImpl
*)This
->resource
.wineD3DDevice
->swapchains
[0];
424 dds_primary
= (IWineD3DSurfaceImpl
*)swapchain
->frontBuffer
;
425 if (dds_primary
&& dds_primary
->palette
)
426 pal
= dds_primary
->palette
->palents
;
430 for (n
=0; n
<256; n
++) {
431 col
[n
].rgbRed
= pal
[n
].peRed
;
432 col
[n
].rgbGreen
= pal
[n
].peGreen
;
433 col
[n
].rgbBlue
= pal
[n
].peBlue
;
434 col
[n
].rgbReserved
= 0;
436 SetDIBColorTable(This
->hDC
, 0, 256, col
);
441 TRACE("returning %p\n",*pHDC
);
442 This
->Flags
|= SFLAG_DCINUSE
;
447 static HRESULT WINAPI
IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
448 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
450 TRACE("(%p)->(%p)\n",This
,hDC
);
452 if (!(This
->Flags
& SFLAG_DCINUSE
))
453 return WINEDDERR_NODC
;
455 if (This
->hDC
!=hDC
) {
456 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
457 return WINEDDERR_NODC
;
460 /* we locked first, so unlock now */
461 IWineD3DSurface_UnlockRect(iface
);
463 This
->Flags
&= ~SFLAG_DCINUSE
;
468 static HRESULT WINAPI
IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
469 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
471 IWineD3DPaletteImpl
*pal
= This
->palette
;
473 IWineD3DSwapChainImpl
*swapchain
;
474 TRACE("(%p)\n", This
);
476 if (!pal
) return WINED3D_OK
;
478 if(This
->Flags
& SFLAG_DIBSECTION
) {
479 TRACE("(%p): Updating the hdc's palette\n", This
);
480 for (n
=0; n
<256; n
++) {
481 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
482 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
483 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
484 col
[n
].rgbReserved
= 0;
486 SetDIBColorTable(This
->hDC
, 0, 256, col
);
489 /* Update the image because of the palette change. Some games like e.g Red Alert
490 call SetEntries a lot to implement fading. */
491 /* Tell the swapchain to update the screen */
492 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
494 x11_copy_to_screen(swapchain
, NULL
);
495 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
501 /*****************************************************************************
502 * IWineD3DSurface::PrivateSetup, GDI version
504 * Initializes the GDI surface, aka creates the DIB section we render to
505 * The DIB section creation is done by calling GetDC, which will create the
506 * section and releasing the dc to allow the app to use it. The dib section
507 * will stay until the surface is released
509 * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
510 * are set to the real sizes to save memory. The NONPOW2 flag is unset to
511 * avoid confusion in the shared surface code.
514 * WINED3D_OK on success
515 * The return values of called methods on failure
517 *****************************************************************************/
518 static HRESULT WINAPI
519 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
)
521 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
523 if(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
)
525 ERR("(%p) Overlays not yet supported by GDI surfaces\n", This
);
526 return WINED3DERR_INVALIDCALL
;
528 /* Sysmem textures have memory already allocated -
529 * release it, this avoids an unnecessary memcpy
531 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
532 This
->resource
.allocatedMemory
= NULL
;
533 This
->resource
.heapMemory
= NULL
;
535 /* We don't mind the nonpow2 stuff in GDI */
536 This
->pow2Width
= This
->currentDesc
.Width
;
537 This
->pow2Height
= This
->currentDesc
.Height
;
539 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
540 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
545 static void WINAPI
IWineGDISurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
546 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
547 FIXME("(%p) : Should not be called on a GDI surface\n", This
);
548 *glDescription
= NULL
;
551 static HRESULT WINAPI
IWineGDISurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
552 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
554 /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
555 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
556 ERR("Not supported on render targets\n");
557 return WINED3DERR_INVALIDCALL
;
560 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
561 WARN("Surface is locked or the HDC is in use\n");
562 return WINED3DERR_INVALIDCALL
;
565 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
566 void *release
= NULL
;
568 /* Do I have to copy the old surface content? */
569 if(This
->Flags
& SFLAG_DIBSECTION
) {
570 /* Release the DC. No need to hold the critical section for the update
571 * Thread because this thread runs only on front buffers, but this method
572 * fails for render targets in the check above.
574 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
576 /* Release the DIB section */
577 DeleteObject(This
->dib
.DIBsection
);
578 This
->dib
.bitmap_data
= NULL
;
579 This
->resource
.allocatedMemory
= NULL
;
581 This
->Flags
&= ~SFLAG_DIBSECTION
;
582 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
583 release
= This
->resource
.allocatedMemory
;
585 This
->resource
.allocatedMemory
= Mem
;
586 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
588 /* Now free the old memory if any */
589 HeapFree(GetProcessHeap(), 0, release
);
590 } else if(This
->Flags
& SFLAG_USERPTR
) {
591 /* LockRect and GetDC will re-create the dib section and allocated memory */
592 This
->resource
.allocatedMemory
= NULL
;
593 This
->Flags
&= ~SFLAG_USERPTR
;
598 /***************************
600 ***************************/
601 static void WINAPI
IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
602 TRACE("(%p)->(%s, %s)\n", iface
,
603 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
604 persistent
? "TRUE" : "FALSE");
605 /* GDI surfaces can be in system memory only */
606 if(flag
!= SFLAG_INSYSMEM
) {
607 ERR("GDI Surface requested in gl %s memory\n", flag
== SFLAG_INDRAWABLE
? "drawable" : "texture");
611 static HRESULT WINAPI
IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
612 if(flag
!= SFLAG_INSYSMEM
) {
613 ERR("GDI Surface requested to be copied to gl %s\n", flag
== SFLAG_INTEXTURE
? "texture" : "drawable");
615 TRACE("Surface requested in surface memory\n");
620 static WINED3DSURFTYPE WINAPI
IWineGDISurfaceImpl_GetImplType(IWineD3DSurface
*iface
) {
624 static HRESULT WINAPI
IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface
*iface
) {
625 FIXME("GDI surfaces can't draw overlays yet\n");
629 /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
630 * only IWineD3DBaseSurface and IWineGDISurface ones.
632 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl
=
635 IWineD3DBaseSurfaceImpl_QueryInterface
,
636 IWineD3DBaseSurfaceImpl_AddRef
,
637 IWineGDISurfaceImpl_Release
,
638 /* IWineD3DResource */
639 IWineD3DBaseSurfaceImpl_GetParent
,
640 IWineD3DBaseSurfaceImpl_GetDevice
,
641 IWineD3DBaseSurfaceImpl_SetPrivateData
,
642 IWineD3DBaseSurfaceImpl_GetPrivateData
,
643 IWineD3DBaseSurfaceImpl_FreePrivateData
,
644 IWineD3DBaseSurfaceImpl_SetPriority
,
645 IWineD3DBaseSurfaceImpl_GetPriority
,
646 IWineGDISurfaceImpl_PreLoad
,
647 IWineGDISurfaceImpl_UnLoad
,
648 IWineD3DBaseSurfaceImpl_GetType
,
649 /* IWineD3DSurface */
650 IWineD3DBaseSurfaceImpl_GetContainer
,
651 IWineD3DBaseSurfaceImpl_GetDesc
,
652 IWineGDISurfaceImpl_LockRect
,
653 IWineGDISurfaceImpl_UnlockRect
,
654 IWineGDISurfaceImpl_GetDC
,
655 IWineGDISurfaceImpl_ReleaseDC
,
656 IWineGDISurfaceImpl_Flip
,
657 IWineD3DBaseSurfaceImpl_Blt
,
658 IWineD3DBaseSurfaceImpl_GetBltStatus
,
659 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
660 IWineD3DBaseSurfaceImpl_IsLost
,
661 IWineD3DBaseSurfaceImpl_Restore
,
662 IWineD3DBaseSurfaceImpl_BltFast
,
663 IWineD3DBaseSurfaceImpl_GetPalette
,
664 IWineD3DBaseSurfaceImpl_SetPalette
,
665 IWineGDISurfaceImpl_RealizePalette
,
666 IWineD3DBaseSurfaceImpl_SetColorKey
,
667 IWineD3DBaseSurfaceImpl_GetPitch
,
668 IWineGDISurfaceImpl_SetMem
,
669 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
670 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
671 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
672 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
673 IWineD3DBaseSurfaceImpl_SetClipper
,
674 IWineD3DBaseSurfaceImpl_GetClipper
,
676 IWineGDISurfaceImpl_LoadTexture
,
677 IWineD3DBaseSurfaceImpl_BindTexture
,
678 IWineGDISurfaceImpl_SaveSnapshot
,
679 IWineD3DBaseSurfaceImpl_SetContainer
,
680 IWineGDISurfaceImpl_GetGlDesc
,
681 IWineD3DBaseSurfaceImpl_GetData
,
682 IWineD3DBaseSurfaceImpl_SetFormat
,
683 IWineGDISurfaceImpl_PrivateSetup
,
684 IWineGDISurfaceImpl_ModifyLocation
,
685 IWineGDISurfaceImpl_LoadLocation
,
686 IWineGDISurfaceImpl_GetImplType
,
687 IWineGDISurfaceImpl_DrawOverlay