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 * To be more specific, this is tricky because we can implicitly be called
50 * from sampler() in state.c. This means we can't touch anything other than
51 * whatever happens to be the currently active texture, or we would risk
52 * marking already applied sampler states dirty again.
54 * TODO: Track the current active texture per GL context instead of using glGet
56 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
59 glGetIntegerv(GL_ACTIVE_TEXTURE
, &active_texture
);
61 active_sampler
= This
->resource
.wineD3DDevice
->rev_tex_unit_map
[active_texture
- GL_TEXTURE0_ARB
];
66 if (active_sampler
!= -1) {
67 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(active_sampler
));
69 IWineD3DSurface_BindTexture((IWineD3DSurface
*)This
);
72 /* This function checks if the primary render target uses the 8bit paletted format. */
73 static BOOL
primary_render_target_is_p8(IWineD3DDeviceImpl
*device
)
75 if (device
->render_targets
&& device
->render_targets
[0]) {
76 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
77 if((render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) && (render_target
->resource
.format
== WINED3DFMT_P8
))
83 /* This call just downloads data, the caller is responsible for activating the
84 * right context and binding the correct texture. */
85 static void surface_download_data(IWineD3DSurfaceImpl
*This
) {
86 if (0 == This
->glDescription
.textureName
) {
87 ERR("Surface does not have a texture, but SFLAG_INTEXTURE is set\n");
91 /* Only support read back of converted P8 surfaces */
92 if(This
->Flags
& SFLAG_CONVERTED
&& (This
->resource
.format
!= WINED3DFMT_P8
)) {
93 FIXME("Read back converted textures unsupported, format=%s\n", debug_d3dformat(This
->resource
.format
));
99 if (This
->resource
.format
== WINED3DFMT_DXT1
||
100 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
101 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
102 This
->resource
.format
== WINED3DFMT_ATI2N
) {
103 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) { /* We can assume this as the texture would not have been created otherwise */
104 FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This
);
106 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
107 This
->glDescription
.glFormat
, This
->glDescription
.glType
, This
->resource
.allocatedMemory
);
109 if(This
->Flags
& SFLAG_PBO
) {
110 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
111 checkGLcall("glBindBufferARB");
112 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, NULL
));
113 checkGLcall("glGetCompressedTexImageARB()");
114 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
115 checkGLcall("glBindBufferARB");
117 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, This
->resource
.allocatedMemory
));
118 checkGLcall("glGetCompressedTexImageARB()");
124 GLenum format
= This
->glDescription
.glFormat
;
125 GLenum type
= This
->glDescription
.glType
;
129 /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
130 if(This
->resource
.format
== WINED3DFMT_P8
&& primary_render_target_is_p8(This
->resource
.wineD3DDevice
)) {
132 type
= GL_UNSIGNED_BYTE
;
135 if (This
->Flags
& SFLAG_NONPOW2
) {
136 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
137 src_pitch
= This
->bytesPerPixel
* This
->pow2Width
;
138 dst_pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
);
139 src_pitch
= (src_pitch
+ alignment
- 1) & ~(alignment
- 1);
140 mem
= HeapAlloc(GetProcessHeap(), 0, src_pitch
* This
->pow2Height
);
142 mem
= This
->resource
.allocatedMemory
;
145 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
148 if(This
->Flags
& SFLAG_PBO
) {
149 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
150 checkGLcall("glBindBufferARB");
152 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, format
,
154 checkGLcall("glGetTexImage()");
156 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
157 checkGLcall("glBindBufferARB");
159 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, format
,
161 checkGLcall("glGetTexImage()");
165 if (This
->Flags
& SFLAG_NONPOW2
) {
166 LPBYTE src_data
, dst_data
;
169 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
170 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
171 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
173 * We're doing this...
175 * instead of boxing the texture :
176 * |<-texture width ->| -->pow2width| /\
177 * |111111111111111111| | |
178 * |222 Texture 222222| boxed empty | texture height
179 * |3333 Data 33333333| | |
180 * |444444444444444444| | \/
181 * ----------------------------------- |
182 * | boxed empty | boxed empty | pow2height
184 * -----------------------------------
187 * we're repacking the data to the expected texture width
189 * |<-texture width ->| -->pow2width| /\
190 * |111111111111111111222222222222222| |
191 * |222333333333333333333444444444444| texture height
195 * | empty | pow2height
197 * -----------------------------------
201 * |<-texture width ->| /\
202 * |111111111111111111|
203 * |222222222222222222|texture height
204 * |333333333333333333|
205 * |444444444444444444| \/
206 * --------------------
208 * this also means that any references to allocatedMemory should work with the data as if were a
209 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
211 * internally the texture is still stored in a boxed format so any references to textureName will
212 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
214 * Performance should not be an issue, because applications normally do not lock the surfaces when
215 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
216 * and doesn't have to be re-read.
219 dst_data
= This
->resource
.allocatedMemory
;
220 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This
, src_pitch
, dst_pitch
);
221 for (y
= 1 ; y
< This
->currentDesc
.Height
; y
++) {
222 /* skip the first row */
223 src_data
+= src_pitch
;
224 dst_data
+= dst_pitch
;
225 memcpy(dst_data
, src_data
, dst_pitch
);
228 HeapFree(GetProcessHeap(), 0, mem
);
232 /* Surface has now been downloaded */
233 This
->Flags
|= SFLAG_INSYSMEM
;
236 /* This call just uploads data, the caller is responsible for activating the
237 * right context and binding the correct texture. */
238 static void surface_upload_data(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*data
) {
240 if(This
->heightscale
!= 1.0 && This
->heightscale
!= 0.0) height
*= This
->heightscale
;
242 if (This
->resource
.format
== WINED3DFMT_DXT1
||
243 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
244 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
245 This
->resource
.format
== WINED3DFMT_ATI2N
) {
246 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
247 FIXME("Using DXT1/3/5 without advertized support\n");
249 /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
250 * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
251 * function uses glCompressedTexImage2D instead of the SubImage call
253 TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This
, width
, height
, data
);
256 if(This
->Flags
& SFLAG_PBO
) {
257 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
258 checkGLcall("glBindBufferARB");
259 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
261 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
262 width
, height
, 0 /* border */, This
->resource
.size
, NULL
));
263 checkGLcall("glCompressedTexSubImage2D");
265 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
266 checkGLcall("glBindBufferARB");
268 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
269 width
, height
, 0 /* border */, This
->resource
.size
, data
));
270 checkGLcall("glCompressedTexSubImage2D");
275 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This
, width
, height
, data
);
278 if(This
->Flags
& SFLAG_PBO
) {
279 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
280 checkGLcall("glBindBufferARB");
281 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
283 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, NULL
);
284 checkGLcall("glTexSubImage2D");
286 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
287 checkGLcall("glBindBufferARB");
290 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, data
);
291 checkGLcall("glTexSubImage2D");
298 /* This call just allocates the texture, the caller is responsible for
299 * activating the right context and binding the correct texture. */
300 static void surface_allocate_surface(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
) {
301 BOOL enable_client_storage
= FALSE
;
304 if(This
->heightscale
!= 1.0 && This
->heightscale
!= 0.0) height
*= This
->heightscale
;
306 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
,
307 This
->glDescription
.target
, This
->glDescription
.level
, debug_d3dformat(This
->resource
.format
), internal
, width
, height
, format
, type
);
309 if (This
->resource
.format
== WINED3DFMT_DXT1
||
310 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
311 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
||
312 This
->resource
.format
== WINED3DFMT_ATI2N
) {
313 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
314 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
316 /* We have to point GL to the client storage memory here, because upload_data might use a PBO. This means a double upload
317 * once, unfortunately
319 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
320 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
321 This
->Flags
|= SFLAG_CLIENT
;
322 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
324 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
325 width
, height
, 0 /* border */, This
->resource
.size
, mem
));
334 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
335 if(This
->Flags
& (SFLAG_NONPOW2
| SFLAG_DIBSECTION
| SFLAG_OVERSIZE
| SFLAG_CONVERTED
) || This
->resource
.allocatedMemory
== NULL
) {
336 /* In some cases we want to disable client storage.
337 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
338 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
339 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
340 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
341 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
343 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_FALSE
);
344 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
345 This
->Flags
&= ~SFLAG_CLIENT
;
346 enable_client_storage
= TRUE
;
348 This
->Flags
|= SFLAG_CLIENT
;
350 /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
351 * it might point into a pbo. Instead use heapMemory, but get the alignment right.
353 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
356 glTexImage2D(This
->glDescription
.target
, This
->glDescription
.level
, internal
, width
, height
, 0, format
, type
, mem
);
357 checkGLcall("glTexImage2D");
359 if(enable_client_storage
) {
360 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
361 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
365 This
->Flags
|= SFLAG_ALLOCATED
;
368 /* In D3D the depth stencil dimensions have to be greater than or equal to the
369 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
370 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
371 void surface_set_compatible_renderbuffer(IWineD3DSurface
*iface
, unsigned int width
, unsigned int height
) {
372 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
373 renderbuffer_entry_t
*entry
;
374 GLuint renderbuffer
= 0;
375 unsigned int src_width
, src_height
;
377 src_width
= This
->pow2Width
;
378 src_height
= This
->pow2Height
;
380 /* A depth stencil smaller than the render target is not valid */
381 if (width
> src_width
|| height
> src_height
) return;
383 /* Remove any renderbuffer set if the sizes match */
384 if (width
== src_width
&& height
== src_height
) {
385 This
->current_renderbuffer
= NULL
;
389 /* Look if we've already got a renderbuffer of the correct dimensions */
390 LIST_FOR_EACH_ENTRY(entry
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
391 if (entry
->width
== width
&& entry
->height
== height
) {
392 renderbuffer
= entry
->id
;
393 This
->current_renderbuffer
= entry
;
399 const GlPixelFormatDesc
*glDesc
;
400 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
402 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer
));
403 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, renderbuffer
));
404 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, glDesc
->glInternal
, width
, height
));
406 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t
));
407 entry
->width
= width
;
408 entry
->height
= height
;
409 entry
->id
= renderbuffer
;
410 list_add_head(&This
->renderbuffers
, &entry
->entry
);
412 This
->current_renderbuffer
= entry
;
415 checkGLcall("set_compatible_renderbuffer");
418 GLenum
surface_get_gl_buffer(IWineD3DSurface
*iface
, IWineD3DSwapChain
*swapchain
) {
419 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
420 IWineD3DSwapChainImpl
*swapchain_impl
= (IWineD3DSwapChainImpl
*)swapchain
;
422 TRACE("(%p) : swapchain %p\n", This
, swapchain
);
424 if (swapchain_impl
->backBuffer
&& swapchain_impl
->backBuffer
[0] == iface
) {
425 TRACE("Returning GL_BACK\n");
427 } else if (swapchain_impl
->frontBuffer
== iface
) {
428 TRACE("Returning GL_FRONT\n");
432 FIXME("Higher back buffer, returning GL_BACK\n");
436 ULONG WINAPI
IWineD3DSurfaceImpl_Release(IWineD3DSurface
*iface
) {
437 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
438 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
439 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
441 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
442 renderbuffer_entry_t
*entry
, *entry2
;
443 TRACE("(%p) : cleaning up\n", This
);
445 /* Need a context to destroy the texture. Use the currently active render target, but only if
446 * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
447 * When destroying the primary rt, Uninit3D will activate a context before doing anything
449 if(device
->render_targets
&& device
->render_targets
[0]) {
450 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
454 if (This
->glDescription
.textureName
!= 0) { /* release the openGL texture.. */
455 TRACE("Deleting texture %d\n", This
->glDescription
.textureName
);
456 glDeleteTextures(1, &This
->glDescription
.textureName
);
459 if(This
->Flags
& SFLAG_PBO
) {
461 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
464 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
465 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
466 HeapFree(GetProcessHeap(), 0, entry
);
470 if(This
->Flags
& SFLAG_DIBSECTION
) {
472 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
474 /* Release the DIB section */
475 DeleteObject(This
->dib
.DIBsection
);
476 This
->dib
.bitmap_data
= NULL
;
477 This
->resource
.allocatedMemory
= NULL
;
479 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
481 HeapFree(GetProcessHeap(), 0, This
->palette9
);
483 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
485 if(This
->overlay_dest
) {
486 list_remove(&This
->overlay_entry
);
489 TRACE("(%p) Released\n", This
);
490 HeapFree(GetProcessHeap(), 0, This
);
496 /* ****************************************************
497 IWineD3DSurface IWineD3DResource parts follow
498 **************************************************** */
500 void WINAPI
IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface
*iface
) {
501 /* TODO: check for locks */
502 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
503 IWineD3DBaseTexture
*baseTexture
= NULL
;
504 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
506 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
507 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
508 TRACE("Passing to container\n");
509 IWineD3DBaseTexture_PreLoad(baseTexture
);
510 IWineD3DBaseTexture_Release(baseTexture
);
512 TRACE("(%p) : About to load surface\n", This
);
514 if(!device
->isInDraw
) {
515 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
518 if (This
->resource
.format
== WINED3DFMT_P8
|| This
->resource
.format
== WINED3DFMT_A8P8
) {
519 if(palette9_changed(This
)) {
520 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
521 /* TODO: This is not necessarily needed with hw palettized texture support */
522 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
523 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
524 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
528 IWineD3DSurface_LoadTexture(iface
, FALSE
);
530 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
531 /* Tell opengl to try and keep this texture in video ram (well mostly) */
535 glPrioritizeTextures(1, &This
->glDescription
.textureName
, &tmp
);
542 static void surface_remove_pbo(IWineD3DSurfaceImpl
*This
) {
543 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
544 This
->resource
.allocatedMemory
=
545 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
548 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
549 checkGLcall("glBindBuffer(GL_PIXEL_UNPACK_BUFFER, This->pbo)");
550 GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0, This
->resource
.size
, This
->resource
.allocatedMemory
));
551 checkGLcall("glGetBufferSubData");
552 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
553 checkGLcall("glDeleteBuffers");
557 This
->Flags
&= ~SFLAG_PBO
;
560 static void WINAPI
IWineD3DSurfaceImpl_UnLoad(IWineD3DSurface
*iface
) {
561 IWineD3DBaseTexture
*texture
= NULL
;
562 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
563 renderbuffer_entry_t
*entry
, *entry2
;
564 TRACE("(%p)\n", iface
);
566 if(This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
567 /* Default pool resources are supposed to be destroyed before Reset is called.
568 * Implicit resources stay however. So this means we have an implicit render target
569 * or depth stencil. The content may be destroyed, but we still have to tear down
570 * opengl resources, so we cannot leave early.
572 * Put the most up to date surface location into the drawable. D3D-wise this content
573 * is undefined, so it would be nowhere, but that would make the location management
574 * more complicated. The drawable is a sane location, because if we mark sysmem or
575 * texture up to date, drawPrim will copy the uninitialized texture or sysmem to the
576 * uninitialized drawable. That's pointless and we'd have to allocate the texture /
579 if (This
->resource
.usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
580 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
582 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, TRUE
);
585 /* Load the surface into system memory */
586 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
587 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, FALSE
);
589 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
590 This
->Flags
&= ~SFLAG_ALLOCATED
;
592 /* Destroy PBOs, but load them into real sysmem before */
593 if(This
->Flags
& SFLAG_PBO
) {
594 surface_remove_pbo(This
);
597 /* Destroy fbo render buffers. This is needed for implicit render targets, for
598 * all application-created targets the application has to release the surface
599 * before calling _Reset
601 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
603 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
605 list_remove(&entry
->entry
);
606 HeapFree(GetProcessHeap(), 0, entry
);
608 list_init(&This
->renderbuffers
);
609 This
->current_renderbuffer
= NULL
;
611 /* If we're in a texture, the texture name belongs to the texture. Otherwise,
614 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **) &texture
);
617 glDeleteTextures(1, &This
->glDescription
.textureName
);
618 This
->glDescription
.textureName
= 0;
621 IWineD3DBaseTexture_Release(texture
);
626 /* ******************************************************
627 IWineD3DSurface IWineD3DSurface parts follow
628 ****************************************************** */
630 void WINAPI
IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface
*iface
, UINT textureName
, int target
) {
631 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
632 TRACE("(%p) : setting textureName %u, target %#x\n", This
, textureName
, target
);
633 if (This
->glDescription
.textureName
== 0 && textureName
!= 0) {
634 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
635 if((This
->Flags
& SFLAG_LOCATIONS
) == 0) {
636 /* In 1.0-rc4 and earlier, AddDirtyRect was called in the place of this if condition.
637 * This had the problem that a correctly set INDRAWABLE flag was removed if the PreLoad
638 * during the offscreen rendering readback triggered the creation of the GL texture.
639 * The change intended to keep the INDRAWABLE intact. To prevent unintended side effects
640 * before release, set the INSYSMEM flag like the old AddDirtyRect did.
642 WARN("Wine 1.0 safety path hit\n");
643 This
->Flags
|= SFLAG_INSYSMEM
;
646 if(target
== GL_TEXTURE_RECTANGLE_ARB
&& This
->glDescription
.target
!= target
) {
647 This
->Flags
&= ~SFLAG_NORMCOORD
;
648 } else if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
&& target
!= GL_TEXTURE_RECTANGLE_ARB
) {
649 This
->Flags
|= SFLAG_NORMCOORD
;
651 This
->glDescription
.textureName
= textureName
;
652 This
->glDescription
.target
= target
;
653 This
->Flags
&= ~SFLAG_ALLOCATED
;
656 void WINAPI
IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
657 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
658 TRACE("(%p) : returning %p\n", This
, &This
->glDescription
);
659 *glDescription
= &This
->glDescription
;
662 /* TODO: think about moving this down to resource? */
663 const void *WINAPI
IWineD3DSurfaceImpl_GetData(IWineD3DSurface
*iface
) {
664 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
665 /* 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 */
666 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
) {
667 FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface
);
669 return (CONST
void*)(This
->resource
.allocatedMemory
);
672 /* Read the framebuffer back into the surface */
673 static void read_from_framebuffer(IWineD3DSurfaceImpl
*This
, CONST RECT
*rect
, void *dest
, UINT pitch
) {
674 IWineD3DSwapChainImpl
*swapchain
;
675 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
679 BYTE
*row
, *top
, *bottom
;
683 BOOL srcIsUpsideDown
;
685 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
686 static BOOL warned
= FALSE
;
688 ERR("The application tries to lock the render target, but render target locking is disabled\n");
694 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
695 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
696 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
697 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
698 * context->last_was_blit set on the unlock.
700 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
703 /* Select the correct read buffer, and give some debug output.
704 * There is no need to keep track of the current read buffer or reset it, every part of the code
705 * that reads sets the read buffer as desired.
708 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
709 * Read from the back buffer
711 TRACE("Locking offscreen render target\n");
712 glReadBuffer(myDevice
->offscreenBuffer
);
713 srcIsUpsideDown
= TRUE
;
715 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
716 TRACE("Locking %#x buffer\n", buffer
);
717 glReadBuffer(buffer
);
718 checkGLcall("glReadBuffer");
720 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
721 srcIsUpsideDown
= FALSE
;
724 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
728 local_rect
.right
= This
->currentDesc
.Width
;
729 local_rect
.bottom
= This
->currentDesc
.Height
;
733 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
735 switch(This
->resource
.format
)
739 if(primary_render_target_is_p8(myDevice
)) {
740 /* In case of P8 render targets the index is stored in the alpha component */
742 type
= GL_UNSIGNED_BYTE
;
744 bpp
= This
->bytesPerPixel
;
746 /* GL can't return palettized data, so read ARGB pixels into a
747 * separate block of memory and convert them into palettized format
748 * in software. Slow, but if the app means to use palettized render
749 * targets and locks it...
751 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
752 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
753 * for the color channels when palettizing the colors.
756 type
= GL_UNSIGNED_BYTE
;
758 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* 3);
760 ERR("Out of memory\n");
764 bpp
= This
->bytesPerPixel
* 3;
771 fmt
= This
->glDescription
.glFormat
;
772 type
= This
->glDescription
.glType
;
773 bpp
= This
->bytesPerPixel
;
776 if(This
->Flags
& SFLAG_PBO
) {
777 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
778 checkGLcall("glBindBufferARB");
781 glReadPixels(local_rect
.left
, local_rect
.top
,
782 local_rect
.right
- local_rect
.left
,
783 local_rect
.bottom
- local_rect
.top
,
785 vcheckGLcall("glReadPixels");
787 if(This
->Flags
& SFLAG_PBO
) {
788 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
789 checkGLcall("glBindBufferARB");
791 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
792 * to get a pointer to it and perform the flipping in software. This is a lot
793 * faster than calling glReadPixels for each line. In case we want more speed
794 * we should rerender it flipped in a FBO and read the data back from the FBO. */
795 if(!srcIsUpsideDown
) {
796 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
797 checkGLcall("glBindBufferARB");
799 mem
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
800 checkGLcall("glMapBufferARB");
804 /* TODO: Merge this with the palettization loop below for P8 targets */
805 if(!srcIsUpsideDown
) {
807 /* glReadPixels returns the image upside down, and there is no way to prevent this.
808 Flip the lines in software */
809 len
= (local_rect
.right
- local_rect
.left
) * bpp
;
810 off
= local_rect
.left
* bpp
;
812 row
= HeapAlloc(GetProcessHeap(), 0, len
);
814 ERR("Out of memory\n");
815 if(This
->resource
.format
== WINED3DFMT_P8
) HeapFree(GetProcessHeap(), 0, mem
);
820 top
= mem
+ pitch
* local_rect
.top
;
821 bottom
= mem
+ pitch
* ( local_rect
.bottom
- local_rect
.top
- 1);
822 for(i
= 0; i
< (local_rect
.bottom
- local_rect
.top
) / 2; i
++) {
823 memcpy(row
, top
+ off
, len
);
824 memcpy(top
+ off
, bottom
+ off
, len
);
825 memcpy(bottom
+ off
, row
, len
);
829 HeapFree(GetProcessHeap(), 0, row
);
831 /* Unmap the temp PBO buffer */
832 if(This
->Flags
& SFLAG_PBO
) {
833 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
834 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
840 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
841 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
842 * the same color but we have no choice.
843 * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
845 if((This
->resource
.format
== WINED3DFMT_P8
) && !primary_render_target_is_p8(myDevice
)) {
846 PALETTEENTRY
*pal
= NULL
;
847 DWORD width
= pitch
/ 3;
851 pal
= This
->palette
->palents
;
853 ERR("Palette is missing, cannot perform inverse palette lookup\n");
854 HeapFree(GetProcessHeap(), 0, mem
);
858 for(y
= local_rect
.top
; y
< local_rect
.bottom
; y
++) {
859 for(x
= local_rect
.left
; x
< local_rect
.right
; x
++) {
860 /* start lines pixels */
861 BYTE
*blue
= mem
+ y
* pitch
+ x
* (sizeof(BYTE
) * 3);
862 BYTE
*green
= blue
+ 1;
863 BYTE
*red
= green
+ 1;
865 for(c
= 0; c
< 256; c
++) {
866 if(*red
== pal
[c
].peRed
&&
867 *green
== pal
[c
].peGreen
&&
868 *blue
== pal
[c
].peBlue
)
870 *((BYTE
*) dest
+ y
* width
+ x
) = c
;
876 HeapFree(GetProcessHeap(), 0, mem
);
880 /* Read the framebuffer contents into a texture */
881 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl
*This
)
883 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
884 IWineD3DSwapChainImpl
*swapchain
;
886 GLenum format
, internal
, type
;
887 CONVERT_TYPES convert
;
890 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
892 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
893 /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
894 * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
895 * states in the stateblock, and no driver was found yet that had bugs in that regard.
897 ActivateContext(device
, (IWineD3DSurface
*) This
, CTXUSAGE_RESOURCELOAD
);
898 surface_bind_and_dirtify(This
);
901 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
903 /* Select the correct read buffer, and give some debug output.
904 * There is no need to keep track of the current read buffer or reset it, every part of the code
905 * that reads sets the read buffer as desired.
908 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
909 * Read from the back buffer
911 TRACE("Locking offscreen render target\n");
912 glReadBuffer(device
->offscreenBuffer
);
914 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
915 TRACE("Locking %#x buffer\n", buffer
);
916 glReadBuffer(buffer
);
917 checkGLcall("glReadBuffer");
919 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
922 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
923 surface_allocate_surface(This
, internal
, This
->pow2Width
,
924 This
->pow2Height
, format
, type
);
927 clear_unused_channels(This
);
929 /* If !SrcIsUpsideDown we should flip the surface.
930 * This can be done using glCopyTexSubImage2D but this
931 * is VERY slow, so don't do that. We should prevent
932 * this code from getting called in such cases or perhaps
935 glCopyTexSubImage2D(This
->glDescription
.target
,
936 This
->glDescription
.level
,
938 This
->currentDesc
.Width
,
939 This
->currentDesc
.Height
);
940 checkGLcall("glCopyTexSubImage2D");
942 glReadBuffer(prevRead
);
943 vcheckGLcall("glReadBuffer");
946 TRACE("Updated target %d\n", This
->glDescription
.target
);
949 static void surface_prepare_system_memory(IWineD3DSurfaceImpl
*This
) {
950 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
951 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
954 if(!(This
->Flags
& SFLAG_DYNLOCK
)) {
956 /* MAXLOCKCOUNT is defined in wined3d_private.h */
957 if(This
->lockCount
> MAXLOCKCOUNT
) {
958 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
959 This
->Flags
|= SFLAG_DYNLOCK
;
963 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
964 * Also don't create a PBO for systemmem surfaces.
966 if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT
) && (This
->Flags
& SFLAG_DYNLOCK
) && !(This
->Flags
& (SFLAG_PBO
| SFLAG_CONVERTED
| SFLAG_NONPOW2
)) && (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
)) {
968 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
970 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
973 GL_EXTCALL(glGenBuffersARB(1, &This
->pbo
));
974 error
= glGetError();
975 if(This
->pbo
== 0 || error
!= GL_NO_ERROR
) {
976 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error
), error
);
979 TRACE("Attaching pbo=%#x to (%p)\n", This
->pbo
, This
);
981 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
982 checkGLcall("glBindBufferARB");
984 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->resource
.size
+ 4, This
->resource
.allocatedMemory
, GL_STREAM_DRAW_ARB
));
985 checkGLcall("glBufferDataARB");
987 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
988 checkGLcall("glBindBufferARB");
990 /* We don't need the system memory anymore and we can't even use it for PBOs */
991 if(!(This
->Flags
& SFLAG_CLIENT
)) {
992 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
993 This
->resource
.heapMemory
= NULL
;
995 This
->resource
.allocatedMemory
= NULL
;
996 This
->Flags
|= SFLAG_PBO
;
998 } else if(!(This
->resource
.allocatedMemory
|| This
->Flags
& SFLAG_PBO
)) {
999 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
1002 if(!This
->resource
.heapMemory
) {
1003 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
1005 This
->resource
.allocatedMemory
=
1006 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
1007 if(This
->Flags
& SFLAG_INSYSMEM
) {
1008 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1013 static HRESULT WINAPI
IWineD3DSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
) {
1014 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1015 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1016 IWineD3DSwapChain
*swapchain
= NULL
;
1018 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
1020 /* This is also done in the base class, but we have to verify this before loading any data from
1021 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1022 * may interfere, and all other bad things may happen
1024 if (This
->Flags
& SFLAG_LOCKED
) {
1025 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1026 return WINED3DERR_INVALIDCALL
;
1028 This
->Flags
|= SFLAG_LOCKED
;
1030 if (!(This
->Flags
& SFLAG_LOCKABLE
))
1032 TRACE("Warning: trying to lock unlockable surf@%p\n", This
);
1035 if (Flags
& WINED3DLOCK_DISCARD
) {
1036 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
1037 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
1038 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
1039 This
->Flags
|= SFLAG_INSYSMEM
;
1043 if (This
->Flags
& SFLAG_INSYSMEM
) {
1044 TRACE("Local copy is up to date, not downloading data\n");
1045 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
1049 /* Now download the surface content from opengl
1050 * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
1051 * Offscreen targets which are not active at the moment or are higher targets(FBOs) can be locked with the texture path
1053 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1054 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
1055 const RECT
*pass_rect
= pRect
;
1057 /* IWineD3DSurface_LoadLocation does not check if the rectangle specifies the full surfaces
1058 * because most caller functions do not need that. So do that here
1063 pRect
->right
== This
->currentDesc
.Width
&&
1064 pRect
->bottom
== This
->currentDesc
.Height
) {
1068 switch(wined3d_settings
.rendertargetlock_mode
) {
1071 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
1073 /* Disabled for now. LoadLocation prefers the texture over the drawable as the source. So if we copy to the
1074 * texture first, then to sysmem, we'll avoid glReadPixels and use glCopyTexImage and glGetTexImage2D instead.
1075 * This may be faster on some cards
1077 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* No partial texture copy yet */);
1084 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, pRect
);
1090 if(swapchain
) IWineD3DSwapChain_Release(swapchain
);
1092 } else if(iface
== myDevice
->stencilBufferTarget
) {
1093 /** the depth stencil in openGL has a format of GL_FLOAT
1094 * which should be good for WINED3DFMT_D16_LOCKABLE
1095 * and WINED3DFMT_D16
1096 * it is unclear what format the stencil buffer is in except.
1097 * 'Each index is converted to fixed point...
1098 * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
1099 * mappings in the table GL_PIXEL_MAP_S_TO_S.
1100 * glReadPixels(This->lockedRect.left,
1101 * This->lockedRect.bottom - j - 1,
1102 * This->lockedRect.right - This->lockedRect.left,
1104 * GL_DEPTH_COMPONENT,
1106 * (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
1108 * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
1109 * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
1110 * none of that is the case the problem is not in this function :-)
1111 ********************************************/
1112 FIXME("Depth stencil locking not supported yet\n");
1114 /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
1115 TRACE("locking an ordinary surface\n");
1116 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
1120 if(This
->Flags
& SFLAG_PBO
) {
1121 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1123 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1124 checkGLcall("glBindBufferARB");
1126 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1127 if(This
->resource
.allocatedMemory
) {
1128 ERR("The surface already has PBO memory allocated!\n");
1131 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
1132 checkGLcall("glMapBufferARB");
1134 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1135 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1136 checkGLcall("glBindBufferARB");
1141 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
1144 IWineD3DBaseTexture
*pBaseTexture
;
1147 * as seen in msdn docs
1149 IWineD3DSurface_AddDirtyRect(iface
, pRect
);
1151 /** Dirtify Container if needed */
1152 if (WINED3D_OK
== IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&pBaseTexture
) && pBaseTexture
!= NULL
) {
1153 TRACE("Making container dirty\n");
1154 IWineD3DBaseTexture_SetDirty(pBaseTexture
, TRUE
);
1155 IWineD3DBaseTexture_Release(pBaseTexture
);
1157 TRACE("Surface is standalone, no need to dirty the container\n");
1161 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
1164 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl
*This
, GLenum fmt
, GLenum type
, UINT bpp
, const BYTE
*mem
) {
1166 GLint prev_rasterpos
[4];
1167 GLint skipBytes
= 0;
1168 UINT pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
); /* target is argb, 4 byte */
1169 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1170 IWineD3DSwapChainImpl
*swapchain
;
1172 /* Activate the correct context for the render target */
1173 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
1176 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1178 /* Primary offscreen render target */
1179 TRACE("Offscreen render target\n");
1180 glDrawBuffer(myDevice
->offscreenBuffer
);
1181 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1183 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
1184 TRACE("Unlocking %#x buffer\n", buffer
);
1185 glDrawBuffer(buffer
);
1186 checkGLcall("glDrawBuffer");
1188 IWineD3DSwapChain_Release((IWineD3DSwapChain
*)swapchain
);
1191 glGetIntegerv(GL_PACK_SWAP_BYTES
, &prev_store
);
1192 vcheckGLcall("glIntegerv");
1193 glGetIntegerv(GL_CURRENT_RASTER_POSITION
, &prev_rasterpos
[0]);
1194 vcheckGLcall("glIntegerv");
1195 glPixelZoom(1.0, -1.0);
1196 vcheckGLcall("glPixelZoom");
1198 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
1199 glGetIntegerv(GL_UNPACK_ROW_LENGTH
, &skipBytes
);
1200 glPixelStorei(GL_UNPACK_ROW_LENGTH
, This
->currentDesc
.Width
);
1202 glRasterPos3i(This
->lockedRect
.left
, This
->lockedRect
.top
, 1);
1203 vcheckGLcall("glRasterPos2f");
1205 /* Some drivers(radeon dri, others?) don't like exceptions during
1206 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
1207 * after ReleaseDC. Reading it will cause an exception, which x11drv will
1208 * catch to put the dib section in InSync mode, which leads to a crash
1209 * and a blocked x server on my radeon card.
1211 * The following lines read the dib section so it is put in InSync mode
1212 * before glDrawPixels is called and the crash is prevented. There won't
1213 * be any interfering gdi accesses, because UnlockRect is called from
1214 * ReleaseDC, and the app won't use the dc any more afterwards.
1216 if((This
->Flags
& SFLAG_DIBSECTION
) && !(This
->Flags
& SFLAG_PBO
)) {
1218 read
= This
->resource
.allocatedMemory
[0];
1221 if(This
->Flags
& SFLAG_PBO
) {
1222 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1223 checkGLcall("glBindBufferARB");
1226 /* When the surface is locked we only have to refresh the locked part else we need to update the whole image */
1227 if(This
->Flags
& SFLAG_LOCKED
) {
1228 glDrawPixels(This
->lockedRect
.right
- This
->lockedRect
.left
,
1229 (This
->lockedRect
.bottom
- This
->lockedRect
.top
)-1,
1231 mem
+ bpp
* This
->lockedRect
.left
+ pitch
* This
->lockedRect
.top
);
1232 checkGLcall("glDrawPixels");
1234 glDrawPixels(This
->currentDesc
.Width
,
1235 This
->currentDesc
.Height
,
1237 checkGLcall("glDrawPixels");
1240 if(This
->Flags
& SFLAG_PBO
) {
1241 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1242 checkGLcall("glBindBufferARB");
1245 glPixelZoom(1.0,1.0);
1246 vcheckGLcall("glPixelZoom");
1248 glRasterPos3iv(&prev_rasterpos
[0]);
1249 vcheckGLcall("glRasterPos3iv");
1251 /* Reset to previous pack row length */
1252 glPixelStorei(GL_UNPACK_ROW_LENGTH
, skipBytes
);
1253 vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1256 glDrawBuffer(myDevice
->offscreenBuffer
);
1257 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1258 } else if(swapchain
->backBuffer
) {
1259 glDrawBuffer(GL_BACK
);
1260 checkGLcall("glDrawBuffer(GL_BACK)");
1262 glDrawBuffer(GL_FRONT
);
1263 checkGLcall("glDrawBuffer(GL_FRONT)");
1270 static HRESULT WINAPI
IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface
*iface
) {
1271 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1272 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1273 IWineD3DSwapChainImpl
*swapchain
= NULL
;
1276 if (!(This
->Flags
& SFLAG_LOCKED
)) {
1277 WARN("trying to Unlock an unlocked surf@%p\n", This
);
1278 return WINED3DERR_INVALIDCALL
;
1281 if (This
->Flags
& SFLAG_PBO
) {
1282 TRACE("Freeing PBO memory\n");
1283 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1285 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1286 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
1287 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1288 checkGLcall("glUnmapBufferARB");
1290 This
->resource
.allocatedMemory
= NULL
;
1293 TRACE("(%p) : dirtyfied(%d)\n", This
, This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
1295 if (This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
)) {
1296 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This
);
1300 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1301 if(swapchain
|| (myDevice
->render_targets
&& iface
== myDevice
->render_targets
[0])) {
1302 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
1304 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
1305 static BOOL warned
= FALSE
;
1307 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1313 if(This
->dirtyRect
.left
== 0 &&
1314 This
->dirtyRect
.top
== 0 &&
1315 This
->dirtyRect
.right
== This
->currentDesc
.Width
&&
1316 This
->dirtyRect
.bottom
== This
->currentDesc
.Height
) {
1319 /* TODO: Proper partial rectangle tracking */
1320 fullsurface
= FALSE
;
1321 This
->Flags
|= SFLAG_INSYSMEM
;
1324 switch(wined3d_settings
.rendertargetlock_mode
) {
1327 ActivateContext(myDevice
, iface
, CTXUSAGE_BLIT
);
1328 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* partial texture loading not supported yet */);
1334 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, fullsurface
? NULL
: &This
->dirtyRect
);
1339 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1340 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1341 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1342 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1343 * not fully up to date because only a subrectangle was read in LockRect.
1345 This
->Flags
&= ~SFLAG_INSYSMEM
;
1346 This
->Flags
|= SFLAG_INDRAWABLE
;
1349 This
->dirtyRect
.left
= This
->currentDesc
.Width
;
1350 This
->dirtyRect
.top
= This
->currentDesc
.Height
;
1351 This
->dirtyRect
.right
= 0;
1352 This
->dirtyRect
.bottom
= 0;
1353 } else if(iface
== myDevice
->stencilBufferTarget
) {
1354 FIXME("Depth Stencil buffer locking is not implemented\n");
1356 /* The rest should be a normal texture */
1357 IWineD3DBaseTextureImpl
*impl
;
1358 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1359 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1360 * states need resetting
1362 if(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&impl
) == WINED3D_OK
) {
1363 if(impl
->baseTexture
.bindCount
) {
1364 IWineD3DDeviceImpl_MarkStateDirty(myDevice
, STATE_SAMPLER(impl
->baseTexture
.sampler
));
1366 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*) impl
);
1371 This
->Flags
&= ~SFLAG_LOCKED
;
1372 memset(&This
->lockedRect
, 0, sizeof(RECT
));
1374 /* Overlays have to be redrawn manually after changes with the GL implementation */
1375 if(This
->overlay_dest
) {
1376 IWineD3DSurface_DrawOverlay(iface
);
1381 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
1382 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1383 WINED3DLOCKED_RECT lock
;
1387 TRACE("(%p)->(%p)\n",This
,pHDC
);
1389 if(This
->Flags
& SFLAG_USERPTR
) {
1390 ERR("Not supported on surfaces with an application-provided surfaces\n");
1391 return WINEDDERR_NODC
;
1394 /* Give more detailed info for ddraw */
1395 if (This
->Flags
& SFLAG_DCINUSE
)
1396 return WINEDDERR_DCALREADYCREATED
;
1398 /* Can't GetDC if the surface is locked */
1399 if (This
->Flags
& SFLAG_LOCKED
)
1400 return WINED3DERR_INVALIDCALL
;
1402 /* According to Direct3D9 docs, only these formats are supported */
1403 if (((IWineD3DImpl
*)This
->resource
.wineD3DDevice
->wineD3D
)->dxVersion
> 7) {
1404 if (This
->resource
.format
!= WINED3DFMT_R5G6B5
&&
1405 This
->resource
.format
!= WINED3DFMT_X1R5G5B5
&&
1406 This
->resource
.format
!= WINED3DFMT_R8G8B8
&&
1407 This
->resource
.format
!= WINED3DFMT_X8R8G8B8
) return WINED3DERR_INVALIDCALL
;
1410 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
1412 /* Create a DIB section if there isn't a hdc yet */
1414 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
1415 if(This
->Flags
& SFLAG_CLIENT
) {
1416 IWineD3DSurface_PreLoad(iface
);
1419 /* Use the dib section from now on if we are not using a PBO */
1420 if(!(This
->Flags
& SFLAG_PBO
))
1421 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
1424 /* Lock the surface */
1425 hr
= IWineD3DSurface_LockRect(iface
,
1430 if(This
->Flags
& SFLAG_PBO
) {
1431 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1432 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, This
->dib
.bitmap_size
);
1436 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
1437 /* keep the dib section */
1441 if(This
->resource
.format
== WINED3DFMT_P8
||
1442 This
->resource
.format
== WINED3DFMT_A8P8
) {
1443 /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
1444 D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
1446 PALETTEENTRY
*pal
= NULL
;
1449 pal
= This
->palette
->palents
;
1451 IWineD3DSurfaceImpl
*dds_primary
;
1452 IWineD3DSwapChainImpl
*swapchain
;
1453 swapchain
= (IWineD3DSwapChainImpl
*)This
->resource
.wineD3DDevice
->swapchains
[0];
1454 dds_primary
= (IWineD3DSurfaceImpl
*)swapchain
->frontBuffer
;
1455 if (dds_primary
&& dds_primary
->palette
)
1456 pal
= dds_primary
->palette
->palents
;
1460 for (n
=0; n
<256; n
++) {
1461 col
[n
].rgbRed
= pal
[n
].peRed
;
1462 col
[n
].rgbGreen
= pal
[n
].peGreen
;
1463 col
[n
].rgbBlue
= pal
[n
].peBlue
;
1464 col
[n
].rgbReserved
= 0;
1466 SetDIBColorTable(This
->hDC
, 0, 256, col
);
1471 TRACE("returning %p\n",*pHDC
);
1472 This
->Flags
|= SFLAG_DCINUSE
;
1477 HRESULT WINAPI
IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
1478 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1480 TRACE("(%p)->(%p)\n",This
,hDC
);
1482 if (!(This
->Flags
& SFLAG_DCINUSE
))
1483 return WINED3DERR_INVALIDCALL
;
1485 if (This
->hDC
!=hDC
) {
1486 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
1487 return WINED3DERR_INVALIDCALL
;
1490 if((This
->Flags
& SFLAG_PBO
) && This
->resource
.allocatedMemory
) {
1491 /* Copy the contents of the DIB over to the PBO */
1492 memcpy(This
->resource
.allocatedMemory
, This
->dib
.bitmap_data
, This
->dib
.bitmap_size
);
1495 /* we locked first, so unlock now */
1496 IWineD3DSurface_UnlockRect(iface
);
1498 This
->Flags
&= ~SFLAG_DCINUSE
;
1503 /* ******************************************************
1504 IWineD3DSurface Internal (No mapping to directx api) parts follow
1505 ****************************************************** */
1507 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
) {
1508 BOOL colorkey_active
= need_alpha_ck
&& (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
);
1509 const GlPixelFormatDesc
*glDesc
;
1510 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1511 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
1513 /* Default values: From the surface */
1514 *format
= glDesc
->glFormat
;
1515 *type
= glDesc
->glType
;
1516 *convert
= NO_CONVERSION
;
1517 *target_bpp
= This
->bytesPerPixel
;
1520 *internal
= glDesc
->glGammaInternal
;
1521 } else if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
1522 *internal
= glDesc
->rtInternal
;
1524 *internal
= glDesc
->glInternal
;
1527 /* Ok, now look if we have to do any conversion */
1528 switch(This
->resource
.format
) {
1534 /* Use conversion when the paletted texture extension OR fragment shaders are available. When either
1535 * of the two is available make sure texturing is requested as neither of the two works in
1536 * conjunction with calls like glDraw-/glReadPixels. Further also use conversion in case of color keying.
1537 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
1538 * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
1539 * conflicts with this.
1541 if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE
) ||
1542 (GL_SUPPORT(ARB_FRAGMENT_PROGRAM
) &&
1543 device
->render_targets
&&
1544 This
== (IWineD3DSurfaceImpl
*)device
->render_targets
[0])) ||
1545 colorkey_active
|| !use_texturing
) {
1547 *internal
= GL_RGBA
;
1548 *type
= GL_UNSIGNED_BYTE
;
1550 if(colorkey_active
) {
1551 *convert
= CONVERT_PALETTED_CK
;
1553 *convert
= CONVERT_PALETTED
;
1556 else if(!GL_SUPPORT(EXT_PALETTED_TEXTURE
) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
1558 *internal
= GL_RGBA
;
1559 *type
= GL_UNSIGNED_BYTE
;
1565 case WINED3DFMT_R3G3B2
:
1566 /* **********************
1567 GL_UNSIGNED_BYTE_3_3_2
1568 ********************** */
1569 if (colorkey_active
) {
1570 /* This texture format will never be used.. So do not care about color keying
1571 up until the point in time it will be needed :-) */
1572 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1576 case WINED3DFMT_R5G6B5
:
1577 if (colorkey_active
) {
1578 *convert
= CONVERT_CK_565
;
1580 *internal
= GL_RGBA
;
1581 *type
= GL_UNSIGNED_SHORT_5_5_5_1
;
1585 case WINED3DFMT_X1R5G5B5
:
1586 if (colorkey_active
) {
1587 *convert
= CONVERT_CK_5551
;
1589 *internal
= GL_RGBA
;
1590 *type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
1594 case WINED3DFMT_R8G8B8
:
1595 if (colorkey_active
) {
1596 *convert
= CONVERT_CK_RGB24
;
1598 *internal
= GL_RGBA
;
1599 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1604 case WINED3DFMT_X8R8G8B8
:
1605 if (colorkey_active
) {
1606 *convert
= CONVERT_RGB32_888
;
1608 *internal
= GL_RGBA
;
1609 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1613 case WINED3DFMT_V8U8
:
1614 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1615 else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1616 *format
= GL_DUDV_ATI
;
1617 *internal
= GL_DU8DV8_ATI
;
1619 /* No conversion - Just change the gl type */
1622 *convert
= CONVERT_V8U8
;
1624 *internal
= GL_RGB8
;
1625 *type
= GL_UNSIGNED_BYTE
;
1629 case WINED3DFMT_L6V5U5
:
1630 *convert
= CONVERT_L6V5U5
;
1631 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1633 /* Use format and types from table */
1635 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1638 *internal
= GL_RGB5
;
1639 *type
= GL_UNSIGNED_SHORT_5_6_5
;
1643 case WINED3DFMT_X8L8V8U8
:
1644 *convert
= CONVERT_X8L8V8U8
;
1646 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1647 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1648 * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1649 * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1650 * the needed type and format parameter, so the internal format contains a
1651 * 4th component, which is returned as alpha
1654 /* Not supported by GL_ATI_envmap_bumpmap */
1656 *internal
= GL_RGB8
;
1657 *type
= GL_UNSIGNED_INT_8_8_8_8_REV
;
1661 case WINED3DFMT_Q8W8V8U8
:
1662 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1663 *convert
= CONVERT_Q8W8V8U8
;
1665 *internal
= GL_RGBA8
;
1666 *type
= GL_UNSIGNED_BYTE
;
1668 /* Not supported by GL_ATI_envmap_bumpmap */
1671 case WINED3DFMT_V16U16
:
1672 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1673 *convert
= CONVERT_V16U16
;
1675 *internal
= GL_RGB16_EXT
;
1676 *type
= GL_UNSIGNED_SHORT
;
1678 /* What should I do here about GL_ATI_envmap_bumpmap?
1679 * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1683 case WINED3DFMT_A4L4
:
1684 /* A4L4 exists as an internal gl format, but for some reason there is not
1685 * format+type combination to load it. Thus convert it to A8L8, then load it
1686 * with A4L4 internal, but A8L8 format+type
1688 *convert
= CONVERT_A4L4
;
1689 *format
= GL_LUMINANCE_ALPHA
;
1690 *internal
= GL_LUMINANCE4_ALPHA4
;
1691 *type
= GL_UNSIGNED_BYTE
;
1695 case WINED3DFMT_R32F
:
1696 /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1697 * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1698 * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1701 * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1703 *convert
= CONVERT_R32F
;
1705 *internal
= GL_RGB32F_ARB
;
1710 case WINED3DFMT_R16F
:
1711 /* Similar to R32F */
1712 *convert
= CONVERT_R16F
;
1714 *internal
= GL_RGB16F_ARB
;
1715 *type
= GL_HALF_FLOAT_ARB
;
1719 case WINED3DFMT_G16R16
:
1720 *convert
= CONVERT_G16R16
;
1722 *internal
= GL_RGB16_EXT
;
1723 *type
= GL_UNSIGNED_SHORT
;
1734 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*This
) {
1735 BYTE
*source
, *dest
;
1736 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src
, dst
, pitch
, height
, outpitch
, convert
,This
);
1741 memcpy(dst
, src
, pitch
* height
);
1744 case CONVERT_PALETTED
:
1745 case CONVERT_PALETTED_CK
:
1747 IWineD3DPaletteImpl
* pal
= This
->palette
;
1752 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1755 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
1757 for (y
= 0; y
< height
; y
++)
1759 source
= src
+ pitch
* y
;
1760 dest
= dst
+ outpitch
* y
;
1761 /* This is an 1 bpp format, using the width here is fine */
1762 for (x
= 0; x
< width
; x
++) {
1763 BYTE color
= *source
++;
1764 *dest
++ = table
[color
][0];
1765 *dest
++ = table
[color
][1];
1766 *dest
++ = table
[color
][2];
1767 *dest
++ = table
[color
][3];
1773 case CONVERT_CK_565
:
1775 /* Converting the 565 format in 5551 packed to emulate color-keying.
1777 Note : in all these conversion, it would be best to average the averaging
1778 pixels to get the color of the pixel that will be color-keyed to
1779 prevent 'color bleeding'. This will be done later on if ever it is
1782 Note2: Nvidia documents say that their driver does not support alpha + color keying
1783 on the same surface and disables color keying in such a case
1789 TRACE("Color keyed 565\n");
1791 for (y
= 0; y
< height
; y
++) {
1792 Source
= (WORD
*) (src
+ y
* pitch
);
1793 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1794 for (x
= 0; x
< width
; x
++ ) {
1795 WORD color
= *Source
++;
1796 *Dest
= ((color
& 0xFFC0) | ((color
& 0x1F) << 1));
1797 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1798 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1807 case CONVERT_CK_5551
:
1809 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1813 TRACE("Color keyed 5551\n");
1814 for (y
= 0; y
< height
; y
++) {
1815 Source
= (WORD
*) (src
+ y
* pitch
);
1816 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1817 for (x
= 0; x
< width
; x
++ ) {
1818 WORD color
= *Source
++;
1820 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1821 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1825 *Dest
&= ~(1 << 15);
1833 case CONVERT_RGB32_888
:
1835 /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
1837 for (y
= 0; y
< height
; y
++)
1839 source
= src
+ pitch
* y
;
1840 dest
= dst
+ outpitch
* y
;
1841 for (x
= 0; x
< width
; x
++) {
1842 DWORD color
= 0xffffff & *(DWORD
*)source
;
1843 DWORD dstcolor
= color
<< 8;
1844 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1845 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1848 *(DWORD
*)dest
= dstcolor
;
1860 unsigned char *Dest
;
1861 for(y
= 0; y
< height
; y
++) {
1862 Source
= (short *) (src
+ y
* pitch
);
1863 Dest
= dst
+ y
* outpitch
;
1864 for (x
= 0; x
< width
; x
++ ) {
1865 long color
= (*Source
++);
1866 /* B */ Dest
[0] = 0xff;
1867 /* G */ Dest
[1] = (color
>> 8) + 128; /* V */
1868 /* R */ Dest
[2] = (color
) + 128; /* U */
1875 case CONVERT_V16U16
:
1879 unsigned short *Dest
;
1880 for(y
= 0; y
< height
; y
++) {
1881 Source
= (DWORD
*) (src
+ y
* pitch
);
1882 Dest
= (unsigned short *) (dst
+ y
* outpitch
);
1883 for (x
= 0; x
< width
; x
++ ) {
1884 DWORD color
= (*Source
++);
1885 /* B */ Dest
[0] = 0xffff;
1886 /* G */ Dest
[1] = (color
>> 16) + 32768; /* V */
1887 /* R */ Dest
[2] = (color
) + 32768; /* U */
1894 case CONVERT_Q8W8V8U8
:
1898 unsigned char *Dest
;
1899 for(y
= 0; y
< height
; y
++) {
1900 Source
= (DWORD
*) (src
+ y
* pitch
);
1901 Dest
= dst
+ y
* outpitch
;
1902 for (x
= 0; x
< width
; x
++ ) {
1903 long color
= (*Source
++);
1904 /* B */ Dest
[0] = ((color
>> 16) & 0xff) + 128; /* W */
1905 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1906 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1907 /* A */ Dest
[3] = ((color
>> 24) & 0xff) + 128; /* Q */
1914 case CONVERT_L6V5U5
:
1918 unsigned char *Dest
;
1920 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1921 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1922 * fixed function and shaders without further conversion once the surface is
1925 for(y
= 0; y
< height
; y
++) {
1926 Source
= (WORD
*) (src
+ y
* pitch
);
1927 Dest
= dst
+ y
* outpitch
;
1928 for (x
= 0; x
< width
; x
++ ) {
1929 short color
= (*Source
++);
1930 unsigned char l
= ((color
>> 10) & 0xfc);
1931 char v
= ((color
>> 5) & 0x3e);
1932 char u
= ((color
) & 0x1f);
1934 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1935 * and doubles the positive range. Thus shift left only once, gl does the 2nd
1936 * shift. GL reads a signed value and converts it into an unsigned value.
1938 /* M */ Dest
[2] = l
<< 1;
1940 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1941 * from 5 bit values to 8 bit values.
1943 /* V */ Dest
[1] = v
<< 3;
1944 /* U */ Dest
[0] = u
<< 3;
1949 for(y
= 0; y
< height
; y
++) {
1950 unsigned short *Dest_s
= (unsigned short *) (dst
+ y
* outpitch
);
1951 Source
= (WORD
*) (src
+ y
* pitch
);
1952 for (x
= 0; x
< width
; x
++ ) {
1953 short color
= (*Source
++);
1954 unsigned char l
= ((color
>> 10) & 0xfc);
1955 short v
= ((color
>> 5) & 0x3e);
1956 short u
= ((color
) & 0x1f);
1957 short v_conv
= v
+ 16;
1958 short u_conv
= u
+ 16;
1960 *Dest_s
= ((v_conv
<< 11) & 0xf800) | ((l
<< 5) & 0x7e0) | (u_conv
& 0x1f);
1968 case CONVERT_X8L8V8U8
:
1972 unsigned char *Dest
;
1974 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1975 /* This implementation works with the fixed function pipeline and shaders
1976 * without further modification after converting the surface.
1978 for(y
= 0; y
< height
; y
++) {
1979 Source
= (DWORD
*) (src
+ y
* pitch
);
1980 Dest
= dst
+ y
* outpitch
;
1981 for (x
= 0; x
< width
; x
++ ) {
1982 long color
= (*Source
++);
1983 /* L */ Dest
[2] = ((color
>> 16) & 0xff); /* L */
1984 /* V */ Dest
[1] = ((color
>> 8 ) & 0xff); /* V */
1985 /* U */ Dest
[0] = (color
& 0xff); /* U */
1986 /* I */ Dest
[3] = 255; /* X */
1991 /* Doesn't work correctly with the fixed function pipeline, but can work in
1992 * shaders if the shader is adjusted. (There's no use for this format in gl's
1993 * standard fixed function pipeline anyway).
1995 for(y
= 0; y
< height
; y
++) {
1996 Source
= (DWORD
*) (src
+ y
* pitch
);
1997 Dest
= dst
+ y
* outpitch
;
1998 for (x
= 0; x
< width
; x
++ ) {
1999 long color
= (*Source
++);
2000 /* B */ Dest
[0] = ((color
>> 16) & 0xff); /* L */
2001 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
2002 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
2013 unsigned char *Source
;
2014 unsigned char *Dest
;
2015 for(y
= 0; y
< height
; y
++) {
2016 Source
= src
+ y
* pitch
;
2017 Dest
= dst
+ y
* outpitch
;
2018 for (x
= 0; x
< width
; x
++ ) {
2019 unsigned char color
= (*Source
++);
2020 /* A */ Dest
[1] = (color
& 0xf0) << 0;
2021 /* L */ Dest
[0] = (color
& 0x0f) << 4;
2033 for(y
= 0; y
< height
; y
++) {
2034 Source
= (float *) (src
+ y
* pitch
);
2035 Dest
= (float *) (dst
+ y
* outpitch
);
2036 for (x
= 0; x
< width
; x
++ ) {
2037 float color
= (*Source
++);
2053 for(y
= 0; y
< height
; y
++) {
2054 Source
= (WORD
*) (src
+ y
* pitch
);
2055 Dest
= (WORD
*) (dst
+ y
* outpitch
);
2056 for (x
= 0; x
< width
; x
++ ) {
2057 WORD color
= (*Source
++);
2067 case CONVERT_G16R16
:
2073 for(y
= 0; y
< height
; y
++) {
2074 Source
= (WORD
*) (src
+ y
* pitch
);
2075 Dest
= (WORD
*) (dst
+ y
* outpitch
);
2076 for (x
= 0; x
< width
; x
++ ) {
2077 WORD green
= (*Source
++);
2078 WORD red
= (*Source
++);
2089 ERR("Unsupported conversation type %d\n", convert
);
2094 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
) {
2095 IWineD3DPaletteImpl
* pal
= This
->palette
;
2096 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2097 BOOL index_in_alpha
= FALSE
;
2098 int dxVersion
= ( (IWineD3DImpl
*) device
->wineD3D
)->dxVersion
;
2101 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
2102 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
2103 * is slow. Further RGB->P8 conversion is not possible because palettes can have
2104 * duplicate entries. Store the color key in the unused alpha component to speed the
2105 * download up and to make conversion unneeded. */
2106 index_in_alpha
= primary_render_target_is_p8(device
);
2109 /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
2110 if(dxVersion
<= 7) {
2111 ERR("This code should never get entered for DirectDraw!, expect problems\n");
2112 if(index_in_alpha
) {
2113 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
2114 there's no palette at this time. */
2115 for (i
= 0; i
< 256; i
++) table
[i
][3] = i
;
2118 /* Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
2119 alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
2120 capability flag is present (wine does advertise this capability) */
2121 for (i
= 0; i
< 256; i
++) {
2122 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
2123 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
2124 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
2125 table
[i
][3] = device
->palettes
[device
->currentPalette
][i
].peFlags
;
2129 TRACE("Using surface palette %p\n", pal
);
2130 /* Get the surface's palette */
2131 for (i
= 0; i
< 256; i
++) {
2132 table
[i
][0] = pal
->palents
[i
].peRed
;
2133 table
[i
][1] = pal
->palents
[i
].peGreen
;
2134 table
[i
][2] = pal
->palents
[i
].peBlue
;
2136 /* When index_in_alpha is the palette index is stored in the alpha component. In case of a readback
2137 we can then read GL_ALPHA. Color keying is handled in BltOverride using a GL_ALPHA_TEST using GL_NOT_EQUAL.
2138 In case of index_in_alpha the color key itself is passed to glAlphaFunc in other cases the alpha component
2139 of pixels that should be masked away is set to 0. */
2140 if(index_in_alpha
) {
2142 } else if(colorkey
&& (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) && (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
2144 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
2145 table
[i
][3] = pal
->palents
[i
].peFlags
;
2153 const char *fragment_palette_conversion
=
2156 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n" /* { 255/256, 0.5/255*255/256, 0, 0 } */
2157 "TEX index, fragment.texcoord[0], texture[0], 2D;\n" /* The alpha-component contains the palette index */
2158 "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 */
2159 "TEX result.color, index.a, texture[1], 1D;\n" /* use the alpha-component as a index in the palette to get the final color */
2162 /* This function is used in case of 8bit paletted textures to upload the palette.
2163 It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
2164 extensions like ATI_fragment_shaders is possible.
2166 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
) {
2167 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2169 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2171 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
2173 /* Try to use the paletted texture extension */
2174 if(GL_SUPPORT(EXT_PALETTED_TEXTURE
))
2176 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2177 GL_EXTCALL(glColorTableEXT(This
->glDescription
.target
,GL_RGBA
,256,GL_RGBA
,GL_UNSIGNED_BYTE
, table
));
2181 /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2182 * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2183 TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2185 /* Create the fragment program if we don't have it */
2186 if(!device
->paletteConversionShader
)
2188 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2189 GL_EXTCALL(glGenProgramsARB(1, &device
->paletteConversionShader
));
2190 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2191 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
, strlen(fragment_palette_conversion
), (const GLbyte
*)fragment_palette_conversion
));
2192 glDisable(GL_FRAGMENT_PROGRAM_ARB
);
2195 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2196 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2198 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1
));
2199 glEnable(GL_TEXTURE_1D
);
2200 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
2202 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2203 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
); /* Make sure we have discrete color levels. */
2204 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
2205 glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA
, 256, 0, GL_RGBA
, GL_UNSIGNED_BYTE
, table
); /* Upload the palette */
2207 /* Switch back to unit 0 in which the 2D texture will be stored. */
2208 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0
));
2210 /* Rebind the texture because it isn't bound anymore */
2211 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2215 BOOL
palette9_changed(IWineD3DSurfaceImpl
*This
) {
2216 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2218 if(This
->palette
|| (This
->resource
.format
!= WINED3DFMT_P8
&& This
->resource
.format
!= WINED3DFMT_A8P8
)) {
2219 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2220 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2225 if(This
->palette9
) {
2226 if(memcmp(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256) == 0) {
2230 This
->palette9
= HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY
) * 256);
2232 memcpy(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256);
2236 static inline void clear_unused_channels(IWineD3DSurfaceImpl
*This
) {
2237 GLboolean oldwrite
[4];
2239 /* Some formats have only some color channels, and the others are 1.0.
2240 * since our rendering renders to all channels, and those pixel formats
2241 * are emulated by using a full texture with the other channels set to 1.0
2242 * manually, clear the unused channels.
2244 * This could be done with hacking colorwriteenable to mask the colors,
2245 * but before drawing the buffer would have to be cleared too, so there's
2248 switch(This
->resource
.format
) {
2249 case WINED3DFMT_R16F
:
2250 case WINED3DFMT_R32F
:
2251 TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2252 /* Do not activate a context, the correct drawable is active already
2253 * though just the read buffer is set, make sure to have the correct draw
2256 glDrawBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
2257 glDisable(GL_SCISSOR_TEST
);
2258 glGetBooleanv(GL_COLOR_WRITEMASK
, oldwrite
);
2259 glColorMask(GL_FALSE
, GL_TRUE
, GL_TRUE
, GL_TRUE
);
2260 glClearColor(0.0, 1.0, 1.0, 1.0);
2261 glClear(GL_COLOR_BUFFER_BIT
);
2262 glColorMask(oldwrite
[0], oldwrite
[1], oldwrite
[2], oldwrite
[3]);
2263 if(!This
->resource
.wineD3DDevice
->render_offscreen
) glDrawBuffer(GL_BACK
);
2264 checkGLcall("Unused channel clear\n");
2271 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
) {
2272 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2274 if (!(This
->Flags
& SFLAG_INTEXTURE
)) {
2275 TRACE("Reloading because surface is dirty\n");
2276 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2277 ((This
->Flags
& SFLAG_GLCKEY
) && (!(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
))) ||
2278 /* Reload: vice versa OR */
2279 ((!(This
->Flags
& SFLAG_GLCKEY
)) && (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
)) ||
2280 /* Also reload: Color key is active AND the color key has changed */
2281 ((This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) && (
2282 (This
->glCKey
.dwColorSpaceLowValue
!= This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
2283 (This
->glCKey
.dwColorSpaceHighValue
!= This
->SrcBltCKey
.dwColorSpaceHighValue
)))) {
2284 TRACE("Reloading because of color keying\n");
2285 /* To perform the color key conversion we need a sysmem copy of
2286 * the surface. Make sure we have it
2289 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2290 /* Make sure the texture is reloaded because of the color key change, this kills performance though :( */
2291 /* TODO: This is not necessarily needed with hw palettized texture support */
2292 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2294 TRACE("surface is already in texture\n");
2298 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2299 * These resources are not bound by device size or format restrictions. Because of this,
2300 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2301 * However, these resources can always be created, locked, and copied.
2303 if (This
->resource
.pool
== WINED3DPOOL_SCRATCH
)
2305 FIXME("(%p) Operation not supported for scratch textures\n",This
);
2306 return WINED3DERR_INVALIDCALL
;
2309 This
->srgb
= srgb_mode
;
2310 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* no partial locking for textures yet */);
2314 static unsigned int gen
= 0;
2317 if ((gen
% 10) == 0) {
2318 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
2319 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
2322 * debugging crash code
2331 if (!(This
->Flags
& SFLAG_DONOTFREE
)) {
2332 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
2333 This
->resource
.allocatedMemory
= NULL
;
2334 This
->resource
.heapMemory
= NULL
;
2335 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, FALSE
);
2341 static void WINAPI
IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface
*iface
) {
2342 /* TODO: check for locks */
2343 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2344 IWineD3DBaseTexture
*baseTexture
= NULL
;
2345 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2347 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
2348 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2349 TRACE("Passing to container\n");
2350 IWineD3DBaseTexture_BindTexture(baseTexture
);
2351 IWineD3DBaseTexture_Release(baseTexture
);
2353 TRACE("(%p) : Binding surface\n", This
);
2355 if(!device
->isInDraw
) {
2356 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
2361 glEnable(This
->glDescription
.target
);
2363 if (!This
->glDescription
.level
) {
2364 if (!This
->glDescription
.textureName
) {
2365 glGenTextures(1, &This
->glDescription
.textureName
);
2366 checkGLcall("glGenTextures");
2367 TRACE("Surface %p given name %d\n", This
, This
->glDescription
.textureName
);
2369 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2370 checkGLcall("glBindTexture");
2371 glTexParameteri(This
->glDescription
.target
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
2372 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)");
2373 glTexParameteri(This
->glDescription
.target
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
2374 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)");
2375 glTexParameteri(This
->glDescription
.target
, GL_TEXTURE_WRAP_R
, GL_CLAMP_TO_EDGE
);
2376 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)");
2377 glTexParameteri(This
->glDescription
.target
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2378 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MIN_FILTER, GL_NEAREST)");
2379 glTexParameteri(This
->glDescription
.target
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2380 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MAG_FILTER, GL_NEAREST)");
2382 /* This is where we should be reducing the amount of GLMemoryUsed */
2383 } else if (This
->glDescription
.textureName
) {
2384 /* Mipmap surfaces should have a base texture container */
2385 ERR("Mipmap surface has a glTexture bound to it!\n");
2388 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2389 checkGLcall("glBindTexture");
2398 HRESULT WINAPI
IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
, const char* filename
) {
2401 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2402 char *allocatedMemory
;
2404 IWineD3DSwapChain
*swapChain
= NULL
;
2406 GLuint tmpTexture
= 0;
2409 Textures may not be stored in ->allocatedgMemory and a GlTexture
2410 so we should lock the surface before saving a snapshot, or at least check that
2412 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2413 by calling GetTexImage and in compressed form by calling
2414 GetCompressedTexImageARB. Queried compressed images can be saved and
2415 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2416 texture images do not need to be processed by the GL and should
2417 significantly improve texture loading performance relative to uncompressed
2420 /* Setup the width and height to be the internal texture width and height. */
2421 width
= This
->pow2Width
;
2422 height
= This
->pow2Height
;
2423 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2424 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapChain
);
2426 if (This
->Flags
& SFLAG_INDRAWABLE
&& !(This
->Flags
& SFLAG_INTEXTURE
)) {
2427 /* if were not a real texture then read the back buffer into a real texture */
2428 /* we don't want to interfere with the back buffer so read the data into a temporary
2429 * texture and then save the data out of the temporary texture
2433 TRACE("(%p) Reading render target into texture\n", This
);
2434 glEnable(GL_TEXTURE_2D
);
2436 glGenTextures(1, &tmpTexture
);
2437 glBindTexture(GL_TEXTURE_2D
, tmpTexture
);
2439 glTexImage2D(GL_TEXTURE_2D
,
2446 GL_UNSIGNED_INT_8_8_8_8_REV
,
2449 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
2450 vcheckGLcall("glGetIntegerv");
2451 glReadBuffer(swapChain
? GL_BACK
: This
->resource
.wineD3DDevice
->offscreenBuffer
);
2452 vcheckGLcall("glReadBuffer");
2453 glCopyTexImage2D(GL_TEXTURE_2D
,
2462 checkGLcall("glCopyTexImage2D");
2463 glReadBuffer(prevRead
);
2466 } else { /* bind the real texture, and make sure it up to date */
2467 IWineD3DSurface_PreLoad(iface
);
2468 surface_bind_and_dirtify(This
);
2470 allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, width
* height
* 4);
2472 FIXME("Saving texture level %d width %d height %d\n", This
->glDescription
.level
, width
, height
);
2473 glGetTexImage(GL_TEXTURE_2D
,
2474 This
->glDescription
.level
,
2476 GL_UNSIGNED_INT_8_8_8_8_REV
,
2478 checkGLcall("glTexImage2D");
2480 glBindTexture(GL_TEXTURE_2D
, 0);
2481 glDeleteTextures(1, &tmpTexture
);
2485 f
= fopen(filename
, "w+");
2487 ERR("opening of %s failed with: %s\n", filename
, strerror(errno
));
2488 return WINED3DERR_INVALIDCALL
;
2490 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2491 TRACE("(%p) opened %s with format %s\n", This
, filename
, debug_d3dformat(This
->resource
.format
));
2506 fwrite(&width
,2,1,f
);
2508 fwrite(&height
,2,1,f
);
2513 /* 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 */
2515 textureRow
= allocatedMemory
+ (width
* (height
- 1) *4);
2517 textureRow
= allocatedMemory
;
2518 for (y
= 0 ; y
< height
; y
++) {
2519 for (i
= 0; i
< width
; i
++) {
2520 color
= *((DWORD
*)textureRow
);
2521 fputc((color
>> 16) & 0xFF, f
); /* B */
2522 fputc((color
>> 8) & 0xFF, f
); /* G */
2523 fputc((color
>> 0) & 0xFF, f
); /* R */
2524 fputc((color
>> 24) & 0xFF, f
); /* A */
2527 /* take two rows of the pointer to the texture memory */
2529 (textureRow
-= width
<< 3);
2532 TRACE("Closing file\n");
2536 IWineD3DSwapChain_Release(swapChain
);
2538 HeapFree(GetProcessHeap(), 0, allocatedMemory
);
2543 * Slightly inefficient way to handle multiple dirty rects but it works :)
2545 HRESULT WINAPI
IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
2546 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2547 IWineD3DBaseTexture
*baseTexture
= NULL
;
2549 if (!(This
->Flags
& SFLAG_INSYSMEM
) && (This
->Flags
& SFLAG_INTEXTURE
))
2550 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
2552 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2553 if (NULL
!= pDirtyRect
) {
2554 This
->dirtyRect
.left
= min(This
->dirtyRect
.left
, pDirtyRect
->left
);
2555 This
->dirtyRect
.top
= min(This
->dirtyRect
.top
, pDirtyRect
->top
);
2556 This
->dirtyRect
.right
= max(This
->dirtyRect
.right
, pDirtyRect
->right
);
2557 This
->dirtyRect
.bottom
= max(This
->dirtyRect
.bottom
, pDirtyRect
->bottom
);
2559 This
->dirtyRect
.left
= 0;
2560 This
->dirtyRect
.top
= 0;
2561 This
->dirtyRect
.right
= This
->currentDesc
.Width
;
2562 This
->dirtyRect
.bottom
= This
->currentDesc
.Height
;
2564 TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This
, This
->dirtyRect
.left
,
2565 This
->dirtyRect
.top
, This
->dirtyRect
.right
, This
->dirtyRect
.bottom
);
2566 /* if the container is a basetexture then mark it dirty. */
2567 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2568 TRACE("Passing to container\n");
2569 IWineD3DBaseTexture_SetDirty(baseTexture
, TRUE
);
2570 IWineD3DBaseTexture_Release(baseTexture
);
2575 HRESULT WINAPI
IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
2576 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2578 const GlPixelFormatDesc
*glDesc
;
2579 getFormatDescEntry(format
, &GLINFO_LOCATION
, &glDesc
);
2581 TRACE("(%p) : Calling base function first\n", This
);
2582 hr
= IWineD3DBaseSurfaceImpl_SetFormat(iface
, format
);
2584 /* Setup some glformat defaults */
2585 This
->glDescription
.glFormat
= glDesc
->glFormat
;
2586 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
2587 This
->glDescription
.glType
= glDesc
->glType
;
2589 This
->Flags
&= ~SFLAG_ALLOCATED
;
2590 TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This
,
2591 This
->glDescription
.glFormat
, This
->glDescription
.glFormatInternal
, This
->glDescription
.glType
);
2596 HRESULT WINAPI
IWineD3DSurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
2597 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
2599 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
2600 WARN("Surface is locked or the HDC is in use\n");
2601 return WINED3DERR_INVALIDCALL
;
2604 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
2605 void *release
= NULL
;
2607 /* Do I have to copy the old surface content? */
2608 if(This
->Flags
& SFLAG_DIBSECTION
) {
2609 /* Release the DC. No need to hold the critical section for the update
2610 * Thread because this thread runs only on front buffers, but this method
2611 * fails for render targets in the check above.
2613 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
2614 DeleteDC(This
->hDC
);
2615 /* Release the DIB section */
2616 DeleteObject(This
->dib
.DIBsection
);
2617 This
->dib
.bitmap_data
= NULL
;
2618 This
->resource
.allocatedMemory
= NULL
;
2620 This
->Flags
&= ~SFLAG_DIBSECTION
;
2621 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
2622 release
= This
->resource
.heapMemory
;
2623 This
->resource
.heapMemory
= NULL
;
2625 This
->resource
.allocatedMemory
= Mem
;
2626 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
2628 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2629 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2631 /* For client textures opengl has to be notified */
2632 if(This
->Flags
& SFLAG_CLIENT
) {
2633 This
->Flags
&= ~SFLAG_ALLOCATED
;
2634 IWineD3DSurface_PreLoad(iface
);
2635 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2638 /* Now free the old memory if any */
2639 HeapFree(GetProcessHeap(), 0, release
);
2640 } else if(This
->Flags
& SFLAG_USERPTR
) {
2641 /* LockRect and GetDC will re-create the dib section and allocated memory */
2642 This
->resource
.allocatedMemory
= NULL
;
2643 /* HeapMemory should be NULL already */
2644 if(This
->resource
.heapMemory
!= NULL
) ERR("User pointer surface has heap memory allocated\n");
2645 This
->Flags
&= ~SFLAG_USERPTR
;
2647 if(This
->Flags
& SFLAG_CLIENT
) {
2648 This
->Flags
&= ~SFLAG_ALLOCATED
;
2649 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2650 IWineD3DSurface_PreLoad(iface
);
2656 void flip_surface(IWineD3DSurfaceImpl
*front
, IWineD3DSurfaceImpl
*back
) {
2658 /* Flip the surface contents */
2663 front
->hDC
= back
->hDC
;
2667 /* Flip the DIBsection */
2670 BOOL hasDib
= front
->Flags
& SFLAG_DIBSECTION
;
2671 tmp
= front
->dib
.DIBsection
;
2672 front
->dib
.DIBsection
= back
->dib
.DIBsection
;
2673 back
->dib
.DIBsection
= tmp
;
2675 if(back
->Flags
& SFLAG_DIBSECTION
) front
->Flags
|= SFLAG_DIBSECTION
;
2676 else front
->Flags
&= ~SFLAG_DIBSECTION
;
2677 if(hasDib
) back
->Flags
|= SFLAG_DIBSECTION
;
2678 else back
->Flags
&= ~SFLAG_DIBSECTION
;
2681 /* Flip the surface data */
2685 tmp
= front
->dib
.bitmap_data
;
2686 front
->dib
.bitmap_data
= back
->dib
.bitmap_data
;
2687 back
->dib
.bitmap_data
= tmp
;
2689 tmp
= front
->resource
.allocatedMemory
;
2690 front
->resource
.allocatedMemory
= back
->resource
.allocatedMemory
;
2691 back
->resource
.allocatedMemory
= tmp
;
2693 tmp
= front
->resource
.heapMemory
;
2694 front
->resource
.heapMemory
= back
->resource
.heapMemory
;
2695 back
->resource
.heapMemory
= tmp
;
2700 GLuint tmp_pbo
= front
->pbo
;
2701 front
->pbo
= back
->pbo
;
2702 back
->pbo
= tmp_pbo
;
2705 /* client_memory should not be different, but just in case */
2708 tmp
= front
->dib
.client_memory
;
2709 front
->dib
.client_memory
= back
->dib
.client_memory
;
2710 back
->dib
.client_memory
= tmp
;
2713 /* Flip the opengl texture */
2715 glDescriptor tmp_desc
= back
->glDescription
;
2716 back
->glDescription
= front
->glDescription
;
2717 front
->glDescription
= tmp_desc
;
2721 DWORD tmp_flags
= back
->Flags
;
2722 back
->Flags
= front
->Flags
;
2723 front
->Flags
= tmp_flags
;
2727 static HRESULT WINAPI
IWineD3DSurfaceImpl_Flip(IWineD3DSurface
*iface
, IWineD3DSurface
*override
, DWORD Flags
) {
2728 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2729 IWineD3DSwapChainImpl
*swapchain
= NULL
;
2731 TRACE("(%p)->(%p,%x)\n", This
, override
, Flags
);
2733 /* Flipping is only supported on RenderTargets and overlays*/
2734 if( !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_OVERLAY
)) ) {
2735 WARN("Tried to flip a non-render target, non-overlay surface\n");
2736 return WINEDDERR_NOTFLIPPABLE
;
2739 if(This
->resource
.usage
& WINED3DUSAGE_OVERLAY
) {
2740 flip_surface(This
, (IWineD3DSurfaceImpl
*) override
);
2742 /* Update the overlay if it is visible */
2743 if(This
->overlay_dest
) {
2744 return IWineD3DSurface_DrawOverlay((IWineD3DSurface
*) This
);
2751 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2752 * FIXME("(%p) Target override is not supported by now\n", This);
2753 * Additionally, it isn't really possible to support triple-buffering
2754 * properly on opengl at all
2758 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
2760 ERR("Flipped surface is not on a swapchain\n");
2761 return WINEDDERR_NOTFLIPPABLE
;
2764 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2765 * and only d3d8 and d3d9 apps specify the presentation interval
2767 if((Flags
& (WINEDDFLIP_NOVSYNC
| WINEDDFLIP_INTERVAL2
| WINEDDFLIP_INTERVAL3
| WINEDDFLIP_INTERVAL4
)) == 0) {
2768 /* Most common case first to avoid wasting time on all the other cases */
2769 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_ONE
;
2770 } else if(Flags
& WINEDDFLIP_NOVSYNC
) {
2771 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2772 } else if(Flags
& WINEDDFLIP_INTERVAL2
) {
2773 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_TWO
;
2774 } else if(Flags
& WINEDDFLIP_INTERVAL3
) {
2775 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_THREE
;
2777 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_FOUR
;
2780 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2781 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
2782 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
2786 /* Does a direct frame buffer -> texture copy. Stretching is done
2787 * with single pixel copy calls
2789 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2790 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2793 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2796 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2797 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2800 /* TODO: Do we need GL_TEXTURE_2D enabled fpr copyteximage? */
2801 glEnable(This
->glDescription
.target
);
2802 checkGLcall("glEnable(This->glDescription.target)");
2804 /* Bind the target texture */
2805 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2806 checkGLcall("glBindTexture");
2808 TRACE("Reading from an offscreen target\n");
2809 upsidedown
= !upsidedown
;
2810 glReadBuffer(myDevice
->offscreenBuffer
);
2812 GLenum buffer
= surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
);
2813 glReadBuffer(buffer
);
2815 checkGLcall("glReadBuffer");
2817 xrel
= (float) (srect
->x2
- srect
->x1
) / (float) (drect
->x2
- drect
->x1
);
2818 yrel
= (float) (srect
->y2
- srect
->y1
) / (float) (drect
->y2
- drect
->y1
);
2820 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2821 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2823 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
2824 ERR("Texture filtering not supported in direct blit\n");
2826 } else if((Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) && ((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2827 ERR("Texture filtering not supported in direct blit\n");
2831 !((xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) &&
2832 !((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2833 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2835 glCopyTexSubImage2D(This
->glDescription
.target
,
2836 This
->glDescription
.level
,
2837 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2838 srect
->x1
, Src
->currentDesc
.Height
- srect
->y2
,
2839 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2841 UINT yoffset
= Src
->currentDesc
.Height
- srect
->y1
+ drect
->y1
- 1;
2842 /* I have to process this row by row to swap the image,
2843 * otherwise it would be upside down, so stretching in y direction
2844 * doesn't cost extra time
2846 * However, stretching in x direction can be avoided if not necessary
2848 for(row
= drect
->y1
; row
< drect
->y2
; row
++) {
2849 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2850 /* Well, that stuff works, but it's very slow.
2851 * find a better way instead
2855 for(col
= drect
->x1
; col
< drect
->x2
; col
++) {
2856 glCopyTexSubImage2D(This
->glDescription
.target
,
2857 This
->glDescription
.level
,
2858 drect
->x1
+ col
, row
, /* xoffset, yoffset */
2859 srect
->x1
+ col
* xrel
, yoffset
- (int) (row
* yrel
),
2863 glCopyTexSubImage2D(This
->glDescription
.target
,
2864 This
->glDescription
.level
,
2865 drect
->x1
, row
, /* xoffset, yoffset */
2866 srect
->x1
, yoffset
- (int) (row
* yrel
),
2867 drect
->x2
-drect
->x1
, 1);
2871 vcheckGLcall("glCopyTexSubImage2D");
2873 /* Leave the opengl state valid for blitting */
2874 glDisable(This
->glDescription
.target
);
2875 checkGLcall("glDisable(This->glDescription.target)");
2880 /* Uses the hardware to stretch and flip the image */
2881 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2882 GLuint src
, backup
= 0;
2883 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2884 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2885 float left
, right
, top
, bottom
; /* Texture coordinates */
2886 UINT fbwidth
= Src
->currentDesc
.Width
;
2887 UINT fbheight
= Src
->currentDesc
.Height
;
2888 GLenum drawBuffer
= GL_BACK
;
2889 GLenum texture_target
;
2890 BOOL noBackBufferBackup
;
2892 TRACE("Using hwstretch blit\n");
2893 /* Activate the Proper context for reading from the source surface, set it up for blitting */
2894 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2895 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2897 noBackBufferBackup
= !swapchain
&& wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
;
2898 if(!noBackBufferBackup
&& Src
->glDescription
.textureName
== 0) {
2899 /* Get it a description */
2900 IWineD3DSurface_PreLoad(SrcSurface
);
2904 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2905 * This way we don't have to wait for the 2nd readback to finish to leave this function.
2907 if(myDevice
->activeContext
->aux_buffers
>= 2) {
2908 /* Got more than one aux buffer? Use the 2nd aux buffer */
2909 drawBuffer
= GL_AUX1
;
2910 } else if((swapchain
|| myDevice
->offscreenBuffer
== GL_BACK
) && myDevice
->activeContext
->aux_buffers
>= 1) {
2911 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2912 drawBuffer
= GL_AUX0
;
2915 if(noBackBufferBackup
) {
2916 glGenTextures(1, &backup
);
2917 checkGLcall("glGenTextures\n");
2918 glBindTexture(GL_TEXTURE_2D
, backup
);
2919 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2920 texture_target
= GL_TEXTURE_2D
;
2922 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2923 * we are reading from the back buffer, the backup can be used as source texture
2925 texture_target
= Src
->glDescription
.target
;
2926 glBindTexture(texture_target
, Src
->glDescription
.textureName
);
2927 checkGLcall("glBindTexture(texture_target, Src->glDescription.textureName)");
2928 glEnable(texture_target
);
2929 checkGLcall("glEnable(texture_target)");
2931 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2932 Src
->Flags
&= ~SFLAG_INTEXTURE
;
2936 glReadBuffer(surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
));
2938 TRACE("Reading from an offscreen target\n");
2939 upsidedown
= !upsidedown
;
2940 glReadBuffer(myDevice
->offscreenBuffer
);
2943 /* TODO: Only back up the part that will be overwritten */
2944 glCopyTexSubImage2D(texture_target
, 0,
2945 0, 0 /* read offsets */,
2950 checkGLcall("glCopyTexSubImage2D");
2952 /* No issue with overriding these - the sampler is dirty due to blit usage */
2953 glTexParameteri(texture_target
, GL_TEXTURE_MAG_FILTER
,
2954 magLookup
[Filter
- WINED3DTEXF_NONE
]);
2955 checkGLcall("glTexParameteri");
2956 glTexParameteri(texture_target
, GL_TEXTURE_MIN_FILTER
,
2957 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2958 checkGLcall("glTexParameteri");
2960 if(!swapchain
|| (IWineD3DSurface
*) Src
== swapchain
->backBuffer
[0]) {
2961 src
= backup
? backup
: Src
->glDescription
.textureName
;
2963 glReadBuffer(GL_FRONT
);
2964 checkGLcall("glReadBuffer(GL_FRONT)");
2966 glGenTextures(1, &src
);
2967 checkGLcall("glGenTextures(1, &src)");
2968 glBindTexture(GL_TEXTURE_2D
, src
);
2969 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2971 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2972 * out for power of 2 sizes
2974 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, Src
->pow2Width
, Src
->pow2Height
, 0,
2975 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
2976 checkGLcall("glTexImage2D");
2977 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2978 0, 0 /* read offsets */,
2983 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2984 checkGLcall("glTexParameteri");
2985 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2986 checkGLcall("glTexParameteri");
2988 glReadBuffer(GL_BACK
);
2989 checkGLcall("glReadBuffer(GL_BACK)");
2991 if(texture_target
!= GL_TEXTURE_2D
) {
2992 glDisable(texture_target
);
2993 glEnable(GL_TEXTURE_2D
);
2994 texture_target
= GL_TEXTURE_2D
;
2997 checkGLcall("glEnd and previous");
3003 top
= Src
->currentDesc
.Height
- srect
->y1
;
3004 bottom
= Src
->currentDesc
.Height
- srect
->y2
;
3006 top
= Src
->currentDesc
.Height
- srect
->y2
;
3007 bottom
= Src
->currentDesc
.Height
- srect
->y1
;
3010 if(Src
->Flags
& SFLAG_NORMCOORD
) {
3011 left
/= Src
->pow2Width
;
3012 right
/= Src
->pow2Width
;
3013 top
/= Src
->pow2Height
;
3014 bottom
/= Src
->pow2Height
;
3017 /* draw the source texture stretched and upside down. The correct surface is bound already */
3018 glTexParameteri(texture_target
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3019 glTexParameteri(texture_target
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3021 glDrawBuffer(drawBuffer
);
3022 glReadBuffer(drawBuffer
);
3026 glTexCoord2f(left
, bottom
);
3027 glVertex2i(0, fbheight
);
3030 glTexCoord2f(left
, top
);
3031 glVertex2i(0, fbheight
- drect
->y2
- drect
->y1
);
3034 glTexCoord2f(right
, top
);
3035 glVertex2i(drect
->x2
- drect
->x1
, fbheight
- drect
->y2
- drect
->y1
);
3038 glTexCoord2f(right
, bottom
);
3039 glVertex2i(drect
->x2
- drect
->x1
, fbheight
);
3041 checkGLcall("glEnd and previous");
3043 if(texture_target
!= This
->glDescription
.target
) {
3044 glDisable(texture_target
);
3045 glEnable(This
->glDescription
.target
);
3046 texture_target
= This
->glDescription
.target
;
3049 /* Now read the stretched and upside down image into the destination texture */
3050 glBindTexture(texture_target
, This
->glDescription
.textureName
);
3051 checkGLcall("glBindTexture");
3052 glCopyTexSubImage2D(texture_target
,
3054 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
3055 0, 0, /* We blitted the image to the origin */
3056 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
3057 checkGLcall("glCopyTexSubImage2D");
3059 if(drawBuffer
== GL_BACK
) {
3060 /* Write the back buffer backup back */
3062 if(texture_target
!= GL_TEXTURE_2D
) {
3063 glDisable(texture_target
);
3064 glEnable(GL_TEXTURE_2D
);
3065 texture_target
= GL_TEXTURE_2D
;
3067 glBindTexture(GL_TEXTURE_2D
, backup
);
3068 checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3070 if(texture_target
!= Src
->glDescription
.target
) {
3071 glDisable(texture_target
);
3072 glEnable(Src
->glDescription
.target
);
3073 texture_target
= Src
->glDescription
.target
;
3075 glBindTexture(Src
->glDescription
.target
, Src
->glDescription
.textureName
);
3076 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
3081 glTexCoord2f(0.0, (float) fbheight
/ (float) Src
->pow2Height
);
3085 glTexCoord2f(0.0, 0.0);
3086 glVertex2i(0, fbheight
);
3089 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, 0.0);
3090 glVertex2i(fbwidth
, Src
->currentDesc
.Height
);
3093 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, (float) fbheight
/ (float) Src
->pow2Height
);
3094 glVertex2i(fbwidth
, 0);
3097 /* Restore the old draw buffer */
3098 glDrawBuffer(GL_BACK
);
3100 glDisable(texture_target
);
3101 checkGLcall("glDisable(texture_target)");
3104 if(src
!= Src
->glDescription
.textureName
&& src
!= backup
) {
3105 glDeleteTextures(1, &src
);
3106 checkGLcall("glDeleteTextures(1, &src)");
3109 glDeleteTextures(1, &backup
);
3110 checkGLcall("glDeleteTextures(1, &backup)");
3116 /* Not called from the VTable */
3117 static HRESULT
IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3119 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3120 IWineD3DSwapChainImpl
*srcSwapchain
= NULL
, *dstSwapchain
= NULL
;
3121 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3123 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3125 /* Get the swapchain. One of the surfaces has to be a primary surface */
3126 if(This
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
3127 WARN("Destination is in sysmem, rejecting gl blt\n");
3128 return WINED3DERR_INVALIDCALL
;
3130 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&dstSwapchain
);
3131 if(dstSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) dstSwapchain
);
3133 if(Src
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
3134 WARN("Src is in sysmem, rejecting gl blt\n");
3135 return WINED3DERR_INVALIDCALL
;
3137 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) Src
, &IID_IWineD3DSwapChain
, (void **)&srcSwapchain
);
3138 if(srcSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) srcSwapchain
);
3141 /* Early sort out of cases where no render target is used */
3142 if(!dstSwapchain
&& !srcSwapchain
&&
3143 SrcSurface
!= myDevice
->render_targets
[0] && This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3144 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src
, This
);
3145 return WINED3DERR_INVALIDCALL
;
3148 /* No destination color keying supported */
3149 if(Flags
& (WINEDDBLT_KEYDEST
| WINEDDBLT_KEYDESTOVERRIDE
)) {
3150 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3151 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3152 return WINED3DERR_INVALIDCALL
;
3156 rect
.x1
= DestRect
->left
;
3157 rect
.y1
= DestRect
->top
;
3158 rect
.x2
= DestRect
->right
;
3159 rect
.y2
= DestRect
->bottom
;
3163 rect
.x2
= This
->currentDesc
.Width
;
3164 rect
.y2
= This
->currentDesc
.Height
;
3167 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3168 if(dstSwapchain
&& dstSwapchain
== srcSwapchain
&& dstSwapchain
->backBuffer
&&
3169 ((IWineD3DSurface
*) This
== dstSwapchain
->frontBuffer
) && SrcSurface
== dstSwapchain
->backBuffer
[0]) {
3170 /* Half-life does a Blt from the back buffer to the front buffer,
3171 * Full surface size, no flags... Use present instead
3173 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3176 /* Check rects - IWineD3DDevice_Present doesn't handle them */
3180 TRACE("Looking if a Present can be done...\n");
3181 /* Source Rectangle must be full surface */
3183 if(SrcRect
->left
!= 0 || SrcRect
->top
!= 0 ||
3184 SrcRect
->right
!= Src
->currentDesc
.Width
|| SrcRect
->bottom
!= Src
->currentDesc
.Height
) {
3185 TRACE("No, Source rectangle doesn't match\n");
3191 mySrcRect
.right
= Src
->currentDesc
.Width
;
3192 mySrcRect
.bottom
= Src
->currentDesc
.Height
;
3194 /* No stretching may occur */
3195 if(mySrcRect
.right
!= rect
.x2
- rect
.x1
||
3196 mySrcRect
.bottom
!= rect
.y2
- rect
.y1
) {
3197 TRACE("No, stretching is done\n");
3201 /* Destination must be full surface or match the clipping rectangle */
3202 if(This
->clipper
&& ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
)
3206 GetClientRect(((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
, &cliprect
);
3211 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
,
3214 if(pos
[0].x
!= cliprect
.left
|| pos
[0].y
!= cliprect
.top
||
3215 pos
[1].x
!= cliprect
.right
|| pos
[1].y
!= cliprect
.bottom
)
3217 TRACE("No, dest rectangle doesn't match(clipper)\n");
3218 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect
.left
, cliprect
.top
, cliprect
.right
, cliprect
.bottom
);
3219 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect
.x1
, rect
.y1
, rect
.x2
, rect
.y2
);
3225 if(rect
.x1
!= 0 || rect
.y1
!= 0 ||
3226 rect
.x2
!= This
->currentDesc
.Width
|| rect
.y2
!= This
->currentDesc
.Height
) {
3227 TRACE("No, dest rectangle doesn't match(surface size)\n");
3234 /* These flags are unimportant for the flag check, remove them */
3235 if((Flags
& ~(WINEDDBLT_DONOTWAIT
| WINEDDBLT_WAIT
)) == 0) {
3236 WINED3DSWAPEFFECT orig_swap
= dstSwapchain
->presentParms
.SwapEffect
;
3238 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3239 * take very long, while a flip is fast.
3240 * This applies to Half-Life, which does such Blts every time it finished
3241 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3242 * menu. This is also used by all apps when they do windowed rendering
3244 * The problem is that flipping is not really the same as copying. After a
3245 * Blt the front buffer is a copy of the back buffer, and the back buffer is
3246 * untouched. Therefore it's necessary to override the swap effect
3247 * and to set it back after the flip.
3249 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3253 dstSwapchain
->presentParms
.SwapEffect
= WINED3DSWAPEFFECT_COPY
;
3254 dstSwapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
3256 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3257 IWineD3DSwapChain_Present((IWineD3DSwapChain
*) dstSwapchain
, NULL
, NULL
, 0, NULL
, 0);
3259 dstSwapchain
->presentParms
.SwapEffect
= orig_swap
;
3266 TRACE("Unsupported blit between buffers on the same swapchain\n");
3267 return WINED3DERR_INVALIDCALL
;
3268 } else if(dstSwapchain
&& dstSwapchain
== srcSwapchain
) {
3269 FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3270 return WINED3DERR_INVALIDCALL
;
3271 } else if(dstSwapchain
&& srcSwapchain
) {
3272 FIXME("Implement hardware blit between two different swapchains\n");
3273 return WINED3DERR_INVALIDCALL
;
3274 } else if(dstSwapchain
) {
3275 if(SrcSurface
== myDevice
->render_targets
[0]) {
3276 TRACE("Blit from active render target to a swapchain\n");
3277 /* Handled with regular texture -> swapchain blit */
3279 } else if(srcSwapchain
&& This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3280 FIXME("Implement blit from a swapchain to the active render target\n");
3281 return WINED3DERR_INVALIDCALL
;
3284 if((srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) && !dstSwapchain
) {
3285 /* Blit from render target to texture */
3287 BOOL upsideDown
, stretchx
;
3288 BOOL paletteOverride
= FALSE
;
3290 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3291 TRACE("Color keying not supported by frame buffer to texture blit\n");
3292 return WINED3DERR_INVALIDCALL
;
3293 /* Destination color key is checked above */
3296 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3297 * glCopyTexSubImage is a bit picky about the parameters we pass to it
3300 if(SrcRect
->top
< SrcRect
->bottom
) {
3301 srect
.y1
= SrcRect
->top
;
3302 srect
.y2
= SrcRect
->bottom
;
3305 srect
.y1
= SrcRect
->bottom
;
3306 srect
.y2
= SrcRect
->top
;
3309 srect
.x1
= SrcRect
->left
;
3310 srect
.x2
= SrcRect
->right
;
3314 srect
.x2
= Src
->currentDesc
.Width
;
3315 srect
.y2
= Src
->currentDesc
.Height
;
3318 if(rect
.x1
> rect
.x2
) {
3322 upsideDown
= !upsideDown
;
3325 if(rect
.x2
- rect
.x1
!= srect
.x2
- srect
.x1
) {
3331 /* When blitting from a render target a texture, the texture isn't required to have a palette.
3332 * In this case grab the palette from the render target. */
3333 if((This
->resource
.format
== WINED3DFMT_P8
) && (This
->palette
== NULL
)) {
3334 paletteOverride
= TRUE
;
3335 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src
, This
->palette
, This
);
3336 This
->palette
= Src
->palette
;
3339 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3340 * flip the image nor scale it.
3342 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3343 * -> If the app wants a image width an unscaled width, copy it line per line
3344 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3345 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3346 * back buffer. This is slower than reading line per line, thus not used for flipping
3347 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3350 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3351 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3354 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
)) {
3355 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, &srect
,
3356 (IWineD3DSurface
*)This
, &rect
, Filter
, upsideDown
);
3357 } else if((!stretchx
) || rect
.x2
- rect
.x1
> Src
->currentDesc
.Width
||
3358 rect
.y2
- rect
.y1
> Src
->currentDesc
.Height
) {
3359 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3360 fb_copy_to_texture_direct(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3362 TRACE("Using hardware stretching to flip / stretch the texture\n");
3363 fb_copy_to_texture_hwstretch(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3366 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3368 This
->palette
= NULL
;
3370 if(!(This
->Flags
& SFLAG_DONOTFREE
)) {
3371 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
3372 This
->resource
.allocatedMemory
= NULL
;
3373 This
->resource
.heapMemory
= NULL
;
3375 This
->Flags
&= ~SFLAG_INSYSMEM
;
3377 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3378 * path is never entered
3380 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INTEXTURE
, TRUE
);
3384 /* Blit from offscreen surface to render target */
3385 float glTexCoord
[4];
3386 DWORD oldCKeyFlags
= Src
->CKeyFlags
;
3387 WINEDDCOLORKEY oldBltCKey
= Src
->SrcBltCKey
;
3388 RECT SourceRectangle
;
3389 BOOL paletteOverride
= FALSE
;
3391 TRACE("Blt from surface %p to rendertarget %p\n", Src
, This
);
3394 SourceRectangle
.left
= SrcRect
->left
;
3395 SourceRectangle
.right
= SrcRect
->right
;
3396 SourceRectangle
.top
= SrcRect
->top
;
3397 SourceRectangle
.bottom
= SrcRect
->bottom
;
3399 SourceRectangle
.left
= 0;
3400 SourceRectangle
.right
= Src
->currentDesc
.Width
;
3401 SourceRectangle
.top
= 0;
3402 SourceRectangle
.bottom
= Src
->currentDesc
.Height
;
3405 /* When blitting from an offscreen surface to a rendertarget, the source
3406 * surface is not required to have a palette. Our rendering / conversion
3407 * code further down the road retrieves the palette from the surface, so
3408 * it must have a palette set. */
3409 if((Src
->resource
.format
== WINED3DFMT_P8
) && (Src
->palette
== NULL
)) {
3410 paletteOverride
= TRUE
;
3411 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src
, This
->palette
, This
);
3412 Src
->palette
= This
->palette
;
3415 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
) &&
3416 (Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) == 0) {
3417 TRACE("Using stretch_rect_fbo\n");
3418 /* The source is always a texture, but never the currently active render target, and the texture
3419 * contents are never upside down
3421 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, (WINED3DRECT
*) &SourceRectangle
,
3422 (IWineD3DSurface
*)This
, &rect
, Filter
, FALSE
);
3424 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3426 Src
->palette
= NULL
;
3430 if(!CalculateTexRect(Src
, &SourceRectangle
, glTexCoord
)) {
3431 /* Fall back to software */
3432 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src
,
3433 SourceRectangle
.left
, SourceRectangle
.top
,
3434 SourceRectangle
.right
, SourceRectangle
.bottom
);
3435 return WINED3DERR_INVALIDCALL
;
3438 /* Color keying: Check if we have to do a color keyed blt,
3439 * and if not check if a color key is activated.
3441 * Just modify the color keying parameters in the surface and restore them afterwards
3442 * The surface keeps track of the color key last used to load the opengl surface.
3443 * PreLoad will catch the change to the flags and color key and reload if necessary.
3445 if(Flags
& WINEDDBLT_KEYSRC
) {
3446 /* Use color key from surface */
3447 } else if(Flags
& WINEDDBLT_KEYSRCOVERRIDE
) {
3448 /* Use color key from DDBltFx */
3449 Src
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
3450 Src
->SrcBltCKey
= DDBltFx
->ddckSrcColorkey
;
3452 /* Do not use color key */
3453 Src
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
3456 /* Now load the surface */
3457 IWineD3DSurface_PreLoad((IWineD3DSurface
*) Src
);
3459 /* Activate the destination context, set it up for blitting */
3460 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
3462 /* The coordinates of the ddraw front buffer are always fullscreen ('screen coordinates',
3463 * while OpenGL coordinates are window relative.
3464 * Also beware of the origin difference(top left vs bottom left).
3465 * Also beware that the front buffer's surface size is screen width x screen height,
3466 * whereas the real gl drawable size is the size of the window.
3468 if (dstSwapchain
&& (IWineD3DSurface
*)This
== dstSwapchain
->frontBuffer
) {
3470 POINT offset
= {0,0};
3472 ClientToScreen(dstSwapchain
->win_handle
, &offset
);
3473 GetClientRect(dstSwapchain
->win_handle
, &windowsize
);
3474 h
= windowsize
.bottom
- windowsize
.top
;
3475 rect
.x1
-= offset
.x
; rect
.x2
-=offset
.x
;
3476 rect
.y1
-= offset
.y
; rect
.y2
-=offset
.y
;
3477 rect
.y1
+= This
->currentDesc
.Height
- h
; rect
.y2
+= This
->currentDesc
.Height
- h
;
3481 myDevice
->blitter
->set_shader((IWineD3DDevice
*) myDevice
, Src
->resource
.format
,
3482 Src
->glDescription
.target
, Src
->pow2Width
, Src
->pow2Height
);
3484 /* Bind the texture */
3485 glBindTexture(Src
->glDescription
.target
, Src
->glDescription
.textureName
);
3486 checkGLcall("glBindTexture");
3488 /* Filtering for StretchRect */
3489 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_MAG_FILTER
,
3490 magLookup
[Filter
- WINED3DTEXF_NONE
]);
3491 checkGLcall("glTexParameteri");
3492 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_MIN_FILTER
,
3493 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
3494 checkGLcall("glTexParameteri");
3495 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3496 glTexParameteri(Src
->glDescription
.target
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3497 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
3498 checkGLcall("glTexEnvi");
3500 /* This is for color keying */
3501 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3502 glEnable(GL_ALPHA_TEST
);
3503 checkGLcall("glEnable GL_ALPHA_TEST");
3505 /* When the primary render target uses P8, the alpha component contains the palette index.
3506 * Which means that the colorkey is one of the palette entries. In other cases pixels that
3507 * should be masked away have alpha set to 0. */
3508 if(primary_render_target_is_p8(myDevice
))
3509 glAlphaFunc(GL_NOTEQUAL
, (float)Src
->SrcBltCKey
.dwColorSpaceLowValue
/ 256.0);
3511 glAlphaFunc(GL_NOTEQUAL
, 0.0);
3512 checkGLcall("glAlphaFunc\n");
3514 glDisable(GL_ALPHA_TEST
);
3515 checkGLcall("glDisable GL_ALPHA_TEST");
3518 /* Draw a textured quad
3522 glColor3d(1.0f
, 1.0f
, 1.0f
);
3523 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
3528 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
3529 glVertex3f(rect
.x1
, rect
.y2
, 0.0);
3531 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
3536 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
3541 checkGLcall("glEnd");
3543 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3544 glDisable(GL_ALPHA_TEST
);
3545 checkGLcall("glDisable(GL_ALPHA_TEST)");
3548 glBindTexture(Src
->glDescription
.target
, 0);
3549 checkGLcall("glBindTexture(Src->glDescription.target, 0)");
3550 /* Leave the opengl state valid for blitting */
3551 myDevice
->blitter
->unset_shader((IWineD3DDevice
*) myDevice
);
3553 /* Restore the color key parameters */
3554 Src
->CKeyFlags
= oldCKeyFlags
;
3555 Src
->SrcBltCKey
= oldBltCKey
;
3557 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3559 Src
->palette
= NULL
;
3563 /* Flush in case the drawable is used by multiple GL contexts */
3564 if(dstSwapchain
&& (This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
|| dstSwapchain
->num_contexts
>= 2))
3567 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3568 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3571 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INDRAWABLE
, TRUE
);
3575 /* Source-Less Blit to render target */
3576 if (Flags
& WINEDDBLT_COLORFILL
) {
3577 /* This is easy to handle for the D3D Device... */
3580 TRACE("Colorfill\n");
3582 /* This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0] || dstSwapchain
3583 must be true if we are here */
3584 if (This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0] &&
3585 !(This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
||
3586 (dstSwapchain
->backBuffer
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->backBuffer
[0]))) {
3587 TRACE("Surface is higher back buffer, falling back to software\n");
3588 return WINED3DERR_INVALIDCALL
;
3591 /* The color as given in the Blt function is in the format of the frame-buffer...
3592 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3594 if (This
->resource
.format
== WINED3DFMT_P8
) {
3597 if (primary_render_target_is_p8(myDevice
)) alpha
= DDBltFx
->u5
.dwFillColor
<< 24;
3598 else alpha
= 0xFF000000;
3600 if (This
->palette
) {
3602 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peRed
<< 16) |
3603 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peGreen
<< 8) |
3604 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peBlue
));
3609 else if (This
->resource
.format
== WINED3DFMT_R5G6B5
) {
3610 if (DDBltFx
->u5
.dwFillColor
== 0xFFFF) {
3613 color
= ((0xFF000000) |
3614 ((DDBltFx
->u5
.dwFillColor
& 0xF800) << 8) |
3615 ((DDBltFx
->u5
.dwFillColor
& 0x07E0) << 5) |
3616 ((DDBltFx
->u5
.dwFillColor
& 0x001F) << 3));
3619 else if ((This
->resource
.format
== WINED3DFMT_R8G8B8
) ||
3620 (This
->resource
.format
== WINED3DFMT_X8R8G8B8
) ) {
3621 color
= 0xFF000000 | DDBltFx
->u5
.dwFillColor
;
3623 else if (This
->resource
.format
== WINED3DFMT_A8R8G8B8
) {
3624 color
= DDBltFx
->u5
.dwFillColor
;
3627 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3628 return WINED3DERR_INVALIDCALL
;
3631 TRACE("(%p) executing Render Target override, color = %x\n", This
, color
);
3632 IWineD3DDeviceImpl_ClearSurface(myDevice
, This
,
3633 1, /* Number of rectangles */
3634 &rect
, WINED3DCLEAR_TARGET
, color
,
3641 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3642 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3643 return WINED3DERR_INVALIDCALL
;
3646 static HRESULT WINAPI
IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
)
3648 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3651 if (Flags
& WINEDDBLT_DEPTHFILL
) {
3652 switch(This
->resource
.format
) {
3653 case WINED3DFMT_D16
:
3654 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000ffff;
3656 case WINED3DFMT_D15S1
:
3657 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000fffe;
3659 case WINED3DFMT_D24S8
:
3660 case WINED3DFMT_D24X8
:
3661 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x00ffffff;
3663 case WINED3DFMT_D32
:
3664 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0xffffffff;
3668 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This
->resource
.format
));
3671 return IWineD3DDevice_Clear((IWineD3DDevice
*) myDevice
,
3672 DestRect
== NULL
? 0 : 1,
3673 (WINED3DRECT
*) DestRect
,
3674 WINED3DCLEAR_ZBUFFER
,
3680 FIXME("(%p): Unsupp depthstencil blit\n", This
);
3681 return WINED3DERR_INVALIDCALL
;
3684 static HRESULT WINAPI
IWineD3DSurfaceImpl_Blt(IWineD3DSurface
*iface
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3685 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3686 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3687 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3688 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3689 TRACE("(%p): Usage is %s\n", This
, debug_d3dusage(This
->resource
.usage
));
3691 if ( (This
->Flags
& SFLAG_LOCKED
) || ((Src
!= NULL
) && (Src
->Flags
& SFLAG_LOCKED
)))
3693 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3694 return WINEDDERR_SURFACEBUSY
;
3697 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3698 * except depth blits, which seem to work
3700 if(iface
== myDevice
->stencilBufferTarget
|| (SrcSurface
&& SrcSurface
== myDevice
->stencilBufferTarget
)) {
3701 if(myDevice
->inScene
&& !(Flags
& WINEDDBLT_DEPTHFILL
)) {
3702 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3703 return WINED3DERR_INVALIDCALL
;
3704 } else if(IWineD3DSurfaceImpl_BltZ(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
) == WINED3D_OK
) {
3705 TRACE("Z Blit override handled the blit\n");
3710 /* Special cases for RenderTargets */
3711 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3712 ( Src
&& (Src
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3713 if(IWineD3DSurfaceImpl_BltOverride(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
) == WINED3D_OK
) return WINED3D_OK
;
3716 /* For the rest call the X11 surface implementation.
3717 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3718 * other Blts are rather rare
3720 return IWineD3DBaseSurfaceImpl_Blt(iface
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
);
3723 HRESULT WINAPI
IWineD3DSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
, IWineD3DSurface
*Source
, RECT
*rsrc
, DWORD trans
) {
3724 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3725 IWineD3DSurfaceImpl
*srcImpl
= (IWineD3DSurfaceImpl
*) Source
;
3726 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3727 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3729 if ( (This
->Flags
& SFLAG_LOCKED
) || ((srcImpl
!= NULL
) && (srcImpl
->Flags
& SFLAG_LOCKED
)))
3731 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3732 return WINEDDERR_SURFACEBUSY
;
3735 if(myDevice
->inScene
&&
3736 (iface
== myDevice
->stencilBufferTarget
||
3737 (Source
&& Source
== myDevice
->stencilBufferTarget
))) {
3738 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3739 return WINED3DERR_INVALIDCALL
;
3742 /* Special cases for RenderTargets */
3743 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3744 ( srcImpl
&& (srcImpl
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3746 RECT SrcRect
, DstRect
;
3750 SrcRect
.left
= rsrc
->left
;
3751 SrcRect
.top
= rsrc
->top
;
3752 SrcRect
.bottom
= rsrc
->bottom
;
3753 SrcRect
.right
= rsrc
->right
;
3757 SrcRect
.right
= srcImpl
->currentDesc
.Width
;
3758 SrcRect
.bottom
= srcImpl
->currentDesc
.Height
;
3761 DstRect
.left
= dstx
;
3763 DstRect
.right
= dstx
+ SrcRect
.right
- SrcRect
.left
;
3764 DstRect
.bottom
= dsty
+ SrcRect
.bottom
- SrcRect
.top
;
3766 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3767 if(trans
& WINEDDBLTFAST_SRCCOLORKEY
)
3768 Flags
|= WINEDDBLT_KEYSRC
;
3769 if(trans
& WINEDDBLTFAST_DESTCOLORKEY
)
3770 Flags
|= WINEDDBLT_KEYDEST
;
3771 if(trans
& WINEDDBLTFAST_WAIT
)
3772 Flags
|= WINEDDBLT_WAIT
;
3773 if(trans
& WINEDDBLTFAST_DONOTWAIT
)
3774 Flags
|= WINEDDBLT_DONOTWAIT
;
3776 if(IWineD3DSurfaceImpl_BltOverride(This
, &DstRect
, Source
, &SrcRect
, Flags
, NULL
, WINED3DTEXF_POINT
) == WINED3D_OK
) return WINED3D_OK
;
3780 return IWineD3DBaseSurfaceImpl_BltFast(iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3783 HRESULT WINAPI
IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface
*iface
) {
3784 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3786 IWineD3DPaletteImpl
*pal
= This
->palette
;
3788 TRACE("(%p)\n", This
);
3790 if (!pal
) return WINED3D_OK
;
3792 if(This
->resource
.format
== WINED3DFMT_P8
||
3793 This
->resource
.format
== WINED3DFMT_A8P8
)
3796 GLenum format
, internal
, type
;
3797 CONVERT_TYPES convert
;
3799 /* Check if we are using a RTL mode which uses texturing for uploads */
3800 BOOL use_texture
= (wined3d_settings
.rendertargetlock_mode
== RTL_READTEX
|| wined3d_settings
.rendertargetlock_mode
== RTL_TEXTEX
);
3802 /* Check if we have hardware palette conversion if we have convert is set to NO_CONVERSION */
3803 d3dfmt_get_conv(This
, TRUE
, use_texture
, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
3805 if((This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) && (convert
== NO_CONVERSION
))
3807 /* Make sure the texture is up to date. This call doesn't do anything if the texture is already up to date. */
3808 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
);
3810 /* We want to force a palette refresh, so mark the drawable as not being up to date */
3811 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INDRAWABLE
, FALSE
);
3813 /* Re-upload the palette */
3814 d3dfmt_p8_upload_palette(iface
, convert
);
3816 if(!(This
->Flags
& SFLAG_INSYSMEM
)) {
3817 TRACE("Palette changed with surface that does not have an up to date system memory copy\n");
3818 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
3820 TRACE("Dirtifying surface\n");
3821 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
3825 if(This
->Flags
& SFLAG_DIBSECTION
) {
3826 TRACE("(%p): Updating the hdc's palette\n", This
);
3827 for (n
=0; n
<256; n
++) {
3828 col
[n
].rgbRed
= pal
->palents
[n
].peRed
;
3829 col
[n
].rgbGreen
= pal
->palents
[n
].peGreen
;
3830 col
[n
].rgbBlue
= pal
->palents
[n
].peBlue
;
3831 col
[n
].rgbReserved
= 0;
3833 SetDIBColorTable(This
->hDC
, 0, 256, col
);
3836 /* Propagate the changes to the drawable when we have a palette. */
3837 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
3838 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, NULL
);
3843 static HRESULT WINAPI
IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
) {
3844 /** Check against the maximum texture sizes supported by the video card **/
3845 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3846 unsigned int pow2Width
, pow2Height
;
3847 const GlPixelFormatDesc
*glDesc
;
3849 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
3850 /* Setup some glformat defaults */
3851 This
->glDescription
.glFormat
= glDesc
->glFormat
;
3852 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
3853 This
->glDescription
.glType
= glDesc
->glType
;
3855 This
->glDescription
.textureName
= 0;
3856 This
->glDescription
.target
= GL_TEXTURE_2D
;
3858 /* Non-power2 support */
3859 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
) || GL_SUPPORT(WINE_NORMALIZED_TEXRECT
)) {
3860 pow2Width
= This
->currentDesc
.Width
;
3861 pow2Height
= This
->currentDesc
.Height
;
3863 /* Find the nearest pow2 match */
3864 pow2Width
= pow2Height
= 1;
3865 while (pow2Width
< This
->currentDesc
.Width
) pow2Width
<<= 1;
3866 while (pow2Height
< This
->currentDesc
.Height
) pow2Height
<<= 1;
3868 This
->pow2Width
= pow2Width
;
3869 This
->pow2Height
= pow2Height
;
3871 if (pow2Width
> This
->currentDesc
.Width
|| pow2Height
> This
->currentDesc
.Height
) {
3872 WINED3DFORMAT Format
= This
->resource
.format
;
3873 /** TODO: add support for non power two compressed textures **/
3874 if (Format
== WINED3DFMT_DXT1
|| Format
== WINED3DFMT_DXT2
|| Format
== WINED3DFMT_DXT3
3875 || Format
== WINED3DFMT_DXT4
|| Format
== WINED3DFMT_DXT5
3876 || This
->resource
.format
== WINED3DFMT_ATI2N
) {
3877 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3878 This
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
3879 return WINED3DERR_NOTAVAILABLE
;
3883 if(pow2Width
!= This
->currentDesc
.Width
||
3884 pow2Height
!= This
->currentDesc
.Height
) {
3885 This
->Flags
|= SFLAG_NONPOW2
;
3888 TRACE("%p\n", This
);
3889 if ((This
->pow2Width
> GL_LIMITS(texture_size
) || This
->pow2Height
> GL_LIMITS(texture_size
)) && !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_DEPTHSTENCIL
))) {
3890 /* one of three options
3891 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)
3892 2: Set the texture to the maximum size (bad idea)
3893 3: WARN and return WINED3DERR_NOTAVAILABLE;
3894 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.
3896 WARN("(%p) Creating an oversized surface\n", This
);
3897 This
->Flags
|= SFLAG_OVERSIZE
;
3899 /* This will be initialized on the first blt */
3900 This
->glRect
.left
= 0;
3901 This
->glRect
.top
= 0;
3902 This
->glRect
.right
= 0;
3903 This
->glRect
.bottom
= 0;
3905 /* Check this after the oversize check - do not make an oversized surface a texture_rectangle one.
3906 Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
3907 is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
3908 doesn't work in combination with ARB_TEXTURE_RECTANGLE.
3910 if(This
->Flags
& SFLAG_NONPOW2
&& GL_SUPPORT(ARB_TEXTURE_RECTANGLE
) &&
3911 !((This
->resource
.format
== WINED3DFMT_P8
) && GL_SUPPORT(EXT_PALETTED_TEXTURE
) && (wined3d_settings
.rendertargetlock_mode
== RTL_READTEX
|| wined3d_settings
.rendertargetlock_mode
== RTL_TEXTEX
)))
3913 This
->glDescription
.target
= GL_TEXTURE_RECTANGLE_ARB
;
3914 This
->pow2Width
= This
->currentDesc
.Width
;
3915 This
->pow2Height
= This
->currentDesc
.Height
;
3916 This
->Flags
&= ~(SFLAG_NONPOW2
| SFLAG_NORMCOORD
);
3919 /* No oversize, gl rect is the full texture size */
3920 This
->Flags
&= ~SFLAG_OVERSIZE
;
3921 This
->glRect
.left
= 0;
3922 This
->glRect
.top
= 0;
3923 This
->glRect
.right
= This
->pow2Width
;
3924 This
->glRect
.bottom
= This
->pow2Height
;
3927 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
3928 switch(wined3d_settings
.offscreen_rendering_mode
) {
3929 case ORM_FBO
: This
->get_drawable_size
= get_drawable_size_fbo
; break;
3930 case ORM_PBUFFER
: This
->get_drawable_size
= get_drawable_size_pbuffer
; break;
3931 case ORM_BACKBUFFER
: This
->get_drawable_size
= get_drawable_size_backbuffer
; break;
3935 This
->Flags
|= SFLAG_INSYSMEM
;
3940 void surface_modify_ds_location(IWineD3DSurface
*iface
, DWORD location
) {
3941 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3943 TRACE("(%p) New location %#x\n", This
, location
);
3945 if (location
& ~SFLAG_DS_LOCATIONS
) {
3946 FIXME("(%p) Invalid location (%#x) specified\n", This
, location
);
3949 This
->Flags
&= ~SFLAG_DS_LOCATIONS
;
3950 This
->Flags
|= location
;
3953 void surface_load_ds_location(IWineD3DSurface
*iface
, DWORD location
) {
3954 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3955 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3957 TRACE("(%p) New location %#x\n", This
, location
);
3959 /* TODO: Make this work for modes other than FBO */
3960 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) return;
3962 if (This
->Flags
& location
) {
3963 TRACE("(%p) Location (%#x) is already up to date\n", This
, location
);
3967 if (This
->current_renderbuffer
) {
3968 FIXME("(%p) Not supported with fixed up depth stencil\n", This
);
3972 if (location
== SFLAG_DS_OFFSCREEN
) {
3973 if (This
->Flags
& SFLAG_DS_ONSCREEN
) {
3974 GLint old_binding
= 0;
3976 TRACE("(%p) Copying onscreen depth buffer to depth texture\n", This
);
3980 if (!device
->depth_blt_texture
) {
3981 glGenTextures(1, &device
->depth_blt_texture
);
3984 /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
3985 * directly on the FBO texture. That's because we need to flip. */
3986 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
3987 glGetIntegerv(GL_TEXTURE_BINDING_2D
, &old_binding
);
3988 glBindTexture(GL_TEXTURE_2D
, device
->depth_blt_texture
);
3989 glCopyTexImage2D(This
->glDescription
.target
,
3990 This
->glDescription
.level
,
3991 This
->glDescription
.glFormatInternal
,
3994 This
->currentDesc
.Width
,
3995 This
->currentDesc
.Height
,
3997 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3998 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3999 glTexParameteri(GL_TEXTURE_2D
, GL_DEPTH_TEXTURE_MODE_ARB
, GL_LUMINANCE
);
4000 glBindTexture(GL_TEXTURE_2D
, old_binding
);
4002 /* Setup the destination */
4003 if (!device
->depth_blt_rb
) {
4004 GL_EXTCALL(glGenRenderbuffersEXT(1, &device
->depth_blt_rb
));
4005 checkGLcall("glGenRenderbuffersEXT");
4007 if (device
->depth_blt_rb_w
!= This
->currentDesc
.Width
4008 || device
->depth_blt_rb_h
!= This
->currentDesc
.Height
) {
4009 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, device
->depth_blt_rb
));
4010 checkGLcall("glBindRenderbufferEXT");
4011 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, GL_RGBA8
, This
->currentDesc
.Width
, This
->currentDesc
.Height
));
4012 checkGLcall("glRenderbufferStorageEXT");
4013 device
->depth_blt_rb_w
= This
->currentDesc
.Width
;
4014 device
->depth_blt_rb_h
= This
->currentDesc
.Height
;
4017 context_bind_fbo((IWineD3DDevice
*)device
, GL_FRAMEBUFFER_EXT
, &device
->activeContext
->dst_fbo
);
4018 GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT
, GL_COLOR_ATTACHMENT0_EXT
, GL_RENDERBUFFER_EXT
, device
->depth_blt_rb
));
4019 checkGLcall("glFramebufferRenderbufferEXT");
4020 context_attach_depth_stencil_fbo(device
, GL_FRAMEBUFFER_EXT
, iface
, FALSE
);
4022 /* Do the actual blit */
4023 depth_blt((IWineD3DDevice
*)device
, device
->depth_blt_texture
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
4024 checkGLcall("depth_blt");
4026 if (device
->activeContext
->current_fbo
) {
4027 context_bind_fbo((IWineD3DDevice
*)device
, GL_FRAMEBUFFER_EXT
, &device
->activeContext
->current_fbo
->id
);
4029 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
4030 checkGLcall("glBindFramebuffer()");
4035 FIXME("No up to date depth stencil location\n");
4037 } else if (location
== SFLAG_DS_ONSCREEN
) {
4038 if (This
->Flags
& SFLAG_DS_OFFSCREEN
) {
4039 TRACE("(%p) Copying depth texture to onscreen depth buffer\n", This
);
4043 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
4044 checkGLcall("glBindFramebuffer()");
4045 depth_blt((IWineD3DDevice
*)device
, This
->glDescription
.textureName
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
4046 checkGLcall("depth_blt");
4048 if (device
->activeContext
->current_fbo
) {
4049 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, device
->activeContext
->current_fbo
->id
));
4050 checkGLcall("glBindFramebuffer()");
4055 FIXME("No up to date depth stencil location\n");
4058 ERR("(%p) Invalid location (%#x) specified\n", This
, location
);
4061 This
->Flags
|= location
;
4064 static void WINAPI
IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
4065 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4066 IWineD3DBaseTexture
*texture
;
4067 IWineD3DSurfaceImpl
*overlay
;
4069 TRACE("(%p)->(%s, %s)\n", iface
,
4070 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
4071 persistent
? "TRUE" : "FALSE");
4073 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
4074 IWineD3DSwapChain
*swapchain
= NULL
;
4076 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
))) {
4077 TRACE("Surface %p is an onscreen surface\n", iface
);
4079 IWineD3DSwapChain_Release(swapchain
);
4081 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4082 if (flag
& (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
)) flag
|= (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
4087 if((This
->Flags
& SFLAG_INTEXTURE
) && !(flag
& SFLAG_INTEXTURE
)) {
4088 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
4089 TRACE("Passing to container\n");
4090 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
4091 IWineD3DBaseTexture_Release(texture
);
4094 This
->Flags
&= ~SFLAG_LOCATIONS
;
4095 This
->Flags
|= flag
;
4097 /* Redraw emulated overlays, if any */
4098 if(flag
& SFLAG_INDRAWABLE
&& !list_empty(&This
->overlays
)) {
4099 LIST_FOR_EACH_ENTRY(overlay
, &This
->overlays
, IWineD3DSurfaceImpl
, overlay_entry
) {
4100 IWineD3DSurface_DrawOverlay((IWineD3DSurface
*) overlay
);
4104 if((This
->Flags
& SFLAG_INTEXTURE
) && (flag
& SFLAG_INTEXTURE
)) {
4105 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
4106 TRACE("Passing to container\n");
4107 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
4108 IWineD3DBaseTexture_Release(texture
);
4111 This
->Flags
&= ~flag
;
4119 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl
*This
, const RECT
*rect_in
) {
4120 struct coords coords
[4];
4122 IWineD3DSwapChain
*swapchain
= NULL
;
4123 IWineD3DBaseTexture
*texture
= NULL
;
4125 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
4132 rect
.right
= This
->currentDesc
.Width
;
4133 rect
.bottom
= This
->currentDesc
.Height
;
4136 ActivateContext(device
, (IWineD3DSurface
*)This
, CTXUSAGE_BLIT
);
4139 if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
) {
4140 glEnable(GL_TEXTURE_RECTANGLE_ARB
);
4141 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
4142 glBindTexture(GL_TEXTURE_RECTANGLE_ARB
, This
->glDescription
.textureName
);
4143 checkGLcall("GL_TEXTURE_RECTANGLE_ARB, This->glDescription.textureName)");
4144 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4145 checkGLcall("glTexParameteri");
4146 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4147 checkGLcall("glTexParameteri");
4149 coords
[0].x
= rect
.left
;
4152 coords
[1].x
= rect
.left
;
4155 coords
[2].x
= rect
.right
;
4158 coords
[3].x
= rect
.right
;
4161 coords
[0].y
= rect
.top
;
4162 coords
[1].y
= rect
.bottom
;
4163 coords
[2].y
= rect
.bottom
;
4164 coords
[3].y
= rect
.top
;
4165 } else if(This
->glDescription
.target
== GL_TEXTURE_2D
) {
4166 glEnable(GL_TEXTURE_2D
);
4167 checkGLcall("glEnable(GL_TEXTURE_2D)");
4168 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
4169 checkGLcall("GL_TEXTURE_2D, This->glDescription.textureName)");
4170 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4171 checkGLcall("glTexParameteri");
4172 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4173 checkGLcall("glTexParameteri");
4175 coords
[0].x
= (float)rect
.left
/ This
->pow2Width
;
4178 coords
[1].x
= (float)rect
.left
/ This
->pow2Width
;
4181 coords
[2].x
= (float)rect
.right
/ This
->pow2Width
;
4184 coords
[3].x
= (float)rect
.right
/ This
->pow2Width
;
4187 coords
[0].y
= (float)rect
.top
/ This
->pow2Height
;
4188 coords
[1].y
= (float)rect
.bottom
/ This
->pow2Height
;
4189 coords
[2].y
= (float)rect
.bottom
/ This
->pow2Height
;
4190 coords
[3].y
= (float)rect
.top
/ This
->pow2Height
;
4192 /* Must be a cube map */
4193 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
4194 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
4195 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB
, This
->glDescription
.textureName
);
4196 checkGLcall("GL_TEXTURE_CUBE_MAP_ARB, This->glDescription.textureName)");
4197 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
4198 checkGLcall("glTexParameteri");
4199 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
4200 checkGLcall("glTexParameteri");
4202 switch(This
->glDescription
.target
) {
4203 case GL_TEXTURE_CUBE_MAP_POSITIVE_X
:
4204 coords
[0].x
= 1; coords
[0].y
= -1; coords
[0].z
= 1;
4205 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
4206 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
4207 coords
[3].x
= 1; coords
[3].y
= -1; coords
[3].z
= -1;
4210 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X
:
4211 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4212 coords
[1].x
= -1; coords
[1].y
= 1; coords
[1].z
= 1;
4213 coords
[2].x
= -1; coords
[2].y
= 1; coords
[2].z
= -1;
4214 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4217 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y
:
4218 coords
[0].x
= -1; coords
[0].y
= 1; coords
[0].z
= 1;
4219 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
4220 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
4221 coords
[3].x
= -1; coords
[3].y
= 1; coords
[3].z
= -1;
4224 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
:
4225 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4226 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
4227 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
4228 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4231 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z
:
4232 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
4233 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
4234 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= 1;
4235 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= 1;
4238 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
:
4239 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= -1;
4240 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= -1;
4241 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
4242 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
4246 ERR("Unexpected texture target\n");
4253 glTexCoord3fv(&coords
[0].x
);
4254 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
4256 glTexCoord3fv(&coords
[1].x
);
4257 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
4259 glTexCoord3fv(&coords
[2].x
);
4260 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
4262 glTexCoord3fv(&coords
[3].x
);
4263 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
4265 checkGLcall("glEnd");
4267 if(This
->glDescription
.target
!= GL_TEXTURE_2D
) {
4268 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
4269 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4271 glDisable(GL_TEXTURE_2D
);
4272 checkGLcall("glDisable(GL_TEXTURE_2D)");
4276 hr
= IWineD3DSurface_GetContainer((IWineD3DSurface
*)This
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
4277 if(hr
== WINED3D_OK
&& swapchain
) {
4278 /* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
4279 if(((IWineD3DSwapChainImpl
*)swapchain
)->frontBuffer
== (IWineD3DSurface
*)This
||
4280 ((IWineD3DSwapChainImpl
*)swapchain
)->num_contexts
>= 2)
4283 IWineD3DSwapChain_Release(swapchain
);
4285 /* We changed the filtering settings on the texture. Inform the container about this to get the filters
4286 * reset properly next draw
4288 hr
= IWineD3DSurface_GetContainer((IWineD3DSurface
*)This
, &IID_IWineD3DBaseTexture
, (void **) &texture
);
4289 if(hr
== WINED3D_OK
&& texture
) {
4290 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MAGFILTER
] = WINED3DTEXF_POINT
;
4291 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MINFILTER
] = WINED3DTEXF_POINT
;
4292 ((IWineD3DBaseTextureImpl
*) texture
)->baseTexture
.states
[WINED3DTEXSTA_MIPFILTER
] = WINED3DTEXF_NONE
;
4293 IWineD3DBaseTexture_Release(texture
);
4298 /*****************************************************************************
4299 * IWineD3DSurface::LoadLocation
4301 * Copies the current surface data from wherever it is to the requested
4302 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
4303 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
4304 * multiple locations, the gl texture is preferred over the drawable, which is
4305 * preferred over system memory. The PBO counts as system memory. If rect is
4306 * not NULL, only the specified rectangle is copied (only supported for
4307 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
4308 * location is marked up to date after the copy.
4311 * flag: Surface location flag to be updated
4312 * rect: rectangle to be copied
4315 * WINED3D_OK on success
4316 * WINED3DERR_DEVICELOST on an internal error
4318 *****************************************************************************/
4319 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
4320 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4321 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
4322 IWineD3DSwapChain
*swapchain
= NULL
;
4323 GLenum format
, internal
, type
;
4324 CONVERT_TYPES convert
;
4326 int width
, pitch
, outpitch
;
4329 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
4330 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
))) {
4331 TRACE("Surface %p is an onscreen surface\n", iface
);
4333 IWineD3DSwapChain_Release(swapchain
);
4335 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4336 * Prefer SFLAG_INTEXTURE. */
4337 if (flag
== SFLAG_INDRAWABLE
) flag
= SFLAG_INTEXTURE
;
4341 TRACE("(%p)->(%s, %p)\n", iface
,
4342 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
4345 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
4348 if(This
->Flags
& flag
) {
4349 TRACE("Location already up to date\n");
4353 if(!(This
->Flags
& SFLAG_LOCATIONS
)) {
4354 ERR("Surface does not have any up to date location\n");
4355 This
->Flags
|= SFLAG_LOST
;
4356 return WINED3DERR_DEVICELOST
;
4359 if(flag
== SFLAG_INSYSMEM
) {
4360 surface_prepare_system_memory(This
);
4362 /* Download the surface to system memory */
4363 if(This
->Flags
& SFLAG_INTEXTURE
) {
4364 if(!device
->isInDraw
) ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
4365 surface_bind_and_dirtify(This
);
4367 surface_download_data(This
);
4369 read_from_framebuffer(This
, rect
,
4370 This
->resource
.allocatedMemory
,
4371 IWineD3DSurface_GetPitch(iface
));
4373 } else if(flag
== SFLAG_INDRAWABLE
) {
4374 if(This
->Flags
& SFLAG_INTEXTURE
) {
4375 surface_blt_to_drawable(This
, rect
);
4377 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, FALSE
/* We won't use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
4379 /* The width is in 'length' not in bytes */
4380 width
= This
->currentDesc
.Width
;
4381 pitch
= IWineD3DSurface_GetPitch(iface
);
4383 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4384 * but it isn't set (yet) in all cases it is getting called. */
4385 if((convert
!= NO_CONVERSION
) && (This
->Flags
& SFLAG_PBO
)) {
4386 TRACE("Removing the pbo attached to surface %p\n", This
);
4387 surface_remove_pbo(This
);
4390 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
4391 int height
= This
->currentDesc
.Height
;
4393 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4394 outpitch
= width
* bpp
;
4395 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
4397 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
4399 ERR("Out of memory %d, %d!\n", outpitch
, height
);
4400 return WINED3DERR_OUTOFVIDEOMEMORY
;
4402 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
4404 This
->Flags
|= SFLAG_CONVERTED
;
4406 This
->Flags
&= ~SFLAG_CONVERTED
;
4407 mem
= This
->resource
.allocatedMemory
;
4410 flush_to_framebuffer_drawpixels(This
, format
, type
, bpp
, mem
);
4412 /* Don't delete PBO memory */
4413 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
4414 HeapFree(GetProcessHeap(), 0, mem
);
4416 } else /* if(flag == SFLAG_INTEXTURE) */ {
4417 if (This
->Flags
& SFLAG_INDRAWABLE
) {
4418 read_from_framebuffer_texture(This
);
4419 } else { /* Upload from system memory */
4420 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
4422 if(!device
->isInDraw
) ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
4423 surface_bind_and_dirtify(This
);
4426 /* The only place where LoadTexture() might get called when isInDraw=1
4427 * is ActivateContext where lastActiveRenderTarget is preloaded.
4429 if(iface
== device
->lastActiveRenderTarget
&& device
->isInDraw
)
4430 ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
4432 /* Otherwise: System memory copy must be most up to date */
4434 if(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) {
4435 This
->Flags
|= SFLAG_GLCKEY
;
4436 This
->glCKey
= This
->SrcBltCKey
;
4438 else This
->Flags
&= ~SFLAG_GLCKEY
;
4440 /* The width is in 'length' not in bytes */
4441 width
= This
->currentDesc
.Width
;
4442 pitch
= IWineD3DSurface_GetPitch(iface
);
4444 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4445 * but it isn't set (yet) in all cases it is getting called. */
4446 if((convert
!= NO_CONVERSION
) && (This
->Flags
& SFLAG_PBO
)) {
4447 TRACE("Removing the pbo attached to surface %p\n", This
);
4448 surface_remove_pbo(This
);
4451 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
4452 int height
= This
->currentDesc
.Height
;
4454 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4455 outpitch
= width
* bpp
;
4456 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
4458 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
4460 ERR("Out of memory %d, %d!\n", outpitch
, height
);
4461 return WINED3DERR_OUTOFVIDEOMEMORY
;
4463 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
4465 This
->Flags
|= SFLAG_CONVERTED
;
4466 } else if( (This
->resource
.format
== WINED3DFMT_P8
) && (GL_SUPPORT(EXT_PALETTED_TEXTURE
) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) ) {
4467 d3dfmt_p8_upload_palette(iface
, convert
);
4468 This
->Flags
&= ~SFLAG_CONVERTED
;
4469 mem
= This
->resource
.allocatedMemory
;
4471 This
->Flags
&= ~SFLAG_CONVERTED
;
4472 mem
= This
->resource
.allocatedMemory
;
4475 /* Make sure the correct pitch is used */
4476 glPixelStorei(GL_UNPACK_ROW_LENGTH
, width
);
4478 if ((This
->Flags
& SFLAG_NONPOW2
) && !(This
->Flags
& SFLAG_OVERSIZE
)) {
4479 TRACE("non power of two support\n");
4480 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
4481 surface_allocate_surface(This
, internal
, This
->pow2Width
, This
->pow2Height
, format
, type
);
4483 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
4484 surface_upload_data(This
, internal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
, format
, type
, mem
);
4487 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
4488 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
4490 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
4491 surface_allocate_surface(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
);
4493 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
4494 surface_upload_data(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
, mem
);
4498 /* Restore the default pitch */
4499 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
4502 /* Don't delete PBO memory */
4503 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
4504 HeapFree(GetProcessHeap(), 0, mem
);
4509 This
->Flags
|= flag
;
4512 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& !swapchain
4513 && (This
->Flags
& (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
))) {
4514 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4515 This
->Flags
|= (SFLAG_INTEXTURE
| SFLAG_INDRAWABLE
);
4521 HRESULT WINAPI
IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface
*iface
, IWineD3DBase
*container
) {
4522 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4523 IWineD3DSwapChain
*swapchain
= NULL
;
4525 /* Update the drawable size method */
4527 IWineD3DBase_QueryInterface(container
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
4530 This
->get_drawable_size
= get_drawable_size_swapchain
;
4531 IWineD3DSwapChain_Release(swapchain
);
4532 } else if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
4533 switch(wined3d_settings
.offscreen_rendering_mode
) {
4534 case ORM_FBO
: This
->get_drawable_size
= get_drawable_size_fbo
; break;
4535 case ORM_PBUFFER
: This
->get_drawable_size
= get_drawable_size_pbuffer
; break;
4536 case ORM_BACKBUFFER
: This
->get_drawable_size
= get_drawable_size_backbuffer
; break;
4540 return IWineD3DBaseSurfaceImpl_SetContainer(iface
, container
);
4543 static WINED3DSURFTYPE WINAPI
IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface
*iface
) {
4544 return SURFACE_OPENGL
;
4547 static HRESULT WINAPI
IWineD3DSurfaceImpl_DrawOverlay(IWineD3DSurface
*iface
) {
4548 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
4551 /* If there's no destination surface there is nothing to do */
4552 if(!This
->overlay_dest
) return WINED3D_OK
;
4554 /* Blt calls ModifyLocation on the dest surface, which in turn calls DrawOverlay to
4555 * update the overlay. Prevent an endless recursion
4557 if(This
->overlay_dest
->Flags
& SFLAG_INOVERLAYDRAW
) {
4560 This
->overlay_dest
->Flags
|= SFLAG_INOVERLAYDRAW
;
4561 hr
= IWineD3DSurfaceImpl_Blt((IWineD3DSurface
*) This
->overlay_dest
, &This
->overlay_destrect
,
4562 iface
, &This
->overlay_srcrect
, WINEDDBLT_WAIT
,
4563 NULL
, WINED3DTEXF_LINEAR
);
4564 This
->overlay_dest
->Flags
&= ~SFLAG_INOVERLAYDRAW
;
4569 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl
=
4572 IWineD3DBaseSurfaceImpl_QueryInterface
,
4573 IWineD3DBaseSurfaceImpl_AddRef
,
4574 IWineD3DSurfaceImpl_Release
,
4575 /* IWineD3DResource */
4576 IWineD3DBaseSurfaceImpl_GetParent
,
4577 IWineD3DBaseSurfaceImpl_GetDevice
,
4578 IWineD3DBaseSurfaceImpl_SetPrivateData
,
4579 IWineD3DBaseSurfaceImpl_GetPrivateData
,
4580 IWineD3DBaseSurfaceImpl_FreePrivateData
,
4581 IWineD3DBaseSurfaceImpl_SetPriority
,
4582 IWineD3DBaseSurfaceImpl_GetPriority
,
4583 IWineD3DSurfaceImpl_PreLoad
,
4584 IWineD3DSurfaceImpl_UnLoad
,
4585 IWineD3DBaseSurfaceImpl_GetType
,
4586 /* IWineD3DSurface */
4587 IWineD3DBaseSurfaceImpl_GetContainer
,
4588 IWineD3DBaseSurfaceImpl_GetDesc
,
4589 IWineD3DSurfaceImpl_LockRect
,
4590 IWineD3DSurfaceImpl_UnlockRect
,
4591 IWineD3DSurfaceImpl_GetDC
,
4592 IWineD3DSurfaceImpl_ReleaseDC
,
4593 IWineD3DSurfaceImpl_Flip
,
4594 IWineD3DSurfaceImpl_Blt
,
4595 IWineD3DBaseSurfaceImpl_GetBltStatus
,
4596 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
4597 IWineD3DBaseSurfaceImpl_IsLost
,
4598 IWineD3DBaseSurfaceImpl_Restore
,
4599 IWineD3DSurfaceImpl_BltFast
,
4600 IWineD3DBaseSurfaceImpl_GetPalette
,
4601 IWineD3DBaseSurfaceImpl_SetPalette
,
4602 IWineD3DSurfaceImpl_RealizePalette
,
4603 IWineD3DBaseSurfaceImpl_SetColorKey
,
4604 IWineD3DBaseSurfaceImpl_GetPitch
,
4605 IWineD3DSurfaceImpl_SetMem
,
4606 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
4607 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
4608 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
4609 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
4610 IWineD3DBaseSurfaceImpl_SetClipper
,
4611 IWineD3DBaseSurfaceImpl_GetClipper
,
4613 IWineD3DSurfaceImpl_AddDirtyRect
,
4614 IWineD3DSurfaceImpl_LoadTexture
,
4615 IWineD3DSurfaceImpl_BindTexture
,
4616 IWineD3DSurfaceImpl_SaveSnapshot
,
4617 IWineD3DSurfaceImpl_SetContainer
,
4618 IWineD3DSurfaceImpl_SetGlTextureDesc
,
4619 IWineD3DSurfaceImpl_GetGlDesc
,
4620 IWineD3DSurfaceImpl_GetData
,
4621 IWineD3DSurfaceImpl_SetFormat
,
4622 IWineD3DSurfaceImpl_PrivateSetup
,
4623 IWineD3DSurfaceImpl_ModifyLocation
,
4624 IWineD3DSurfaceImpl_LoadLocation
,
4625 IWineD3DSurfaceImpl_GetImplType
,
4626 IWineD3DSurfaceImpl_DrawOverlay
4628 #undef GLINFO_LOCATION
4630 #define GLINFO_LOCATION device->adapter->gl_info
4631 static HRESULT
ffp_blit_alloc(IWineD3DDevice
*iface
) { return WINED3D_OK
; }
4632 static void ffp_blit_free(IWineD3DDevice
*iface
) { }
4634 static HRESULT
ffp_blit_set(IWineD3DDevice
*iface
, WINED3DFORMAT fmt
, GLenum textype
, UINT width
, UINT height
) {
4636 checkGLcall("glEnable(textype)");
4640 static void ffp_blit_unset(IWineD3DDevice
*iface
) {
4641 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) iface
;
4642 glDisable(GL_TEXTURE_2D
);
4643 checkGLcall("glDisable(GL_TEXTURE_2D)");
4644 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
4645 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
4646 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4648 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
4649 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
4650 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
4654 static BOOL
ffp_blit_conv_supported(WINED3DFORMAT fmt
) {
4655 TRACE("Checking blit format support for format %s: [FAILED]\n", debug_d3dformat(fmt
));
4659 const struct blit_shader ffp_blit
= {
4664 ffp_blit_conv_supported