2 * IWineD3DSurface Implementation of management(non-rendering) functions
4 * Copyright 1998 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2002-2005 Jason Edmeades
7 * Copyright 2002-2003 Raphael Junqueira
8 * Copyright 2004 Christian Costa
9 * Copyright 2005 Oliver Stieber
10 * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
11 * Copyright 2007 Henri Verbeet
12 * Copyright 2006-2007 Roderick Colenbrander
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/port.h"
31 #include "wined3d_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
37 /* See also float_16_to_32() in wined3d_private.h */
38 static inline unsigned short float_32_to_16(const float *in
)
41 float tmp
= fabs(*in
);
42 unsigned int mantissa
;
45 /* Deal with special numbers */
46 if(*in
== 0.0) return 0x0000;
47 if(isnan(*in
)) return 0x7C01;
48 if(isinf(*in
)) return (*in
< 0.0 ? 0xFC00 : 0x7c00);
50 if(tmp
< pow(2, 10)) {
55 }while(tmp
< pow(2, 10));
56 } else if(tmp
>= pow(2, 11)) {
61 }while(tmp
>= pow(2, 11));
64 mantissa
= (unsigned int) tmp
;
65 if(tmp
- mantissa
>= 0.5) mantissa
++; /* round to nearest, away from zero */
67 exp
+= 10; /* Normalize the mantissa */
68 exp
+= 15; /* Exponent is encoded with excess 15 */
70 if(exp
> 30) { /* too big */
71 ret
= 0x7c00; /* INF */
73 /* exp == 0: Non-normalized mantissa. Returns 0x0000 (=0.0) for too small numbers */
75 mantissa
= mantissa
>> 1;
78 ret
= mantissa
& 0x3ff;
80 ret
= (exp
<< 10) | (mantissa
& 0x3ff);
83 ret
|= ((*in
< 0.0 ? 1 : 0) << 15); /* Add the sign */
88 /* Do NOT define GLINFO_LOCATION in this file. THIS CODE MUST NOT USE IT */
90 /* *******************************************
91 IWineD3DSurface IUnknown parts follow
92 ******************************************* */
93 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface
*iface
, REFIID riid
, LPVOID
*ppobj
)
95 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
96 /* Warn ,but be nice about things */
97 TRACE("(%p)->(%s,%p)\n", This
,debugstr_guid(riid
),ppobj
);
99 if (IsEqualGUID(riid
, &IID_IUnknown
)
100 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
101 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
102 || IsEqualGUID(riid
, &IID_IWineD3DSurface
)) {
103 IUnknown_AddRef((IUnknown
*)iface
);
108 return E_NOINTERFACE
;
111 ULONG WINAPI
IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface
*iface
) {
112 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
113 ULONG ref
= InterlockedIncrement(&This
->resource
.ref
);
114 TRACE("(%p) : AddRef increasing from %d\n", This
,ref
- 1);
118 /* ****************************************************
119 IWineD3DSurface IWineD3DResource parts follow
120 **************************************************** */
121 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetDevice(IWineD3DSurface
*iface
, IWineD3DDevice
** ppDevice
) {
122 return resource_get_device((IWineD3DResource
*)iface
, ppDevice
);
125 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
126 return resource_set_private_data((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
129 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
130 return resource_get_private_data((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
133 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface
*iface
, REFGUID refguid
) {
134 return resource_free_private_data((IWineD3DResource
*)iface
, refguid
);
137 DWORD WINAPI
IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface
*iface
, DWORD PriorityNew
) {
138 return resource_set_priority((IWineD3DResource
*)iface
, PriorityNew
);
141 DWORD WINAPI
IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface
*iface
) {
142 return resource_get_priority((IWineD3DResource
*)iface
);
145 WINED3DRESOURCETYPE WINAPI
IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface
*iface
) {
146 TRACE("(%p) : calling resourceimpl_GetType\n", iface
);
147 return resource_get_type((IWineD3DResource
*)iface
);
150 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface
*iface
, IUnknown
**pParent
) {
151 TRACE("(%p) : calling resourceimpl_GetParent\n", iface
);
152 return resource_get_parent((IWineD3DResource
*)iface
, pParent
);
155 /* ******************************************************
156 IWineD3DSurface IWineD3DSurface parts follow
157 ****************************************************** */
159 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetContainer(IWineD3DSurface
* iface
, REFIID riid
, void** ppContainer
) {
160 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
161 IWineD3DBase
*container
= 0;
163 TRACE("(This %p, riid %s, ppContainer %p)\n", This
, debugstr_guid(riid
), ppContainer
);
166 ERR("Called without a valid ppContainer.\n");
170 * If the surface is created using CreateImageSurface/CreateOffscreenPlainSurface, CreateRenderTarget,
171 * or CreateDepthStencilSurface, the surface is considered stand alone. In this case,
172 * GetContainer will return the Direct3D device used to create the surface.
174 if (This
->container
) {
175 container
= This
->container
;
177 container
= (IWineD3DBase
*)This
->resource
.wineD3DDevice
;
180 TRACE("Relaying to QueryInterface\n");
181 return IUnknown_QueryInterface(container
, riid
, ppContainer
);
184 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface
*iface
, WINED3DSURFACE_DESC
*pDesc
) {
185 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
187 TRACE("(%p) : copying into %p\n", This
, pDesc
);
188 if(pDesc
->Format
!= NULL
) *(pDesc
->Format
) = This
->resource
.format
;
189 if(pDesc
->Type
!= NULL
) *(pDesc
->Type
) = This
->resource
.resourceType
;
190 if(pDesc
->Usage
!= NULL
) *(pDesc
->Usage
) = This
->resource
.usage
;
191 if(pDesc
->Pool
!= NULL
) *(pDesc
->Pool
) = This
->resource
.pool
;
192 if(pDesc
->Size
!= NULL
) *(pDesc
->Size
) = This
->resource
.size
; /* dx8 only */
193 if(pDesc
->MultiSampleType
!= NULL
) *(pDesc
->MultiSampleType
) = This
->currentDesc
.MultiSampleType
;
194 if(pDesc
->MultiSampleQuality
!= NULL
) *(pDesc
->MultiSampleQuality
) = This
->currentDesc
.MultiSampleQuality
;
195 if(pDesc
->Width
!= NULL
) *(pDesc
->Width
) = This
->currentDesc
.Width
;
196 if(pDesc
->Height
!= NULL
) *(pDesc
->Height
) = This
->currentDesc
.Height
;
200 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface
*iface
, DWORD Flags
) {
201 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
202 TRACE("(%p)->(%x)\n", This
, Flags
);
206 case WINEDDGBS_CANBLT
:
207 case WINEDDGBS_ISBLTDONE
:
211 return WINED3DERR_INVALIDCALL
;
215 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface
*iface
, DWORD Flags
) {
216 /* XXX: DDERR_INVALIDSURFACETYPE */
218 TRACE("(%p)->(%08x)\n",iface
,Flags
);
220 case WINEDDGFS_CANFLIP
:
221 case WINEDDGFS_ISFLIPDONE
:
225 return WINED3DERR_INVALIDCALL
;
229 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_IsLost(IWineD3DSurface
*iface
) {
230 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
231 TRACE("(%p)\n", This
);
233 /* D3D8 and 9 loose full devices, ddraw only surfaces */
234 return This
->Flags
& SFLAG_LOST
? WINED3DERR_DEVICELOST
: WINED3D_OK
;
237 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_Restore(IWineD3DSurface
*iface
) {
238 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
239 TRACE("(%p)\n", This
);
241 /* So far we don't lose anything :) */
242 This
->Flags
&= ~SFLAG_LOST
;
246 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetPalette(IWineD3DSurface
*iface
, IWineD3DPalette
*Pal
) {
247 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
248 IWineD3DPaletteImpl
*PalImpl
= (IWineD3DPaletteImpl
*) Pal
;
249 TRACE("(%p)->(%p)\n", This
, Pal
);
251 if(This
->palette
== PalImpl
) {
252 TRACE("Nop palette change\n");
256 if(This
->palette
!= NULL
)
257 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
258 This
->palette
->Flags
&= ~WINEDDPCAPS_PRIMARYSURFACE
;
260 This
->palette
= PalImpl
;
262 if(PalImpl
!= NULL
) {
263 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
264 (PalImpl
)->Flags
|= WINEDDPCAPS_PRIMARYSURFACE
;
267 return IWineD3DSurface_RealizePalette(iface
);
269 else return WINED3D_OK
;
272 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface
*iface
, DWORD Flags
, const WINEDDCOLORKEY
*CKey
)
274 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
275 TRACE("(%p)->(%08x,%p)\n", This
, Flags
, CKey
);
277 if ((Flags
& WINEDDCKEY_COLORSPACE
) != 0) {
278 FIXME(" colorkey value not supported (%08x) !\n", Flags
);
279 return WINED3DERR_INVALIDCALL
;
282 /* Dirtify the surface, but only if a key was changed */
284 switch (Flags
& ~WINEDDCKEY_COLORSPACE
) {
285 case WINEDDCKEY_DESTBLT
:
286 This
->DestBltCKey
= *CKey
;
287 This
->CKeyFlags
|= WINEDDSD_CKDESTBLT
;
290 case WINEDDCKEY_DESTOVERLAY
:
291 This
->DestOverlayCKey
= *CKey
;
292 This
->CKeyFlags
|= WINEDDSD_CKDESTOVERLAY
;
295 case WINEDDCKEY_SRCOVERLAY
:
296 This
->SrcOverlayCKey
= *CKey
;
297 This
->CKeyFlags
|= WINEDDSD_CKSRCOVERLAY
;
300 case WINEDDCKEY_SRCBLT
:
301 This
->SrcBltCKey
= *CKey
;
302 This
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
307 switch (Flags
& ~WINEDDCKEY_COLORSPACE
) {
308 case WINEDDCKEY_DESTBLT
:
309 This
->CKeyFlags
&= ~WINEDDSD_CKDESTBLT
;
312 case WINEDDCKEY_DESTOVERLAY
:
313 This
->CKeyFlags
&= ~WINEDDSD_CKDESTOVERLAY
;
316 case WINEDDCKEY_SRCOVERLAY
:
317 This
->CKeyFlags
&= ~WINEDDSD_CKSRCOVERLAY
;
320 case WINEDDCKEY_SRCBLT
:
321 This
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
329 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface
*iface
, IWineD3DPalette
**Pal
) {
330 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
331 TRACE("(%p)->(%p)\n", This
, Pal
);
333 *Pal
= (IWineD3DPalette
*) This
->palette
;
337 DWORD WINAPI
IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface
*iface
) {
338 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
340 TRACE("(%p)\n", This
);
342 /* DXTn formats don't have exact pitches as they are to the new row of blocks,
343 where each block is 4x4 pixels, 8 bytes (dxt1) and 16 bytes (dxt2/3/4/5)
344 ie pitch = (width/4) * bytes per block */
345 if (This
->resource
.format
== WINED3DFMT_DXT1
) /* DXT1 is 8 bytes per block */
346 ret
= ((This
->currentDesc
.Width
+ 3) >> 2) << 3;
347 else if (This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
348 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) /* DXT2/3/4/5 is 16 bytes per block */
349 ret
= ((This
->currentDesc
.Width
+ 3) >> 2) << 4;
351 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
352 ret
= This
->bytesPerPixel
* This
->currentDesc
.Width
; /* Bytes / row */
353 ret
= (ret
+ alignment
- 1) & ~(alignment
- 1);
355 TRACE("(%p) Returning %d\n", This
, ret
);
359 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetOverlayPosition(IWineD3DSurface
*iface
, LONG X
, LONG Y
) {
360 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
363 TRACE("(%p)->(%d,%d) Stub!\n", This
, X
, Y
);
365 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
367 TRACE("(%p): Not an overlay surface\n", This
);
368 return WINEDDERR_NOTAOVERLAYSURFACE
;
371 w
= This
->overlay_destrect
.right
- This
->overlay_destrect
.left
;
372 h
= This
->overlay_destrect
.bottom
- This
->overlay_destrect
.top
;
373 This
->overlay_destrect
.left
= X
;
374 This
->overlay_destrect
.top
= Y
;
375 This
->overlay_destrect
.right
= X
+ w
;
376 This
->overlay_destrect
.bottom
= Y
+ h
;
378 IWineD3DSurface_DrawOverlay(iface
);
383 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetOverlayPosition(IWineD3DSurface
*iface
, LONG
*X
, LONG
*Y
) {
384 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
387 TRACE("(%p)->(%p,%p)\n", This
, X
, Y
);
389 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
391 TRACE("(%p): Not an overlay surface\n", This
);
392 return WINEDDERR_NOTAOVERLAYSURFACE
;
394 if(This
->overlay_dest
== NULL
) {
396 hr
= WINEDDERR_OVERLAYNOTVISIBLE
;
398 *X
= This
->overlay_destrect
.left
;
399 *Y
= This
->overlay_destrect
.top
;
403 TRACE("Returning 0x%08x, position %d, %d\n", hr
, *X
, *Y
);
407 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface
*iface
, DWORD Flags
, IWineD3DSurface
*Ref
) {
408 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
409 IWineD3DSurfaceImpl
*RefImpl
= (IWineD3DSurfaceImpl
*) Ref
;
411 FIXME("(%p)->(%08x,%p) Stub!\n", This
, Flags
, RefImpl
);
413 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
415 TRACE("(%p): Not an overlay surface\n", This
);
416 return WINEDDERR_NOTAOVERLAYSURFACE
;
422 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface
*iface
, const RECT
*SrcRect
,
423 IWineD3DSurface
*DstSurface
, const RECT
*DstRect
, DWORD Flags
, const WINEDDOVERLAYFX
*FX
)
425 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
426 IWineD3DSurfaceImpl
*Dst
= (IWineD3DSurfaceImpl
*) DstSurface
;
427 TRACE("(%p)->(%p, %p, %p, %08x, %p)\n", This
, SrcRect
, Dst
, DstRect
, Flags
, FX
);
429 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
431 WARN("(%p): Not an overlay surface\n", This
);
432 return WINEDDERR_NOTAOVERLAYSURFACE
;
433 } else if(!DstSurface
) {
434 WARN("(%p): Dest surface is NULL\n", This
);
435 return WINED3DERR_INVALIDCALL
;
439 This
->overlay_srcrect
= *SrcRect
;
441 This
->overlay_srcrect
.left
= 0;
442 This
->overlay_srcrect
.top
= 0;
443 This
->overlay_srcrect
.right
= This
->currentDesc
.Width
;
444 This
->overlay_srcrect
.bottom
= This
->currentDesc
.Height
;
448 This
->overlay_destrect
= *DstRect
;
450 This
->overlay_destrect
.left
= 0;
451 This
->overlay_destrect
.top
= 0;
452 This
->overlay_destrect
.right
= Dst
? Dst
->currentDesc
.Width
: 0;
453 This
->overlay_destrect
.bottom
= Dst
? Dst
->currentDesc
.Height
: 0;
456 if(This
->overlay_dest
&& (This
->overlay_dest
!= Dst
|| Flags
& WINEDDOVER_HIDE
)) {
457 list_remove(&This
->overlay_entry
);
460 if(Flags
& WINEDDOVER_SHOW
) {
461 if(This
->overlay_dest
!= Dst
) {
462 This
->overlay_dest
= Dst
;
463 list_add_tail(&Dst
->overlays
, &This
->overlay_entry
);
465 } else if(Flags
& WINEDDOVER_HIDE
) {
466 /* tests show that the rectangles are erased on hide */
467 This
->overlay_srcrect
.left
= 0; This
->overlay_srcrect
.top
= 0;
468 This
->overlay_srcrect
.right
= 0; This
->overlay_srcrect
.bottom
= 0;
469 This
->overlay_destrect
.left
= 0; This
->overlay_destrect
.top
= 0;
470 This
->overlay_destrect
.right
= 0; This
->overlay_destrect
.bottom
= 0;
471 This
->overlay_dest
= NULL
;
474 IWineD3DSurface_DrawOverlay(iface
);
479 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetClipper(IWineD3DSurface
*iface
, IWineD3DClipper
*clipper
)
481 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
482 TRACE("(%p)->(%p)\n", This
, clipper
);
484 This
->clipper
= clipper
;
488 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface
*iface
, IWineD3DClipper
**clipper
)
490 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
491 TRACE("(%p)->(%p)\n", This
, clipper
);
493 *clipper
= This
->clipper
;
495 IWineD3DClipper_AddRef(*clipper
);
500 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetContainer(IWineD3DSurface
*iface
, IWineD3DBase
*container
) {
501 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
503 TRACE("This %p, container %p\n", This
, container
);
505 /* We can't keep a reference to the container, since the container already keeps a reference to us. */
507 TRACE("Setting container to %p from %p\n", container
, This
->container
);
508 This
->container
= container
;
513 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
514 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
515 const StaticPixelFormatDesc
*formatEntry
= getFormatDescEntry(format
, NULL
, NULL
);
517 if (This
->resource
.format
!= WINED3DFMT_UNKNOWN
) {
518 FIXME("(%p) : The format of the surface must be WINED3DFORMAT_UNKNOWN\n", This
);
519 return WINED3DERR_INVALIDCALL
;
522 TRACE("(%p) : Setting texture format to (%d,%s)\n", This
, format
, debug_d3dformat(format
));
523 if (format
== WINED3DFMT_UNKNOWN
) {
524 This
->resource
.size
= 0;
525 } else if (format
== WINED3DFMT_DXT1
) {
526 /* DXT1 is half byte per pixel */
527 This
->resource
.size
= ((max(This
->pow2Width
, 4) * formatEntry
->bpp
) * max(This
->pow2Height
, 4)) >> 1;
529 } else if (format
== WINED3DFMT_DXT2
|| format
== WINED3DFMT_DXT3
||
530 format
== WINED3DFMT_DXT4
|| format
== WINED3DFMT_DXT5
) {
531 This
->resource
.size
= ((max(This
->pow2Width
, 4) * formatEntry
->bpp
) * max(This
->pow2Height
, 4));
533 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
534 This
->resource
.size
= ((This
->pow2Width
* formatEntry
->bpp
) + alignment
- 1) & ~(alignment
- 1);
535 This
->resource
.size
*= This
->pow2Height
;
538 if (format
!= WINED3DFMT_UNKNOWN
) {
539 This
->bytesPerPixel
= formatEntry
->bpp
;
541 This
->bytesPerPixel
= 0;
544 This
->Flags
|= (WINED3DFMT_D16_LOCKABLE
== format
) ? SFLAG_LOCKABLE
: 0;
546 This
->resource
.format
= format
;
548 TRACE("(%p) : Size %d, bytesPerPixel %d\n", This
, This
->resource
.size
, This
->bytesPerPixel
);
553 HRESULT
IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface
*iface
) {
554 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
560 const StaticPixelFormatDesc
*formatEntry
= getFormatDescEntry(This
->resource
.format
, NULL
, NULL
);
563 switch (This
->bytesPerPixel
) {
566 /* Allocate extra space to store the RGB bit masks. */
567 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + 3 * sizeof(DWORD
));
571 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
));
575 /* Allocate extra space for a palette. */
576 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
577 sizeof(BITMAPINFOHEADER
)
579 * (1 << (This
->bytesPerPixel
* 8)));
584 return E_OUTOFMEMORY
;
586 /* Some apps access the surface in via DWORDs, and do not take the necessary care at the end of the
587 * surface. So we need at least extra 4 bytes at the end of the surface. Check against the page size,
588 * if the last page used for the surface has at least 4 spare bytes we're safe, otherwise
589 * add an extra line to the dib section
591 GetSystemInfo(&sysInfo
);
592 if( ((This
->resource
.size
+ 3) % sysInfo
.dwPageSize
) < 4) {
594 TRACE("Adding an extra line to the dib section\n");
597 b_info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
598 /* TODO: Is there a nicer way to force a specific alignment? (8 byte for ddraw) */
599 b_info
->bmiHeader
.biWidth
= IWineD3DSurface_GetPitch(iface
) / This
->bytesPerPixel
;
600 b_info
->bmiHeader
.biHeight
= -This
->currentDesc
.Height
-extraline
;
601 b_info
->bmiHeader
.biSizeImage
= ( This
->currentDesc
.Height
+ extraline
) * IWineD3DSurface_GetPitch(iface
);
602 b_info
->bmiHeader
.biPlanes
= 1;
603 b_info
->bmiHeader
.biBitCount
= This
->bytesPerPixel
* 8;
605 b_info
->bmiHeader
.biXPelsPerMeter
= 0;
606 b_info
->bmiHeader
.biYPelsPerMeter
= 0;
607 b_info
->bmiHeader
.biClrUsed
= 0;
608 b_info
->bmiHeader
.biClrImportant
= 0;
610 /* Get the bit masks */
611 masks
= (DWORD
*)b_info
->bmiColors
;
612 switch (This
->resource
.format
) {
613 case WINED3DFMT_R8G8B8
:
614 usage
= DIB_RGB_COLORS
;
615 b_info
->bmiHeader
.biCompression
= BI_RGB
;
618 case WINED3DFMT_X1R5G5B5
:
619 case WINED3DFMT_A1R5G5B5
:
620 case WINED3DFMT_A4R4G4B4
:
621 case WINED3DFMT_X4R4G4B4
:
622 case WINED3DFMT_R3G3B2
:
623 case WINED3DFMT_A8R3G3B2
:
624 case WINED3DFMT_A2B10G10R10
:
625 case WINED3DFMT_A8B8G8R8
:
626 case WINED3DFMT_X8B8G8R8
:
627 case WINED3DFMT_A2R10G10B10
:
628 case WINED3DFMT_R5G6B5
:
629 case WINED3DFMT_A16B16G16R16
:
631 b_info
->bmiHeader
.biCompression
= BI_BITFIELDS
;
632 masks
[0] = formatEntry
->redMask
;
633 masks
[1] = formatEntry
->greenMask
;
634 masks
[2] = formatEntry
->blueMask
;
638 /* Don't know palette */
639 b_info
->bmiHeader
.biCompression
= BI_RGB
;
646 HeapFree(GetProcessHeap(), 0, b_info
);
647 return HRESULT_FROM_WIN32(GetLastError());
650 TRACE("Creating a DIB section with size %dx%dx%d, size=%d\n", b_info
->bmiHeader
.biWidth
, b_info
->bmiHeader
.biHeight
, b_info
->bmiHeader
.biBitCount
, b_info
->bmiHeader
.biSizeImage
);
651 This
->dib
.DIBsection
= CreateDIBSection(ddc
, b_info
, usage
, &This
->dib
.bitmap_data
, 0 /* Handle */, 0 /* Offset */);
654 if (!This
->dib
.DIBsection
) {
655 ERR("CreateDIBSection failed!\n");
656 HeapFree(GetProcessHeap(), 0, b_info
);
657 return HRESULT_FROM_WIN32(GetLastError());
660 TRACE("DIBSection at : %p\n", This
->dib
.bitmap_data
);
661 /* copy the existing surface to the dib section */
662 if(This
->resource
.allocatedMemory
) {
663 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, This
->currentDesc
.Height
* IWineD3DSurface_GetPitch(iface
));
665 /* This is to make LockRect read the gl Texture although memory is allocated */
666 This
->Flags
&= ~SFLAG_INSYSMEM
;
668 This
->dib
.bitmap_size
= b_info
->bmiHeader
.biSizeImage
;
670 HeapFree(GetProcessHeap(), 0, b_info
);
672 /* Now allocate a HDC */
673 This
->hDC
= CreateCompatibleDC(0);
674 This
->dib
.holdbitmap
= SelectObject(This
->hDC
, This
->dib
.DIBsection
);
675 TRACE("using wined3d palette %p\n", This
->palette
);
676 SelectPalette(This
->hDC
,
677 This
->palette
? This
->palette
->hpal
: 0,
680 This
->Flags
|= SFLAG_DIBSECTION
;
682 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
683 This
->resource
.heapMemory
= NULL
;
688 static void convert_r32f_r16f(const BYTE
*src
, BYTE
*dst
, DWORD pitch_in
, DWORD pitch_out
,
689 unsigned int w
, unsigned int h
)
693 unsigned short *dst_s
;
695 TRACE("Converting %dx%d pixels, pitches %d %d\n", w
, h
, pitch_in
, pitch_out
);
696 for(y
= 0; y
< h
; y
++) {
697 src_f
= (const float *)(src
+ y
* pitch_in
);
698 dst_s
= (unsigned short *) (dst
+ y
* pitch_out
);
699 for(x
= 0; x
< w
; x
++) {
700 dst_s
[x
] = float_32_to_16(src_f
+ x
);
705 struct d3dfmt_convertor_desc
{
706 WINED3DFORMAT from
, to
;
707 void (*convert
)(const BYTE
*src
, BYTE
*dst
, DWORD pitch_in
, DWORD pitch_out
, unsigned int w
, unsigned int h
);
710 static const struct d3dfmt_convertor_desc convertors
[] =
712 {WINED3DFMT_R32F
, WINED3DFMT_R16F
, convert_r32f_r16f
},
715 static inline const struct d3dfmt_convertor_desc
*find_convertor(WINED3DFORMAT from
, WINED3DFORMAT to
)
718 for(i
= 0; i
< (sizeof(convertors
) / sizeof(convertors
[0])); i
++) {
719 if(convertors
[i
].from
== from
&& convertors
[i
].to
== to
) {
720 return &convertors
[i
];
726 /*****************************************************************************
727 * surface_convert_format
729 * Creates a duplicate of a surface in a different format. Is used by Blt to
730 * blit between surfaces with different formats
733 * source: Source surface
734 * fmt: Requested destination format
736 *****************************************************************************/
737 static IWineD3DSurfaceImpl
*surface_convert_format(IWineD3DSurfaceImpl
*source
, WINED3DFORMAT to_fmt
) {
738 IWineD3DSurface
*ret
= NULL
;
739 const struct d3dfmt_convertor_desc
*conv
;
740 WINED3DLOCKED_RECT lock_src
, lock_dst
;
743 conv
= find_convertor(source
->resource
.format
, to_fmt
);
745 FIXME("Cannot find a conversion function from format %s to %s\n",
746 debug_d3dformat(source
->resource
.format
), debug_d3dformat(to_fmt
));
750 IWineD3DDevice_CreateSurface((IWineD3DDevice
*) source
->resource
.wineD3DDevice
,
751 source
->currentDesc
.Width
,
752 source
->currentDesc
.Height
,
758 WINED3DRTYPE_SURFACE
,
761 WINED3DMULTISAMPLE_NONE
, /* TODO: Multisampled conversion */
762 0, /* MultiSampleQuality */
763 NULL
, /* SharedHandle */
764 IWineD3DSurface_GetImplType((IWineD3DSurface
*) source
),
767 ERR("Failed to create a destination surface for conversion\n");
771 memset(&lock_src
, 0, sizeof(lock_src
));
772 memset(&lock_dst
, 0, sizeof(lock_dst
));
774 hr
= IWineD3DSurface_LockRect((IWineD3DSurface
*) source
, &lock_src
, NULL
, WINED3DLOCK_READONLY
);
776 ERR("Failed to lock the source surface\n");
777 IWineD3DSurface_Release(ret
);
780 hr
= IWineD3DSurface_LockRect(ret
, &lock_dst
, NULL
, WINED3DLOCK_READONLY
);
782 ERR("Failed to lock the dest surface\n");
783 IWineD3DSurface_UnlockRect((IWineD3DSurface
*) source
);
784 IWineD3DSurface_Release(ret
);
788 conv
->convert(lock_src
.pBits
, lock_dst
.pBits
, lock_src
.Pitch
, lock_dst
.Pitch
,
789 source
->currentDesc
.Width
, source
->currentDesc
.Height
);
791 IWineD3DSurface_UnlockRect(ret
);
792 IWineD3DSurface_UnlockRect((IWineD3DSurface
*) source
);
794 return (IWineD3DSurfaceImpl
*) ret
;
797 /*****************************************************************************
800 * Helper function that fills a memory area with a specific color
803 * buf: memory address to start filling at
804 * width, height: Dimensions of the area to fill
805 * bpp: Bit depth of the surface
806 * lPitch: pitch of the surface
807 * color: Color to fill with
809 *****************************************************************************/
811 _Blt_ColorFill(BYTE
*buf
,
812 int width
, int height
,
813 int bpp
, LONG lPitch
,
821 #define COLORFILL_ROW(type) \
823 type *d = (type *) buf; \
824 for (x = 0; x < width; x++) \
825 d[x] = (type) color; \
830 case 1: COLORFILL_ROW(BYTE
)
831 case 2: COLORFILL_ROW(WORD
)
835 for (x
= 0; x
< width
; x
++,d
+=3)
837 d
[0] = (color
) & 0xFF;
838 d
[1] = (color
>> 8) & 0xFF;
839 d
[2] = (color
>>16) & 0xFF;
843 case 4: COLORFILL_ROW(DWORD
)
845 FIXME("Color fill not implemented for bpp %d!\n", bpp
*8);
846 return WINED3DERR_NOTAVAILABLE
;
851 /* Now copy first row */
853 for (y
= 1; y
< height
; y
++)
856 memcpy(buf
, first
, width
* bpp
);
861 /*****************************************************************************
862 * IWineD3DSurface::Blt, SW emulation version
864 * Performs blits to a surface, eigher from a source of source-less blts
865 * This is the main functionality of DirectDraw
868 * DestRect: Destination rectangle to write to
869 * SrcSurface: Source surface, can be NULL
870 * SrcRect: Source rectangle
871 *****************************************************************************/
872 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface
*iface
, const RECT
*DestRect
, IWineD3DSurface
*SrcSurface
,
873 const RECT
*SrcRect
, DWORD Flags
, const WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
)
875 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
876 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
878 HRESULT ret
= WINED3D_OK
;
879 WINED3DLOCKED_RECT dlock
, slock
;
880 WINED3DFORMAT dfmt
= WINED3DFMT_UNKNOWN
, sfmt
= WINED3DFMT_UNKNOWN
;
881 int bpp
, srcheight
, srcwidth
, dstheight
, dstwidth
, width
;
883 const StaticPixelFormatDesc
*sEntry
, *dEntry
;
886 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, Src
, SrcRect
, Flags
, DDBltFx
);
888 if (TRACE_ON(d3d_surface
))
890 if (DestRect
) TRACE("\tdestrect :%dx%d-%dx%d\n",
891 DestRect
->left
, DestRect
->top
, DestRect
->right
, DestRect
->bottom
);
892 if (SrcRect
) TRACE("\tsrcrect :%dx%d-%dx%d\n",
893 SrcRect
->left
, SrcRect
->top
, SrcRect
->right
, SrcRect
->bottom
);
896 DDRAW_dump_DDBLT(Flags
);
897 if (Flags
& WINEDDBLT_DDFX
)
900 DDRAW_dump_DDBLTFX(DDBltFx
->dwDDFX
);
905 if ( (This
->Flags
& SFLAG_LOCKED
) || ((Src
!= NULL
) && (Src
->Flags
& SFLAG_LOCKED
)))
907 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
908 return WINEDDERR_SURFACEBUSY
;
911 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
912 /* Can happen when d3d9 apps do a StretchRect call which isn't handled in gl */
913 FIXME("Filters not supported in software blit\n");
916 /* First check for the validity of source / destination rectangles. This was
917 * verified using a test application + by MSDN.
919 if ((Src
!= NULL
) && (SrcRect
!= NULL
) &&
920 ((SrcRect
->bottom
> Src
->currentDesc
.Height
)||(SrcRect
->bottom
< 0) ||
921 (SrcRect
->top
> Src
->currentDesc
.Height
)||(SrcRect
->top
< 0) ||
922 (SrcRect
->left
> Src
->currentDesc
.Width
) ||(SrcRect
->left
< 0) ||
923 (SrcRect
->right
> Src
->currentDesc
.Width
) ||(SrcRect
->right
< 0) ||
924 (SrcRect
->right
< SrcRect
->left
) ||(SrcRect
->bottom
< SrcRect
->top
)))
926 WARN("Application gave us bad source rectangle for Blt.\n");
927 return WINEDDERR_INVALIDRECT
;
929 /* For the Destination rect, it can be out of bounds on the condition that a clipper
930 * is set for the given surface.
932 if ((/*This->clipper == NULL*/ TRUE
) && (DestRect
) &&
933 ((DestRect
->bottom
> This
->currentDesc
.Height
)||(DestRect
->bottom
< 0) ||
934 (DestRect
->top
> This
->currentDesc
.Height
)||(DestRect
->top
< 0) ||
935 (DestRect
->left
> This
->currentDesc
.Width
) ||(DestRect
->left
< 0) ||
936 (DestRect
->right
> This
->currentDesc
.Width
) ||(DestRect
->right
< 0) ||
937 (DestRect
->right
< DestRect
->left
) ||(DestRect
->bottom
< DestRect
->top
)))
939 WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
940 return WINEDDERR_INVALIDRECT
;
943 /* Now handle negative values in the rectangles. Warning: only supported for now
944 in the 'simple' cases (ie not in any stretching / rotation cases).
946 First, the case where nothing is to be done.
948 if ((DestRect
&& ((DestRect
->bottom
<= 0) || (DestRect
->right
<= 0) ||
949 (DestRect
->top
>= (int) This
->currentDesc
.Height
) ||
950 (DestRect
->left
>= (int) This
->currentDesc
.Width
))) ||
951 ((Src
!= NULL
) && (SrcRect
!= NULL
) &&
952 ((SrcRect
->bottom
<= 0) || (SrcRect
->right
<= 0) ||
953 (SrcRect
->top
>= (int) Src
->currentDesc
.Height
) ||
954 (SrcRect
->left
>= (int) Src
->currentDesc
.Width
)) ))
956 TRACE("Nothing to be done !\n");
967 xdst
.bottom
= This
->currentDesc
.Height
;
969 xdst
.right
= This
->currentDesc
.Width
;
981 xsrc
.bottom
= Src
->currentDesc
.Height
;
983 xsrc
.right
= Src
->currentDesc
.Width
;
987 memset(&xsrc
,0,sizeof(xsrc
));
991 /* The easy case : the source-less blits.... */
992 if (Src
== NULL
&& DestRect
)
995 RECT temp_rect
; /* No idea if intersect rect can be the same as one of the source rect */
999 full_rect
.right
= This
->currentDesc
.Width
;
1000 full_rect
.bottom
= This
->currentDesc
.Height
;
1001 IntersectRect(&temp_rect
, &full_rect
, DestRect
);
1006 /* Only handle clipping on the destination rectangle */
1007 int clip_horiz
= (DestRect
->left
< 0) || (DestRect
->right
> (int) This
->currentDesc
.Width
);
1008 int clip_vert
= (DestRect
->top
< 0) || (DestRect
->bottom
> (int) This
->currentDesc
.Height
);
1009 if (clip_vert
|| clip_horiz
)
1011 /* Now check if this is a special case or not... */
1012 if ((((DestRect
->bottom
- DestRect
->top
) != (xsrc
.bottom
- xsrc
.top
)) && clip_vert
) ||
1013 (((DestRect
->right
- DestRect
->left
) != (xsrc
.right
- xsrc
.left
)) && clip_horiz
) ||
1014 (Flags
& WINEDDBLT_DDFX
))
1016 WARN("Out of screen rectangle in special case. Not handled right now.\n");
1022 if (DestRect
->left
< 0) { xsrc
.left
-= DestRect
->left
; xdst
.left
= 0; }
1023 if (DestRect
->right
> This
->currentDesc
.Width
)
1025 xsrc
.right
-= (DestRect
->right
- (int) This
->currentDesc
.Width
);
1026 xdst
.right
= (int) This
->currentDesc
.Width
;
1031 if (DestRect
->top
< 0)
1033 xsrc
.top
-= DestRect
->top
;
1036 if (DestRect
->bottom
> This
->currentDesc
.Height
)
1038 xsrc
.bottom
-= (DestRect
->bottom
- (int) This
->currentDesc
.Height
);
1039 xdst
.bottom
= (int) This
->currentDesc
.Height
;
1042 /* And check if after clipping something is still to be done... */
1043 if ((xdst
.bottom
<= 0) || (xdst
.right
<= 0) ||
1044 (xdst
.top
>= (int) This
->currentDesc
.Height
) ||
1045 (xdst
.left
>= (int) This
->currentDesc
.Width
) ||
1046 (xsrc
.bottom
<= 0) || (xsrc
.right
<= 0) ||
1047 (xsrc
.top
>= (int) Src
->currentDesc
.Height
) ||
1048 (xsrc
.left
>= (int) Src
->currentDesc
.Width
))
1050 TRACE("Nothing to be done after clipping !\n");
1058 IWineD3DSurface_LockRect(iface
, &dlock
, NULL
, 0);
1059 dfmt
= This
->resource
.format
;
1062 sEntry
= getFormatDescEntry(sfmt
, NULL
, NULL
);
1067 dfmt
= This
->resource
.format
;
1068 dEntry
= getFormatDescEntry(dfmt
, NULL
, NULL
);
1071 if(This
->resource
.format
!= Src
->resource
.format
) {
1072 Src
= surface_convert_format(Src
, dfmt
);
1074 /* The conv function writes a FIXME */
1075 WARN("Cannot convert source surface format to dest format\n");
1079 IWineD3DSurface_LockRect((IWineD3DSurface
*) Src
, &slock
, NULL
, WINED3DLOCK_READONLY
);
1080 sfmt
= Src
->resource
.format
;
1082 sEntry
= getFormatDescEntry(sfmt
, NULL
, NULL
);
1084 IWineD3DSurface_LockRect(iface
, &dlock
, &xdst
, 0);
1086 IWineD3DSurface_LockRect(iface
, &dlock
, NULL
, 0);
1089 if (!DDBltFx
|| !(DDBltFx
->dwDDFX
)) Flags
&= ~WINEDDBLT_DDFX
;
1091 if (sEntry
->isFourcc
&& dEntry
->isFourcc
)
1093 if (!DestRect
|| Src
== This
)
1095 memcpy(dlock
.pBits
, slock
.pBits
, This
->resource
.size
);
1100 bpp
= This
->bytesPerPixel
;
1101 srcheight
= xsrc
.bottom
- xsrc
.top
;
1102 srcwidth
= xsrc
.right
- xsrc
.left
;
1103 dstheight
= xdst
.bottom
- xdst
.top
;
1104 dstwidth
= xdst
.right
- xdst
.left
;
1105 width
= (xdst
.right
- xdst
.left
) * bpp
;
1107 assert(width
<= dlock
.Pitch
);
1109 if (DestRect
&& Src
!= This
)
1110 dbuf
= (BYTE
*)dlock
.pBits
;
1112 dbuf
= (BYTE
*)dlock
.pBits
+(xdst
.top
*dlock
.Pitch
)+(xdst
.left
*bpp
);
1114 if (Flags
& WINEDDBLT_WAIT
)
1116 Flags
&= ~WINEDDBLT_WAIT
;
1118 if (Flags
& WINEDDBLT_ASYNC
)
1120 static BOOL displayed
= FALSE
;
1122 FIXME("Can't handle WINEDDBLT_ASYNC flag right now.\n");
1124 Flags
&= ~WINEDDBLT_ASYNC
;
1126 if (Flags
& WINEDDBLT_DONOTWAIT
)
1128 /* WINEDDBLT_DONOTWAIT appeared in DX7 */
1129 static BOOL displayed
= FALSE
;
1131 FIXME("Can't handle WINEDDBLT_DONOTWAIT flag right now.\n");
1133 Flags
&= ~WINEDDBLT_DONOTWAIT
;
1136 /* First, all the 'source-less' blits */
1137 if (Flags
& WINEDDBLT_COLORFILL
)
1139 ret
= _Blt_ColorFill(dbuf
, dstwidth
, dstheight
, bpp
,
1140 dlock
.Pitch
, DDBltFx
->u5
.dwFillColor
);
1141 Flags
&= ~WINEDDBLT_COLORFILL
;
1144 if (Flags
& WINEDDBLT_DEPTHFILL
)
1146 FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
1148 if (Flags
& WINEDDBLT_ROP
)
1150 /* Catch some degenerate cases here */
1151 switch(DDBltFx
->dwROP
)
1154 ret
= _Blt_ColorFill(dbuf
,dstwidth
,dstheight
,bpp
,dlock
.Pitch
,0);
1156 case 0xAA0029: /* No-op */
1159 ret
= _Blt_ColorFill(dbuf
,dstwidth
,dstheight
,bpp
,dlock
.Pitch
,~0);
1161 case SRCCOPY
: /* well, we do that below ? */
1164 FIXME("Unsupported raster op: %08x Pattern: %p\n", DDBltFx
->dwROP
, DDBltFx
->u5
.lpDDSPattern
);
1167 Flags
&= ~WINEDDBLT_ROP
;
1169 if (Flags
& WINEDDBLT_DDROPS
)
1171 FIXME("\tDdraw Raster Ops: %08x Pattern: %p\n", DDBltFx
->dwDDROP
, DDBltFx
->u5
.lpDDSPattern
);
1173 /* Now the 'with source' blits */
1177 int sx
, xinc
, sy
, yinc
;
1179 if (!dstwidth
|| !dstheight
) /* hmm... stupid program ? */
1181 sbase
= (BYTE
*)slock
.pBits
+(xsrc
.top
*slock
.Pitch
)+xsrc
.left
*bpp
;
1182 xinc
= (srcwidth
<< 16) / dstwidth
;
1183 yinc
= (srcheight
<< 16) / dstheight
;
1187 /* No effects, we can cheat here */
1188 if (dstwidth
== srcwidth
)
1190 if (dstheight
== srcheight
)
1192 /* No stretching in either direction. This needs to be as
1193 * fast as possible */
1196 /* check for overlapping surfaces */
1197 if (Src
!= This
|| xdst
.top
< xsrc
.top
||
1198 xdst
.right
<= xsrc
.left
|| xsrc
.right
<= xdst
.left
)
1200 /* no overlap, or dst above src, so copy from top downwards */
1201 for (y
= 0; y
< dstheight
; y
++)
1203 memcpy(dbuf
, sbuf
, width
);
1204 sbuf
+= slock
.Pitch
;
1205 dbuf
+= dlock
.Pitch
;
1208 else if (xdst
.top
> xsrc
.top
) /* copy from bottom upwards */
1210 sbuf
+= (slock
.Pitch
*dstheight
);
1211 dbuf
+= (dlock
.Pitch
*dstheight
);
1212 for (y
= 0; y
< dstheight
; y
++)
1214 sbuf
-= slock
.Pitch
;
1215 dbuf
-= dlock
.Pitch
;
1216 memcpy(dbuf
, sbuf
, width
);
1219 else /* src and dst overlapping on the same line, use memmove */
1221 for (y
= 0; y
< dstheight
; y
++)
1223 memmove(dbuf
, sbuf
, width
);
1224 sbuf
+= slock
.Pitch
;
1225 dbuf
+= dlock
.Pitch
;
1229 /* Stretching in Y direction only */
1230 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
) {
1231 sbuf
= sbase
+ (sy
>> 16) * slock
.Pitch
;
1232 memcpy(dbuf
, sbuf
, width
);
1233 dbuf
+= dlock
.Pitch
;
1239 /* Stretching in X direction */
1241 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
)
1243 sbuf
= sbase
+ (sy
>> 16) * slock
.Pitch
;
1245 if ((sy
>> 16) == (last_sy
>> 16))
1247 /* this sourcerow is the same as last sourcerow -
1248 * copy already stretched row
1250 memcpy(dbuf
, dbuf
- dlock
.Pitch
, width
);
1254 #define STRETCH_ROW(type) { \
1255 const type *s = (const type *)sbuf; \
1256 type *d = (type *)dbuf; \
1257 for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
1258 d[x] = s[sx >> 16]; \
1263 case 1: STRETCH_ROW(BYTE
)
1264 case 2: STRETCH_ROW(WORD
)
1265 case 4: STRETCH_ROW(DWORD
)
1270 for (x
= sx
= 0; x
< dstwidth
; x
++, sx
+= xinc
)
1274 s
= sbuf
+3*(sx
>>16);
1275 pixel
= s
[0]|(s
[1]<<8)|(s
[2]<<16);
1276 d
[0] = (pixel
)&0xff;
1277 d
[1] = (pixel
>> 8)&0xff;
1278 d
[2] = (pixel
>>16)&0xff;
1284 FIXME("Stretched blit not implemented for bpp %d!\n", bpp
*8);
1285 ret
= WINED3DERR_NOTAVAILABLE
;
1290 dbuf
+= dlock
.Pitch
;
1297 LONG dstyinc
= dlock
.Pitch
, dstxinc
= bpp
;
1298 DWORD keylow
= 0xFFFFFFFF, keyhigh
= 0, keymask
= 0xFFFFFFFF;
1299 DWORD destkeylow
= 0x0, destkeyhigh
= 0xFFFFFFFF, destkeymask
= 0xFFFFFFFF;
1300 if (Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYDEST
| WINEDDBLT_KEYSRCOVERRIDE
| WINEDDBLT_KEYDESTOVERRIDE
))
1302 /* The color keying flags are checked for correctness in ddraw */
1303 if (Flags
& WINEDDBLT_KEYSRC
)
1305 keylow
= Src
->SrcBltCKey
.dwColorSpaceLowValue
;
1306 keyhigh
= Src
->SrcBltCKey
.dwColorSpaceHighValue
;
1308 else if (Flags
& WINEDDBLT_KEYSRCOVERRIDE
)
1310 keylow
= DDBltFx
->ddckSrcColorkey
.dwColorSpaceLowValue
;
1311 keyhigh
= DDBltFx
->ddckSrcColorkey
.dwColorSpaceHighValue
;
1314 if (Flags
& WINEDDBLT_KEYDEST
)
1316 /* Destination color keys are taken from the source surface ! */
1317 destkeylow
= Src
->DestBltCKey
.dwColorSpaceLowValue
;
1318 destkeyhigh
= Src
->DestBltCKey
.dwColorSpaceHighValue
;
1320 else if (Flags
& WINEDDBLT_KEYDESTOVERRIDE
)
1322 destkeylow
= DDBltFx
->ddckDestColorkey
.dwColorSpaceLowValue
;
1323 destkeyhigh
= DDBltFx
->ddckDestColorkey
.dwColorSpaceHighValue
;
1332 keymask
= sEntry
->redMask
|
1336 Flags
&= ~(WINEDDBLT_KEYSRC
| WINEDDBLT_KEYDEST
| WINEDDBLT_KEYSRCOVERRIDE
| WINEDDBLT_KEYDESTOVERRIDE
);
1339 if (Flags
& WINEDDBLT_DDFX
)
1341 LPBYTE dTopLeft
, dTopRight
, dBottomLeft
, dBottomRight
, tmp
;
1344 dTopRight
= dbuf
+((dstwidth
-1)*bpp
);
1345 dBottomLeft
= dTopLeft
+((dstheight
-1)*dlock
.Pitch
);
1346 dBottomRight
= dBottomLeft
+((dstwidth
-1)*bpp
);
1348 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_ARITHSTRETCHY
)
1350 /* I don't think we need to do anything about this flag */
1351 WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_ARITHSTRETCHY\n");
1353 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_MIRRORLEFTRIGHT
)
1356 dTopRight
= dTopLeft
;
1359 dBottomRight
= dBottomLeft
;
1361 dstxinc
= dstxinc
*-1;
1363 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_MIRRORUPDOWN
)
1366 dTopLeft
= dBottomLeft
;
1369 dTopRight
= dBottomRight
;
1371 dstyinc
= dstyinc
*-1;
1373 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_NOTEARING
)
1375 /* I don't think we need to do anything about this flag */
1376 WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_NOTEARING\n");
1378 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_ROTATE180
)
1381 dBottomRight
= dTopLeft
;
1384 dBottomLeft
= dTopRight
;
1386 dstxinc
= dstxinc
* -1;
1387 dstyinc
= dstyinc
* -1;
1389 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_ROTATE270
)
1392 dTopLeft
= dBottomLeft
;
1393 dBottomLeft
= dBottomRight
;
1394 dBottomRight
= dTopRight
;
1399 dstxinc
= dstxinc
* -1;
1401 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_ROTATE90
)
1404 dTopLeft
= dTopRight
;
1405 dTopRight
= dBottomRight
;
1406 dBottomRight
= dBottomLeft
;
1411 dstyinc
= dstyinc
* -1;
1413 if (DDBltFx
->dwDDFX
& WINEDDBLTFX_ZBUFFERBASEDEST
)
1415 /* I don't think we need to do anything about this flag */
1416 WARN("Flags=WINEDDBLT_DDFX nothing done for WINEDDBLTFX_ZBUFFERBASEDEST\n");
1419 Flags
&= ~(WINEDDBLT_DDFX
);
1422 #define COPY_COLORKEY_FX(type) { \
1424 type *d = (type *)dbuf, *dx, tmp; \
1425 for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
1426 s = (const type*)(sbase + (sy >> 16) * slock.Pitch); \
1428 for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
1429 tmp = s[sx >> 16]; \
1430 if (((tmp & keymask) < keylow || (tmp & keymask) > keyhigh) && \
1431 ((dx[0] & destkeymask) >= destkeylow && (dx[0] & destkeymask) <= destkeyhigh)) { \
1434 dx = (type*)(((LPBYTE)dx)+dstxinc); \
1436 d = (type*)(((LPBYTE)d)+dstyinc); \
1441 case 1: COPY_COLORKEY_FX(BYTE
)
1442 case 2: COPY_COLORKEY_FX(WORD
)
1443 case 4: COPY_COLORKEY_FX(DWORD
)
1447 BYTE
*d
= dbuf
, *dx
;
1448 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
)
1450 sbuf
= sbase
+ (sy
>> 16) * slock
.Pitch
;
1452 for (x
= sx
= 0; x
< dstwidth
; x
++, sx
+= xinc
)
1454 DWORD pixel
, dpixel
= 0;
1455 s
= sbuf
+3*(sx
>>16);
1456 pixel
= s
[0]|(s
[1]<<8)|(s
[2]<<16);
1457 dpixel
= dx
[0]|(dx
[1]<<8)|(dx
[2]<<16);
1458 if (((pixel
& keymask
) < keylow
|| (pixel
& keymask
) > keyhigh
) &&
1459 ((dpixel
& keymask
) >= destkeylow
|| (dpixel
& keymask
) <= keyhigh
))
1461 dx
[0] = (pixel
)&0xff;
1462 dx
[1] = (pixel
>> 8)&0xff;
1463 dx
[2] = (pixel
>>16)&0xff;
1472 FIXME("%s color-keyed blit not implemented for bpp %d!\n",
1473 (Flags
& WINEDDBLT_KEYSRC
) ? "Source" : "Destination", bpp
*8);
1474 ret
= WINED3DERR_NOTAVAILABLE
;
1476 #undef COPY_COLORKEY_FX
1482 if (Flags
&& FIXME_ON(d3d_surface
))
1484 FIXME("\tUnsupported flags: %08x\n", Flags
);
1488 IWineD3DSurface_UnlockRect(iface
);
1489 if (Src
&& Src
!= This
) IWineD3DSurface_UnlockRect((IWineD3DSurface
*) Src
);
1490 /* Release the converted surface if any */
1491 if (Src
&& SrcSurface
!= (IWineD3DSurface
*) Src
) IWineD3DSurface_Release((IWineD3DSurface
*) Src
);
1495 /*****************************************************************************
1496 * IWineD3DSurface::BltFast, SW emulation version
1498 * This is the software implementation of BltFast, as used by GDI surfaces
1499 * and as a fallback for OpenGL surfaces. This code is taken from the old
1500 * DirectDraw code, and was originally written by TransGaming.
1505 * Source: Source surface to copy from
1506 * rsrc: Source rectangle
1510 * WINED3D_OK on success
1512 *****************************************************************************/
1513 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
,
1514 IWineD3DSurface
*Source
, const RECT
*rsrc
, DWORD trans
)
1516 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
1517 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) Source
;
1519 int bpp
, w
, h
, x
, y
;
1520 WINED3DLOCKED_RECT dlock
,slock
;
1521 HRESULT ret
= WINED3D_OK
;
1523 RECT lock_src
, lock_dst
, lock_union
;
1526 const StaticPixelFormatDesc
*sEntry
, *dEntry
;
1528 if (TRACE_ON(d3d_surface
))
1530 TRACE("(%p)->(%d,%d,%p,%p,%08x)\n", This
,dstx
,dsty
,Src
,rsrc
,trans
);
1534 TRACE("\tsrcrect: %dx%d-%dx%d\n",rsrc
->left
,rsrc
->top
,
1535 rsrc
->right
,rsrc
->bottom
);
1539 TRACE(" srcrect: NULL\n");
1543 if ((This
->Flags
& SFLAG_LOCKED
) ||
1544 (Src
->Flags
& SFLAG_LOCKED
))
1546 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
1547 return WINEDDERR_SURFACEBUSY
;
1552 WARN("rsrc is NULL!\n");
1555 rsrc2
.right
= Src
->currentDesc
.Width
;
1556 rsrc2
.bottom
= Src
->currentDesc
.Height
;
1560 /* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/
1561 if ((rsrc
->bottom
> Src
->currentDesc
.Height
) || (rsrc
->bottom
< 0) ||
1562 (rsrc
->top
> Src
->currentDesc
.Height
) || (rsrc
->top
< 0) ||
1563 (rsrc
->left
> Src
->currentDesc
.Width
) || (rsrc
->left
< 0) ||
1564 (rsrc
->right
> Src
->currentDesc
.Width
) || (rsrc
->right
< 0) ||
1565 (rsrc
->right
< rsrc
->left
) || (rsrc
->bottom
< rsrc
->top
))
1567 WARN("Application gave us bad source rectangle for BltFast.\n");
1568 return WINEDDERR_INVALIDRECT
;
1571 h
= rsrc
->bottom
- rsrc
->top
;
1572 if (h
> This
->currentDesc
.Height
-dsty
) h
= This
->currentDesc
.Height
-dsty
;
1573 if (h
> Src
->currentDesc
.Height
-rsrc
->top
) h
=Src
->currentDesc
.Height
-rsrc
->top
;
1574 if (h
<= 0) return WINEDDERR_INVALIDRECT
;
1576 w
= rsrc
->right
- rsrc
->left
;
1577 if (w
> This
->currentDesc
.Width
-dstx
) w
= This
->currentDesc
.Width
-dstx
;
1578 if (w
> Src
->currentDesc
.Width
-rsrc
->left
) w
= Src
->currentDesc
.Width
-rsrc
->left
;
1579 if (w
<= 0) return WINEDDERR_INVALIDRECT
;
1581 /* Now compute the locking rectangle... */
1582 lock_src
.left
= rsrc
->left
;
1583 lock_src
.top
= rsrc
->top
;
1584 lock_src
.right
= lock_src
.left
+ w
;
1585 lock_src
.bottom
= lock_src
.top
+ h
;
1587 lock_dst
.left
= dstx
;
1588 lock_dst
.top
= dsty
;
1589 lock_dst
.right
= dstx
+ w
;
1590 lock_dst
.bottom
= dsty
+ h
;
1592 bpp
= This
->bytesPerPixel
;
1594 /* We need to lock the surfaces, or we won't get refreshes when done. */
1599 UnionRect(&lock_union
, &lock_src
, &lock_dst
);
1601 /* Lock the union of the two rectangles */
1602 ret
= IWineD3DSurface_LockRect(iface
, &dlock
, &lock_union
, 0);
1603 if(ret
!= WINED3D_OK
) goto error
;
1605 pitch
= dlock
.Pitch
;
1606 slock
.Pitch
= dlock
.Pitch
;
1608 /* Since slock was originally copied from this surface's description, we can just reuse it */
1609 assert(This
->resource
.allocatedMemory
!= NULL
);
1610 sbuf
= This
->resource
.allocatedMemory
+ lock_src
.top
* pitch
+ lock_src
.left
* bpp
;
1611 dbuf
= This
->resource
.allocatedMemory
+ lock_dst
.top
* pitch
+ lock_dst
.left
* bpp
;
1612 sEntry
= getFormatDescEntry(Src
->resource
.format
, NULL
, NULL
);
1617 ret
= IWineD3DSurface_LockRect(Source
, &slock
, &lock_src
, WINED3DLOCK_READONLY
);
1618 if(ret
!= WINED3D_OK
) goto error
;
1619 ret
= IWineD3DSurface_LockRect(iface
, &dlock
, &lock_dst
, 0);
1620 if(ret
!= WINED3D_OK
) goto error
;
1624 TRACE("Dst is at %p, Src is at %p\n", dbuf
, sbuf
);
1626 sEntry
= getFormatDescEntry(Src
->resource
.format
, NULL
, NULL
);
1627 dEntry
= getFormatDescEntry(This
->resource
.format
, NULL
, NULL
);
1630 /* Handle first the FOURCC surfaces... */
1631 if (sEntry
->isFourcc
&& dEntry
->isFourcc
)
1633 TRACE("Fourcc -> Fourcc copy\n");
1635 FIXME("trans arg not supported when a FOURCC surface is involved\n");
1637 FIXME("offset for destination surface is not supported\n");
1638 if (Src
->resource
.format
!= This
->resource
.format
)
1640 FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
1641 ret
= WINED3DERR_WRONGTEXTUREFORMAT
;
1644 /* FIXME: Watch out that the size is correct for FOURCC surfaces */
1645 memcpy(dbuf
, sbuf
, This
->resource
.size
);
1648 if (sEntry
->isFourcc
&& !dEntry
->isFourcc
)
1650 /* TODO: Use the libtxc_dxtn.so shared library to do
1651 * software decompression
1653 ERR("DXTC decompression not supported by now\n");
1657 if (trans
& (WINEDDBLTFAST_SRCCOLORKEY
| WINEDDBLTFAST_DESTCOLORKEY
))
1659 DWORD keylow
, keyhigh
;
1660 TRACE("Color keyed copy\n");
1661 if (trans
& WINEDDBLTFAST_SRCCOLORKEY
)
1663 keylow
= Src
->SrcBltCKey
.dwColorSpaceLowValue
;
1664 keyhigh
= Src
->SrcBltCKey
.dwColorSpaceHighValue
;
1668 /* I'm not sure if this is correct */
1669 FIXME("WINEDDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1670 keylow
= This
->DestBltCKey
.dwColorSpaceLowValue
;
1671 keyhigh
= This
->DestBltCKey
.dwColorSpaceHighValue
;
1674 #define COPYBOX_COLORKEY(type) { \
1675 const type *s = (const type *)sbuf; \
1676 type *d = (type *)dbuf; \
1678 for (y = 0; y < h; y++) { \
1679 for (x = 0; x < w; x++) { \
1681 if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1683 s = (const type *)((const BYTE *)s + slock.Pitch); \
1684 d = (type *)((BYTE *)d + dlock.Pitch); \
1690 case 1: COPYBOX_COLORKEY(BYTE
)
1691 case 2: COPYBOX_COLORKEY(WORD
)
1692 case 4: COPYBOX_COLORKEY(DWORD
)
1700 for (y
= 0; y
< h
; y
++)
1702 for (x
= 0; x
< w
* 3; x
+= 3)
1704 tmp
= (DWORD
)s
[x
] + ((DWORD
)s
[x
+ 1] << 8) + ((DWORD
)s
[x
+ 2] << 16);
1705 if (tmp
< keylow
|| tmp
> keyhigh
)
1707 d
[x
+ 0] = s
[x
+ 0];
1708 d
[x
+ 1] = s
[x
+ 1];
1709 d
[x
+ 2] = s
[x
+ 2];
1718 FIXME("Source color key blitting not supported for bpp %d\n",bpp
*8);
1719 ret
= WINED3DERR_NOTAVAILABLE
;
1722 #undef COPYBOX_COLORKEY
1723 TRACE("Copy Done\n");
1727 int width
= w
* bpp
;
1728 INT sbufpitch
, dbufpitch
;
1730 TRACE("NO color key copy\n");
1731 /* Handle overlapping surfaces */
1734 sbuf
+= (h
- 1) * slock
.Pitch
;
1735 dbuf
+= (h
- 1) * dlock
.Pitch
;
1736 sbufpitch
= -slock
.Pitch
;
1737 dbufpitch
= -dlock
.Pitch
;
1741 sbufpitch
= slock
.Pitch
;
1742 dbufpitch
= dlock
.Pitch
;
1744 for (y
= 0; y
< h
; y
++)
1746 /* This is pretty easy, a line for line memcpy */
1747 memmove(dbuf
, sbuf
, width
);
1751 TRACE("Copy done\n");
1757 IWineD3DSurface_UnlockRect(iface
);
1761 IWineD3DSurface_UnlockRect(iface
);
1762 IWineD3DSurface_UnlockRect(Source
);
1768 HRESULT WINAPI
IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
)
1770 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1772 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n",
1773 This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
1775 pLockedRect
->Pitch
= IWineD3DSurface_GetPitch(iface
);
1779 pLockedRect
->pBits
= This
->resource
.allocatedMemory
;
1780 This
->lockedRect
.left
= 0;
1781 This
->lockedRect
.top
= 0;
1782 This
->lockedRect
.right
= This
->currentDesc
.Width
;
1783 This
->lockedRect
.bottom
= This
->currentDesc
.Height
;
1785 TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n",
1786 &This
->lockedRect
, This
->lockedRect
.left
, This
->lockedRect
.top
,
1787 This
->lockedRect
.right
, This
->lockedRect
.bottom
);
1791 TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n",
1792 pRect
, pRect
->left
, pRect
->top
, pRect
->right
, pRect
->bottom
);
1794 /* DXTn textures are based on compressed blocks of 4x4 pixels, each
1795 * 16 bytes large (8 bytes in case of DXT1). Because of that Pitch has
1796 * slightly different meaning compared to regular textures. For DXTn
1797 * textures Pitch is the size of a row of blocks, 4 high and "width"
1798 * long. The x offset is calculated differently as well, since moving 4
1799 * pixels to the right actually moves an entire 4x4 block to right, ie
1800 * 16 bytes (8 in case of DXT1). */
1801 if (This
->resource
.format
== WINED3DFMT_DXT1
)
1803 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+ (pLockedRect
->Pitch
* pRect
->top
/ 4) + (pRect
->left
* 2);
1805 else if (This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
1806 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
)
1808 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+ (pLockedRect
->Pitch
* pRect
->top
/ 4) + (pRect
->left
* 4);
1812 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+
1813 (pLockedRect
->Pitch
* pRect
->top
) +
1814 (pRect
->left
* This
->bytesPerPixel
);
1816 This
->lockedRect
.left
= pRect
->left
;
1817 This
->lockedRect
.top
= pRect
->top
;
1818 This
->lockedRect
.right
= pRect
->right
;
1819 This
->lockedRect
.bottom
= pRect
->bottom
;
1822 /* No dirtifying is needed for this surface implementation */
1823 TRACE("returning memory@%p, pitch(%d)\n", pLockedRect
->pBits
, pLockedRect
->Pitch
);
1828 void WINAPI
IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface
*iface
) {
1829 ERR("Should not be called on base texture\n");
1833 /* TODO: think about moving this down to resource? */
1834 const void *WINAPI
IWineD3DBaseSurfaceImpl_GetData(IWineD3DSurface
*iface
)
1836 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1838 /* This should only be called for sysmem textures, it may be a good idea
1839 * to extend this to all pools at some point in the future */
1840 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
)
1842 FIXME("(%p) Attempting to get system memory for a non-system memory texture\n", iface
);
1844 return This
->resource
.allocatedMemory
;