2 * IWineD3DSurface Implementation
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 Stefan Dösinger for CodeWeavers
11 * Copyright 2007 Henri Verbeet
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"
32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
33 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
55 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*surf
);
57 static void surface_download_data(IWineD3DSurfaceImpl
*This
) {
58 if (!This
->resource
.allocatedMemory
) This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
+ 4);
59 if (This
->resource
.format
== WINED3DFMT_DXT1
||
60 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
61 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
62 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) { /* We can assume this as the texture would not have been created otherwise */
63 FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This
);
65 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
66 This
->glDescription
.glFormat
, This
->glDescription
.glType
, This
->resource
.allocatedMemory
);
68 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, This
->resource
.allocatedMemory
));
69 checkGLcall("glGetCompressedTexImageARB()");
76 if(This
->Flags
& SFLAG_CONVERTED
) {
77 FIXME("Read back converted textures unsupported\n");
81 if (This
->Flags
& SFLAG_NONPOW2
) {
82 src_pitch
= This
->bytesPerPixel
* This
->pow2Width
;
83 dst_pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
);
84 src_pitch
= (src_pitch
+ SURFACE_ALIGNMENT
- 1) & ~(SURFACE_ALIGNMENT
- 1);
85 mem
= HeapAlloc(GetProcessHeap(), 0, src_pitch
* This
->pow2Height
);
87 mem
= This
->resource
.allocatedMemory
;
90 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
91 This
->glDescription
.glFormat
, This
->glDescription
.glType
, mem
);
93 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, This
->glDescription
.glFormat
,
94 This
->glDescription
.glType
, mem
);
95 checkGLcall("glGetTexImage()");
97 if (This
->Flags
& SFLAG_NONPOW2
) {
98 LPBYTE src_data
, dst_data
;
101 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
102 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
103 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
105 * We're doing this...
107 * instead of boxing the texture :
108 * |<-texture width ->| -->pow2width| /\
109 * |111111111111111111| | |
110 * |222 Texture 222222| boxed empty | texture height
111 * |3333 Data 33333333| | |
112 * |444444444444444444| | \/
113 * ----------------------------------- |
114 * | boxed empty | boxed empty | pow2height
116 * -----------------------------------
119 * we're repacking the data to the expected texture width
121 * |<-texture width ->| -->pow2width| /\
122 * |111111111111111111222222222222222| |
123 * |222333333333333333333444444444444| texture height
127 * | empty | pow2height
129 * -----------------------------------
133 * |<-texture width ->| /\
134 * |111111111111111111|
135 * |222222222222222222|texture height
136 * |333333333333333333|
137 * |444444444444444444| \/
138 * --------------------
140 * this also means that any references to allocatedMemory should work with the data as if were a
141 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
143 * internally the texture is still stored in a boxed format so any references to textureName will
144 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
146 * Performance should not be an issue, because applications normally do not lock the surfaces when
147 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
148 * and doesn't have to be re-read.
151 dst_data
= This
->resource
.allocatedMemory
;
152 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This
, src_pitch
, dst_pitch
);
153 for (y
= 1 ; y
< This
->currentDesc
.Height
; y
++) {
154 /* skip the first row */
155 src_data
+= src_pitch
;
156 dst_data
+= dst_pitch
;
157 memcpy(dst_data
, src_data
, dst_pitch
);
160 HeapFree(GetProcessHeap(), 0, mem
);
163 /* Surface has now been downloaded */
164 This
->Flags
|= SFLAG_INSYSMEM
;
167 static void surface_upload_data(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*data
) {
168 if (This
->resource
.format
== WINED3DFMT_DXT1
||
169 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
170 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
171 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
172 FIXME("Using DXT1/3/5 without advertized support\n");
174 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
175 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
176 This
->Flags
|= SFLAG_CLIENT
;
179 TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This
, width
, height
, data
);
181 /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
182 * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
183 * function uses glCompressedTexImage2D instead of the SubImage call
185 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
186 width
, height
, 0 /* border */, This
->resource
.size
, data
));
187 checkGLcall("glCompressedTexSubImage2D");
191 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This
, width
, height
, data
);
193 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, data
);
194 checkGLcall("glTexSubImage2D");
199 static void surface_allocate_surface(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
) {
200 BOOL enable_client_storage
= FALSE
;
202 TRACE("(%p) : Creating surface (target %#x) level %d, d3d format %s, internal format %#x, width %d, height %d, gl format %#x, gl type=%#x\n", This
,
203 This
->glDescription
.target
, This
->glDescription
.level
, debug_d3dformat(This
->resource
.format
), internal
, width
, height
, format
, type
);
205 if (This
->resource
.format
== WINED3DFMT_DXT1
||
206 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
207 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
208 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
209 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
215 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
216 if(This
->Flags
& (SFLAG_NONPOW2
| SFLAG_DIBSECTION
| SFLAG_OVERSIZE
| SFLAG_CONVERTED
) || This
->resource
.allocatedMemory
== NULL
) {
217 /* In some cases we want to disable client storage.
218 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
219 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
220 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
221 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
222 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
224 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_FALSE
);
225 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
226 This
->Flags
&= SFLAG_CLIENT
;
227 enable_client_storage
= TRUE
;
229 This
->Flags
|= SFLAG_CLIENT
;
230 /* Below point opengl to our allocated texture memory */
233 glTexImage2D(This
->glDescription
.target
, This
->glDescription
.level
, internal
, width
, height
, 0, format
, type
,
234 This
->Flags
& SFLAG_CLIENT
? This
->resource
.allocatedMemory
: NULL
);
235 checkGLcall("glTexImage2D");
237 if(enable_client_storage
) {
238 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
239 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
243 This
->Flags
|= SFLAG_ALLOCATED
;
246 /* In D3D the depth stencil dimensions have to be greater than or equal to the
247 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
248 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
249 void surface_set_compatible_renderbuffer(IWineD3DSurface
*iface
, unsigned int width
, unsigned int height
) {
250 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
251 renderbuffer_entry_t
*entry
;
252 GLuint renderbuffer
= 0;
253 unsigned int src_width
, src_height
;
255 src_width
= This
->pow2Width
;
256 src_height
= This
->pow2Height
;
258 /* A depth stencil smaller than the render target is not valid */
259 if (width
> src_width
|| height
> src_height
) return;
261 /* Remove any renderbuffer set if the sizes match */
262 if (width
== src_width
&& height
== src_height
) {
263 This
->current_renderbuffer
= NULL
;
267 /* Look if we've already got a renderbuffer of the correct dimensions */
268 LIST_FOR_EACH_ENTRY(entry
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
269 if (entry
->width
== width
&& entry
->height
== height
) {
270 renderbuffer
= entry
->id
;
271 This
->current_renderbuffer
= entry
;
277 const PixelFormatDesc
*format_entry
= getFormatDescEntry(This
->resource
.format
);
279 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer
));
280 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, renderbuffer
));
281 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, format_entry
->glFormat
, width
, height
));
283 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t
));
284 entry
->width
= width
;
285 entry
->height
= height
;
286 entry
->id
= renderbuffer
;
287 list_add_head(&This
->renderbuffers
, &entry
->entry
);
289 This
->current_renderbuffer
= entry
;
292 checkGLcall("set_compatible_renderbuffer");
295 GLenum
surface_get_gl_buffer(IWineD3DSurface
*iface
, IWineD3DSwapChain
*swapchain
) {
296 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
297 IWineD3DSwapChainImpl
*swapchain_impl
= (IWineD3DSwapChainImpl
*)swapchain
;
299 TRACE("(%p) : swapchain %p\n", This
, swapchain
);
301 if (swapchain_impl
->backBuffer
&& swapchain_impl
->backBuffer
[0] == iface
) {
302 TRACE("Returning GL_BACK\n");
304 } else if (swapchain_impl
->frontBuffer
== iface
) {
305 TRACE("Returning GL_FRONT\n");
309 FIXME("Higher back buffer, returning GL_BACK\n");
313 /* *******************************************
314 IWineD3DSurface IUnknown parts follow
315 ******************************************* */
316 HRESULT WINAPI
IWineD3DSurfaceImpl_QueryInterface(IWineD3DSurface
*iface
, REFIID riid
, LPVOID
*ppobj
)
318 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
319 /* Warn ,but be nice about things */
320 TRACE("(%p)->(%s,%p)\n", This
,debugstr_guid(riid
),ppobj
);
322 if (IsEqualGUID(riid
, &IID_IUnknown
)
323 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
324 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
325 || IsEqualGUID(riid
, &IID_IWineD3DSurface
)) {
326 IUnknown_AddRef((IUnknown
*)iface
);
331 return E_NOINTERFACE
;
334 ULONG WINAPI
IWineD3DSurfaceImpl_AddRef(IWineD3DSurface
*iface
) {
335 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
336 ULONG ref
= InterlockedIncrement(&This
->resource
.ref
);
337 TRACE("(%p) : AddRef increasing from %d\n", This
,ref
- 1);
341 ULONG WINAPI
IWineD3DSurfaceImpl_Release(IWineD3DSurface
*iface
) {
342 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
343 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
344 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
346 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->resource
.wineD3DDevice
;
347 renderbuffer_entry_t
*entry
, *entry2
;
348 TRACE("(%p) : cleaning up\n", This
);
350 if(iface
== device
->lastActiveRenderTarget
) {
351 IWineD3DSwapChainImpl
*swapchain
= device
->swapchains
? (IWineD3DSwapChainImpl
*) device
->swapchains
[0] : NULL
;
353 TRACE("Last active render target destroyed\n");
354 /* Find a replacement surface for the currently active back buffer. The context manager does not do NULL
355 * checks, so switch to a valid target as long as the currently set surface is still valid. Use the
356 * surface of the implicit swpchain. If that is the same as the destroyed surface the device is destroyed
357 * and the lastActiveRenderTarget member shouldn't matter
360 ENTER_GL(); /* For ActivateContext */
361 if(swapchain
->backBuffer
&& swapchain
->backBuffer
[0] != iface
) {
362 TRACE("Activating primary back buffer\n");
363 ActivateContext(device
, swapchain
->backBuffer
[0], CTXUSAGE_RESOURCELOAD
);
364 } else if(!swapchain
->backBuffer
&& swapchain
->frontBuffer
!= iface
) {
365 /* Single buffering environment */
366 TRACE("Activating primary front buffer\n");
367 ActivateContext(device
, swapchain
->frontBuffer
, CTXUSAGE_RESOURCELOAD
);
369 TRACE("Device is being destroyed, setting lastActiveRenderTarget = 0xdeadbabe\n");
370 /* Implicit render target destroyed, that means the device is being destroyed
371 * whatever we set here, it shouldn't matter
373 device
->lastActiveRenderTarget
= (IWineD3DSurface
*) 0xdeadbabe;
377 /* May happen during ddraw uninitialization */
378 TRACE("Render target set, but swapchain does not exist!\n");
379 device
->lastActiveRenderTarget
= (IWineD3DSurface
*) 0xdeadcafe;
383 if (This
->glDescription
.textureName
!= 0) { /* release the openGL texture.. */
386 /* Need a context to destroy the texture. Use the currently active render target, but only if
387 * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
388 * When destroying the primary rt, Uninit3D will activate a context before doing anything
390 if(device
->render_targets
[0]) {
391 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
394 TRACE("Deleting texture %d\n", This
->glDescription
.textureName
);
395 glDeleteTextures(1, &This
->glDescription
.textureName
);
399 if(This
->Flags
& SFLAG_DIBSECTION
) {
401 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
403 /* Release the DIB section */
404 DeleteObject(This
->dib
.DIBsection
);
405 This
->dib
.bitmap_data
= NULL
;
406 This
->resource
.allocatedMemory
= NULL
;
408 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
410 HeapFree(GetProcessHeap(), 0, This
->palette9
);
412 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
413 if(iface
== device
->ddraw_primary
)
414 device
->ddraw_primary
= NULL
;
416 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
417 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
418 HeapFree(GetProcessHeap(), 0, entry
);
421 TRACE("(%p) Released\n", This
);
422 HeapFree(GetProcessHeap(), 0, This
);
428 /* ****************************************************
429 IWineD3DSurface IWineD3DResource parts follow
430 **************************************************** */
431 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDevice(IWineD3DSurface
*iface
, IWineD3DDevice
** ppDevice
) {
432 return IWineD3DResourceImpl_GetDevice((IWineD3DResource
*)iface
, ppDevice
);
435 HRESULT WINAPI
IWineD3DSurfaceImpl_SetPrivateData(IWineD3DSurface
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
436 return IWineD3DResourceImpl_SetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
439 HRESULT WINAPI
IWineD3DSurfaceImpl_GetPrivateData(IWineD3DSurface
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
440 return IWineD3DResourceImpl_GetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
443 HRESULT WINAPI
IWineD3DSurfaceImpl_FreePrivateData(IWineD3DSurface
*iface
, REFGUID refguid
) {
444 return IWineD3DResourceImpl_FreePrivateData((IWineD3DResource
*)iface
, refguid
);
447 DWORD WINAPI
IWineD3DSurfaceImpl_SetPriority(IWineD3DSurface
*iface
, DWORD PriorityNew
) {
448 return IWineD3DResourceImpl_SetPriority((IWineD3DResource
*)iface
, PriorityNew
);
451 DWORD WINAPI
IWineD3DSurfaceImpl_GetPriority(IWineD3DSurface
*iface
) {
452 return IWineD3DResourceImpl_GetPriority((IWineD3DResource
*)iface
);
455 void WINAPI
IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface
*iface
) {
456 /* TODO: check for locks */
457 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
458 IWineD3DBaseTexture
*baseTexture
= NULL
;
459 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
461 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
462 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
463 TRACE("Passing to container\n");
464 IWineD3DBaseTexture_PreLoad(baseTexture
);
465 IWineD3DBaseTexture_Release(baseTexture
);
467 TRACE("(%p) : About to load surface\n", This
);
470 if(!device
->isInDraw
) {
471 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
474 glEnable(This
->glDescription
.target
);/* make sure texture support is enabled in this context */
475 if (!This
->glDescription
.level
) {
476 if (!This
->glDescription
.textureName
) {
477 glGenTextures(1, &This
->glDescription
.textureName
);
478 checkGLcall("glGenTextures");
479 TRACE("Surface %p given name %d\n", This
, This
->glDescription
.textureName
);
481 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
482 checkGLcall("glBindTexture");
483 IWineD3DSurface_LoadTexture(iface
, FALSE
);
484 /* This is where we should be reducing the amount of GLMemoryUsed */
485 } else if (This
->glDescription
.textureName
) { /* NOTE: the level 0 surface of a mpmapped texture must be loaded first! */
486 /* assume this is a coding error not a real error for now */
487 FIXME("Mipmap surface has a glTexture bound to it!\n");
489 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
490 /* Tell opengl to try and keep this texture in video ram (well mostly) */
493 glPrioritizeTextures(1, &This
->glDescription
.textureName
, &tmp
);
500 WINED3DRESOURCETYPE WINAPI
IWineD3DSurfaceImpl_GetType(IWineD3DSurface
*iface
) {
501 TRACE("(%p) : calling resourceimpl_GetType\n", iface
);
502 return IWineD3DResourceImpl_GetType((IWineD3DResource
*)iface
);
505 HRESULT WINAPI
IWineD3DSurfaceImpl_GetParent(IWineD3DSurface
*iface
, IUnknown
**pParent
) {
506 TRACE("(%p) : calling resourceimpl_GetParent\n", iface
);
507 return IWineD3DResourceImpl_GetParent((IWineD3DResource
*)iface
, pParent
);
510 /* ******************************************************
511 IWineD3DSurface IWineD3DSurface parts follow
512 ****************************************************** */
514 HRESULT WINAPI
IWineD3DSurfaceImpl_GetContainer(IWineD3DSurface
* iface
, REFIID riid
, void** ppContainer
) {
515 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
516 IWineD3DBase
*container
= 0;
518 TRACE("(This %p, riid %s, ppContainer %p)\n", This
, debugstr_guid(riid
), ppContainer
);
521 ERR("Called without a valid ppContainer.\n");
525 * If the surface is created using CreateImageSurface/CreateOffscreenPlainSurface, CreateRenderTarget,
526 * or CreateDepthStencilSurface, the surface is considered stand alone. In this case,
527 * GetContainer will return the Direct3D device used to create the surface.
529 if (This
->container
) {
530 container
= This
->container
;
532 container
= (IWineD3DBase
*)This
->resource
.wineD3DDevice
;
535 TRACE("Relaying to QueryInterface\n");
536 return IUnknown_QueryInterface(container
, riid
, ppContainer
);
539 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDesc(IWineD3DSurface
*iface
, WINED3DSURFACE_DESC
*pDesc
) {
540 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
542 TRACE("(%p) : copying into %p\n", This
, pDesc
);
543 if(pDesc
->Format
!= NULL
) *(pDesc
->Format
) = This
->resource
.format
;
544 if(pDesc
->Type
!= NULL
) *(pDesc
->Type
) = This
->resource
.resourceType
;
545 if(pDesc
->Usage
!= NULL
) *(pDesc
->Usage
) = This
->resource
.usage
;
546 if(pDesc
->Pool
!= NULL
) *(pDesc
->Pool
) = This
->resource
.pool
;
547 if(pDesc
->Size
!= NULL
) *(pDesc
->Size
) = This
->resource
.size
; /* dx8 only */
548 if(pDesc
->MultiSampleType
!= NULL
) *(pDesc
->MultiSampleType
) = This
->currentDesc
.MultiSampleType
;
549 if(pDesc
->MultiSampleQuality
!= NULL
) *(pDesc
->MultiSampleQuality
) = This
->currentDesc
.MultiSampleQuality
;
550 if(pDesc
->Width
!= NULL
) *(pDesc
->Width
) = This
->currentDesc
.Width
;
551 if(pDesc
->Height
!= NULL
) *(pDesc
->Height
) = This
->currentDesc
.Height
;
555 void WINAPI
IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface
*iface
, UINT textureName
, int target
) {
556 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
557 TRACE("(%p) : setting textureName %u, target %i\n", This
, textureName
, target
);
558 if (This
->glDescription
.textureName
== 0 && textureName
!= 0) {
559 This
->Flags
&= ~SFLAG_INTEXTURE
;
560 IWineD3DSurface_AddDirtyRect(iface
, NULL
);
562 This
->glDescription
.textureName
= textureName
;
563 This
->glDescription
.target
= target
;
564 This
->Flags
&= ~SFLAG_ALLOCATED
;
567 void WINAPI
IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
568 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
569 TRACE("(%p) : returning %p\n", This
, &This
->glDescription
);
570 *glDescription
= &This
->glDescription
;
573 /* TODO: think about moving this down to resource? */
574 const void *WINAPI
IWineD3DSurfaceImpl_GetData(IWineD3DSurface
*iface
) {
575 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
576 /* This should only be called for sysmem textures, it may be a good idea to extend this to all pools at some point in the future */
577 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
) {
578 FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface
);
580 return (CONST
void*)(This
->resource
.allocatedMemory
);
583 static void read_from_framebuffer(IWineD3DSurfaceImpl
*This
, CONST RECT
*rect
, void *dest
, UINT pitch
, BOOL srcUpsideDown
) {
587 BYTE
*row
, *top
, *bottom
;
591 switch(This
->resource
.format
)
595 /* GL can't return palettized data, so read ARGB pixels into a
596 * separate block of memory and convert them into palettized format
597 * in software. Slow, but if the app means to use palettized render
598 * targets and locks it...
600 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
601 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
602 * for the color channels when palettizing the colors.
605 type
= GL_UNSIGNED_BYTE
;
607 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* 3);
609 ERR("Out of memory\n");
612 bpp
= This
->bytesPerPixel
* 3;
618 fmt
= This
->glDescription
.glFormat
;
619 type
= This
->glDescription
.glType
;
620 bpp
= This
->bytesPerPixel
;
623 glReadPixels(rect
->left
, rect
->top
,
624 rect
->right
- rect
->left
,
625 rect
->bottom
- rect
->top
,
627 vcheckGLcall("glReadPixels");
629 /* TODO: Merge this with the palettization loop below for P8 targets */
633 /* glReadPixels returns the image upside down, and there is no way to prevent this.
634 Flip the lines in software */
635 len
= (rect
->right
- rect
->left
) * bpp
;
636 off
= rect
->left
* bpp
;
638 row
= HeapAlloc(GetProcessHeap(), 0, len
);
640 ERR("Out of memory\n");
641 if(This
->resource
.format
== WINED3DFMT_P8
) HeapFree(GetProcessHeap(), 0, mem
);
645 top
= mem
+ pitch
* rect
->top
;
646 bottom
= ((BYTE
*) mem
) + pitch
* ( rect
->bottom
- rect
->top
- 1);
647 for(i
= 0; i
< (rect
->bottom
- rect
->top
) / 2; i
++) {
648 memcpy(row
, top
+ off
, len
);
649 memcpy(top
+ off
, bottom
+ off
, len
);
650 memcpy(bottom
+ off
, row
, len
);
654 HeapFree(GetProcessHeap(), 0, row
);
657 if(This
->resource
.format
== WINED3DFMT_P8
) {
659 DWORD width
= pitch
/ 3;
662 pal
= This
->palette
->palents
;
664 pal
= This
->resource
.wineD3DDevice
->palettes
[This
->resource
.wineD3DDevice
->currentPalette
];
667 for(y
= rect
->top
; y
< rect
->bottom
; y
++) {
668 for(x
= rect
->left
; x
< rect
->right
; x
++) {
669 /* start lines pixels */
670 BYTE
*blue
= (BYTE
*) ((BYTE
*) mem
) + y
* pitch
+ x
* (sizeof(BYTE
) * 3);
671 BYTE
*green
= blue
+ 1;
672 BYTE
*red
= green
+ 1;
674 for(c
= 0; c
< 256; c
++) {
675 if(*red
== pal
[c
].peRed
&&
676 *green
== pal
[c
].peGreen
&&
677 *blue
== pal
[c
].peBlue
)
679 *((BYTE
*) dest
+ y
* width
+ x
) = c
;
685 HeapFree(GetProcessHeap(), 0, mem
);
689 static HRESULT WINAPI
IWineD3DSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
) {
690 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
691 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
692 IWineD3DSwapChainImpl
*swapchain
= NULL
;
694 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
696 if (!(This
->Flags
& SFLAG_LOCKABLE
)) {
697 /* Note: UpdateTextures calls CopyRects which calls this routine to populate the
698 texture regions, and since the destination is an unlockable region we need
700 TRACE("Warning: trying to lock unlockable surf@%p\n", This
);
701 /*return WINED3DERR_INVALIDCALL; */
704 pLockedRect
->Pitch
= IWineD3DSurface_GetPitch(iface
);
706 /* Mark the surface locked */
707 This
->Flags
|= SFLAG_LOCKED
;
709 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy */
710 if(!This
->resource
.allocatedMemory
) {
711 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ 4);
712 This
->Flags
&= ~SFLAG_INSYSMEM
; /* This is the marker that surface data has to be downloaded */
715 /* Calculate the correct start address to report */
717 pLockedRect
->pBits
= This
->resource
.allocatedMemory
;
718 This
->lockedRect
.left
= 0;
719 This
->lockedRect
.top
= 0;
720 This
->lockedRect
.right
= This
->currentDesc
.Width
;
721 This
->lockedRect
.bottom
= This
->currentDesc
.Height
;
722 TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n", &This
->lockedRect
, This
->lockedRect
.left
, This
->lockedRect
.top
, This
->lockedRect
.right
, This
->lockedRect
.bottom
);
724 TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n", pRect
, pRect
->left
, pRect
->top
, pRect
->right
, pRect
->bottom
);
726 /* DXTn textures are based on compressed blocks of 4x4 pixels, each
727 * 16 bytes large (8 bytes in case of DXT1). Because of that Pitch has
728 * slightly different meaning compared to regular textures. For DXTn
729 * textures Pitch is the size of a row of blocks, 4 high and "width"
730 * long. The x offset is calculated differently as well, since moving 4
731 * pixels to the right actually moves an entire 4x4 block to right, ie
732 * 16 bytes (8 in case of DXT1). */
733 if (This
->resource
.format
== WINED3DFMT_DXT1
) {
734 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+ (pLockedRect
->Pitch
* pRect
->top
/ 4) + (pRect
->left
* 2);
735 } else if (This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
736 || This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
737 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+ (pLockedRect
->Pitch
* pRect
->top
/ 4) + (pRect
->left
* 4);
739 pLockedRect
->pBits
= This
->resource
.allocatedMemory
+ (pLockedRect
->Pitch
* pRect
->top
) + (pRect
->left
* This
->bytesPerPixel
);
741 This
->lockedRect
.left
= pRect
->left
;
742 This
->lockedRect
.top
= pRect
->top
;
743 This
->lockedRect
.right
= pRect
->right
;
744 This
->lockedRect
.bottom
= pRect
->bottom
;
747 if (This
->Flags
& SFLAG_NONPOW2
) {
748 TRACE("Locking non-power 2 texture\n");
751 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
752 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
755 if(!(This
->Flags
& SFLAG_DYNLOCK
)) {
757 /* MAXLOCKCOUNT is defined in wined3d_private.h */
758 if(This
->lockCount
> MAXLOCKCOUNT
) {
759 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
760 This
->Flags
|= SFLAG_DYNLOCK
;
764 if((Flags
& WINED3DLOCK_DISCARD
) || (This
->Flags
& SFLAG_INSYSMEM
)) {
765 TRACE("WINED3DLOCK_DISCARD flag passed, or local copy is up to date, not downloading data\n");
769 /* Now download the surface content from opengl
770 * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
771 * Offscreen targets which are not active at the moment or are higher targets(fbos) can be locked with the texture path
773 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
774 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
775 BOOL srcIsUpsideDown
;
777 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
778 static BOOL warned
= FALSE
;
780 ERR("The application tries to lock the render target, but render target locking is disabled\n");
783 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
787 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
788 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
789 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
790 * context->last_was_blit set on the unlock.
793 ActivateContext(myDevice
, iface
, CTXUSAGE_BLIT
);
795 /* Select the correct read buffer, and give some debug output.
796 * There is no need to keep track of the current read buffer or reset it, every part of the code
797 * that reads sets the read buffer as desired.
800 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
801 * Read from the back buffer
803 TRACE("Locking offscreen render target\n");
804 glReadBuffer(myDevice
->offscreenBuffer
);
805 srcIsUpsideDown
= TRUE
;
807 GLenum buffer
= surface_get_gl_buffer(iface
, (IWineD3DSwapChain
*)swapchain
);
808 TRACE("Locking %#x buffer\n", buffer
);
809 glReadBuffer(buffer
);
810 checkGLcall("glReadBuffer");
812 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
813 srcIsUpsideDown
= FALSE
;
816 switch(wined3d_settings
.rendertargetlock_mode
) {
820 read_from_framebuffer(This
, &This
->lockedRect
, This
->resource
.allocatedMemory
, pLockedRect
->Pitch
, srcIsUpsideDown
);
825 read_from_framebuffer(This
, &This
->lockedRect
, This
->resource
.allocatedMemory
, pLockedRect
->Pitch
, srcIsUpsideDown
);
826 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
831 /* Mark the local copy up to date if a full download was done */
832 if(This
->lockedRect
.left
== 0 &&
833 This
->lockedRect
.top
== 0 &&
834 This
->lockedRect
.right
== This
->currentDesc
.Width
&&
835 This
->lockedRect
.bottom
== This
->currentDesc
.Height
) {
836 This
->Flags
|= SFLAG_INSYSMEM
;
838 } else if(iface
== myDevice
->stencilBufferTarget
) {
839 /** the depth stencil in openGL has a format of GL_FLOAT
840 * which should be good for WINED3DFMT_D16_LOCKABLE
842 * it is unclear what format the stencil buffer is in except.
843 * 'Each index is converted to fixed point...
844 * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
845 * mappings in the table GL_PIXEL_MAP_S_TO_S.
846 * glReadPixels(This->lockedRect.left,
847 * This->lockedRect.bottom - j - 1,
848 * This->lockedRect.right - This->lockedRect.left,
850 * GL_DEPTH_COMPONENT,
852 * (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
854 * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
855 * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
856 * none of that is the case the problem is not in this function :-)
857 ********************************************/
858 FIXME("Depth stencil locking not supported yet\n");
860 /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
861 TRACE("locking an ordinary surface\n");
863 if (0 != This
->glDescription
.textureName
) {
864 /* Now I have to copy thing bits back */
868 if(myDevice
->createParms
.BehaviorFlags
& WINED3DCREATE_MULTITHREADED
) {
869 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
872 /* Make sure that a proper texture unit is selected, bind the texture and dirtify the sampler to restore the texture on the next draw */
873 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
874 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
875 checkGLcall("glActiveTextureARB");
877 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(0));
878 IWineD3DSurface_PreLoad(iface
);
880 surface_download_data(This
);
886 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
889 IWineD3DBaseTexture
*pBaseTexture
;
892 * as seen in msdn docs
894 IWineD3DSurface_AddDirtyRect(iface
, &This
->lockedRect
);
896 /** Dirtify Container if needed */
897 if (WINED3D_OK
== IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&pBaseTexture
) && pBaseTexture
!= NULL
) {
898 TRACE("Making container dirty\n");
899 IWineD3DBaseTexture_SetDirty(pBaseTexture
, TRUE
);
900 IWineD3DBaseTexture_Release(pBaseTexture
);
902 TRACE("Surface is standalone, no need to dirty the container\n");
906 TRACE("returning memory@%p, pitch(%d) dirtyfied(%d)\n", pLockedRect
->pBits
, pLockedRect
->Pitch
,
907 This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
911 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl
*This
) {
913 GLint prev_rasterpos
[4];
915 BOOL storechanged
= FALSE
, memory_allocated
= FALSE
;
919 UINT pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
); /* target is argb, 4 byte */
921 glDisable(GL_TEXTURE_2D
);
922 vcheckGLcall("glDisable(GL_TEXTURE_2D)");
925 vcheckGLcall("glFlush");
926 glGetIntegerv(GL_PACK_SWAP_BYTES
, &prev_store
);
927 vcheckGLcall("glIntegerv");
928 glGetIntegerv(GL_CURRENT_RASTER_POSITION
, &prev_rasterpos
[0]);
929 vcheckGLcall("glIntegerv");
930 glPixelZoom(1.0, -1.0);
931 vcheckGLcall("glPixelZoom");
933 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
934 glGetIntegerv(GL_UNPACK_ROW_LENGTH
, &skipBytes
);
935 glPixelStorei(GL_UNPACK_ROW_LENGTH
, This
->currentDesc
.Width
);
937 glRasterPos3i(This
->lockedRect
.left
, This
->lockedRect
.top
, 1);
938 vcheckGLcall("glRasterPos2f");
940 /* Some drivers(radeon dri, others?) don't like exceptions during
941 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
942 * after ReleaseDC. Reading it will cause an exception, which x11drv will
943 * catch to put the dib section in InSync mode, which leads to a crash
944 * and a blocked x server on my radeon card.
946 * The following lines read the dib section so it is put in inSync mode
947 * before glDrawPixels is called and the crash is prevented. There won't
948 * be any interfering gdi accesses, because UnlockRect is called from
949 * ReleaseDC, and the app won't use the dc any more afterwards.
951 if(This
->Flags
& SFLAG_DIBSECTION
) {
953 read
= This
->resource
.allocatedMemory
[0];
956 switch (This
->resource
.format
) {
957 /* No special care needed */
958 case WINED3DFMT_A4R4G4B4
:
959 case WINED3DFMT_R5G6B5
:
960 case WINED3DFMT_A1R5G5B5
:
961 case WINED3DFMT_R8G8B8
:
962 type
= This
->glDescription
.glType
;
963 fmt
= This
->glDescription
.glFormat
;
964 mem
= This
->resource
.allocatedMemory
;
965 bpp
= This
->bytesPerPixel
;
968 case WINED3DFMT_X4R4G4B4
:
971 unsigned short *data
;
972 data
= (unsigned short *)This
->resource
.allocatedMemory
;
973 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
979 type
= This
->glDescription
.glType
;
980 fmt
= This
->glDescription
.glFormat
;
981 mem
= This
->resource
.allocatedMemory
;
982 bpp
= This
->bytesPerPixel
;
986 case WINED3DFMT_X1R5G5B5
:
989 unsigned short *data
;
990 data
= (unsigned short *)This
->resource
.allocatedMemory
;
991 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
997 type
= This
->glDescription
.glType
;
998 fmt
= This
->glDescription
.glFormat
;
999 mem
= This
->resource
.allocatedMemory
;
1000 bpp
= This
->bytesPerPixel
;
1004 case WINED3DFMT_X8R8G8B8
:
1006 /* make sure the X byte is set to alpha on, since it
1007 could be any random value. This fixes the intro movie in Pirates! */
1010 data
= (unsigned int *)This
->resource
.allocatedMemory
;
1011 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1013 *data
|= 0xFF000000;
1020 case WINED3DFMT_A8R8G8B8
:
1022 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1023 vcheckGLcall("glPixelStorei");
1024 storechanged
= TRUE
;
1025 type
= This
->glDescription
.glType
;
1026 fmt
= This
->glDescription
.glFormat
;
1027 mem
= This
->resource
.allocatedMemory
;
1028 bpp
= This
->bytesPerPixel
;
1032 case WINED3DFMT_A2R10G10B10
:
1034 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1035 vcheckGLcall("glPixelStorei");
1036 storechanged
= TRUE
;
1037 type
= This
->glDescription
.glType
;
1038 fmt
= This
->glDescription
.glFormat
;
1039 mem
= This
->resource
.allocatedMemory
;
1040 bpp
= This
->bytesPerPixel
;
1046 int height
= This
->glRect
.bottom
- This
->glRect
.top
;
1047 type
= GL_UNSIGNED_BYTE
;
1050 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* sizeof(DWORD
));
1052 ERR("Out of memory\n");
1055 memory_allocated
= TRUE
;
1056 d3dfmt_convert_surface(This
->resource
.allocatedMemory
,
1064 bpp
= This
->bytesPerPixel
* 4;
1070 FIXME("Unsupported Format %u in locking func\n", This
->resource
.format
);
1073 type
= This
->glDescription
.glType
;
1074 fmt
= This
->glDescription
.glFormat
;
1075 mem
= This
->resource
.allocatedMemory
;
1076 bpp
= This
->bytesPerPixel
;
1079 glDrawPixels(This
->lockedRect
.right
- This
->lockedRect
.left
,
1080 (This
->lockedRect
.bottom
- This
->lockedRect
.top
)-1,
1082 mem
+ bpp
* This
->lockedRect
.left
+ pitch
* This
->lockedRect
.top
);
1083 checkGLcall("glDrawPixels");
1084 glPixelZoom(1.0,1.0);
1085 vcheckGLcall("glPixelZoom");
1087 glRasterPos3iv(&prev_rasterpos
[0]);
1088 vcheckGLcall("glRasterPos3iv");
1090 /* Reset to previous pack row length */
1091 glPixelStorei(GL_UNPACK_ROW_LENGTH
, skipBytes
);
1092 vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1094 glPixelStorei(GL_PACK_SWAP_BYTES
, prev_store
);
1095 vcheckGLcall("glPixelStorei GL_PACK_SWAP_BYTES");
1098 /* Blitting environment requires that 2D texturing is enabled. It was turned off before,
1101 glEnable(GL_TEXTURE_2D
);
1102 checkGLcall("glEnable(GL_TEXTURE_2D)");
1104 if(memory_allocated
) HeapFree(GetProcessHeap(), 0, mem
);
1108 static void flush_to_framebuffer_texture(IWineD3DSurfaceImpl
*This
) {
1109 float glTexCoord
[4];
1111 glTexCoord
[0] = (float) This
->lockedRect
.left
/ (float) This
->pow2Width
; /* left */
1112 glTexCoord
[1] = (float) This
->lockedRect
.right
/ (float) This
->pow2Width
; /* right */
1113 glTexCoord
[2] = (float) This
->lockedRect
.top
/ (float) This
->pow2Height
; /* top */
1114 glTexCoord
[3] = (float) This
->lockedRect
.bottom
/ (float) This
->pow2Height
; /* bottom */
1116 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
1120 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
1121 checkGLcall("glEnable glBindTexture");
1123 /* No filtering for blts */
1124 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
1125 checkGLcall("glTexParameteri");
1126 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
1127 checkGLcall("glTexParameteri");
1129 /* Start drawing a quad */
1132 glColor3d(1.0f
, 1.0f
, 1.0f
);
1133 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
1134 glVertex3f(This
->lockedRect
.left
, This
->lockedRect
.top
, 0.0);
1136 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
1137 glVertex3f(This
->lockedRect
.left
, This
->lockedRect
.bottom
, 0.0);
1139 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
1140 glVertex3d(This
->lockedRect
.right
, This
->lockedRect
.bottom
, 0.0);
1142 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
1143 glVertex3f(This
->lockedRect
.right
, This
->lockedRect
.top
, 0.0);
1146 checkGLcall("glEnd");
1148 /* Unbind the texture */
1149 glBindTexture(GL_TEXTURE_2D
, 0);
1150 checkGLcall("glEnable glBindTexture");
1155 static HRESULT WINAPI
IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface
*iface
) {
1156 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1157 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1158 IWineD3DSwapChainImpl
*swapchain
= NULL
;
1160 if (!(This
->Flags
& SFLAG_LOCKED
)) {
1161 WARN("trying to Unlock an unlocked surf@%p\n", This
);
1162 return WINED3DERR_INVALIDCALL
;
1165 TRACE("(%p) : dirtyfied(%d)\n", This
, This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
1167 if (This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
)) {
1168 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This
);
1172 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1173 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
1174 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
1175 static BOOL warned
= FALSE
;
1177 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1180 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
1184 /* Activate the correct context for the render target */
1186 ActivateContext(myDevice
, iface
, CTXUSAGE_BLIT
);
1189 /* Primary offscreen render target */
1190 TRACE("Offscreen render target\n");
1191 glDrawBuffer(myDevice
->offscreenBuffer
);
1192 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1194 GLenum buffer
= surface_get_gl_buffer(iface
, (IWineD3DSwapChain
*)swapchain
);
1195 TRACE("Unlocking %#x buffer\n", buffer
);
1196 glDrawBuffer(buffer
);
1197 checkGLcall("glDrawBuffer");
1199 IWineD3DSwapChain_Release((IWineD3DSwapChain
*)swapchain
);
1202 switch(wined3d_settings
.rendertargetlock_mode
) {
1206 flush_to_framebuffer_drawpixels(This
);
1211 flush_to_framebuffer_texture(This
);
1215 glDrawBuffer(myDevice
->offscreenBuffer
);
1216 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1217 } else if(swapchain
->backBuffer
) {
1218 glDrawBuffer(GL_BACK
);
1219 checkGLcall("glDrawBuffer(GL_BACK)");
1221 glDrawBuffer(GL_FRONT
);
1222 checkGLcall("glDrawBuffer(GL_FRONT)");
1226 This
->dirtyRect
.left
= This
->currentDesc
.Width
;
1227 This
->dirtyRect
.top
= This
->currentDesc
.Height
;
1228 This
->dirtyRect
.right
= 0;
1229 This
->dirtyRect
.bottom
= 0;
1230 This
->Flags
|= SFLAG_INDRAWABLE
;
1231 } else if(iface
== myDevice
->stencilBufferTarget
) {
1232 FIXME("Depth Stencil buffer locking is not implemented\n");
1234 /* The rest should be a normal texture */
1235 IWineD3DBaseTextureImpl
*impl
;
1236 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1237 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1238 * states need resetting
1240 if(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&impl
) == WINED3D_OK
) {
1241 if(impl
->baseTexture
.bindCount
) {
1242 IWineD3DDeviceImpl_MarkStateDirty(myDevice
, STATE_SAMPLER(impl
->baseTexture
.sampler
));
1244 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*) impl
);
1249 This
->Flags
&= ~SFLAG_LOCKED
;
1250 memset(&This
->lockedRect
, 0, sizeof(RECT
));
1254 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
1255 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1256 WINED3DLOCKED_RECT lock
;
1263 const PixelFormatDesc
*formatEntry
= getFormatDescEntry(This
->resource
.format
);
1265 TRACE("(%p)->(%p)\n",This
,pHDC
);
1267 if(This
->Flags
& SFLAG_USERPTR
) {
1268 ERR("Not supported on surfaces with an application-provided surfaces\n");
1269 return WINEDDERR_NODC
;
1272 /* Give more detailed info for ddraw */
1273 if (This
->Flags
& SFLAG_DCINUSE
)
1274 return WINEDDERR_DCALREADYCREATED
;
1276 /* Can't GetDC if the surface is locked */
1277 if (This
->Flags
& SFLAG_LOCKED
)
1278 return WINED3DERR_INVALIDCALL
;
1280 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
1282 /* Create a DIB section if there isn't a hdc yet */
1285 SYSTEM_INFO sysInfo
;
1286 void *oldmem
= This
->resource
.allocatedMemory
;
1288 switch (This
->bytesPerPixel
) {
1291 /* Allocate extra space to store the RGB bit masks. */
1292 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + 3 * sizeof(DWORD
));
1296 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
));
1300 /* Allocate extra space for a palette. */
1301 b_info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1302 sizeof(BITMAPINFOHEADER
)
1304 * (1 << (This
->bytesPerPixel
* 8)));
1309 return E_OUTOFMEMORY
;
1311 /* Some apps access the surface in via DWORDs, and do not take the necessary care at the end of the
1312 * surface. So we need at least extra 4 bytes at the end of the surface. Check against the page size,
1313 * if the last page used for the surface has at least 4 spare bytes we're safe, otherwise
1314 * add an extra line to the dib section
1316 GetSystemInfo(&sysInfo
);
1317 if( ((This
->resource
.size
+ 3) % sysInfo
.dwPageSize
) < 4) {
1319 TRACE("Adding an extra line to the dib section\n");
1322 b_info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1323 b_info
->bmiHeader
.biWidth
= This
->currentDesc
.Width
;
1324 b_info
->bmiHeader
.biHeight
= -This
->currentDesc
.Height
-extraline
;
1325 b_info
->bmiHeader
.biSizeImage
= ( This
->currentDesc
.Height
+ extraline
) * IWineD3DSurface_GetPitch(iface
);
1326 b_info
->bmiHeader
.biPlanes
= 1;
1327 b_info
->bmiHeader
.biBitCount
= This
->bytesPerPixel
* 8;
1329 b_info
->bmiHeader
.biXPelsPerMeter
= 0;
1330 b_info
->bmiHeader
.biYPelsPerMeter
= 0;
1331 b_info
->bmiHeader
.biClrUsed
= 0;
1332 b_info
->bmiHeader
.biClrImportant
= 0;
1334 /* Get the bit masks */
1335 masks
= (DWORD
*) &(b_info
->bmiColors
);
1336 switch (This
->resource
.format
) {
1337 case WINED3DFMT_R8G8B8
:
1338 usage
= DIB_RGB_COLORS
;
1339 b_info
->bmiHeader
.biCompression
= BI_RGB
;
1342 case WINED3DFMT_X1R5G5B5
:
1343 case WINED3DFMT_A1R5G5B5
:
1344 case WINED3DFMT_A4R4G4B4
:
1345 case WINED3DFMT_X4R4G4B4
:
1346 case WINED3DFMT_R3G3B2
:
1347 case WINED3DFMT_A8R3G3B2
:
1348 case WINED3DFMT_A2B10G10R10
:
1349 case WINED3DFMT_A8B8G8R8
:
1350 case WINED3DFMT_X8B8G8R8
:
1351 case WINED3DFMT_A2R10G10B10
:
1352 case WINED3DFMT_R5G6B5
:
1353 case WINED3DFMT_A16B16G16R16
:
1355 b_info
->bmiHeader
.biCompression
= BI_BITFIELDS
;
1356 masks
[0] = formatEntry
->redMask
;
1357 masks
[1] = formatEntry
->greenMask
;
1358 masks
[2] = formatEntry
->blueMask
;
1362 /* Don't know palette */
1363 b_info
->bmiHeader
.biCompression
= BI_RGB
;
1370 HeapFree(GetProcessHeap(), 0, b_info
);
1371 return HRESULT_FROM_WIN32(GetLastError());
1374 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
);
1375 This
->dib
.DIBsection
= CreateDIBSection(ddc
, b_info
, usage
, &This
->dib
.bitmap_data
, 0 /* Handle */, 0 /* Offset */);
1378 if (!This
->dib
.DIBsection
) {
1379 ERR("CreateDIBSection failed!\n");
1380 HeapFree(GetProcessHeap(), 0, b_info
);
1381 return HRESULT_FROM_WIN32(GetLastError());
1384 TRACE("DIBSection at : %p\n", This
->dib
.bitmap_data
);
1386 /* copy the existing surface to the dib section */
1387 if(This
->resource
.allocatedMemory
) {
1388 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, b_info
->bmiHeader
.biSizeImage
);
1389 /* We won't need that any more */
1391 /* This is to make LockRect read the gl Texture although memory is allocated */
1392 This
->Flags
&= ~SFLAG_INSYSMEM
;
1395 HeapFree(GetProcessHeap(), 0, b_info
);
1397 /* Use the dib section from now on */
1398 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
1400 /* Now allocate a HDC */
1401 This
->hDC
= CreateCompatibleDC(0);
1402 This
->dib
.holdbitmap
= SelectObject(This
->hDC
, This
->dib
.DIBsection
);
1403 TRACE("using wined3d palette %p\n", This
->palette
);
1404 SelectPalette(This
->hDC
,
1405 This
->palette
? This
->palette
->hpal
: 0,
1408 This
->Flags
|= SFLAG_DIBSECTION
;
1410 if(This
->Flags
& SFLAG_CLIENT
) {
1411 IWineD3DSurface_PreLoad(iface
);
1413 HeapFree(GetProcessHeap(), 0, oldmem
);
1416 /* Lock the surface */
1417 hr
= IWineD3DSurface_LockRect(iface
,
1422 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
1423 /* keep the dib section */
1427 if(This
->resource
.format
== WINED3DFMT_P8
||
1428 This
->resource
.format
== WINED3DFMT_A8P8
) {
1431 PALETTEENTRY ent
[256];
1433 GetPaletteEntries(This
->palette
->hpal
, 0, 256, ent
);
1434 for (n
=0; n
<256; n
++) {
1435 col
[n
].rgbRed
= ent
[n
].peRed
;
1436 col
[n
].rgbGreen
= ent
[n
].peGreen
;
1437 col
[n
].rgbBlue
= ent
[n
].peBlue
;
1438 col
[n
].rgbReserved
= 0;
1441 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1443 for (n
=0; n
<256; n
++) {
1444 col
[n
].rgbRed
= device
->palettes
[device
->currentPalette
][n
].peRed
;
1445 col
[n
].rgbGreen
= device
->palettes
[device
->currentPalette
][n
].peGreen
;
1446 col
[n
].rgbBlue
= device
->palettes
[device
->currentPalette
][n
].peBlue
;
1447 col
[n
].rgbReserved
= 0;
1451 SetDIBColorTable(This
->hDC
, 0, 256, col
);
1455 TRACE("returning %p\n",*pHDC
);
1456 This
->Flags
|= SFLAG_DCINUSE
;
1461 HRESULT WINAPI
IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
1462 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1464 TRACE("(%p)->(%p)\n",This
,hDC
);
1466 if (!(This
->Flags
& SFLAG_DCINUSE
))
1467 return WINED3DERR_INVALIDCALL
;
1469 /* we locked first, so unlock now */
1470 IWineD3DSurface_UnlockRect(iface
);
1472 This
->Flags
&= ~SFLAG_DCINUSE
;
1477 /* ******************************************************
1478 IWineD3DSurface Internal (No mapping to directx api) parts follow
1479 ****************************************************** */
1481 static HRESULT
d3dfmt_get_conv(IWineD3DSurfaceImpl
*This
, BOOL need_alpha_ck
, BOOL use_texturing
, GLenum
*format
, GLenum
*internal
, GLenum
*type
, CONVERT_TYPES
*convert
, int *target_bpp
, BOOL srgb_mode
) {
1482 BOOL colorkey_active
= need_alpha_ck
&& (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
);
1483 const PixelFormatDesc
*formatEntry
= getFormatDescEntry(This
->resource
.format
);
1485 /* Default values: From the surface */
1486 *format
= formatEntry
->glFormat
;
1487 *internal
= srgb_mode
?formatEntry
->glGammaInternal
:formatEntry
->glInternal
;
1488 *type
= formatEntry
->glType
;
1489 *convert
= NO_CONVERSION
;
1490 *target_bpp
= This
->bytesPerPixel
;
1492 /* Ok, now look if we have to do any conversion */
1493 switch(This
->resource
.format
) {
1498 /* Use conversion when the paletted texture extension is not available, or when it is available make sure it is used
1499 * for texturing as it won't work for calls like glDraw-/glReadPixels and further also use conversion in case of color keying.
1501 if(!GL_SUPPORT(EXT_PALETTED_TEXTURE
) || colorkey_active
|| (!use_texturing
&& GL_SUPPORT(EXT_PALETTED_TEXTURE
)) ) {
1503 *internal
= GL_RGBA
;
1504 *type
= GL_UNSIGNED_BYTE
;
1506 if(colorkey_active
) {
1507 *convert
= CONVERT_PALETTED_CK
;
1509 *convert
= CONVERT_PALETTED
;
1515 case WINED3DFMT_R3G3B2
:
1516 /* **********************
1517 GL_UNSIGNED_BYTE_3_3_2
1518 ********************** */
1519 if (colorkey_active
) {
1520 /* This texture format will never be used.. So do not care about color keying
1521 up until the point in time it will be needed :-) */
1522 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1526 case WINED3DFMT_R5G6B5
:
1527 if (colorkey_active
) {
1528 *convert
= CONVERT_CK_565
;
1530 *internal
= GL_RGBA
;
1531 *type
= GL_UNSIGNED_SHORT_5_5_5_1
;
1535 case WINED3DFMT_X1R5G5B5
:
1536 if (colorkey_active
) {
1537 *convert
= CONVERT_CK_5551
;
1539 *internal
= GL_RGBA
;
1540 *type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
1544 case WINED3DFMT_R8G8B8
:
1545 if (colorkey_active
) {
1546 *convert
= CONVERT_CK_RGB24
;
1548 *internal
= GL_RGBA
;
1549 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1554 case WINED3DFMT_X8R8G8B8
:
1555 if (colorkey_active
) {
1556 *convert
= CONVERT_RGB32_888
;
1558 *internal
= GL_RGBA
;
1559 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1563 case WINED3DFMT_V8U8
:
1564 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1565 else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1566 *format
= GL_DUDV_ATI
;
1567 *internal
= GL_DU8DV8_ATI
;
1569 /* No conversion - Just change the gl type */
1572 *convert
= CONVERT_V8U8
;
1574 *internal
= GL_RGB8
;
1575 *type
= GL_UNSIGNED_BYTE
;
1579 case WINED3DFMT_X8L8V8U8
:
1580 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1581 *convert
= CONVERT_X8L8V8U8
;
1583 *internal
= GL_RGBA8
;
1584 *type
= GL_UNSIGNED_BYTE
;
1586 /* Not supported by GL_ATI_envmap_bumpmap */
1589 case WINED3DFMT_Q8W8V8U8
:
1590 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1591 *convert
= CONVERT_Q8W8V8U8
;
1593 *internal
= GL_RGBA8
;
1594 *type
= GL_UNSIGNED_BYTE
;
1596 /* Not supported by GL_ATI_envmap_bumpmap */
1599 case WINED3DFMT_V16U16
:
1600 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1601 *convert
= CONVERT_V16U16
;
1603 *internal
= GL_RGB16
;
1606 /* What should I do here about GL_ATI_envmap_bumpmap?
1607 * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1618 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*surf
) {
1619 BYTE
*source
, *dest
;
1620 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src
, dst
, pitch
, height
, outpitch
, convert
, surf
);
1625 memcpy(dst
, src
, pitch
* height
);
1628 case CONVERT_PALETTED
:
1629 case CONVERT_PALETTED_CK
:
1631 IWineD3DPaletteImpl
* pal
= surf
->palette
;
1637 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1641 /* Still no palette? Use the device's palette */
1642 /* Get the surface's palette */
1643 for (i
= 0; i
< 256; i
++) {
1644 IWineD3DDeviceImpl
*device
= surf
->resource
.wineD3DDevice
;
1646 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
1647 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
1648 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
1649 if ((convert
== CONVERT_PALETTED_CK
) &&
1650 (i
>= surf
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1651 (i
<= surf
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1652 /* We should maybe here put a more 'neutral' color than the standard bright purple
1653 one often used by application to prevent the nice purple borders when bi-linear
1661 TRACE("Using surface palette %p\n", pal
);
1662 /* Get the surface's palette */
1663 for (i
= 0; i
< 256; i
++) {
1664 table
[i
][0] = pal
->palents
[i
].peRed
;
1665 table
[i
][1] = pal
->palents
[i
].peGreen
;
1666 table
[i
][2] = pal
->palents
[i
].peBlue
;
1667 if ((convert
== CONVERT_PALETTED_CK
) &&
1668 (i
>= surf
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1669 (i
<= surf
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1670 /* We should maybe here put a more 'neutral' color than the standard bright purple
1671 one often used by application to prevent the nice purple borders when bi-linear
1674 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
1675 table
[i
][3] = pal
->palents
[i
].peFlags
;
1682 for (y
= 0; y
< height
; y
++)
1684 source
= src
+ pitch
* y
;
1685 dest
= dst
+ outpitch
* y
;
1686 /* This is an 1 bpp format, using the width here is fine */
1687 for (x
= 0; x
< width
; x
++) {
1688 BYTE color
= *source
++;
1689 *dest
++ = table
[color
][0];
1690 *dest
++ = table
[color
][1];
1691 *dest
++ = table
[color
][2];
1692 *dest
++ = table
[color
][3];
1698 case CONVERT_CK_565
:
1700 /* Converting the 565 format in 5551 packed to emulate color-keying.
1702 Note : in all these conversion, it would be best to average the averaging
1703 pixels to get the color of the pixel that will be color-keyed to
1704 prevent 'color bleeding'. This will be done later on if ever it is
1707 Note2: Nvidia documents say that their driver does not support alpha + color keying
1708 on the same surface and disables color keying in such a case
1714 TRACE("Color keyed 565\n");
1716 for (y
= 0; y
< height
; y
++) {
1717 Source
= (WORD
*) (src
+ y
* pitch
);
1718 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1719 for (x
= 0; x
< width
; x
++ ) {
1720 WORD color
= *Source
++;
1721 *Dest
= ((color
& 0xFFC0) | ((color
& 0x1F) << 1));
1722 if ((color
< surf
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1723 (color
> surf
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1732 case CONVERT_CK_5551
:
1734 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1738 TRACE("Color keyed 5551\n");
1739 for (y
= 0; y
< height
; y
++) {
1740 Source
= (WORD
*) (src
+ y
* pitch
);
1741 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1742 for (x
= 0; x
< width
; x
++ ) {
1743 WORD color
= *Source
++;
1745 if ((color
< surf
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1746 (color
> surf
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1750 *Dest
&= ~(1 << 15);
1762 unsigned char *Dest
;
1763 for(y
= 0; y
< height
; y
++) {
1764 Source
= (short *) (src
+ y
* pitch
);
1765 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1766 for (x
= 0; x
< width
; x
++ ) {
1767 long color
= (*Source
++);
1768 /* B */ Dest
[0] = 0xff;
1769 /* G */ Dest
[1] = (color
>> 8) + 128; /* V */
1770 /* R */ Dest
[2] = (color
) + 128; /* U */
1777 case CONVERT_Q8W8V8U8
:
1781 unsigned char *Dest
;
1782 for(y
= 0; y
< height
; y
++) {
1783 Source
= (DWORD
*) (src
+ y
* pitch
);
1784 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1785 for (x
= 0; x
< width
; x
++ ) {
1786 long color
= (*Source
++);
1787 /* B */ Dest
[0] = ((color
>> 16) & 0xff) + 128; /* W */
1788 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1789 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1790 /* A */ Dest
[3] = ((color
>> 24) & 0xff) + 128; /* Q */
1798 ERR("Unsupported conversation type %d\n", convert
);
1803 /* This function is used in case of 8bit paletted textures to upload the palette.
1804 For now it only supports GL_EXT_paletted_texture extension but support for other
1805 extensions like ARB_fragment_program and ATI_fragment_shaders will be added as well.
1807 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
) {
1808 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1809 IWineD3DPaletteImpl
* pal
= This
->palette
;
1814 /* Still no palette? Use the device's palette */
1815 /* Get the surface's palette */
1816 for (i
= 0; i
< 256; i
++) {
1817 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1819 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
1820 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
1821 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
1822 if ((convert
== CONVERT_PALETTED_CK
) &&
1823 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1824 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1825 /* We should maybe here put a more 'neutral' color than the standard bright purple
1826 one often used by application to prevent the nice purple borders when bi-linear
1834 TRACE("Using surface palette %p\n", pal
);
1835 /* Get the surface's palette */
1836 for (i
= 0; i
< 256; i
++) {
1837 table
[i
][0] = pal
->palents
[i
].peRed
;
1838 table
[i
][1] = pal
->palents
[i
].peGreen
;
1839 table
[i
][2] = pal
->palents
[i
].peBlue
;
1840 if ((convert
== CONVERT_PALETTED_CK
) &&
1841 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1842 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1843 /* We should maybe here put a more 'neutral' color than the standard bright purple
1844 one often used by application to prevent the nice purple borders when bi-linear
1847 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
1848 table
[i
][3] = pal
->palents
[i
].peFlags
;
1854 GL_EXTCALL(glColorTableEXT(GL_TEXTURE_2D
,GL_RGBA
,256,GL_RGBA
,GL_UNSIGNED_BYTE
, table
));
1857 static BOOL
palette9_changed(IWineD3DSurfaceImpl
*This
) {
1858 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1860 if(This
->palette
|| (This
->resource
.format
!= WINED3DFMT_P8
&& This
->resource
.format
!= WINED3DFMT_A8P8
)) {
1861 /* If a ddraw-style palette is attached assume no d3d9 palette change.
1862 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
1867 if(This
->palette9
) {
1868 if(memcmp(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256) == 0) {
1872 This
->palette9
= (PALETTEENTRY
*) HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY
) * 256);
1874 memcpy(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256);
1878 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
) {
1879 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1880 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1881 GLenum format
, internal
, type
;
1882 CONVERT_TYPES convert
;
1884 int width
, pitch
, outpitch
;
1887 if (!(This
->Flags
& SFLAG_INTEXTURE
)) {
1888 TRACE("Reloading because surface is dirty\n");
1889 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
1890 ((This
->Flags
& SFLAG_GLCKEY
) && (!(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
))) ||
1891 /* Reload: vice versa OR */
1892 ((!(This
->Flags
& SFLAG_GLCKEY
)) && (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
)) ||
1893 /* Also reload: Color key is active AND the color key has changed */
1894 ((This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) && (
1895 (This
->glCKey
.dwColorSpaceLowValue
!= This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1896 (This
->glCKey
.dwColorSpaceHighValue
!= This
->SrcBltCKey
.dwColorSpaceHighValue
)))) {
1897 TRACE("Reloading because of color keying\n");
1898 } else if(palette9_changed(This
)) {
1899 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
1901 TRACE("surface is already in texture\n");
1905 This
->Flags
|= SFLAG_INTEXTURE
;
1907 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
1908 * These resources are not bound by device size or format restrictions. Because of this,
1909 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
1910 * However, these resources can always be created, locked, and copied.
1912 if (This
->resource
.pool
== WINED3DPOOL_SCRATCH
)
1914 FIXME("(%p) Operation not supported for scratch textures\n",This
);
1915 return WINED3DERR_INVALIDCALL
;
1918 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, srgb_mode
);
1920 if (This
->Flags
& SFLAG_INDRAWABLE
) {
1921 if (This
->glDescription
.level
!= 0)
1922 FIXME("Surface in texture is only supported for level 0\n");
1923 else if (This
->resource
.format
== WINED3DFMT_P8
|| This
->resource
.format
== WINED3DFMT_A8P8
||
1924 This
->resource
.format
== WINED3DFMT_DXT1
|| This
->resource
.format
== WINED3DFMT_DXT2
||
1925 This
->resource
.format
== WINED3DFMT_DXT3
|| This
->resource
.format
== WINED3DFMT_DXT4
||
1926 This
->resource
.format
== WINED3DFMT_DXT5
)
1927 FIXME("Format %d not supported\n", This
->resource
.format
);
1932 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
1933 vcheckGLcall("glGetIntegerv");
1934 glReadBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
1935 vcheckGLcall("glReadBuffer");
1937 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
1938 surface_allocate_surface(This
, internal
, This
->pow2Width
,
1939 This
->pow2Height
, format
, type
);
1942 glCopyTexSubImage2D(This
->glDescription
.target
,
1943 This
->glDescription
.level
,
1945 This
->currentDesc
.Width
,
1946 This
->currentDesc
.Height
);
1947 checkGLcall("glCopyTexSubImage2D");
1949 glReadBuffer(prevRead
);
1950 vcheckGLcall("glReadBuffer");
1954 TRACE("Updated target %d\n", This
->glDescription
.target
);
1958 /* The only place where LoadTexture() might get called when isInDraw=1
1959 * is ActivateContext where lastActiveRenderTarget is preloaded.
1961 if(iface
== device
->lastActiveRenderTarget
&& device
->isInDraw
)
1962 ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
1964 /* Otherwise: System memory copy must be most up to date */
1966 if(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) {
1967 This
->Flags
|= SFLAG_GLCKEY
;
1968 This
->glCKey
= This
->SrcBltCKey
;
1970 else This
->Flags
&= ~SFLAG_GLCKEY
;
1972 /* The width is in 'length' not in bytes */
1973 width
= This
->currentDesc
.Width
;
1974 pitch
= IWineD3DSurface_GetPitch(iface
);
1976 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
1977 int height
= This
->currentDesc
.Height
;
1979 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
1980 outpitch
= width
* bpp
;
1981 outpitch
= (outpitch
+ SURFACE_ALIGNMENT
- 1) & ~(SURFACE_ALIGNMENT
- 1);
1983 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
1985 ERR("Out of memory %d, %d!\n", outpitch
, height
);
1986 return WINED3DERR_OUTOFVIDEOMEMORY
;
1988 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
1990 This
->Flags
|= SFLAG_CONVERTED
;
1991 } else if (This
->resource
.format
== WINED3DFMT_P8
&& GL_SUPPORT(EXT_PALETTED_TEXTURE
)) {
1992 d3dfmt_p8_upload_palette(iface
, convert
);
1993 This
->Flags
&= ~SFLAG_CONVERTED
;
1994 mem
= This
->resource
.allocatedMemory
;
1996 This
->Flags
&= ~SFLAG_CONVERTED
;
1997 mem
= This
->resource
.allocatedMemory
;
2000 /* Make sure the correct pitch is used */
2001 glPixelStorei(GL_UNPACK_ROW_LENGTH
, width
);
2003 if ((This
->Flags
& SFLAG_NONPOW2
) && !(This
->Flags
& SFLAG_OVERSIZE
)) {
2004 TRACE("non power of two support\n");
2005 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
2006 surface_allocate_surface(This
, internal
, This
->pow2Width
, This
->pow2Height
, format
, type
);
2009 surface_upload_data(This
, internal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
, format
, type
, mem
);
2012 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
2013 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
2015 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
2016 surface_allocate_surface(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
);
2019 surface_upload_data(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
, mem
);
2023 /* Restore the default pitch */
2024 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
2026 if (mem
!= This
->resource
.allocatedMemory
)
2027 HeapFree(GetProcessHeap(), 0, mem
);
2031 static unsigned int gen
= 0;
2034 if ((gen
% 10) == 0) {
2035 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
2036 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
2039 * debugging crash code
2048 if (!(This
->Flags
& SFLAG_DONOTFREE
)) {
2049 HeapFree(GetProcessHeap(), 0, This
->resource
.allocatedMemory
);
2050 This
->resource
.allocatedMemory
= NULL
;
2051 This
->Flags
&= ~SFLAG_INSYSMEM
;
2059 HRESULT WINAPI
IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
, const char* filename
) {
2062 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2063 char *allocatedMemory
;
2065 IWineD3DSwapChain
*swapChain
= NULL
;
2067 GLuint tmpTexture
= 0;
2070 Textures may not be stored in ->allocatedgMemory and a GlTexture
2071 so we should lock the surface before saving a snapshot, or at least check that
2073 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2074 by calling GetTexImage and in compressed form by calling
2075 GetCompressedTexImageARB. Queried compressed images can be saved and
2076 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2077 texture images do not need to be processed by the GL and should
2078 significantly improve texture loading performance relative to uncompressed
2081 /* Setup the width and height to be the internal texture width and height. */
2082 width
= This
->pow2Width
;
2083 height
= This
->pow2Height
;
2084 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2085 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapChain
);
2087 if (This
->Flags
& SFLAG_INDRAWABLE
&& !(This
->Flags
& SFLAG_INTEXTURE
)) {
2088 /* if were not a real texture then read the back buffer into a real texture */
2089 /* we don't want to interfere with the back buffer so read the data into a temporary
2090 * texture and then save the data out of the temporary texture
2094 TRACE("(%p) Reading render target into texture\n", This
);
2095 glEnable(GL_TEXTURE_2D
);
2097 glGenTextures(1, &tmpTexture
);
2098 glBindTexture(GL_TEXTURE_2D
, tmpTexture
);
2100 glTexImage2D(GL_TEXTURE_2D
,
2107 GL_UNSIGNED_INT_8_8_8_8_REV
,
2110 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
2111 vcheckGLcall("glGetIntegerv");
2112 glReadBuffer(swapChain
? GL_BACK
: This
->resource
.wineD3DDevice
->offscreenBuffer
);
2113 vcheckGLcall("glReadBuffer");
2114 glCopyTexImage2D(GL_TEXTURE_2D
,
2123 checkGLcall("glCopyTexImage2D");
2124 glReadBuffer(prevRead
);
2127 } else { /* bind the real texture, and make sure it up to date */
2128 IWineD3DSurface_PreLoad(iface
);
2130 allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, width
* height
* 4);
2132 FIXME("Saving texture level %d width %d height %d\n", This
->glDescription
.level
, width
, height
);
2133 glGetTexImage(GL_TEXTURE_2D
,
2134 This
->glDescription
.level
,
2136 GL_UNSIGNED_INT_8_8_8_8_REV
,
2138 checkGLcall("glTexImage2D");
2140 glBindTexture(GL_TEXTURE_2D
, 0);
2141 glDeleteTextures(1, &tmpTexture
);
2145 f
= fopen(filename
, "w+");
2147 ERR("opening of %s failed with: %s\n", filename
, strerror(errno
));
2148 return WINED3DERR_INVALIDCALL
;
2150 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2151 TRACE("(%p) opened %s with format %s\n", This
, filename
, debug_d3dformat(This
->resource
.format
));
2166 fwrite(&width
,2,1,f
);
2168 fwrite(&height
,2,1,f
);
2173 /* if the data is upside down if we've fetched it from a back buffer, so it needs flipping again to make it the correct way up */
2175 textureRow
= allocatedMemory
+ (width
* (height
- 1) *4);
2177 textureRow
= allocatedMemory
;
2178 for (y
= 0 ; y
< height
; y
++) {
2179 for (i
= 0; i
< width
; i
++) {
2180 color
= *((DWORD
*)textureRow
);
2181 fputc((color
>> 16) & 0xFF, f
); /* B */
2182 fputc((color
>> 8) & 0xFF, f
); /* G */
2183 fputc((color
>> 0) & 0xFF, f
); /* R */
2184 fputc((color
>> 24) & 0xFF, f
); /* A */
2187 /* take two rows of the pointer to the texture memory */
2189 (textureRow
-= width
<< 3);
2192 TRACE("Closing file\n");
2196 IWineD3DSwapChain_Release(swapChain
);
2198 HeapFree(GetProcessHeap(), 0, allocatedMemory
);
2203 * Slightly inefficient way to handle multiple dirty rects but it works :)
2205 extern HRESULT WINAPI
IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
2206 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2207 IWineD3DBaseTexture
*baseTexture
= NULL
;
2208 if (!(This
->Flags
& SFLAG_INSYSMEM
) && (This
->Flags
& SFLAG_INTEXTURE
))
2209 surface_download_data(This
);
2211 This
->Flags
&= ~(SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
2212 if (NULL
!= pDirtyRect
) {
2213 This
->dirtyRect
.left
= min(This
->dirtyRect
.left
, pDirtyRect
->left
);
2214 This
->dirtyRect
.top
= min(This
->dirtyRect
.top
, pDirtyRect
->top
);
2215 This
->dirtyRect
.right
= max(This
->dirtyRect
.right
, pDirtyRect
->right
);
2216 This
->dirtyRect
.bottom
= max(This
->dirtyRect
.bottom
, pDirtyRect
->bottom
);
2218 This
->dirtyRect
.left
= 0;
2219 This
->dirtyRect
.top
= 0;
2220 This
->dirtyRect
.right
= This
->currentDesc
.Width
;
2221 This
->dirtyRect
.bottom
= This
->currentDesc
.Height
;
2223 TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This
, This
->dirtyRect
.left
,
2224 This
->dirtyRect
.top
, This
->dirtyRect
.right
, This
->dirtyRect
.bottom
);
2225 /* if the container is a basetexture then mark it dirty. */
2226 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2227 TRACE("Passing to container\n");
2228 IWineD3DBaseTexture_SetDirty(baseTexture
, TRUE
);
2229 IWineD3DBaseTexture_Release(baseTexture
);
2234 HRESULT WINAPI
IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface
*iface
, IWineD3DBase
*container
) {
2235 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2237 TRACE("This %p, container %p\n", This
, container
);
2239 /* We can't keep a reference to the container, since the container already keeps a reference to us. */
2241 TRACE("Setting container to %p from %p\n", container
, This
->container
);
2242 This
->container
= container
;
2247 HRESULT WINAPI
IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
2248 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2249 const PixelFormatDesc
*formatEntry
= getFormatDescEntry(format
);
2251 if (This
->resource
.format
!= WINED3DFMT_UNKNOWN
) {
2252 FIXME("(%p) : The format of the surface must be WINED3DFORMAT_UNKNOWN\n", This
);
2253 return WINED3DERR_INVALIDCALL
;
2256 TRACE("(%p) : Setting texture format to (%d,%s)\n", This
, format
, debug_d3dformat(format
));
2257 if (format
== WINED3DFMT_UNKNOWN
) {
2258 This
->resource
.size
= 0;
2259 } else if (format
== WINED3DFMT_DXT1
) {
2260 /* DXT1 is half byte per pixel */
2261 This
->resource
.size
= ((max(This
->pow2Width
, 4) * formatEntry
->bpp
) * max(This
->pow2Height
, 4)) >> 1;
2263 } else if (format
== WINED3DFMT_DXT2
|| format
== WINED3DFMT_DXT3
||
2264 format
== WINED3DFMT_DXT4
|| format
== WINED3DFMT_DXT5
) {
2265 This
->resource
.size
= ((max(This
->pow2Width
, 4) * formatEntry
->bpp
) * max(This
->pow2Height
, 4));
2267 This
->resource
.size
= ((This
->pow2Width
* formatEntry
->bpp
) + SURFACE_ALIGNMENT
- 1) & ~(SURFACE_ALIGNMENT
- 1);
2268 This
->resource
.size
*= This
->pow2Height
;
2272 /* Setup some glformat defaults */
2273 This
->glDescription
.glFormat
= formatEntry
->glFormat
;
2274 This
->glDescription
.glFormatInternal
= formatEntry
->glInternal
;
2275 This
->glDescription
.glType
= formatEntry
->glType
;
2277 if (format
!= WINED3DFMT_UNKNOWN
) {
2278 This
->bytesPerPixel
= formatEntry
->bpp
;
2280 This
->bytesPerPixel
= 0;
2283 This
->Flags
|= (WINED3DFMT_D16_LOCKABLE
== format
) ? SFLAG_LOCKABLE
: 0;
2284 This
->Flags
&= ~SFLAG_ALLOCATED
;
2286 This
->resource
.format
= format
;
2288 TRACE("(%p) : Size %d, bytesPerPixel %d, glFormat %d, glFotmatInternal %d, glType %d\n", This
, This
->resource
.size
, This
->bytesPerPixel
, This
->glDescription
.glFormat
, This
->glDescription
.glFormatInternal
, This
->glDescription
.glType
);
2293 HRESULT WINAPI
IWineD3DSurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
2294 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
2296 /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
2297 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
2298 ERR("Not supported on render targets\n");
2299 return WINED3DERR_INVALIDCALL
;
2302 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
2303 WARN("Surface is locked or the HDC is in use\n");
2304 return WINED3DERR_INVALIDCALL
;
2307 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
2308 void *release
= NULL
;
2310 /* Do I have to copy the old surface content? */
2311 if(This
->Flags
& SFLAG_DIBSECTION
) {
2312 /* Release the DC. No need to hold the critical section for the update
2313 * Thread because this thread runs only on front buffers, but this method
2314 * fails for render targets in the check above.
2316 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
2317 DeleteDC(This
->hDC
);
2318 /* Release the DIB section */
2319 DeleteObject(This
->dib
.DIBsection
);
2320 This
->dib
.bitmap_data
= NULL
;
2321 This
->resource
.allocatedMemory
= NULL
;
2323 This
->Flags
&= ~SFLAG_DIBSECTION
;
2324 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
2325 release
= This
->resource
.allocatedMemory
;
2327 This
->resource
.allocatedMemory
= Mem
;
2328 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
2330 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2331 This
->Flags
&= ~(SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
);
2333 /* For client textures opengl has to be notified */
2334 if(This
->Flags
& SFLAG_CLIENT
) {
2335 This
->Flags
&= ~SFLAG_ALLOCATED
;
2336 IWineD3DSurface_PreLoad(iface
);
2337 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2340 /* Now free the old memory if any */
2341 HeapFree(GetProcessHeap(), 0, release
);
2342 } else if(This
->Flags
& SFLAG_USERPTR
) {
2343 /* Lockrect and GetDC will re-create the dib section and allocated memory */
2344 This
->resource
.allocatedMemory
= NULL
;
2345 This
->Flags
&= ~SFLAG_USERPTR
;
2347 if(This
->Flags
& SFLAG_CLIENT
) {
2348 This
->Flags
&= ~SFLAG_ALLOCATED
;
2349 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2350 IWineD3DSurface_PreLoad(iface
);
2356 static HRESULT WINAPI
IWineD3DSurfaceImpl_Flip(IWineD3DSurface
*iface
, IWineD3DSurface
*override
, DWORD Flags
) {
2357 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2358 IWineD3DDevice
*D3D
= (IWineD3DDevice
*) This
->resource
.wineD3DDevice
;
2359 TRACE("(%p)->(%p,%x)\n", This
, override
, Flags
);
2361 /* Flipping is only supported on RenderTargets */
2362 if( !(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ) return WINEDDERR_NOTFLIPPABLE
;
2365 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2366 * FIXME("(%p) Target override is not supported by now\n", This);
2367 * Additionally, it isn't really possible to support triple-buffering
2368 * properly on opengl at all
2372 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2373 return IWineD3DDevice_Present(D3D
, NULL
, NULL
, 0, NULL
);
2376 /* Does a direct frame buffer -> texture copy. Stretching is done
2377 * with single pixel copy calls
2379 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2380 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2383 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2387 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2389 /* Bind the target texture */
2390 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
2391 checkGLcall("glBindTexture");
2393 glReadBuffer(myDevice
->offscreenBuffer
);
2395 GLenum buffer
= surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
);
2396 glReadBuffer(buffer
);
2398 checkGLcall("glReadBuffer");
2400 xrel
= (float) (srect
->x2
- srect
->x1
) / (float) (drect
->x2
- drect
->x1
);
2401 yrel
= (float) (srect
->y2
- srect
->y1
) / (float) (drect
->y2
- drect
->y1
);
2403 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2404 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2406 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
2407 ERR("Texture filtering not supported in direct blit\n");
2409 } else if((Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) && ((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2410 ERR("Texture filtering not supported in direct blit\n");
2414 !((xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) &&
2415 !((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2416 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2418 glCopyTexSubImage2D(This
->glDescription
.target
,
2419 This
->glDescription
.level
,
2420 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2421 srect
->x1
, Src
->currentDesc
.Height
- srect
->y2
,
2422 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2424 UINT yoffset
= Src
->currentDesc
.Height
- srect
->y1
+ drect
->y1
- 1;
2425 /* I have to process this row by row to swap the image,
2426 * otherwise it would be upside down, so stretching in y direction
2427 * doesn't cost extra time
2429 * However, stretching in x direction can be avoided if not necessary
2431 for(row
= drect
->y1
; row
< drect
->y2
; row
++) {
2432 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2433 /* Well, that stuff works, but it's very slow.
2434 * find a better way instead
2438 for(col
= drect
->x1
; col
< drect
->x2
; col
++) {
2439 glCopyTexSubImage2D(This
->glDescription
.target
,
2440 This
->glDescription
.level
,
2441 drect
->x1
+ col
, row
, /* xoffset, yoffset */
2442 srect
->x1
+ col
* xrel
, yoffset
- (int) (row
* yrel
),
2446 glCopyTexSubImage2D(This
->glDescription
.target
,
2447 This
->glDescription
.level
,
2448 drect
->x1
, row
, /* xoffset, yoffset */
2449 srect
->x1
, yoffset
- (int) (row
* yrel
),
2450 drect
->x2
-drect
->x1
, 1);
2455 vcheckGLcall("glCopyTexSubImage2D");
2459 /* Uses the hardware to stretch and flip the image */
2460 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2461 GLuint src
, backup
= 0;
2462 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2463 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2464 float left
, right
, top
, bottom
; /* Texture coordinates */
2465 UINT fbwidth
= Src
->currentDesc
.Width
;
2466 UINT fbheight
= Src
->currentDesc
.Height
;
2467 GLenum drawBuffer
= GL_BACK
;
2469 TRACE("Using hwstretch blit\n");
2470 /* Activate the Proper context for reading from the source surface, set it up for blitting */
2472 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2474 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2475 * This way we don't have to wait for the 2nd readback to finish to leave this function.
2477 if(GL_LIMITS(aux_buffers
) >= 2) {
2478 /* Got more than one aux buffer? Use the 2nd aux buffer */
2479 drawBuffer
= GL_AUX1
;
2480 } else if((swapchain
|| myDevice
->offscreenBuffer
== GL_BACK
) && GL_LIMITS(aux_buffers
) >= 1) {
2481 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2482 drawBuffer
= GL_AUX0
;
2485 if(!swapchain
&& wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
2486 glGenTextures(1, &backup
);
2487 checkGLcall("glGenTextures\n");
2488 glBindTexture(GL_TEXTURE_2D
, backup
);
2489 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2491 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2492 * we are reading from the back buffer, the backup can be used as source texture
2494 if(Src
->glDescription
.textureName
== 0) {
2495 /* Get it a description */
2496 IWineD3DSurface_PreLoad(SrcSurface
);
2498 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
2499 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2501 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2502 Src
->Flags
&= ~SFLAG_INTEXTURE
;
2505 glReadBuffer(GL_BACK
);
2506 checkGLcall("glReadBuffer(GL_BACK)");
2508 /* TODO: Only back up the part that will be overwritten */
2509 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2510 0, 0 /* read offsets */,
2515 checkGLcall("glCopyTexSubImage2D");
2517 /* No issue with overriding these - the sampler is dirty due to blit usage */
2518 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
2519 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
2520 checkGLcall("glTexParameteri");
2521 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
2522 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2523 checkGLcall("glTexParameteri");
2525 if(!swapchain
|| (IWineD3DSurface
*) Src
== swapchain
->backBuffer
[0]) {
2526 src
= backup
? backup
: Src
->glDescription
.textureName
;
2528 glReadBuffer(GL_FRONT
);
2529 checkGLcall("glReadBuffer(GL_FRONT)");
2531 glGenTextures(1, &src
);
2532 checkGLcall("glGenTextures(1, &src)");
2533 glBindTexture(GL_TEXTURE_2D
, src
);
2534 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2536 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2537 * out for power of 2 sizes
2539 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, Src
->pow2Width
, Src
->pow2Height
, 0,
2540 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
2541 checkGLcall("glTexImage2D");
2542 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2543 0, 0 /* read offsets */,
2548 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2549 checkGLcall("glTexParameteri");
2550 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2551 checkGLcall("glTexParameteri");
2553 glReadBuffer(GL_BACK
);
2554 checkGLcall("glReadBuffer(GL_BACK)");
2556 checkGLcall("glEnd and previous");
2558 left
= (float) srect
->x1
/ (float) Src
->pow2Width
;
2559 right
= (float) srect
->x2
/ (float) Src
->pow2Width
;
2562 top
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2563 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2565 top
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2566 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2569 /* draw the source texture stretched and upside down. The correct surface is bound already */
2570 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
2571 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
2573 glDrawBuffer(drawBuffer
);
2574 glReadBuffer(drawBuffer
);
2578 glTexCoord2f(left
, bottom
);
2579 glVertex2i(0, fbheight
);
2582 glTexCoord2f(left
, top
);
2583 glVertex2i(0, fbheight
- drect
->y2
- drect
->y1
);
2586 glTexCoord2f(right
, top
);
2587 glVertex2i(drect
->x2
- drect
->x1
, fbheight
- drect
->y2
- drect
->y1
);
2590 glTexCoord2f(right
, bottom
);
2591 glVertex2i(drect
->x2
- drect
->x1
, fbheight
);
2593 checkGLcall("glEnd and previous");
2595 /* Now read the stretched and upside down image into the destination texture */
2596 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2597 checkGLcall("glBindTexture");
2598 glCopyTexSubImage2D(This
->glDescription
.target
,
2600 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2601 0, 0, /* We blitted the image to the origin */
2602 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2603 checkGLcall("glCopyTexSubImage2D");
2605 /* Write the back buffer backup back */
2606 glBindTexture(GL_TEXTURE_2D
, backup
? backup
: Src
->glDescription
.textureName
);
2607 checkGLcall("glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName)");
2609 if(drawBuffer
== GL_BACK
) {
2612 glTexCoord2f(0.0, (float) fbheight
/ (float) Src
->pow2Height
);
2616 glTexCoord2f(0.0, 0.0);
2617 glVertex2i(0, fbheight
);
2620 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, 0.0);
2621 glVertex2i(fbwidth
, Src
->currentDesc
.Height
);
2624 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, (float) fbheight
/ (float) Src
->pow2Height
);
2625 glVertex2i(fbwidth
, 0);
2628 /* Restore the old draw buffer */
2629 glDrawBuffer(GL_BACK
);
2633 if(src
!= Src
->glDescription
.textureName
&& src
!= backup
) {
2634 glDeleteTextures(1, &src
);
2635 checkGLcall("glDeleteTextures(1, &src)");
2638 glDeleteTextures(1, &backup
);
2639 checkGLcall("glDeleteTextures(1, &backup)");
2644 /* Not called from the VTable */
2645 static HRESULT
IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
2647 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2648 IWineD3DSwapChainImpl
*srcSwapchain
= NULL
, *dstSwapchain
= NULL
;
2649 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2651 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
2653 /* Get the swapchain. One of the surfaces has to be a primary surface */
2654 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&dstSwapchain
);
2655 if(dstSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) dstSwapchain
);
2657 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) Src
, &IID_IWineD3DSwapChain
, (void **)&srcSwapchain
);
2658 if(srcSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) srcSwapchain
);
2661 /* Early sort out of cases where no render target is used */
2662 if(!dstSwapchain
&& !srcSwapchain
&&
2663 SrcSurface
!= myDevice
->render_targets
[0] && This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
2664 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src
, This
);
2665 return WINED3DERR_INVALIDCALL
;
2668 /* No destination color keying supported */
2669 if(Flags
& (WINEDDBLT_KEYDEST
| WINEDDBLT_KEYDESTOVERRIDE
)) {
2670 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
2671 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
2672 return WINED3DERR_INVALIDCALL
;
2676 rect
.x1
= DestRect
->left
;
2677 rect
.y1
= DestRect
->top
;
2678 rect
.x2
= DestRect
->right
;
2679 rect
.y2
= DestRect
->bottom
;
2683 rect
.x2
= This
->currentDesc
.Width
;
2684 rect
.y2
= This
->currentDesc
.Height
;
2687 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
2688 if(dstSwapchain
&& dstSwapchain
== srcSwapchain
&& dstSwapchain
->backBuffer
&&
2689 ((IWineD3DSurface
*) This
== dstSwapchain
->frontBuffer
) && SrcSurface
== dstSwapchain
->backBuffer
[0]) {
2690 /* Half-life does a Blt from the back buffer to the front buffer,
2691 * Full surface size, no flags... Use present instead
2693 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
2696 /* Check rects - IWineD3DDevice_Present doesn't handle them */
2700 TRACE("Looking if a Present can be done...\n");
2701 /* Source Rectangle must be full surface */
2703 if(SrcRect
->left
!= 0 || SrcRect
->top
!= 0 ||
2704 SrcRect
->right
!= Src
->currentDesc
.Width
|| SrcRect
->bottom
!= Src
->currentDesc
.Height
) {
2705 TRACE("No, Source rectangle doesn't match\n");
2711 mySrcRect
.right
= Src
->currentDesc
.Width
;
2712 mySrcRect
.bottom
= Src
->currentDesc
.Height
;
2714 /* No stretching may occur */
2715 if(mySrcRect
.right
!= rect
.x2
- rect
.x1
||
2716 mySrcRect
.bottom
!= rect
.y2
- rect
.y1
) {
2717 TRACE("No, stretching is done\n");
2721 /* Destination must be full surface or match the clipping rectangle */
2722 if(This
->clipper
&& ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
)
2726 GetClientRect(((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
, &cliprect
);
2731 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
,
2734 if(pos
[0].x
!= cliprect
.left
|| pos
[0].y
!= cliprect
.top
||
2735 pos
[1].x
!= cliprect
.right
|| pos
[1].y
!= cliprect
.bottom
)
2737 TRACE("No, dest rectangle doesn't match(clipper)\n");
2738 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect
.left
, cliprect
.top
, cliprect
.right
, cliprect
.bottom
);
2739 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect
.x1
, rect
.y1
, rect
.x2
, rect
.y2
);
2745 if(rect
.x1
!= 0 || rect
.y1
!= 0 ||
2746 rect
.x2
!= This
->currentDesc
.Width
|| rect
.y2
!= This
->currentDesc
.Height
) {
2747 TRACE("No, dest rectangle doesn't match(surface size)\n");
2754 /* These flags are unimportant for the flag check, remove them */
2755 if((Flags
& ~(WINEDDBLT_DONOTWAIT
| WINEDDBLT_WAIT
)) == 0) {
2756 WINED3DSWAPEFFECT orig_swap
= dstSwapchain
->presentParms
.SwapEffect
;
2758 /* The idea behind this is that a glReadPixels and a glDrawPixels call
2759 * take very long, while a flip is fast.
2760 * This applies to Half-Life, which does such Blts every time it finished
2761 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
2762 * menu. This is also used by all apps when they do windowed rendering
2764 * The problem is that flipping is not really the same as copying. After a
2765 * Blt the front buffer is a copy of the back buffer, and the back buffer is
2766 * untouched. Therefore it's necessary to override the swap effect
2767 * and to set it back after the flip.
2769 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
2773 dstSwapchain
->presentParms
.SwapEffect
= WINED3DSWAPEFFECT_COPY
;
2775 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
2776 IWineD3DDevice_Present((IWineD3DDevice
*) This
->resource
.wineD3DDevice
,
2777 NULL
, NULL
, 0, NULL
);
2779 dstSwapchain
->presentParms
.SwapEffect
= orig_swap
;
2786 TRACE("Unsupported blit between buffers on the same swapchain\n");
2787 return WINED3DERR_INVALIDCALL
;
2788 } else if((dstSwapchain
|| This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) &&
2789 (srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) ) {
2790 ERR("Can't perform hardware blit between 2 different swapchains, falling back to software\n");
2791 return WINED3DERR_INVALIDCALL
;
2794 if(srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) {
2795 /* Blit from render target to texture */
2797 BOOL upsideDown
, stretchx
;
2799 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
2800 TRACE("Color keying not supported by frame buffer to texture blit\n");
2801 return WINED3DERR_INVALIDCALL
;
2802 /* Destination color key is checked above */
2805 /* Call preload for the surface to make sure it isn't dirty */
2806 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
2807 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
2808 checkGLcall("glActiveTextureARB");
2810 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(0));
2811 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2813 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2814 * glCopyTexSubImage is a bit picky about the parameters we pass to it
2817 if(SrcRect
->top
< SrcRect
->bottom
) {
2818 srect
.y1
= SrcRect
->top
;
2819 srect
.y2
= SrcRect
->bottom
;
2822 srect
.y1
= SrcRect
->bottom
;
2823 srect
.y2
= SrcRect
->top
;
2826 srect
.x1
= SrcRect
->left
;
2827 srect
.x2
= SrcRect
->right
;
2831 srect
.x2
= Src
->currentDesc
.Width
;
2832 srect
.y2
= Src
->currentDesc
.Height
;
2835 if(rect
.x1
> rect
.x2
) {
2839 upsideDown
= !upsideDown
;
2842 TRACE("Reading from an offscreen target\n");
2843 upsideDown
= !upsideDown
;
2846 if(rect
.x2
- rect
.x1
!= srect
.x2
- srect
.x1
) {
2852 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
2853 * flip the image nor scale it.
2855 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
2856 * -> If the app wants a image width an unscaled width, copy it line per line
2857 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
2858 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
2859 * back buffer. This is slower than reading line per line, thus not used for flipping
2860 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
2863 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
2864 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
2867 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
)) {
2868 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, &srect
,
2869 (IWineD3DSurface
*)This
, &rect
, Filter
, upsideDown
);
2870 } else if((!stretchx
) || rect
.x2
- rect
.x1
> Src
->currentDesc
.Width
||
2871 rect
.y2
- rect
.y1
> Src
->currentDesc
.Height
) {
2872 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
2873 fb_copy_to_texture_direct(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
2875 TRACE("Using hardware stretching to flip / stretch the texture\n");
2876 fb_copy_to_texture_hwstretch(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
2879 if(!(This
->Flags
& SFLAG_DONOTFREE
)) {
2880 HeapFree(GetProcessHeap(), 0, This
->resource
.allocatedMemory
);
2881 This
->resource
.allocatedMemory
= NULL
;
2883 This
->Flags
&= ~SFLAG_INSYSMEM
;
2885 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
2886 * path is never entered
2888 This
->Flags
|= SFLAG_INTEXTURE
;
2892 /* Blit from offscreen surface to render target */
2893 float glTexCoord
[4];
2894 DWORD oldCKeyFlags
= Src
->CKeyFlags
;
2895 WINEDDCOLORKEY oldBltCKey
= This
->SrcBltCKey
;
2896 RECT SourceRectangle
;
2898 TRACE("Blt from surface %p to rendertarget %p\n", Src
, This
);
2901 SourceRectangle
.left
= SrcRect
->left
;
2902 SourceRectangle
.right
= SrcRect
->right
;
2903 SourceRectangle
.top
= SrcRect
->top
;
2904 SourceRectangle
.bottom
= SrcRect
->bottom
;
2906 SourceRectangle
.left
= 0;
2907 SourceRectangle
.right
= Src
->currentDesc
.Width
;
2908 SourceRectangle
.top
= 0;
2909 SourceRectangle
.bottom
= Src
->currentDesc
.Height
;
2912 if(!CalculateTexRect(Src
, &SourceRectangle
, glTexCoord
)) {
2913 /* Fall back to software */
2914 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src
,
2915 SourceRectangle
.left
, SourceRectangle
.top
,
2916 SourceRectangle
.right
, SourceRectangle
.bottom
);
2917 return WINED3DERR_INVALIDCALL
;
2920 /* Color keying: Check if we have to do a color keyed blt,
2921 * and if not check if a color key is activated.
2923 * Just modify the color keying parameters in the surface and restore them afterwards
2924 * The surface keeps track of the color key last used to load the opengl surface.
2925 * PreLoad will catch the change to the flags and color key and reload if necessary.
2927 if(Flags
& WINEDDBLT_KEYSRC
) {
2928 /* Use color key from surface */
2929 } else if(Flags
& WINEDDBLT_KEYSRCOVERRIDE
) {
2930 /* Use color key from DDBltFx */
2931 Src
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
2932 This
->SrcBltCKey
= DDBltFx
->ddckSrcColorkey
;
2934 /* Do not use color key */
2935 Src
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
2938 /* Now load the surface */
2939 IWineD3DSurface_PreLoad((IWineD3DSurface
*) Src
);
2943 /* Activate the destination context, set it up for blitting */
2944 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
2947 TRACE("Drawing to offscreen buffer\n");
2948 glDrawBuffer(myDevice
->offscreenBuffer
);
2949 checkGLcall("glDrawBuffer");
2951 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*)This
, (IWineD3DSwapChain
*)dstSwapchain
);
2952 TRACE("Drawing to %#x buffer\n", buffer
);
2953 glDrawBuffer(buffer
);
2954 checkGLcall("glDrawBuffer");
2957 /* Bind the texture */
2958 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
2959 checkGLcall("glBindTexture");
2961 /* Filtering for StretchRect */
2962 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
2963 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
2964 checkGLcall("glTexParameteri");
2965 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
2966 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2967 checkGLcall("glTexParameteri");
2968 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
2969 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
2970 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
2971 checkGLcall("glTexEnvi");
2973 /* This is for color keying */
2974 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
2975 glEnable(GL_ALPHA_TEST
);
2976 checkGLcall("glEnable GL_ALPHA_TEST");
2977 glAlphaFunc(GL_NOTEQUAL
, 0.0);
2978 checkGLcall("glAlphaFunc\n");
2980 glDisable(GL_ALPHA_TEST
);
2981 checkGLcall("glDisable GL_ALPHA_TEST");
2984 /* Draw a textured quad
2988 glColor3d(1.0f
, 1.0f
, 1.0f
);
2989 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
2994 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
2995 glVertex3f(rect
.x1
, rect
.y2
, 0.0);
2997 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
3002 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
3007 checkGLcall("glEnd");
3009 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3010 glDisable(GL_ALPHA_TEST
);
3011 checkGLcall("glDisable(GL_ALPHA_TEST)");
3014 /* Unbind the texture */
3015 glBindTexture(GL_TEXTURE_2D
, 0);
3016 checkGLcall("glEnable glBindTexture");
3018 /* The draw buffer should only need to be restored if we were drawing to the front buffer, and there is a back buffer.
3019 * otherwise the context manager should choose between GL_BACK / offscreenDrawBuffer
3021 if(dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
&& dstSwapchain
->backBuffer
) {
3022 glDrawBuffer(GL_BACK
);
3023 checkGLcall("glDrawBuffer");
3025 /* Restore the color key parameters */
3026 Src
->CKeyFlags
= oldCKeyFlags
;
3027 This
->SrcBltCKey
= oldBltCKey
;
3031 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3032 This
->Flags
&= ~SFLAG_INSYSMEM
;
3033 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3036 if(dstSwapchain
|| wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) {
3037 This
->Flags
|= SFLAG_INDRAWABLE
;
3038 This
->Flags
&= ~SFLAG_INTEXTURE
;
3040 This
->Flags
|= SFLAG_INTEXTURE
;
3045 /* Source-Less Blit to render target */
3046 if (Flags
& WINEDDBLT_COLORFILL
) {
3047 /* This is easy to handle for the D3D Device... */
3050 TRACE("Colorfill\n");
3052 /* The color as given in the Blt function is in the format of the frame-buffer...
3053 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3055 if (This
->resource
.format
== WINED3DFMT_P8
) {
3056 if (This
->palette
) {
3057 color
= ((0xFF000000) |
3058 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peRed
<< 16) |
3059 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peGreen
<< 8) |
3060 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peBlue
));
3065 else if (This
->resource
.format
== WINED3DFMT_R5G6B5
) {
3066 if (DDBltFx
->u5
.dwFillColor
== 0xFFFF) {
3069 color
= ((0xFF000000) |
3070 ((DDBltFx
->u5
.dwFillColor
& 0xF800) << 8) |
3071 ((DDBltFx
->u5
.dwFillColor
& 0x07E0) << 5) |
3072 ((DDBltFx
->u5
.dwFillColor
& 0x001F) << 3));
3075 else if ((This
->resource
.format
== WINED3DFMT_R8G8B8
) ||
3076 (This
->resource
.format
== WINED3DFMT_X8R8G8B8
) ) {
3077 color
= 0xFF000000 | DDBltFx
->u5
.dwFillColor
;
3079 else if (This
->resource
.format
== WINED3DFMT_A8R8G8B8
) {
3080 color
= DDBltFx
->u5
.dwFillColor
;
3083 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3084 return WINED3DERR_INVALIDCALL
;
3087 TRACE("Calling GetSwapChain with mydevice = %p\n", myDevice
);
3088 if(dstSwapchain
&& dstSwapchain
->backBuffer
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->backBuffer
[0]) {
3089 glDrawBuffer(GL_BACK
);
3090 checkGLcall("glDrawBuffer(GL_BACK)");
3091 } else if (dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
) {
3092 glDrawBuffer(GL_FRONT
);
3093 checkGLcall("glDrawBuffer(GL_FRONT)");
3094 } else if(This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3095 glDrawBuffer(myDevice
->offscreenBuffer
);
3096 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer3)");
3098 TRACE("Surface is higher back buffer, falling back to software\n");
3099 return WINED3DERR_INVALIDCALL
;
3102 TRACE("(%p) executing Render Target override, color = %x\n", This
, color
);
3104 IWineD3DDevice_Clear( (IWineD3DDevice
*) myDevice
,
3105 1 /* Number of rectangles */,
3107 WINED3DCLEAR_TARGET
,
3112 /* Restore the original draw buffer */
3114 glDrawBuffer(myDevice
->offscreenBuffer
);
3115 } else if(dstSwapchain
->backBuffer
&& dstSwapchain
->backBuffer
[0]) {
3116 glDrawBuffer(GL_BACK
);
3118 vcheckGLcall("glDrawBuffer");
3124 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3125 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3126 return WINED3DERR_INVALIDCALL
;
3129 static HRESULT WINAPI
IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
)
3131 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3133 if (Flags
& WINEDDBLT_DEPTHFILL
) {
3134 return IWineD3DDevice_Clear((IWineD3DDevice
*) myDevice
,
3135 DestRect
== NULL
? 0 : 1,
3136 (WINED3DRECT
*) DestRect
,
3137 WINED3DCLEAR_ZBUFFER
,
3139 (float) DDBltFx
->u5
.dwFillDepth
/ (float) MAXDWORD
,
3145 FIXME("(%p): Unsupp depthstencil blit\n", This
);
3146 return WINED3DERR_INVALIDCALL
;
3149 static HRESULT WINAPI
IWineD3DSurfaceImpl_Blt(IWineD3DSurface
*iface
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3150 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3151 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3152 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3153 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3154 TRACE("(%p): Usage is %s\n", This
, debug_d3dusage(This
->resource
.usage
));
3156 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair */
3157 if(iface
== myDevice
->stencilBufferTarget
|| (SrcSurface
&& SrcSurface
== myDevice
->stencilBufferTarget
)) {
3158 if(myDevice
->inScene
) {
3159 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3160 return WINED3DERR_INVALIDCALL
;
3161 } else if(IWineD3DSurfaceImpl_BltZ(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
) == WINED3D_OK
) {
3162 TRACE("Z Blit override handled the blit\n");
3167 /* Special cases for RenderTargets */
3168 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3169 ( Src
&& (Src
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3170 if(IWineD3DSurfaceImpl_BltOverride(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
) == WINED3D_OK
) return WINED3D_OK
;
3173 /* For the rest call the X11 surface implementation.
3174 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3175 * other Blts are rather rare
3177 return IWineGDISurfaceImpl_Blt(iface
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
);
3180 HRESULT WINAPI
IWineD3DSurfaceImpl_GetBltStatus(IWineD3DSurface
*iface
, DWORD Flags
) {
3181 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3182 TRACE("(%p)->(%x)\n", This
, Flags
);
3186 case WINEDDGBS_CANBLT
:
3187 case WINEDDGBS_ISBLTDONE
:
3191 return WINED3DERR_INVALIDCALL
;
3195 HRESULT WINAPI
IWineD3DSurfaceImpl_GetFlipStatus(IWineD3DSurface
*iface
, DWORD Flags
) {
3196 /* XXX: DDERR_INVALIDSURFACETYPE */
3198 TRACE("(%p)->(%08x)\n",iface
,Flags
);
3200 case WINEDDGFS_CANFLIP
:
3201 case WINEDDGFS_ISFLIPDONE
:
3205 return WINED3DERR_INVALIDCALL
;
3209 HRESULT WINAPI
IWineD3DSurfaceImpl_IsLost(IWineD3DSurface
*iface
) {
3210 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3211 TRACE("(%p)\n", This
);
3213 /* D3D8 and 9 loose full devices, ddraw only surfaces */
3214 return This
->Flags
& SFLAG_LOST
? WINED3DERR_DEVICELOST
: WINED3D_OK
;
3217 HRESULT WINAPI
IWineD3DSurfaceImpl_Restore(IWineD3DSurface
*iface
) {
3218 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3219 TRACE("(%p)\n", This
);
3221 /* So far we don't lose anything :) */
3222 This
->Flags
&= ~SFLAG_LOST
;
3226 HRESULT WINAPI
IWineD3DSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
, IWineD3DSurface
*Source
, RECT
*rsrc
, DWORD trans
) {
3227 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3228 IWineD3DSurfaceImpl
*srcImpl
= (IWineD3DSurfaceImpl
*) Source
;
3229 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3230 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3232 if(myDevice
->inScene
&&
3233 (iface
== myDevice
->stencilBufferTarget
||
3234 (Source
&& Source
== myDevice
->stencilBufferTarget
))) {
3235 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3236 return WINED3DERR_INVALIDCALL
;
3239 /* Special cases for RenderTargets */
3240 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3241 ( srcImpl
&& (srcImpl
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3243 RECT SrcRect
, DstRect
;
3247 SrcRect
.left
= rsrc
->left
;
3248 SrcRect
.top
= rsrc
->top
;
3249 SrcRect
.bottom
= rsrc
->bottom
;
3250 SrcRect
.right
= rsrc
->right
;
3254 SrcRect
.right
= srcImpl
->currentDesc
.Width
;
3255 SrcRect
.bottom
= srcImpl
->currentDesc
.Height
;
3258 DstRect
.left
= dstx
;
3260 DstRect
.right
= dstx
+ SrcRect
.right
- SrcRect
.left
;
3261 DstRect
.bottom
= dsty
+ SrcRect
.bottom
- SrcRect
.top
;
3263 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3264 if(trans
& WINEDDBLTFAST_SRCCOLORKEY
)
3265 Flags
|= WINEDDBLT_KEYSRC
;
3266 if(trans
& WINEDDBLTFAST_DESTCOLORKEY
)
3267 Flags
|= WINEDDBLT_KEYDEST
;
3268 if(trans
& WINEDDBLTFAST_WAIT
)
3269 Flags
|= WINEDDBLT_WAIT
;
3270 if(trans
& WINEDDBLTFAST_DONOTWAIT
)
3271 Flags
|= WINEDDBLT_DONOTWAIT
;
3273 if(IWineD3DSurfaceImpl_BltOverride(This
, &DstRect
, Source
, &SrcRect
, Flags
, NULL
, WINED3DTEXF_POINT
) == WINED3D_OK
) return WINED3D_OK
;
3277 return IWineGDISurfaceImpl_BltFast(iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3280 HRESULT WINAPI
IWineD3DSurfaceImpl_GetPalette(IWineD3DSurface
*iface
, IWineD3DPalette
**Pal
) {
3281 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3282 TRACE("(%p)->(%p)\n", This
, Pal
);
3284 *Pal
= (IWineD3DPalette
*) This
->palette
;
3288 HRESULT WINAPI
IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
3289 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3291 IWineD3DPaletteImpl
*pal
= This
->palette
;
3293 TRACE("(%p)\n", This
);
3295 if(This
->resource
.format
== WINED3DFMT_P8
||
3296 This
->resource
.format
== WINED3DFMT_A8P8
)
3298 if(!This
->Flags
& SFLAG_INSYSMEM
) {
3299 FIXME("Palette changed with surface that does not have an up to date system memory copy\n");
3301 TRACE("Dirtifying surface\n");
3302 This
->Flags
&= ~(SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
3305 if(This
->Flags
& SFLAG_DIBSECTION
) {
3306 TRACE("(%p): Updating the hdc's palette\n", This
);
3307 for (n
=0; n
<256; n
++) {
3309 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
3310 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
3311 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
3313 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3314 /* Use the default device palette */
3315 col
[n
].rgbRed
= device
->palettes
[device
->currentPalette
][n
].peRed
;
3316 col
[n
].rgbGreen
= device
->palettes
[device
->currentPalette
][n
].peGreen
;
3317 col
[n
].rgbBlue
= device
->palettes
[device
->currentPalette
][n
].peBlue
;
3319 col
[n
].rgbReserved
= 0;
3321 SetDIBColorTable(This
->hDC
, 0, 256, col
);
3327 HRESULT WINAPI
IWineD3DSurfaceImpl_SetPalette(IWineD3DSurface
*iface
, IWineD3DPalette
*Pal
) {
3328 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3329 IWineD3DPaletteImpl
*PalImpl
= (IWineD3DPaletteImpl
*) Pal
;
3330 TRACE("(%p)->(%p)\n", This
, Pal
);
3332 if(This
->palette
!= NULL
)
3333 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
3334 This
->palette
->Flags
&= ~WINEDDPCAPS_PRIMARYSURFACE
;
3336 if(PalImpl
!= NULL
) {
3337 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
3338 /* Set the device's main palette if the palette
3339 * wasn't a primary palette before
3341 if(!(PalImpl
->Flags
& WINEDDPCAPS_PRIMARYSURFACE
)) {
3342 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3345 for(i
=0; i
< 256; i
++) {
3346 device
->palettes
[device
->currentPalette
][i
] = PalImpl
->palents
[i
];
3350 (PalImpl
)->Flags
|= WINEDDPCAPS_PRIMARYSURFACE
;
3353 This
->palette
= PalImpl
;
3355 return IWineD3DSurface_RealizePalette(iface
);
3358 HRESULT WINAPI
IWineD3DSurfaceImpl_SetColorKey(IWineD3DSurface
*iface
, DWORD Flags
, WINEDDCOLORKEY
*CKey
) {
3359 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3360 TRACE("(%p)->(%08x,%p)\n", This
, Flags
, CKey
);
3362 if ((Flags
& WINEDDCKEY_COLORSPACE
) != 0) {
3363 FIXME(" colorkey value not supported (%08x) !\n", Flags
);
3364 return WINED3DERR_INVALIDCALL
;
3367 /* Dirtify the surface, but only if a key was changed */
3369 switch (Flags
& ~WINEDDCKEY_COLORSPACE
) {
3370 case WINEDDCKEY_DESTBLT
:
3371 This
->DestBltCKey
= *CKey
;
3372 This
->CKeyFlags
|= WINEDDSD_CKDESTBLT
;
3375 case WINEDDCKEY_DESTOVERLAY
:
3376 This
->DestOverlayCKey
= *CKey
;
3377 This
->CKeyFlags
|= WINEDDSD_CKDESTOVERLAY
;
3380 case WINEDDCKEY_SRCOVERLAY
:
3381 This
->SrcOverlayCKey
= *CKey
;
3382 This
->CKeyFlags
|= WINEDDSD_CKSRCOVERLAY
;
3385 case WINEDDCKEY_SRCBLT
:
3386 This
->SrcBltCKey
= *CKey
;
3387 This
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
3392 switch (Flags
& ~WINEDDCKEY_COLORSPACE
) {
3393 case WINEDDCKEY_DESTBLT
:
3394 This
->CKeyFlags
&= ~WINEDDSD_CKDESTBLT
;
3397 case WINEDDCKEY_DESTOVERLAY
:
3398 This
->CKeyFlags
&= ~WINEDDSD_CKDESTOVERLAY
;
3401 case WINEDDCKEY_SRCOVERLAY
:
3402 This
->CKeyFlags
&= ~WINEDDSD_CKSRCOVERLAY
;
3405 case WINEDDCKEY_SRCBLT
:
3406 This
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
3414 static HRESULT WINAPI
IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
) {
3415 /** Check against the maximum texture sizes supported by the video card **/
3416 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3418 TRACE("%p\n", This
);
3419 if ((This
->pow2Width
> GL_LIMITS(texture_size
) || This
->pow2Height
> GL_LIMITS(texture_size
)) && !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_DEPTHSTENCIL
))) {
3420 /* one of three options
3421 1: Do the same as we do with nonpow 2 and scale the texture, (any texture ops would require the texture to be scaled which is potentially slow)
3422 2: Set the texture to the maximum size (bad idea)
3423 3: WARN and return WINED3DERR_NOTAVAILABLE;
3424 4: Create the surface, but allow it to be used only for DirectDraw Blts. Some apps(e.g. Swat 3) create textures with a Height of 16 and a Width > 3000 and blt 16x16 letter areas from them to the render target.
3426 WARN("(%p) Creating an oversized surface\n", This
);
3427 This
->Flags
|= SFLAG_OVERSIZE
;
3429 /* This will be initialized on the first blt */
3430 This
->glRect
.left
= 0;
3431 This
->glRect
.top
= 0;
3432 This
->glRect
.right
= 0;
3433 This
->glRect
.bottom
= 0;
3435 /* No oversize, gl rect is the full texture size */
3436 This
->Flags
&= ~SFLAG_OVERSIZE
;
3437 This
->glRect
.left
= 0;
3438 This
->glRect
.top
= 0;
3439 This
->glRect
.right
= This
->pow2Width
;
3440 This
->glRect
.bottom
= This
->pow2Height
;
3443 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
) && This
->resource
.allocatedMemory
== NULL
) {
3444 /* Make sure that memory is allocated from the start if we are going to use GL_APPLE_client_storage.
3445 * Otherwise a glTexImage2D with a NULL pointer may be done, e.g. when blitting or with offscreen render
3446 * targets, thus the client storage wouldn't be used for that texture
3448 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
+ 4);
3453 DWORD WINAPI
IWineD3DSurfaceImpl_GetPitch(IWineD3DSurface
*iface
) {
3454 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3456 TRACE("(%p)\n", This
);
3458 /* DXTn formats don't have exact pitches as they are to the new row of blocks,
3459 where each block is 4x4 pixels, 8 bytes (dxt1) and 16 bytes (dxt2/3/4/5)
3460 ie pitch = (width/4) * bytes per block */
3461 if (This
->resource
.format
== WINED3DFMT_DXT1
) /* DXT1 is 8 bytes per block */
3462 ret
= ((This
->currentDesc
.Width
+ 3) >> 2) << 3;
3463 else if (This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
3464 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) /* DXT2/3/4/5 is 16 bytes per block */
3465 ret
= ((This
->currentDesc
.Width
+ 3) >> 2) << 4;
3467 ret
= This
->bytesPerPixel
* This
->currentDesc
.Width
; /* Bytes / row */
3468 /* Surfaces are 32 bit aligned */
3469 ret
= (ret
+ SURFACE_ALIGNMENT
- 1) & ~(SURFACE_ALIGNMENT
- 1);
3471 TRACE("(%p) Returning %d\n", This
, ret
);
3475 HRESULT WINAPI
IWineD3DSurfaceImpl_SetOverlayPosition(IWineD3DSurface
*iface
, LONG X
, LONG Y
) {
3476 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3478 FIXME("(%p)->(%d,%d) Stub!\n", This
, X
, Y
);
3480 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
3482 TRACE("(%p): Not an overlay surface\n", This
);
3483 return WINEDDERR_NOTAOVERLAYSURFACE
;
3489 HRESULT WINAPI
IWineD3DSurfaceImpl_GetOverlayPosition(IWineD3DSurface
*iface
, LONG
*X
, LONG
*Y
) {
3490 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3492 FIXME("(%p)->(%p,%p) Stub!\n", This
, X
, Y
);
3494 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
3496 TRACE("(%p): Not an overlay surface\n", This
);
3497 return WINEDDERR_NOTAOVERLAYSURFACE
;
3503 HRESULT WINAPI
IWineD3DSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface
*iface
, DWORD Flags
, IWineD3DSurface
*Ref
) {
3504 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3505 IWineD3DSurfaceImpl
*RefImpl
= (IWineD3DSurfaceImpl
*) Ref
;
3507 FIXME("(%p)->(%08x,%p) Stub!\n", This
, Flags
, RefImpl
);
3509 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
3511 TRACE("(%p): Not an overlay surface\n", This
);
3512 return WINEDDERR_NOTAOVERLAYSURFACE
;
3518 HRESULT WINAPI
IWineD3DSurfaceImpl_UpdateOverlay(IWineD3DSurface
*iface
, RECT
*SrcRect
, IWineD3DSurface
*DstSurface
, RECT
*DstRect
, DWORD Flags
, WINEDDOVERLAYFX
*FX
) {
3519 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3520 IWineD3DSurfaceImpl
*Dst
= (IWineD3DSurfaceImpl
*) DstSurface
;
3521 FIXME("(%p)->(%p, %p, %p, %08x, %p)\n", This
, SrcRect
, Dst
, DstRect
, Flags
, FX
);
3523 if(!(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
))
3525 TRACE("(%p): Not an overlay surface\n", This
);
3526 return WINEDDERR_NOTAOVERLAYSURFACE
;
3532 HRESULT WINAPI
IWineD3DSurfaceImpl_SetClipper(IWineD3DSurface
*iface
, IWineD3DClipper
*clipper
)
3534 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3535 TRACE("(%p)->(%p)\n", This
, clipper
);
3537 This
->clipper
= clipper
;
3541 HRESULT WINAPI
IWineD3DSurfaceImpl_GetClipper(IWineD3DSurface
*iface
, IWineD3DClipper
**clipper
)
3543 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3544 TRACE("(%p)->(%p)\n", This
, clipper
);
3546 *clipper
= This
->clipper
;
3548 IWineD3DClipper_AddRef(*clipper
);
3553 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl
=
3556 IWineD3DSurfaceImpl_QueryInterface
,
3557 IWineD3DSurfaceImpl_AddRef
,
3558 IWineD3DSurfaceImpl_Release
,
3559 /* IWineD3DResource */
3560 IWineD3DSurfaceImpl_GetParent
,
3561 IWineD3DSurfaceImpl_GetDevice
,
3562 IWineD3DSurfaceImpl_SetPrivateData
,
3563 IWineD3DSurfaceImpl_GetPrivateData
,
3564 IWineD3DSurfaceImpl_FreePrivateData
,
3565 IWineD3DSurfaceImpl_SetPriority
,
3566 IWineD3DSurfaceImpl_GetPriority
,
3567 IWineD3DSurfaceImpl_PreLoad
,
3568 IWineD3DSurfaceImpl_GetType
,
3569 /* IWineD3DSurface */
3570 IWineD3DSurfaceImpl_GetContainer
,
3571 IWineD3DSurfaceImpl_GetDesc
,
3572 IWineD3DSurfaceImpl_LockRect
,
3573 IWineD3DSurfaceImpl_UnlockRect
,
3574 IWineD3DSurfaceImpl_GetDC
,
3575 IWineD3DSurfaceImpl_ReleaseDC
,
3576 IWineD3DSurfaceImpl_Flip
,
3577 IWineD3DSurfaceImpl_Blt
,
3578 IWineD3DSurfaceImpl_GetBltStatus
,
3579 IWineD3DSurfaceImpl_GetFlipStatus
,
3580 IWineD3DSurfaceImpl_IsLost
,
3581 IWineD3DSurfaceImpl_Restore
,
3582 IWineD3DSurfaceImpl_BltFast
,
3583 IWineD3DSurfaceImpl_GetPalette
,
3584 IWineD3DSurfaceImpl_SetPalette
,
3585 IWineD3DSurfaceImpl_RealizePalette
,
3586 IWineD3DSurfaceImpl_SetColorKey
,
3587 IWineD3DSurfaceImpl_GetPitch
,
3588 IWineD3DSurfaceImpl_SetMem
,
3589 IWineD3DSurfaceImpl_SetOverlayPosition
,
3590 IWineD3DSurfaceImpl_GetOverlayPosition
,
3591 IWineD3DSurfaceImpl_UpdateOverlayZOrder
,
3592 IWineD3DSurfaceImpl_UpdateOverlay
,
3593 IWineD3DSurfaceImpl_SetClipper
,
3594 IWineD3DSurfaceImpl_GetClipper
,
3596 IWineD3DSurfaceImpl_AddDirtyRect
,
3597 IWineD3DSurfaceImpl_LoadTexture
,
3598 IWineD3DSurfaceImpl_SaveSnapshot
,
3599 IWineD3DSurfaceImpl_SetContainer
,
3600 IWineD3DSurfaceImpl_SetGlTextureDesc
,
3601 IWineD3DSurfaceImpl_GetGlDesc
,
3602 IWineD3DSurfaceImpl_GetData
,
3603 IWineD3DSurfaceImpl_SetFormat
,
3604 IWineD3DSurfaceImpl_PrivateSetup