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 /*****************************************************************************
39 * IWineD3DSurface::Release, GDI version
41 * In general a normal COM Release method, but the GDI version doesn't have
42 * to destroy all the GL things.
44 *****************************************************************************/
45 static ULONG WINAPI
IWineGDISurfaceImpl_Release(IWineD3DSurface
*iface
) {
46 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
47 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
48 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
50 TRACE("(%p) : cleaning up\n", This
);
52 if(This
->Flags
& SFLAG_DIBSECTION
) {
54 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
56 /* Release the DIB section */
57 DeleteObject(This
->dib
.DIBsection
);
58 This
->dib
.bitmap_data
= NULL
;
59 This
->resource
.allocatedMemory
= NULL
;
61 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
63 HeapFree(GetProcessHeap(), 0, This
->palette9
);
65 resource_cleanup((IWineD3DResource
*)iface
);
67 if(This
->overlay_dest
) {
68 list_remove(&This
->overlay_entry
);
71 TRACE("(%p) Released\n", This
);
72 HeapFree(GetProcessHeap(), 0, This
);
78 /*****************************************************************************
79 * IWineD3DSurface::PreLoad, GDI version
81 * This call is unsupported on GDI surfaces, if it's called something went
82 * wrong in the parent library. Write an informative warning
84 *****************************************************************************/
86 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface
*iface
)
88 ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface
);
89 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
90 ERR("(%p): Please report to wine-devel\n", iface
);
93 /*****************************************************************************
94 * IWineD3DSurface::UnLoad, GDI version
96 * This call is unsupported on GDI surfaces, if it's called something went
97 * wrong in the parent library. Write an informative warning.
99 *****************************************************************************/
100 static void WINAPI
IWineGDISurfaceImpl_UnLoad(IWineD3DSurface
*iface
)
102 ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface
);
103 ERR("(%p): Most likely the parent library did something wrong.\n", iface
);
104 ERR("(%p): Please report to wine-devel\n", iface
);
107 /*****************************************************************************
108 * IWineD3DSurface::LockRect, GDI version
110 * Locks the surface and returns a pointer to the surface memory
113 * pLockedRect: Address to return the locking info at
114 * pRect: Rectangle to lock
118 * WINED3D_OK on success
119 * WINED3DERR_INVALIDCALL on errors
121 *****************************************************************************/
122 static HRESULT WINAPI
123 IWineGDISurfaceImpl_LockRect(IWineD3DSurface
*iface
,
124 WINED3DLOCKED_RECT
* pLockedRect
,
128 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
130 /* Already locked? */
131 if(This
->Flags
& SFLAG_LOCKED
)
133 ERR("(%p) Surface already locked\n", This
);
134 /* What should I return here? */
135 return WINED3DERR_INVALIDCALL
;
137 This
->Flags
|= SFLAG_LOCKED
;
139 if(!This
->resource
.allocatedMemory
) {
140 /* This happens on gdi surfaces if the application set a user pointer and resets it.
141 * Recreate the DIB section
143 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
144 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
147 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
150 /*****************************************************************************
151 * IWineD3DSurface::UnlockRect, GDI version
153 * Unlocks a surface. This implementation doesn't do much, except updating
154 * the window if the front buffer is unlocked
157 * WINED3D_OK on success
158 * WINED3DERR_INVALIDCALL on failure
160 *****************************************************************************/
161 static HRESULT WINAPI
162 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface
*iface
)
164 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
165 IWineD3DSwapChainImpl
*swapchain
= NULL
;
166 TRACE("(%p)\n", This
);
168 if (!(This
->Flags
& SFLAG_LOCKED
))
170 WARN("trying to Unlock an unlocked surf@%p\n", This
);
171 return WINED3DERR_INVALIDCALL
;
174 /* Can be useful for debugging */
177 static unsigned int gen
= 0;
180 if ((gen
% 10) == 0) {
181 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
182 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
185 * debugging crash code
194 /* Tell the swapchain to update the screen */
195 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
197 x11_copy_to_screen(swapchain
, &This
->lockedRect
);
198 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
201 This
->Flags
&= ~SFLAG_LOCKED
;
202 memset(&This
->lockedRect
, 0, sizeof(RECT
));
206 /*****************************************************************************
207 * IWineD3DSurface::Flip, GDI version
209 * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
210 * the parent library. This implementation changes the data pointers of the
211 * surfaces and copies the new front buffer content to the screen
214 * override: Flipping target(e.g. back buffer)
217 * WINED3D_OK on success
219 *****************************************************************************/
220 static HRESULT WINAPI
221 IWineGDISurfaceImpl_Flip(IWineD3DSurface
*iface
,
222 IWineD3DSurface
*override
,
225 IWineD3DSwapChainImpl
*swapchain
= NULL
;
228 if(FAILED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
230 ERR("Flipped surface is not on a swapchain\n");
231 return WINEDDERR_NOTFLIPPABLE
;
234 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
235 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
239 /*****************************************************************************
240 * IWineD3DSurface::LoadTexture, GDI version
242 * This is mutually unsupported by GDI surfaces
247 *****************************************************************************/
248 static HRESULT WINAPI
249 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
)
251 ERR("Unsupported on X11 surfaces\n");
252 return WINED3DERR_INVALIDCALL
;
255 /*****************************************************************************
256 * IWineD3DSurface::SaveSnapshot, GDI version
258 * This method writes the surface's contents to the in tga format to the
259 * file specified in filename.
262 * filename: File to write to
265 * WINED3DERR_INVALIDCALL if the file couldn't be opened
266 * WINED3D_OK on success
268 *****************************************************************************/
269 static int get_shift(DWORD color_mask
) {
271 while (color_mask
> 0xFF) {
275 while ((color_mask
& 0x80) == 0) {
283 static HRESULT WINAPI
284 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
,
285 const char* filename
)
289 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
290 static char *output
= NULL
;
291 static UINT size
= 0;
292 const StaticPixelFormatDesc
*formatEntry
= getFormatDescEntry(This
->resource
.format
, NULL
, NULL
);
294 if (This
->pow2Width
> size
) {
295 output
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->pow2Width
* 3);
296 size
= This
->pow2Width
;
300 f
= fopen(filename
, "w+");
302 ERR("opening of %s failed with\n", filename
);
303 return WINED3DERR_INVALIDCALL
;
305 fprintf(f
, "P6\n%d %d\n255\n", This
->pow2Width
, This
->pow2Height
);
307 if (This
->resource
.format
== WINED3DFMT_P8
) {
308 unsigned char table
[256][3];
311 if (This
->palette
== NULL
) {
313 return WINED3DERR_INVALIDCALL
;
315 for (i
= 0; i
< 256; i
++) {
316 table
[i
][0] = This
->palette
->palents
[i
].peRed
;
317 table
[i
][1] = This
->palette
->palents
[i
].peGreen
;
318 table
[i
][2] = This
->palette
->palents
[i
].peBlue
;
320 for (y
= 0; y
< This
->pow2Height
; y
++) {
321 unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
322 for (x
= 0; x
< This
->pow2Width
; x
++) {
323 unsigned char color
= *src
;
326 output
[3 * x
+ 0] = table
[color
][0];
327 output
[3 * x
+ 1] = table
[color
][1];
328 output
[3 * x
+ 2] = table
[color
][2];
330 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
333 int red_shift
, green_shift
, blue_shift
, pix_width
, alpha_shift
;
335 pix_width
= This
->bytesPerPixel
;
337 red_shift
= get_shift(formatEntry
->redMask
);
338 green_shift
= get_shift(formatEntry
->greenMask
);
339 blue_shift
= get_shift(formatEntry
->blueMask
);
340 alpha_shift
= get_shift(formatEntry
->alphaMask
);
342 for (y
= 0; y
< This
->pow2Height
; y
++) {
343 const unsigned char *src
= This
->resource
.allocatedMemory
+ (y
* 1 * IWineD3DSurface_GetPitch(iface
));
344 for (x
= 0; x
< This
->pow2Width
; x
++) {
350 for (i
= 0; i
< pix_width
; i
++) {
351 color
|= src
[i
] << (8 * i
);
353 src
+= 1 * pix_width
;
355 comp
= color
& formatEntry
->redMask
;
356 output
[3 * x
+ 0] = red_shift
> 0 ? comp
>> red_shift
: comp
<< -red_shift
;
357 comp
= color
& formatEntry
->greenMask
;
358 output
[3 * x
+ 1] = green_shift
> 0 ? comp
>> green_shift
: comp
<< -green_shift
;
359 comp
= color
& formatEntry
->alphaMask
;
360 output
[3 * x
+ 2] = alpha_shift
> 0 ? comp
>> alpha_shift
: comp
<< -alpha_shift
;
362 fwrite(output
, 3 * This
->pow2Width
, 1, f
);
369 static HRESULT WINAPI
IWineGDISurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
370 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
371 WINED3DLOCKED_RECT lock
;
375 TRACE("(%p)->(%p)\n",This
,pHDC
);
377 if(This
->Flags
& SFLAG_USERPTR
) {
378 ERR("Not supported on surfaces with an application-provided surfaces\n");
379 return WINEDDERR_NODC
;
382 /* Give more detailed info for ddraw */
383 if (This
->Flags
& SFLAG_DCINUSE
)
384 return WINEDDERR_DCALREADYCREATED
;
386 /* Can't GetDC if the surface is locked */
387 if (This
->Flags
& SFLAG_LOCKED
)
388 return WINED3DERR_INVALIDCALL
;
390 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
392 /* Should have a DIB section already */
394 /* Lock the surface */
395 hr
= IWineD3DSurface_LockRect(iface
,
400 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
401 /* keep the dib section */
405 if(This
->resource
.format
== WINED3DFMT_P8
||
406 This
->resource
.format
== WINED3DFMT_A8P8
) {
408 const PALETTEENTRY
*pal
= NULL
;
411 pal
= This
->palette
->palents
;
413 IWineD3DSurfaceImpl
*dds_primary
;
414 IWineD3DSwapChainImpl
*swapchain
;
415 swapchain
= (IWineD3DSwapChainImpl
*)This
->resource
.wineD3DDevice
->swapchains
[0];
416 dds_primary
= (IWineD3DSurfaceImpl
*)swapchain
->frontBuffer
;
417 if (dds_primary
&& dds_primary
->palette
)
418 pal
= dds_primary
->palette
->palents
;
422 for (n
=0; n
<256; n
++) {
423 col
[n
].rgbRed
= pal
[n
].peRed
;
424 col
[n
].rgbGreen
= pal
[n
].peGreen
;
425 col
[n
].rgbBlue
= pal
[n
].peBlue
;
426 col
[n
].rgbReserved
= 0;
428 SetDIBColorTable(This
->hDC
, 0, 256, col
);
433 TRACE("returning %p\n",*pHDC
);
434 This
->Flags
|= SFLAG_DCINUSE
;
439 static HRESULT WINAPI
IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
440 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
442 TRACE("(%p)->(%p)\n",This
,hDC
);
444 if (!(This
->Flags
& SFLAG_DCINUSE
))
445 return WINED3DERR_INVALIDCALL
;
447 if (This
->hDC
!=hDC
) {
448 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
449 return WINED3DERR_INVALIDCALL
;
452 /* we locked first, so unlock now */
453 IWineD3DSurface_UnlockRect(iface
);
455 This
->Flags
&= ~SFLAG_DCINUSE
;
460 static HRESULT WINAPI
IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
461 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
463 IWineD3DPaletteImpl
*pal
= This
->palette
;
465 IWineD3DSwapChainImpl
*swapchain
;
466 TRACE("(%p)\n", This
);
468 if (!pal
) return WINED3D_OK
;
470 if(This
->Flags
& SFLAG_DIBSECTION
) {
471 TRACE("(%p): Updating the hdc's palette\n", This
);
472 for (n
=0; n
<256; n
++) {
473 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
474 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
475 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
476 col
[n
].rgbReserved
= 0;
478 SetDIBColorTable(This
->hDC
, 0, 256, col
);
481 /* Update the image because of the palette change. Some games like e.g Red Alert
482 call SetEntries a lot to implement fading. */
483 /* Tell the swapchain to update the screen */
484 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
)))
486 x11_copy_to_screen(swapchain
, NULL
);
487 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
493 /*****************************************************************************
494 * IWineD3DSurface::PrivateSetup, GDI version
496 * Initializes the GDI surface, aka creates the DIB section we render to
497 * The DIB section creation is done by calling GetDC, which will create the
498 * section and releasing the dc to allow the app to use it. The dib section
499 * will stay until the surface is released
501 * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
502 * are set to the real sizes to save memory. The NONPOW2 flag is unset to
503 * avoid confusion in the shared surface code.
506 * WINED3D_OK on success
507 * The return values of called methods on failure
509 *****************************************************************************/
510 static HRESULT WINAPI
511 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
)
513 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
515 if(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
)
517 ERR("(%p) Overlays not yet supported by GDI surfaces\n", This
);
518 return WINED3DERR_INVALIDCALL
;
520 /* Sysmem textures have memory already allocated -
521 * release it, this avoids an unnecessary memcpy
523 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
524 This
->resource
.allocatedMemory
= NULL
;
525 This
->resource
.heapMemory
= NULL
;
527 /* We don't mind the nonpow2 stuff in GDI */
528 This
->pow2Width
= This
->currentDesc
.Width
;
529 This
->pow2Height
= This
->currentDesc
.Height
;
531 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
532 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
537 static void WINAPI
IWineGDISurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
538 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
539 FIXME("(%p) : Should not be called on a GDI surface\n", This
);
540 *glDescription
= NULL
;
543 static HRESULT WINAPI
IWineGDISurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
544 /* GDI surface data can only be in one location, the system memory dib section. So they are
545 * always clean by definition.
547 TRACE("No dirtification in GDI surfaces\n");
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_AddDirtyRect
,
677 IWineGDISurfaceImpl_LoadTexture
,
678 IWineD3DBaseSurfaceImpl_BindTexture
,
679 IWineGDISurfaceImpl_SaveSnapshot
,
680 IWineD3DBaseSurfaceImpl_SetContainer
,
681 IWineGDISurfaceImpl_GetGlDesc
,
682 IWineD3DBaseSurfaceImpl_GetData
,
683 IWineD3DBaseSurfaceImpl_SetFormat
,
684 IWineGDISurfaceImpl_PrivateSetup
,
685 IWineGDISurfaceImpl_ModifyLocation
,
686 IWineGDISurfaceImpl_LoadLocation
,
687 IWineGDISurfaceImpl_GetImplType
,
688 IWineGDISurfaceImpl_DrawOverlay