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-2007 Stefan Dösinger for CodeWeavers
11 * Copyright 2007 Henri Verbeet
12 * Copyright 2006-2007 Roderick Colenbrander
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/port.h"
31 #include "wined3d_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
34 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
36 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*surf
);
37 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
);
39 static void surface_download_data(IWineD3DSurfaceImpl
*This
) {
40 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
42 if (0 == This
->glDescription
.textureName
) {
43 ERR("Surface does not have a texture, but SFLAG_INTEXTURE is set\n");
47 if(myDevice
->createParms
.BehaviorFlags
& WINED3DCREATE_MULTITHREADED
) {
48 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
52 /* Make sure that a proper texture unit is selected, bind the texture
53 * and dirtify the sampler to restore the texture on the next draw
55 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
56 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
57 checkGLcall("glActiveTextureARB");
59 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(0));
60 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
62 if (This
->resource
.format
== WINED3DFMT_DXT1
||
63 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
64 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
65 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) { /* We can assume this as the texture would not have been created otherwise */
66 FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This
);
68 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
69 This
->glDescription
.glFormat
, This
->glDescription
.glType
, This
->resource
.allocatedMemory
);
71 if(This
->Flags
& SFLAG_PBO
) {
72 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
73 checkGLcall("glBindBufferARB");
74 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, NULL
));
75 checkGLcall("glGetCompressedTexImageARB()");
76 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
77 checkGLcall("glBindBufferARB");
79 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, This
->resource
.allocatedMemory
));
80 checkGLcall("glGetCompressedTexImageARB()");
89 if(This
->Flags
& SFLAG_CONVERTED
) {
90 FIXME("Read back converted textures unsupported\n");
95 if (This
->Flags
& SFLAG_NONPOW2
) {
96 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
97 src_pitch
= This
->bytesPerPixel
* This
->pow2Width
;
98 dst_pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
);
99 src_pitch
= (src_pitch
+ alignment
- 1) & ~(alignment
- 1);
100 mem
= HeapAlloc(GetProcessHeap(), 0, src_pitch
* This
->pow2Height
);
102 mem
= This
->resource
.allocatedMemory
;
105 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
106 This
->glDescription
.glFormat
, This
->glDescription
.glType
, mem
);
108 if(This
->Flags
& SFLAG_PBO
) {
109 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
110 checkGLcall("glBindBufferARB");
112 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, This
->glDescription
.glFormat
,
113 This
->glDescription
.glType
, NULL
);
114 checkGLcall("glGetTexImage()");
116 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
117 checkGLcall("glBindBufferARB");
119 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, This
->glDescription
.glFormat
,
120 This
->glDescription
.glType
, mem
);
121 checkGLcall("glGetTexImage()");
125 if (This
->Flags
& SFLAG_NONPOW2
) {
126 LPBYTE src_data
, dst_data
;
129 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
130 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
131 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
133 * We're doing this...
135 * instead of boxing the texture :
136 * |<-texture width ->| -->pow2width| /\
137 * |111111111111111111| | |
138 * |222 Texture 222222| boxed empty | texture height
139 * |3333 Data 33333333| | |
140 * |444444444444444444| | \/
141 * ----------------------------------- |
142 * | boxed empty | boxed empty | pow2height
144 * -----------------------------------
147 * we're repacking the data to the expected texture width
149 * |<-texture width ->| -->pow2width| /\
150 * |111111111111111111222222222222222| |
151 * |222333333333333333333444444444444| texture height
155 * | empty | pow2height
157 * -----------------------------------
161 * |<-texture width ->| /\
162 * |111111111111111111|
163 * |222222222222222222|texture height
164 * |333333333333333333|
165 * |444444444444444444| \/
166 * --------------------
168 * this also means that any references to allocatedMemory should work with the data as if were a
169 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
171 * internally the texture is still stored in a boxed format so any references to textureName will
172 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
174 * Performance should not be an issue, because applications normally do not lock the surfaces when
175 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
176 * and doesn't have to be re-read.
179 dst_data
= This
->resource
.allocatedMemory
;
180 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This
, src_pitch
, dst_pitch
);
181 for (y
= 1 ; y
< This
->currentDesc
.Height
; y
++) {
182 /* skip the first row */
183 src_data
+= src_pitch
;
184 dst_data
+= dst_pitch
;
185 memcpy(dst_data
, src_data
, dst_pitch
);
188 HeapFree(GetProcessHeap(), 0, mem
);
192 /* Surface has now been downloaded */
193 This
->Flags
|= SFLAG_INSYSMEM
;
196 static void surface_upload_data(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*data
) {
197 if (This
->resource
.format
== WINED3DFMT_DXT1
||
198 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
199 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
200 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
201 FIXME("Using DXT1/3/5 without advertized support\n");
203 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
204 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
205 This
->Flags
|= SFLAG_CLIENT
;
208 /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
209 * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
210 * function uses glCompressedTexImage2D instead of the SubImage call
212 TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This
, width
, height
, data
);
215 if(This
->Flags
& SFLAG_PBO
) {
216 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
217 checkGLcall("glBindBufferARB");
218 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
220 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
221 width
, height
, 0 /* border */, This
->resource
.size
, NULL
));
222 checkGLcall("glCompressedTexSubImage2D");
224 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
225 checkGLcall("glBindBufferARB");
227 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
228 width
, height
, 0 /* border */, This
->resource
.size
, data
));
229 checkGLcall("glCompressedTexSubImage2D");
234 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This
, width
, height
, data
);
237 if(This
->Flags
& SFLAG_PBO
) {
238 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
239 checkGLcall("glBindBufferARB");
240 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
242 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, NULL
);
243 checkGLcall("glTexSubImage2D");
245 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
246 checkGLcall("glBindBufferARB");
249 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, data
);
250 checkGLcall("glTexSubImage2D");
257 static void surface_allocate_surface(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
) {
258 BOOL enable_client_storage
= FALSE
;
260 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
,
261 This
->glDescription
.target
, This
->glDescription
.level
, debug_d3dformat(This
->resource
.format
), internal
, width
, height
, format
, type
);
263 if (This
->resource
.format
== WINED3DFMT_DXT1
||
264 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
265 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
266 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
267 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
273 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
274 if(This
->Flags
& (SFLAG_NONPOW2
| SFLAG_DIBSECTION
| SFLAG_OVERSIZE
| SFLAG_CONVERTED
) || This
->resource
.allocatedMemory
== NULL
) {
275 /* In some cases we want to disable client storage.
276 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
277 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
278 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
279 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
280 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
282 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_FALSE
);
283 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
284 This
->Flags
&= ~SFLAG_CLIENT
;
285 enable_client_storage
= TRUE
;
287 This
->Flags
|= SFLAG_CLIENT
;
288 /* Below point opengl to our allocated texture memory */
291 glTexImage2D(This
->glDescription
.target
, This
->glDescription
.level
, internal
, width
, height
, 0, format
, type
,
292 This
->Flags
& SFLAG_CLIENT
? This
->resource
.allocatedMemory
: NULL
);
293 checkGLcall("glTexImage2D");
295 if(enable_client_storage
) {
296 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
297 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
301 This
->Flags
|= SFLAG_ALLOCATED
;
304 /* In D3D the depth stencil dimensions have to be greater than or equal to the
305 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
306 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
307 void surface_set_compatible_renderbuffer(IWineD3DSurface
*iface
, unsigned int width
, unsigned int height
) {
308 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
309 renderbuffer_entry_t
*entry
;
310 GLuint renderbuffer
= 0;
311 unsigned int src_width
, src_height
;
313 src_width
= This
->pow2Width
;
314 src_height
= This
->pow2Height
;
316 /* A depth stencil smaller than the render target is not valid */
317 if (width
> src_width
|| height
> src_height
) return;
319 /* Remove any renderbuffer set if the sizes match */
320 if (width
== src_width
&& height
== src_height
) {
321 This
->current_renderbuffer
= NULL
;
325 /* Look if we've already got a renderbuffer of the correct dimensions */
326 LIST_FOR_EACH_ENTRY(entry
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
327 if (entry
->width
== width
&& entry
->height
== height
) {
328 renderbuffer
= entry
->id
;
329 This
->current_renderbuffer
= entry
;
335 const GlPixelFormatDesc
*glDesc
;
336 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
338 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer
));
339 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, renderbuffer
));
340 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, glDesc
->glFormat
, width
, height
));
342 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t
));
343 entry
->width
= width
;
344 entry
->height
= height
;
345 entry
->id
= renderbuffer
;
346 list_add_head(&This
->renderbuffers
, &entry
->entry
);
348 This
->current_renderbuffer
= entry
;
351 checkGLcall("set_compatible_renderbuffer");
354 GLenum
surface_get_gl_buffer(IWineD3DSurface
*iface
, IWineD3DSwapChain
*swapchain
) {
355 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
356 IWineD3DSwapChainImpl
*swapchain_impl
= (IWineD3DSwapChainImpl
*)swapchain
;
358 TRACE("(%p) : swapchain %p\n", This
, swapchain
);
360 if (swapchain_impl
->backBuffer
&& swapchain_impl
->backBuffer
[0] == iface
) {
361 TRACE("Returning GL_BACK\n");
363 } else if (swapchain_impl
->frontBuffer
== iface
) {
364 TRACE("Returning GL_FRONT\n");
368 FIXME("Higher back buffer, returning GL_BACK\n");
372 ULONG WINAPI
IWineD3DSurfaceImpl_Release(IWineD3DSurface
*iface
) {
373 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
374 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
375 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
377 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->resource
.wineD3DDevice
;
378 renderbuffer_entry_t
*entry
, *entry2
;
379 TRACE("(%p) : cleaning up\n", This
);
381 if (This
->glDescription
.textureName
!= 0) { /* release the openGL texture.. */
383 /* Need a context to destroy the texture. Use the currently active render target, but only if
384 * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
385 * When destroying the primary rt, Uninit3D will activate a context before doing anything
387 if(device
->render_targets
&& device
->render_targets
[0]) {
388 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
391 TRACE("Deleting texture %d\n", This
->glDescription
.textureName
);
393 glDeleteTextures(1, &This
->glDescription
.textureName
);
397 if(This
->Flags
& SFLAG_PBO
) {
399 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
402 if(This
->Flags
& SFLAG_DIBSECTION
) {
404 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
406 /* Release the DIB section */
407 DeleteObject(This
->dib
.DIBsection
);
408 This
->dib
.bitmap_data
= NULL
;
409 This
->resource
.allocatedMemory
= NULL
;
411 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
413 HeapFree(GetProcessHeap(), 0, This
->palette9
);
415 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
416 if(iface
== device
->ddraw_primary
)
417 device
->ddraw_primary
= NULL
;
419 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
420 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
421 HeapFree(GetProcessHeap(), 0, entry
);
424 TRACE("(%p) Released\n", This
);
425 HeapFree(GetProcessHeap(), 0, This
);
431 /* ****************************************************
432 IWineD3DSurface IWineD3DResource parts follow
433 **************************************************** */
435 void WINAPI
IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface
*iface
) {
436 /* TODO: check for locks */
437 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
438 IWineD3DBaseTexture
*baseTexture
= NULL
;
439 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
441 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
442 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
443 TRACE("Passing to container\n");
444 IWineD3DBaseTexture_PreLoad(baseTexture
);
445 IWineD3DBaseTexture_Release(baseTexture
);
447 TRACE("(%p) : About to load surface\n", This
);
449 if(!device
->isInDraw
) {
450 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
454 glEnable(This
->glDescription
.target
);/* make sure texture support is enabled in this context */
455 if (!This
->glDescription
.level
) {
456 if (!This
->glDescription
.textureName
) {
457 glGenTextures(1, &This
->glDescription
.textureName
);
458 checkGLcall("glGenTextures");
459 TRACE("Surface %p given name %d\n", This
, This
->glDescription
.textureName
);
461 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
462 checkGLcall("glBindTexture");
463 IWineD3DSurface_LoadTexture(iface
, FALSE
);
464 /* This is where we should be reducing the amount of GLMemoryUsed */
465 } else if (This
->glDescription
.textureName
) { /* NOTE: the level 0 surface of a mpmapped texture must be loaded first! */
466 /* assume this is a coding error not a real error for now */
467 FIXME("Mipmap surface has a glTexture bound to it!\n");
469 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
470 /* Tell opengl to try and keep this texture in video ram (well mostly) */
473 glPrioritizeTextures(1, &This
->glDescription
.textureName
, &tmp
);
480 /* ******************************************************
481 IWineD3DSurface IWineD3DSurface parts follow
482 ****************************************************** */
484 void WINAPI
IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface
*iface
, UINT textureName
, int target
) {
485 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
486 TRACE("(%p) : setting textureName %u, target %i\n", This
, textureName
, target
);
487 if (This
->glDescription
.textureName
== 0 && textureName
!= 0) {
488 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
489 IWineD3DSurface_AddDirtyRect(iface
, NULL
);
491 This
->glDescription
.textureName
= textureName
;
492 This
->glDescription
.target
= target
;
493 This
->Flags
&= ~SFLAG_ALLOCATED
;
496 void WINAPI
IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
497 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
498 TRACE("(%p) : returning %p\n", This
, &This
->glDescription
);
499 *glDescription
= &This
->glDescription
;
502 /* TODO: think about moving this down to resource? */
503 const void *WINAPI
IWineD3DSurfaceImpl_GetData(IWineD3DSurface
*iface
) {
504 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
505 /* 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 */
506 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
) {
507 FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface
);
509 return (CONST
void*)(This
->resource
.allocatedMemory
);
512 static void read_from_framebuffer(IWineD3DSurfaceImpl
*This
, CONST RECT
*rect
, void *dest
, UINT pitch
) {
513 IWineD3DSwapChainImpl
*swapchain
;
514 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
518 BYTE
*row
, *top
, *bottom
;
522 BOOL srcIsUpsideDown
;
524 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
525 static BOOL warned
= FALSE
;
527 ERR("The application tries to lock the render target, but render target locking is disabled\n");
533 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
534 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
535 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
536 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
537 * context->last_was_blit set on the unlock.
539 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
542 /* Select the correct read buffer, and give some debug output.
543 * There is no need to keep track of the current read buffer or reset it, every part of the code
544 * that reads sets the read buffer as desired.
547 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
548 * Read from the back buffer
550 TRACE("Locking offscreen render target\n");
551 glReadBuffer(myDevice
->offscreenBuffer
);
552 srcIsUpsideDown
= TRUE
;
554 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
555 TRACE("Locking %#x buffer\n", buffer
);
556 glReadBuffer(buffer
);
557 checkGLcall("glReadBuffer");
559 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
560 srcIsUpsideDown
= FALSE
;
563 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
567 local_rect
.right
= This
->currentDesc
.Width
;
568 local_rect
.bottom
= This
->currentDesc
.Height
;
572 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
574 switch(This
->resource
.format
)
578 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
579 /* In case of P8 render targets the index is stored in the alpha component */
581 type
= GL_UNSIGNED_BYTE
;
583 bpp
= This
->bytesPerPixel
;
585 /* GL can't return palettized data, so read ARGB pixels into a
586 * separate block of memory and convert them into palettized format
587 * in software. Slow, but if the app means to use palettized render
588 * targets and locks it...
590 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
591 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
592 * for the color channels when palettizing the colors.
595 type
= GL_UNSIGNED_BYTE
;
597 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* 3);
599 ERR("Out of memory\n");
603 bpp
= This
->bytesPerPixel
* 3;
610 fmt
= This
->glDescription
.glFormat
;
611 type
= This
->glDescription
.glType
;
612 bpp
= This
->bytesPerPixel
;
615 if(This
->Flags
& SFLAG_PBO
) {
616 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
617 checkGLcall("glBindBufferARB");
620 glReadPixels(local_rect
.left
, local_rect
.top
,
621 local_rect
.right
- local_rect
.left
,
622 local_rect
.bottom
- local_rect
.top
,
624 vcheckGLcall("glReadPixels");
626 if(This
->Flags
& SFLAG_PBO
) {
627 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
628 checkGLcall("glBindBufferARB");
630 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
631 * to get a pointer to it and perform the flipping in software. This is a lot
632 * faster than calling glReadPixels for each line. In case we want more speed
633 * we should rerender it flipped in a FBO and read the data back from the FBO. */
634 if(!srcIsUpsideDown
) {
635 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
636 checkGLcall("glBindBufferARB");
638 mem
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
639 checkGLcall("glMapBufferARB");
643 /* TODO: Merge this with the palettization loop below for P8 targets */
644 if(!srcIsUpsideDown
) {
646 /* glReadPixels returns the image upside down, and there is no way to prevent this.
647 Flip the lines in software */
648 len
= (local_rect
.right
- local_rect
.left
) * bpp
;
649 off
= local_rect
.left
* bpp
;
651 row
= HeapAlloc(GetProcessHeap(), 0, len
);
653 ERR("Out of memory\n");
654 if(This
->resource
.format
== WINED3DFMT_P8
) HeapFree(GetProcessHeap(), 0, mem
);
659 top
= mem
+ pitch
* local_rect
.top
;
660 bottom
= ((BYTE
*) mem
) + pitch
* ( local_rect
.bottom
- local_rect
.top
- 1);
661 for(i
= 0; i
< (local_rect
.bottom
- local_rect
.top
) / 2; i
++) {
662 memcpy(row
, top
+ off
, len
);
663 memcpy(top
+ off
, bottom
+ off
, len
);
664 memcpy(bottom
+ off
, row
, len
);
668 HeapFree(GetProcessHeap(), 0, row
);
670 /* Unmap the temp PBO buffer */
671 if(This
->Flags
& SFLAG_PBO
) {
672 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
673 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
677 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
678 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
679 * the same color but we have no choice.
680 * In case of render targets, the index is stored in the alpha component so no conversion is needed.
682 if((This
->resource
.format
== WINED3DFMT_P8
) && !(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)) {
684 DWORD width
= pitch
/ 3;
687 pal
= This
->palette
->palents
;
689 pal
= This
->resource
.wineD3DDevice
->palettes
[This
->resource
.wineD3DDevice
->currentPalette
];
692 for(y
= local_rect
.top
; y
< local_rect
.bottom
; y
++) {
693 for(x
= local_rect
.left
; x
< local_rect
.right
; x
++) {
694 /* start lines pixels */
695 BYTE
*blue
= (BYTE
*) ((BYTE
*) mem
) + y
* pitch
+ x
* (sizeof(BYTE
) * 3);
696 BYTE
*green
= blue
+ 1;
697 BYTE
*red
= green
+ 1;
699 for(c
= 0; c
< 256; c
++) {
700 if(*red
== pal
[c
].peRed
&&
701 *green
== pal
[c
].peGreen
&&
702 *blue
== pal
[c
].peBlue
)
704 *((BYTE
*) dest
+ y
* width
+ x
) = c
;
710 HeapFree(GetProcessHeap(), 0, mem
);
715 static void surface_prepare_system_memory(IWineD3DSurfaceImpl
*This
) {
716 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
717 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
720 if(!(This
->Flags
& SFLAG_DYNLOCK
)) {
722 /* MAXLOCKCOUNT is defined in wined3d_private.h */
723 if(This
->lockCount
> MAXLOCKCOUNT
) {
724 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
725 This
->Flags
|= SFLAG_DYNLOCK
;
729 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
730 * Also don't create a PBO for systemmem surfaces.
732 if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT
) && (This
->Flags
& SFLAG_DYNLOCK
) && !(This
->Flags
& (SFLAG_PBO
| SFLAG_CONVERTED
| SFLAG_NONPOW2
)) && (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
)) {
736 GL_EXTCALL(glGenBuffersARB(1, &This
->pbo
));
737 error
= glGetError();
738 if(This
->pbo
== 0 || error
!= GL_NO_ERROR
) {
739 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error
), error
);
742 TRACE("Attaching pbo=%#x to (%p)\n", This
->pbo
, This
);
744 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
745 checkGLcall("glBindBufferARB");
747 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->resource
.size
+ 4, This
->resource
.allocatedMemory
, GL_STREAM_DRAW_ARB
));
748 checkGLcall("glBufferDataARB");
750 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
751 checkGLcall("glBindBufferARB");
753 /* We don't need the system memory anymore and we can't even use it for PBOs */
754 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
755 This
->resource
.allocatedMemory
= NULL
;
756 This
->resource
.heapMemory
= NULL
;
757 This
->Flags
|= SFLAG_PBO
;
759 } else if(!(This
->resource
.allocatedMemory
|| This
->Flags
& SFLAG_PBO
)) {
760 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
763 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
764 This
->resource
.allocatedMemory
=
765 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
766 if(This
->Flags
& SFLAG_INSYSMEM
) {
767 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
772 static HRESULT WINAPI
IWineD3DSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
) {
773 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
774 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
775 IWineD3DSwapChain
*swapchain
= NULL
;
777 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
779 /* This is also done in the base class, but we have to verify this before loading any data from
780 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
781 * may interfere, and all other bad things may happen
783 if (This
->Flags
& SFLAG_LOCKED
) {
784 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
785 return WINED3DERR_INVALIDCALL
;
788 if (Flags
& WINED3DLOCK_DISCARD
) {
789 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
790 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
791 This
->Flags
|= SFLAG_INSYSMEM
;
794 if (This
->Flags
& SFLAG_INSYSMEM
) {
795 TRACE("Local copy is up to date, not downloading data\n");
796 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
800 /* Now download the surface content from opengl
801 * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
802 * Offscreen targets which are not active at the moment or are higher targets(fbos) can be locked with the texture path
804 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
805 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
806 const RECT
*pass_rect
= pRect
;
808 /* IWineD3DSurface_LoadLocation does not check if the rectangle specifies the full surfaces
809 * because most caller functions do not need that. So do that here
814 pRect
->right
== This
->currentDesc
.Width
&&
815 pRect
->bottom
== This
->currentDesc
.Height
) {
819 switch(wined3d_settings
.rendertargetlock_mode
) {
822 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
824 /* Disabled for now. LoadLocation prefers the texture over the drawable as the source. So if we copy to the
825 * texture first, then to sysmem, we'll avoid glReadPixels and use glCopyTexImage and glGetTexImage2D instead.
826 * This may be faster on some cards
828 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* No partial texture copy yet */);
835 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, pRect
);
841 if(swapchain
) IWineD3DSwapChain_Release(swapchain
);
843 } else if(iface
== myDevice
->stencilBufferTarget
) {
844 /** the depth stencil in openGL has a format of GL_FLOAT
845 * which should be good for WINED3DFMT_D16_LOCKABLE
847 * it is unclear what format the stencil buffer is in except.
848 * 'Each index is converted to fixed point...
849 * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
850 * mappings in the table GL_PIXEL_MAP_S_TO_S.
851 * glReadPixels(This->lockedRect.left,
852 * This->lockedRect.bottom - j - 1,
853 * This->lockedRect.right - This->lockedRect.left,
855 * GL_DEPTH_COMPONENT,
857 * (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
859 * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
860 * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
861 * none of that is the case the problem is not in this function :-)
862 ********************************************/
863 FIXME("Depth stencil locking not supported yet\n");
865 /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
866 TRACE("locking an ordinary surface\n");
867 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
871 if(This
->Flags
& SFLAG_PBO
) {
872 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
874 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
875 checkGLcall("glBindBufferARB");
877 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
878 if(This
->resource
.allocatedMemory
) {
879 ERR("The surface already has PBO memory allocated!\n");
882 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
883 checkGLcall("glMapBufferARB");
885 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
886 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
887 checkGLcall("glBindBufferARB");
892 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
895 IWineD3DBaseTexture
*pBaseTexture
;
898 * as seen in msdn docs
900 IWineD3DSurface_AddDirtyRect(iface
, pRect
);
902 /** Dirtify Container if needed */
903 if (WINED3D_OK
== IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&pBaseTexture
) && pBaseTexture
!= NULL
) {
904 TRACE("Making container dirty\n");
905 IWineD3DBaseTexture_SetDirty(pBaseTexture
, TRUE
);
906 IWineD3DBaseTexture_Release(pBaseTexture
);
908 TRACE("Surface is standalone, no need to dirty the container\n");
912 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
915 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl
*This
) {
917 GLint prev_rasterpos
[4];
919 BOOL storechanged
= FALSE
, memory_allocated
= FALSE
;
923 UINT pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
); /* target is argb, 4 byte */
924 IWineD3DDeviceImpl
*myDevice
= (IWineD3DDeviceImpl
*) This
->resource
.wineD3DDevice
;
925 IWineD3DSwapChainImpl
*swapchain
;
927 /* Activate the correct context for the render target */
928 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
931 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
933 /* Primary offscreen render target */
934 TRACE("Offscreen render target\n");
935 glDrawBuffer(myDevice
->offscreenBuffer
);
936 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
938 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
939 TRACE("Unlocking %#x buffer\n", buffer
);
940 glDrawBuffer(buffer
);
941 checkGLcall("glDrawBuffer");
943 IWineD3DSwapChain_Release((IWineD3DSwapChain
*)swapchain
);
946 glDisable(GL_TEXTURE_2D
);
947 vcheckGLcall("glDisable(GL_TEXTURE_2D)");
950 vcheckGLcall("glFlush");
951 glGetIntegerv(GL_PACK_SWAP_BYTES
, &prev_store
);
952 vcheckGLcall("glIntegerv");
953 glGetIntegerv(GL_CURRENT_RASTER_POSITION
, &prev_rasterpos
[0]);
954 vcheckGLcall("glIntegerv");
955 glPixelZoom(1.0, -1.0);
956 vcheckGLcall("glPixelZoom");
958 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
959 glGetIntegerv(GL_UNPACK_ROW_LENGTH
, &skipBytes
);
960 glPixelStorei(GL_UNPACK_ROW_LENGTH
, This
->currentDesc
.Width
);
962 glRasterPos3i(This
->lockedRect
.left
, This
->lockedRect
.top
, 1);
963 vcheckGLcall("glRasterPos2f");
965 /* Some drivers(radeon dri, others?) don't like exceptions during
966 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
967 * after ReleaseDC. Reading it will cause an exception, which x11drv will
968 * catch to put the dib section in InSync mode, which leads to a crash
969 * and a blocked x server on my radeon card.
971 * The following lines read the dib section so it is put in inSync mode
972 * before glDrawPixels is called and the crash is prevented. There won't
973 * be any interfering gdi accesses, because UnlockRect is called from
974 * ReleaseDC, and the app won't use the dc any more afterwards.
976 if((This
->Flags
& SFLAG_DIBSECTION
) && !(This
->Flags
& SFLAG_PBO
)) {
978 read
= This
->resource
.allocatedMemory
[0];
981 switch (This
->resource
.format
) {
982 /* No special care needed */
983 case WINED3DFMT_A4R4G4B4
:
984 case WINED3DFMT_R5G6B5
:
985 case WINED3DFMT_A1R5G5B5
:
986 case WINED3DFMT_R8G8B8
:
987 type
= This
->glDescription
.glType
;
988 fmt
= This
->glDescription
.glFormat
;
989 mem
= This
->resource
.allocatedMemory
;
990 bpp
= This
->bytesPerPixel
;
993 case WINED3DFMT_X4R4G4B4
:
996 unsigned short *data
;
997 data
= (unsigned short *)This
->resource
.allocatedMemory
;
998 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1004 type
= This
->glDescription
.glType
;
1005 fmt
= This
->glDescription
.glFormat
;
1006 mem
= This
->resource
.allocatedMemory
;
1007 bpp
= This
->bytesPerPixel
;
1011 case WINED3DFMT_X1R5G5B5
:
1014 unsigned short *data
;
1015 data
= (unsigned short *)This
->resource
.allocatedMemory
;
1016 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1022 type
= This
->glDescription
.glType
;
1023 fmt
= This
->glDescription
.glFormat
;
1024 mem
= This
->resource
.allocatedMemory
;
1025 bpp
= This
->bytesPerPixel
;
1029 case WINED3DFMT_X8R8G8B8
:
1031 /* make sure the X byte is set to alpha on, since it
1032 could be any random value. This fixes the intro movie in Pirates! */
1035 data
= (unsigned int *)This
->resource
.allocatedMemory
;
1036 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1038 *data
|= 0xFF000000;
1045 case WINED3DFMT_A8R8G8B8
:
1047 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1048 vcheckGLcall("glPixelStorei");
1049 storechanged
= TRUE
;
1050 type
= This
->glDescription
.glType
;
1051 fmt
= This
->glDescription
.glFormat
;
1052 mem
= This
->resource
.allocatedMemory
;
1053 bpp
= This
->bytesPerPixel
;
1057 case WINED3DFMT_A2R10G10B10
:
1059 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1060 vcheckGLcall("glPixelStorei");
1061 storechanged
= TRUE
;
1062 type
= This
->glDescription
.glType
;
1063 fmt
= This
->glDescription
.glFormat
;
1064 mem
= This
->resource
.allocatedMemory
;
1065 bpp
= This
->bytesPerPixel
;
1071 int height
= This
->glRect
.bottom
- This
->glRect
.top
;
1072 type
= GL_UNSIGNED_BYTE
;
1075 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* sizeof(DWORD
));
1077 ERR("Out of memory\n");
1080 memory_allocated
= TRUE
;
1081 d3dfmt_convert_surface(This
->resource
.allocatedMemory
,
1089 bpp
= This
->bytesPerPixel
* 4;
1095 FIXME("Unsupported Format %u in locking func\n", This
->resource
.format
);
1098 type
= This
->glDescription
.glType
;
1099 fmt
= This
->glDescription
.glFormat
;
1100 mem
= This
->resource
.allocatedMemory
;
1101 bpp
= This
->bytesPerPixel
;
1104 if(This
->Flags
& SFLAG_PBO
) {
1105 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1106 checkGLcall("glBindBufferARB");
1109 glDrawPixels(This
->lockedRect
.right
- This
->lockedRect
.left
,
1110 (This
->lockedRect
.bottom
- This
->lockedRect
.top
)-1,
1112 mem
+ bpp
* This
->lockedRect
.left
+ pitch
* This
->lockedRect
.top
);
1113 checkGLcall("glDrawPixels");
1116 if(This
->Flags
& SFLAG_PBO
) {
1117 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1118 checkGLcall("glBindBufferARB");
1121 glPixelZoom(1.0,1.0);
1122 vcheckGLcall("glPixelZoom");
1124 glRasterPos3iv(&prev_rasterpos
[0]);
1125 vcheckGLcall("glRasterPos3iv");
1127 /* Reset to previous pack row length */
1128 glPixelStorei(GL_UNPACK_ROW_LENGTH
, skipBytes
);
1129 vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1131 glPixelStorei(GL_PACK_SWAP_BYTES
, prev_store
);
1132 vcheckGLcall("glPixelStorei GL_PACK_SWAP_BYTES");
1135 /* Blitting environment requires that 2D texturing is enabled. It was turned off before,
1138 glEnable(GL_TEXTURE_2D
);
1139 checkGLcall("glEnable(GL_TEXTURE_2D)");
1141 if(memory_allocated
) HeapFree(GetProcessHeap(), 0, mem
);
1144 glDrawBuffer(myDevice
->offscreenBuffer
);
1145 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1146 } else if(swapchain
->backBuffer
) {
1147 glDrawBuffer(GL_BACK
);
1148 checkGLcall("glDrawBuffer(GL_BACK)");
1150 glDrawBuffer(GL_FRONT
);
1151 checkGLcall("glDrawBuffer(GL_FRONT)");
1158 static HRESULT WINAPI
IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface
*iface
) {
1159 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1160 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1161 IWineD3DSwapChainImpl
*swapchain
= NULL
;
1164 if (!(This
->Flags
& SFLAG_LOCKED
)) {
1165 WARN("trying to Unlock an unlocked surf@%p\n", This
);
1166 return WINED3DERR_INVALIDCALL
;
1169 if (This
->Flags
& SFLAG_PBO
) {
1170 TRACE("Freeing PBO memory\n");
1171 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1173 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1174 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
1175 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1176 checkGLcall("glUnmapBufferARB");
1178 This
->resource
.allocatedMemory
= NULL
;
1181 TRACE("(%p) : dirtyfied(%d)\n", This
, This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
1183 if (This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
)) {
1184 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This
);
1188 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1189 if(swapchain
|| (myDevice
->render_targets
&& iface
== myDevice
->render_targets
[0])) {
1190 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
1191 static BOOL warned
= FALSE
;
1193 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1196 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
1200 if(This
->dirtyRect
.left
== 0 &&
1201 This
->dirtyRect
.top
== 0 &&
1202 This
->dirtyRect
.right
== This
->currentDesc
.Width
&&
1203 This
->dirtyRect
.bottom
== This
->currentDesc
.Height
) {
1206 /* TODO: Proper partial rectangle tracking */
1207 fullsurface
= FALSE
;
1208 This
->Flags
|= SFLAG_INSYSMEM
;
1211 switch(wined3d_settings
.rendertargetlock_mode
) {
1215 if (This
->glDescription
.textureName
== 0) {
1216 glGenTextures(1, &This
->glDescription
.textureName
);
1217 checkGLcall("glGenTextures");
1219 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
1220 checkGLcall("glBindTexture(GL_TEXTURE_2D, This->glDescription.textureName);");
1222 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* partial texture loading not supported yet */);
1228 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, fullsurface
? NULL
: &This
->dirtyRect
);
1233 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1234 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1235 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1236 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1237 * not fully up to date because only a subrectangle was read in LockRect.
1239 This
->Flags
&= ~SFLAG_INSYSMEM
;
1240 This
->Flags
|= SFLAG_INDRAWABLE
;
1243 This
->dirtyRect
.left
= This
->currentDesc
.Width
;
1244 This
->dirtyRect
.top
= This
->currentDesc
.Height
;
1245 This
->dirtyRect
.right
= 0;
1246 This
->dirtyRect
.bottom
= 0;
1247 } else if(iface
== myDevice
->stencilBufferTarget
) {
1248 FIXME("Depth Stencil buffer locking is not implemented\n");
1250 /* The rest should be a normal texture */
1251 IWineD3DBaseTextureImpl
*impl
;
1252 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1253 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1254 * states need resetting
1256 if(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&impl
) == WINED3D_OK
) {
1257 if(impl
->baseTexture
.bindCount
) {
1258 IWineD3DDeviceImpl_MarkStateDirty(myDevice
, STATE_SAMPLER(impl
->baseTexture
.sampler
));
1260 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*) impl
);
1265 This
->Flags
&= ~SFLAG_LOCKED
;
1266 memset(&This
->lockedRect
, 0, sizeof(RECT
));
1270 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
1271 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1272 WINED3DLOCKED_RECT lock
;
1276 TRACE("(%p)->(%p)\n",This
,pHDC
);
1278 if(This
->Flags
& SFLAG_USERPTR
) {
1279 ERR("Not supported on surfaces with an application-provided surfaces\n");
1280 return WINEDDERR_NODC
;
1283 /* Give more detailed info for ddraw */
1284 if (This
->Flags
& SFLAG_DCINUSE
)
1285 return WINEDDERR_DCALREADYCREATED
;
1287 /* Can't GetDC if the surface is locked */
1288 if (This
->Flags
& SFLAG_LOCKED
)
1289 return WINED3DERR_INVALIDCALL
;
1291 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
1293 /* Create a DIB section if there isn't a hdc yet */
1295 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
1296 if(This
->Flags
& SFLAG_CLIENT
) {
1297 IWineD3DSurface_PreLoad(iface
);
1300 /* Use the dib section from now on if we are not using a PBO */
1301 if(!(This
->Flags
& SFLAG_PBO
))
1302 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
1305 /* Lock the surface */
1306 hr
= IWineD3DSurface_LockRect(iface
,
1311 if(This
->Flags
& SFLAG_PBO
) {
1312 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1313 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, This
->dib
.bitmap_size
);
1317 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
1318 /* keep the dib section */
1322 if(This
->resource
.format
== WINED3DFMT_P8
||
1323 This
->resource
.format
== WINED3DFMT_A8P8
) {
1326 PALETTEENTRY ent
[256];
1328 GetPaletteEntries(This
->palette
->hpal
, 0, 256, ent
);
1329 for (n
=0; n
<256; n
++) {
1330 col
[n
].rgbRed
= ent
[n
].peRed
;
1331 col
[n
].rgbGreen
= ent
[n
].peGreen
;
1332 col
[n
].rgbBlue
= ent
[n
].peBlue
;
1333 col
[n
].rgbReserved
= 0;
1336 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1338 for (n
=0; n
<256; n
++) {
1339 col
[n
].rgbRed
= device
->palettes
[device
->currentPalette
][n
].peRed
;
1340 col
[n
].rgbGreen
= device
->palettes
[device
->currentPalette
][n
].peGreen
;
1341 col
[n
].rgbBlue
= device
->palettes
[device
->currentPalette
][n
].peBlue
;
1342 col
[n
].rgbReserved
= 0;
1346 SetDIBColorTable(This
->hDC
, 0, 256, col
);
1350 TRACE("returning %p\n",*pHDC
);
1351 This
->Flags
|= SFLAG_DCINUSE
;
1356 HRESULT WINAPI
IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
1357 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1359 TRACE("(%p)->(%p)\n",This
,hDC
);
1361 if (!(This
->Flags
& SFLAG_DCINUSE
))
1362 return WINED3DERR_INVALIDCALL
;
1364 if (This
->hDC
!=hDC
) {
1365 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
1366 return WINED3DERR_INVALIDCALL
;
1369 if((This
->Flags
& SFLAG_PBO
) && This
->resource
.allocatedMemory
) {
1370 /* Copy the contents of the DIB over to the PBO */
1371 memcpy(This
->resource
.allocatedMemory
, This
->dib
.bitmap_data
, This
->dib
.bitmap_size
);
1374 /* we locked first, so unlock now */
1375 IWineD3DSurface_UnlockRect(iface
);
1377 This
->Flags
&= ~SFLAG_DCINUSE
;
1382 /* ******************************************************
1383 IWineD3DSurface Internal (No mapping to directx api) parts follow
1384 ****************************************************** */
1386 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
) {
1387 BOOL colorkey_active
= need_alpha_ck
&& (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
);
1388 const GlPixelFormatDesc
*glDesc
;
1389 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1390 BOOL p8_render_target
= FALSE
;
1391 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
1393 /* Default values: From the surface */
1394 *format
= glDesc
->glFormat
;
1395 *internal
= srgb_mode
?glDesc
->glGammaInternal
:glDesc
->glInternal
;
1396 *type
= glDesc
->glType
;
1397 *convert
= NO_CONVERSION
;
1398 *target_bpp
= This
->bytesPerPixel
;
1400 /* Ok, now look if we have to do any conversion */
1401 switch(This
->resource
.format
) {
1407 if (device
->render_targets
&& device
->render_targets
[0]) {
1408 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
1409 if(render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
1410 p8_render_target
= TRUE
;
1413 /* Use conversion when the paletted texture extension is not available, or when it is available make sure it is used
1414 * for texturing as it won't work for calls like glDraw-/glReadPixels and further also use conversion in case of color keying.
1415 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which conflicts with this.
1417 if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE
) || (GL_SUPPORT(ARB_FRAGMENT_PROGRAM
) && p8_render_target
)) || colorkey_active
|| (!use_texturing
&& GL_SUPPORT(EXT_PALETTED_TEXTURE
)) ) {
1419 *internal
= GL_RGBA
;
1420 *type
= GL_UNSIGNED_BYTE
;
1422 if(colorkey_active
) {
1423 *convert
= CONVERT_PALETTED_CK
;
1425 *convert
= CONVERT_PALETTED
;
1428 else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
1430 *internal
= GL_RGBA
;
1431 *type
= GL_UNSIGNED_BYTE
;
1437 case WINED3DFMT_R3G3B2
:
1438 /* **********************
1439 GL_UNSIGNED_BYTE_3_3_2
1440 ********************** */
1441 if (colorkey_active
) {
1442 /* This texture format will never be used.. So do not care about color keying
1443 up until the point in time it will be needed :-) */
1444 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1448 case WINED3DFMT_R5G6B5
:
1449 if (colorkey_active
) {
1450 *convert
= CONVERT_CK_565
;
1452 *internal
= GL_RGBA
;
1453 *type
= GL_UNSIGNED_SHORT_5_5_5_1
;
1457 case WINED3DFMT_X1R5G5B5
:
1458 if (colorkey_active
) {
1459 *convert
= CONVERT_CK_5551
;
1461 *internal
= GL_RGBA
;
1462 *type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
1466 case WINED3DFMT_R8G8B8
:
1467 if (colorkey_active
) {
1468 *convert
= CONVERT_CK_RGB24
;
1470 *internal
= GL_RGBA
;
1471 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1476 case WINED3DFMT_X8R8G8B8
:
1477 if (colorkey_active
) {
1478 *convert
= CONVERT_RGB32_888
;
1480 *internal
= GL_RGBA
;
1481 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1485 case WINED3DFMT_V8U8
:
1486 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1487 else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1488 *format
= GL_DUDV_ATI
;
1489 *internal
= GL_DU8DV8_ATI
;
1491 /* No conversion - Just change the gl type */
1494 *convert
= CONVERT_V8U8
;
1496 *internal
= GL_RGB8
;
1497 *type
= GL_UNSIGNED_BYTE
;
1501 case WINED3DFMT_L6V5U5
:
1502 *convert
= CONVERT_L6V5U5
;
1503 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1505 /* Use format and types from table */
1507 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1510 *internal
= GL_RGB5
;
1511 *type
= GL_UNSIGNED_SHORT_5_6_5
;
1515 case WINED3DFMT_X8L8V8U8
:
1516 *convert
= CONVERT_X8L8V8U8
;
1518 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1519 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1520 * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1521 * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1522 * the needed type and format parameter, so the internal format contains a
1523 * 4th component, which is returned as alpha
1526 /* Not supported by GL_ATI_envmap_bumpmap */
1528 *internal
= GL_RGB8
;
1529 *type
= GL_UNSIGNED_INT_8_8_8_8_REV
;
1533 case WINED3DFMT_Q8W8V8U8
:
1534 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1535 *convert
= CONVERT_Q8W8V8U8
;
1537 *internal
= GL_RGBA8
;
1538 *type
= GL_UNSIGNED_BYTE
;
1540 /* Not supported by GL_ATI_envmap_bumpmap */
1543 case WINED3DFMT_V16U16
:
1544 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1545 *convert
= CONVERT_V16U16
;
1547 *internal
= GL_RGB16_EXT
;
1548 *type
= GL_UNSIGNED_SHORT
;
1550 /* What should I do here about GL_ATI_envmap_bumpmap?
1551 * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1555 case WINED3DFMT_A4L4
:
1556 /* A4L4 exists as an internal gl format, but for some reason there is not
1557 * format+type combination to load it. Thus convert it to A8L8, then load it
1558 * with A4L4 internal, but A8L8 format+type
1560 *convert
= CONVERT_A4L4
;
1561 *format
= GL_LUMINANCE_ALPHA
;
1562 *internal
= GL_LUMINANCE4_ALPHA4
;
1563 *type
= GL_UNSIGNED_BYTE
;
1567 case WINED3DFMT_R32F
:
1568 /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1569 * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1570 * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1573 * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1575 *convert
= CONVERT_R32F
;
1577 *internal
= GL_RGB32F_ARB
;
1582 case WINED3DFMT_R16F
:
1583 /* Similar to R32F */
1584 *convert
= CONVERT_R16F
;
1586 *internal
= GL_RGB16F_ARB
;
1587 *type
= GL_HALF_FLOAT_ARB
;
1598 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*This
) {
1599 BYTE
*source
, *dest
;
1600 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src
, dst
, pitch
, height
, outpitch
, convert
,This
);
1605 memcpy(dst
, src
, pitch
* height
);
1608 case CONVERT_PALETTED
:
1609 case CONVERT_PALETTED_CK
:
1611 IWineD3DPaletteImpl
* pal
= This
->palette
;
1616 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1619 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
1621 for (y
= 0; y
< height
; y
++)
1623 source
= src
+ pitch
* y
;
1624 dest
= dst
+ outpitch
* y
;
1625 /* This is an 1 bpp format, using the width here is fine */
1626 for (x
= 0; x
< width
; x
++) {
1627 BYTE color
= *source
++;
1628 *dest
++ = table
[color
][0];
1629 *dest
++ = table
[color
][1];
1630 *dest
++ = table
[color
][2];
1631 *dest
++ = table
[color
][3];
1637 case CONVERT_CK_565
:
1639 /* Converting the 565 format in 5551 packed to emulate color-keying.
1641 Note : in all these conversion, it would be best to average the averaging
1642 pixels to get the color of the pixel that will be color-keyed to
1643 prevent 'color bleeding'. This will be done later on if ever it is
1646 Note2: Nvidia documents say that their driver does not support alpha + color keying
1647 on the same surface and disables color keying in such a case
1653 TRACE("Color keyed 565\n");
1655 for (y
= 0; y
< height
; y
++) {
1656 Source
= (WORD
*) (src
+ y
* pitch
);
1657 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1658 for (x
= 0; x
< width
; x
++ ) {
1659 WORD color
= *Source
++;
1660 *Dest
= ((color
& 0xFFC0) | ((color
& 0x1F) << 1));
1661 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1662 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1671 case CONVERT_CK_5551
:
1673 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1677 TRACE("Color keyed 5551\n");
1678 for (y
= 0; y
< height
; y
++) {
1679 Source
= (WORD
*) (src
+ y
* pitch
);
1680 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1681 for (x
= 0; x
< width
; x
++ ) {
1682 WORD color
= *Source
++;
1684 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1685 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1689 *Dest
&= ~(1 << 15);
1701 unsigned char *Dest
;
1702 for(y
= 0; y
< height
; y
++) {
1703 Source
= (short *) (src
+ y
* pitch
);
1704 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1705 for (x
= 0; x
< width
; x
++ ) {
1706 long color
= (*Source
++);
1707 /* B */ Dest
[0] = 0xff;
1708 /* G */ Dest
[1] = (color
>> 8) + 128; /* V */
1709 /* R */ Dest
[2] = (color
) + 128; /* U */
1716 case CONVERT_V16U16
:
1720 unsigned short *Dest
;
1721 for(y
= 0; y
< height
; y
++) {
1722 Source
= (DWORD
*) (src
+ y
* pitch
);
1723 Dest
= (unsigned short *) (dst
+ y
* outpitch
);
1724 for (x
= 0; x
< width
; x
++ ) {
1725 DWORD color
= (*Source
++);
1726 /* B */ Dest
[0] = 0xffff;
1727 /* G */ Dest
[1] = (color
>> 16) + 32768; /* V */
1728 /* R */ Dest
[2] = (color
) + 32768; /* U */
1735 case CONVERT_Q8W8V8U8
:
1739 unsigned char *Dest
;
1740 for(y
= 0; y
< height
; y
++) {
1741 Source
= (DWORD
*) (src
+ y
* pitch
);
1742 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1743 for (x
= 0; x
< width
; x
++ ) {
1744 long color
= (*Source
++);
1745 /* B */ Dest
[0] = ((color
>> 16) & 0xff) + 128; /* W */
1746 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1747 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1748 /* A */ Dest
[3] = ((color
>> 24) & 0xff) + 128; /* Q */
1755 case CONVERT_L6V5U5
:
1759 unsigned char *Dest
;
1761 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1762 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1763 * fixed function and shaders without further conversion once the surface is
1766 for(y
= 0; y
< height
; y
++) {
1767 Source
= (WORD
*) (src
+ y
* pitch
);
1768 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1769 for (x
= 0; x
< width
; x
++ ) {
1770 short color
= (*Source
++);
1771 unsigned char l
= ((color
>> 10) & 0xfc);
1772 char v
= ((color
>> 5) & 0x3e);
1773 char u
= ((color
) & 0x1f);
1775 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1776 * and doubles the positive range. Thus shift left only once, gl does the 2nd
1777 * shift. GL reads a signed value and converts it into an unsigned value.
1779 /* M */ Dest
[2] = l
<< 1;
1781 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1782 * from 5 bit values to 8 bit values.
1784 /* V */ Dest
[1] = v
<< 3;
1785 /* U */ Dest
[0] = u
<< 3;
1790 for(y
= 0; y
< height
; y
++) {
1791 unsigned short *Dest_s
= (unsigned short *) (dst
+ y
* outpitch
);
1792 Source
= (WORD
*) (src
+ y
* pitch
);
1793 for (x
= 0; x
< width
; x
++ ) {
1794 short color
= (*Source
++);
1795 unsigned char l
= ((color
>> 10) & 0xfc);
1796 short v
= ((color
>> 5) & 0x3e);
1797 short u
= ((color
) & 0x1f);
1798 short v_conv
= v
+ 16;
1799 short u_conv
= u
+ 16;
1801 *Dest_s
= ((v_conv
<< 11) & 0xf800) | ((l
<< 5) & 0x7e0) | (u_conv
& 0x1f);
1809 case CONVERT_X8L8V8U8
:
1813 unsigned char *Dest
;
1815 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1816 /* This implementation works with the fixed function pipeline and shaders
1817 * without further modification after converting the surface.
1819 for(y
= 0; y
< height
; y
++) {
1820 Source
= (DWORD
*) (src
+ y
* pitch
);
1821 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1822 for (x
= 0; x
< width
; x
++ ) {
1823 long color
= (*Source
++);
1824 /* L */ Dest
[2] = ((color
>> 16) & 0xff); /* L */
1825 /* V */ Dest
[1] = ((color
>> 8 ) & 0xff); /* V */
1826 /* U */ Dest
[0] = (color
& 0xff); /* U */
1827 /* I */ Dest
[3] = 255; /* X */
1832 /* Doesn't work correctly with the fixed function pipeline, but can work in
1833 * shaders if the shader is adjusted. (There's no use for this format in gl's
1834 * standard fixed function pipeline anyway).
1836 for(y
= 0; y
< height
; y
++) {
1837 Source
= (DWORD
*) (src
+ y
* pitch
);
1838 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1839 for (x
= 0; x
< width
; x
++ ) {
1840 long color
= (*Source
++);
1841 /* B */ Dest
[0] = ((color
>> 16) & 0xff); /* L */
1842 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1843 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1854 unsigned char *Source
;
1855 unsigned char *Dest
;
1856 for(y
= 0; y
< height
; y
++) {
1857 Source
= (unsigned char *) (src
+ y
* pitch
);
1858 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1859 for (x
= 0; x
< width
; x
++ ) {
1860 unsigned char color
= (*Source
++);
1861 /* A */ Dest
[1] = (color
& 0xf0) << 0;
1862 /* L */ Dest
[0] = (color
& 0x0f) << 4;
1874 for(y
= 0; y
< height
; y
++) {
1875 Source
= (float *) (src
+ y
* pitch
);
1876 Dest
= (float *) (dst
+ y
* outpitch
);
1877 for (x
= 0; x
< width
; x
++ ) {
1878 float color
= (*Source
++);
1894 for(y
= 0; y
< height
; y
++) {
1895 Source
= (WORD
*) (src
+ y
* pitch
);
1896 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1897 for (x
= 0; x
< width
; x
++ ) {
1898 WORD color
= (*Source
++);
1908 ERR("Unsupported conversation type %d\n", convert
);
1913 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
) {
1914 IWineD3DPaletteImpl
* pal
= This
->palette
;
1915 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1916 BOOL index_in_alpha
= FALSE
;
1919 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
1920 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
1921 * is slow. Further RGB->P8 conversion is not possible because palettes can have
1922 * duplicate entries. Store the color key in the unused alpha component to speed the
1923 * download up and to make conversion unneeded. */
1924 if (device
->render_targets
&& device
->render_targets
[0]) {
1925 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
1927 if(render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
1928 index_in_alpha
= TRUE
;
1932 /* Still no palette? Use the device's palette */
1933 /* Get the surface's palette */
1934 for (i
= 0; i
< 256; i
++) {
1935 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
1936 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
1937 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
1939 if(index_in_alpha
) {
1941 } else if (colorkey
&&
1942 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1943 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1944 /* We should maybe here put a more 'neutral' color than the standard bright purple
1945 one often used by application to prevent the nice purple borders when bi-linear
1953 TRACE("Using surface palette %p\n", pal
);
1954 /* Get the surface's palette */
1955 for (i
= 0; i
< 256; i
++) {
1956 table
[i
][0] = pal
->palents
[i
].peRed
;
1957 table
[i
][1] = pal
->palents
[i
].peGreen
;
1958 table
[i
][2] = pal
->palents
[i
].peBlue
;
1960 if(index_in_alpha
) {
1963 else if (colorkey
&&
1964 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1965 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1966 /* We should maybe here put a more 'neutral' color than the standard bright purple
1967 one often used by application to prevent the nice purple borders when bi-linear
1970 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
1971 table
[i
][3] = pal
->palents
[i
].peFlags
;
1979 const char *fragment_palette_conversion
=
1982 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n" /* { 255/256, 0.5/255*255/256, 0, 0 } */
1983 "TEX index.x, fragment.texcoord[0], texture[0], 2D;\n" /* store the red-component of the current pixel */
1984 "MAD index.x, index.x, constants.x, constants.y;\n" /* Scale the index by 255/256 and add a bias of '0.5' in order to sample in the middle */
1985 "TEX result.color, index, texture[1], 1D;\n" /* use the red-component as a index in the palette to get the final color */
1988 /* This function is used in case of 8bit paletted textures to upload the palette.
1989 It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
1990 extensions like ATI_fragment_shaders is possible.
1992 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
) {
1993 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1995 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1997 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
1999 /* Try to use the paletted texture extension */
2000 if(GL_SUPPORT(EXT_PALETTED_TEXTURE
))
2002 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2003 GL_EXTCALL(glColorTableEXT(GL_TEXTURE_2D
,GL_RGBA
,256,GL_RGBA
,GL_UNSIGNED_BYTE
, table
));
2007 /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2008 * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2009 TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2011 /* Create the fragment program if we don't have it */
2012 if(!device
->paletteConversionShader
)
2014 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2015 GL_EXTCALL(glGenProgramsARB(1, &device
->paletteConversionShader
));
2016 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2017 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
, strlen(fragment_palette_conversion
), (const GLbyte
*)fragment_palette_conversion
));
2018 glDisable(GL_FRAGMENT_PROGRAM_ARB
);
2021 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2022 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2024 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1
));
2025 glEnable(GL_TEXTURE_1D
);
2026 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
2028 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2029 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
); /* Make sure we have discrete color levels. */
2030 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
2031 glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA
, 256, 0, GL_RGBA
, GL_UNSIGNED_BYTE
, table
); /* Upload the palette */
2033 /* Switch back to unit 0 in which the 2D texture will be stored. */
2034 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0
));
2036 /* Rebind the texture because it isn't bound anymore */
2037 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2041 static BOOL
palette9_changed(IWineD3DSurfaceImpl
*This
) {
2042 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2044 if(This
->palette
|| (This
->resource
.format
!= WINED3DFMT_P8
&& This
->resource
.format
!= WINED3DFMT_A8P8
)) {
2045 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2046 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2051 if(This
->palette9
) {
2052 if(memcmp(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256) == 0) {
2056 This
->palette9
= HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY
) * 256);
2058 memcpy(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256);
2062 static inline void clear_unused_channels(IWineD3DSurfaceImpl
*This
) {
2063 GLboolean oldwrite
[4];
2065 /* Some formats have only some color channels, and the others are 1.0.
2066 * since our rendering renders to all channels, and those pixel formats
2067 * are emulated by using a full texture with the other channels set to 1.0
2068 * manually, clear the unused channels.
2070 * This could be done with hacking colorwriteenable to mask the colors,
2071 * but before drawing the buffer would have to be cleared too, so there's
2074 switch(This
->resource
.format
) {
2075 case WINED3DFMT_R16F
:
2076 case WINED3DFMT_R32F
:
2077 TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2078 /* Do not activate a context, the correct drawable is active already
2079 * though just the read buffer is set, make sure to have the correct draw
2082 glDrawBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
2083 glDisable(GL_SCISSOR_TEST
);
2084 glGetBooleanv(GL_COLOR_WRITEMASK
, oldwrite
);
2085 glColorMask(GL_FALSE
, GL_TRUE
, GL_TRUE
, GL_TRUE
);
2086 glClearColor(0.0, 1.0, 1.0, 1.0);
2087 glClear(GL_COLOR_BUFFER_BIT
);
2088 glColorMask(oldwrite
[0], oldwrite
[1], oldwrite
[2], oldwrite
[3]);
2089 if(!This
->resource
.wineD3DDevice
->render_offscreen
) glDrawBuffer(GL_BACK
);
2090 checkGLcall("Unused channel clear\n");
2097 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
) {
2098 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2100 if (!(This
->Flags
& SFLAG_INTEXTURE
)) {
2101 TRACE("Reloading because surface is dirty\n");
2102 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2103 ((This
->Flags
& SFLAG_GLCKEY
) && (!(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
))) ||
2104 /* Reload: vice versa OR */
2105 ((!(This
->Flags
& SFLAG_GLCKEY
)) && (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
)) ||
2106 /* Also reload: Color key is active AND the color key has changed */
2107 ((This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) && (
2108 (This
->glCKey
.dwColorSpaceLowValue
!= This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
2109 (This
->glCKey
.dwColorSpaceHighValue
!= This
->SrcBltCKey
.dwColorSpaceHighValue
)))) {
2110 TRACE("Reloading because of color keying\n");
2111 /* To perform the color key conversion we need a sysmem copy of
2112 * the surface. Make sure we have it
2114 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2115 } else if(palette9_changed(This
)) {
2116 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
2117 /* TODO: This is not necessarily needed with hw palettized texture support */
2118 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2120 TRACE("surface is already in texture\n");
2124 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2125 * These resources are not bound by device size or format restrictions. Because of this,
2126 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2127 * However, these resources can always be created, locked, and copied.
2129 if (This
->resource
.pool
== WINED3DPOOL_SCRATCH
)
2131 FIXME("(%p) Operation not supported for scratch textures\n",This
);
2132 return WINED3DERR_INVALIDCALL
;
2135 This
->srgb
= srgb_mode
;
2136 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* no partial locking for textures yet */);
2140 static unsigned int gen
= 0;
2143 if ((gen
% 10) == 0) {
2144 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
2145 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
2148 * debugging crash code
2157 if (!(This
->Flags
& SFLAG_DONOTFREE
)) {
2158 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
2159 This
->resource
.allocatedMemory
= NULL
;
2160 This
->resource
.heapMemory
= NULL
;
2161 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, FALSE
);
2169 HRESULT WINAPI
IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
, const char* filename
) {
2172 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2173 char *allocatedMemory
;
2175 IWineD3DSwapChain
*swapChain
= NULL
;
2177 GLuint tmpTexture
= 0;
2180 Textures may not be stored in ->allocatedgMemory and a GlTexture
2181 so we should lock the surface before saving a snapshot, or at least check that
2183 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2184 by calling GetTexImage and in compressed form by calling
2185 GetCompressedTexImageARB. Queried compressed images can be saved and
2186 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2187 texture images do not need to be processed by the GL and should
2188 significantly improve texture loading performance relative to uncompressed
2191 /* Setup the width and height to be the internal texture width and height. */
2192 width
= This
->pow2Width
;
2193 height
= This
->pow2Height
;
2194 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2195 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapChain
);
2197 if (This
->Flags
& SFLAG_INDRAWABLE
&& !(This
->Flags
& SFLAG_INTEXTURE
)) {
2198 /* if were not a real texture then read the back buffer into a real texture */
2199 /* we don't want to interfere with the back buffer so read the data into a temporary
2200 * texture and then save the data out of the temporary texture
2204 TRACE("(%p) Reading render target into texture\n", This
);
2205 glEnable(GL_TEXTURE_2D
);
2207 glGenTextures(1, &tmpTexture
);
2208 glBindTexture(GL_TEXTURE_2D
, tmpTexture
);
2210 glTexImage2D(GL_TEXTURE_2D
,
2217 GL_UNSIGNED_INT_8_8_8_8_REV
,
2220 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
2221 vcheckGLcall("glGetIntegerv");
2222 glReadBuffer(swapChain
? GL_BACK
: This
->resource
.wineD3DDevice
->offscreenBuffer
);
2223 vcheckGLcall("glReadBuffer");
2224 glCopyTexImage2D(GL_TEXTURE_2D
,
2233 checkGLcall("glCopyTexImage2D");
2234 glReadBuffer(prevRead
);
2237 } else { /* bind the real texture, and make sure it up to date */
2238 IWineD3DSurface_PreLoad(iface
);
2240 allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, width
* height
* 4);
2242 FIXME("Saving texture level %d width %d height %d\n", This
->glDescription
.level
, width
, height
);
2243 glGetTexImage(GL_TEXTURE_2D
,
2244 This
->glDescription
.level
,
2246 GL_UNSIGNED_INT_8_8_8_8_REV
,
2248 checkGLcall("glTexImage2D");
2250 glBindTexture(GL_TEXTURE_2D
, 0);
2251 glDeleteTextures(1, &tmpTexture
);
2255 f
= fopen(filename
, "w+");
2257 ERR("opening of %s failed with: %s\n", filename
, strerror(errno
));
2258 return WINED3DERR_INVALIDCALL
;
2260 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2261 TRACE("(%p) opened %s with format %s\n", This
, filename
, debug_d3dformat(This
->resource
.format
));
2276 fwrite(&width
,2,1,f
);
2278 fwrite(&height
,2,1,f
);
2283 /* 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 */
2285 textureRow
= allocatedMemory
+ (width
* (height
- 1) *4);
2287 textureRow
= allocatedMemory
;
2288 for (y
= 0 ; y
< height
; y
++) {
2289 for (i
= 0; i
< width
; i
++) {
2290 color
= *((DWORD
*)textureRow
);
2291 fputc((color
>> 16) & 0xFF, f
); /* B */
2292 fputc((color
>> 8) & 0xFF, f
); /* G */
2293 fputc((color
>> 0) & 0xFF, f
); /* R */
2294 fputc((color
>> 24) & 0xFF, f
); /* A */
2297 /* take two rows of the pointer to the texture memory */
2299 (textureRow
-= width
<< 3);
2302 TRACE("Closing file\n");
2306 IWineD3DSwapChain_Release(swapChain
);
2308 HeapFree(GetProcessHeap(), 0, allocatedMemory
);
2313 * Slightly inefficient way to handle multiple dirty rects but it works :)
2315 extern HRESULT WINAPI
IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
2316 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2317 IWineD3DBaseTexture
*baseTexture
= NULL
;
2319 if (!(This
->Flags
& SFLAG_INSYSMEM
) && (This
->Flags
& SFLAG_INTEXTURE
))
2320 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
2322 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2323 if (NULL
!= pDirtyRect
) {
2324 This
->dirtyRect
.left
= min(This
->dirtyRect
.left
, pDirtyRect
->left
);
2325 This
->dirtyRect
.top
= min(This
->dirtyRect
.top
, pDirtyRect
->top
);
2326 This
->dirtyRect
.right
= max(This
->dirtyRect
.right
, pDirtyRect
->right
);
2327 This
->dirtyRect
.bottom
= max(This
->dirtyRect
.bottom
, pDirtyRect
->bottom
);
2329 This
->dirtyRect
.left
= 0;
2330 This
->dirtyRect
.top
= 0;
2331 This
->dirtyRect
.right
= This
->currentDesc
.Width
;
2332 This
->dirtyRect
.bottom
= This
->currentDesc
.Height
;
2334 TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This
, This
->dirtyRect
.left
,
2335 This
->dirtyRect
.top
, This
->dirtyRect
.right
, This
->dirtyRect
.bottom
);
2336 /* if the container is a basetexture then mark it dirty. */
2337 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2338 TRACE("Passing to container\n");
2339 IWineD3DBaseTexture_SetDirty(baseTexture
, TRUE
);
2340 IWineD3DBaseTexture_Release(baseTexture
);
2345 HRESULT WINAPI
IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
2346 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2348 const GlPixelFormatDesc
*glDesc
;
2349 getFormatDescEntry(format
, &GLINFO_LOCATION
, &glDesc
);
2351 TRACE("(%p) : Calling base function first\n", This
);
2352 hr
= IWineD3DBaseSurfaceImpl_SetFormat(iface
, format
);
2354 /* Setup some glformat defaults */
2355 This
->glDescription
.glFormat
= glDesc
->glFormat
;
2356 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
2357 This
->glDescription
.glType
= glDesc
->glType
;
2359 This
->Flags
&= ~SFLAG_ALLOCATED
;
2360 TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This
,
2361 This
->glDescription
.glFormat
, This
->glDescription
.glFormatInternal
, This
->glDescription
.glType
);
2366 HRESULT WINAPI
IWineD3DSurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
2367 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
2369 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
2370 WARN("Surface is locked or the HDC is in use\n");
2371 return WINED3DERR_INVALIDCALL
;
2374 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
2375 void *release
= NULL
;
2377 /* Do I have to copy the old surface content? */
2378 if(This
->Flags
& SFLAG_DIBSECTION
) {
2379 /* Release the DC. No need to hold the critical section for the update
2380 * Thread because this thread runs only on front buffers, but this method
2381 * fails for render targets in the check above.
2383 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
2384 DeleteDC(This
->hDC
);
2385 /* Release the DIB section */
2386 DeleteObject(This
->dib
.DIBsection
);
2387 This
->dib
.bitmap_data
= NULL
;
2388 This
->resource
.allocatedMemory
= NULL
;
2390 This
->Flags
&= ~SFLAG_DIBSECTION
;
2391 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
2392 release
= This
->resource
.heapMemory
;
2393 This
->resource
.heapMemory
= NULL
;
2395 This
->resource
.allocatedMemory
= Mem
;
2396 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
2398 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2399 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2401 /* For client textures opengl has to be notified */
2402 if(This
->Flags
& SFLAG_CLIENT
) {
2403 This
->Flags
&= ~SFLAG_ALLOCATED
;
2404 IWineD3DSurface_PreLoad(iface
);
2405 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2408 /* Now free the old memory if any */
2409 HeapFree(GetProcessHeap(), 0, release
);
2410 } else if(This
->Flags
& SFLAG_USERPTR
) {
2411 /* Lockrect and GetDC will re-create the dib section and allocated memory */
2412 This
->resource
.allocatedMemory
= NULL
;
2413 /* HeapMemory should be NULL already */
2414 if(This
->resource
.heapMemory
!= NULL
) ERR("User pointer surface has heap memory allocated\n");
2415 This
->Flags
&= ~SFLAG_USERPTR
;
2417 if(This
->Flags
& SFLAG_CLIENT
) {
2418 This
->Flags
&= ~SFLAG_ALLOCATED
;
2419 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2420 IWineD3DSurface_PreLoad(iface
);
2426 static HRESULT WINAPI
IWineD3DSurfaceImpl_Flip(IWineD3DSurface
*iface
, IWineD3DSurface
*override
, DWORD Flags
) {
2427 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2428 IWineD3DSwapChainImpl
*swapchain
= NULL
;
2430 TRACE("(%p)->(%p,%x)\n", This
, override
, Flags
);
2432 /* Flipping is only supported on RenderTargets */
2433 if( !(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ) return WINEDDERR_NOTFLIPPABLE
;
2436 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2437 * FIXME("(%p) Target override is not supported by now\n", This);
2438 * Additionally, it isn't really possible to support triple-buffering
2439 * properly on opengl at all
2443 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
2445 ERR("Flipped surface is not on a swapchain\n");
2446 return WINEDDERR_NOTFLIPPABLE
;
2449 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2450 * and only d3d8 and d3d9 apps specify the presentation interval
2452 if((Flags
& (WINEDDFLIP_NOVSYNC
| WINEDDFLIP_INTERVAL2
| WINEDDFLIP_INTERVAL3
| WINEDDFLIP_INTERVAL4
)) == 0) {
2453 /* Most common case first to avoid wasting time on all the other cases */
2454 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_ONE
;
2455 } else if(Flags
& WINEDDFLIP_NOVSYNC
) {
2456 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2457 } else if(Flags
& WINEDDFLIP_INTERVAL2
) {
2458 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_TWO
;
2459 } else if(Flags
& WINEDDFLIP_INTERVAL3
) {
2460 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_THREE
;
2462 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_FOUR
;
2465 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2466 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
2467 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
2471 /* Does a direct frame buffer -> texture copy. Stretching is done
2472 * with single pixel copy calls
2474 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2475 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2478 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2481 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2483 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2485 /* Bind the target texture */
2486 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
2487 checkGLcall("glBindTexture");
2489 glReadBuffer(myDevice
->offscreenBuffer
);
2491 GLenum buffer
= surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
);
2492 glReadBuffer(buffer
);
2494 checkGLcall("glReadBuffer");
2496 xrel
= (float) (srect
->x2
- srect
->x1
) / (float) (drect
->x2
- drect
->x1
);
2497 yrel
= (float) (srect
->y2
- srect
->y1
) / (float) (drect
->y2
- drect
->y1
);
2499 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2500 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2502 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
2503 ERR("Texture filtering not supported in direct blit\n");
2505 } else if((Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) && ((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2506 ERR("Texture filtering not supported in direct blit\n");
2510 !((xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) &&
2511 !((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2512 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2514 glCopyTexSubImage2D(This
->glDescription
.target
,
2515 This
->glDescription
.level
,
2516 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2517 srect
->x1
, Src
->currentDesc
.Height
- srect
->y2
,
2518 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2520 UINT yoffset
= Src
->currentDesc
.Height
- srect
->y1
+ drect
->y1
- 1;
2521 /* I have to process this row by row to swap the image,
2522 * otherwise it would be upside down, so stretching in y direction
2523 * doesn't cost extra time
2525 * However, stretching in x direction can be avoided if not necessary
2527 for(row
= drect
->y1
; row
< drect
->y2
; row
++) {
2528 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2529 /* Well, that stuff works, but it's very slow.
2530 * find a better way instead
2534 for(col
= drect
->x1
; col
< drect
->x2
; col
++) {
2535 glCopyTexSubImage2D(This
->glDescription
.target
,
2536 This
->glDescription
.level
,
2537 drect
->x1
+ col
, row
, /* xoffset, yoffset */
2538 srect
->x1
+ col
* xrel
, yoffset
- (int) (row
* yrel
),
2542 glCopyTexSubImage2D(This
->glDescription
.target
,
2543 This
->glDescription
.level
,
2544 drect
->x1
, row
, /* xoffset, yoffset */
2545 srect
->x1
, yoffset
- (int) (row
* yrel
),
2546 drect
->x2
-drect
->x1
, 1);
2551 vcheckGLcall("glCopyTexSubImage2D");
2555 /* Uses the hardware to stretch and flip the image */
2556 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2557 GLuint src
, backup
= 0;
2558 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2559 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2560 float left
, right
, top
, bottom
; /* Texture coordinates */
2561 UINT fbwidth
= Src
->currentDesc
.Width
;
2562 UINT fbheight
= Src
->currentDesc
.Height
;
2563 GLenum drawBuffer
= GL_BACK
;
2565 TRACE("Using hwstretch blit\n");
2566 /* Activate the Proper context for reading from the source surface, set it up for blitting */
2567 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2569 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2571 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2572 * This way we don't have to wait for the 2nd readback to finish to leave this function.
2574 if(GL_LIMITS(aux_buffers
) >= 2) {
2575 /* Got more than one aux buffer? Use the 2nd aux buffer */
2576 drawBuffer
= GL_AUX1
;
2577 } else if((swapchain
|| myDevice
->offscreenBuffer
== GL_BACK
) && GL_LIMITS(aux_buffers
) >= 1) {
2578 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2579 drawBuffer
= GL_AUX0
;
2582 if(!swapchain
&& wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
2583 glGenTextures(1, &backup
);
2584 checkGLcall("glGenTextures\n");
2585 glBindTexture(GL_TEXTURE_2D
, backup
);
2586 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2588 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2589 * we are reading from the back buffer, the backup can be used as source texture
2591 if(Src
->glDescription
.textureName
== 0) {
2592 /* Get it a description */
2593 IWineD3DSurface_PreLoad(SrcSurface
);
2595 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
2596 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2598 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2599 Src
->Flags
&= ~SFLAG_INTEXTURE
;
2602 glReadBuffer(GL_BACK
);
2603 checkGLcall("glReadBuffer(GL_BACK)");
2605 /* TODO: Only back up the part that will be overwritten */
2606 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2607 0, 0 /* read offsets */,
2612 checkGLcall("glCopyTexSubImage2D");
2614 /* No issue with overriding these - the sampler is dirty due to blit usage */
2615 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
2616 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
2617 checkGLcall("glTexParameteri");
2618 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
2619 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2620 checkGLcall("glTexParameteri");
2622 if(!swapchain
|| (IWineD3DSurface
*) Src
== swapchain
->backBuffer
[0]) {
2623 src
= backup
? backup
: Src
->glDescription
.textureName
;
2625 glReadBuffer(GL_FRONT
);
2626 checkGLcall("glReadBuffer(GL_FRONT)");
2628 glGenTextures(1, &src
);
2629 checkGLcall("glGenTextures(1, &src)");
2630 glBindTexture(GL_TEXTURE_2D
, src
);
2631 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2633 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2634 * out for power of 2 sizes
2636 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, Src
->pow2Width
, Src
->pow2Height
, 0,
2637 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
2638 checkGLcall("glTexImage2D");
2639 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2640 0, 0 /* read offsets */,
2645 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2646 checkGLcall("glTexParameteri");
2647 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2648 checkGLcall("glTexParameteri");
2650 glReadBuffer(GL_BACK
);
2651 checkGLcall("glReadBuffer(GL_BACK)");
2653 checkGLcall("glEnd and previous");
2655 left
= (float) srect
->x1
/ (float) Src
->pow2Width
;
2656 right
= (float) srect
->x2
/ (float) Src
->pow2Width
;
2659 top
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2660 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2662 top
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2663 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2666 /* draw the source texture stretched and upside down. The correct surface is bound already */
2667 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
2668 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
2670 glDrawBuffer(drawBuffer
);
2671 glReadBuffer(drawBuffer
);
2675 glTexCoord2f(left
, bottom
);
2676 glVertex2i(0, fbheight
);
2679 glTexCoord2f(left
, top
);
2680 glVertex2i(0, fbheight
- drect
->y2
- drect
->y1
);
2683 glTexCoord2f(right
, top
);
2684 glVertex2i(drect
->x2
- drect
->x1
, fbheight
- drect
->y2
- drect
->y1
);
2687 glTexCoord2f(right
, bottom
);
2688 glVertex2i(drect
->x2
- drect
->x1
, fbheight
);
2690 checkGLcall("glEnd and previous");
2692 /* Now read the stretched and upside down image into the destination texture */
2693 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2694 checkGLcall("glBindTexture");
2695 glCopyTexSubImage2D(This
->glDescription
.target
,
2697 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2698 0, 0, /* We blitted the image to the origin */
2699 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2700 checkGLcall("glCopyTexSubImage2D");
2702 /* Write the back buffer backup back */
2703 glBindTexture(GL_TEXTURE_2D
, backup
? backup
: Src
->glDescription
.textureName
);
2704 checkGLcall("glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName)");
2706 if(drawBuffer
== GL_BACK
) {
2709 glTexCoord2f(0.0, (float) fbheight
/ (float) Src
->pow2Height
);
2713 glTexCoord2f(0.0, 0.0);
2714 glVertex2i(0, fbheight
);
2717 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, 0.0);
2718 glVertex2i(fbwidth
, Src
->currentDesc
.Height
);
2721 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, (float) fbheight
/ (float) Src
->pow2Height
);
2722 glVertex2i(fbwidth
, 0);
2725 /* Restore the old draw buffer */
2726 glDrawBuffer(GL_BACK
);
2730 if(src
!= Src
->glDescription
.textureName
&& src
!= backup
) {
2731 glDeleteTextures(1, &src
);
2732 checkGLcall("glDeleteTextures(1, &src)");
2735 glDeleteTextures(1, &backup
);
2736 checkGLcall("glDeleteTextures(1, &backup)");
2741 /* Not called from the VTable */
2742 static HRESULT
IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
2744 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2745 IWineD3DSwapChainImpl
*srcSwapchain
= NULL
, *dstSwapchain
= NULL
;
2746 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2748 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
2750 /* Get the swapchain. One of the surfaces has to be a primary surface */
2751 if(This
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
2752 WARN("Destination is in sysmem, rejecting gl blt\n");
2753 return WINED3DERR_INVALIDCALL
;
2755 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&dstSwapchain
);
2756 if(dstSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) dstSwapchain
);
2758 if(Src
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
2759 WARN("Src is in sysmem, rejecting gl blt\n");
2760 return WINED3DERR_INVALIDCALL
;
2762 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) Src
, &IID_IWineD3DSwapChain
, (void **)&srcSwapchain
);
2763 if(srcSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) srcSwapchain
);
2766 /* Early sort out of cases where no render target is used */
2767 if(!dstSwapchain
&& !srcSwapchain
&&
2768 SrcSurface
!= myDevice
->render_targets
[0] && This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
2769 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src
, This
);
2770 return WINED3DERR_INVALIDCALL
;
2773 /* No destination color keying supported */
2774 if(Flags
& (WINEDDBLT_KEYDEST
| WINEDDBLT_KEYDESTOVERRIDE
)) {
2775 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
2776 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
2777 return WINED3DERR_INVALIDCALL
;
2781 rect
.x1
= DestRect
->left
;
2782 rect
.y1
= DestRect
->top
;
2783 rect
.x2
= DestRect
->right
;
2784 rect
.y2
= DestRect
->bottom
;
2788 rect
.x2
= This
->currentDesc
.Width
;
2789 rect
.y2
= This
->currentDesc
.Height
;
2792 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
2793 if(dstSwapchain
&& dstSwapchain
== srcSwapchain
&& dstSwapchain
->backBuffer
&&
2794 ((IWineD3DSurface
*) This
== dstSwapchain
->frontBuffer
) && SrcSurface
== dstSwapchain
->backBuffer
[0]) {
2795 /* Half-life does a Blt from the back buffer to the front buffer,
2796 * Full surface size, no flags... Use present instead
2798 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
2801 /* Check rects - IWineD3DDevice_Present doesn't handle them */
2805 TRACE("Looking if a Present can be done...\n");
2806 /* Source Rectangle must be full surface */
2808 if(SrcRect
->left
!= 0 || SrcRect
->top
!= 0 ||
2809 SrcRect
->right
!= Src
->currentDesc
.Width
|| SrcRect
->bottom
!= Src
->currentDesc
.Height
) {
2810 TRACE("No, Source rectangle doesn't match\n");
2816 mySrcRect
.right
= Src
->currentDesc
.Width
;
2817 mySrcRect
.bottom
= Src
->currentDesc
.Height
;
2819 /* No stretching may occur */
2820 if(mySrcRect
.right
!= rect
.x2
- rect
.x1
||
2821 mySrcRect
.bottom
!= rect
.y2
- rect
.y1
) {
2822 TRACE("No, stretching is done\n");
2826 /* Destination must be full surface or match the clipping rectangle */
2827 if(This
->clipper
&& ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
)
2831 GetClientRect(((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
, &cliprect
);
2836 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
,
2839 if(pos
[0].x
!= cliprect
.left
|| pos
[0].y
!= cliprect
.top
||
2840 pos
[1].x
!= cliprect
.right
|| pos
[1].y
!= cliprect
.bottom
)
2842 TRACE("No, dest rectangle doesn't match(clipper)\n");
2843 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect
.left
, cliprect
.top
, cliprect
.right
, cliprect
.bottom
);
2844 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect
.x1
, rect
.y1
, rect
.x2
, rect
.y2
);
2850 if(rect
.x1
!= 0 || rect
.y1
!= 0 ||
2851 rect
.x2
!= This
->currentDesc
.Width
|| rect
.y2
!= This
->currentDesc
.Height
) {
2852 TRACE("No, dest rectangle doesn't match(surface size)\n");
2859 /* These flags are unimportant for the flag check, remove them */
2860 if((Flags
& ~(WINEDDBLT_DONOTWAIT
| WINEDDBLT_WAIT
)) == 0) {
2861 WINED3DSWAPEFFECT orig_swap
= dstSwapchain
->presentParms
.SwapEffect
;
2863 /* The idea behind this is that a glReadPixels and a glDrawPixels call
2864 * take very long, while a flip is fast.
2865 * This applies to Half-Life, which does such Blts every time it finished
2866 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
2867 * menu. This is also used by all apps when they do windowed rendering
2869 * The problem is that flipping is not really the same as copying. After a
2870 * Blt the front buffer is a copy of the back buffer, and the back buffer is
2871 * untouched. Therefore it's necessary to override the swap effect
2872 * and to set it back after the flip.
2874 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
2878 dstSwapchain
->presentParms
.SwapEffect
= WINED3DSWAPEFFECT_COPY
;
2879 dstSwapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2881 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
2882 IWineD3DSwapChain_Present((IWineD3DSwapChain
*) dstSwapchain
, NULL
, NULL
, 0, NULL
, 0);
2884 dstSwapchain
->presentParms
.SwapEffect
= orig_swap
;
2891 TRACE("Unsupported blit between buffers on the same swapchain\n");
2892 return WINED3DERR_INVALIDCALL
;
2893 } else if((dstSwapchain
|| This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) &&
2894 (srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) ) {
2895 ERR("Can't perform hardware blit between 2 different swapchains, falling back to software\n");
2896 return WINED3DERR_INVALIDCALL
;
2899 if(srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) {
2900 /* Blit from render target to texture */
2902 BOOL upsideDown
, stretchx
;
2904 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
2905 TRACE("Color keying not supported by frame buffer to texture blit\n");
2906 return WINED3DERR_INVALIDCALL
;
2907 /* Destination color key is checked above */
2910 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2911 * glCopyTexSubImage is a bit picky about the parameters we pass to it
2914 if(SrcRect
->top
< SrcRect
->bottom
) {
2915 srect
.y1
= SrcRect
->top
;
2916 srect
.y2
= SrcRect
->bottom
;
2919 srect
.y1
= SrcRect
->bottom
;
2920 srect
.y2
= SrcRect
->top
;
2923 srect
.x1
= SrcRect
->left
;
2924 srect
.x2
= SrcRect
->right
;
2928 srect
.x2
= Src
->currentDesc
.Width
;
2929 srect
.y2
= Src
->currentDesc
.Height
;
2932 if(rect
.x1
> rect
.x2
) {
2936 upsideDown
= !upsideDown
;
2939 TRACE("Reading from an offscreen target\n");
2940 upsideDown
= !upsideDown
;
2943 if(rect
.x2
- rect
.x1
!= srect
.x2
- srect
.x1
) {
2949 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
2950 * flip the image nor scale it.
2952 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
2953 * -> If the app wants a image width an unscaled width, copy it line per line
2954 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
2955 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
2956 * back buffer. This is slower than reading line per line, thus not used for flipping
2957 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
2960 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
2961 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
2964 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
)) {
2965 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, &srect
,
2966 (IWineD3DSurface
*)This
, &rect
, Filter
, upsideDown
);
2967 } else if((!stretchx
) || rect
.x2
- rect
.x1
> Src
->currentDesc
.Width
||
2968 rect
.y2
- rect
.y1
> Src
->currentDesc
.Height
) {
2969 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
2970 fb_copy_to_texture_direct(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
2972 TRACE("Using hardware stretching to flip / stretch the texture\n");
2973 fb_copy_to_texture_hwstretch(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
2976 if(!(This
->Flags
& SFLAG_DONOTFREE
)) {
2977 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
2978 This
->resource
.allocatedMemory
= NULL
;
2979 This
->resource
.heapMemory
= NULL
;
2981 This
->Flags
&= ~SFLAG_INSYSMEM
;
2983 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
2984 * path is never entered
2986 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INTEXTURE
, TRUE
);
2990 /* Blit from offscreen surface to render target */
2991 float glTexCoord
[4];
2992 DWORD oldCKeyFlags
= Src
->CKeyFlags
;
2993 WINEDDCOLORKEY oldBltCKey
= This
->SrcBltCKey
;
2994 RECT SourceRectangle
;
2996 TRACE("Blt from surface %p to rendertarget %p\n", Src
, This
);
2999 SourceRectangle
.left
= SrcRect
->left
;
3000 SourceRectangle
.right
= SrcRect
->right
;
3001 SourceRectangle
.top
= SrcRect
->top
;
3002 SourceRectangle
.bottom
= SrcRect
->bottom
;
3004 SourceRectangle
.left
= 0;
3005 SourceRectangle
.right
= Src
->currentDesc
.Width
;
3006 SourceRectangle
.top
= 0;
3007 SourceRectangle
.bottom
= Src
->currentDesc
.Height
;
3010 if(!CalculateTexRect(Src
, &SourceRectangle
, glTexCoord
)) {
3011 /* Fall back to software */
3012 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src
,
3013 SourceRectangle
.left
, SourceRectangle
.top
,
3014 SourceRectangle
.right
, SourceRectangle
.bottom
);
3015 return WINED3DERR_INVALIDCALL
;
3018 /* Color keying: Check if we have to do a color keyed blt,
3019 * and if not check if a color key is activated.
3021 * Just modify the color keying parameters in the surface and restore them afterwards
3022 * The surface keeps track of the color key last used to load the opengl surface.
3023 * PreLoad will catch the change to the flags and color key and reload if necessary.
3025 if(Flags
& WINEDDBLT_KEYSRC
) {
3026 /* Use color key from surface */
3027 } else if(Flags
& WINEDDBLT_KEYSRCOVERRIDE
) {
3028 /* Use color key from DDBltFx */
3029 Src
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
3030 This
->SrcBltCKey
= DDBltFx
->ddckSrcColorkey
;
3032 /* Do not use color key */
3033 Src
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
3036 /* Now load the surface */
3037 IWineD3DSurface_PreLoad((IWineD3DSurface
*) Src
);
3040 /* Activate the destination context, set it up for blitting */
3041 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
3045 TRACE("Drawing to offscreen buffer\n");
3046 glDrawBuffer(myDevice
->offscreenBuffer
);
3047 checkGLcall("glDrawBuffer");
3049 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*)This
, (IWineD3DSwapChain
*)dstSwapchain
);
3050 TRACE("Drawing to %#x buffer\n", buffer
);
3051 glDrawBuffer(buffer
);
3052 checkGLcall("glDrawBuffer");
3055 /* Bind the texture */
3056 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
3057 checkGLcall("glBindTexture");
3059 /* Filtering for StretchRect */
3060 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
3061 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
3062 checkGLcall("glTexParameteri");
3063 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
3064 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
3065 checkGLcall("glTexParameteri");
3066 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3067 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3068 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
3069 checkGLcall("glTexEnvi");
3071 /* This is for color keying */
3072 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3073 glEnable(GL_ALPHA_TEST
);
3074 checkGLcall("glEnable GL_ALPHA_TEST");
3075 glAlphaFunc(GL_NOTEQUAL
, 0.0);
3076 checkGLcall("glAlphaFunc\n");
3078 glDisable(GL_ALPHA_TEST
);
3079 checkGLcall("glDisable GL_ALPHA_TEST");
3082 /* Draw a textured quad
3086 glColor3d(1.0f
, 1.0f
, 1.0f
);
3087 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
3092 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
3093 glVertex3f(rect
.x1
, rect
.y2
, 0.0);
3095 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
3100 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
3105 checkGLcall("glEnd");
3107 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3108 glDisable(GL_ALPHA_TEST
);
3109 checkGLcall("glDisable(GL_ALPHA_TEST)");
3112 /* Unbind the texture */
3113 glBindTexture(GL_TEXTURE_2D
, 0);
3114 checkGLcall("glEnable glBindTexture");
3116 /* The draw buffer should only need to be restored if we were drawing to the front buffer, and there is a back buffer.
3117 * otherwise the context manager should choose between GL_BACK / offscreenDrawBuffer
3119 if(dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
&& dstSwapchain
->backBuffer
) {
3120 glDrawBuffer(GL_BACK
);
3121 checkGLcall("glDrawBuffer");
3123 /* Restore the color key parameters */
3124 Src
->CKeyFlags
= oldCKeyFlags
;
3125 This
->SrcBltCKey
= oldBltCKey
;
3129 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3130 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3133 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INDRAWABLE
, TRUE
);
3134 /* TODO: This should be moved to ModifyLocation() */
3135 if(!(dstSwapchain
|| wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
)) {
3136 This
->Flags
|= SFLAG_INTEXTURE
;
3141 /* Source-Less Blit to render target */
3142 if (Flags
& WINEDDBLT_COLORFILL
) {
3143 /* This is easy to handle for the D3D Device... */
3146 TRACE("Colorfill\n");
3148 /* The color as given in the Blt function is in the format of the frame-buffer...
3149 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3151 if (This
->resource
.format
== WINED3DFMT_P8
) {
3152 if (This
->palette
) {
3153 color
= ((0xFF000000) |
3154 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peRed
<< 16) |
3155 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peGreen
<< 8) |
3156 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peBlue
));
3161 else if (This
->resource
.format
== WINED3DFMT_R5G6B5
) {
3162 if (DDBltFx
->u5
.dwFillColor
== 0xFFFF) {
3165 color
= ((0xFF000000) |
3166 ((DDBltFx
->u5
.dwFillColor
& 0xF800) << 8) |
3167 ((DDBltFx
->u5
.dwFillColor
& 0x07E0) << 5) |
3168 ((DDBltFx
->u5
.dwFillColor
& 0x001F) << 3));
3171 else if ((This
->resource
.format
== WINED3DFMT_R8G8B8
) ||
3172 (This
->resource
.format
== WINED3DFMT_X8R8G8B8
) ) {
3173 color
= 0xFF000000 | DDBltFx
->u5
.dwFillColor
;
3175 else if (This
->resource
.format
== WINED3DFMT_A8R8G8B8
) {
3176 color
= DDBltFx
->u5
.dwFillColor
;
3179 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3180 return WINED3DERR_INVALIDCALL
;
3183 TRACE("Calling GetSwapChain with mydevice = %p\n", myDevice
);
3184 if(dstSwapchain
&& dstSwapchain
->backBuffer
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->backBuffer
[0]) {
3185 glDrawBuffer(GL_BACK
);
3186 checkGLcall("glDrawBuffer(GL_BACK)");
3187 } else if (dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
) {
3188 glDrawBuffer(GL_FRONT
);
3189 checkGLcall("glDrawBuffer(GL_FRONT)");
3190 } else if(This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3191 glDrawBuffer(myDevice
->offscreenBuffer
);
3192 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer3)");
3194 TRACE("Surface is higher back buffer, falling back to software\n");
3195 return WINED3DERR_INVALIDCALL
;
3198 TRACE("(%p) executing Render Target override, color = %x\n", This
, color
);
3200 IWineD3DDevice_Clear( (IWineD3DDevice
*) myDevice
,
3201 1 /* Number of rectangles */,
3203 WINED3DCLEAR_TARGET
,
3208 /* Restore the original draw buffer */
3210 glDrawBuffer(myDevice
->offscreenBuffer
);
3211 } else if(dstSwapchain
->backBuffer
&& dstSwapchain
->backBuffer
[0]) {
3212 glDrawBuffer(GL_BACK
);
3214 vcheckGLcall("glDrawBuffer");
3220 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3221 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3222 return WINED3DERR_INVALIDCALL
;
3225 static HRESULT WINAPI
IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
)
3227 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3230 if (Flags
& WINEDDBLT_DEPTHFILL
) {
3231 switch(This
->resource
.format
) {
3232 case WINED3DFMT_D16
:
3233 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000ffff;
3235 case WINED3DFMT_D15S1
:
3236 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000fffe;
3238 case WINED3DFMT_D24S8
:
3239 case WINED3DFMT_D24X8
:
3240 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x00ffffff;
3242 case WINED3DFMT_D32
:
3243 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0xffffffff;
3247 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This
->resource
.format
));
3250 return IWineD3DDevice_Clear((IWineD3DDevice
*) myDevice
,
3251 DestRect
== NULL
? 0 : 1,
3252 (WINED3DRECT
*) DestRect
,
3253 WINED3DCLEAR_ZBUFFER
,
3259 FIXME("(%p): Unsupp depthstencil blit\n", This
);
3260 return WINED3DERR_INVALIDCALL
;
3263 static HRESULT WINAPI
IWineD3DSurfaceImpl_Blt(IWineD3DSurface
*iface
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3264 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3265 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3266 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3267 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3268 TRACE("(%p): Usage is %s\n", This
, debug_d3dusage(This
->resource
.usage
));
3270 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3271 * except depth blits, which seem to work
3273 if(iface
== myDevice
->stencilBufferTarget
|| (SrcSurface
&& SrcSurface
== myDevice
->stencilBufferTarget
)) {
3274 if(myDevice
->inScene
&& !(Flags
& WINEDDBLT_DEPTHFILL
)) {
3275 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3276 return WINED3DERR_INVALIDCALL
;
3277 } else if(IWineD3DSurfaceImpl_BltZ(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
) == WINED3D_OK
) {
3278 TRACE("Z Blit override handled the blit\n");
3283 /* Special cases for RenderTargets */
3284 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3285 ( Src
&& (Src
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3286 if(IWineD3DSurfaceImpl_BltOverride(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
) == WINED3D_OK
) return WINED3D_OK
;
3289 /* For the rest call the X11 surface implementation.
3290 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3291 * other Blts are rather rare
3293 return IWineD3DBaseSurfaceImpl_Blt(iface
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
);
3296 HRESULT WINAPI
IWineD3DSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
, IWineD3DSurface
*Source
, RECT
*rsrc
, DWORD trans
) {
3297 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3298 IWineD3DSurfaceImpl
*srcImpl
= (IWineD3DSurfaceImpl
*) Source
;
3299 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3300 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3302 if(myDevice
->inScene
&&
3303 (iface
== myDevice
->stencilBufferTarget
||
3304 (Source
&& Source
== myDevice
->stencilBufferTarget
))) {
3305 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3306 return WINED3DERR_INVALIDCALL
;
3309 /* Special cases for RenderTargets */
3310 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3311 ( srcImpl
&& (srcImpl
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3313 RECT SrcRect
, DstRect
;
3317 SrcRect
.left
= rsrc
->left
;
3318 SrcRect
.top
= rsrc
->top
;
3319 SrcRect
.bottom
= rsrc
->bottom
;
3320 SrcRect
.right
= rsrc
->right
;
3324 SrcRect
.right
= srcImpl
->currentDesc
.Width
;
3325 SrcRect
.bottom
= srcImpl
->currentDesc
.Height
;
3328 DstRect
.left
= dstx
;
3330 DstRect
.right
= dstx
+ SrcRect
.right
- SrcRect
.left
;
3331 DstRect
.bottom
= dsty
+ SrcRect
.bottom
- SrcRect
.top
;
3333 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3334 if(trans
& WINEDDBLTFAST_SRCCOLORKEY
)
3335 Flags
|= WINEDDBLT_KEYSRC
;
3336 if(trans
& WINEDDBLTFAST_DESTCOLORKEY
)
3337 Flags
|= WINEDDBLT_KEYDEST
;
3338 if(trans
& WINEDDBLTFAST_WAIT
)
3339 Flags
|= WINEDDBLT_WAIT
;
3340 if(trans
& WINEDDBLTFAST_DONOTWAIT
)
3341 Flags
|= WINEDDBLT_DONOTWAIT
;
3343 if(IWineD3DSurfaceImpl_BltOverride(This
, &DstRect
, Source
, &SrcRect
, Flags
, NULL
, WINED3DTEXF_POINT
) == WINED3D_OK
) return WINED3D_OK
;
3347 return IWineD3DBaseSurfaceImpl_BltFast(iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3350 static HRESULT WINAPI
IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
) {
3351 /** Check against the maximum texture sizes supported by the video card **/
3352 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3353 unsigned int pow2Width
, pow2Height
;
3354 const GlPixelFormatDesc
*glDesc
;
3356 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
3357 /* Setup some glformat defaults */
3358 This
->glDescription
.glFormat
= glDesc
->glFormat
;
3359 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
3360 This
->glDescription
.glType
= glDesc
->glType
;
3362 This
->glDescription
.textureName
= 0;
3363 This
->glDescription
.target
= GL_TEXTURE_2D
;
3365 /* Non-power2 support */
3366 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
)) {
3367 pow2Width
= This
->currentDesc
.Width
;
3368 pow2Height
= This
->currentDesc
.Height
;
3370 /* Find the nearest pow2 match */
3371 pow2Width
= pow2Height
= 1;
3372 while (pow2Width
< This
->currentDesc
.Width
) pow2Width
<<= 1;
3373 while (pow2Height
< This
->currentDesc
.Height
) pow2Height
<<= 1;
3375 This
->pow2Width
= pow2Width
;
3376 This
->pow2Height
= pow2Height
;
3378 if (pow2Width
> This
->currentDesc
.Width
|| pow2Height
> This
->currentDesc
.Height
) {
3379 WINED3DFORMAT Format
= This
->resource
.format
;
3380 /** TODO: add support for non power two compressed textures **/
3381 if (Format
== WINED3DFMT_DXT1
|| Format
== WINED3DFMT_DXT2
|| Format
== WINED3DFMT_DXT3
3382 || Format
== WINED3DFMT_DXT4
|| Format
== WINED3DFMT_DXT5
) {
3383 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3384 This
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
3385 return WINED3DERR_NOTAVAILABLE
;
3389 if(pow2Width
!= This
->currentDesc
.Width
||
3390 pow2Height
!= This
->currentDesc
.Height
) {
3391 This
->Flags
|= SFLAG_NONPOW2
;
3394 TRACE("%p\n", This
);
3395 if ((This
->pow2Width
> GL_LIMITS(texture_size
) || This
->pow2Height
> GL_LIMITS(texture_size
)) && !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_DEPTHSTENCIL
))) {
3396 /* one of three options
3397 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)
3398 2: Set the texture to the maximum size (bad idea)
3399 3: WARN and return WINED3DERR_NOTAVAILABLE;
3400 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.
3402 WARN("(%p) Creating an oversized surface\n", This
);
3403 This
->Flags
|= SFLAG_OVERSIZE
;
3405 /* This will be initialized on the first blt */
3406 This
->glRect
.left
= 0;
3407 This
->glRect
.top
= 0;
3408 This
->glRect
.right
= 0;
3409 This
->glRect
.bottom
= 0;
3411 /* No oversize, gl rect is the full texture size */
3412 This
->Flags
&= ~SFLAG_OVERSIZE
;
3413 This
->glRect
.left
= 0;
3414 This
->glRect
.top
= 0;
3415 This
->glRect
.right
= This
->pow2Width
;
3416 This
->glRect
.bottom
= This
->pow2Height
;
3419 This
->Flags
|= SFLAG_INSYSMEM
;
3424 static void WINAPI
IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
3425 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3427 TRACE("(%p)->(%s, %s)\n", iface
,
3428 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
3429 persistent
? "TRUE" : "FALSE");
3431 /* TODO: For offscreen textures with fbo offscreen rendering the drawable is the same as the texture.*/
3433 This
->Flags
&= ~SFLAG_LOCATIONS
;
3434 This
->Flags
|= flag
;
3436 This
->Flags
&= ~flag
;
3444 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl
*This
, const RECT
*rect_in
) {
3445 struct coords coords
[4];
3447 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3454 rect
.right
= This
->currentDesc
.Width
;
3455 rect
.bottom
= This
->currentDesc
.Height
;
3458 ActivateContext(device
, device
->render_targets
[0], CTXUSAGE_BLIT
);
3461 if(This
->glDescription
.target
== GL_TEXTURE_2D
) {
3462 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
3463 checkGLcall("GL_TEXTURE_2D, This->glDescription.textureName)");
3464 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3465 checkGLcall("glTexParameteri");
3466 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3467 checkGLcall("glTexParameteri");
3469 coords
[0].x
= rect
.left
/ This
->pow2Width
;
3472 coords
[1].x
= rect
.left
/ This
->pow2Width
;
3475 coords
[2].x
= rect
.right
/ This
->pow2Width
;
3478 coords
[3].x
= rect
.right
/ This
->pow2Width
;
3481 coords
[0].y
= rect
.top
/ This
->pow2Height
;
3482 coords
[1].y
= rect
.bottom
/ This
->pow2Height
;
3483 coords
[2].y
= rect
.bottom
/ This
->pow2Height
;
3484 coords
[3].y
= rect
.top
/ This
->pow2Height
;
3486 /* Must be a cube map */
3487 glDisable(GL_TEXTURE_2D
);
3488 checkGLcall("glDisable(GL_TEXTURE_2D)");
3489 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
3490 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
3491 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB
, This
->glDescription
.textureName
);
3492 checkGLcall("GL_TEXTURE_CUBE_MAP_ARB, This->glDescription.textureName)");
3493 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3494 checkGLcall("glTexParameteri");
3495 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3496 checkGLcall("glTexParameteri");
3498 switch(This
->glDescription
.target
) {
3499 case GL_TEXTURE_CUBE_MAP_POSITIVE_X
:
3500 coords
[0].x
= 1; coords
[0].y
= -1; coords
[0].z
= 1;
3501 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
3502 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
3503 coords
[3].x
= 1; coords
[3].y
= -1; coords
[3].z
= -1;
3506 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X
:
3507 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3508 coords
[1].x
= -1; coords
[1].y
= 1; coords
[1].z
= 1;
3509 coords
[2].x
= -1; coords
[2].y
= 1; coords
[2].z
= -1;
3510 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3513 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y
:
3514 coords
[0].x
= -1; coords
[0].y
= 1; coords
[0].z
= 1;
3515 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
3516 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
3517 coords
[3].x
= -1; coords
[3].y
= 1; coords
[3].z
= -1;
3520 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
:
3521 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3522 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
3523 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
3524 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3527 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z
:
3528 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3529 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
3530 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= 1;
3531 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= 1;
3534 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
:
3535 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= -1;
3536 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= -1;
3537 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
3538 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3541 ERR("Unexpected texture target\n");
3548 glTexCoord3iv((GLint
*) &coords
[0]);
3549 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
3551 glTexCoord3iv((GLint
*) &coords
[1]);
3552 glVertex2i(0, device
->render_offscreen
? rect
.top
: rect
.bottom
);
3554 glTexCoord3iv((GLint
*) &coords
[2]);
3555 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
3557 glTexCoord3iv((GLint
*) &coords
[3]);
3558 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
3560 checkGLcall("glEnd");
3562 if(This
->glDescription
.target
!= GL_TEXTURE_2D
) {
3563 glEnable(GL_TEXTURE_2D
);
3564 checkGLcall("glEnable(GL_TEXTURE_2D)");
3565 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
3566 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3571 /*****************************************************************************
3572 * IWineD3DSurface::LoadLocation
3574 * Copies the current surface data from wherever it is to the requested
3575 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
3576 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
3577 * multiple locations, the gl texture is prefered over the drawable, which is
3578 * prefered over system memory. The PBO counts as system memory. If rect is
3579 * not NULL, only the specified rectangle is copied(only supported for
3580 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
3581 * location is marked up to date after the copy.
3584 * flag: Surface location flag to be updated
3585 * rect: rectangle to be copied
3588 * WINED3D_OK on success
3589 * WINED3DERR_DEVICELOST on an internal error
3591 *****************************************************************************/
3592 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
3593 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3594 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3595 GLenum format
, internal
, type
;
3596 CONVERT_TYPES convert
;
3598 int width
, pitch
, outpitch
;
3601 TRACE("(%p)->(%s, %p)\n", iface
,
3602 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
3605 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
3608 /* TODO: For fbo targets, texture == drawable */
3609 if(This
->Flags
& flag
) {
3610 TRACE("Location already up to date\n");
3614 if(!(This
->Flags
& SFLAG_LOCATIONS
)) {
3615 ERR("Surface does not have any up to date location\n");
3616 This
->Flags
|= SFLAG_LOST
;
3617 return WINED3DERR_DEVICELOST
;
3620 if(flag
== SFLAG_INSYSMEM
) {
3621 surface_prepare_system_memory(This
);
3623 /* Download the surface to system memory */
3624 if(This
->Flags
& SFLAG_INTEXTURE
) {
3625 surface_download_data(This
);
3627 read_from_framebuffer(This
, rect
,
3628 This
->resource
.allocatedMemory
,
3629 IWineD3DSurface_GetPitch(iface
));
3631 } else if(flag
== SFLAG_INDRAWABLE
) {
3632 if(This
->Flags
& SFLAG_INTEXTURE
) {
3633 surface_blt_to_drawable(This
, rect
);
3635 flush_to_framebuffer_drawpixels(This
);
3637 } else /* if(flag == SFLAG_INTEXTURE) */ {
3638 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
3640 if (This
->Flags
& SFLAG_INDRAWABLE
) {
3644 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
3645 vcheckGLcall("glGetIntegerv");
3646 glReadBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
3647 vcheckGLcall("glReadBuffer");
3649 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3650 surface_allocate_surface(This
, internal
, This
->pow2Width
,
3651 This
->pow2Height
, format
, type
);
3654 clear_unused_channels(This
);
3656 glCopyTexSubImage2D(This
->glDescription
.target
,
3657 This
->glDescription
.level
,
3659 This
->currentDesc
.Width
,
3660 This
->currentDesc
.Height
);
3661 checkGLcall("glCopyTexSubImage2D");
3663 glReadBuffer(prevRead
);
3664 vcheckGLcall("glReadBuffer");
3668 TRACE("Updated target %d\n", This
->glDescription
.target
);
3670 /* The only place where LoadTexture() might get called when isInDraw=1
3671 * is ActivateContext where lastActiveRenderTarget is preloaded.
3673 if(iface
== device
->lastActiveRenderTarget
&& device
->isInDraw
)
3674 ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
3676 /* Otherwise: System memory copy must be most up to date */
3678 if(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) {
3679 This
->Flags
|= SFLAG_GLCKEY
;
3680 This
->glCKey
= This
->SrcBltCKey
;
3682 else This
->Flags
&= ~SFLAG_GLCKEY
;
3684 /* The width is in 'length' not in bytes */
3685 width
= This
->currentDesc
.Width
;
3686 pitch
= IWineD3DSurface_GetPitch(iface
);
3688 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
3689 int height
= This
->currentDesc
.Height
;
3691 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
3692 outpitch
= width
* bpp
;
3693 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
3695 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
3697 ERR("Out of memory %d, %d!\n", outpitch
, height
);
3698 return WINED3DERR_OUTOFVIDEOMEMORY
;
3700 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
3702 This
->Flags
|= SFLAG_CONVERTED
;
3703 } else if( (This
->resource
.format
== WINED3DFMT_P8
) && (GL_SUPPORT(EXT_PALETTED_TEXTURE
) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) ) {
3704 d3dfmt_p8_upload_palette(iface
, convert
);
3705 This
->Flags
&= ~SFLAG_CONVERTED
;
3706 mem
= This
->resource
.allocatedMemory
;
3708 This
->Flags
&= ~SFLAG_CONVERTED
;
3709 mem
= This
->resource
.allocatedMemory
;
3712 /* Make sure the correct pitch is used */
3713 glPixelStorei(GL_UNPACK_ROW_LENGTH
, width
);
3715 if ((This
->Flags
& SFLAG_NONPOW2
) && !(This
->Flags
& SFLAG_OVERSIZE
)) {
3716 TRACE("non power of two support\n");
3717 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3718 surface_allocate_surface(This
, internal
, This
->pow2Width
, This
->pow2Height
, format
, type
);
3720 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
3721 surface_upload_data(This
, internal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
, format
, type
, mem
);
3724 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
3725 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
3727 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3728 surface_allocate_surface(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
);
3730 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
3731 surface_upload_data(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
, mem
);
3735 /* Restore the default pitch */
3736 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
3738 /* Don't delete PBO memory */
3739 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
3740 HeapFree(GetProcessHeap(), 0, mem
);
3745 This
->Flags
|= flag
;
3751 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl
=
3754 IWineD3DBaseSurfaceImpl_QueryInterface
,
3755 IWineD3DBaseSurfaceImpl_AddRef
,
3756 IWineD3DSurfaceImpl_Release
,
3757 /* IWineD3DResource */
3758 IWineD3DBaseSurfaceImpl_GetParent
,
3759 IWineD3DBaseSurfaceImpl_GetDevice
,
3760 IWineD3DBaseSurfaceImpl_SetPrivateData
,
3761 IWineD3DBaseSurfaceImpl_GetPrivateData
,
3762 IWineD3DBaseSurfaceImpl_FreePrivateData
,
3763 IWineD3DBaseSurfaceImpl_SetPriority
,
3764 IWineD3DBaseSurfaceImpl_GetPriority
,
3765 IWineD3DSurfaceImpl_PreLoad
,
3766 IWineD3DBaseSurfaceImpl_GetType
,
3767 /* IWineD3DSurface */
3768 IWineD3DBaseSurfaceImpl_GetContainer
,
3769 IWineD3DBaseSurfaceImpl_GetDesc
,
3770 IWineD3DSurfaceImpl_LockRect
,
3771 IWineD3DSurfaceImpl_UnlockRect
,
3772 IWineD3DSurfaceImpl_GetDC
,
3773 IWineD3DSurfaceImpl_ReleaseDC
,
3774 IWineD3DSurfaceImpl_Flip
,
3775 IWineD3DSurfaceImpl_Blt
,
3776 IWineD3DBaseSurfaceImpl_GetBltStatus
,
3777 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
3778 IWineD3DBaseSurfaceImpl_IsLost
,
3779 IWineD3DBaseSurfaceImpl_Restore
,
3780 IWineD3DSurfaceImpl_BltFast
,
3781 IWineD3DBaseSurfaceImpl_GetPalette
,
3782 IWineD3DBaseSurfaceImpl_SetPalette
,
3783 IWineD3DBaseSurfaceImpl_RealizePalette
,
3784 IWineD3DBaseSurfaceImpl_SetColorKey
,
3785 IWineD3DBaseSurfaceImpl_GetPitch
,
3786 IWineD3DSurfaceImpl_SetMem
,
3787 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
3788 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
3789 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
3790 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
3791 IWineD3DBaseSurfaceImpl_SetClipper
,
3792 IWineD3DBaseSurfaceImpl_GetClipper
,
3794 IWineD3DSurfaceImpl_AddDirtyRect
,
3795 IWineD3DSurfaceImpl_LoadTexture
,
3796 IWineD3DSurfaceImpl_SaveSnapshot
,
3797 IWineD3DBaseSurfaceImpl_SetContainer
,
3798 IWineD3DSurfaceImpl_SetGlTextureDesc
,
3799 IWineD3DSurfaceImpl_GetGlDesc
,
3800 IWineD3DSurfaceImpl_GetData
,
3801 IWineD3DSurfaceImpl_SetFormat
,
3802 IWineD3DSurfaceImpl_PrivateSetup
,
3803 IWineD3DSurfaceImpl_ModifyLocation
,
3804 IWineD3DSurfaceImpl_LoadLocation