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-2008 Stefan Dösinger for CodeWeavers
11 * Copyright 2007-2008 Henri Verbeet
12 * Copyright 2006-2008 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
);
38 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
);
39 static inline void clear_unused_channels(IWineD3DSurfaceImpl
*This
);
40 static void surface_remove_pbo(IWineD3DSurfaceImpl
*This
);
42 static void surface_bind_and_dirtify(IWineD3DSurfaceImpl
*This
) {
45 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
46 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
47 * gl states. The current texture unit should always be a valid one.
49 * TODO: Track the current active texture per GL context instead of using glGet
51 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
54 glGetIntegerv(GL_ACTIVE_TEXTURE
, &active_texture
);
56 active_sampler
= This
->resource
.wineD3DDevice
->rev_tex_unit_map
[active_texture
- GL_TEXTURE0_ARB
];
61 if (active_sampler
!= -1) {
62 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(active_sampler
));
64 IWineD3DSurface_BindTexture((IWineD3DSurface
*)This
);
67 /* This function checks if the primary render target uses the 8bit paletted format. */
68 static BOOL
primary_render_target_is_p8(IWineD3DDeviceImpl
*device
)
70 if (device
->render_targets
&& device
->render_targets
[0]) {
71 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
72 if((render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) && (render_target
->resource
.format
== WINED3DFMT_P8
))
78 /* This call just downloads data, the caller is responsible for activating the
79 * right context and binding the correct texture. */
80 static void surface_download_data(IWineD3DSurfaceImpl
*This
) {
81 if (0 == This
->glDescription
.textureName
) {
82 ERR("Surface does not have a texture, but SFLAG_INTEXTURE is set\n");
86 /* Only support read back of converted P8 surfaces */
87 if(This
->Flags
& SFLAG_CONVERTED
&& (This
->resource
.format
!= WINED3DFMT_P8
)) {
88 FIXME("Read back converted textures unsupported, format=%s\n", debug_d3dformat(This
->resource
.format
));
94 if (This
->resource
.format
== WINED3DFMT_DXT1
||
95 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
96 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
97 This
->resource
.format
== WINED3DFMT_ATI2N
) {
98 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) { /* We can assume this as the texture would not have been created otherwise */
99 FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This
);
101 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
102 This
->glDescription
.glFormat
, This
->glDescription
.glType
, This
->resource
.allocatedMemory
);
104 if(This
->Flags
& SFLAG_PBO
) {
105 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
106 checkGLcall("glBindBufferARB");
107 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, NULL
));
108 checkGLcall("glGetCompressedTexImageARB()");
109 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
110 checkGLcall("glBindBufferARB");
112 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, This
->resource
.allocatedMemory
));
113 checkGLcall("glGetCompressedTexImageARB()");
119 GLenum format
= This
->glDescription
.glFormat
;
120 GLenum type
= This
->glDescription
.glType
;
124 /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
125 if(This
->resource
.format
== WINED3DFMT_P8
&& primary_render_target_is_p8(This
->resource
.wineD3DDevice
)) {
127 type
= GL_UNSIGNED_BYTE
;
130 if (This
->Flags
& SFLAG_NONPOW2
) {
131 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
132 src_pitch
= This
->bytesPerPixel
* This
->pow2Width
;
133 dst_pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
);
134 src_pitch
= (src_pitch
+ alignment
- 1) & ~(alignment
- 1);
135 mem
= HeapAlloc(GetProcessHeap(), 0, src_pitch
* This
->pow2Height
);
137 mem
= This
->resource
.allocatedMemory
;
140 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
143 if(This
->Flags
& SFLAG_PBO
) {
144 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
145 checkGLcall("glBindBufferARB");
147 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, format
,
149 checkGLcall("glGetTexImage()");
151 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
152 checkGLcall("glBindBufferARB");
154 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, format
,
156 checkGLcall("glGetTexImage()");
160 if (This
->Flags
& SFLAG_NONPOW2
) {
161 LPBYTE src_data
, dst_data
;
164 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
165 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
166 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
168 * We're doing this...
170 * instead of boxing the texture :
171 * |<-texture width ->| -->pow2width| /\
172 * |111111111111111111| | |
173 * |222 Texture 222222| boxed empty | texture height
174 * |3333 Data 33333333| | |
175 * |444444444444444444| | \/
176 * ----------------------------------- |
177 * | boxed empty | boxed empty | pow2height
179 * -----------------------------------
182 * we're repacking the data to the expected texture width
184 * |<-texture width ->| -->pow2width| /\
185 * |111111111111111111222222222222222| |
186 * |222333333333333333333444444444444| texture height
190 * | empty | pow2height
192 * -----------------------------------
196 * |<-texture width ->| /\
197 * |111111111111111111|
198 * |222222222222222222|texture height
199 * |333333333333333333|
200 * |444444444444444444| \/
201 * --------------------
203 * this also means that any references to allocatedMemory should work with the data as if were a
204 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
206 * internally the texture is still stored in a boxed format so any references to textureName will
207 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
209 * Performance should not be an issue, because applications normally do not lock the surfaces when
210 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
211 * and doesn't have to be re-read.
214 dst_data
= This
->resource
.allocatedMemory
;
215 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This
, src_pitch
, dst_pitch
);
216 for (y
= 1 ; y
< This
->currentDesc
.Height
; y
++) {
217 /* skip the first row */
218 src_data
+= src_pitch
;
219 dst_data
+= dst_pitch
;
220 memcpy(dst_data
, src_data
, dst_pitch
);
223 HeapFree(GetProcessHeap(), 0, mem
);
227 /* Surface has now been downloaded */
228 This
->Flags
|= SFLAG_INSYSMEM
;
231 /* This call just uploads data, the caller is responsible for activating the
232 * right context and binding the correct texture. */
233 static void surface_upload_data(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*data
) {
235 if(This
->heightscale
!= 1.0 && This
->heightscale
!= 0.0) height
*= This
->heightscale
;
237 if (This
->resource
.format
== WINED3DFMT_DXT1
||
238 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
239 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
240 This
->resource
.format
== WINED3DFMT_ATI2N
) {
241 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
242 FIXME("Using DXT1/3/5 without advertized support\n");
244 /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
245 * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
246 * function uses glCompressedTexImage2D instead of the SubImage call
248 TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This
, width
, height
, data
);
251 if(This
->Flags
& SFLAG_PBO
) {
252 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
253 checkGLcall("glBindBufferARB");
254 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
256 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
257 width
, height
, 0 /* border */, This
->resource
.size
, NULL
));
258 checkGLcall("glCompressedTexSubImage2D");
260 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
261 checkGLcall("glBindBufferARB");
263 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
264 width
, height
, 0 /* border */, This
->resource
.size
, data
));
265 checkGLcall("glCompressedTexSubImage2D");
270 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This
, width
, height
, data
);
273 if(This
->Flags
& SFLAG_PBO
) {
274 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
275 checkGLcall("glBindBufferARB");
276 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
278 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, NULL
);
279 checkGLcall("glTexSubImage2D");
281 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
282 checkGLcall("glBindBufferARB");
285 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, data
);
286 checkGLcall("glTexSubImage2D");
293 /* This call just allocates the texture, the caller is responsible for
294 * activating the right context and binding the correct texture. */
295 static void surface_allocate_surface(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
) {
296 BOOL enable_client_storage
= FALSE
;
299 if(This
->heightscale
!= 1.0 && This
->heightscale
!= 0.0) height
*= This
->heightscale
;
301 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
,
302 This
->glDescription
.target
, This
->glDescription
.level
, debug_d3dformat(This
->resource
.format
), internal
, width
, height
, format
, type
);
304 if (This
->resource
.format
== WINED3DFMT_DXT1
||
305 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
306 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
307 This
->resource
.format
== WINED3DFMT_ATI2N
) {
308 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
309 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
311 /* We have to point GL to the client storage memory here, because upload_data might use a PBO. This means a double upload
312 * once, unfortunately
314 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
315 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
316 This
->Flags
|= SFLAG_CLIENT
;
317 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
319 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
320 width
, height
, 0 /* border */, This
->resource
.size
, mem
));
329 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
330 if(This
->Flags
& (SFLAG_NONPOW2
| SFLAG_DIBSECTION
| SFLAG_OVERSIZE
| SFLAG_CONVERTED
) || This
->resource
.allocatedMemory
== NULL
) {
331 /* In some cases we want to disable client storage.
332 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
333 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
334 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
335 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
336 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
338 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_FALSE
);
339 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
340 This
->Flags
&= ~SFLAG_CLIENT
;
341 enable_client_storage
= TRUE
;
343 This
->Flags
|= SFLAG_CLIENT
;
345 /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
346 * it might point into a pbo. Instead use heapMemory, but get the alignment right.
348 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
351 glTexImage2D(This
->glDescription
.target
, This
->glDescription
.level
, internal
, width
, height
, 0, format
, type
, mem
);
352 checkGLcall("glTexImage2D");
354 if(enable_client_storage
) {
355 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
356 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
360 This
->Flags
|= SFLAG_ALLOCATED
;
363 /* In D3D the depth stencil dimensions have to be greater than or equal to the
364 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
365 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
366 void surface_set_compatible_renderbuffer(IWineD3DSurface
*iface
, unsigned int width
, unsigned int height
) {
367 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
368 renderbuffer_entry_t
*entry
;
369 GLuint renderbuffer
= 0;
370 unsigned int src_width
, src_height
;
372 src_width
= This
->pow2Width
;
373 src_height
= This
->pow2Height
;
375 /* A depth stencil smaller than the render target is not valid */
376 if (width
> src_width
|| height
> src_height
) return;
378 /* Remove any renderbuffer set if the sizes match */
379 if (width
== src_width
&& height
== src_height
) {
380 This
->current_renderbuffer
= NULL
;
384 /* Look if we've already got a renderbuffer of the correct dimensions */
385 LIST_FOR_EACH_ENTRY(entry
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
386 if (entry
->width
== width
&& entry
->height
== height
) {
387 renderbuffer
= entry
->id
;
388 This
->current_renderbuffer
= entry
;
394 const GlPixelFormatDesc
*glDesc
;
395 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
397 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer
));
398 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, renderbuffer
));
399 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, glDesc
->glInternal
, width
, height
));
401 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t
));
402 entry
->width
= width
;
403 entry
->height
= height
;
404 entry
->id
= renderbuffer
;
405 list_add_head(&This
->renderbuffers
, &entry
->entry
);
407 This
->current_renderbuffer
= entry
;
410 checkGLcall("set_compatible_renderbuffer");
413 GLenum
surface_get_gl_buffer(IWineD3DSurface
*iface
, IWineD3DSwapChain
*swapchain
) {
414 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
415 IWineD3DSwapChainImpl
*swapchain_impl
= (IWineD3DSwapChainImpl
*)swapchain
;
417 TRACE("(%p) : swapchain %p\n", This
, swapchain
);
419 if (swapchain_impl
->backBuffer
&& swapchain_impl
->backBuffer
[0] == iface
) {
420 TRACE("Returning GL_BACK\n");
422 } else if (swapchain_impl
->frontBuffer
== iface
) {
423 TRACE("Returning GL_FRONT\n");
427 FIXME("Higher back buffer, returning GL_BACK\n");
431 ULONG WINAPI
IWineD3DSurfaceImpl_Release(IWineD3DSurface
*iface
) {
432 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
433 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
434 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
436 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
437 renderbuffer_entry_t
*entry
, *entry2
;
438 TRACE("(%p) : cleaning up\n", This
);
440 /* Need a context to destroy the texture. Use the currently active render target, but only if
441 * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
442 * When destroying the primary rt, Uninit3D will activate a context before doing anything
444 if(device
->render_targets
&& device
->render_targets
[0]) {
445 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
449 if (This
->glDescription
.textureName
!= 0) { /* release the openGL texture.. */
450 TRACE("Deleting texture %d\n", This
->glDescription
.textureName
);
451 glDeleteTextures(1, &This
->glDescription
.textureName
);
454 if(This
->Flags
& SFLAG_PBO
) {
456 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
459 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
460 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
461 HeapFree(GetProcessHeap(), 0, entry
);
465 if(This
->Flags
& SFLAG_DIBSECTION
) {
467 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
469 /* Release the DIB section */
470 DeleteObject(This
->dib
.DIBsection
);
471 This
->dib
.bitmap_data
= NULL
;
472 This
->resource
.allocatedMemory
= NULL
;
474 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
476 HeapFree(GetProcessHeap(), 0, This
->palette9
);
478 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
480 if(This
->overlay_dest
) {
481 list_remove(&This
->overlay_entry
);
484 TRACE("(%p) Released\n", This
);
485 HeapFree(GetProcessHeap(), 0, This
);
491 /* ****************************************************
492 IWineD3DSurface IWineD3DResource parts follow
493 **************************************************** */
495 void WINAPI
IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface
*iface
) {
496 /* TODO: check for locks */
497 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
498 IWineD3DBaseTexture
*baseTexture
= NULL
;
499 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
501 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
502 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
503 TRACE("Passing to container\n");
504 IWineD3DBaseTexture_PreLoad(baseTexture
);
505 IWineD3DBaseTexture_Release(baseTexture
);
507 TRACE("(%p) : About to load surface\n", This
);
509 if(!device
->isInDraw
) {
510 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
513 if (This
->resource
.format
== WINED3DFMT_P8
|| This
->resource
.format
== WINED3DFMT_A8P8
) {
514 if(palette9_changed(This
)) {
515 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
516 /* TODO: This is not necessarily needed with hw palettized texture support */
517 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
518 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
519 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
523 IWineD3DSurface_LoadTexture(iface
, FALSE
);
525 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
526 /* Tell opengl to try and keep this texture in video ram (well mostly) */
530 glPrioritizeTextures(1, &This
->glDescription
.textureName
, &tmp
);
537 static void surface_remove_pbo(IWineD3DSurfaceImpl
*This
) {
538 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
539 This
->resource
.allocatedMemory
=
540 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
543 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
544 checkGLcall("glBindBuffer(GL_PIXEL_UNPACK_BUFFER, This->pbo)");
545 GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0, This
->resource
.size
, This
->resource
.allocatedMemory
));
546 checkGLcall("glGetBufferSubData");
547 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
548 checkGLcall("glDeleteBuffers");
552 This
->Flags
&= ~SFLAG_PBO
;
555 static void WINAPI
IWineD3DSurfaceImpl_UnLoad(IWineD3DSurface
*iface
) {
556 IWineD3DBaseTexture
*texture
= NULL
;
557 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
558 renderbuffer_entry_t
*entry
, *entry2
;
559 TRACE("(%p)\n", iface
);
561 if(This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
562 /* Default pool resources are supposed to be destroyed before Reset is called.
563 * Implicit resources stay however. So this means we have an implicit render target
564 * or depth stencil. The content may be destroyed, but we still have to tear down
565 * opengl resources, so we cannot leave early.
567 * Put the most up to date surface location into the drawable. D3D-wise this content
568 * is undefined, so it would be nowhere, but that would make the location management
569 * more complicated. The drawable is a sane location, because if we mark sysmem or
570 * texture up to date, drawPrim will copy the uninitialized texture or sysmem to the
571 * uninitialized drawable. That's pointless and we'd have to allocate the texture /
574 if (This
->resource
.usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
575 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
577 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, TRUE
);
580 /* Load the surface into system memory */
581 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
582 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, FALSE
);
584 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
585 This
->Flags
&= ~SFLAG_ALLOCATED
;
587 /* Destroy PBOs, but load them into real sysmem before */
588 if(This
->Flags
& SFLAG_PBO
) {
589 surface_remove_pbo(This
);
592 /* Destroy fbo render buffers. This is needed for implicit render targets, for
593 * all application-created targets the application has to release the surface
594 * before calling _Reset
596 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
598 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
600 list_remove(&entry
->entry
);
601 HeapFree(GetProcessHeap(), 0, entry
);
603 list_init(&This
->renderbuffers
);
604 This
->current_renderbuffer
= NULL
;
606 /* If we're in a texture, the texture name belongs to the texture. Otherwise,
609 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **) &texture
);
612 glDeleteTextures(1, &This
->glDescription
.textureName
);
613 This
->glDescription
.textureName
= 0;
616 IWineD3DBaseTexture_Release(texture
);
621 /* ******************************************************
622 IWineD3DSurface IWineD3DSurface parts follow
623 ****************************************************** */
625 void WINAPI
IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface
*iface
, UINT textureName
, int target
) {
626 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
627 TRACE("(%p) : setting textureName %u, target %#x\n", This
, textureName
, target
);
628 if (This
->glDescription
.textureName
== 0 && textureName
!= 0) {
629 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
630 if((This
->Flags
& SFLAG_LOCATIONS
) == 0) {
631 /* In 1.0-rc4 and earlier, AddDirtyRect was called in the place of this if condition.
632 * This had the problem that a correctly set INDRAWABLE flag was removed if the PreLoad
633 * during the offscreen rendering readback triggered the creation of the GL texture.
634 * The change intended to keep the INDRAWABLE intact. To prevent unintended side effects
635 * before release, set the INSYSMEM flag like the old AddDirtyRect did.
637 WARN("Wine 1.0 safety path hit\n");
638 This
->Flags
|= SFLAG_INSYSMEM
;
641 if(target
== GL_TEXTURE_RECTANGLE_ARB
&& This
->glDescription
.target
!= target
) {
642 This
->Flags
&= ~SFLAG_NORMCOORD
;
643 } else if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
&& target
!= GL_TEXTURE_RECTANGLE_ARB
) {
644 This
->Flags
|= SFLAG_NORMCOORD
;
646 This
->glDescription
.textureName
= textureName
;
647 This
->glDescription
.target
= target
;
648 This
->Flags
&= ~SFLAG_ALLOCATED
;
651 void WINAPI
IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
652 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
653 TRACE("(%p) : returning %p\n", This
, &This
->glDescription
);
654 *glDescription
= &This
->glDescription
;
657 /* TODO: think about moving this down to resource? */
658 const void *WINAPI
IWineD3DSurfaceImpl_GetData(IWineD3DSurface
*iface
) {
659 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
660 /* 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 */
661 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
) {
662 FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface
);
664 return (CONST
void*)(This
->resource
.allocatedMemory
);
667 /* Read the framebuffer back into the surface */
668 static void read_from_framebuffer(IWineD3DSurfaceImpl
*This
, CONST RECT
*rect
, void *dest
, UINT pitch
) {
669 IWineD3DSwapChainImpl
*swapchain
;
670 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
674 BYTE
*row
, *top
, *bottom
;
678 BOOL srcIsUpsideDown
;
680 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
681 static BOOL warned
= FALSE
;
683 ERR("The application tries to lock the render target, but render target locking is disabled\n");
689 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
690 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
691 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
692 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
693 * context->last_was_blit set on the unlock.
695 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
698 /* Select the correct read buffer, and give some debug output.
699 * There is no need to keep track of the current read buffer or reset it, every part of the code
700 * that reads sets the read buffer as desired.
703 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
704 * Read from the back buffer
706 TRACE("Locking offscreen render target\n");
707 glReadBuffer(myDevice
->offscreenBuffer
);
708 srcIsUpsideDown
= TRUE
;
710 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
711 TRACE("Locking %#x buffer\n", buffer
);
712 glReadBuffer(buffer
);
713 checkGLcall("glReadBuffer");
715 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
716 srcIsUpsideDown
= FALSE
;
719 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
723 local_rect
.right
= This
->currentDesc
.Width
;
724 local_rect
.bottom
= This
->currentDesc
.Height
;
728 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
730 switch(This
->resource
.format
)
734 if(primary_render_target_is_p8(myDevice
)) {
735 /* In case of P8 render targets the index is stored in the alpha component */
737 type
= GL_UNSIGNED_BYTE
;
739 bpp
= This
->bytesPerPixel
;
741 /* GL can't return palettized data, so read ARGB pixels into a
742 * separate block of memory and convert them into palettized format
743 * in software. Slow, but if the app means to use palettized render
744 * targets and locks it...
746 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
747 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
748 * for the color channels when palettizing the colors.
751 type
= GL_UNSIGNED_BYTE
;
753 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* 3);
755 ERR("Out of memory\n");
759 bpp
= This
->bytesPerPixel
* 3;
766 fmt
= This
->glDescription
.glFormat
;
767 type
= This
->glDescription
.glType
;
768 bpp
= This
->bytesPerPixel
;
771 if(This
->Flags
& SFLAG_PBO
) {
772 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
773 checkGLcall("glBindBufferARB");
776 glReadPixels(local_rect
.left
, local_rect
.top
,
777 local_rect
.right
- local_rect
.left
,
778 local_rect
.bottom
- local_rect
.top
,
780 vcheckGLcall("glReadPixels");
782 if(This
->Flags
& SFLAG_PBO
) {
783 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
784 checkGLcall("glBindBufferARB");
786 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
787 * to get a pointer to it and perform the flipping in software. This is a lot
788 * faster than calling glReadPixels for each line. In case we want more speed
789 * we should rerender it flipped in a FBO and read the data back from the FBO. */
790 if(!srcIsUpsideDown
) {
791 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
792 checkGLcall("glBindBufferARB");
794 mem
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
795 checkGLcall("glMapBufferARB");
799 /* TODO: Merge this with the palettization loop below for P8 targets */
800 if(!srcIsUpsideDown
) {
802 /* glReadPixels returns the image upside down, and there is no way to prevent this.
803 Flip the lines in software */
804 len
= (local_rect
.right
- local_rect
.left
) * bpp
;
805 off
= local_rect
.left
* bpp
;
807 row
= HeapAlloc(GetProcessHeap(), 0, len
);
809 ERR("Out of memory\n");
810 if(This
->resource
.format
== WINED3DFMT_P8
) HeapFree(GetProcessHeap(), 0, mem
);
815 top
= mem
+ pitch
* local_rect
.top
;
816 bottom
= mem
+ pitch
* ( local_rect
.bottom
- local_rect
.top
- 1);
817 for(i
= 0; i
< (local_rect
.bottom
- local_rect
.top
) / 2; i
++) {
818 memcpy(row
, top
+ off
, len
);
819 memcpy(top
+ off
, bottom
+ off
, len
);
820 memcpy(bottom
+ off
, row
, len
);
824 HeapFree(GetProcessHeap(), 0, row
);
826 /* Unmap the temp PBO buffer */
827 if(This
->Flags
& SFLAG_PBO
) {
828 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
829 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
835 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
836 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
837 * the same color but we have no choice.
838 * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
840 if((This
->resource
.format
== WINED3DFMT_P8
) && !primary_render_target_is_p8(myDevice
)) {
841 PALETTEENTRY
*pal
= NULL
;
842 DWORD width
= pitch
/ 3;
846 pal
= This
->palette
->palents
;
848 ERR("Palette is missing, cannot perform inverse palette lookup\n");
849 HeapFree(GetProcessHeap(), 0, mem
);
853 for(y
= local_rect
.top
; y
< local_rect
.bottom
; y
++) {
854 for(x
= local_rect
.left
; x
< local_rect
.right
; x
++) {
855 /* start lines pixels */
856 BYTE
*blue
= mem
+ y
* pitch
+ x
* (sizeof(BYTE
) * 3);
857 BYTE
*green
= blue
+ 1;
858 BYTE
*red
= green
+ 1;
860 for(c
= 0; c
< 256; c
++) {
861 if(*red
== pal
[c
].peRed
&&
862 *green
== pal
[c
].peGreen
&&
863 *blue
== pal
[c
].peBlue
)
865 *((BYTE
*) dest
+ y
* width
+ x
) = c
;
871 HeapFree(GetProcessHeap(), 0, mem
);
875 /* Read the framebuffer contents into a texture */
876 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl
*This
)
878 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
879 IWineD3DSwapChainImpl
*swapchain
;
881 GLenum format
, internal
, type
;
882 CONVERT_TYPES convert
;
885 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
887 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
888 /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
889 * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
890 * states in the stateblock, and no driver was found yet that had bugs in that regard.
892 ActivateContext(device
, (IWineD3DSurface
*) This
, CTXUSAGE_RESOURCELOAD
);
893 surface_bind_and_dirtify(This
);
896 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
898 /* Select the correct read buffer, and give some debug output.
899 * There is no need to keep track of the current read buffer or reset it, every part of the code
900 * that reads sets the read buffer as desired.
903 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
904 * Read from the back buffer
906 TRACE("Locking offscreen render target\n");
907 glReadBuffer(device
->offscreenBuffer
);
909 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
910 TRACE("Locking %#x buffer\n", buffer
);
911 glReadBuffer(buffer
);
912 checkGLcall("glReadBuffer");
914 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
917 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
918 surface_allocate_surface(This
, internal
, This
->pow2Width
,
919 This
->pow2Height
, format
, type
);
922 clear_unused_channels(This
);
924 /* If !SrcIsUpsideDown we should flip the surface.
925 * This can be done using glCopyTexSubImage2D but this
926 * is VERY slow, so don't do that. We should prevent
927 * this code from getting called in such cases or perhaps
930 glCopyTexSubImage2D(This
->glDescription
.target
,
931 This
->glDescription
.level
,
933 This
->currentDesc
.Width
,
934 This
->currentDesc
.Height
);
935 checkGLcall("glCopyTexSubImage2D");
937 glReadBuffer(prevRead
);
938 vcheckGLcall("glReadBuffer");
941 TRACE("Updated target %d\n", This
->glDescription
.target
);
944 static void surface_prepare_system_memory(IWineD3DSurfaceImpl
*This
) {
945 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
946 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
949 if(!(This
->Flags
& SFLAG_DYNLOCK
)) {
951 /* MAXLOCKCOUNT is defined in wined3d_private.h */
952 if(This
->lockCount
> MAXLOCKCOUNT
) {
953 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
954 This
->Flags
|= SFLAG_DYNLOCK
;
958 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
959 * Also don't create a PBO for systemmem surfaces.
961 if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT
) && (This
->Flags
& SFLAG_DYNLOCK
) && !(This
->Flags
& (SFLAG_PBO
| SFLAG_CONVERTED
| SFLAG_NONPOW2
)) && (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
)) {
963 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
965 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
968 GL_EXTCALL(glGenBuffersARB(1, &This
->pbo
));
969 error
= glGetError();
970 if(This
->pbo
== 0 || error
!= GL_NO_ERROR
) {
971 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error
), error
);
974 TRACE("Attaching pbo=%#x to (%p)\n", This
->pbo
, This
);
976 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
977 checkGLcall("glBindBufferARB");
979 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->resource
.size
+ 4, This
->resource
.allocatedMemory
, GL_STREAM_DRAW_ARB
));
980 checkGLcall("glBufferDataARB");
982 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
983 checkGLcall("glBindBufferARB");
985 /* We don't need the system memory anymore and we can't even use it for PBOs */
986 if(!(This
->Flags
& SFLAG_CLIENT
)) {
987 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
988 This
->resource
.heapMemory
= NULL
;
990 This
->resource
.allocatedMemory
= NULL
;
991 This
->Flags
|= SFLAG_PBO
;
993 } else if(!(This
->resource
.allocatedMemory
|| This
->Flags
& SFLAG_PBO
)) {
994 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
997 if(!This
->resource
.heapMemory
) {
998 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
1000 This
->resource
.allocatedMemory
=
1001 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
1002 if(This
->Flags
& SFLAG_INSYSMEM
) {
1003 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1008 static HRESULT WINAPI
IWineD3DSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
) {
1009 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1010 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1011 IWineD3DSwapChain
*swapchain
= NULL
;
1013 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
1015 /* This is also done in the base class, but we have to verify this before loading any data from
1016 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1017 * may interfere, and all other bad things may happen
1019 if (This
->Flags
& SFLAG_LOCKED
) {
1020 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1021 return WINED3DERR_INVALIDCALL
;
1023 This
->Flags
|= SFLAG_LOCKED
;
1025 if (!(This
->Flags
& SFLAG_LOCKABLE
))
1027 TRACE("Warning: trying to lock unlockable surf@%p\n", This
);
1030 if (Flags
& WINED3DLOCK_DISCARD
) {
1031 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
1032 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
1033 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
1034 This
->Flags
|= SFLAG_INSYSMEM
;
1038 if (This
->Flags
& SFLAG_INSYSMEM
) {
1039 TRACE("Local copy is up to date, not downloading data\n");
1040 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
1044 /* Now download the surface content from opengl
1045 * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
1046 * Offscreen targets which are not active at the moment or are higher targets(FBOs) can be locked with the texture path
1048 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1049 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
1050 const RECT
*pass_rect
= pRect
;
1052 /* IWineD3DSurface_LoadLocation does not check if the rectangle specifies the full surfaces
1053 * because most caller functions do not need that. So do that here
1058 pRect
->right
== This
->currentDesc
.Width
&&
1059 pRect
->bottom
== This
->currentDesc
.Height
) {
1063 switch(wined3d_settings
.rendertargetlock_mode
) {
1066 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
1068 /* Disabled for now. LoadLocation prefers the texture over the drawable as the source. So if we copy to the
1069 * texture first, then to sysmem, we'll avoid glReadPixels and use glCopyTexImage and glGetTexImage2D instead.
1070 * This may be faster on some cards
1072 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* No partial texture copy yet */);
1079 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, pRect
);
1085 if(swapchain
) IWineD3DSwapChain_Release(swapchain
);
1087 } else if(iface
== myDevice
->stencilBufferTarget
) {
1088 /** the depth stencil in openGL has a format of GL_FLOAT
1089 * which should be good for WINED3DFMT_D16_LOCKABLE
1090 * and WINED3DFMT_D16
1091 * it is unclear what format the stencil buffer is in except.
1092 * 'Each index is converted to fixed point...
1093 * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
1094 * mappings in the table GL_PIXEL_MAP_S_TO_S.
1095 * glReadPixels(This->lockedRect.left,
1096 * This->lockedRect.bottom - j - 1,
1097 * This->lockedRect.right - This->lockedRect.left,
1099 * GL_DEPTH_COMPONENT,
1101 * (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
1103 * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
1104 * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
1105 * none of that is the case the problem is not in this function :-)
1106 ********************************************/
1107 FIXME("Depth stencil locking not supported yet\n");
1109 /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
1110 TRACE("locking an ordinary surface\n");
1111 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
1115 if(This
->Flags
& SFLAG_PBO
) {
1116 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1118 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1119 checkGLcall("glBindBufferARB");
1121 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1122 if(This
->resource
.allocatedMemory
) {
1123 ERR("The surface already has PBO memory allocated!\n");
1126 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
1127 checkGLcall("glMapBufferARB");
1129 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1130 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1131 checkGLcall("glBindBufferARB");
1136 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
1139 IWineD3DBaseTexture
*pBaseTexture
;
1142 * as seen in msdn docs
1144 IWineD3DSurface_AddDirtyRect(iface
, pRect
);
1146 /** Dirtify Container if needed */
1147 if (WINED3D_OK
== IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&pBaseTexture
) && pBaseTexture
!= NULL
) {
1148 TRACE("Making container dirty\n");
1149 IWineD3DBaseTexture_SetDirty(pBaseTexture
, TRUE
);
1150 IWineD3DBaseTexture_Release(pBaseTexture
);
1152 TRACE("Surface is standalone, no need to dirty the container\n");
1156 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
1159 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl
*This
, GLenum fmt
, GLenum type
, UINT bpp
, const BYTE
*mem
) {
1161 GLint prev_rasterpos
[4];
1162 GLint skipBytes
= 0;
1163 UINT pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
); /* target is argb, 4 byte */
1164 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1165 IWineD3DSwapChainImpl
*swapchain
;
1167 /* Activate the correct context for the render target */
1168 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
1171 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1173 /* Primary offscreen render target */
1174 TRACE("Offscreen render target\n");
1175 glDrawBuffer(myDevice
->offscreenBuffer
);
1176 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1178 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
1179 TRACE("Unlocking %#x buffer\n", buffer
);
1180 glDrawBuffer(buffer
);
1181 checkGLcall("glDrawBuffer");
1183 IWineD3DSwapChain_Release((IWineD3DSwapChain
*)swapchain
);
1186 glGetIntegerv(GL_PACK_SWAP_BYTES
, &prev_store
);
1187 vcheckGLcall("glIntegerv");
1188 glGetIntegerv(GL_CURRENT_RASTER_POSITION
, &prev_rasterpos
[0]);
1189 vcheckGLcall("glIntegerv");
1190 glPixelZoom(1.0, -1.0);
1191 vcheckGLcall("glPixelZoom");
1193 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
1194 glGetIntegerv(GL_UNPACK_ROW_LENGTH
, &skipBytes
);
1195 glPixelStorei(GL_UNPACK_ROW_LENGTH
, This
->currentDesc
.Width
);
1197 glRasterPos3i(This
->lockedRect
.left
, This
->lockedRect
.top
, 1);
1198 vcheckGLcall("glRasterPos2f");
1200 /* Some drivers(radeon dri, others?) don't like exceptions during
1201 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
1202 * after ReleaseDC. Reading it will cause an exception, which x11drv will
1203 * catch to put the dib section in InSync mode, which leads to a crash
1204 * and a blocked x server on my radeon card.
1206 * The following lines read the dib section so it is put in InSync mode
1207 * before glDrawPixels is called and the crash is prevented. There won't
1208 * be any interfering gdi accesses, because UnlockRect is called from
1209 * ReleaseDC, and the app won't use the dc any more afterwards.
1211 if((This
->Flags
& SFLAG_DIBSECTION
) && !(This
->Flags
& SFLAG_PBO
)) {
1213 read
= This
->resource
.allocatedMemory
[0];
1216 if(This
->Flags
& SFLAG_PBO
) {
1217 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1218 checkGLcall("glBindBufferARB");
1221 /* When the surface is locked we only have to refresh the locked part else we need to update the whole image */
1222 if(This
->Flags
& SFLAG_LOCKED
) {
1223 glDrawPixels(This
->lockedRect
.right
- This
->lockedRect
.left
,
1224 (This
->lockedRect
.bottom
- This
->lockedRect
.top
)-1,
1226 mem
+ bpp
* This
->lockedRect
.left
+ pitch
* This
->lockedRect
.top
);
1227 checkGLcall("glDrawPixels");
1229 glDrawPixels(This
->currentDesc
.Width
,
1230 This
->currentDesc
.Height
,
1232 checkGLcall("glDrawPixels");
1235 if(This
->Flags
& SFLAG_PBO
) {
1236 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1237 checkGLcall("glBindBufferARB");
1240 glPixelZoom(1.0,1.0);
1241 vcheckGLcall("glPixelZoom");
1243 glRasterPos3iv(&prev_rasterpos
[0]);
1244 vcheckGLcall("glRasterPos3iv");
1246 /* Reset to previous pack row length */
1247 glPixelStorei(GL_UNPACK_ROW_LENGTH
, skipBytes
);
1248 vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1251 glDrawBuffer(myDevice
->offscreenBuffer
);
1252 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1253 } else if(swapchain
->backBuffer
) {
1254 glDrawBuffer(GL_BACK
);
1255 checkGLcall("glDrawBuffer(GL_BACK)");
1257 glDrawBuffer(GL_FRONT
);
1258 checkGLcall("glDrawBuffer(GL_FRONT)");
1265 static HRESULT WINAPI
IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface
*iface
) {
1266 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1267 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1268 IWineD3DSwapChainImpl
*swapchain
= NULL
;
1271 if (!(This
->Flags
& SFLAG_LOCKED
)) {
1272 WARN("trying to Unlock an unlocked surf@%p\n", This
);
1273 return WINED3DERR_INVALIDCALL
;
1276 if (This
->Flags
& SFLAG_PBO
) {
1277 TRACE("Freeing PBO memory\n");
1278 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1280 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1281 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
1282 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1283 checkGLcall("glUnmapBufferARB");
1285 This
->resource
.allocatedMemory
= NULL
;
1288 TRACE("(%p) : dirtyfied(%d)\n", This
, This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
1290 if (This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
)) {
1291 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This
);
1295 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1296 if(swapchain
|| (myDevice
->render_targets
&& iface
== myDevice
->render_targets
[0])) {
1297 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
1299 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
1300 static BOOL warned
= FALSE
;
1302 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1308 if(This
->dirtyRect
.left
== 0 &&
1309 This
->dirtyRect
.top
== 0 &&
1310 This
->dirtyRect
.right
== This
->currentDesc
.Width
&&
1311 This
->dirtyRect
.bottom
== This
->currentDesc
.Height
) {
1314 /* TODO: Proper partial rectangle tracking */
1315 fullsurface
= FALSE
;
1316 This
->Flags
|= SFLAG_INSYSMEM
;
1319 switch(wined3d_settings
.rendertargetlock_mode
) {
1322 ActivateContext(myDevice
, iface
, CTXUSAGE_BLIT
);
1323 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* partial texture loading not supported yet */);
1329 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, fullsurface
? NULL
: &This
->dirtyRect
);
1334 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1335 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1336 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1337 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1338 * not fully up to date because only a subrectangle was read in LockRect.
1340 This
->Flags
&= ~SFLAG_INSYSMEM
;
1341 This
->Flags
|= SFLAG_INDRAWABLE
;
1344 This
->dirtyRect
.left
= This
->currentDesc
.Width
;
1345 This
->dirtyRect
.top
= This
->currentDesc
.Height
;
1346 This
->dirtyRect
.right
= 0;
1347 This
->dirtyRect
.bottom
= 0;
1348 } else if(iface
== myDevice
->stencilBufferTarget
) {
1349 FIXME("Depth Stencil buffer locking is not implemented\n");
1351 /* The rest should be a normal texture */
1352 IWineD3DBaseTextureImpl
*impl
;
1353 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1354 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1355 * states need resetting
1357 if(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&impl
) == WINED3D_OK
) {
1358 if(impl
->baseTexture
.bindCount
) {
1359 IWineD3DDeviceImpl_MarkStateDirty(myDevice
, STATE_SAMPLER(impl
->baseTexture
.sampler
));
1361 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*) impl
);
1366 This
->Flags
&= ~SFLAG_LOCKED
;
1367 memset(&This
->lockedRect
, 0, sizeof(RECT
));
1369 /* Overlays have to be redrawn manually after changes with the GL implementation */
1370 if(This
->overlay_dest
) {
1371 IWineD3DSurface_DrawOverlay(iface
);
1376 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
1377 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1378 WINED3DLOCKED_RECT lock
;
1382 TRACE("(%p)->(%p)\n",This
,pHDC
);
1384 if(This
->Flags
& SFLAG_USERPTR
) {
1385 ERR("Not supported on surfaces with an application-provided surfaces\n");
1386 return WINEDDERR_NODC
;
1389 /* Give more detailed info for ddraw */
1390 if (This
->Flags
& SFLAG_DCINUSE
)
1391 return WINEDDERR_DCALREADYCREATED
;
1393 /* Can't GetDC if the surface is locked */
1394 if (This
->Flags
& SFLAG_LOCKED
)
1395 return WINED3DERR_INVALIDCALL
;
1397 /* According to Direct3D9 docs, only these formats are supported */
1398 if (((IWineD3DImpl
*)This
->resource
.wineD3DDevice
->wineD3D
)->dxVersion
> 7) {
1399 if (This
->resource
.format
!= WINED3DFMT_R5G6B5
&&
1400 This
->resource
.format
!= WINED3DFMT_X1R5G5B5
&&
1401 This
->resource
.format
!= WINED3DFMT_R8G8B8
&&
1402 This
->resource
.format
!= WINED3DFMT_X8R8G8B8
) return WINED3DERR_INVALIDCALL
;
1405 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
1407 /* Create a DIB section if there isn't a hdc yet */
1409 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
1410 if(This
->Flags
& SFLAG_CLIENT
) {
1411 IWineD3DSurface_PreLoad(iface
);
1414 /* Use the dib section from now on if we are not using a PBO */
1415 if(!(This
->Flags
& SFLAG_PBO
))
1416 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
1419 /* Lock the surface */
1420 hr
= IWineD3DSurface_LockRect(iface
,
1425 if(This
->Flags
& SFLAG_PBO
) {
1426 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1427 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, This
->dib
.bitmap_size
);
1431 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
1432 /* keep the dib section */
1436 if(This
->resource
.format
== WINED3DFMT_P8
||
1437 This
->resource
.format
== WINED3DFMT_A8P8
) {
1438 /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
1439 D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
1441 PALETTEENTRY
*pal
= NULL
;
1444 pal
= This
->palette
->palents
;
1446 IWineD3DSurfaceImpl
*dds_primary
;
1447 IWineD3DSwapChainImpl
*swapchain
;
1448 swapchain
= (IWineD3DSwapChainImpl
*)This
->resource
.wineD3DDevice
->swapchains
[0];
1449 dds_primary
= (IWineD3DSurfaceImpl
*)swapchain
->frontBuffer
;
1450 if (dds_primary
&& dds_primary
->palette
)
1451 pal
= dds_primary
->palette
->palents
;
1455 for (n
=0; n
<256; n
++) {
1456 col
[n
].rgbRed
= pal
[n
].peRed
;
1457 col
[n
].rgbGreen
= pal
[n
].peGreen
;
1458 col
[n
].rgbBlue
= pal
[n
].peBlue
;
1459 col
[n
].rgbReserved
= 0;
1461 SetDIBColorTable(This
->hDC
, 0, 256, col
);
1466 TRACE("returning %p\n",*pHDC
);
1467 This
->Flags
|= SFLAG_DCINUSE
;
1472 HRESULT WINAPI
IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
1473 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1475 TRACE("(%p)->(%p)\n",This
,hDC
);
1477 if (!(This
->Flags
& SFLAG_DCINUSE
))
1478 return WINED3DERR_INVALIDCALL
;
1480 if (This
->hDC
!=hDC
) {
1481 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
1482 return WINED3DERR_INVALIDCALL
;
1485 if((This
->Flags
& SFLAG_PBO
) && This
->resource
.allocatedMemory
) {
1486 /* Copy the contents of the DIB over to the PBO */
1487 memcpy(This
->resource
.allocatedMemory
, This
->dib
.bitmap_data
, This
->dib
.bitmap_size
);
1490 /* we locked first, so unlock now */
1491 IWineD3DSurface_UnlockRect(iface
);
1493 This
->Flags
&= ~SFLAG_DCINUSE
;
1498 /* ******************************************************
1499 IWineD3DSurface Internal (No mapping to directx api) parts follow
1500 ****************************************************** */
1502 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
) {
1503 BOOL colorkey_active
= need_alpha_ck
&& (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
);
1504 const GlPixelFormatDesc
*glDesc
;
1505 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1506 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
1508 /* Default values: From the surface */
1509 *format
= glDesc
->glFormat
;
1510 *type
= glDesc
->glType
;
1511 *convert
= NO_CONVERSION
;
1512 *target_bpp
= This
->bytesPerPixel
;
1515 *internal
= glDesc
->glGammaInternal
;
1516 } else if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
1517 *internal
= glDesc
->rtInternal
;
1519 *internal
= glDesc
->glInternal
;
1522 /* Ok, now look if we have to do any conversion */
1523 switch(This
->resource
.format
) {
1529 /* Use conversion when the paletted texture extension OR fragment shaders are available. When either
1530 * of the two is available make sure texturing is requested as neither of the two works in
1531 * conjunction with calls like glDraw-/glReadPixels. Further also use conversion in case of color keying.
1532 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
1533 * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
1534 * conflicts with this.
1536 if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE
) ||
1537 (GL_SUPPORT(ARB_FRAGMENT_PROGRAM
) &&
1538 device
->render_targets
&&
1539 This
== (IWineD3DSurfaceImpl
*)device
->render_targets
[0])) ||
1540 colorkey_active
|| !use_texturing
) {
1542 *internal
= GL_RGBA
;
1543 *type
= GL_UNSIGNED_BYTE
;
1545 if(colorkey_active
) {
1546 *convert
= CONVERT_PALETTED_CK
;
1548 *convert
= CONVERT_PALETTED
;
1551 else if(!GL_SUPPORT(EXT_PALETTED_TEXTURE
) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
1553 *internal
= GL_RGBA
;
1554 *type
= GL_UNSIGNED_BYTE
;
1560 case WINED3DFMT_R3G3B2
:
1561 /* **********************
1562 GL_UNSIGNED_BYTE_3_3_2
1563 ********************** */
1564 if (colorkey_active
) {
1565 /* This texture format will never be used.. So do not care about color keying
1566 up until the point in time it will be needed :-) */
1567 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1571 case WINED3DFMT_R5G6B5
:
1572 if (colorkey_active
) {
1573 *convert
= CONVERT_CK_565
;
1575 *internal
= GL_RGBA
;
1576 *type
= GL_UNSIGNED_SHORT_5_5_5_1
;
1580 case WINED3DFMT_X1R5G5B5
:
1581 if (colorkey_active
) {
1582 *convert
= CONVERT_CK_5551
;
1584 *internal
= GL_RGBA
;
1585 *type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
1589 case WINED3DFMT_R8G8B8
:
1590 if (colorkey_active
) {
1591 *convert
= CONVERT_CK_RGB24
;
1593 *internal
= GL_RGBA
;
1594 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1599 case WINED3DFMT_X8R8G8B8
:
1600 if (colorkey_active
) {
1601 *convert
= CONVERT_RGB32_888
;
1603 *internal
= GL_RGBA
;
1604 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1608 case WINED3DFMT_V8U8
:
1609 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1610 else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1611 *format
= GL_DUDV_ATI
;
1612 *internal
= GL_DU8DV8_ATI
;
1614 /* No conversion - Just change the gl type */
1617 *convert
= CONVERT_V8U8
;
1619 *internal
= GL_RGB8
;
1620 *type
= GL_UNSIGNED_BYTE
;
1624 case WINED3DFMT_L6V5U5
:
1625 *convert
= CONVERT_L6V5U5
;
1626 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1628 /* Use format and types from table */
1630 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1633 *internal
= GL_RGB5
;
1634 *type
= GL_UNSIGNED_SHORT_5_6_5
;
1638 case WINED3DFMT_X8L8V8U8
:
1639 *convert
= CONVERT_X8L8V8U8
;
1641 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1642 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1643 * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1644 * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1645 * the needed type and format parameter, so the internal format contains a
1646 * 4th component, which is returned as alpha
1649 /* Not supported by GL_ATI_envmap_bumpmap */
1651 *internal
= GL_RGB8
;
1652 *type
= GL_UNSIGNED_INT_8_8_8_8_REV
;
1656 case WINED3DFMT_Q8W8V8U8
:
1657 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1658 *convert
= CONVERT_Q8W8V8U8
;
1660 *internal
= GL_RGBA8
;
1661 *type
= GL_UNSIGNED_BYTE
;
1663 /* Not supported by GL_ATI_envmap_bumpmap */
1666 case WINED3DFMT_V16U16
:
1667 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1668 *convert
= CONVERT_V16U16
;
1670 *internal
= GL_RGB16_EXT
;
1671 *type
= GL_UNSIGNED_SHORT
;
1673 /* What should I do here about GL_ATI_envmap_bumpmap?
1674 * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1678 case WINED3DFMT_A4L4
:
1679 /* A4L4 exists as an internal gl format, but for some reason there is not
1680 * format+type combination to load it. Thus convert it to A8L8, then load it
1681 * with A4L4 internal, but A8L8 format+type
1683 *convert
= CONVERT_A4L4
;
1684 *format
= GL_LUMINANCE_ALPHA
;
1685 *internal
= GL_LUMINANCE4_ALPHA4
;
1686 *type
= GL_UNSIGNED_BYTE
;
1690 case WINED3DFMT_R32F
:
1691 /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1692 * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1693 * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1696 * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1698 *convert
= CONVERT_R32F
;
1700 *internal
= GL_RGB32F_ARB
;
1705 case WINED3DFMT_R16F
:
1706 /* Similar to R32F */
1707 *convert
= CONVERT_R16F
;
1709 *internal
= GL_RGB16F_ARB
;
1710 *type
= GL_HALF_FLOAT_ARB
;
1714 case WINED3DFMT_G16R16
:
1715 *convert
= CONVERT_G16R16
;
1717 *internal
= GL_RGB16_EXT
;
1718 *type
= GL_UNSIGNED_SHORT
;
1729 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*This
) {
1730 BYTE
*source
, *dest
;
1731 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src
, dst
, pitch
, height
, outpitch
, convert
,This
);
1736 memcpy(dst
, src
, pitch
* height
);
1739 case CONVERT_PALETTED
:
1740 case CONVERT_PALETTED_CK
:
1742 IWineD3DPaletteImpl
* pal
= This
->palette
;
1747 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1750 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
1752 for (y
= 0; y
< height
; y
++)
1754 source
= src
+ pitch
* y
;
1755 dest
= dst
+ outpitch
* y
;
1756 /* This is an 1 bpp format, using the width here is fine */
1757 for (x
= 0; x
< width
; x
++) {
1758 BYTE color
= *source
++;
1759 *dest
++ = table
[color
][0];
1760 *dest
++ = table
[color
][1];
1761 *dest
++ = table
[color
][2];
1762 *dest
++ = table
[color
][3];
1768 case CONVERT_CK_565
:
1770 /* Converting the 565 format in 5551 packed to emulate color-keying.
1772 Note : in all these conversion, it would be best to average the averaging
1773 pixels to get the color of the pixel that will be color-keyed to
1774 prevent 'color bleeding'. This will be done later on if ever it is
1777 Note2: Nvidia documents say that their driver does not support alpha + color keying
1778 on the same surface and disables color keying in such a case
1784 TRACE("Color keyed 565\n");
1786 for (y
= 0; y
< height
; y
++) {
1787 Source
= (WORD
*) (src
+ y
* pitch
);
1788 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1789 for (x
= 0; x
< width
; x
++ ) {
1790 WORD color
= *Source
++;
1791 *Dest
= ((color
& 0xFFC0) | ((color
& 0x1F) << 1));
1792 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1793 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1802 case CONVERT_CK_5551
:
1804 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1808 TRACE("Color keyed 5551\n");
1809 for (y
= 0; y
< height
; y
++) {
1810 Source
= (WORD
*) (src
+ y
* pitch
);
1811 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1812 for (x
= 0; x
< width
; x
++ ) {
1813 WORD color
= *Source
++;
1815 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1816 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1820 *Dest
&= ~(1 << 15);
1828 case CONVERT_RGB32_888
:
1830 /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
1832 for (y
= 0; y
< height
; y
++)
1834 source
= src
+ pitch
* y
;
1835 dest
= dst
+ outpitch
* y
;
1836 for (x
= 0; x
< width
; x
++) {
1837 DWORD color
= 0xffffff & *(DWORD
*)source
;
1838 DWORD dstcolor
= color
<< 8;
1839 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1840 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1843 *(DWORD
*)dest
= dstcolor
;
1855 unsigned char *Dest
;
1856 for(y
= 0; y
< height
; y
++) {
1857 Source
= (short *) (src
+ y
* pitch
);
1858 Dest
= dst
+ y
* outpitch
;
1859 for (x
= 0; x
< width
; x
++ ) {
1860 long color
= (*Source
++);
1861 /* B */ Dest
[0] = 0xff;
1862 /* G */ Dest
[1] = (color
>> 8) + 128; /* V */
1863 /* R */ Dest
[2] = (color
) + 128; /* U */
1870 case CONVERT_V16U16
:
1874 unsigned short *Dest
;
1875 for(y
= 0; y
< height
; y
++) {
1876 Source
= (DWORD
*) (src
+ y
* pitch
);
1877 Dest
= (unsigned short *) (dst
+ y
* outpitch
);
1878 for (x
= 0; x
< width
; x
++ ) {
1879 DWORD color
= (*Source
++);
1880 /* B */ Dest
[0] = 0xffff;
1881 /* G */ Dest
[1] = (color
>> 16) + 32768; /* V */
1882 /* R */ Dest
[2] = (color
) + 32768; /* U */
1889 case CONVERT_Q8W8V8U8
:
1893 unsigned char *Dest
;
1894 for(y
= 0; y
< height
; y
++) {
1895 Source
= (DWORD
*) (src
+ y
* pitch
);
1896 Dest
= dst
+ y
* outpitch
;
1897 for (x
= 0; x
< width
; x
++ ) {
1898 long color
= (*Source
++);
1899 /* B */ Dest
[0] = ((color
>> 16) & 0xff) + 128; /* W */
1900 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1901 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1902 /* A */ Dest
[3] = ((color
>> 24) & 0xff) + 128; /* Q */
1909 case CONVERT_L6V5U5
:
1913 unsigned char *Dest
;
1915 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1916 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1917 * fixed function and shaders without further conversion once the surface is
1920 for(y
= 0; y
< height
; y
++) {
1921 Source
= (WORD
*) (src
+ y
* pitch
);
1922 Dest
= dst
+ y
* outpitch
;
1923 for (x
= 0; x
< width
; x
++ ) {
1924 short color
= (*Source
++);
1925 unsigned char l
= ((color
>> 10) & 0xfc);
1926 char v
= ((color
>> 5) & 0x3e);
1927 char u
= ((color
) & 0x1f);
1929 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1930 * and doubles the positive range. Thus shift left only once, gl does the 2nd
1931 * shift. GL reads a signed value and converts it into an unsigned value.
1933 /* M */ Dest
[2] = l
<< 1;
1935 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1936 * from 5 bit values to 8 bit values.
1938 /* V */ Dest
[1] = v
<< 3;
1939 /* U */ Dest
[0] = u
<< 3;
1944 for(y
= 0; y
< height
; y
++) {
1945 unsigned short *Dest_s
= (unsigned short *) (dst
+ y
* outpitch
);
1946 Source
= (WORD
*) (src
+ y
* pitch
);
1947 for (x
= 0; x
< width
; x
++ ) {
1948 short color
= (*Source
++);
1949 unsigned char l
= ((color
>> 10) & 0xfc);
1950 short v
= ((color
>> 5) & 0x3e);
1951 short u
= ((color
) & 0x1f);
1952 short v_conv
= v
+ 16;
1953 short u_conv
= u
+ 16;
1955 *Dest_s
= ((v_conv
<< 11) & 0xf800) | ((l
<< 5) & 0x7e0) | (u_conv
& 0x1f);
1963 case CONVERT_X8L8V8U8
:
1967 unsigned char *Dest
;
1969 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1970 /* This implementation works with the fixed function pipeline and shaders
1971 * without further modification after converting the surface.
1973 for(y
= 0; y
< height
; y
++) {
1974 Source
= (DWORD
*) (src
+ y
* pitch
);
1975 Dest
= dst
+ y
* outpitch
;
1976 for (x
= 0; x
< width
; x
++ ) {
1977 long color
= (*Source
++);
1978 /* L */ Dest
[2] = ((color
>> 16) & 0xff); /* L */
1979 /* V */ Dest
[1] = ((color
>> 8 ) & 0xff); /* V */
1980 /* U */ Dest
[0] = (color
& 0xff); /* U */
1981 /* I */ Dest
[3] = 255; /* X */
1986 /* Doesn't work correctly with the fixed function pipeline, but can work in
1987 * shaders if the shader is adjusted. (There's no use for this format in gl's
1988 * standard fixed function pipeline anyway).
1990 for(y
= 0; y
< height
; y
++) {
1991 Source
= (DWORD
*) (src
+ y
* pitch
);
1992 Dest
= dst
+ y
* outpitch
;
1993 for (x
= 0; x
< width
; x
++ ) {
1994 long color
= (*Source
++);
1995 /* B */ Dest
[0] = ((color
>> 16) & 0xff); /* L */
1996 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1997 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
2008 unsigned char *Source
;
2009 unsigned char *Dest
;
2010 for(y
= 0; y
< height
; y
++) {
2011 Source
= src
+ y
* pitch
;
2012 Dest
= dst
+ y
* outpitch
;
2013 for (x
= 0; x
< width
; x
++ ) {
2014 unsigned char color
= (*Source
++);
2015 /* A */ Dest
[1] = (color
& 0xf0) << 0;
2016 /* L */ Dest
[0] = (color
& 0x0f) << 4;
2028 for(y
= 0; y
< height
; y
++) {
2029 Source
= (float *) (src
+ y
* pitch
);
2030 Dest
= (float *) (dst
+ y
* outpitch
);
2031 for (x
= 0; x
< width
; x
++ ) {
2032 float color
= (*Source
++);
2048 for(y
= 0; y
< height
; y
++) {
2049 Source
= (WORD
*) (src
+ y
* pitch
);
2050 Dest
= (WORD
*) (dst
+ y
* outpitch
);
2051 for (x
= 0; x
< width
; x
++ ) {
2052 WORD color
= (*Source
++);
2062 case CONVERT_G16R16
:
2068 for(y
= 0; y
< height
; y
++) {
2069 Source
= (WORD
*) (src
+ y
* pitch
);
2070 Dest
= (WORD
*) (dst
+ y
* outpitch
);
2071 for (x
= 0; x
< width
; x
++ ) {
2072 WORD green
= (*Source
++);
2073 WORD red
= (*Source
++);
2084 ERR("Unsupported conversation type %d\n", convert
);
2089 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
) {
2090 IWineD3DPaletteImpl
* pal
= This
->palette
;
2091 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2092 BOOL index_in_alpha
= FALSE
;
2093 int dxVersion
= ( (IWineD3DImpl
*) device
->wineD3D
)->dxVersion
;
2096 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
2097 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
2098 * is slow. Further RGB->P8 conversion is not possible because palettes can have
2099 * duplicate entries. Store the color key in the unused alpha component to speed the
2100 * download up and to make conversion unneeded. */
2101 index_in_alpha
= primary_render_target_is_p8(device
);
2104 /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
2105 if(dxVersion
<= 7) {
2106 ERR("This code should never get entered for DirectDraw!, expect problems\n");
2107 if(index_in_alpha
) {
2108 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
2109 there's no palette at this time. */
2110 for (i
= 0; i
< 256; i
++) table
[i
][3] = i
;
2113 /* Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
2114 alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
2115 capability flag is present (wine does advertise this capability) */
2116 for (i
= 0; i
< 256; i
++) {
2117 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
2118 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
2119 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
2120 table
[i
][3] = device
->palettes
[device
->currentPalette
][i
].peFlags
;
2124 TRACE("Using surface palette %p\n", pal
);
2125 /* Get the surface's palette */
2126 for (i
= 0; i
< 256; i
++) {
2127 table
[i
][0] = pal
->palents
[i
].peRed
;
2128 table
[i
][1] = pal
->palents
[i
].peGreen
;
2129 table
[i
][2] = pal
->palents
[i
].peBlue
;
2131 /* When index_in_alpha is the palette index is stored in the alpha component. In case of a readback
2132 we can then read GL_ALPHA. Color keying is handled in BltOverride using a GL_ALPHA_TEST using GL_NOT_EQUAL.
2133 In case of index_in_alpha the color key itself is passed to glAlphaFunc in other cases the alpha component
2134 of pixels that should be masked away is set to 0. */
2135 if(index_in_alpha
) {
2137 } else if(colorkey
&& (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) && (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
2139 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
2140 table
[i
][3] = pal
->palents
[i
].peFlags
;
2148 const char *fragment_palette_conversion
=
2151 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n" /* { 255/256, 0.5/255*255/256, 0, 0 } */
2152 "TEX index, fragment.texcoord[0], texture[0], 2D;\n" /* The alpha-component contains the palette index */
2153 "MAD index.a, index.a, 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 */
2154 "TEX result.color, index.a, texture[1], 1D;\n" /* use the alpha-component as a index in the palette to get the final color */
2157 /* This function is used in case of 8bit paletted textures to upload the palette.
2158 It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
2159 extensions like ATI_fragment_shaders is possible.
2161 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
) {
2162 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2164 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2166 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
2168 /* Try to use the paletted texture extension */
2169 if(GL_SUPPORT(EXT_PALETTED_TEXTURE
))
2171 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2172 GL_EXTCALL(glColorTableEXT(This
->glDescription
.target
,GL_RGBA
,256,GL_RGBA
,GL_UNSIGNED_BYTE
, table
));
2176 /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2177 * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2178 TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2180 /* Create the fragment program if we don't have it */
2181 if(!device
->paletteConversionShader
)
2183 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2184 GL_EXTCALL(glGenProgramsARB(1, &device
->paletteConversionShader
));
2185 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2186 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
, strlen(fragment_palette_conversion
), (const GLbyte
*)fragment_palette_conversion
));
2187 glDisable(GL_FRAGMENT_PROGRAM_ARB
);
2190 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2191 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2193 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1
));
2194 glEnable(GL_TEXTURE_1D
);
2195 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
2197 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2198 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
); /* Make sure we have discrete color levels. */
2199 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
2200 glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA
, 256, 0, GL_RGBA
, GL_UNSIGNED_BYTE
, table
); /* Upload the palette */
2202 /* Switch back to unit 0 in which the 2D texture will be stored. */
2203 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0
));
2205 /* Rebind the texture because it isn't bound anymore */
2206 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2210 BOOL
palette9_changed(IWineD3DSurfaceImpl
*This
) {
2211 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2213 if(This
->palette
|| (This
->resource
.format
!= WINED3DFMT_P8
&& This
->resource
.format
!= WINED3DFMT_A8P8
)) {
2214 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2215 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2220 if(This
->palette9
) {
2221 if(memcmp(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256) == 0) {
2225 This
->palette9
= HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY
) * 256);
2227 memcpy(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256);
2231 static inline void clear_unused_channels(IWineD3DSurfaceImpl
*This
) {
2232 GLboolean oldwrite
[4];
2234 /* Some formats have only some color channels, and the others are 1.0.
2235 * since our rendering renders to all channels, and those pixel formats
2236 * are emulated by using a full texture with the other channels set to 1.0
2237 * manually, clear the unused channels.
2239 * This could be done with hacking colorwriteenable to mask the colors,
2240 * but before drawing the buffer would have to be cleared too, so there's
2243 switch(This
->resource
.format
) {
2244 case WINED3DFMT_R16F
:
2245 case WINED3DFMT_R32F
:
2246 TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2247 /* Do not activate a context, the correct drawable is active already
2248 * though just the read buffer is set, make sure to have the correct draw
2251 glDrawBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
2252 glDisable(GL_SCISSOR_TEST
);
2253 glGetBooleanv(GL_COLOR_WRITEMASK
, oldwrite
);
2254 glColorMask(GL_FALSE
, GL_TRUE
, GL_TRUE
, GL_TRUE
);
2255 glClearColor(0.0, 1.0, 1.0, 1.0);
2256 glClear(GL_COLOR_BUFFER_BIT
);
2257 glColorMask(oldwrite
[0], oldwrite
[1], oldwrite
[2], oldwrite
[3]);
2258 if(!This
->resource
.wineD3DDevice
->render_offscreen
) glDrawBuffer(GL_BACK
);
2259 checkGLcall("Unused channel clear\n");
2266 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
) {
2267 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2269 if (!(This
->Flags
& SFLAG_INTEXTURE
)) {
2270 TRACE("Reloading because surface is dirty\n");
2271 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2272 ((This
->Flags
& SFLAG_GLCKEY
) && (!(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
))) ||
2273 /* Reload: vice versa OR */
2274 ((!(This
->Flags
& SFLAG_GLCKEY
)) && (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
)) ||
2275 /* Also reload: Color key is active AND the color key has changed */
2276 ((This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) && (
2277 (This
->glCKey
.dwColorSpaceLowValue
!= This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
2278 (This
->glCKey
.dwColorSpaceHighValue
!= This
->SrcBltCKey
.dwColorSpaceHighValue
)))) {
2279 TRACE("Reloading because of color keying\n");
2280 /* To perform the color key conversion we need a sysmem copy of
2281 * the surface. Make sure we have it
2284 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2285 /* Make sure the texture is reloaded because of the color key change, this kills performance though :( */
2286 /* TODO: This is not necessarily needed with hw palettized texture support */
2287 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2289 TRACE("surface is already in texture\n");
2293 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2294 * These resources are not bound by device size or format restrictions. Because of this,
2295 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2296 * However, these resources can always be created, locked, and copied.
2298 if (This
->resource
.pool
== WINED3DPOOL_SCRATCH
)
2300 FIXME("(%p) Operation not supported for scratch textures\n",This
);
2301 return WINED3DERR_INVALIDCALL
;
2304 This
->srgb
= srgb_mode
;
2305 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* no partial locking for textures yet */);
2309 static unsigned int gen
= 0;
2312 if ((gen
% 10) == 0) {
2313 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
2314 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
2317 * debugging crash code
2326 if (!(This
->Flags
& SFLAG_DONOTFREE
)) {
2327 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
2328 This
->resource
.allocatedMemory
= NULL
;
2329 This
->resource
.heapMemory
= NULL
;
2330 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, FALSE
);
2336 static void WINAPI
IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface
*iface
) {
2337 /* TODO: check for locks */
2338 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2339 IWineD3DBaseTexture
*baseTexture
= NULL
;
2340 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2342 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
2343 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2344 TRACE("Passing to container\n");
2345 IWineD3DBaseTexture_BindTexture(baseTexture
);
2346 IWineD3DBaseTexture_Release(baseTexture
);
2348 TRACE("(%p) : Binding surface\n", This
);
2350 if(!device
->isInDraw
) {
2351 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
2356 glEnable(This
->glDescription
.target
);
2358 if (!This
->glDescription
.level
) {
2359 if (!This
->glDescription
.textureName
) {
2360 glGenTextures(1, &This
->glDescription
.textureName
);
2361 checkGLcall("glGenTextures");
2362 TRACE("Surface %p given name %d\n", This
, This
->glDescription
.textureName
);
2364 /* This is where we should be reducing the amount of GLMemoryUsed */
2365 } else if (This
->glDescription
.textureName
) {
2366 /* Mipmap surfaces should have a base texture container */
2367 ERR("Mipmap surface has a glTexture bound to it!\n");
2370 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2371 checkGLcall("glBindTexture");
2380 HRESULT WINAPI
IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
, const char* filename
) {
2383 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2384 char *allocatedMemory
;
2386 IWineD3DSwapChain
*swapChain
= NULL
;
2388 GLuint tmpTexture
= 0;
2391 Textures may not be stored in ->allocatedgMemory and a GlTexture
2392 so we should lock the surface before saving a snapshot, or at least check that
2394 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2395 by calling GetTexImage and in compressed form by calling
2396 GetCompressedTexImageARB. Queried compressed images can be saved and
2397 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2398 texture images do not need to be processed by the GL and should
2399 significantly improve texture loading performance relative to uncompressed
2402 /* Setup the width and height to be the internal texture width and height. */
2403 width
= This
->pow2Width
;
2404 height
= This
->pow2Height
;
2405 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2406 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapChain
);
2408 if (This
->Flags
& SFLAG_INDRAWABLE
&& !(This
->Flags
& SFLAG_INTEXTURE
)) {
2409 /* if were not a real texture then read the back buffer into a real texture */
2410 /* we don't want to interfere with the back buffer so read the data into a temporary
2411 * texture and then save the data out of the temporary texture
2415 TRACE("(%p) Reading render target into texture\n", This
);
2416 glEnable(GL_TEXTURE_2D
);
2418 glGenTextures(1, &tmpTexture
);
2419 glBindTexture(GL_TEXTURE_2D
, tmpTexture
);
2421 glTexImage2D(GL_TEXTURE_2D
,
2428 GL_UNSIGNED_INT_8_8_8_8_REV
,
2431 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
2432 vcheckGLcall("glGetIntegerv");
2433 glReadBuffer(swapChain
? GL_BACK
: This
->resource
.wineD3DDevice
->offscreenBuffer
);
2434 vcheckGLcall("glReadBuffer");
2435 glCopyTexImage2D(GL_TEXTURE_2D
,
2444 checkGLcall("glCopyTexImage2D");
2445 glReadBuffer(prevRead
);
2448 } else { /* bind the real texture, and make sure it up to date */
2449 IWineD3DSurface_PreLoad(iface
);
2451 allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, width
* height
* 4);
2453 FIXME("Saving texture level %d width %d height %d\n", This
->glDescription
.level
, width
, height
);
2454 glGetTexImage(GL_TEXTURE_2D
,
2455 This
->glDescription
.level
,
2457 GL_UNSIGNED_INT_8_8_8_8_REV
,
2459 checkGLcall("glTexImage2D");
2461 glBindTexture(GL_TEXTURE_2D
, 0);
2462 glDeleteTextures(1, &tmpTexture
);
2466 f
= fopen(filename
, "w+");
2468 ERR("opening of %s failed with: %s\n", filename
, strerror(errno
));
2469 return WINED3DERR_INVALIDCALL
;
2471 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2472 TRACE("(%p) opened %s with format %s\n", This
, filename
, debug_d3dformat(This
->resource
.format
));
2487 fwrite(&width
,2,1,f
);
2489 fwrite(&height
,2,1,f
);
2494 /* 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 */
2496 textureRow
= allocatedMemory
+ (width
* (height
- 1) *4);
2498 textureRow
= allocatedMemory
;
2499 for (y
= 0 ; y
< height
; y
++) {
2500 for (i
= 0; i
< width
; i
++) {
2501 color
= *((DWORD
*)textureRow
);
2502 fputc((color
>> 16) & 0xFF, f
); /* B */
2503 fputc((color
>> 8) & 0xFF, f
); /* G */
2504 fputc((color
>> 0) & 0xFF, f
); /* R */
2505 fputc((color
>> 24) & 0xFF, f
); /* A */
2508 /* take two rows of the pointer to the texture memory */
2510 (textureRow
-= width
<< 3);
2513 TRACE("Closing file\n");
2517 IWineD3DSwapChain_Release(swapChain
);
2519 HeapFree(GetProcessHeap(), 0, allocatedMemory
);
2524 * Slightly inefficient way to handle multiple dirty rects but it works :)
2526 HRESULT WINAPI
IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
2527 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2528 IWineD3DBaseTexture
*baseTexture
= NULL
;
2530 if (!(This
->Flags
& SFLAG_INSYSMEM
) && (This
->Flags
& SFLAG_INTEXTURE
))
2531 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
2533 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2534 if (NULL
!= pDirtyRect
) {
2535 This
->dirtyRect
.left
= min(This
->dirtyRect
.left
, pDirtyRect
->left
);
2536 This
->dirtyRect
.top
= min(This
->dirtyRect
.top
, pDirtyRect
->top
);
2537 This
->dirtyRect
.right
= max(This
->dirtyRect
.right
, pDirtyRect
->right
);
2538 This
->dirtyRect
.bottom
= max(This
->dirtyRect
.bottom
, pDirtyRect
->bottom
);
2540 This
->dirtyRect
.left
= 0;
2541 This
->dirtyRect
.top
= 0;
2542 This
->dirtyRect
.right
= This
->currentDesc
.Width
;
2543 This
->dirtyRect
.bottom
= This
->currentDesc
.Height
;
2545 TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This
, This
->dirtyRect
.left
,
2546 This
->dirtyRect
.top
, This
->dirtyRect
.right
, This
->dirtyRect
.bottom
);
2547 /* if the container is a basetexture then mark it dirty. */
2548 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2549 TRACE("Passing to container\n");
2550 IWineD3DBaseTexture_SetDirty(baseTexture
, TRUE
);
2551 IWineD3DBaseTexture_Release(baseTexture
);
2556 HRESULT WINAPI
IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
2557 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2559 const GlPixelFormatDesc
*glDesc
;
2560 getFormatDescEntry(format
, &GLINFO_LOCATION
, &glDesc
);
2562 TRACE("(%p) : Calling base function first\n", This
);
2563 hr
= IWineD3DBaseSurfaceImpl_SetFormat(iface
, format
);
2565 /* Setup some glformat defaults */
2566 This
->glDescription
.glFormat
= glDesc
->glFormat
;
2567 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
2568 This
->glDescription
.glType
= glDesc
->glType
;
2570 This
->Flags
&= ~SFLAG_ALLOCATED
;
2571 TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This
,
2572 This
->glDescription
.glFormat
, This
->glDescription
.glFormatInternal
, This
->glDescription
.glType
);
2577 HRESULT WINAPI
IWineD3DSurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
2578 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
2580 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
2581 WARN("Surface is locked or the HDC is in use\n");
2582 return WINED3DERR_INVALIDCALL
;
2585 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
2586 void *release
= NULL
;
2588 /* Do I have to copy the old surface content? */
2589 if(This
->Flags
& SFLAG_DIBSECTION
) {
2590 /* Release the DC. No need to hold the critical section for the update
2591 * Thread because this thread runs only on front buffers, but this method
2592 * fails for render targets in the check above.
2594 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
2595 DeleteDC(This
->hDC
);
2596 /* Release the DIB section */
2597 DeleteObject(This
->dib
.DIBsection
);
2598 This
->dib
.bitmap_data
= NULL
;
2599 This
->resource
.allocatedMemory
= NULL
;
2601 This
->Flags
&= ~SFLAG_DIBSECTION
;
2602 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
2603 release
= This
->resource
.heapMemory
;
2604 This
->resource
.heapMemory
= NULL
;
2606 This
->resource
.allocatedMemory
= Mem
;
2607 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
2609 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2610 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2612 /* For client textures opengl has to be notified */
2613 if(This
->Flags
& SFLAG_CLIENT
) {
2614 This
->Flags
&= ~SFLAG_ALLOCATED
;
2615 IWineD3DSurface_PreLoad(iface
);
2616 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2619 /* Now free the old memory if any */
2620 HeapFree(GetProcessHeap(), 0, release
);
2621 } else if(This
->Flags
& SFLAG_USERPTR
) {
2622 /* LockRect and GetDC will re-create the dib section and allocated memory */
2623 This
->resource
.allocatedMemory
= NULL
;
2624 /* HeapMemory should be NULL already */
2625 if(This
->resource
.heapMemory
!= NULL
) ERR("User pointer surface has heap memory allocated\n");
2626 This
->Flags
&= ~SFLAG_USERPTR
;
2628 if(This
->Flags
& SFLAG_CLIENT
) {
2629 This
->Flags
&= ~SFLAG_ALLOCATED
;
2630 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2631 IWineD3DSurface_PreLoad(iface
);
2637 void flip_surface(IWineD3DSurfaceImpl
*front
, IWineD3DSurfaceImpl
*back
) {
2639 /* Flip the surface contents */
2644 front
->hDC
= back
->hDC
;
2648 /* Flip the DIBsection */
2651 BOOL hasDib
= front
->Flags
& SFLAG_DIBSECTION
;
2652 tmp
= front
->dib
.DIBsection
;
2653 front
->dib
.DIBsection
= back
->dib
.DIBsection
;
2654 back
->dib
.DIBsection
= tmp
;
2656 if(back
->Flags
& SFLAG_DIBSECTION
) front
->Flags
|= SFLAG_DIBSECTION
;
2657 else front
->Flags
&= ~SFLAG_DIBSECTION
;
2658 if(hasDib
) back
->Flags
|= SFLAG_DIBSECTION
;
2659 else back
->Flags
&= ~SFLAG_DIBSECTION
;
2662 /* Flip the surface data */
2666 tmp
= front
->dib
.bitmap_data
;
2667 front
->dib
.bitmap_data
= back
->dib
.bitmap_data
;
2668 back
->dib
.bitmap_data
= tmp
;
2670 tmp
= front
->resource
.allocatedMemory
;
2671 front
->resource
.allocatedMemory
= back
->resource
.allocatedMemory
;
2672 back
->resource
.allocatedMemory
= tmp
;
2674 tmp
= front
->resource
.heapMemory
;
2675 front
->resource
.heapMemory
= back
->resource
.heapMemory
;
2676 back
->resource
.heapMemory
= tmp
;
2681 GLuint tmp_pbo
= front
->pbo
;
2682 front
->pbo
= back
->pbo
;
2683 back
->pbo
= tmp_pbo
;
2686 /* client_memory should not be different, but just in case */
2689 tmp
= front
->dib
.client_memory
;
2690 front
->dib
.client_memory
= back
->dib
.client_memory
;
2691 back
->dib
.client_memory
= tmp
;
2694 /* Flip the opengl texture */
2696 glDescriptor tmp_desc
= back
->glDescription
;
2697 back
->glDescription
= front
->glDescription
;
2698 front
->glDescription
= tmp_desc
;
2702 DWORD tmp_flags
= back
->Flags
;
2703 back
->Flags
= front
->Flags
;
2704 front
->Flags
= tmp_flags
;
2708 static HRESULT WINAPI
IWineD3DSurfaceImpl_Flip(IWineD3DSurface
*iface
, IWineD3DSurface
*override
, DWORD Flags
) {
2709 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2710 IWineD3DSwapChainImpl
*swapchain
= NULL
;
2712 TRACE("(%p)->(%p,%x)\n", This
, override
, Flags
);
2714 /* Flipping is only supported on RenderTargets and overlays*/
2715 if( !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_OVERLAY
)) ) {
2716 WARN("Tried to flip a non-render target, non-overlay surface\n");
2717 return WINEDDERR_NOTFLIPPABLE
;
2720 if(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
) {
2721 flip_surface(This
, (IWineD3DSurfaceImpl
*) override
);
2723 /* Update the overlay if it is visible */
2724 if(This
->overlay_dest
) {
2725 return IWineD3DSurface_DrawOverlay((IWineD3DSurface
*) This
);
2732 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2733 * FIXME("(%p) Target override is not supported by now\n", This);
2734 * Additionally, it isn't really possible to support triple-buffering
2735 * properly on opengl at all
2739 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
2741 ERR("Flipped surface is not on a swapchain\n");
2742 return WINEDDERR_NOTFLIPPABLE
;
2745 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2746 * and only d3d8 and d3d9 apps specify the presentation interval
2748 if((Flags
& (WINEDDFLIP_NOVSYNC
| WINEDDFLIP_INTERVAL2
| WINEDDFLIP_INTERVAL3
| WINEDDFLIP_INTERVAL4
)) == 0) {
2749 /* Most common case first to avoid wasting time on all the other cases */
2750 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_ONE
;
2751 } else if(Flags
& WINEDDFLIP_NOVSYNC
) {
2752 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2753 } else if(Flags
& WINEDDFLIP_INTERVAL2
) {
2754 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_TWO
;
2755 } else if(Flags
& WINEDDFLIP_INTERVAL3
) {
2756 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_THREE
;
2758 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_FOUR
;
2761 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2762 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
2763 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
2767 /* Does a direct frame buffer -> texture copy. Stretching is done
2768 * with single pixel copy calls
2770 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2771 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2774 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2777 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2778 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2781 /* TODO: Do we need GL_TEXTURE_2D enabled fpr copyteximage? */
2782 glEnable(This
->glDescription
.target
);
2783 checkGLcall("glEnable(This->glDescription.target)");
2785 /* Bind the target texture */
2786 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2787 checkGLcall("glBindTexture");
2789 TRACE("Reading from an offscreen target\n");
2790 upsidedown
= !upsidedown
;
2791 glReadBuffer(myDevice
->offscreenBuffer
);
2793 GLenum buffer
= surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
);
2794 glReadBuffer(buffer
);
2796 checkGLcall("glReadBuffer");
2798 xrel
= (float) (srect
->x2
- srect
->x1
) / (float) (drect
->x2
- drect
->x1
);
2799 yrel
= (float) (srect
->y2
- srect
->y1
) / (float) (drect
->y2
- drect
->y1
);
2801 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2802 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2804 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
2805 ERR("Texture filtering not supported in direct blit\n");
2807 } else if((Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) && ((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2808 ERR("Texture filtering not supported in direct blit\n");
2812 !((xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) &&
2813 !((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2814 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2816 glCopyTexSubImage2D(This
->glDescription
.target
,
2817 This
->glDescription
.level
,
2818 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2819 srect
->x1
, Src
->currentDesc
.Height
- srect
->y2
,
2820 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2822 UINT yoffset
= Src
->currentDesc
.Height
- srect
->y1
+ drect
->y1
- 1;
2823 /* I have to process this row by row to swap the image,
2824 * otherwise it would be upside down, so stretching in y direction
2825 * doesn't cost extra time
2827 * However, stretching in x direction can be avoided if not necessary
2829 for(row
= drect
->y1
; row
< drect
->y2
; row
++) {
2830 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2831 /* Well, that stuff works, but it's very slow.
2832 * find a better way instead
2836 for(col
= drect
->x1
; col
< drect
->x2
; col
++) {
2837 glCopyTexSubImage2D(This
->glDescription
.target
,
2838 This
->glDescription
.level
,
2839 drect
->x1
+ col
, row
, /* xoffset, yoffset */
2840 srect
->x1
+ col
* xrel
, yoffset
- (int) (row
* yrel
),
2844 glCopyTexSubImage2D(This
->glDescription
.target
,
2845 This
->glDescription
.level
,
2846 drect
->x1
, row
, /* xoffset, yoffset */
2847 srect
->x1
, yoffset
- (int) (row
* yrel
),
2848 drect
->x2
-drect
->x1
, 1);
2852 vcheckGLcall("glCopyTexSubImage2D");
2854 /* Leave the opengl state valid for blitting */
2855 glDisable(This
->glDescription
.target
);
2856 checkGLcall("glDisable(This->glDescription.target)");
2861 /* Uses the hardware to stretch and flip the image */
2862 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2863 GLuint src
, backup
= 0;
2864 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2865 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2866 float left
, right
, top
, bottom
; /* Texture coordinates */
2867 UINT fbwidth
= Src
->currentDesc
.Width
;
2868 UINT fbheight
= Src
->currentDesc
.Height
;
2869 GLenum drawBuffer
= GL_BACK
;
2870 GLenum texture_target
;
2871 BOOL noBackBufferBackup
;
2873 TRACE("Using hwstretch blit\n");
2874 /* Activate the Proper context for reading from the source surface, set it up for blitting */
2875 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2876 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2878 noBackBufferBackup
= !swapchain
&& wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
;
2879 if(!noBackBufferBackup
&& Src
->glDescription
.textureName
== 0) {
2880 /* Get it a description */
2881 IWineD3DSurface_PreLoad(SrcSurface
);
2885 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2886 * This way we don't have to wait for the 2nd readback to finish to leave this function.
2888 if(myDevice
->activeContext
->aux_buffers
>= 2) {
2889 /* Got more than one aux buffer? Use the 2nd aux buffer */
2890 drawBuffer
= GL_AUX1
;
2891 } else if((swapchain
|| myDevice
->offscreenBuffer
== GL_BACK
) && myDevice
->activeContext
->aux_buffers
>= 1) {
2892 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2893 drawBuffer
= GL_AUX0
;
2896 if(noBackBufferBackup
) {
2897 glGenTextures(1, &backup
);
2898 checkGLcall("glGenTextures\n");
2899 glBindTexture(GL_TEXTURE_2D
, backup
);
2900 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2901 texture_target
= GL_TEXTURE_2D
;
2903 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2904 * we are reading from the back buffer, the backup can be used as source texture
2906 texture_target
= Src
->glDescription
.target
;
2907 glBindTexture(texture_target
, Src
->glDescription
.textureName
);
2908 checkGLcall("glBindTexture(texture_target, Src->glDescription.textureName)");
2909 glEnable(texture_target
);
2910 checkGLcall("glEnable(texture_target)");
2912 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2913 Src
->Flags
&= ~SFLAG_INTEXTURE
;
2917 glReadBuffer(surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
));
2919 TRACE("Reading from an offscreen target\n");
2920 upsidedown
= !upsidedown
;
2921 glReadBuffer(myDevice
->offscreenBuffer
);
2924 /* TODO: Only back up the part that will be overwritten */
2925 glCopyTexSubImage2D(texture_target
, 0,
2926 0, 0 /* read offsets */,
2931 checkGLcall("glCopyTexSubImage2D");
2933 /* No issue with overriding these - the sampler is dirty due to blit usage */
2934 glTexParameteri(texture_target
, GL_TEXTURE_MAG_FILTER
,
2935 magLookup
[Filter
- WINED3DTEXF_NONE
]);
2936 checkGLcall("glTexParameteri");
2937 glTexParameteri(texture_target
, GL_TEXTURE_MIN_FILTER
,
2938 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2939 checkGLcall("glTexParameteri");
2941 if(!swapchain
|| (IWineD3DSurface
*) Src
== swapchain
->backBuffer
[0]) {
2942 src
= backup
? backup
: Src
->glDescription
.textureName
;
2944 glReadBuffer(GL_FRONT
);
2945 checkGLcall("glReadBuffer(GL_FRONT)");
2947 glGenTextures(1, &src
);
2948 checkGLcall("glGenTextures(1, &src)");
2949 glBindTexture(GL_TEXTURE_2D
, src
);
2950 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2952 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2953 * out for power of 2 sizes
2955 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, Src
->pow2Width
, Src
->pow2Height
, 0,
2956 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
2957 checkGLcall("glTexImage2D");
2958 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2959 0, 0 /* read offsets */,
2964 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2965 checkGLcall("glTexParameteri");
2966 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2967 checkGLcall("glTexParameteri");
2969 glReadBuffer(GL_BACK
);
2970 checkGLcall("glReadBuffer(GL_BACK)");
2972 if(texture_target
!= GL_TEXTURE_2D
) {
2973 glDisable(texture_target
);
2974 glEnable(GL_TEXTURE_2D
);
2975 texture_target
= GL_TEXTURE_2D
;
2978 checkGLcall("glEnd and previous");
2984 top
= Src
->currentDesc
.Height
- srect
->y1
;
2985 bottom
= Src
->currentDesc
.Height
- srect
->y2
;
2987 top
= Src
->currentDesc
.Height
- srect
->y2
;
2988 bottom
= Src
->currentDesc
.Height
- srect
->y1
;
2991 if(Src
->Flags
& SFLAG_NORMCOORD
) {
2992 left
/= Src
->pow2Width
;
2993 right
/= Src
->pow2Width
;
2994 top
/= Src
->pow2Height
;
2995 bottom
/= Src
->pow2Height
;
2998 /* draw the source texture stretched and upside down. The correct surface is bound already */
2999 glTexParameteri(texture_target
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3000 glTexParameteri(texture_target
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3002 glDrawBuffer(drawBuffer
);
3003 glReadBuffer(drawBuffer
);
3007 glTexCoord2f(left
, bottom
);
3008 glVertex2i(0, fbheight
);
3011 glTexCoord2f(left
, top
);
3012 glVertex2i(0, fbheight
- drect
->y2
- drect
->y1
);
3015 glTexCoord2f(right
, top
);
3016 glVertex2i(drect
->x2
- drect
->x1
, fbheight
- drect
->y2
- drect
->y1
);
3019 glTexCoord2f(right
, bottom
);
3020 glVertex2i(drect
->x2
- drect
->x1
, fbheight
);
3022 checkGLcall("glEnd and previous");
3024 if(texture_target
!= This
->glDescription
.target
) {
3025 glDisable(texture_target
);
3026 glEnable(This
->glDescription
.target
);
3027 texture_target
= This
->glDescription
.target
;
3030 /* Now read the stretched and upside down image into the destination texture */
3031 glBindTexture(texture_target
, This
->glDescription
.textureName
);
3032 checkGLcall("glBindTexture");
3033 glCopyTexSubImage2D(texture_target
,
3035 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
3036 0, 0, /* We blitted the image to the origin */
3037 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
3038 checkGLcall("glCopyTexSubImage2D");
3040 if(drawBuffer
== GL_BACK
) {
3041 /* Write the back buffer backup back */
3043 if(texture_target
!= GL_TEXTURE_2D
) {
3044 glDisable(texture_target
);
3045 glEnable(GL_TEXTURE_2D
);
3046 texture_target
= GL_TEXTURE_2D
;
3048 glBindTexture(GL_TEXTURE_2D
, backup
);
3049 checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3051 if(texture_target
!= Src
->glDescription
.target
) {
3052 glDisable(texture_target
);
3053 glEnable(Src
->glDescription
.target
);
3054 texture_target
= Src
->glDescription
.target
;
3056 glBindTexture(Src
->glDescription
.target
, Src
->glDescription
.textureName
);
3057 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
3062 glTexCoord2f(0.0, (float) fbheight
/ (float) Src
->pow2Height
);
3066 glTexCoord2f(0.0, 0.0);
3067 glVertex2i(0, fbheight
);
3070 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, 0.0);
3071 glVertex2i(fbwidth
, Src
->currentDesc
.Height
);
3074 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, (float) fbheight
/ (float) Src
->pow2Height
);
3075 glVertex2i(fbwidth
, 0);
3078 /* Restore the old draw buffer */
3079 glDrawBuffer(GL_BACK
);
3081 glDisable(texture_target
);
3082 checkGLcall("glDisable(texture_target)");
3085 if(src
!= Src
->glDescription
.textureName
&& src
!= backup
) {
3086 glDeleteTextures(1, &src
);
3087 checkGLcall("glDeleteTextures(1, &src)");
3090 glDeleteTextures(1, &backup
);
3091 checkGLcall("glDeleteTextures(1, &backup)");
3097 /* Not called from the VTable */
3098 static HRESULT
IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3100 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3101 IWineD3DSwapChainImpl
*srcSwapchain
= NULL
, *dstSwapchain
= NULL
;
3102 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3104 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3106 /* Get the swapchain. One of the surfaces has to be a primary surface */
3107 if(This
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
3108 WARN("Destination is in sysmem, rejecting gl blt\n");
3109 return WINED3DERR_INVALIDCALL
;
3111 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&dstSwapchain
);
3112 if(dstSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) dstSwapchain
);
3114 if(Src
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
3115 WARN("Src is in sysmem, rejecting gl blt\n");
3116 return WINED3DERR_INVALIDCALL
;
3118 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) Src
, &IID_IWineD3DSwapChain
, (void **)&srcSwapchain
);
3119 if(srcSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) srcSwapchain
);
3122 /* Early sort out of cases where no render target is used */
3123 if(!dstSwapchain
&& !srcSwapchain
&&
3124 SrcSurface
!= myDevice
->render_targets
[0] && This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3125 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src
, This
);
3126 return WINED3DERR_INVALIDCALL
;
3129 /* No destination color keying supported */
3130 if(Flags
& (WINEDDBLT_KEYDEST
| WINEDDBLT_KEYDESTOVERRIDE
)) {
3131 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3132 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3133 return WINED3DERR_INVALIDCALL
;
3137 rect
.x1
= DestRect
->left
;
3138 rect
.y1
= DestRect
->top
;
3139 rect
.x2
= DestRect
->right
;
3140 rect
.y2
= DestRect
->bottom
;
3144 rect
.x2
= This
->currentDesc
.Width
;
3145 rect
.y2
= This
->currentDesc
.Height
;
3148 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3149 if(dstSwapchain
&& dstSwapchain
== srcSwapchain
&& dstSwapchain
->backBuffer
&&
3150 ((IWineD3DSurface
*) This
== dstSwapchain
->frontBuffer
) && SrcSurface
== dstSwapchain
->backBuffer
[0]) {
3151 /* Half-life does a Blt from the back buffer to the front buffer,
3152 * Full surface size, no flags... Use present instead
3154 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3157 /* Check rects - IWineD3DDevice_Present doesn't handle them */
3161 TRACE("Looking if a Present can be done...\n");
3162 /* Source Rectangle must be full surface */
3164 if(SrcRect
->left
!= 0 || SrcRect
->top
!= 0 ||
3165 SrcRect
->right
!= Src
->currentDesc
.Width
|| SrcRect
->bottom
!= Src
->currentDesc
.Height
) {
3166 TRACE("No, Source rectangle doesn't match\n");
3172 mySrcRect
.right
= Src
->currentDesc
.Width
;
3173 mySrcRect
.bottom
= Src
->currentDesc
.Height
;
3175 /* No stretching may occur */
3176 if(mySrcRect
.right
!= rect
.x2
- rect
.x1
||
3177 mySrcRect
.bottom
!= rect
.y2
- rect
.y1
) {
3178 TRACE("No, stretching is done\n");
3182 /* Destination must be full surface or match the clipping rectangle */
3183 if(This
->clipper
&& ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
)
3187 GetClientRect(((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
, &cliprect
);
3192 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
,
3195 if(pos
[0].x
!= cliprect
.left
|| pos
[0].y
!= cliprect
.top
||
3196 pos
[1].x
!= cliprect
.right
|| pos
[1].y
!= cliprect
.bottom
)
3198 TRACE("No, dest rectangle doesn't match(clipper)\n");
3199 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect
.left
, cliprect
.top
, cliprect
.right
, cliprect
.bottom
);
3200 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect
.x1
, rect
.y1
, rect
.x2
, rect
.y2
);
3206 if(rect
.x1
!= 0 || rect
.y1
!= 0 ||
3207 rect
.x2
!= This
->currentDesc
.Width
|| rect
.y2
!= This
->currentDesc
.Height
) {
3208 TRACE("No, dest rectangle doesn't match(surface size)\n");
3215 /* These flags are unimportant for the flag check, remove them */
3216 if((Flags
& ~(WINEDDBLT_DONOTWAIT
| WINEDDBLT_WAIT
)) == 0) {
3217 WINED3DSWAPEFFECT orig_swap
= dstSwapchain
->presentParms
.SwapEffect
;
3219 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3220 * take very long, while a flip is fast.
3221 * This applies to Half-Life, which does such Blts every time it finished
3222 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3223 * menu. This is also used by all apps when they do windowed rendering
3225 * The problem is that flipping is not really the same as copying. After a
3226 * Blt the front buffer is a copy of the back buffer, and the back buffer is
3227 * untouched. Therefore it's necessary to override the swap effect
3228 * and to set it back after the flip.
3230 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3234 dstSwapchain
->presentParms
.SwapEffect
= WINED3DSWAPEFFECT_COPY
;
3235 dstSwapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
3237 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3238 IWineD3DSwapChain_Present((IWineD3DSwapChain
*) dstSwapchain
, NULL
, NULL
, 0, NULL
, 0);
3240 dstSwapchain
->presentParms
.SwapEffect
= orig_swap
;
3247 TRACE("Unsupported blit between buffers on the same swapchain\n");
3248 return WINED3DERR_INVALIDCALL
;
3249 } else if(dstSwapchain
&& dstSwapchain
== srcSwapchain
) {
3250 FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3251 return WINED3DERR_INVALIDCALL
;
3252 } else if(dstSwapchain
&& srcSwapchain
) {
3253 FIXME("Implement hardware blit between two different swapchains\n");
3254 return WINED3DERR_INVALIDCALL
;
3255 } else if(dstSwapchain
) {
3256 if(SrcSurface
== myDevice
->render_targets
[0]) {
3257 TRACE("Blit from active render target to a swapchain\n");
3258 /* Handled with regular texture -> swapchain blit */
3260 } else if(srcSwapchain
&& This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3261 FIXME("Implement blit from a swapchain to the active render target\n");
3262 return WINED3DERR_INVALIDCALL
;
3265 if((srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) && !dstSwapchain
) {
3266 /* Blit from render target to texture */
3268 BOOL upsideDown
, stretchx
;
3269 BOOL paletteOverride
= FALSE
;
3271 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3272 TRACE("Color keying not supported by frame buffer to texture blit\n");
3273 return WINED3DERR_INVALIDCALL
;
3274 /* Destination color key is checked above */
3277 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3278 * glCopyTexSubImage is a bit picky about the parameters we pass to it
3281 if(SrcRect
->top
< SrcRect
->bottom
) {
3282 srect
.y1
= SrcRect
->top
;
3283 srect
.y2
= SrcRect
->bottom
;
3286 srect
.y1
= SrcRect
->bottom
;
3287 srect
.y2
= SrcRect
->top
;
3290 srect
.x1
= SrcRect
->left
;
3291 srect
.x2
= SrcRect
->right
;
3295 srect
.x2
= Src
->currentDesc
.Width
;
3296 srect
.y2
= Src
->currentDesc
.Height
;
3299 if(rect
.x1
> rect
.x2
) {
3303 upsideDown
= !upsideDown
;
3306 if(rect
.x2
- rect
.x1
!= srect
.x2
- srect
.x1
) {
3312 /* When blitting from a render target a texture, the texture isn't required to have a palette.
3313 * In this case grab the palette from the render target. */
3314 if((This
->resource
.format
== WINED3DFMT_P8
) && (This
->palette
== NULL
)) {
3315 paletteOverride
= TRUE
;
3316 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src
, This
->palette
, This
);
3317 This
->palette
= Src
->palette
;
3320 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3321 * flip the image nor scale it.
3323 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3324 * -> If the app wants a image width an unscaled width, copy it line per line
3325 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3326 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3327 * back buffer. This is slower than reading line per line, thus not used for flipping
3328 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3331 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3332 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3335 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
)) {
3336 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, &srect
,
3337 (IWineD3DSurface
*)This
, &rect
, Filter
, upsideDown
);
3338 } else if((!stretchx
) || rect
.x2
- rect
.x1
> Src
->currentDesc
.Width
||
3339 rect
.y2
- rect
.y1
> Src
->currentDesc
.Height
) {
3340 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3341 fb_copy_to_texture_direct(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3343 TRACE("Using hardware stretching to flip / stretch the texture\n");
3344 fb_copy_to_texture_hwstretch(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3347 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3349 This
->palette
= NULL
;
3351 if(!(This
->Flags
& SFLAG_DONOTFREE
)) {
3352 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
3353 This
->resource
.allocatedMemory
= NULL
;
3354 This
->resource
.heapMemory
= NULL
;
3356 This
->Flags
&= ~SFLAG_INSYSMEM
;
3358 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3359 * path is never entered
3361 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INTEXTURE
, TRUE
);
3365 /* Blit from offscreen surface to render target */
3366 float glTexCoord
[4];
3367 DWORD oldCKeyFlags
= Src
->CKeyFlags
;
3368 WINEDDCOLORKEY oldBltCKey
= Src
->SrcBltCKey
;
3369 RECT SourceRectangle
;
3370 BOOL paletteOverride
= FALSE
;
3372 TRACE("Blt from surface %p to rendertarget %p\n", Src
, This
);
3375 SourceRectangle
.left
= SrcRect
->left
;
3376 SourceRectangle
.right
= SrcRect
->right
;
3377 SourceRectangle
.top
= SrcRect
->top
;
3378 SourceRectangle
.bottom
= SrcRect
->bottom
;
3380 SourceRectangle
.left
= 0;
3381 SourceRectangle
.right
= Src
->currentDesc
.Width
;
3382 SourceRectangle
.top
= 0;
3383 SourceRectangle
.bottom
= Src
->currentDesc
.Height
;
3386 /* When blitting from an offscreen surface to a rendertarget, the source
3387 * surface is not required to have a palette. Our rendering / conversion
3388 * code further down the road retrieves the palette from the surface, so
3389 * it must have a palette set. */
3390 if((Src
->resource
.format
== WINED3DFMT_P8
) && (Src
->palette
== NULL
)) {
3391 paletteOverride
= TRUE
;
3392 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src
, This
->palette
, This
);
3393 Src
->palette
= This
->palette
;
3396 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
) &&
3397 (Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) == 0) {
3398 TRACE("Using stretch_rect_fbo\n");
3399 /* The source is always a texture, but never the currently active render target, and the texture
3400 * contents are never upside down
3402 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, (WINED3DRECT
*) &SourceRectangle
,
3403 (IWineD3DSurface
*)This
, &rect
, Filter
, FALSE
);
3405 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3407 Src
->palette
= NULL
;
3411 if(!CalculateTexRect(Src
, &SourceRectangle
, glTexCoord
)) {
3412 /* Fall back to software */
3413 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src
,
3414 SourceRectangle
.left
, SourceRectangle
.top
,
3415 SourceRectangle
.right
, SourceRectangle
.bottom
);
3416 return WINED3DERR_INVALIDCALL
;
3419 /* Color keying: Check if we have to do a color keyed blt,
3420 * and if not check if a color key is activated.
3422 * Just modify the color keying parameters in the surface and restore them afterwards
3423 * The surface keeps track of the color key last used to load the opengl surface.
3424 * PreLoad will catch the change to the flags and color key and reload if necessary.
3426 if(Flags
& WINEDDBLT_KEYSRC
) {
3427 /* Use color key from surface */
3428 } else if(Flags
& WINEDDBLT_KEYSRCOVERRIDE
) {
3429 /* Use color key from DDBltFx */
3430 Src
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
3431 Src
->SrcBltCKey
= DDBltFx
->ddckSrcColorkey
;
3433 /* Do not use color key */
3434 Src
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
3437 /* Now load the surface */
3438 IWineD3DSurface_PreLoad((IWineD3DSurface
*) Src
);
3440 /* Activate the destination context, set it up for blitting */
3441 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
3443 if (dstSwapchain
&& (IWineD3DSurface
*)This
== dstSwapchain
->frontBuffer
) {
3445 POINT offset
= {0,0};
3447 ClientToScreen(dstSwapchain
->win_handle
, &offset
);
3448 GetClientRect(dstSwapchain
->win_handle
, &windowsize
);
3449 h
= windowsize
.bottom
- windowsize
.top
;
3450 rect
.x1
-= offset
.x
; rect
.x2
-=offset
.x
;
3451 rect
.y1
-= offset
.y
; rect
.y2
-=offset
.y
;
3452 rect
.y1
+= This
->currentDesc
.Height
- h
; rect
.y2
+= This
->currentDesc
.Height
- h
;
3456 myDevice
->blitter
->set_shader((IWineD3DDevice
*) myDevice
, Src
->resource
.format
,
3457 Src
->glDescription
.target
, Src
->pow2Width
, Src
->pow2Height
);
3459 /* Bind the texture */
3460 glBindTexture(Src
->glDescription
.target
, Src
->glDescription
.textureName
);
3461 checkGLcall("glBindTexture");
3463 /* Filtering for StretchRect */
3464 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_MAG_FILTER
,
3465 magLookup
[Filter
- WINED3DTEXF_NONE
]);
3466 checkGLcall("glTexParameteri");
3467 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_MIN_FILTER
,
3468 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
3469 checkGLcall("glTexParameteri");
3470 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3471 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3472 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
3473 checkGLcall("glTexEnvi");
3475 /* This is for color keying */
3476 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3477 glEnable(GL_ALPHA_TEST
);
3478 checkGLcall("glEnable GL_ALPHA_TEST");
3480 /* When the primary render target uses P8, the alpha component contains the palette index.
3481 * Which means that the colorkey is one of the palette entries. In other cases pixels that
3482 * should be masked away have alpha set to 0. */
3483 if(primary_render_target_is_p8(myDevice
))
3484 glAlphaFunc(GL_NOTEQUAL
, (float)Src
->SrcBltCKey
.dwColorSpaceLowValue
/ 256.0);
3486 glAlphaFunc(GL_NOTEQUAL
, 0.0);
3487 checkGLcall("glAlphaFunc\n");
3489 glDisable(GL_ALPHA_TEST
);
3490 checkGLcall("glDisable GL_ALPHA_TEST");
3493 /* Draw a textured quad
3497 glColor3d(1.0f
, 1.0f
, 1.0f
);
3498 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
3503 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
3504 glVertex3f(rect
.x1
, rect
.y2
, 0.0);
3506 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
3511 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
3516 checkGLcall("glEnd");
3518 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3519 glDisable(GL_ALPHA_TEST
);
3520 checkGLcall("glDisable(GL_ALPHA_TEST)");
3523 glBindTexture(Src
->glDescription
.target
, 0);
3524 checkGLcall("glBindTexture(Src->glDescription.target, 0)");
3525 /* Leave the opengl state valid for blitting */
3526 myDevice
->blitter
->unset_shader((IWineD3DDevice
*) myDevice
);
3528 /* Restore the color key parameters */
3529 Src
->CKeyFlags
= oldCKeyFlags
;
3530 Src
->SrcBltCKey
= oldBltCKey
;
3532 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3534 Src
->palette
= NULL
;
3538 /* Flush in case the drawable is used by multiple GL contexts */
3539 if(dstSwapchain
&& (This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
|| dstSwapchain
->num_contexts
>= 2))
3542 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3543 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3546 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INDRAWABLE
, TRUE
);
3550 /* Source-Less Blit to render target */
3551 if (Flags
& WINEDDBLT_COLORFILL
) {
3552 /* This is easy to handle for the D3D Device... */
3555 TRACE("Colorfill\n");
3557 /* This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0] || dstSwapchain
3558 must be true if we are here */
3559 if (This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0] &&
3560 !(This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
||
3561 (dstSwapchain
->backBuffer
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->backBuffer
[0]))) {
3562 TRACE("Surface is higher back buffer, falling back to software\n");
3563 return WINED3DERR_INVALIDCALL
;
3566 /* The color as given in the Blt function is in the format of the frame-buffer...
3567 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3569 if (This
->resource
.format
== WINED3DFMT_P8
) {
3572 if (primary_render_target_is_p8(myDevice
)) alpha
= DDBltFx
->u5
.dwFillColor
<< 24;
3573 else alpha
= 0xFF000000;
3575 if (This
->palette
) {
3577 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peRed
<< 16) |
3578 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peGreen
<< 8) |
3579 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peBlue
));
3584 else if (This
->resource
.format
== WINED3DFMT_R5G6B5
) {
3585 if (DDBltFx
->u5
.dwFillColor
== 0xFFFF) {
3588 color
= ((0xFF000000) |
3589 ((DDBltFx
->u5
.dwFillColor
& 0xF800) << 8) |
3590 ((DDBltFx
->u5
.dwFillColor
& 0x07E0) << 5) |
3591 ((DDBltFx
->u5
.dwFillColor
& 0x001F) << 3));
3594 else if ((This
->resource
.format
== WINED3DFMT_R8G8B8
) ||
3595 (This
->resource
.format
== WINED3DFMT_X8R8G8B8
) ) {
3596 color
= 0xFF000000 | DDBltFx
->u5
.dwFillColor
;
3598 else if (This
->resource
.format
== WINED3DFMT_A8R8G8B8
) {
3599 color
= DDBltFx
->u5
.dwFillColor
;
3602 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3603 return WINED3DERR_INVALIDCALL
;
3606 TRACE("(%p) executing Render Target override, color = %x\n", This
, color
);
3607 IWineD3DDeviceImpl_ClearSurface(myDevice
, This
,
3608 1, /* Number of rectangles */
3609 &rect
, WINED3DCLEAR_TARGET
, color
,
3616 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3617 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3618 return WINED3DERR_INVALIDCALL
;
3621 static HRESULT WINAPI
IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
)
3623 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3626 if (Flags
& WINEDDBLT_DEPTHFILL
) {
3627 switch(This
->resource
.format
) {
3628 case WINED3DFMT_D16
:
3629 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000ffff;
3631 case WINED3DFMT_D15S1
:
3632 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000fffe;
3634 case WINED3DFMT_D24S8
:
3635 case WINED3DFMT_D24X8
:
3636 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x00ffffff;
3638 case WINED3DFMT_D32
:
3639 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0xffffffff;
3643 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This
->resource
.format
));
3646 return IWineD3DDevice_Clear((IWineD3DDevice
*) myDevice
,
3647 DestRect
== NULL
? 0 : 1,
3648 (WINED3DRECT
*) DestRect
,
3649 WINED3DCLEAR_ZBUFFER
,
3655 FIXME("(%p): Unsupp depthstencil blit\n", This
);
3656 return WINED3DERR_INVALIDCALL
;
3659 static HRESULT WINAPI
IWineD3DSurfaceImpl_Blt(IWineD3DSurface
*iface
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3660 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3661 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3662 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3663 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3664 TRACE("(%p): Usage is %s\n", This
, debug_d3dusage(This
->resource
.usage
));
3666 if ( (This
->Flags
& SFLAG_LOCKED
) || ((Src
!= NULL
) && (Src
->Flags
& SFLAG_LOCKED
)))
3668 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3669 return WINEDDERR_SURFACEBUSY
;
3672 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3673 * except depth blits, which seem to work
3675 if(iface
== myDevice
->stencilBufferTarget
|| (SrcSurface
&& SrcSurface
== myDevice
->stencilBufferTarget
)) {
3676 if(myDevice
->inScene
&& !(Flags
& WINEDDBLT_DEPTHFILL
)) {
3677 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3678 return WINED3DERR_INVALIDCALL
;
3679 } else if(IWineD3DSurfaceImpl_BltZ(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
) == WINED3D_OK
) {
3680 TRACE("Z Blit override handled the blit\n");
3685 /* Special cases for RenderTargets */
3686 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3687 ( Src
&& (Src
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3688 if(IWineD3DSurfaceImpl_BltOverride(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
) == WINED3D_OK
) return WINED3D_OK
;
3691 /* For the rest call the X11 surface implementation.
3692 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3693 * other Blts are rather rare
3695 return IWineD3DBaseSurfaceImpl_Blt(iface
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
);
3698 HRESULT WINAPI
IWineD3DSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
, IWineD3DSurface
*Source
, RECT
*rsrc
, DWORD trans
) {
3699 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3700 IWineD3DSurfaceImpl
*srcImpl
= (IWineD3DSurfaceImpl
*) Source
;
3701 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3702 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3704 if ( (This
->Flags
& SFLAG_LOCKED
) || ((srcImpl
!= NULL
) && (srcImpl
->Flags
& SFLAG_LOCKED
)))
3706 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3707 return WINEDDERR_SURFACEBUSY
;
3710 if(myDevice
->inScene
&&
3711 (iface
== myDevice
->stencilBufferTarget
||
3712 (Source
&& Source
== myDevice
->stencilBufferTarget
))) {
3713 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3714 return WINED3DERR_INVALIDCALL
;
3717 /* Special cases for RenderTargets */
3718 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3719 ( srcImpl
&& (srcImpl
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3721 RECT SrcRect
, DstRect
;
3725 SrcRect
.left
= rsrc
->left
;
3726 SrcRect
.top
= rsrc
->top
;
3727 SrcRect
.bottom
= rsrc
->bottom
;
3728 SrcRect
.right
= rsrc
->right
;
3732 SrcRect
.right
= srcImpl
->currentDesc
.Width
;
3733 SrcRect
.bottom
= srcImpl
->currentDesc
.Height
;
3736 DstRect
.left
= dstx
;
3738 DstRect
.right
= dstx
+ SrcRect
.right
- SrcRect
.left
;
3739 DstRect
.bottom
= dsty
+ SrcRect
.bottom
- SrcRect
.top
;
3741 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3742 if(trans
& WINEDDBLTFAST_SRCCOLORKEY
)
3743 Flags
|= WINEDDBLT_KEYSRC
;
3744 if(trans
& WINEDDBLTFAST_DESTCOLORKEY
)
3745 Flags
|= WINEDDBLT_KEYDEST
;
3746 if(trans
& WINEDDBLTFAST_WAIT
)
3747 Flags
|= WINEDDBLT_WAIT
;
3748 if(trans
& WINEDDBLTFAST_DONOTWAIT
)
3749 Flags
|= WINEDDBLT_DONOTWAIT
;
3751 if(IWineD3DSurfaceImpl_BltOverride(This
, &DstRect
, Source
, &SrcRect
, Flags
, NULL
, WINED3DTEXF_POINT
) == WINED3D_OK
) return WINED3D_OK
;
3755 return IWineD3DBaseSurfaceImpl_BltFast(iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3758 HRESULT WINAPI
IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
3759 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3761 IWineD3DPaletteImpl
*pal
= This
->palette
;
3763 TRACE("(%p)\n", This
);
3765 if (!pal
) return WINED3D_OK
;
3767 if(This
->resource
.format
== WINED3DFMT_P8
||
3768 This
->resource
.format
== WINED3DFMT_A8P8
)
3771 GLenum format
, internal
, type
;
3772 CONVERT_TYPES convert
;
3774 /* Check if we are using a RTL mode which uses texturing for uploads */
3775 BOOL use_texture
= (wined3d_settings
.rendertargetlock_mode
== RTL_READTEX
|| wined3d_settings
.rendertargetlock_mode
== RTL_TEXTEX
);
3777 /* Check if we have hardware palette conversion if we have convert is set to NO_CONVERSION */
3778 d3dfmt_get_conv(This
, TRUE
, use_texture
, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
3780 if((This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) && (convert
== NO_CONVERSION
))
3782 /* Make sure the texture is up to date. This call doesn't do anything if the texture is already up to date. */
3783 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
);
3785 /* We want to force a palette refresh, so mark the drawable as not being up to date */
3786 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, FALSE
);
3788 /* Re-upload the palette */
3789 d3dfmt_p8_upload_palette(iface
, convert
);
3791 if(!(This
->Flags
& SFLAG_INSYSMEM
)) {
3792 TRACE("Palette changed with surface that does not have an up to date system memory copy\n");
3793 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
3795 TRACE("Dirtifying surface\n");
3796 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
3800 if(This
->Flags
& SFLAG_DIBSECTION
) {
3801 TRACE("(%p): Updating the hdc's palette\n", This
);
3802 for (n
=0; n
<256; n
++) {
3803 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
3804 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
3805 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
3806 col
[n
].rgbReserved
= 0;
3808 SetDIBColorTable(This
->hDC
, 0, 256, col
);
3811 /* Propagate the changes to the drawable when we have a palette. */
3812 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
3813 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, NULL
);
3818 static HRESULT WINAPI
IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
) {
3819 /** Check against the maximum texture sizes supported by the video card **/
3820 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3821 unsigned int pow2Width
, pow2Height
;
3822 const GlPixelFormatDesc
*glDesc
;
3824 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
3825 /* Setup some glformat defaults */
3826 This
->glDescription
.glFormat
= glDesc
->glFormat
;
3827 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
3828 This
->glDescription
.glType
= glDesc
->glType
;
3830 This
->glDescription
.textureName
= 0;
3831 This
->glDescription
.target
= GL_TEXTURE_2D
;
3833 /* Non-power2 support */
3834 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
) || GL_SUPPORT(WINE_NORMALIZED_TEXRECT
)) {
3835 pow2Width
= This
->currentDesc
.Width
;
3836 pow2Height
= This
->currentDesc
.Height
;
3838 /* Find the nearest pow2 match */
3839 pow2Width
= pow2Height
= 1;
3840 while (pow2Width
< This
->currentDesc
.Width
) pow2Width
<<= 1;
3841 while (pow2Height
< This
->currentDesc
.Height
) pow2Height
<<= 1;
3843 This
->pow2Width
= pow2Width
;
3844 This
->pow2Height
= pow2Height
;
3846 if (pow2Width
> This
->currentDesc
.Width
|| pow2Height
> This
->currentDesc
.Height
) {
3847 WINED3DFORMAT Format
= This
->resource
.format
;
3848 /** TODO: add support for non power two compressed textures **/
3849 if (Format
== WINED3DFMT_DXT1
|| Format
== WINED3DFMT_DXT2
|| Format
== WINED3DFMT_DXT3
3850 || Format
== WINED3DFMT_DXT4
|| Format
== WINED3DFMT_DXT5
3851 || This
->resource
.format
== WINED3DFMT_ATI2N
) {
3852 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3853 This
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
3854 return WINED3DERR_NOTAVAILABLE
;
3858 if(pow2Width
!= This
->currentDesc
.Width
||
3859 pow2Height
!= This
->currentDesc
.Height
) {
3860 This
->Flags
|= SFLAG_NONPOW2
;
3863 TRACE("%p\n", This
);
3864 if ((This
->pow2Width
> GL_LIMITS(texture_size
) || This
->pow2Height
> GL_LIMITS(texture_size
)) && !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_DEPTHSTENCIL
))) {
3865 /* one of three options
3866 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)
3867 2: Set the texture to the maximum size (bad idea)
3868 3: WARN and return WINED3DERR_NOTAVAILABLE;
3869 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.
3871 WARN("(%p) Creating an oversized surface\n", This
);
3872 This
->Flags
|= SFLAG_OVERSIZE
;
3874 /* This will be initialized on the first blt */
3875 This
->glRect
.left
= 0;
3876 This
->glRect
.top
= 0;
3877 This
->glRect
.right
= 0;
3878 This
->glRect
.bottom
= 0;
3880 /* Check this after the oversize check - do not make an oversized surface a texture_rectangle one.
3881 Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
3882 is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
3883 doesn't work in combination with ARB_TEXTURE_RECTANGLE.
3885 if(This
->Flags
& SFLAG_NONPOW2
&& GL_SUPPORT(ARB_TEXTURE_RECTANGLE
) &&
3886 !((This
->resource
.format
== WINED3DFMT_P8
) && GL_SUPPORT(EXT_PALETTED_TEXTURE
) && (wined3d_settings
.rendertargetlock_mode
== RTL_READTEX
|| wined3d_settings
.rendertargetlock_mode
== RTL_TEXTEX
)))
3888 This
->glDescription
.target
= GL_TEXTURE_RECTANGLE_ARB
;
3889 This
->pow2Width
= This
->currentDesc
.Width
;
3890 This
->pow2Height
= This
->currentDesc
.Height
;
3891 This
->Flags
&= ~(SFLAG_NONPOW2
| SFLAG_NORMCOORD
);
3894 /* No oversize, gl rect is the full texture size */
3895 This
->Flags
&= ~SFLAG_OVERSIZE
;
3896 This
->glRect
.left
= 0;
3897 This
->glRect
.top
= 0;
3898 This
->glRect
.right
= This
->pow2Width
;
3899 This
->glRect
.bottom
= This
->pow2Height
;
3902 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
3903 switch(wined3d_settings
.offscreen_rendering_mode
) {
3904 case ORM_FBO
: This
->get_drawable_size
= get_drawable_size_fbo
; break;
3905 case ORM_PBUFFER
: This
->get_drawable_size
= get_drawable_size_pbuffer
; break;
3906 case ORM_BACKBUFFER
: This
->get_drawable_size
= get_drawable_size_backbuffer
; break;
3910 This
->Flags
|= SFLAG_INSYSMEM
;
3915 void surface_modify_ds_location(IWineD3DSurface
*iface
, DWORD location
) {
3916 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3918 TRACE("(%p) New location %#x\n", This
, location
);
3920 if (location
& ~SFLAG_DS_LOCATIONS
) {
3921 FIXME("(%p) Invalid location (%#x) specified\n", This
, location
);
3924 This
->Flags
&= ~SFLAG_DS_LOCATIONS
;
3925 This
->Flags
|= location
;
3928 void surface_load_ds_location(IWineD3DSurface
*iface
, DWORD location
) {
3929 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3930 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3932 TRACE("(%p) New location %#x\n", This
, location
);
3934 /* TODO: Make this work for modes other than FBO */
3935 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) return;
3937 if (This
->Flags
& location
) {
3938 TRACE("(%p) Location (%#x) is already up to date\n", This
, location
);
3942 if (This
->current_renderbuffer
) {
3943 FIXME("(%p) Not supported with fixed up depth stencil\n", This
);
3947 if (location
== SFLAG_DS_OFFSCREEN
) {
3948 if (This
->Flags
& SFLAG_DS_ONSCREEN
) {
3949 GLint old_binding
= 0;
3951 TRACE("(%p) Copying onscreen depth buffer to depth texture\n", This
);
3955 if (!device
->depth_blt_texture
) {
3956 glGenTextures(1, &device
->depth_blt_texture
);
3959 /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
3960 * directly on the FBO texture. That's because we need to flip. */
3961 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
3962 glGetIntegerv(GL_TEXTURE_BINDING_2D
, &old_binding
);
3963 glBindTexture(GL_TEXTURE_2D
, device
->depth_blt_texture
);
3964 glCopyTexImage2D(This
->glDescription
.target
,
3965 This
->glDescription
.level
,
3966 This
->glDescription
.glFormatInternal
,
3969 This
->currentDesc
.Width
,
3970 This
->currentDesc
.Height
,
3972 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3973 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3974 glTexParameteri(GL_TEXTURE_2D
, GL_DEPTH_TEXTURE_MODE_ARB
, GL_LUMINANCE
);
3975 glBindTexture(GL_TEXTURE_2D
, old_binding
);
3977 /* Setup the destination */
3978 if (!device
->depth_blt_rb
) {
3979 GL_EXTCALL(glGenRenderbuffersEXT(1, &device
->depth_blt_rb
));
3980 checkGLcall("glGenRenderbuffersEXT");
3982 if (device
->depth_blt_rb_w
!= This
->currentDesc
.Width
3983 || device
->depth_blt_rb_h
!= This
->currentDesc
.Height
) {
3984 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, device
->depth_blt_rb
));
3985 checkGLcall("glBindRenderbufferEXT");
3986 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, GL_RGBA8
, This
->currentDesc
.Width
, This
->currentDesc
.Height
));
3987 checkGLcall("glRenderbufferStorageEXT");
3988 device
->depth_blt_rb_w
= This
->currentDesc
.Width
;
3989 device
->depth_blt_rb_h
= This
->currentDesc
.Height
;
3992 bind_fbo((IWineD3DDevice
*)device
, GL_FRAMEBUFFER_EXT
, &device
->activeContext
->dst_fbo
);
3993 GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT
, GL_COLOR_ATTACHMENT0_EXT
, GL_RENDERBUFFER_EXT
, device
->depth_blt_rb
));
3994 checkGLcall("glFramebufferRenderbufferEXT");
3995 attach_depth_stencil_fbo(device
, GL_FRAMEBUFFER_EXT
, iface
, FALSE
);
3997 /* Do the actual blit */
3998 depth_blt((IWineD3DDevice
*)device
, device
->depth_blt_texture
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
3999 checkGLcall("depth_blt");
4001 if (device
->render_offscreen
) {
4002 bind_fbo((IWineD3DDevice
*)device
, GL_FRAMEBUFFER_EXT
, &device
->activeContext
->fbo
);
4004 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
4005 checkGLcall("glBindFramebuffer()");
4010 FIXME("No up to date depth stencil location\n");
4012 } else if (location
== SFLAG_DS_ONSCREEN
) {
4013 if (This
->Flags
& SFLAG_DS_OFFSCREEN
) {
4014 TRACE("(%p) Copying depth texture to onscreen depth buffer\n", This
);
4018 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
4019 checkGLcall("glBindFramebuffer()");
4020 depth_blt((IWineD3DDevice
*)device
, This
->glDescription
.textureName
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
4021 checkGLcall("depth_blt");
4023 if (device
->render_offscreen
) {
4024 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, device
->activeContext
->fbo
));
4025 checkGLcall("glBindFramebuffer()");
4030 FIXME("No up to date depth stencil location\n");
4033 ERR("(%p) Invalid location (%#x) specified\n", This
, location
);
4036 This
->Flags
|= location
;
4039 static void WINAPI
IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
4040 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4041 IWineD3DBaseTexture
*texture
;
4042 IWineD3DSurfaceImpl
*overlay
;
4044 TRACE("(%p)->(%s, %s)\n", iface
,
4045 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
4046 persistent
? "TRUE" : "FALSE");
4048 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
4049 IWineD3DSwapChain
*swapchain
= NULL
;
4051 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
))) {
4052 TRACE("Surface %p is an onscreen surface\n", iface
);
4054 IWineD3DSwapChain_Release(swapchain
);
4056 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4057 if (flag
& (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
)) flag
|= (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
4062 if((This
->Flags
& SFLAG_INTEXTURE
) && !(flag
& SFLAG_INTEXTURE
)) {
4063 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
4064 TRACE("Passing to container\n");
4065 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
4066 IWineD3DBaseTexture_Release(texture
);
4069 This
->Flags
&= ~SFLAG_LOCATIONS
;
4070 This
->Flags
|= flag
;
4072 /* Redraw emulated overlays, if any */
4073 if(flag
& SFLAG_INDRAWABLE
&& !list_empty(&This
->overlays
)) {
4074 LIST_FOR_EACH_ENTRY(overlay
, &This
->overlays
, IWineD3DSurfaceImpl
, overlay_entry
) {
4075 IWineD3DSurface_DrawOverlay((IWineD3DSurface
*) overlay
);
4079 if((This
->Flags
& SFLAG_INTEXTURE
) && (flag
& SFLAG_INTEXTURE
)) {
4080 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
4081 TRACE("Passing to container\n");
4082 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
4083 IWineD3DBaseTexture_Release(texture
);
4086 This
->Flags
&= ~flag
;
4094 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl
*This
, const RECT
*rect_in
) {
4095 struct coords coords
[4];
4097 IWineD3DSwapChain
*swapchain
= NULL
;
4098 IWineD3DBaseTexture
*texture
= NULL
;
4100 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
4107 rect
.right
= This
->currentDesc
.Width
;
4108 rect
.bottom
= This
->currentDesc
.Height
;
4111 ActivateContext(device
, (IWineD3DSurface
*)This
, CTXUSAGE_BLIT
);
4114 if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
) {
4115 glEnable(GL_TEXTURE_RECTANGLE_ARB
);
4116 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
4117 glBindTexture(GL_TEXTURE_RECTANGLE_ARB
, This
->glDescription
.textureName
);
4118 checkGLcall("GL_TEXTURE_RECTANGLE_ARB, This->glDescription.textureName)");
4119 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4120 checkGLcall("glTexParameteri");
4121 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4122 checkGLcall("glTexParameteri");
4124 coords
[0].x
= rect
.left
;
4127 coords
[1].x
= rect
.left
;
4130 coords
[2].x
= rect
.right
;
4133 coords
[3].x
= rect
.right
;
4136 coords
[0].y
= rect
.top
;
4137 coords
[1].y
= rect
.bottom
;
4138 coords
[2].y
= rect
.bottom
;
4139 coords
[3].y
= rect
.top
;
4140 } else if(This
->glDescription
.target
== GL_TEXTURE_2D
) {
4141 glEnable(GL_TEXTURE_2D
);
4142 checkGLcall("glEnable(GL_TEXTURE_2D)");
4143 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
4144 checkGLcall("GL_TEXTURE_2D, This->glDescription.textureName)");
4145 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4146 checkGLcall("glTexParameteri");
4147 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4148 checkGLcall("glTexParameteri");
4150 coords
[0].x
= (float)rect
.left
/ This
->pow2Width
;
4153 coords
[1].x
= (float)rect
.left
/ This
->pow2Width
;
4156 coords
[2].x
= (float)rect
.right
/ This
->pow2Width
;
4159 coords
[3].x
= (float)rect
.right
/ This
->pow2Width
;
4162 coords
[0].y
= (float)rect
.top
/ This
->pow2Height
;
4163 coords
[1].y
= (float)rect
.bottom
/ This
->pow2Height
;
4164 coords
[2].y
= (float)rect
.bottom
/ This
->pow2Height
;
4165 coords
[3].y
= (float)rect
.top
/ This
->pow2Height
;
4167 /* Must be a cube map */
4168 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
4169 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
4170 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB
, This
->glDescription
.textureName
);
4171 checkGLcall("GL_TEXTURE_CUBE_MAP_ARB, This->glDescription.textureName)");
4172 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4173 checkGLcall("glTexParameteri");
4174 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4175 checkGLcall("glTexParameteri");
4177 switch(This
->glDescription
.target
) {
4178 case GL_TEXTURE_CUBE_MAP_POSITIVE_X
:
4179 coords
[0].x
= 1; coords
[0].y
= -1; coords
[0].z
= 1;
4180 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
4181 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
4182 coords
[3].x
= 1; coords
[3].y
= -1; coords
[3].z
= -1;
4185 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X
:
4186 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4187 coords
[1].x
= -1; coords
[1].y
= 1; coords
[1].z
= 1;
4188 coords
[2].x
= -1; coords
[2].y
= 1; coords
[2].z
= -1;
4189 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4192 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y
:
4193 coords
[0].x
= -1; coords
[0].y
= 1; coords
[0].z
= 1;
4194 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
4195 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
4196 coords
[3].x
= -1; coords
[3].y
= 1; coords
[3].z
= -1;
4199 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
:
4200 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4201 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
4202 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
4203 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4206 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z
:
4207 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4208 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
4209 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= 1;
4210 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= 1;
4213 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
:
4214 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= -1;
4215 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= -1;
4216 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
4217 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4221 ERR("Unexpected texture target\n");
4228 glTexCoord3fv(&coords
[0].x
);
4229 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
4231 glTexCoord3fv(&coords
[1].x
);
4232 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
4234 glTexCoord3fv(&coords
[2].x
);
4235 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
4237 glTexCoord3fv(&coords
[3].x
);
4238 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
4240 checkGLcall("glEnd");
4242 if(This
->glDescription
.target
!= GL_TEXTURE_2D
) {
4243 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
4244 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4246 glDisable(GL_TEXTURE_2D
);
4247 checkGLcall("glDisable(GL_TEXTURE_2D)");
4251 hr
= IWineD3DSurface_GetContainer((IWineD3DSurface
*)This
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
4252 if(hr
== WINED3D_OK
&& swapchain
) {
4253 /* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
4254 if(((IWineD3DSwapChainImpl
*)swapchain
)->frontBuffer
== (IWineD3DSurface
*)This
||
4255 ((IWineD3DSwapChainImpl
*)swapchain
)->num_contexts
>= 2)
4258 IWineD3DSwapChain_Release(swapchain
);
4260 /* We changed the filtering settings on the texture. Inform the container about this to get the filters
4261 * reset properly next draw
4263 hr
= IWineD3DSurface_GetContainer((IWineD3DSurface
*)This
, &IID_IWineD3DBaseTexture
, (void **) &texture
);
4264 if(hr
== WINED3D_OK
&& texture
) {
4265 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MAGFILTER
] = WINED3DTEXF_POINT
;
4266 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MINFILTER
] = WINED3DTEXF_POINT
;
4267 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MIPFILTER
] = WINED3DTEXF_NONE
;
4268 IWineD3DBaseTexture_Release(texture
);
4273 /*****************************************************************************
4274 * IWineD3DSurface::LoadLocation
4276 * Copies the current surface data from wherever it is to the requested
4277 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
4278 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
4279 * multiple locations, the gl texture is preferred over the drawable, which is
4280 * preferred over system memory. The PBO counts as system memory. If rect is
4281 * not NULL, only the specified rectangle is copied (only supported for
4282 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
4283 * location is marked up to date after the copy.
4286 * flag: Surface location flag to be updated
4287 * rect: rectangle to be copied
4290 * WINED3D_OK on success
4291 * WINED3DERR_DEVICELOST on an internal error
4293 *****************************************************************************/
4294 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
4295 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4296 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
4297 IWineD3DSwapChain
*swapchain
= NULL
;
4298 GLenum format
, internal
, type
;
4299 CONVERT_TYPES convert
;
4301 int width
, pitch
, outpitch
;
4304 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
4305 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
))) {
4306 TRACE("Surface %p is an onscreen surface\n", iface
);
4308 IWineD3DSwapChain_Release(swapchain
);
4310 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4311 * Prefer SFLAG_INTEXTURE. */
4312 if (flag
== SFLAG_INDRAWABLE
) flag
= SFLAG_INTEXTURE
;
4316 TRACE("(%p)->(%s, %p)\n", iface
,
4317 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
4320 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
4323 if(This
->Flags
& flag
) {
4324 TRACE("Location already up to date\n");
4328 if(!(This
->Flags
& SFLAG_LOCATIONS
)) {
4329 ERR("Surface does not have any up to date location\n");
4330 This
->Flags
|= SFLAG_LOST
;
4331 return WINED3DERR_DEVICELOST
;
4334 if(flag
== SFLAG_INSYSMEM
) {
4335 surface_prepare_system_memory(This
);
4337 /* Download the surface to system memory */
4338 if(This
->Flags
& SFLAG_INTEXTURE
) {
4339 if(!device
->isInDraw
) ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
4340 surface_bind_and_dirtify(This
);
4342 surface_download_data(This
);
4344 read_from_framebuffer(This
, rect
,
4345 This
->resource
.allocatedMemory
,
4346 IWineD3DSurface_GetPitch(iface
));
4348 } else if(flag
== SFLAG_INDRAWABLE
) {
4349 if(This
->Flags
& SFLAG_INTEXTURE
) {
4350 surface_blt_to_drawable(This
, rect
);
4352 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, FALSE
/* We won't use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
4354 /* The width is in 'length' not in bytes */
4355 width
= This
->currentDesc
.Width
;
4356 pitch
= IWineD3DSurface_GetPitch(iface
);
4358 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4359 * but it isn't set (yet) in all cases it is getting called. */
4360 if((convert
!= NO_CONVERSION
) && (This
->Flags
& SFLAG_PBO
)) {
4361 TRACE("Removing the pbo attached to surface %p\n", This
);
4362 surface_remove_pbo(This
);
4365 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
4366 int height
= This
->currentDesc
.Height
;
4368 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4369 outpitch
= width
* bpp
;
4370 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
4372 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
4374 ERR("Out of memory %d, %d!\n", outpitch
, height
);
4375 return WINED3DERR_OUTOFVIDEOMEMORY
;
4377 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
4379 This
->Flags
|= SFLAG_CONVERTED
;
4381 This
->Flags
&= ~SFLAG_CONVERTED
;
4382 mem
= This
->resource
.allocatedMemory
;
4385 flush_to_framebuffer_drawpixels(This
, format
, type
, bpp
, mem
);
4387 /* Don't delete PBO memory */
4388 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
4389 HeapFree(GetProcessHeap(), 0, mem
);
4391 } else /* if(flag == SFLAG_INTEXTURE) */ {
4392 if (This
->Flags
& SFLAG_INDRAWABLE
) {
4393 read_from_framebuffer_texture(This
);
4394 } else { /* Upload from system memory */
4395 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
4397 if(!device
->isInDraw
) ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
4398 surface_bind_and_dirtify(This
);
4401 /* The only place where LoadTexture() might get called when isInDraw=1
4402 * is ActivateContext where lastActiveRenderTarget is preloaded.
4404 if(iface
== device
->lastActiveRenderTarget
&& device
->isInDraw
)
4405 ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
4407 /* Otherwise: System memory copy must be most up to date */
4409 if(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) {
4410 This
->Flags
|= SFLAG_GLCKEY
;
4411 This
->glCKey
= This
->SrcBltCKey
;
4413 else This
->Flags
&= ~SFLAG_GLCKEY
;
4415 /* The width is in 'length' not in bytes */
4416 width
= This
->currentDesc
.Width
;
4417 pitch
= IWineD3DSurface_GetPitch(iface
);
4419 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4420 * but it isn't set (yet) in all cases it is getting called. */
4421 if((convert
!= NO_CONVERSION
) && (This
->Flags
& SFLAG_PBO
)) {
4422 TRACE("Removing the pbo attached to surface %p\n", This
);
4423 surface_remove_pbo(This
);
4426 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
4427 int height
= This
->currentDesc
.Height
;
4429 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4430 outpitch
= width
* bpp
;
4431 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
4433 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
4435 ERR("Out of memory %d, %d!\n", outpitch
, height
);
4436 return WINED3DERR_OUTOFVIDEOMEMORY
;
4438 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
4440 This
->Flags
|= SFLAG_CONVERTED
;
4441 } else if( (This
->resource
.format
== WINED3DFMT_P8
) && (GL_SUPPORT(EXT_PALETTED_TEXTURE
) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) ) {
4442 d3dfmt_p8_upload_palette(iface
, convert
);
4443 This
->Flags
&= ~SFLAG_CONVERTED
;
4444 mem
= This
->resource
.allocatedMemory
;
4446 This
->Flags
&= ~SFLAG_CONVERTED
;
4447 mem
= This
->resource
.allocatedMemory
;
4450 /* Make sure the correct pitch is used */
4451 glPixelStorei(GL_UNPACK_ROW_LENGTH
, width
);
4453 if ((This
->Flags
& SFLAG_NONPOW2
) && !(This
->Flags
& SFLAG_OVERSIZE
)) {
4454 TRACE("non power of two support\n");
4455 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
4456 surface_allocate_surface(This
, internal
, This
->pow2Width
, This
->pow2Height
, format
, type
);
4458 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
4459 surface_upload_data(This
, internal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
, format
, type
, mem
);
4462 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
4463 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
4465 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
4466 surface_allocate_surface(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
);
4468 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
4469 surface_upload_data(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
, mem
);
4473 /* Restore the default pitch */
4474 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
4477 /* Don't delete PBO memory */
4478 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
4479 HeapFree(GetProcessHeap(), 0, mem
);
4484 This
->Flags
|= flag
;
4487 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& !swapchain
4488 && (This
->Flags
& (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
))) {
4489 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4490 This
->Flags
|= (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
4496 HRESULT WINAPI
IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface
*iface
, IWineD3DBase
*container
) {
4497 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4498 IWineD3DSwapChain
*swapchain
= NULL
;
4500 /* Update the drawable size method */
4502 IWineD3DBase_QueryInterface(container
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
4505 This
->get_drawable_size
= get_drawable_size_swapchain
;
4506 IWineD3DSwapChain_Release(swapchain
);
4507 } else if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
4508 switch(wined3d_settings
.offscreen_rendering_mode
) {
4509 case ORM_FBO
: This
->get_drawable_size
= get_drawable_size_fbo
; break;
4510 case ORM_PBUFFER
: This
->get_drawable_size
= get_drawable_size_pbuffer
; break;
4511 case ORM_BACKBUFFER
: This
->get_drawable_size
= get_drawable_size_backbuffer
; break;
4515 return IWineD3DBaseSurfaceImpl_SetContainer(iface
, container
);
4518 static WINED3DSURFTYPE WINAPI
IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface
*iface
) {
4519 return SURFACE_OPENGL
;
4522 static HRESULT WINAPI
IWineD3DSurfaceImpl_DrawOverlay(IWineD3DSurface
*iface
) {
4523 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4526 /* If there's no destination surface there is nothing to do */
4527 if(!This
->overlay_dest
) return WINED3D_OK
;
4529 /* Blt calls ModifyLocation on the dest surface, which in turn calls DrawOverlay to
4530 * update the overlay. Prevent an endless recursion
4532 if(This
->overlay_dest
->Flags
& SFLAG_INOVERLAYDRAW
) {
4535 This
->overlay_dest
->Flags
|= SFLAG_INOVERLAYDRAW
;
4536 hr
= IWineD3DSurfaceImpl_Blt((IWineD3DSurface
*) This
->overlay_dest
, &This
->overlay_destrect
,
4537 iface
, &This
->overlay_srcrect
, WINEDDBLT_WAIT
,
4538 NULL
, WINED3DTEXF_LINEAR
);
4539 This
->overlay_dest
->Flags
&= ~SFLAG_INOVERLAYDRAW
;
4544 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl
=
4547 IWineD3DBaseSurfaceImpl_QueryInterface
,
4548 IWineD3DBaseSurfaceImpl_AddRef
,
4549 IWineD3DSurfaceImpl_Release
,
4550 /* IWineD3DResource */
4551 IWineD3DBaseSurfaceImpl_GetParent
,
4552 IWineD3DBaseSurfaceImpl_GetDevice
,
4553 IWineD3DBaseSurfaceImpl_SetPrivateData
,
4554 IWineD3DBaseSurfaceImpl_GetPrivateData
,
4555 IWineD3DBaseSurfaceImpl_FreePrivateData
,
4556 IWineD3DBaseSurfaceImpl_SetPriority
,
4557 IWineD3DBaseSurfaceImpl_GetPriority
,
4558 IWineD3DSurfaceImpl_PreLoad
,
4559 IWineD3DSurfaceImpl_UnLoad
,
4560 IWineD3DBaseSurfaceImpl_GetType
,
4561 /* IWineD3DSurface */
4562 IWineD3DBaseSurfaceImpl_GetContainer
,
4563 IWineD3DBaseSurfaceImpl_GetDesc
,
4564 IWineD3DSurfaceImpl_LockRect
,
4565 IWineD3DSurfaceImpl_UnlockRect
,
4566 IWineD3DSurfaceImpl_GetDC
,
4567 IWineD3DSurfaceImpl_ReleaseDC
,
4568 IWineD3DSurfaceImpl_Flip
,
4569 IWineD3DSurfaceImpl_Blt
,
4570 IWineD3DBaseSurfaceImpl_GetBltStatus
,
4571 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
4572 IWineD3DBaseSurfaceImpl_IsLost
,
4573 IWineD3DBaseSurfaceImpl_Restore
,
4574 IWineD3DSurfaceImpl_BltFast
,
4575 IWineD3DBaseSurfaceImpl_GetPalette
,
4576 IWineD3DBaseSurfaceImpl_SetPalette
,
4577 IWineD3DSurfaceImpl_RealizePalette
,
4578 IWineD3DBaseSurfaceImpl_SetColorKey
,
4579 IWineD3DBaseSurfaceImpl_GetPitch
,
4580 IWineD3DSurfaceImpl_SetMem
,
4581 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
4582 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
4583 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
4584 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
4585 IWineD3DBaseSurfaceImpl_SetClipper
,
4586 IWineD3DBaseSurfaceImpl_GetClipper
,
4588 IWineD3DSurfaceImpl_AddDirtyRect
,
4589 IWineD3DSurfaceImpl_LoadTexture
,
4590 IWineD3DSurfaceImpl_BindTexture
,
4591 IWineD3DSurfaceImpl_SaveSnapshot
,
4592 IWineD3DSurfaceImpl_SetContainer
,
4593 IWineD3DSurfaceImpl_SetGlTextureDesc
,
4594 IWineD3DSurfaceImpl_GetGlDesc
,
4595 IWineD3DSurfaceImpl_GetData
,
4596 IWineD3DSurfaceImpl_SetFormat
,
4597 IWineD3DSurfaceImpl_PrivateSetup
,
4598 IWineD3DSurfaceImpl_ModifyLocation
,
4599 IWineD3DSurfaceImpl_LoadLocation
,
4600 IWineD3DSurfaceImpl_GetImplType
,
4601 IWineD3DSurfaceImpl_DrawOverlay
4603 #undef GLINFO_LOCATION
4605 #define GLINFO_LOCATION device->adapter->gl_info
4606 static HRESULT
ffp_blit_alloc(IWineD3DDevice
*iface
) { return WINED3D_OK
; }
4607 static void ffp_blit_free(IWineD3DDevice
*iface
) { }
4609 static HRESULT
ffp_blit_set(IWineD3DDevice
*iface
, WINED3DFORMAT fmt
, GLenum textype
, UINT width
, UINT height
) {
4611 checkGLcall("glEnable(textype)");
4615 static void ffp_blit_unset(IWineD3DDevice
*iface
) {
4616 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) iface
;
4617 glDisable(GL_TEXTURE_2D
);
4618 checkGLcall("glDisable(GL_TEXTURE_2D)");
4619 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
4620 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
4621 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4623 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
4624 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
4625 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
4629 static BOOL
ffp_blit_conv_supported(WINED3DFORMAT fmt
) {
4630 TRACE("Checking blit format support for format %s: [FAILED]\n", debug_d3dformat(fmt
));
4634 const struct blit_shader ffp_blit
= {
4639 ffp_blit_conv_supported