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 WINE_DECLARE_DEBUG_CHANNEL(d3d);
36 #define GLINFO_LOCATION (*gl_info)
38 static void surface_cleanup(IWineD3DSurfaceImpl *This)
40 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
41 const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
42 renderbuffer_entry_t *entry, *entry2;
44 TRACE("(%p) : Cleaning up.\n", This);
46 /* Need a context to destroy the texture. Use the currently active render
47 * target, but only if the primary render target exists. Otherwise
48 * lastActiveRenderTarget is garbage. When destroying the primary render
49 * target, Uninit3D() will activate a context before doing anything. */
50 if (device->render_targets && device->render_targets[0])
52 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
57 if (This->glDescription.textureName)
59 /* Release the OpenGL texture. */
60 TRACE("Deleting texture %u.\n", This->glDescription.textureName);
61 glDeleteTextures(1, &This->glDescription.textureName);
64 if (This->Flags & SFLAG_PBO)
67 GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
70 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry)
72 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry->id));
73 HeapFree(GetProcessHeap(), 0, entry);
78 if (This->Flags & SFLAG_DIBSECTION)
81 SelectObject(This->hDC, This->dib.holdbitmap);
83 /* Release the DIB section. */
84 DeleteObject(This->dib.DIBsection);
85 This->dib.bitmap_data = NULL;
86 This->resource.allocatedMemory = NULL;
89 if (This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
90 if (This->overlay_dest) list_remove(&This->overlay_entry);
92 HeapFree(GetProcessHeap(), 0, This->palette9);
94 resource_cleanup((IWineD3DResource *)This);
97 UINT surface_calculate_size(const struct GlPixelFormatDesc *format_desc, UINT alignment, UINT width, UINT height)
101 if (format_desc->format == WINED3DFMT_UNKNOWN)
105 else if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
107 UINT row_block_count = (width + format_desc->block_width - 1) / format_desc->block_width;
108 UINT row_count = (height + format_desc->block_height - 1) / format_desc->block_height;
109 size = row_count * row_block_count * format_desc->block_byte_count;
113 /* The pitch is a multiple of 4 bytes. */
114 size = height * (((width * format_desc->byte_count) + alignment - 1) & ~(alignment - 1));
117 if (format_desc->heightscale != 0.0) size *= format_desc->heightscale;
122 HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
123 UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
124 UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
125 WINED3DPOOL pool, IUnknown *parent)
127 const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
128 const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(format, &GLINFO_LOCATION);
129 void (*cleanup)(IWineD3DSurfaceImpl *This);
130 unsigned int resource_size;
133 if (multisample_quality > 0)
135 FIXME("multisample_quality set to %u, substituting 0\n", multisample_quality);
136 multisample_quality = 0;
139 /* FIXME: Check that the format is supported by the device. */
141 resource_size = surface_calculate_size(format_desc, alignment, width, height);
143 /* Look at the implementation and set the correct Vtable. */
144 switch (surface_type)
147 surface->lpVtbl = &IWineD3DSurface_Vtbl;
148 cleanup = surface_cleanup;
152 surface->lpVtbl = &IWineGDISurface_Vtbl;
153 cleanup = surface_gdi_cleanup;
157 ERR("Requested unknown surface implementation %#x.\n", surface_type);
158 return WINED3DERR_INVALIDCALL;
161 hr = resource_init((IWineD3DResource *)surface, WINED3DRTYPE_SURFACE,
162 device, resource_size, usage, format_desc, pool, parent);
165 WARN("Failed to initialize resource, returning %#x.\n", hr);
169 /* "Standalone" surface. */
170 IWineD3DSurface_SetContainer((IWineD3DSurface *)surface, NULL);
172 surface->currentDesc.Width = width;
173 surface->currentDesc.Height = height;
174 surface->currentDesc.MultiSampleType = multisample_type;
175 surface->currentDesc.MultiSampleQuality = multisample_quality;
176 surface->glDescription.level = level;
177 list_init(&surface->overlays);
180 surface->Flags = SFLAG_NORMCOORD; /* Default to normalized coords. */
181 if (discard) surface->Flags |= SFLAG_DISCARD;
182 if (lockable || format == WINED3DFMT_D16_LOCKABLE) surface->Flags |= SFLAG_LOCKABLE;
184 /* Quick lockable sanity check.
185 * TODO: remove this after surfaces, usage and lockability have been debugged properly
186 * this function is too deep to need to care about things like this.
187 * Levels need to be checked too, since they all affect what can be done. */
190 case WINED3DPOOL_SCRATCH:
193 FIXME("Called with a pool of SCRATCH and a lockable of FALSE "
194 "which are mutually exclusive, setting lockable to TRUE.\n");
199 case WINED3DPOOL_SYSTEMMEM:
201 FIXME("Called with a pool of SYSTEMMEM and a lockable of FALSE, this is acceptable but unexpected.\n");
204 case WINED3DPOOL_MANAGED:
205 if (usage & WINED3DUSAGE_DYNAMIC)
206 FIXME("Called with a pool of MANAGED and a usage of DYNAMIC which are mutually exclusive.\n");
209 case WINED3DPOOL_DEFAULT:
210 if (lockable && !(usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL)))
211 WARN("Creating a lockable surface with a POOL of DEFAULT, that doesn't specify DYNAMIC usage.\n");
215 FIXME("Unknown pool %#x.\n", pool);
219 if (usage & WINED3DUSAGE_RENDERTARGET && pool != WINED3DPOOL_DEFAULT)
221 FIXME("Trying to create a render target that isn't in the default pool.\n");
224 /* Mark the texture as dirty so that it gets loaded first time around. */
225 surface_add_dirty_rect((IWineD3DSurface *)surface, NULL);
226 list_init(&surface->renderbuffers);
228 TRACE("surface %p, memory %p, size %u\n", surface, surface->resource.allocatedMemory, surface->resource.size);
230 /* Call the private setup routine */
231 hr = IWineD3DSurface_PrivateSetup((IWineD3DSurface *)surface);
234 ERR("Private setup failed, returning %#x\n", hr);
242 static void surface_force_reload(IWineD3DSurface *iface)
244 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
246 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
249 void surface_set_texture_name(IWineD3DSurface *iface, GLuint new_name, BOOL srgb)
251 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
257 name = &This->glDescription.srgbTextureName;
258 flag = SFLAG_INSRGBTEX;
262 name = &This->glDescription.textureName;
263 flag = SFLAG_INTEXTURE;
266 TRACE("(%p) : setting texture name %u\n", This, new_name);
268 if (!*name && new_name)
270 /* FIXME: We shouldn't need to remove SFLAG_INTEXTURE if the
271 * surface has no texture name yet. See if we can get rid of this. */
272 if (This->Flags & flag)
273 ERR("Surface has SFLAG_INTEXTURE set, but no texture name\n");
274 IWineD3DSurface_ModifyLocation(iface, flag, FALSE);
278 surface_force_reload(iface);
281 void surface_set_texture_target(IWineD3DSurface *iface, GLenum target)
283 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
285 TRACE("(%p) : setting target %#x\n", This, target);
287 if (This->glDescription.target != target)
289 if (target == GL_TEXTURE_RECTANGLE_ARB)
291 This->Flags &= ~SFLAG_NORMCOORD;
293 else if (This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB)
295 This->Flags |= SFLAG_NORMCOORD;
298 This->glDescription.target = target;
299 surface_force_reload(iface);
302 static void surface_bind_and_dirtify(IWineD3DSurfaceImpl *This, BOOL srgb) {
305 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
306 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
307 * gl states. The current texture unit should always be a valid one.
309 * To be more specific, this is tricky because we can implicitly be called
310 * from sampler() in state.c. This means we can't touch anything other than
311 * whatever happens to be the currently active texture, or we would risk
312 * marking already applied sampler states dirty again.
314 * TODO: Track the current active texture per GL context instead of using glGet
316 GLint active_texture;
318 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
320 active_sampler = This->resource.wineD3DDevice->rev_tex_unit_map[active_texture - GL_TEXTURE0_ARB];
322 if (active_sampler != -1) {
323 IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_SAMPLER(active_sampler));
325 IWineD3DSurface_BindTexture((IWineD3DSurface *)This, srgb);
328 /* This function checks if the primary render target uses the 8bit paletted format. */
329 static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
331 if (device->render_targets && device->render_targets[0]) {
332 IWineD3DSurfaceImpl* render_target = (IWineD3DSurfaceImpl*)device->render_targets[0];
333 if ((render_target->resource.usage & WINED3DUSAGE_RENDERTARGET)
334 && (render_target->resource.format_desc->format == WINED3DFMT_P8))
340 #undef GLINFO_LOCATION
342 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
344 /* This call just downloads data, the caller is responsible for activating the
345 * right context and binding the correct texture. */
346 static void surface_download_data(IWineD3DSurfaceImpl *This) {
347 const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
349 /* Only support read back of converted P8 surfaces */
350 if (This->Flags & SFLAG_CONVERTED && format_desc->format != WINED3DFMT_P8)
352 FIXME("Read back converted textures unsupported, format=%s\n", debug_d3dformat(format_desc->format));
358 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
360 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p.\n",
361 This, This->glDescription.level, format_desc->glFormat, format_desc->glType,
362 This->resource.allocatedMemory);
364 if (This->Flags & SFLAG_PBO)
366 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
367 checkGLcall("glBindBufferARB");
368 GL_EXTCALL(glGetCompressedTexImageARB(This->glDescription.target, This->glDescription.level, NULL));
369 checkGLcall("glGetCompressedTexImageARB()");
370 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
371 checkGLcall("glBindBufferARB");
375 GL_EXTCALL(glGetCompressedTexImageARB(This->glDescription.target,
376 This->glDescription.level, This->resource.allocatedMemory));
377 checkGLcall("glGetCompressedTexImageARB()");
383 GLenum format = format_desc->glFormat;
384 GLenum type = format_desc->glType;
388 /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
389 if (format_desc->format == WINED3DFMT_P8 && primary_render_target_is_p8(This->resource.wineD3DDevice))
392 type = GL_UNSIGNED_BYTE;
395 if (This->Flags & SFLAG_NONPOW2) {
396 unsigned char alignment = This->resource.wineD3DDevice->surface_alignment;
397 src_pitch = format_desc->byte_count * This->pow2Width;
398 dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
399 src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
400 mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
402 mem = This->resource.allocatedMemory;
405 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This, This->glDescription.level,
408 if(This->Flags & SFLAG_PBO) {
409 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
410 checkGLcall("glBindBufferARB");
412 glGetTexImage(This->glDescription.target, This->glDescription.level, format,
414 checkGLcall("glGetTexImage()");
416 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
417 checkGLcall("glBindBufferARB");
419 glGetTexImage(This->glDescription.target, This->glDescription.level, format,
421 checkGLcall("glGetTexImage()");
425 if (This->Flags & SFLAG_NONPOW2) {
426 const BYTE *src_data;
430 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
431 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
432 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
434 * We're doing this...
436 * instead of boxing the texture :
437 * |<-texture width ->| -->pow2width| /\
438 * |111111111111111111| | |
439 * |222 Texture 222222| boxed empty | texture height
440 * |3333 Data 33333333| | |
441 * |444444444444444444| | \/
442 * ----------------------------------- |
443 * | boxed empty | boxed empty | pow2height
445 * -----------------------------------
448 * we're repacking the data to the expected texture width
450 * |<-texture width ->| -->pow2width| /\
451 * |111111111111111111222222222222222| |
452 * |222333333333333333333444444444444| texture height
456 * | empty | pow2height
458 * -----------------------------------
462 * |<-texture width ->| /\
463 * |111111111111111111|
464 * |222222222222222222|texture height
465 * |333333333333333333|
466 * |444444444444444444| \/
467 * --------------------
469 * this also means that any references to allocatedMemory should work with the data as if were a
470 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
472 * internally the texture is still stored in a boxed format so any references to textureName will
473 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
475 * Performance should not be an issue, because applications normally do not lock the surfaces when
476 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
477 * and doesn't have to be re-read.
480 dst_data = This->resource.allocatedMemory;
481 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This, src_pitch, dst_pitch);
482 for (y = 1 ; y < This->currentDesc.Height; y++) {
483 /* skip the first row */
484 src_data += src_pitch;
485 dst_data += dst_pitch;
486 memcpy(dst_data, src_data, dst_pitch);
489 HeapFree(GetProcessHeap(), 0, mem);
493 /* Surface has now been downloaded */
494 This->Flags |= SFLAG_INSYSMEM;
497 /* This call just uploads data, the caller is responsible for activating the
498 * right context and binding the correct texture. */
499 static void surface_upload_data(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) {
500 const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
502 if (format_desc->heightscale != 1.0 && format_desc->heightscale != 0.0) height *= format_desc->heightscale;
504 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
506 /* glCompressedTexSubImage2D() for uploading and glTexImage2D() for
507 * allocating does not work well on some drivers (r200 dri, MacOS ATI
508 * driver). glCompressedTexImage2D() does not accept NULL pointers. So
509 * for compressed textures surface_allocate_surface() does nothing,
510 * and this function uses glCompressedTexImage2D() instead of
511 * glCompressedTexSubImage2D(). */
512 TRACE("(%p) : Calling glCompressedTexImage2DARB w %u, h %u, data %p.\n", This, width, height, data);
516 if (This->Flags & SFLAG_PBO)
518 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
519 checkGLcall("glBindBufferARB");
521 TRACE("(%p) pbo: %#x, data: %p.\n", This, This->pbo, data);
523 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level,
524 internal, width, height, 0 /* border */, This->resource.size, NULL));
525 checkGLcall("glCompressedTexImage2DARB");
527 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
528 checkGLcall("glBindBufferARB");
532 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level,
533 internal, width, height, 0 /* border */, This->resource.size, data));
534 checkGLcall("glCompressedTexSubImage2D");
541 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This, width, height, data);
544 if(This->Flags & SFLAG_PBO) {
545 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
546 checkGLcall("glBindBufferARB");
547 TRACE("(%p) pbo: %#x, data: %p\n", This, This->pbo, data);
549 glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, NULL);
550 checkGLcall("glTexSubImage2D");
552 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
553 checkGLcall("glBindBufferARB");
556 glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, data);
557 checkGLcall("glTexSubImage2D");
564 /* This call just allocates the texture, the caller is responsible for
565 * activating the right context and binding the correct texture. */
566 static void surface_allocate_surface(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type) {
567 const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
568 BOOL enable_client_storage = FALSE;
569 const BYTE *mem = NULL;
571 if (format_desc->heightscale != 1.0 && format_desc->heightscale != 0.0) height *= format_desc->heightscale;
573 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",
574 This, This->glDescription.target, This->glDescription.level, debug_d3dformat(format_desc->format),
575 internal, width, height, format, type);
577 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
579 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
580 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
582 /* We have to point GL to the client storage memory here, because upload_data might use a PBO. This means a double upload
583 * once, unfortunately
585 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
586 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
587 This->Flags |= SFLAG_CLIENT;
588 mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
590 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
591 width, height, 0 /* border */, This->resource.size, mem));
600 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
601 if(This->Flags & (SFLAG_NONPOW2 | SFLAG_DIBSECTION | SFLAG_OVERSIZE | SFLAG_CONVERTED) || This->resource.allocatedMemory == NULL) {
602 /* In some cases we want to disable client storage.
603 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
604 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
605 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
606 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
607 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
609 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
610 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
611 This->Flags &= ~SFLAG_CLIENT;
612 enable_client_storage = TRUE;
614 This->Flags |= SFLAG_CLIENT;
616 /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
617 * it might point into a pbo. Instead use heapMemory, but get the alignment right.
619 mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
622 glTexImage2D(This->glDescription.target, This->glDescription.level, internal, width, height, 0, format, type, mem);
623 checkGLcall("glTexImage2D");
625 if(enable_client_storage) {
626 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
627 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
632 /* In D3D the depth stencil dimensions have to be greater than or equal to the
633 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
634 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
635 /* GL locking is done by the caller */
636 void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height) {
637 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
638 renderbuffer_entry_t *entry;
639 GLuint renderbuffer = 0;
640 unsigned int src_width, src_height;
642 src_width = This->pow2Width;
643 src_height = This->pow2Height;
645 /* A depth stencil smaller than the render target is not valid */
646 if (width > src_width || height > src_height) return;
648 /* Remove any renderbuffer set if the sizes match */
649 if (width == src_width && height == src_height) {
650 This->current_renderbuffer = NULL;
654 /* Look if we've already got a renderbuffer of the correct dimensions */
655 LIST_FOR_EACH_ENTRY(entry, &This->renderbuffers, renderbuffer_entry_t, entry) {
656 if (entry->width == width && entry->height == height) {
657 renderbuffer = entry->id;
658 This->current_renderbuffer = entry;
664 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer));
665 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer));
666 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
667 This->resource.format_desc->glInternal, width, height));
669 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
670 entry->width = width;
671 entry->height = height;
672 entry->id = renderbuffer;
673 list_add_head(&This->renderbuffers, &entry->entry);
675 This->current_renderbuffer = entry;
678 checkGLcall("set_compatible_renderbuffer");
681 GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain) {
682 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
683 IWineD3DSwapChainImpl *swapchain_impl = (IWineD3DSwapChainImpl *)swapchain;
685 TRACE("(%p) : swapchain %p\n", This, swapchain);
687 if (swapchain_impl->backBuffer && swapchain_impl->backBuffer[0] == iface) {
688 TRACE("Returning GL_BACK\n");
690 } else if (swapchain_impl->frontBuffer == iface) {
691 TRACE("Returning GL_FRONT\n");
695 FIXME("Higher back buffer, returning GL_BACK\n");
699 /* Slightly inefficient way to handle multiple dirty rects but it works :) */
700 void surface_add_dirty_rect(IWineD3DSurface *iface, const RECT *dirty_rect)
702 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
703 IWineD3DBaseTexture *baseTexture = NULL;
705 if (!(This->Flags & SFLAG_INSYSMEM) && (This->Flags & SFLAG_INTEXTURE))
706 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL /* no partial locking for textures yet */);
708 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
711 This->dirtyRect.left = min(This->dirtyRect.left, dirty_rect->left);
712 This->dirtyRect.top = min(This->dirtyRect.top, dirty_rect->top);
713 This->dirtyRect.right = max(This->dirtyRect.right, dirty_rect->right);
714 This->dirtyRect.bottom = max(This->dirtyRect.bottom, dirty_rect->bottom);
718 This->dirtyRect.left = 0;
719 This->dirtyRect.top = 0;
720 This->dirtyRect.right = This->currentDesc.Width;
721 This->dirtyRect.bottom = This->currentDesc.Height;
724 TRACE("(%p) : Dirty: yes, Rect:(%d, %d, %d, %d)\n", This, This->dirtyRect.left,
725 This->dirtyRect.top, This->dirtyRect.right, This->dirtyRect.bottom);
727 /* if the container is a basetexture then mark it dirty. */
728 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture)))
730 TRACE("Passing to container\n");
731 IWineD3DBaseTexture_SetDirty(baseTexture, TRUE);
732 IWineD3DBaseTexture_Release(baseTexture);
736 static inline BOOL surface_can_stretch_rect(IWineD3DSurfaceImpl *src, IWineD3DSurfaceImpl *dst)
738 return ((src->resource.format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE)
739 || (src->resource.usage & WINED3DUSAGE_RENDERTARGET))
740 && ((dst->resource.format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE)
741 || (dst->resource.usage & WINED3DUSAGE_RENDERTARGET))
742 && (src->resource.format_desc->format == dst->resource.format_desc->format
743 || (is_identity_fixup(src->resource.format_desc->color_fixup)
744 && is_identity_fixup(dst->resource.format_desc->color_fixup)));
747 static ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface)
749 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
750 ULONG ref = InterlockedDecrement(&This->resource.ref);
751 TRACE("(%p) : Releasing from %d\n", This, ref + 1);
755 surface_cleanup(This);
757 TRACE("(%p) Released.\n", This);
758 HeapFree(GetProcessHeap(), 0, This);
764 /* ****************************************************
765 IWineD3DSurface IWineD3DResource parts follow
766 **************************************************** */
768 void surface_internal_preload(IWineD3DSurface *iface, enum WINED3DSRGB srgb)
770 /* TODO: check for locks */
771 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
772 IWineD3DBaseTexture *baseTexture = NULL;
773 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
775 TRACE("(%p)Checking to see if the container is a base texture\n", This);
776 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
777 IWineD3DBaseTextureImpl *tex_impl = (IWineD3DBaseTextureImpl *) baseTexture;
778 TRACE("Passing to container\n");
779 tex_impl->baseTexture.internal_preload(baseTexture, SRGB_RGB);
780 IWineD3DBaseTexture_Release(baseTexture);
782 TRACE("(%p) : About to load surface\n", This);
784 if(!device->isInDraw) {
785 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
788 if (This->resource.format_desc->format == WINED3DFMT_P8
789 || This->resource.format_desc->format == WINED3DFMT_A8P8)
791 if(palette9_changed(This)) {
792 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
793 /* TODO: This is not necessarily needed with hw palettized texture support */
794 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
795 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
796 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
800 IWineD3DSurface_LoadTexture(iface, srgb == SRGB_SRGB ? TRUE : FALSE);
802 if (This->resource.pool == WINED3DPOOL_DEFAULT) {
803 /* Tell opengl to try and keep this texture in video ram (well mostly) */
807 glPrioritizeTextures(1, &This->glDescription.textureName, &tmp);
814 static void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface) {
815 surface_internal_preload(iface, SRGB_ANY);
818 static void surface_remove_pbo(IWineD3DSurfaceImpl *This) {
819 This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
820 This->resource.allocatedMemory =
821 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
824 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
825 checkGLcall("glBindBuffer(GL_PIXEL_UNPACK_BUFFER, This->pbo)");
826 GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0, This->resource.size, This->resource.allocatedMemory));
827 checkGLcall("glGetBufferSubData");
828 GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
829 checkGLcall("glDeleteBuffers");
833 This->Flags &= ~SFLAG_PBO;
836 static void WINAPI IWineD3DSurfaceImpl_UnLoad(IWineD3DSurface *iface) {
837 IWineD3DBaseTexture *texture = NULL;
838 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
839 renderbuffer_entry_t *entry, *entry2;
840 TRACE("(%p)\n", iface);
842 if(This->resource.pool == WINED3DPOOL_DEFAULT) {
843 /* Default pool resources are supposed to be destroyed before Reset is called.
844 * Implicit resources stay however. So this means we have an implicit render target
845 * or depth stencil. The content may be destroyed, but we still have to tear down
846 * opengl resources, so we cannot leave early.
848 * Put the most up to date surface location into the drawable. D3D-wise this content
849 * is undefined, so it would be nowhere, but that would make the location management
850 * more complicated. The drawable is a sane location, because if we mark sysmem or
851 * texture up to date, drawPrim will copy the uninitialized texture or sysmem to the
852 * uninitialized drawable. That's pointless and we'd have to allocate the texture /
855 if (This->resource.usage & WINED3DUSAGE_DEPTHSTENCIL) {
856 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
858 IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, TRUE);
861 /* Load the surface into system memory */
862 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
863 IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
865 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
866 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSRGBTEX, FALSE);
867 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
869 /* Destroy PBOs, but load them into real sysmem before */
870 if(This->Flags & SFLAG_PBO) {
871 surface_remove_pbo(This);
874 /* Destroy fbo render buffers. This is needed for implicit render targets, for
875 * all application-created targets the application has to release the surface
876 * before calling _Reset
878 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry) {
880 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry->id));
882 list_remove(&entry->entry);
883 HeapFree(GetProcessHeap(), 0, entry);
885 list_init(&This->renderbuffers);
886 This->current_renderbuffer = NULL;
888 /* If we're in a texture, the texture name belongs to the texture. Otherwise,
891 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **) &texture);
894 glDeleteTextures(1, &This->glDescription.textureName);
895 This->glDescription.textureName = 0;
896 glDeleteTextures(1, &This->glDescription.srgbTextureName);
897 This->glDescription.srgbTextureName = 0;
900 IWineD3DBaseTexture_Release(texture);
905 /* ******************************************************
906 IWineD3DSurface IWineD3DSurface parts follow
907 ****************************************************** */
909 static void WINAPI IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription)
911 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
912 TRACE("(%p) : returning %p\n", This, &This->glDescription);
913 *glDescription = &This->glDescription;
916 /* Read the framebuffer back into the surface */
917 static void read_from_framebuffer(IWineD3DSurfaceImpl *This, CONST RECT *rect, void *dest, UINT pitch) {
918 IWineD3DSwapChainImpl *swapchain;
919 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
923 BYTE *row, *top, *bottom;
927 BOOL srcIsUpsideDown;
932 if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
933 static BOOL warned = FALSE;
935 ERR("The application tries to lock the render target, but render target locking is disabled\n");
941 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
942 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
943 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
944 * context->last_was_blit set on the unlock.
946 ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
949 /* Select the correct read buffer, and give some debug output.
950 * There is no need to keep track of the current read buffer or reset it, every part of the code
951 * that reads sets the read buffer as desired.
953 if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&swapchain)))
955 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
956 TRACE("Locking %#x buffer\n", buffer);
957 glReadBuffer(buffer);
958 checkGLcall("glReadBuffer");
960 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
961 srcIsUpsideDown = FALSE;
963 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
964 * Read from the back buffer
966 TRACE("Locking offscreen render target\n");
967 glReadBuffer(myDevice->offscreenBuffer);
968 srcIsUpsideDown = TRUE;
971 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
975 local_rect.right = This->currentDesc.Width;
976 local_rect.bottom = This->currentDesc.Height;
980 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
982 switch(This->resource.format_desc->format)
986 if(primary_render_target_is_p8(myDevice)) {
987 /* In case of P8 render targets the index is stored in the alpha component */
989 type = GL_UNSIGNED_BYTE;
991 bpp = This->resource.format_desc->byte_count;
993 /* GL can't return palettized data, so read ARGB pixels into a
994 * separate block of memory and convert them into palettized format
995 * in software. Slow, but if the app means to use palettized render
996 * targets and locks it...
998 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
999 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
1000 * for the color channels when palettizing the colors.
1003 type = GL_UNSIGNED_BYTE;
1005 mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * 3);
1007 ERR("Out of memory\n");
1011 bpp = This->resource.format_desc->byte_count * 3;
1018 fmt = This->resource.format_desc->glFormat;
1019 type = This->resource.format_desc->glType;
1020 bpp = This->resource.format_desc->byte_count;
1023 if(This->Flags & SFLAG_PBO) {
1024 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
1025 checkGLcall("glBindBufferARB");
1027 ERR("mem not null for pbo -- unexpected\n");
1032 /* Save old pixel store pack state */
1033 glGetIntegerv(GL_PACK_ROW_LENGTH, &rowLen);
1034 checkGLcall("glIntegerv");
1035 glGetIntegerv(GL_PACK_SKIP_PIXELS, &skipPix);
1036 checkGLcall("glIntegerv");
1037 glGetIntegerv(GL_PACK_SKIP_ROWS, &skipRow);
1038 checkGLcall("glIntegerv");
1040 /* Setup pixel store pack state -- to glReadPixels into the correct place */
1041 glPixelStorei(GL_PACK_ROW_LENGTH, This->currentDesc.Width);
1042 checkGLcall("glPixelStorei");
1043 glPixelStorei(GL_PACK_SKIP_PIXELS, local_rect.left);
1044 checkGLcall("glPixelStorei");
1045 glPixelStorei(GL_PACK_SKIP_ROWS, local_rect.top);
1046 checkGLcall("glPixelStorei");
1048 glReadPixels(local_rect.left, (!srcIsUpsideDown) ? (This->currentDesc.Height - local_rect.bottom) : local_rect.top ,
1049 local_rect.right - local_rect.left,
1050 local_rect.bottom - local_rect.top,
1052 checkGLcall("glReadPixels");
1054 /* Reset previous pixel store pack state */
1055 glPixelStorei(GL_PACK_ROW_LENGTH, rowLen);
1056 checkGLcall("glPixelStorei");
1057 glPixelStorei(GL_PACK_SKIP_PIXELS, skipPix);
1058 checkGLcall("glPixelStorei");
1059 glPixelStorei(GL_PACK_SKIP_ROWS, skipRow);
1060 checkGLcall("glPixelStorei");
1062 if(This->Flags & SFLAG_PBO) {
1063 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
1064 checkGLcall("glBindBufferARB");
1066 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
1067 * to get a pointer to it and perform the flipping in software. This is a lot
1068 * faster than calling glReadPixels for each line. In case we want more speed
1069 * we should rerender it flipped in a FBO and read the data back from the FBO. */
1070 if(!srcIsUpsideDown) {
1071 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1072 checkGLcall("glBindBufferARB");
1074 mem = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1075 checkGLcall("glMapBufferARB");
1079 /* TODO: Merge this with the palettization loop below for P8 targets */
1080 if(!srcIsUpsideDown) {
1082 /* glReadPixels returns the image upside down, and there is no way to prevent this.
1083 Flip the lines in software */
1084 len = (local_rect.right - local_rect.left) * bpp;
1085 off = local_rect.left * bpp;
1087 row = HeapAlloc(GetProcessHeap(), 0, len);
1089 ERR("Out of memory\n");
1090 if (This->resource.format_desc->format == WINED3DFMT_P8) HeapFree(GetProcessHeap(), 0, mem);
1095 top = mem + pitch * local_rect.top;
1096 bottom = mem + pitch * (local_rect.bottom - 1);
1097 for(i = 0; i < (local_rect.bottom - local_rect.top) / 2; i++) {
1098 memcpy(row, top + off, len);
1099 memcpy(top + off, bottom + off, len);
1100 memcpy(bottom + off, row, len);
1104 HeapFree(GetProcessHeap(), 0, row);
1106 /* Unmap the temp PBO buffer */
1107 if(This->Flags & SFLAG_PBO) {
1108 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1109 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1115 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
1116 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
1117 * the same color but we have no choice.
1118 * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
1120 if ((This->resource.format_desc->format == WINED3DFMT_P8) && !primary_render_target_is_p8(myDevice))
1122 const PALETTEENTRY *pal = NULL;
1123 DWORD width = pitch / 3;
1127 pal = This->palette->palents;
1129 ERR("Palette is missing, cannot perform inverse palette lookup\n");
1130 HeapFree(GetProcessHeap(), 0, mem);
1134 for(y = local_rect.top; y < local_rect.bottom; y++) {
1135 for(x = local_rect.left; x < local_rect.right; x++) {
1136 /* start lines pixels */
1137 const BYTE *blue = mem + y * pitch + x * (sizeof(BYTE) * 3);
1138 const BYTE *green = blue + 1;
1139 const BYTE *red = green + 1;
1141 for(c = 0; c < 256; c++) {
1142 if(*red == pal[c].peRed &&
1143 *green == pal[c].peGreen &&
1144 *blue == pal[c].peBlue)
1146 *((BYTE *) dest + y * width + x) = c;
1152 HeapFree(GetProcessHeap(), 0, mem);
1156 /* Read the framebuffer contents into a texture */
1157 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl *This, BOOL srgb)
1159 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1160 IWineD3DSwapChainImpl *swapchain;
1162 GLenum format, internal, type;
1163 CONVERT_TYPES convert;
1165 BOOL alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
1167 d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb);
1169 /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
1170 * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
1171 * states in the stateblock, and no driver was found yet that had bugs in that regard.
1173 ActivateContext(device, (IWineD3DSurface *) This, CTXUSAGE_RESOURCELOAD);
1174 surface_bind_and_dirtify(This, srgb);
1177 glGetIntegerv(GL_READ_BUFFER, &prevRead);
1180 /* Select the correct read buffer, and give some debug output.
1181 * There is no need to keep track of the current read buffer or reset it, every part of the code
1182 * that reads sets the read buffer as desired.
1184 if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)This, &IID_IWineD3DSwapChain, (void **)&swapchain)))
1186 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
1187 TRACE("Locking %#x buffer\n", buffer);
1190 glReadBuffer(buffer);
1191 checkGLcall("glReadBuffer");
1194 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
1196 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
1197 * Read from the back buffer
1199 TRACE("Locking offscreen render target\n");
1201 glReadBuffer(device->offscreenBuffer);
1202 checkGLcall("glReadBuffer");
1206 if(!(This->Flags & alloc_flag)) {
1207 surface_allocate_surface(This, internal, This->pow2Width,
1208 This->pow2Height, format, type);
1209 This->Flags |= alloc_flag;
1213 /* If !SrcIsUpsideDown we should flip the surface.
1214 * This can be done using glCopyTexSubImage2D but this
1215 * is VERY slow, so don't do that. We should prevent
1216 * this code from getting called in such cases or perhaps
1217 * we can use FBOs */
1219 glCopyTexSubImage2D(This->glDescription.target,
1220 This->glDescription.level,
1222 This->currentDesc.Width,
1223 This->currentDesc.Height);
1224 checkGLcall("glCopyTexSubImage2D");
1226 glReadBuffer(prevRead);
1227 checkGLcall("glReadBuffer");
1230 TRACE("Updated target %d\n", This->glDescription.target);
1233 static void surface_prepare_system_memory(IWineD3DSurfaceImpl *This) {
1234 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
1235 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
1238 if(!(This->Flags & SFLAG_DYNLOCK)) {
1240 /* MAXLOCKCOUNT is defined in wined3d_private.h */
1241 if(This->lockCount > MAXLOCKCOUNT) {
1242 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
1243 This->Flags |= SFLAG_DYNLOCK;
1247 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
1248 * Also don't create a PBO for systemmem surfaces.
1250 if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT) && (This->Flags & SFLAG_DYNLOCK) && !(This->Flags & (SFLAG_PBO | SFLAG_CONVERTED | SFLAG_NONPOW2)) && (This->resource.pool != WINED3DPOOL_SYSTEMMEM)) {
1252 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1254 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1257 GL_EXTCALL(glGenBuffersARB(1, &This->pbo));
1258 error = glGetError();
1259 if(This->pbo == 0 || error != GL_NO_ERROR) {
1260 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error), error);
1263 TRACE("Attaching pbo=%#x to (%p)\n", This->pbo, This);
1265 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1266 checkGLcall("glBindBufferARB");
1268 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->resource.size + 4, This->resource.allocatedMemory, GL_STREAM_DRAW_ARB));
1269 checkGLcall("glBufferDataARB");
1271 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1272 checkGLcall("glBindBufferARB");
1274 /* We don't need the system memory anymore and we can't even use it for PBOs */
1275 if(!(This->Flags & SFLAG_CLIENT)) {
1276 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
1277 This->resource.heapMemory = NULL;
1279 This->resource.allocatedMemory = NULL;
1280 This->Flags |= SFLAG_PBO;
1282 } else if(!(This->resource.allocatedMemory || This->Flags & SFLAG_PBO)) {
1283 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
1286 if(!This->resource.heapMemory) {
1287 This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
1289 This->resource.allocatedMemory =
1290 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1291 if(This->Flags & SFLAG_INSYSMEM) {
1292 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1297 static HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
1298 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1299 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
1300 const RECT *pass_rect = pRect;
1302 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This, pRect, Flags, pLockedRect, This->resource.allocatedMemory);
1304 /* This is also done in the base class, but we have to verify this before loading any data from
1305 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1306 * may interfere, and all other bad things may happen
1308 if (This->Flags & SFLAG_LOCKED) {
1309 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1310 return WINED3DERR_INVALIDCALL;
1312 This->Flags |= SFLAG_LOCKED;
1314 if (!(This->Flags & SFLAG_LOCKABLE))
1316 TRACE("Warning: trying to lock unlockable surf@%p\n", This);
1319 if (Flags & WINED3DLOCK_DISCARD) {
1320 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
1321 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
1322 surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1323 This->Flags |= SFLAG_INSYSMEM;
1327 if (This->Flags & SFLAG_INSYSMEM) {
1328 TRACE("Local copy is up to date, not downloading data\n");
1329 surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1333 /* IWineD3DSurface_LoadLocation() does not check if the rectangle specifies
1334 * the full surface. Most callers don't need that, so do it here. */
1335 if (pRect && pRect->top == 0 && pRect->left == 0
1336 && pRect->right == This->currentDesc.Width
1337 && pRect->bottom == This->currentDesc.Height)
1342 if (!(wined3d_settings.rendertargetlock_mode == RTL_DISABLE
1343 && ((This->Flags & SFLAG_SWAPCHAIN) || iface == myDevice->render_targets[0])))
1345 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, pass_rect);
1349 if(This->Flags & SFLAG_PBO) {
1350 ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1352 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1353 checkGLcall("glBindBufferARB");
1355 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1356 if(This->resource.allocatedMemory) {
1357 ERR("The surface already has PBO memory allocated!\n");
1360 This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1361 checkGLcall("glMapBufferARB");
1363 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1364 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1365 checkGLcall("glBindBufferARB");
1370 if (Flags & (WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY)) {
1373 IWineD3DBaseTexture *pBaseTexture;
1376 * as seen in msdn docs
1378 surface_add_dirty_rect(iface, pRect);
1380 /** Dirtify Container if needed */
1381 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&pBaseTexture))) {
1382 TRACE("Making container dirty\n");
1383 IWineD3DBaseTexture_SetDirty(pBaseTexture, TRUE);
1384 IWineD3DBaseTexture_Release(pBaseTexture);
1386 TRACE("Surface is standalone, no need to dirty the container\n");
1390 return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
1393 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This, GLenum fmt, GLenum type, UINT bpp, const BYTE *mem) {
1395 GLint prev_rasterpos[4];
1396 GLint skipBytes = 0;
1397 UINT pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This); /* target is argb, 4 byte */
1398 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
1399 IWineD3DSwapChainImpl *swapchain;
1401 /* Activate the correct context for the render target */
1402 ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
1405 if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)This, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
1406 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
1407 TRACE("Unlocking %#x buffer\n", buffer);
1408 glDrawBuffer(buffer);
1409 checkGLcall("glDrawBuffer");
1411 IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
1413 /* Primary offscreen render target */
1414 TRACE("Offscreen render target\n");
1415 glDrawBuffer(myDevice->offscreenBuffer);
1416 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1419 glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
1420 checkGLcall("glIntegerv");
1421 glGetIntegerv(GL_CURRENT_RASTER_POSITION, &prev_rasterpos[0]);
1422 checkGLcall("glIntegerv");
1423 glPixelZoom(1.0, -1.0);
1424 checkGLcall("glPixelZoom");
1426 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
1427 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &skipBytes);
1428 glPixelStorei(GL_UNPACK_ROW_LENGTH, This->currentDesc.Width);
1430 glRasterPos3i(This->lockedRect.left, This->lockedRect.top, 1);
1431 checkGLcall("glRasterPos2f");
1433 /* Some drivers(radeon dri, others?) don't like exceptions during
1434 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
1435 * after ReleaseDC. Reading it will cause an exception, which x11drv will
1436 * catch to put the dib section in InSync mode, which leads to a crash
1437 * and a blocked x server on my radeon card.
1439 * The following lines read the dib section so it is put in InSync mode
1440 * before glDrawPixels is called and the crash is prevented. There won't
1441 * be any interfering gdi accesses, because UnlockRect is called from
1442 * ReleaseDC, and the app won't use the dc any more afterwards.
1444 if((This->Flags & SFLAG_DIBSECTION) && !(This->Flags & SFLAG_PBO)) {
1446 read = This->resource.allocatedMemory[0];
1449 if(This->Flags & SFLAG_PBO) {
1450 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1451 checkGLcall("glBindBufferARB");
1454 /* When the surface is locked we only have to refresh the locked part else we need to update the whole image */
1455 if(This->Flags & SFLAG_LOCKED) {
1456 glDrawPixels(This->lockedRect.right - This->lockedRect.left,
1457 (This->lockedRect.bottom - This->lockedRect.top)-1,
1459 mem + bpp * This->lockedRect.left + pitch * This->lockedRect.top);
1460 checkGLcall("glDrawPixels");
1462 glDrawPixels(This->currentDesc.Width,
1463 This->currentDesc.Height,
1465 checkGLcall("glDrawPixels");
1468 if(This->Flags & SFLAG_PBO) {
1469 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1470 checkGLcall("glBindBufferARB");
1473 glPixelZoom(1.0,1.0);
1474 checkGLcall("glPixelZoom");
1476 glRasterPos3iv(&prev_rasterpos[0]);
1477 checkGLcall("glRasterPos3iv");
1479 /* Reset to previous pack row length */
1480 glPixelStorei(GL_UNPACK_ROW_LENGTH, skipBytes);
1481 checkGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1484 glDrawBuffer(myDevice->offscreenBuffer);
1485 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1486 } else if(swapchain->backBuffer) {
1487 glDrawBuffer(GL_BACK);
1488 checkGLcall("glDrawBuffer(GL_BACK)");
1490 glDrawBuffer(GL_FRONT);
1491 checkGLcall("glDrawBuffer(GL_FRONT)");
1498 static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) {
1499 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1500 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
1503 if (!(This->Flags & SFLAG_LOCKED)) {
1504 WARN("trying to Unlock an unlocked surf@%p\n", This);
1505 return WINEDDERR_NOTLOCKED;
1508 if (This->Flags & SFLAG_PBO) {
1509 TRACE("Freeing PBO memory\n");
1510 ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1512 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1513 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1514 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1515 checkGLcall("glUnmapBufferARB");
1517 This->resource.allocatedMemory = NULL;
1520 TRACE("(%p) : dirtyfied(%d)\n", This, This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
1522 if (This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE)) {
1523 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This);
1527 if ((This->Flags & SFLAG_SWAPCHAIN) || (myDevice->render_targets && iface == myDevice->render_targets[0]))
1529 if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1530 static BOOL warned = FALSE;
1532 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1538 if(This->dirtyRect.left == 0 &&
1539 This->dirtyRect.top == 0 &&
1540 This->dirtyRect.right == This->currentDesc.Width &&
1541 This->dirtyRect.bottom == This->currentDesc.Height) {
1544 /* TODO: Proper partial rectangle tracking */
1545 fullsurface = FALSE;
1546 This->Flags |= SFLAG_INSYSMEM;
1549 switch(wined3d_settings.rendertargetlock_mode) {
1552 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL /* partial texture loading not supported yet */);
1558 IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, fullsurface ? NULL : &This->dirtyRect);
1563 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1564 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1565 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1566 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1567 * not fully up to date because only a subrectangle was read in LockRect.
1569 This->Flags &= ~SFLAG_INSYSMEM;
1570 This->Flags |= SFLAG_INDRAWABLE;
1573 This->dirtyRect.left = This->currentDesc.Width;
1574 This->dirtyRect.top = This->currentDesc.Height;
1575 This->dirtyRect.right = 0;
1576 This->dirtyRect.bottom = 0;
1577 } else if(iface == myDevice->stencilBufferTarget) {
1578 FIXME("Depth Stencil buffer locking is not implemented\n");
1580 /* The rest should be a normal texture */
1581 IWineD3DBaseTextureImpl *impl;
1582 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1583 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1584 * states need resetting
1586 if(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&impl) == WINED3D_OK) {
1587 if(impl->baseTexture.bindCount) {
1588 IWineD3DDeviceImpl_MarkStateDirty(myDevice, STATE_SAMPLER(impl->baseTexture.sampler));
1590 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *) impl);
1595 This->Flags &= ~SFLAG_LOCKED;
1596 memset(&This->lockedRect, 0, sizeof(RECT));
1598 /* Overlays have to be redrawn manually after changes with the GL implementation */
1599 if(This->overlay_dest) {
1600 IWineD3DSurface_DrawOverlay(iface);
1605 static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC)
1607 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1608 WINED3DLOCKED_RECT lock;
1612 TRACE("(%p)->(%p)\n",This,pHDC);
1614 if(This->Flags & SFLAG_USERPTR) {
1615 ERR("Not supported on surfaces with an application-provided surfaces\n");
1616 return WINEDDERR_NODC;
1619 /* Give more detailed info for ddraw */
1620 if (This->Flags & SFLAG_DCINUSE)
1621 return WINEDDERR_DCALREADYCREATED;
1623 /* Can't GetDC if the surface is locked */
1624 if (This->Flags & SFLAG_LOCKED)
1625 return WINED3DERR_INVALIDCALL;
1627 /* According to Direct3D9 docs, only these formats are supported */
1628 if (((IWineD3DImpl *)This->resource.wineD3DDevice->wineD3D)->dxVersion > 7) {
1629 if (This->resource.format_desc->format != WINED3DFMT_R5G6B5
1630 && This->resource.format_desc->format != WINED3DFMT_X1R5G5B5
1631 && This->resource.format_desc->format != WINED3DFMT_R8G8B8
1632 && This->resource.format_desc->format != WINED3DFMT_X8R8G8B8)
1633 return WINED3DERR_INVALIDCALL;
1636 memset(&lock, 0, sizeof(lock)); /* To be sure */
1638 /* Create a DIB section if there isn't a hdc yet */
1640 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
1641 if(This->Flags & SFLAG_CLIENT) {
1642 surface_internal_preload(iface, SRGB_RGB);
1645 /* Use the dib section from now on if we are not using a PBO */
1646 if(!(This->Flags & SFLAG_PBO))
1647 This->resource.allocatedMemory = This->dib.bitmap_data;
1650 /* Lock the surface */
1651 hr = IWineD3DSurface_LockRect(iface,
1656 if(This->Flags & SFLAG_PBO) {
1657 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1658 memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
1662 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
1663 /* keep the dib section */
1667 if (This->resource.format_desc->format == WINED3DFMT_P8
1668 || This->resource.format_desc->format == WINED3DFMT_A8P8)
1670 /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
1671 D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
1673 const PALETTEENTRY *pal = NULL;
1676 pal = This->palette->palents;
1678 IWineD3DSurfaceImpl *dds_primary;
1679 IWineD3DSwapChainImpl *swapchain;
1680 swapchain = (IWineD3DSwapChainImpl *)This->resource.wineD3DDevice->swapchains[0];
1681 dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
1682 if (dds_primary && dds_primary->palette)
1683 pal = dds_primary->palette->palents;
1687 for (n=0; n<256; n++) {
1688 col[n].rgbRed = pal[n].peRed;
1689 col[n].rgbGreen = pal[n].peGreen;
1690 col[n].rgbBlue = pal[n].peBlue;
1691 col[n].rgbReserved = 0;
1693 SetDIBColorTable(This->hDC, 0, 256, col);
1698 TRACE("returning %p\n",*pHDC);
1699 This->Flags |= SFLAG_DCINUSE;
1704 static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC)
1706 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1708 TRACE("(%p)->(%p)\n",This,hDC);
1710 if (!(This->Flags & SFLAG_DCINUSE))
1711 return WINEDDERR_NODC;
1713 if (This->hDC !=hDC) {
1714 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
1715 return WINEDDERR_NODC;
1718 if((This->Flags & SFLAG_PBO) && This->resource.allocatedMemory) {
1719 /* Copy the contents of the DIB over to the PBO */
1720 memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
1723 /* we locked first, so unlock now */
1724 IWineD3DSurface_UnlockRect(iface);
1726 This->Flags &= ~SFLAG_DCINUSE;
1731 /* ******************************************************
1732 IWineD3DSurface Internal (No mapping to directx api) parts follow
1733 ****************************************************** */
1735 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) {
1736 BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
1737 const struct GlPixelFormatDesc *glDesc = This->resource.format_desc;
1738 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1740 /* Default values: From the surface */
1741 *format = glDesc->glFormat;
1742 *type = glDesc->glType;
1743 *convert = NO_CONVERSION;
1744 *target_bpp = glDesc->byte_count;
1747 *internal = glDesc->glGammaInternal;
1749 else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET
1750 && !(This->Flags & SFLAG_SWAPCHAIN))
1752 *internal = glDesc->rtInternal;
1754 *internal = glDesc->glInternal;
1757 /* Ok, now look if we have to do any conversion */
1758 switch(This->resource.format_desc->format)
1765 /* Use conversion when the paletted texture extension OR fragment shaders are available. When either
1766 * of the two is available make sure texturing is requested as neither of the two works in
1767 * conjunction with calls like glDraw-/glReadPixels. Further also use conversion in case of color keying.
1768 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
1769 * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
1770 * conflicts with this.
1772 if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE) ||
1773 (GL_SUPPORT(ARB_FRAGMENT_PROGRAM) &&
1774 device->render_targets &&
1775 This == (IWineD3DSurfaceImpl*)device->render_targets[0])) ||
1776 colorkey_active || !use_texturing ) {
1778 *internal = GL_RGBA;
1779 *type = GL_UNSIGNED_BYTE;
1781 if(colorkey_active) {
1782 *convert = CONVERT_PALETTED_CK;
1784 *convert = CONVERT_PALETTED;
1787 else if(!GL_SUPPORT(EXT_PALETTED_TEXTURE) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
1789 *type = GL_UNSIGNED_BYTE;
1795 case WINED3DFMT_R3G3B2:
1796 /* **********************
1797 GL_UNSIGNED_BYTE_3_3_2
1798 ********************** */
1799 if (colorkey_active) {
1800 /* This texture format will never be used.. So do not care about color keying
1801 up until the point in time it will be needed :-) */
1802 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1806 case WINED3DFMT_R5G6B5:
1807 if (colorkey_active) {
1808 *convert = CONVERT_CK_565;
1810 *internal = GL_RGB5_A1;
1811 *type = GL_UNSIGNED_SHORT_5_5_5_1;
1815 case WINED3DFMT_X1R5G5B5:
1816 if (colorkey_active) {
1817 *convert = CONVERT_CK_5551;
1819 *internal = GL_RGB5_A1;
1820 *type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1824 case WINED3DFMT_R8G8B8:
1825 if (colorkey_active) {
1826 *convert = CONVERT_CK_RGB24;
1828 *internal = GL_RGBA8;
1829 *type = GL_UNSIGNED_INT_8_8_8_8;
1834 case WINED3DFMT_X8R8G8B8:
1835 if (colorkey_active) {
1836 *convert = CONVERT_RGB32_888;
1838 *internal = GL_RGBA8;
1839 *type = GL_UNSIGNED_INT_8_8_8_8;
1843 case WINED3DFMT_R8G8_SNORM:
1844 if (GL_SUPPORT(NV_TEXTURE_SHADER)) break;
1845 *convert = CONVERT_V8U8;
1847 *type = GL_UNSIGNED_BYTE;
1851 case WINED3DFMT_L6V5U5:
1852 *convert = CONVERT_L6V5U5;
1853 if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1855 /* Use format and types from table */
1857 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1860 *type = GL_UNSIGNED_SHORT_5_6_5;
1864 case WINED3DFMT_X8L8V8U8:
1865 *convert = CONVERT_X8L8V8U8;
1867 if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1868 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1869 * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1870 * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1871 * the needed type and format parameter, so the internal format contains a
1872 * 4th component, which is returned as alpha
1876 *type = GL_UNSIGNED_INT_8_8_8_8_REV;
1880 case WINED3DFMT_R8G8B8A8_SNORM:
1881 if (GL_SUPPORT(NV_TEXTURE_SHADER)) break;
1882 *convert = CONVERT_Q8W8V8U8;
1884 *type = GL_UNSIGNED_BYTE;
1888 case WINED3DFMT_R16G16_SNORM:
1889 if (GL_SUPPORT(NV_TEXTURE_SHADER)) break;
1890 *convert = CONVERT_V16U16;
1892 *type = GL_UNSIGNED_SHORT;
1896 case WINED3DFMT_A4L4:
1897 /* A4L4 exists as an internal gl format, but for some reason there is not
1898 * format+type combination to load it. Thus convert it to A8L8, then load it
1899 * with A4L4 internal, but A8L8 format+type
1901 *convert = CONVERT_A4L4;
1902 *format = GL_LUMINANCE_ALPHA;
1903 *type = GL_UNSIGNED_BYTE;
1907 case WINED3DFMT_R16G16_UNORM:
1908 *convert = CONVERT_G16R16;
1910 *type = GL_UNSIGNED_SHORT;
1914 case WINED3DFMT_R16G16_FLOAT:
1915 *convert = CONVERT_R16G16F;
1917 *type = GL_HALF_FLOAT_ARB;
1921 case WINED3DFMT_R32G32_FLOAT:
1922 *convert = CONVERT_R32G32F;
1928 case WINED3DFMT_D15S1:
1929 if (GL_SUPPORT(EXT_PACKED_DEPTH_STENCIL))
1931 *convert = CONVERT_D15S1;
1936 case WINED3DFMT_D24X4S4:
1937 if (GL_SUPPORT(EXT_PACKED_DEPTH_STENCIL))
1939 *convert = CONVERT_D24X4S4;
1943 case WINED3DFMT_D24FS8:
1944 if (GL_SUPPORT(ARB_DEPTH_BUFFER_FLOAT))
1946 *convert = CONVERT_D24FS8;
1958 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey)
1960 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1961 IWineD3DPaletteImpl *pal = This->palette;
1962 BOOL index_in_alpha = FALSE;
1965 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
1966 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
1967 * is slow. Further RGB->P8 conversion is not possible because palettes can have
1968 * duplicate entries. Store the color key in the unused alpha component to speed the
1969 * download up and to make conversion unneeded. */
1970 index_in_alpha = primary_render_target_is_p8(device);
1974 UINT dxVersion = ((IWineD3DImpl *)device->wineD3D)->dxVersion;
1976 /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
1979 ERR("This code should never get entered for DirectDraw!, expect problems\n");
1982 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
1983 * there's no palette at this time. */
1984 for (i = 0; i < 256; i++) table[i][3] = i;
1989 /* Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
1990 * alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
1991 * capability flag is present (wine does advertise this capability) */
1992 for (i = 0; i < 256; ++i)
1994 table[i][0] = device->palettes[device->currentPalette][i].peRed;
1995 table[i][1] = device->palettes[device->currentPalette][i].peGreen;
1996 table[i][2] = device->palettes[device->currentPalette][i].peBlue;
1997 table[i][3] = device->palettes[device->currentPalette][i].peFlags;
2003 TRACE("Using surface palette %p\n", pal);
2004 /* Get the surface's palette */
2005 for (i = 0; i < 256; ++i)
2007 table[i][0] = pal->palents[i].peRed;
2008 table[i][1] = pal->palents[i].peGreen;
2009 table[i][2] = pal->palents[i].peBlue;
2011 /* When index_in_alpha is set the palette index is stored in the
2012 * alpha component. In case of a readback we can then read
2013 * GL_ALPHA. Color keying is handled in BltOverride using a
2014 * GL_ALPHA_TEST using GL_NOT_EQUAL. In case of index_in_alpha the
2015 * color key itself is passed to glAlphaFunc in other cases the
2016 * alpha component of pixels that should be masked away is set to 0. */
2021 else if (colorkey && (i >= This->SrcBltCKey.dwColorSpaceLowValue)
2022 && (i <= This->SrcBltCKey.dwColorSpaceHighValue))
2026 else if(pal->Flags & WINEDDPCAPS_ALPHA)
2028 table[i][3] = pal->palents[i].peFlags;
2038 static HRESULT d3dfmt_convert_surface(const BYTE *src, BYTE *dst, UINT pitch, UINT width,
2039 UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This)
2043 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
2048 memcpy(dst, src, pitch * height);
2051 case CONVERT_PALETTED:
2052 case CONVERT_PALETTED_CK:
2054 IWineD3DPaletteImpl* pal = This->palette;
2059 /* TODO: If we are a sublevel, try to get the palette from level 0 */
2062 d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
2064 for (y = 0; y < height; y++)
2066 source = src + pitch * y;
2067 dest = dst + outpitch * y;
2068 /* This is an 1 bpp format, using the width here is fine */
2069 for (x = 0; x < width; x++) {
2070 BYTE color = *source++;
2071 *dest++ = table[color][0];
2072 *dest++ = table[color][1];
2073 *dest++ = table[color][2];
2074 *dest++ = table[color][3];
2080 case CONVERT_CK_565:
2082 /* Converting the 565 format in 5551 packed to emulate color-keying.
2084 Note : in all these conversion, it would be best to average the averaging
2085 pixels to get the color of the pixel that will be color-keyed to
2086 prevent 'color bleeding'. This will be done later on if ever it is
2089 Note2: Nvidia documents say that their driver does not support alpha + color keying
2090 on the same surface and disables color keying in such a case
2096 TRACE("Color keyed 565\n");
2098 for (y = 0; y < height; y++) {
2099 Source = (const WORD *)(src + y * pitch);
2100 Dest = (WORD *) (dst + y * outpitch);
2101 for (x = 0; x < width; x++ ) {
2102 WORD color = *Source++;
2103 *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
2104 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2105 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2114 case CONVERT_CK_5551:
2116 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
2120 TRACE("Color keyed 5551\n");
2121 for (y = 0; y < height; y++) {
2122 Source = (const WORD *)(src + y * pitch);
2123 Dest = (WORD *) (dst + y * outpitch);
2124 for (x = 0; x < width; x++ ) {
2125 WORD color = *Source++;
2127 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2128 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2132 *Dest &= ~(1 << 15);
2140 case CONVERT_CK_RGB24:
2142 /* Converting R8G8B8 format to R8G8B8A8 with color-keying. */
2144 for (y = 0; y < height; y++)
2146 source = src + pitch * y;
2147 dest = dst + outpitch * y;
2148 for (x = 0; x < width; x++) {
2149 DWORD color = ((DWORD)source[0] << 16) + ((DWORD)source[1] << 8) + (DWORD)source[2] ;
2150 DWORD dstcolor = color << 8;
2151 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2152 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2155 *(DWORD*)dest = dstcolor;
2163 case CONVERT_RGB32_888:
2165 /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
2167 for (y = 0; y < height; y++)
2169 source = src + pitch * y;
2170 dest = dst + outpitch * y;
2171 for (x = 0; x < width; x++) {
2172 DWORD color = 0xffffff & *(const DWORD*)source;
2173 DWORD dstcolor = color << 8;
2174 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2175 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2178 *(DWORD*)dest = dstcolor;
2189 const short *Source;
2190 unsigned char *Dest;
2191 for(y = 0; y < height; y++) {
2192 Source = (const short *)(src + y * pitch);
2193 Dest = dst + y * outpitch;
2194 for (x = 0; x < width; x++ ) {
2195 long color = (*Source++);
2196 /* B */ Dest[0] = 0xff;
2197 /* G */ Dest[1] = (color >> 8) + 128; /* V */
2198 /* R */ Dest[2] = (color) + 128; /* U */
2205 case CONVERT_V16U16:
2208 const DWORD *Source;
2209 unsigned short *Dest;
2210 for(y = 0; y < height; y++) {
2211 Source = (const DWORD *)(src + y * pitch);
2212 Dest = (unsigned short *) (dst + y * outpitch);
2213 for (x = 0; x < width; x++ ) {
2214 DWORD color = (*Source++);
2215 /* B */ Dest[0] = 0xffff;
2216 /* G */ Dest[1] = (color >> 16) + 32768; /* V */
2217 /* R */ Dest[2] = (color ) + 32768; /* U */
2224 case CONVERT_Q8W8V8U8:
2227 const DWORD *Source;
2228 unsigned char *Dest;
2229 for(y = 0; y < height; y++) {
2230 Source = (const DWORD *)(src + y * pitch);
2231 Dest = dst + y * outpitch;
2232 for (x = 0; x < width; x++ ) {
2233 long color = (*Source++);
2234 /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
2235 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
2236 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
2237 /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
2244 case CONVERT_L6V5U5:
2248 unsigned char *Dest;
2250 if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
2251 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
2252 * fixed function and shaders without further conversion once the surface is
2255 for(y = 0; y < height; y++) {
2256 Source = (const WORD *)(src + y * pitch);
2257 Dest = dst + y * outpitch;
2258 for (x = 0; x < width; x++ ) {
2259 short color = (*Source++);
2260 unsigned char l = ((color >> 10) & 0xfc);
2261 char v = ((color >> 5) & 0x3e);
2262 char u = ((color ) & 0x1f);
2264 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
2265 * and doubles the positive range. Thus shift left only once, gl does the 2nd
2266 * shift. GL reads a signed value and converts it into an unsigned value.
2268 /* M */ Dest[2] = l << 1;
2270 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
2271 * from 5 bit values to 8 bit values.
2273 /* V */ Dest[1] = v << 3;
2274 /* U */ Dest[0] = u << 3;
2279 for(y = 0; y < height; y++) {
2280 unsigned short *Dest_s = (unsigned short *) (dst + y * outpitch);
2281 Source = (const WORD *)(src + y * pitch);
2282 for (x = 0; x < width; x++ ) {
2283 short color = (*Source++);
2284 unsigned char l = ((color >> 10) & 0xfc);
2285 short v = ((color >> 5) & 0x3e);
2286 short u = ((color ) & 0x1f);
2287 short v_conv = v + 16;
2288 short u_conv = u + 16;
2290 *Dest_s = ((v_conv << 11) & 0xf800) | ((l << 5) & 0x7e0) | (u_conv & 0x1f);
2298 case CONVERT_X8L8V8U8:
2301 const DWORD *Source;
2302 unsigned char *Dest;
2304 if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
2305 /* This implementation works with the fixed function pipeline and shaders
2306 * without further modification after converting the surface.
2308 for(y = 0; y < height; y++) {
2309 Source = (const DWORD *)(src + y * pitch);
2310 Dest = dst + y * outpitch;
2311 for (x = 0; x < width; x++ ) {
2312 long color = (*Source++);
2313 /* L */ Dest[2] = ((color >> 16) & 0xff); /* L */
2314 /* V */ Dest[1] = ((color >> 8 ) & 0xff); /* V */
2315 /* U */ Dest[0] = (color & 0xff); /* U */
2316 /* I */ Dest[3] = 255; /* X */
2321 /* Doesn't work correctly with the fixed function pipeline, but can work in
2322 * shaders if the shader is adjusted. (There's no use for this format in gl's
2323 * standard fixed function pipeline anyway).
2325 for(y = 0; y < height; y++) {
2326 Source = (const DWORD *)(src + y * pitch);
2327 Dest = dst + y * outpitch;
2328 for (x = 0; x < width; x++ ) {
2329 long color = (*Source++);
2330 /* B */ Dest[0] = ((color >> 16) & 0xff); /* L */
2331 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
2332 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
2343 const unsigned char *Source;
2344 unsigned char *Dest;
2345 for(y = 0; y < height; y++) {
2346 Source = src + y * pitch;
2347 Dest = dst + y * outpitch;
2348 for (x = 0; x < width; x++ ) {
2349 unsigned char color = (*Source++);
2350 /* A */ Dest[1] = (color & 0xf0) << 0;
2351 /* L */ Dest[0] = (color & 0x0f) << 4;
2358 case CONVERT_G16R16:
2359 case CONVERT_R16G16F:
2365 for(y = 0; y < height; y++) {
2366 Source = (const WORD *)(src + y * pitch);
2367 Dest = (WORD *) (dst + y * outpitch);
2368 for (x = 0; x < width; x++ ) {
2369 WORD green = (*Source++);
2370 WORD red = (*Source++);
2373 /* Strictly speaking not correct for R16G16F, but it doesn't matter because the
2374 * shader overwrites it anyway
2383 case CONVERT_R32G32F:
2386 const float *Source;
2388 for(y = 0; y < height; y++) {
2389 Source = (const float *)(src + y * pitch);
2390 Dest = (float *) (dst + y * outpitch);
2391 for (x = 0; x < width; x++ ) {
2392 float green = (*Source++);
2393 float red = (*Source++);
2407 for (y = 0; y < height; ++y)
2409 const WORD *source = (const WORD *)(src + y * pitch);
2410 DWORD *dest = (DWORD *)(dst + y * outpitch);
2412 for (x = 0; x < width; ++x)
2414 /* The depth data is normalized, so needs to be scaled,
2415 * the stencil data isn't. Scale depth data by
2416 * (2^24-1)/(2^15-1) ~~ (2^9 + 2^-6). */
2417 WORD d15 = source[x] >> 1;
2418 DWORD d24 = (d15 << 9) + (d15 >> 6);
2419 dest[x] = (d24 << 8) | (source[x] & 0x1);
2425 case CONVERT_D24X4S4:
2429 for (y = 0; y < height; ++y)
2431 const DWORD *source = (const DWORD *)(src + y * pitch);
2432 DWORD *dest = (DWORD *)(dst + y * outpitch);
2434 for (x = 0; x < width; ++x)
2436 /* Just need to clear out the X4 part. */
2437 dest[x] = source[x] & ~0xf0;
2443 case CONVERT_D24FS8:
2447 for (y = 0; y < height; ++y)
2449 const DWORD *source = (const DWORD *)(src + y * pitch);
2450 float *dest_f = (float *)(dst + y * outpitch);
2451 DWORD *dest_s = (DWORD *)(dst + y * outpitch);
2453 for (x = 0; x < width; ++x)
2455 dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00) >> 8);
2456 dest_s[x * 2 + 1] = source[x] & 0xff;
2463 ERR("Unsupported conversion type %#x.\n", convert);
2468 /* This function is used in case of 8bit paletted textures to upload the palette.
2469 It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
2470 extensions like ATI_fragment_shaders is possible.
2472 static void d3dfmt_p8_upload_palette(IWineD3DSurface *iface, CONVERT_TYPES convert) {
2473 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2475 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2477 d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
2479 /* Try to use the paletted texture extension */
2480 if(GL_SUPPORT(EXT_PALETTED_TEXTURE))
2482 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2484 GL_EXTCALL(glColorTableEXT(This->glDescription.target,GL_RGBA,256,GL_RGBA,GL_UNSIGNED_BYTE, table));
2489 /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2490 * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2491 TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2495 /* Create the fragment program if we don't have it */
2496 if(!device->paletteConversionShader)
2498 const char *fragment_palette_conversion =
2501 /* { 255/256, 0.5/255*255/256, 0, 0 } */
2502 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n"
2503 /* The alpha-component contains the palette index */
2504 "TEX index, fragment.texcoord[0], texture[0], 2D;\n"
2505 /* Scale the index by 255/256 and add a bias of '0.5' in order to sample in the middle */
2506 "MAD index.a, index.a, constants.x, constants.y;\n"
2507 /* Use the alpha-component as an index in the palette to get the final color */
2508 "TEX result.color, index.a, texture[1], 1D;\n"
2511 glEnable(GL_FRAGMENT_PROGRAM_ARB);
2512 GL_EXTCALL(glGenProgramsARB(1, &device->paletteConversionShader));
2513 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, device->paletteConversionShader));
2514 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(fragment_palette_conversion), fragment_palette_conversion));
2515 glDisable(GL_FRAGMENT_PROGRAM_ARB);
2518 glEnable(GL_FRAGMENT_PROGRAM_ARB);
2519 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, device->paletteConversionShader));
2521 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1));
2522 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2524 glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2525 glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); /* Make sure we have discrete color levels. */
2526 glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2527 glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, table); /* Upload the palette */
2529 /* Switch back to unit 0 in which the 2D texture will be stored. */
2530 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0));
2532 /* Rebind the texture because it isn't bound anymore */
2533 glBindTexture(This->glDescription.target, This->glDescription.textureName);
2539 BOOL palette9_changed(IWineD3DSurfaceImpl *This) {
2540 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2542 if (This->palette || (This->resource.format_desc->format != WINED3DFMT_P8
2543 && This->resource.format_desc->format != WINED3DFMT_A8P8))
2545 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2546 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2551 if(This->palette9) {
2552 if(memcmp(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256) == 0) {
2556 This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2558 memcpy(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
2562 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) {
2563 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2564 DWORD flag = srgb_mode ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE;
2566 if (!(This->Flags & flag)) {
2567 TRACE("Reloading because surface is dirty\n");
2568 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2569 ((This->Flags & SFLAG_GLCKEY) && (!(This->CKeyFlags & WINEDDSD_CKSRCBLT))) ||
2570 /* Reload: vice versa OR */
2571 ((!(This->Flags & SFLAG_GLCKEY)) && (This->CKeyFlags & WINEDDSD_CKSRCBLT)) ||
2572 /* Also reload: Color key is active AND the color key has changed */
2573 ((This->CKeyFlags & WINEDDSD_CKSRCBLT) && (
2574 (This->glCKey.dwColorSpaceLowValue != This->SrcBltCKey.dwColorSpaceLowValue) ||
2575 (This->glCKey.dwColorSpaceHighValue != This->SrcBltCKey.dwColorSpaceHighValue)))) {
2576 TRACE("Reloading because of color keying\n");
2577 /* To perform the color key conversion we need a sysmem copy of
2578 * the surface. Make sure we have it
2581 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
2582 /* Make sure the texture is reloaded because of the color key change, this kills performance though :( */
2583 /* TODO: This is not necessarily needed with hw palettized texture support */
2584 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2586 TRACE("surface is already in texture\n");
2590 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2591 * These resources are not bound by device size or format restrictions. Because of this,
2592 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2593 * However, these resources can always be created, locked, and copied.
2595 if (This->resource.pool == WINED3DPOOL_SCRATCH )
2597 FIXME("(%p) Operation not supported for scratch textures\n",This);
2598 return WINED3DERR_INVALIDCALL;
2601 IWineD3DSurface_LoadLocation(iface, flag, NULL /* no partial locking for textures yet */);
2605 static unsigned int gen = 0;
2608 if ((gen % 10) == 0) {
2609 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
2610 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
2613 * debugging crash code
2622 if (!(This->Flags & SFLAG_DONOTFREE)) {
2623 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
2624 This->resource.allocatedMemory = NULL;
2625 This->resource.heapMemory = NULL;
2626 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, FALSE);
2632 static void WINAPI IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface *iface, BOOL srgb) {
2633 /* TODO: check for locks */
2634 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2635 IWineD3DBaseTexture *baseTexture = NULL;
2636 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2638 TRACE("(%p)Checking to see if the container is a base texture\n", This);
2639 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
2640 TRACE("Passing to container\n");
2641 IWineD3DBaseTexture_BindTexture(baseTexture, srgb);
2642 IWineD3DBaseTexture_Release(baseTexture);
2645 TRACE("(%p) : Binding surface\n", This);
2647 name = srgb ? &This->glDescription.srgbTextureName : &This->glDescription.textureName;
2648 if(!device->isInDraw) {
2649 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
2654 if (!This->glDescription.level) {
2656 glGenTextures(1, name);
2657 checkGLcall("glGenTextures");
2658 TRACE("Surface %p given name %d\n", This, *name);
2660 glBindTexture(This->glDescription.target, *name);
2661 checkGLcall("glBindTexture");
2662 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2663 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)");
2664 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2665 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)");
2666 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2667 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)");
2668 glTexParameteri(This->glDescription.target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2669 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MIN_FILTER, GL_NEAREST)");
2670 glTexParameteri(This->glDescription.target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2671 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MAG_FILTER, GL_NEAREST)");
2673 /* This is where we should be reducing the amount of GLMemoryUsed */
2675 /* Mipmap surfaces should have a base texture container */
2676 ERR("Mipmap surface has a glTexture bound to it!\n");
2679 glBindTexture(This->glDescription.target, *name);
2680 checkGLcall("glBindTexture");
2689 static HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename)
2692 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2693 char *allocatedMemory;
2694 const char *textureRow;
2695 IWineD3DSwapChain *swapChain = NULL;
2696 int width, height, i, y;
2697 GLuint tmpTexture = 0;
2700 Textures may not be stored in ->allocatedgMemory and a GlTexture
2701 so we should lock the surface before saving a snapshot, or at least check that
2703 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2704 by calling GetTexImage and in compressed form by calling
2705 GetCompressedTexImageARB. Queried compressed images can be saved and
2706 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2707 texture images do not need to be processed by the GL and should
2708 significantly improve texture loading performance relative to uncompressed
2711 /* Setup the width and height to be the internal texture width and height. */
2712 width = This->pow2Width;
2713 height = This->pow2Height;
2714 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2715 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapChain);
2717 if (This->Flags & SFLAG_INDRAWABLE && !(This->Flags & SFLAG_INTEXTURE)) {
2718 /* if were not a real texture then read the back buffer into a real texture */
2719 /* we don't want to interfere with the back buffer so read the data into a temporary
2720 * texture and then save the data out of the temporary texture
2724 TRACE("(%p) Reading render target into texture\n", This);
2726 glGenTextures(1, &tmpTexture);
2727 glBindTexture(GL_TEXTURE_2D, tmpTexture);
2729 glTexImage2D(GL_TEXTURE_2D,
2736 GL_UNSIGNED_INT_8_8_8_8_REV,
2739 glGetIntegerv(GL_READ_BUFFER, &prevRead);
2740 checkGLcall("glGetIntegerv");
2741 glReadBuffer(swapChain ? GL_BACK : This->resource.wineD3DDevice->offscreenBuffer);
2742 checkGLcall("glReadBuffer");
2743 glCopyTexImage2D(GL_TEXTURE_2D,
2752 checkGLcall("glCopyTexImage2D");
2753 glReadBuffer(prevRead);
2756 } else { /* bind the real texture, and make sure it up to date */
2757 surface_internal_preload(iface, SRGB_RGB);
2758 surface_bind_and_dirtify(This, FALSE);
2760 allocatedMemory = HeapAlloc(GetProcessHeap(), 0, width * height * 4);
2762 FIXME("Saving texture level %d width %d height %d\n", This->glDescription.level, width, height);
2763 glGetTexImage(GL_TEXTURE_2D,
2764 This->glDescription.level,
2766 GL_UNSIGNED_INT_8_8_8_8_REV,
2768 checkGLcall("glTexImage2D");
2770 glBindTexture(GL_TEXTURE_2D, 0);
2771 glDeleteTextures(1, &tmpTexture);
2775 f = fopen(filename, "w+");
2777 ERR("opening of %s failed with: %s\n", filename, strerror(errno));
2778 return WINED3DERR_INVALIDCALL;
2780 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2781 TRACE("(%p) opened %s with format %s\n", This, filename, debug_d3dformat(This->resource.format_desc->format));
2796 fwrite(&width,2,1,f);
2798 fwrite(&height,2,1,f);
2803 /* 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 */
2805 textureRow = allocatedMemory + (width * (height - 1) *4);
2807 textureRow = allocatedMemory;
2808 for (y = 0 ; y < height; y++) {
2809 for (i = 0; i < width; i++) {
2810 color = *((const DWORD*)textureRow);
2811 fputc((color >> 16) & 0xFF, f); /* B */
2812 fputc((color >> 8) & 0xFF, f); /* G */
2813 fputc((color >> 0) & 0xFF, f); /* R */
2814 fputc((color >> 24) & 0xFF, f); /* A */
2817 /* take two rows of the pointer to the texture memory */
2819 (textureRow-= width << 3);
2822 TRACE("Closing file\n");
2826 IWineD3DSwapChain_Release(swapChain);
2828 HeapFree(GetProcessHeap(), 0, allocatedMemory);
2832 static HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) {
2833 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2836 TRACE("(%p) : Calling base function first\n", This);
2837 hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2839 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2840 TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format_desc->glFormat,
2841 This->resource.format_desc->glInternal, This->resource.format_desc->glType);
2846 static HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2847 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2849 if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
2850 WARN("Surface is locked or the HDC is in use\n");
2851 return WINED3DERR_INVALIDCALL;
2854 if(Mem && Mem != This->resource.allocatedMemory) {
2855 void *release = NULL;
2857 /* Do I have to copy the old surface content? */
2858 if(This->Flags & SFLAG_DIBSECTION) {
2859 /* Release the DC. No need to hold the critical section for the update
2860 * Thread because this thread runs only on front buffers, but this method
2861 * fails for render targets in the check above.
2863 SelectObject(This->hDC, This->dib.holdbitmap);
2864 DeleteDC(This->hDC);
2865 /* Release the DIB section */
2866 DeleteObject(This->dib.DIBsection);
2867 This->dib.bitmap_data = NULL;
2868 This->resource.allocatedMemory = NULL;
2870 This->Flags &= ~SFLAG_DIBSECTION;
2871 } else if(!(This->Flags & SFLAG_USERPTR)) {
2872 release = This->resource.heapMemory;
2873 This->resource.heapMemory = NULL;
2875 This->resource.allocatedMemory = Mem;
2876 This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
2878 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2879 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2881 /* For client textures opengl has to be notified */
2882 if(This->Flags & SFLAG_CLIENT) {
2883 DWORD oldFlags = This->Flags;
2884 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2885 if(oldFlags & SFLAG_ALLOCATED) surface_internal_preload(iface, SRGB_RGB);
2886 if(oldFlags & SFLAG_SRGBALLOCATED) surface_internal_preload(iface, SRGB_SRGB);
2887 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2890 /* Now free the old memory if any */
2891 HeapFree(GetProcessHeap(), 0, release);
2892 } else if(This->Flags & SFLAG_USERPTR) {
2893 /* LockRect and GetDC will re-create the dib section and allocated memory */
2894 This->resource.allocatedMemory = NULL;
2895 /* HeapMemory should be NULL already */
2896 if(This->resource.heapMemory != NULL) ERR("User pointer surface has heap memory allocated\n");
2897 This->Flags &= ~SFLAG_USERPTR;
2899 if(This->Flags & SFLAG_CLIENT) {
2900 DWORD oldFlags = This->Flags;
2901 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2902 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2903 if(oldFlags & SFLAG_ALLOCATED) surface_internal_preload(iface, SRGB_RGB);
2904 if(oldFlags & SFLAG_SRGBALLOCATED) surface_internal_preload(iface, SRGB_SRGB);
2910 void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) {
2912 /* Flip the surface contents */
2917 front->hDC = back->hDC;
2921 /* Flip the DIBsection */
2924 BOOL hasDib = front->Flags & SFLAG_DIBSECTION;
2925 tmp = front->dib.DIBsection;
2926 front->dib.DIBsection = back->dib.DIBsection;
2927 back->dib.DIBsection = tmp;
2929 if(back->Flags & SFLAG_DIBSECTION) front->Flags |= SFLAG_DIBSECTION;
2930 else front->Flags &= ~SFLAG_DIBSECTION;
2931 if(hasDib) back->Flags |= SFLAG_DIBSECTION;
2932 else back->Flags &= ~SFLAG_DIBSECTION;
2935 /* Flip the surface data */
2939 tmp = front->dib.bitmap_data;
2940 front->dib.bitmap_data = back->dib.bitmap_data;
2941 back->dib.bitmap_data = tmp;
2943 tmp = front->resource.allocatedMemory;
2944 front->resource.allocatedMemory = back->resource.allocatedMemory;
2945 back->resource.allocatedMemory = tmp;
2947 tmp = front->resource.heapMemory;
2948 front->resource.heapMemory = back->resource.heapMemory;
2949 back->resource.heapMemory = tmp;
2954 GLuint tmp_pbo = front->pbo;
2955 front->pbo = back->pbo;
2956 back->pbo = tmp_pbo;
2959 /* client_memory should not be different, but just in case */
2962 tmp = front->dib.client_memory;
2963 front->dib.client_memory = back->dib.client_memory;
2964 back->dib.client_memory = tmp;
2967 /* Flip the opengl texture */
2969 glDescriptor tmp_desc = back->glDescription;
2970 back->glDescription = front->glDescription;
2971 front->glDescription = tmp_desc;
2975 DWORD tmp_flags = back->Flags;
2976 back->Flags = front->Flags;
2977 front->Flags = tmp_flags;
2981 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD Flags) {
2982 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2983 IWineD3DSwapChainImpl *swapchain = NULL;
2985 TRACE("(%p)->(%p,%x)\n", This, override, Flags);
2987 /* Flipping is only supported on RenderTargets and overlays*/
2988 if( !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_OVERLAY)) ) {
2989 WARN("Tried to flip a non-render target, non-overlay surface\n");
2990 return WINEDDERR_NOTFLIPPABLE;
2993 if(This->resource.usage & WINED3DUSAGE_OVERLAY) {
2994 flip_surface(This, (IWineD3DSurfaceImpl *) override);
2996 /* Update the overlay if it is visible */
2997 if(This->overlay_dest) {
2998 return IWineD3DSurface_DrawOverlay((IWineD3DSurface *) This);
3005 /* DDraw sets this for the X11 surfaces, so don't confuse the user
3006 * FIXME("(%p) Target override is not supported by now\n", This);
3007 * Additionally, it isn't really possible to support triple-buffering
3008 * properly on opengl at all
3012 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **) &swapchain);
3014 ERR("Flipped surface is not on a swapchain\n");
3015 return WINEDDERR_NOTFLIPPABLE;
3018 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
3019 * and only d3d8 and d3d9 apps specify the presentation interval
3021 if((Flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)) == 0) {
3022 /* Most common case first to avoid wasting time on all the other cases */
3023 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
3024 } else if(Flags & WINEDDFLIP_NOVSYNC) {
3025 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3026 } else if(Flags & WINEDDFLIP_INTERVAL2) {
3027 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
3028 } else if(Flags & WINEDDFLIP_INTERVAL3) {
3029 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
3031 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
3034 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
3035 hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *) swapchain, NULL, NULL, 0, NULL, 0);
3036 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
3040 /* Does a direct frame buffer -> texture copy. Stretching is done
3041 * with single pixel copy calls
3043 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
3044 IWineD3DSwapChainImpl *swapchain, const WINED3DRECT *srect, const WINED3DRECT *drect,
3045 BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter)
3047 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3050 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3053 ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
3054 surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
3057 /* Bind the target texture */
3058 glBindTexture(This->glDescription.target, This->glDescription.textureName);
3059 checkGLcall("glBindTexture");
3061 TRACE("Reading from an offscreen target\n");
3062 upsidedown = !upsidedown;
3063 glReadBuffer(myDevice->offscreenBuffer);
3065 GLenum buffer = surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain);
3066 glReadBuffer(buffer);
3068 checkGLcall("glReadBuffer");
3070 xrel = (float) (srect->x2 - srect->x1) / (float) (drect->x2 - drect->x1);
3071 yrel = (float) (srect->y2 - srect->y1) / (float) (drect->y2 - drect->y1);
3073 if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
3074 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
3076 if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
3077 ERR("Texture filtering not supported in direct blit\n");
3079 } else if((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) && ((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
3080 ERR("Texture filtering not supported in direct blit\n");
3084 !((xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) &&
3085 !((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
3086 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
3088 glCopyTexSubImage2D(This->glDescription.target,
3089 This->glDescription.level,
3090 drect->x1, drect->y1, /* xoffset, yoffset */
3091 srect->x1, Src->currentDesc.Height - srect->y2,
3092 drect->x2 - drect->x1, drect->y2 - drect->y1);
3094 UINT yoffset = Src->currentDesc.Height - srect->y1 + drect->y1 - 1;
3095 /* I have to process this row by row to swap the image,
3096 * otherwise it would be upside down, so stretching in y direction
3097 * doesn't cost extra time
3099 * However, stretching in x direction can be avoided if not necessary
3101 for(row = drect->y1; row < drect->y2; row++) {
3102 if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
3103 /* Well, that stuff works, but it's very slow.
3104 * find a better way instead
3108 for(col = drect->x1; col < drect->x2; col++) {
3109 glCopyTexSubImage2D(This->glDescription.target,
3110 This->glDescription.level,
3111 drect->x1 + col, row, /* xoffset, yoffset */
3112 srect->x1 + col * xrel, yoffset - (int) (row * yrel),
3116 glCopyTexSubImage2D(This->glDescription.target,
3117 This->glDescription.level,
3118 drect->x1, row, /* xoffset, yoffset */
3119 srect->x1, yoffset - (int) (row * yrel),
3120 drect->x2-drect->x1, 1);
3124 checkGLcall("glCopyTexSubImage2D");
3129 /* Uses the hardware to stretch and flip the image */
3130 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
3131 IWineD3DSwapChainImpl *swapchain, const WINED3DRECT *srect, const WINED3DRECT *drect,
3132 BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter)
3134 GLuint src, backup = 0;
3135 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3136 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3137 float left, right, top, bottom; /* Texture coordinates */
3138 UINT fbwidth = Src->currentDesc.Width;
3139 UINT fbheight = Src->currentDesc.Height;
3140 GLenum drawBuffer = GL_BACK;
3141 GLenum texture_target;
3142 BOOL noBackBufferBackup;
3144 TRACE("Using hwstretch blit\n");
3145 /* Activate the Proper context for reading from the source surface, set it up for blitting */
3146 ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
3147 surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
3149 noBackBufferBackup = !swapchain && wined3d_settings.offscreen_rendering_mode == ORM_FBO;
3150 if(!noBackBufferBackup && Src->glDescription.textureName == 0) {
3151 /* Get it a description */
3152 surface_internal_preload(SrcSurface, SRGB_RGB);
3156 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
3157 * This way we don't have to wait for the 2nd readback to finish to leave this function.
3159 if(myDevice->activeContext->aux_buffers >= 2) {
3160 /* Got more than one aux buffer? Use the 2nd aux buffer */
3161 drawBuffer = GL_AUX1;
3162 } else if((swapchain || myDevice->offscreenBuffer == GL_BACK) && myDevice->activeContext->aux_buffers >= 1) {
3163 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
3164 drawBuffer = GL_AUX0;
3167 if(noBackBufferBackup) {
3168 glGenTextures(1, &backup);
3169 checkGLcall("glGenTextures\n");
3170 glBindTexture(GL_TEXTURE_2D, backup);
3171 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
3172 texture_target = GL_TEXTURE_2D;
3174 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
3175 * we are reading from the back buffer, the backup can be used as source texture
3177 texture_target = Src->glDescription.target;
3178 glBindTexture(texture_target, Src->glDescription.textureName);
3179 checkGLcall("glBindTexture(texture_target, Src->glDescription.textureName)");
3180 glEnable(texture_target);
3181 checkGLcall("glEnable(texture_target)");
3183 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
3184 Src->Flags &= ~SFLAG_INTEXTURE;
3188 glReadBuffer(surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain));
3190 TRACE("Reading from an offscreen target\n");
3191 upsidedown = !upsidedown;
3192 glReadBuffer(myDevice->offscreenBuffer);
3195 /* TODO: Only back up the part that will be overwritten */
3196 glCopyTexSubImage2D(texture_target, 0,
3197 0, 0 /* read offsets */,
3202 checkGLcall("glCopyTexSubImage2D");
3204 /* No issue with overriding these - the sampler is dirty due to blit usage */
3205 glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER,
3206 magLookup[Filter - WINED3DTEXF_NONE]);
3207 checkGLcall("glTexParameteri");
3208 glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER,
3209 minMipLookup[Filter].mip[WINED3DTEXF_NONE]);
3210 checkGLcall("glTexParameteri");
3212 if(!swapchain || (IWineD3DSurface *) Src == swapchain->backBuffer[0]) {
3213 src = backup ? backup : Src->glDescription.textureName;
3215 glReadBuffer(GL_FRONT);
3216 checkGLcall("glReadBuffer(GL_FRONT)");
3218 glGenTextures(1, &src);
3219 checkGLcall("glGenTextures(1, &src)");
3220 glBindTexture(GL_TEXTURE_2D, src);
3221 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
3223 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
3224 * out for power of 2 sizes
3226 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Src->pow2Width, Src->pow2Height, 0,
3227 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
3228 checkGLcall("glTexImage2D");
3229 glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
3230 0, 0 /* read offsets */,
3235 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3236 checkGLcall("glTexParameteri");
3237 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3238 checkGLcall("glTexParameteri");
3240 glReadBuffer(GL_BACK);
3241 checkGLcall("glReadBuffer(GL_BACK)");
3243 if(texture_target != GL_TEXTURE_2D) {
3244 glDisable(texture_target);
3245 glEnable(GL_TEXTURE_2D);
3246 texture_target = GL_TEXTURE_2D;
3249 checkGLcall("glEnd and previous");
3255 top = Src->currentDesc.Height - srect->y1;
3256 bottom = Src->currentDesc.Height - srect->y2;
3258 top = Src->currentDesc.Height - srect->y2;
3259 bottom = Src->currentDesc.Height - srect->y1;
3262 if(Src->Flags & SFLAG_NORMCOORD) {
3263 left /= Src->pow2Width;
3264 right /= Src->pow2Width;
3265 top /= Src->pow2Height;
3266 bottom /= Src->pow2Height;
3269 /* draw the source texture stretched and upside down. The correct surface is bound already */
3270 glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3271 glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3273 glDrawBuffer(drawBuffer);
3274 glReadBuffer(drawBuffer);
3278 glTexCoord2f(left, bottom);
3279 glVertex2i(0, fbheight);
3282 glTexCoord2f(left, top);
3283 glVertex2i(0, fbheight - drect->y2 - drect->y1);
3286 glTexCoord2f(right, top);
3287 glVertex2i(drect->x2 - drect->x1, fbheight - drect->y2 - drect->y1);
3290 glTexCoord2f(right, bottom);
3291 glVertex2i(drect->x2 - drect->x1, fbheight);
3293 checkGLcall("glEnd and previous");
3295 if(texture_target != This->glDescription.target) {
3296 glDisable(texture_target);
3297 glEnable(This->glDescription.target);
3298 texture_target = This->glDescription.target;
3301 /* Now read the stretched and upside down image into the destination texture */
3302 glBindTexture(texture_target, This->glDescription.textureName);
3303 checkGLcall("glBindTexture");
3304 glCopyTexSubImage2D(texture_target,
3306 drect->x1, drect->y1, /* xoffset, yoffset */
3307 0, 0, /* We blitted the image to the origin */
3308 drect->x2 - drect->x1, drect->y2 - drect->y1);
3309 checkGLcall("glCopyTexSubImage2D");
3311 if(drawBuffer == GL_BACK) {
3312 /* Write the back buffer backup back */
3314 if(texture_target != GL_TEXTURE_2D) {
3315 glDisable(texture_target);
3316 glEnable(GL_TEXTURE_2D);
3317 texture_target = GL_TEXTURE_2D;
3319 glBindTexture(GL_TEXTURE_2D, backup);
3320 checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3322 if(texture_target != Src->glDescription.target) {
3323 glDisable(texture_target);
3324 glEnable(Src->glDescription.target);
3325 texture_target = Src->glDescription.target;
3327 glBindTexture(Src->glDescription.target, Src->glDescription.textureName);
3328 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
3333 glTexCoord2f(0.0, (float) fbheight / (float) Src->pow2Height);
3337 glTexCoord2f(0.0, 0.0);
3338 glVertex2i(0, fbheight);
3341 glTexCoord2f((float) fbwidth / (float) Src->pow2Width, 0.0);
3342 glVertex2i(fbwidth, Src->currentDesc.Height);
3345 glTexCoord2f((float) fbwidth / (float) Src->pow2Width, (float) fbheight / (float) Src->pow2Height);
3346 glVertex2i(fbwidth, 0);
3349 /* Restore the old draw buffer */
3350 glDrawBuffer(GL_BACK);
3352 glDisable(texture_target);
3353 checkGLcall("glDisable(texture_target)");
3356 if(src != Src->glDescription.textureName && src != backup) {
3357 glDeleteTextures(1, &src);
3358 checkGLcall("glDeleteTextures(1, &src)");
3361 glDeleteTextures(1, &backup);
3362 checkGLcall("glDeleteTextures(1, &backup)");
3368 /* Not called from the VTable */
3369 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3370 IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx,
3371 WINED3DTEXTUREFILTERTYPE Filter)
3374 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3375 IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
3376 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3378 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3380 /* Get the swapchain. One of the surfaces has to be a primary surface */
3381 if(This->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3382 WARN("Destination is in sysmem, rejecting gl blt\n");
3383 return WINED3DERR_INVALIDCALL;
3385 IWineD3DSurface_GetContainer( (IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&dstSwapchain);
3386 if(dstSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) dstSwapchain);
3388 if(Src->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3389 WARN("Src is in sysmem, rejecting gl blt\n");
3390 return WINED3DERR_INVALIDCALL;
3392 IWineD3DSurface_GetContainer( (IWineD3DSurface *) Src, &IID_IWineD3DSwapChain, (void **)&srcSwapchain);
3393 if(srcSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) srcSwapchain);
3396 /* Early sort out of cases where no render target is used */
3397 if(!dstSwapchain && !srcSwapchain &&
3398 SrcSurface != myDevice->render_targets[0] && This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3399 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src, This);
3400 return WINED3DERR_INVALIDCALL;
3403 /* No destination color keying supported */
3404 if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
3405 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3406 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3407 return WINED3DERR_INVALIDCALL;
3411 rect.x1 = DestRect->left;
3412 rect.y1 = DestRect->top;
3413 rect.x2 = DestRect->right;
3414 rect.y2 = DestRect->bottom;
3418 rect.x2 = This->currentDesc.Width;
3419 rect.y2 = This->currentDesc.Height;
3422 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3423 if(dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->backBuffer &&
3424 ((IWineD3DSurface *) This == dstSwapchain->frontBuffer) && SrcSurface == dstSwapchain->backBuffer[0]) {
3425 /* Half-life does a Blt from the back buffer to the front buffer,
3426 * Full surface size, no flags... Use present instead
3428 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3431 /* Check rects - IWineD3DDevice_Present doesn't handle them */
3435 TRACE("Looking if a Present can be done...\n");
3436 /* Source Rectangle must be full surface */
3438 if(SrcRect->left != 0 || SrcRect->top != 0 ||
3439 SrcRect->right != Src->currentDesc.Width || SrcRect->bottom != Src->currentDesc.Height) {
3440 TRACE("No, Source rectangle doesn't match\n");
3446 mySrcRect.right = Src->currentDesc.Width;
3447 mySrcRect.bottom = Src->currentDesc.Height;
3449 /* No stretching may occur */
3450 if(mySrcRect.right != rect.x2 - rect.x1 ||
3451 mySrcRect.bottom != rect.y2 - rect.y1) {
3452 TRACE("No, stretching is done\n");
3456 /* Destination must be full surface or match the clipping rectangle */
3457 if(This->clipper && ((IWineD3DClipperImpl *) This->clipper)->hWnd)
3461 GetClientRect(((IWineD3DClipperImpl *) This->clipper)->hWnd, &cliprect);
3466 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl *) This->clipper)->hWnd,
3469 if(pos[0].x != cliprect.left || pos[0].y != cliprect.top ||
3470 pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
3472 TRACE("No, dest rectangle doesn't match(clipper)\n");
3473 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect.left, cliprect.top, cliprect.right, cliprect.bottom);
3474 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect.x1, rect.y1, rect.x2, rect.y2);
3480 if(rect.x1 != 0 || rect.y1 != 0 ||
3481 rect.x2 != This->currentDesc.Width || rect.y2 != This->currentDesc.Height) {
3482 TRACE("No, dest rectangle doesn't match(surface size)\n");
3489 /* These flags are unimportant for the flag check, remove them */
3490 if((Flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)) == 0) {
3491 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
3493 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3494 * take very long, while a flip is fast.
3495 * This applies to Half-Life, which does such Blts every time it finished
3496 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3497 * menu. This is also used by all apps when they do windowed rendering
3499 * The problem is that flipping is not really the same as copying. After a
3500 * Blt the front buffer is a copy of the back buffer, and the back buffer is
3501 * untouched. Therefore it's necessary to override the swap effect
3502 * and to set it back after the flip.
3504 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3508 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
3509 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3511 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3512 IWineD3DSwapChain_Present((IWineD3DSwapChain *) dstSwapchain, NULL, NULL, 0, NULL, 0);
3514 dstSwapchain->presentParms.SwapEffect = orig_swap;
3521 TRACE("Unsupported blit between buffers on the same swapchain\n");
3522 return WINED3DERR_INVALIDCALL;
3523 } else if(dstSwapchain && dstSwapchain == srcSwapchain) {
3524 FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3525 return WINED3DERR_INVALIDCALL;
3526 } else if(dstSwapchain && srcSwapchain) {
3527 FIXME("Implement hardware blit between two different swapchains\n");
3528 return WINED3DERR_INVALIDCALL;
3529 } else if(dstSwapchain) {
3530 if(SrcSurface == myDevice->render_targets[0]) {
3531 TRACE("Blit from active render target to a swapchain\n");
3532 /* Handled with regular texture -> swapchain blit */
3534 } else if(srcSwapchain && This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3535 FIXME("Implement blit from a swapchain to the active render target\n");
3536 return WINED3DERR_INVALIDCALL;
3539 if((srcSwapchain || SrcSurface == myDevice->render_targets[0]) && !dstSwapchain) {
3540 /* Blit from render target to texture */
3542 BOOL upsideDown, stretchx;
3543 BOOL paletteOverride = FALSE;
3545 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3546 TRACE("Color keying not supported by frame buffer to texture blit\n");
3547 return WINED3DERR_INVALIDCALL;
3548 /* Destination color key is checked above */
3551 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3552 * glCopyTexSubImage is a bit picky about the parameters we pass to it
3555 if(SrcRect->top < SrcRect->bottom) {
3556 srect.y1 = SrcRect->top;
3557 srect.y2 = SrcRect->bottom;
3560 srect.y1 = SrcRect->bottom;
3561 srect.y2 = SrcRect->top;
3564 srect.x1 = SrcRect->left;
3565 srect.x2 = SrcRect->right;
3569 srect.x2 = Src->currentDesc.Width;
3570 srect.y2 = Src->currentDesc.Height;
3573 if(rect.x1 > rect.x2) {
3577 upsideDown = !upsideDown;
3580 if(rect.x2 - rect.x1 != srect.x2 - srect.x1) {
3586 /* When blitting from a render target a texture, the texture isn't required to have a palette.
3587 * In this case grab the palette from the render target. */
3588 if ((This->resource.format_desc->format == WINED3DFMT_P8) && (This->palette == NULL))
3590 paletteOverride = TRUE;
3591 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src, This->palette, This);
3592 This->palette = Src->palette;
3595 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3596 * flip the image nor scale it.
3598 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3599 * -> If the app wants a image width an unscaled width, copy it line per line
3600 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3601 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3602 * back buffer. This is slower than reading line per line, thus not used for flipping
3603 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3606 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3607 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3610 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT)
3611 && surface_can_stretch_rect(Src, This))
3613 stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &srect,
3614 (IWineD3DSurface *)This, &rect, Filter, upsideDown);
3615 } else if((!stretchx) || rect.x2 - rect.x1 > Src->currentDesc.Width ||
3616 rect.y2 - rect.y1 > Src->currentDesc.Height) {
3617 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3618 fb_copy_to_texture_direct(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3620 TRACE("Using hardware stretching to flip / stretch the texture\n");
3621 fb_copy_to_texture_hwstretch(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3624 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3626 This->palette = NULL;
3628 if(!(This->Flags & SFLAG_DONOTFREE)) {
3629 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
3630 This->resource.allocatedMemory = NULL;
3631 This->resource.heapMemory = NULL;
3633 This->Flags &= ~SFLAG_INSYSMEM;
3635 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3636 * path is never entered
3638 IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INTEXTURE, TRUE);
3642 /* Blit from offscreen surface to render target */
3643 float glTexCoord[4];
3644 DWORD oldCKeyFlags = Src->CKeyFlags;
3645 WINEDDCOLORKEY oldBltCKey = Src->SrcBltCKey;
3646 RECT SourceRectangle;
3647 BOOL paletteOverride = FALSE;
3649 TRACE("Blt from surface %p to rendertarget %p\n", Src, This);
3652 SourceRectangle.left = SrcRect->left;
3653 SourceRectangle.right = SrcRect->right;
3654 SourceRectangle.top = SrcRect->top;
3655 SourceRectangle.bottom = SrcRect->bottom;
3657 SourceRectangle.left = 0;
3658 SourceRectangle.right = Src->currentDesc.Width;
3659 SourceRectangle.top = 0;
3660 SourceRectangle.bottom = Src->currentDesc.Height;
3663 /* When blitting from an offscreen surface to a rendertarget, the source
3664 * surface is not required to have a palette. Our rendering / conversion
3665 * code further down the road retrieves the palette from the surface, so
3666 * it must have a palette set. */
3667 if ((Src->resource.format_desc->format == WINED3DFMT_P8) && (Src->palette == NULL))
3669 paletteOverride = TRUE;
3670 TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src, This->palette, This);
3671 Src->palette = This->palette;
3674 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT)
3675 && !(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3676 && surface_can_stretch_rect(Src, This))
3678 TRACE("Using stretch_rect_fbo\n");
3679 /* The source is always a texture, but never the currently active render target, and the texture
3680 * contents are never upside down
3682 stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, (WINED3DRECT *) &SourceRectangle,
3683 (IWineD3DSurface *)This, &rect, Filter, FALSE);
3685 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3687 Src->palette = NULL;
3691 if(!CalculateTexRect(Src, &SourceRectangle, glTexCoord)) {
3692 /* Fall back to software */
3693 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src,
3694 SourceRectangle.left, SourceRectangle.top,
3695 SourceRectangle.right, SourceRectangle.bottom);
3696 return WINED3DERR_INVALIDCALL;
3699 /* Color keying: Check if we have to do a color keyed blt,
3700 * and if not check if a color key is activated.
3702 * Just modify the color keying parameters in the surface and restore them afterwards
3703 * The surface keeps track of the color key last used to load the opengl surface.
3704 * PreLoad will catch the change to the flags and color key and reload if necessary.
3706 if(Flags & WINEDDBLT_KEYSRC) {
3707 /* Use color key from surface */
3708 } else if(Flags & WINEDDBLT_KEYSRCOVERRIDE) {
3709 /* Use color key from DDBltFx */
3710 Src->CKeyFlags |= WINEDDSD_CKSRCBLT;
3711 Src->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3713 /* Do not use color key */
3714 Src->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3717 /* Now load the surface */
3718 surface_internal_preload((IWineD3DSurface *) Src, SRGB_RGB);
3720 /* Activate the destination context, set it up for blitting */
3721 ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
3723 /* The coordinates of the ddraw front buffer are always fullscreen ('screen coordinates',
3724 * while OpenGL coordinates are window relative.
3725 * Also beware of the origin difference(top left vs bottom left).
3726 * Also beware that the front buffer's surface size is screen width x screen height,
3727 * whereas the real gl drawable size is the size of the window.
3729 if (dstSwapchain && (IWineD3DSurface *)This == dstSwapchain->frontBuffer) {
3731 POINT offset = {0,0};
3733 ClientToScreen(dstSwapchain->win_handle, &offset);
3734 GetClientRect(dstSwapchain->win_handle, &windowsize);
3735 h = windowsize.bottom - windowsize.top;
3736 rect.x1 -= offset.x; rect.x2 -=offset.x;
3737 rect.y1 -= offset.y; rect.y2 -=offset.y;
3738 rect.y1 += This->currentDesc.Height - h; rect.y2 += This->currentDesc.Height - h;
3741 if (!is_identity_fixup(This->resource.format_desc->color_fixup))
3743 FIXME("Destination format %s has a fixup, this is not supported.\n",
3744 debug_d3dformat(This->resource.format_desc->format));
3745 dump_color_fixup_desc(This->resource.format_desc->color_fixup);
3748 if (!myDevice->blitter->color_fixup_supported(Src->resource.format_desc->color_fixup))
3750 FIXME("Source format %s has an unsupported fixup:\n",
3751 debug_d3dformat(Src->resource.format_desc->format));
3752 dump_color_fixup_desc(Src->resource.format_desc->color_fixup);
3755 myDevice->blitter->set_shader((IWineD3DDevice *) myDevice, Src->resource.format_desc,
3756 Src->glDescription.target, Src->pow2Width, Src->pow2Height);
3760 /* Bind the texture */
3761 glBindTexture(Src->glDescription.target, Src->glDescription.textureName);
3762 checkGLcall("glBindTexture");
3764 /* Filtering for StretchRect */
3765 glTexParameteri(Src->glDescription.target, GL_TEXTURE_MAG_FILTER,
3766 magLookup[Filter - WINED3DTEXF_NONE]);
3767 checkGLcall("glTexParameteri");
3768 glTexParameteri(Src->glDescription.target, GL_TEXTURE_MIN_FILTER,
3769 minMipLookup[Filter].mip[WINED3DTEXF_NONE]);
3770 checkGLcall("glTexParameteri");
3771 glTexParameteri(Src->glDescription.target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3772 glTexParameteri(Src->glDescription.target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3773 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
3774 checkGLcall("glTexEnvi");
3776 /* This is for color keying */
3777 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3778 glEnable(GL_ALPHA_TEST);
3779 checkGLcall("glEnable GL_ALPHA_TEST");
3781 /* When the primary render target uses P8, the alpha component contains the palette index.
3782 * Which means that the colorkey is one of the palette entries. In other cases pixels that
3783 * should be masked away have alpha set to 0. */
3784 if(primary_render_target_is_p8(myDevice))
3785 glAlphaFunc(GL_NOTEQUAL, (float)Src->SrcBltCKey.dwColorSpaceLowValue / 256.0);
3787 glAlphaFunc(GL_NOTEQUAL, 0.0);
3788 checkGLcall("glAlphaFunc\n");
3790 glDisable(GL_ALPHA_TEST);
3791 checkGLcall("glDisable GL_ALPHA_TEST");
3794 /* Draw a textured quad
3798 glColor3d(1.0f, 1.0f, 1.0f);
3799 glTexCoord2f(glTexCoord[0], glTexCoord[2]);
3804 glTexCoord2f(glTexCoord[0], glTexCoord[3]);
3805 glVertex3f(rect.x1, rect.y2, 0.0);
3807 glTexCoord2f(glTexCoord[1], glTexCoord[3]);
3812 glTexCoord2f(glTexCoord[1], glTexCoord[2]);
3817 checkGLcall("glEnd");
3819 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3820 glDisable(GL_ALPHA_TEST);
3821 checkGLcall("glDisable(GL_ALPHA_TEST)");
3824 glBindTexture(Src->glDescription.target, 0);
3825 checkGLcall("glBindTexture(Src->glDescription.target, 0)");
3827 /* Restore the color key parameters */
3828 Src->CKeyFlags = oldCKeyFlags;
3829 Src->SrcBltCKey = oldBltCKey;
3831 /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3833 Src->palette = NULL;
3837 /* Leave the opengl state valid for blitting */
3838 myDevice->blitter->unset_shader((IWineD3DDevice *) myDevice);
3840 /* Flush in case the drawable is used by multiple GL contexts */
3841 if(dstSwapchain && (This == (IWineD3DSurfaceImpl *) dstSwapchain->frontBuffer || dstSwapchain->num_contexts >= 2))
3844 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3845 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3848 IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INDRAWABLE, TRUE);
3852 /* Source-Less Blit to render target */
3853 if (Flags & WINEDDBLT_COLORFILL) {
3854 /* This is easy to handle for the D3D Device... */
3857 TRACE("Colorfill\n");
3859 /* This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0] || dstSwapchain
3860 must be true if we are here */
3861 if (This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0] &&
3862 !(This == (IWineD3DSurfaceImpl*) dstSwapchain->frontBuffer ||
3863 (dstSwapchain->backBuffer && This == (IWineD3DSurfaceImpl*) dstSwapchain->backBuffer[0]))) {
3864 TRACE("Surface is higher back buffer, falling back to software\n");
3865 return WINED3DERR_INVALIDCALL;
3868 /* The color as given in the Blt function is in the format of the frame-buffer...
3869 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3871 if (This->resource.format_desc->format == WINED3DFMT_P8)
3875 if (primary_render_target_is_p8(myDevice)) alpha = DDBltFx->u5.dwFillColor << 24;
3876 else alpha = 0xFF000000;
3878 if (This->palette) {
3880 (This->palette->palents[DDBltFx->u5.dwFillColor].peRed << 16) |
3881 (This->palette->palents[DDBltFx->u5.dwFillColor].peGreen << 8) |
3882 (This->palette->palents[DDBltFx->u5.dwFillColor].peBlue));
3887 else if (This->resource.format_desc->format == WINED3DFMT_R5G6B5)
3889 if (DDBltFx->u5.dwFillColor == 0xFFFF) {
3892 color = ((0xFF000000) |
3893 ((DDBltFx->u5.dwFillColor & 0xF800) << 8) |
3894 ((DDBltFx->u5.dwFillColor & 0x07E0) << 5) |
3895 ((DDBltFx->u5.dwFillColor & 0x001F) << 3));
3898 else if ((This->resource.format_desc->format == WINED3DFMT_R8G8B8)
3899 || (This->resource.format_desc->format == WINED3DFMT_X8R8G8B8))
3901 color = 0xFF000000 | DDBltFx->u5.dwFillColor;
3903 else if (This->resource.format_desc->format == WINED3DFMT_A8R8G8B8)
3905 color = DDBltFx->u5.dwFillColor;
3908 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3909 return WINED3DERR_INVALIDCALL;
3912 TRACE("(%p) executing Render Target override, color = %x\n", This, color);
3913 IWineD3DDeviceImpl_ClearSurface(myDevice, This,
3914 1, /* Number of rectangles */
3915 &rect, WINED3DCLEAR_TARGET, color,
3922 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3923 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3924 return WINED3DERR_INVALIDCALL;
3927 static HRESULT IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3928 IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx)
3930 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3933 if (Flags & WINEDDBLT_DEPTHFILL) {
3934 switch(This->resource.format_desc->format)
3936 case WINED3DFMT_D16_UNORM:
3937 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
3939 case WINED3DFMT_D15S1:
3940 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000fffe;
3942 case WINED3DFMT_D24S8:
3943 case WINED3DFMT_D24X8:
3944 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x00ffffff;
3946 case WINED3DFMT_D32:
3947 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0xffffffff;
3951 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This->resource.format_desc->format));
3954 return IWineD3DDevice_Clear((IWineD3DDevice *) myDevice,
3955 DestRect == NULL ? 0 : 1,
3956 (const WINED3DRECT *)DestRect,
3957 WINED3DCLEAR_ZBUFFER,
3963 FIXME("(%p): Unsupp depthstencil blit\n", This);
3964 return WINED3DERR_INVALIDCALL;
3967 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect, IWineD3DSurface *SrcSurface,
3968 const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
3969 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
3970 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3971 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3972 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3973 TRACE("(%p): Usage is %s\n", This, debug_d3dusage(This->resource.usage));
3975 if ( (This->Flags & SFLAG_LOCKED) || ((Src != NULL) && (Src->Flags & SFLAG_LOCKED)))
3977 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3978 return WINEDDERR_SURFACEBUSY;
3981 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3982 * except depth blits, which seem to work
3984 if(iface == myDevice->stencilBufferTarget || (SrcSurface && SrcSurface == myDevice->stencilBufferTarget)) {
3985 if(myDevice->inScene && !(Flags & WINEDDBLT_DEPTHFILL)) {
3986 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3987 return WINED3DERR_INVALIDCALL;
3988 } else if(IWineD3DSurfaceImpl_BltZ(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx) == WINED3D_OK) {
3989 TRACE("Z Blit override handled the blit\n");
3994 /* Special cases for RenderTargets */
3995 if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3996 ( Src && (Src->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3997 if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
4000 /* For the rest call the X11 surface implementation.
4001 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
4002 * other Blts are rather rare
4004 return IWineD3DBaseSurfaceImpl_Blt(iface, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter);
4007 static HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
4008 IWineD3DSurface *Source, const RECT *rsrc, DWORD trans)
4010 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4011 IWineD3DSurfaceImpl *srcImpl = (IWineD3DSurfaceImpl *) Source;
4012 IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
4013 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface, dstx, dsty, Source, rsrc, trans);
4015 if ( (This->Flags & SFLAG_LOCKED) || ((srcImpl != NULL) && (srcImpl->Flags & SFLAG_LOCKED)))
4017 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
4018 return WINEDDERR_SURFACEBUSY;
4021 if(myDevice->inScene &&
4022 (iface == myDevice->stencilBufferTarget ||
4023 (Source && Source == myDevice->stencilBufferTarget))) {
4024 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
4025 return WINED3DERR_INVALIDCALL;
4028 /* Special cases for RenderTargets */
4029 if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
4030 ( srcImpl && (srcImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
4032 RECT SrcRect, DstRect;
4036 SrcRect.left = rsrc->left;
4037 SrcRect.top= rsrc->top;
4038 SrcRect.bottom = rsrc->bottom;
4039 SrcRect.right = rsrc->right;
4043 SrcRect.right = srcImpl->currentDesc.Width;
4044 SrcRect.bottom = srcImpl->currentDesc.Height;
4047 DstRect.left = dstx;
4049 DstRect.right = dstx + SrcRect.right - SrcRect.left;
4050 DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
4052 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
4053 if(trans & WINEDDBLTFAST_SRCCOLORKEY)
4054 Flags |= WINEDDBLT_KEYSRC;
4055 if(trans & WINEDDBLTFAST_DESTCOLORKEY)
4056 Flags |= WINEDDBLT_KEYDEST;
4057 if(trans & WINEDDBLTFAST_WAIT)
4058 Flags |= WINEDDBLT_WAIT;
4059 if(trans & WINEDDBLTFAST_DONOTWAIT)
4060 Flags |= WINEDDBLT_DONOTWAIT;
4062 if(IWineD3DSurfaceImpl_BltOverride(This, &DstRect, Source, &SrcRect, Flags, NULL, WINED3DTEXF_POINT) == WINED3D_OK) return WINED3D_OK;
4066 return IWineD3DBaseSurfaceImpl_BltFast(iface, dstx, dsty, Source, rsrc, trans);
4069 static HRESULT WINAPI IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface *iface)
4071 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4073 IWineD3DPaletteImpl *pal = This->palette;
4075 TRACE("(%p)\n", This);
4077 if (!pal) return WINED3D_OK;
4079 if (This->resource.format_desc->format == WINED3DFMT_P8
4080 || This->resource.format_desc->format == WINED3DFMT_A8P8)
4083 GLenum format, internal, type;
4084 CONVERT_TYPES convert;
4086 /* Check if we are using a RTL mode which uses texturing for uploads */
4087 BOOL use_texture = (wined3d_settings.rendertargetlock_mode == RTL_READTEX || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX);
4089 /* Check if we have hardware palette conversion if we have convert is set to NO_CONVERSION */
4090 d3dfmt_get_conv(This, TRUE, use_texture, &format, &internal, &type, &convert, &bpp, FALSE);
4092 if((This->resource.usage & WINED3DUSAGE_RENDERTARGET) && (convert == NO_CONVERSION))
4094 /* Make sure the texture is up to date. This call doesn't do anything if the texture is already up to date. */
4095 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL);
4097 /* We want to force a palette refresh, so mark the drawable as not being up to date */
4098 IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
4100 /* Re-upload the palette */
4101 d3dfmt_p8_upload_palette(iface, convert);
4103 if(!(This->Flags & SFLAG_INSYSMEM)) {
4104 TRACE("Palette changed with surface that does not have an up to date system memory copy\n");
4105 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
4107 TRACE("Dirtifying surface\n");
4108 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
4112 if(This->Flags & SFLAG_DIBSECTION) {
4113 TRACE("(%p): Updating the hdc's palette\n", This);
4114 for (n=0; n<256; n++) {
4115 col[n].rgbRed = pal->palents[n].peRed;
4116 col[n].rgbGreen = pal->palents[n].peGreen;
4117 col[n].rgbBlue = pal->palents[n].peBlue;
4118 col[n].rgbReserved = 0;
4120 SetDIBColorTable(This->hDC, 0, 256, col);
4123 /* Propagate the changes to the drawable when we have a palette. */
4124 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET)
4125 IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, NULL);
4130 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
4131 /** Check against the maximum texture sizes supported by the video card **/
4132 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4133 unsigned int pow2Width, pow2Height;
4135 This->glDescription.textureName = 0;
4136 This->glDescription.target = GL_TEXTURE_2D;
4138 /* Non-power2 support */
4139 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) || GL_SUPPORT(WINE_NORMALIZED_TEXRECT)) {
4140 pow2Width = This->currentDesc.Width;
4141 pow2Height = This->currentDesc.Height;
4143 /* Find the nearest pow2 match */
4144 pow2Width = pow2Height = 1;
4145 while (pow2Width < This->currentDesc.Width) pow2Width <<= 1;
4146 while (pow2Height < This->currentDesc.Height) pow2Height <<= 1;
4148 This->pow2Width = pow2Width;
4149 This->pow2Height = pow2Height;
4151 if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
4152 /** TODO: add support for non power two compressed textures **/
4153 if (This->resource.format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
4155 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
4156 This, This->currentDesc.Width, This->currentDesc.Height);
4157 return WINED3DERR_NOTAVAILABLE;
4161 if(pow2Width != This->currentDesc.Width ||
4162 pow2Height != This->currentDesc.Height) {
4163 This->Flags |= SFLAG_NONPOW2;
4166 TRACE("%p\n", This);
4167 if ((This->pow2Width > GL_LIMITS(texture_size) || This->pow2Height > GL_LIMITS(texture_size)) && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))) {
4168 /* one of three options
4169 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)
4170 2: Set the texture to the maximum size (bad idea)
4171 3: WARN and return WINED3DERR_NOTAVAILABLE;
4172 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.
4174 WARN("(%p) Creating an oversized surface: %ux%u (texture is %ux%u)\n",
4175 This, This->pow2Width, This->pow2Height, This->currentDesc.Width, This->currentDesc.Height);
4176 This->Flags |= SFLAG_OVERSIZE;
4178 /* This will be initialized on the first blt */
4179 This->glRect.left = 0;
4180 This->glRect.top = 0;
4181 This->glRect.right = 0;
4182 This->glRect.bottom = 0;
4184 /* Check this after the oversize check - do not make an oversized surface a texture_rectangle one.
4185 Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
4186 is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
4187 doesn't work in combination with ARB_TEXTURE_RECTANGLE.
4189 if(This->Flags & SFLAG_NONPOW2 && GL_SUPPORT(ARB_TEXTURE_RECTANGLE)
4190 && !((This->resource.format_desc->format == WINED3DFMT_P8) && GL_SUPPORT(EXT_PALETTED_TEXTURE)
4191 && (wined3d_settings.rendertargetlock_mode == RTL_READTEX
4192 || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX)))
4194 This->glDescription.target = GL_TEXTURE_RECTANGLE_ARB;
4195 This->pow2Width = This->currentDesc.Width;
4196 This->pow2Height = This->currentDesc.Height;
4197 This->Flags &= ~(SFLAG_NONPOW2 | SFLAG_NORMCOORD);
4200 /* No oversize, gl rect is the full texture size */
4201 This->Flags &= ~SFLAG_OVERSIZE;
4202 This->glRect.left = 0;
4203 This->glRect.top = 0;
4204 This->glRect.right = This->pow2Width;
4205 This->glRect.bottom = This->pow2Height;
4208 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
4209 switch(wined3d_settings.offscreen_rendering_mode) {
4210 case ORM_FBO: This->get_drawable_size = get_drawable_size_fbo; break;
4211 case ORM_PBUFFER: This->get_drawable_size = get_drawable_size_pbuffer; break;
4212 case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
4216 This->Flags |= SFLAG_INSYSMEM;
4221 struct depth_blt_info
4225 enum tex_types tex_type;
4226 GLfloat coords[4][3];
4229 static void surface_get_depth_blt_info(GLenum target, GLsizei w, GLsizei h, struct depth_blt_info *info)
4231 GLfloat (*coords)[3] = info->coords;
4236 FIXME("Unsupported texture target %#x\n", target);
4237 /* Fall back to GL_TEXTURE_2D */
4239 info->binding = GL_TEXTURE_BINDING_2D;
4240 info->bind_target = GL_TEXTURE_2D;
4241 info->tex_type = tex_2d;
4242 coords[0][0] = 0.0f; coords[0][1] = 1.0f; coords[0][2] = 0.0f;
4243 coords[1][0] = 1.0f; coords[1][1] = 1.0f; coords[1][2] = 0.0f;
4244 coords[2][0] = 0.0f; coords[2][1] = 0.0f; coords[2][2] = 0.0f;
4245 coords[3][0] = 1.0f; coords[3][1] = 0.0f; coords[3][2] = 0.0f;
4248 case GL_TEXTURE_RECTANGLE_ARB:
4249 info->binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
4250 info->bind_target = GL_TEXTURE_RECTANGLE_ARB;
4251 info->tex_type = tex_rect;
4252 coords[0][0] = 0.0f; coords[0][1] = h; coords[0][2] = 0.0f;
4253 coords[1][0] = w; coords[1][1] = h; coords[1][2] = 0.0f;
4254 coords[2][0] = 0.0f; coords[2][1] = 0.0f; coords[2][2] = 0.0f;
4255 coords[3][0] = w; coords[3][1] = 0.0f; coords[3][2] = 0.0f;
4258 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
4259 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4260 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4261 info->tex_type = tex_cube;
4262 coords[0][0] = 1.0f; coords[0][1] = -1.0f; coords[0][2] = 1.0f;
4263 coords[1][0] = 1.0f; coords[1][1] = -1.0f; coords[1][2] = -1.0f;
4264 coords[2][0] = 1.0f; coords[2][1] = 1.0f; coords[2][2] = 1.0f;
4265 coords[3][0] = 1.0f; coords[3][1] = 1.0f; coords[3][2] = -1.0f;
4267 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
4268 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4269 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4270 info->tex_type = tex_cube;
4271 coords[0][0] = -1.0f; coords[0][1] = -1.0f; coords[0][2] = -1.0f;
4272 coords[1][0] = -1.0f; coords[1][1] = -1.0f; coords[1][2] = 1.0f;
4273 coords[2][0] = -1.0f; coords[2][1] = 1.0f; coords[2][2] = -1.0f;
4274 coords[3][0] = -1.0f; coords[3][1] = 1.0f; coords[3][2] = 1.0f;
4276 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4277 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4278 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4279 info->tex_type = tex_cube;
4280 coords[0][0] = -1.0f; coords[0][1] = 1.0f; coords[0][2] = 1.0f;
4281 coords[1][0] = 1.0f; coords[1][1] = 1.0f; coords[1][2] = 1.0f;
4282 coords[2][0] = -1.0f; coords[2][1] = 1.0f; coords[2][2] = -1.0f;
4283 coords[3][0] = 1.0f; coords[3][1] = 1.0f; coords[3][2] = -1.0f;
4285 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4286 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4287 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4288 info->tex_type = tex_cube;
4289 coords[0][0] = -1.0f; coords[0][1] = -1.0f; coords[0][2] = -1.0f;
4290 coords[1][0] = 1.0f; coords[1][1] = -1.0f; coords[1][2] = -1.0f;
4291 coords[2][0] = -1.0f; coords[2][1] = -1.0f; coords[2][2] = 1.0f;
4292 coords[3][0] = 1.0f; coords[3][1] = -1.0f; coords[3][2] = 1.0f;
4294 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4295 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4296 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4297 info->tex_type = tex_cube;
4298 coords[0][0] = -1.0f; coords[0][1] = -1.0f; coords[0][2] = 1.0f;
4299 coords[1][0] = 1.0f; coords[1][1] = -1.0f; coords[1][2] = 1.0f;
4300 coords[2][0] = -1.0f; coords[2][1] = 1.0f; coords[2][2] = 1.0f;
4301 coords[3][0] = 1.0f; coords[3][1] = 1.0f; coords[3][2] = 1.0f;
4303 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4304 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4305 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4306 info->tex_type = tex_cube;
4307 coords[0][0] = 1.0f; coords[0][1] = -1.0f; coords[0][2] = -1.0f;
4308 coords[1][0] = -1.0f; coords[1][1] = -1.0f; coords[1][2] = -1.0f;
4309 coords[2][0] = 1.0f; coords[2][1] = 1.0f; coords[2][2] = -1.0f;
4310 coords[3][0] = -1.0f; coords[3][1] = 1.0f; coords[3][2] = -1.0f;
4314 /* GL locking is done by the caller */
4315 static void surface_depth_blt(IWineD3DSurfaceImpl *This, GLuint texture, GLsizei w, GLsizei h, GLenum target)
4317 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4318 struct depth_blt_info info;
4319 GLint old_binding = 0;
4321 glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_VIEWPORT_BIT);
4323 glDisable(GL_CULL_FACE);
4325 glDisable(GL_ALPHA_TEST);
4326 glDisable(GL_SCISSOR_TEST);
4327 glDisable(GL_STENCIL_TEST);
4328 glEnable(GL_DEPTH_TEST);
4329 glDepthFunc(GL_ALWAYS);
4330 glDepthMask(GL_TRUE);
4331 glBlendFunc(GL_ZERO, GL_ONE);
4332 glViewport(0, 0, w, h);
4334 surface_get_depth_blt_info(target, w, h, &info);
4335 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
4336 glGetIntegerv(info.binding, &old_binding);
4337 glBindTexture(info.bind_target, texture);
4339 device->shader_backend->shader_select_depth_blt((IWineD3DDevice *)device, info.tex_type);
4341 glBegin(GL_TRIANGLE_STRIP);
4342 glTexCoord3fv(info.coords[0]);
4343 glVertex2f(-1.0f, -1.0f);
4344 glTexCoord3fv(info.coords[1]);
4345 glVertex2f(1.0f, -1.0f);
4346 glTexCoord3fv(info.coords[2]);
4347 glVertex2f(-1.0f, 1.0f);
4348 glTexCoord3fv(info.coords[3]);
4349 glVertex2f(1.0f, 1.0f);
4352 glBindTexture(info.bind_target, old_binding);
4356 device->shader_backend->shader_deselect_depth_blt((IWineD3DDevice *)device);
4359 void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location) {
4360 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4362 TRACE("(%p) New location %#x\n", This, location);
4364 if (location & ~SFLAG_DS_LOCATIONS) {
4365 FIXME("(%p) Invalid location (%#x) specified\n", This, location);
4368 This->Flags &= ~SFLAG_DS_LOCATIONS;
4369 This->Flags |= location;
4372 void surface_load_ds_location(IWineD3DSurface *iface, DWORD location) {
4373 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4374 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4376 TRACE("(%p) New location %#x\n", This, location);
4378 /* TODO: Make this work for modes other than FBO */
4379 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return;
4381 if (This->Flags & location) {
4382 TRACE("(%p) Location (%#x) is already up to date\n", This, location);
4386 if (This->current_renderbuffer) {
4387 FIXME("(%p) Not supported with fixed up depth stencil\n", This);
4391 if (location == SFLAG_DS_OFFSCREEN) {
4392 if (This->Flags & SFLAG_DS_ONSCREEN) {
4393 GLint old_binding = 0;
4396 TRACE("(%p) Copying onscreen depth buffer to depth texture\n", This);
4400 if (!device->depth_blt_texture) {
4401 glGenTextures(1, &device->depth_blt_texture);
4404 /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
4405 * directly on the FBO texture. That's because we need to flip. */
4406 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4407 if (This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
4408 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
4409 bind_target = GL_TEXTURE_RECTANGLE_ARB;
4411 glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
4412 bind_target = GL_TEXTURE_2D;
4414 glBindTexture(bind_target, device->depth_blt_texture);
4415 glCopyTexImage2D(bind_target,
4416 This->glDescription.level,
4417 This->resource.format_desc->glInternal,
4420 This->currentDesc.Width,
4421 This->currentDesc.Height,
4423 glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4424 glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4425 glTexParameteri(bind_target, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
4426 glBindTexture(bind_target, old_binding);
4428 /* Setup the destination */
4429 if (!device->depth_blt_rb) {
4430 GL_EXTCALL(glGenRenderbuffersEXT(1, &device->depth_blt_rb));
4431 checkGLcall("glGenRenderbuffersEXT");
4433 if (device->depth_blt_rb_w != This->currentDesc.Width
4434 || device->depth_blt_rb_h != This->currentDesc.Height) {
4435 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, device->depth_blt_rb));
4436 checkGLcall("glBindRenderbufferEXT");
4437 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, This->currentDesc.Width, This->currentDesc.Height));
4438 checkGLcall("glRenderbufferStorageEXT");
4439 device->depth_blt_rb_w = This->currentDesc.Width;
4440 device->depth_blt_rb_h = This->currentDesc.Height;
4443 context_bind_fbo((IWineD3DDevice *)device, GL_FRAMEBUFFER_EXT, &device->activeContext->dst_fbo);
4444 GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, device->depth_blt_rb));
4445 checkGLcall("glFramebufferRenderbufferEXT");
4446 context_attach_depth_stencil_fbo(device, GL_FRAMEBUFFER_EXT, iface, FALSE);
4448 /* Do the actual blit */
4449 surface_depth_blt(This, device->depth_blt_texture, This->currentDesc.Width, This->currentDesc.Height, bind_target);
4450 checkGLcall("depth_blt");
4452 if (device->activeContext->current_fbo) {
4453 context_bind_fbo((IWineD3DDevice *)device, GL_FRAMEBUFFER_EXT, &device->activeContext->current_fbo->id);
4455 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4456 checkGLcall("glBindFramebuffer()");
4461 FIXME("No up to date depth stencil location\n");
4463 } else if (location == SFLAG_DS_ONSCREEN) {
4464 if (This->Flags & SFLAG_DS_OFFSCREEN) {
4465 TRACE("(%p) Copying depth texture to onscreen depth buffer\n", This);
4469 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4470 checkGLcall("glBindFramebuffer()");
4471 surface_depth_blt(This, This->glDescription.textureName, This->currentDesc.Width, This->currentDesc.Height, This->glDescription.target);
4472 checkGLcall("depth_blt");
4474 if (device->activeContext->current_fbo) {
4475 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, device->activeContext->current_fbo->id));
4476 checkGLcall("glBindFramebuffer()");
4481 FIXME("No up to date depth stencil location\n");
4484 ERR("(%p) Invalid location (%#x) specified\n", This, location);
4487 This->Flags |= location;
4490 static void WINAPI IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
4491 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4492 IWineD3DBaseTexture *texture;
4493 IWineD3DSurfaceImpl *overlay;
4495 TRACE("(%p)->(%s, %s)\n", iface, debug_surflocation(flag),
4496 persistent ? "TRUE" : "FALSE");
4498 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4499 if (This->Flags & SFLAG_SWAPCHAIN)
4501 TRACE("Surface %p is an onscreen surface\n", iface);
4503 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4504 if (flag & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)) flag |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4509 if(((This->Flags & SFLAG_INTEXTURE) && !(flag & SFLAG_INTEXTURE)) ||
4510 ((This->Flags & SFLAG_INSRGBTEX) && !(flag & SFLAG_INSRGBTEX))) {
4511 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4512 TRACE("Passing to container\n");
4513 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4514 IWineD3DBaseTexture_Release(texture);
4517 This->Flags &= ~SFLAG_LOCATIONS;
4518 This->Flags |= flag;
4520 /* Redraw emulated overlays, if any */
4521 if(flag & SFLAG_INDRAWABLE && !list_empty(&This->overlays)) {
4522 LIST_FOR_EACH_ENTRY(overlay, &This->overlays, IWineD3DSurfaceImpl, overlay_entry) {
4523 IWineD3DSurface_DrawOverlay((IWineD3DSurface *) overlay);
4527 if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) && (flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX))) {
4528 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4529 TRACE("Passing to container\n");
4530 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4531 IWineD3DBaseTexture_Release(texture);
4534 This->Flags &= ~flag;
4537 if(!(This->Flags & SFLAG_LOCATIONS)) {
4538 ERR("%p: Surface does not have any up to date location\n", This);
4554 static inline void cube_coords_float(const RECT *r, UINT w, UINT h, struct float_rect *f)
4556 f->l = ((r->left * 2.0f) / w) - 1.0f;
4557 f->t = ((r->top * 2.0f) / h) - 1.0f;
4558 f->r = ((r->right * 2.0f) / w) - 1.0f;
4559 f->b = ((r->bottom * 2.0f) / h) - 1.0f;
4562 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT *rect_in) {
4563 struct coords coords[4];
4565 IWineD3DSwapChain *swapchain;
4566 IWineD3DBaseTexture *texture;
4567 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4569 struct float_rect f;
4576 rect.right = This->currentDesc.Width;
4577 rect.bottom = This->currentDesc.Height;
4580 switch(This->glDescription.target)
4583 bind_target = GL_TEXTURE_2D;
4585 coords[0].x = (float)rect.left / This->pow2Width;
4586 coords[0].y = (float)rect.top / This->pow2Height;
4589 coords[1].x = (float)rect.left / This->pow2Width;
4590 coords[1].y = (float)rect.bottom / This->pow2Height;
4593 coords[2].x = (float)rect.right / This->pow2Width;
4594 coords[2].y = (float)rect.bottom / This->pow2Height;
4597 coords[3].x = (float)rect.right / This->pow2Width;
4598 coords[3].y = (float)rect.top / This->pow2Height;
4602 case GL_TEXTURE_RECTANGLE_ARB:
4603 bind_target = GL_TEXTURE_RECTANGLE_ARB;
4604 coords[0].x = rect.left; coords[0].y = rect.top; coords[0].z = 0;
4605 coords[1].x = rect.left; coords[1].y = rect.bottom; coords[1].z = 0;
4606 coords[2].x = rect.right; coords[2].y = rect.bottom; coords[2].z = 0;
4607 coords[3].x = rect.right; coords[3].y = rect.top; coords[3].z = 0;
4610 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
4611 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4612 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4613 coords[0].x = 1; coords[0].y = -f.t; coords[0].z = -f.l;
4614 coords[1].x = 1; coords[1].y = -f.b; coords[1].z = -f.l;
4615 coords[2].x = 1; coords[2].y = -f.b; coords[2].z = -f.r;
4616 coords[3].x = 1; coords[3].y = -f.t; coords[3].z = -f.r;
4619 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
4620 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4621 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4622 coords[0].x = -1; coords[0].y = -f.t; coords[0].z = f.l;
4623 coords[1].x = -1; coords[1].y = -f.b; coords[1].z = f.l;
4624 coords[2].x = -1; coords[2].y = -f.b; coords[2].z = f.r;
4625 coords[3].x = -1; coords[3].y = -f.t; coords[3].z = f.r;
4628 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4629 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4630 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4631 coords[0].x = f.l; coords[0].y = 1; coords[0].z = f.t;
4632 coords[1].x = f.l; coords[1].y = 1; coords[1].z = f.b;
4633 coords[2].x = f.r; coords[2].y = 1; coords[2].z = f.b;
4634 coords[3].x = f.r; coords[3].y = 1; coords[3].z = f.t;
4637 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4638 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4639 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4640 coords[0].x = f.l; coords[0].y = -1; coords[0].z = -f.t;
4641 coords[1].x = f.l; coords[1].y = -1; coords[1].z = -f.b;
4642 coords[2].x = f.r; coords[2].y = -1; coords[2].z = -f.b;
4643 coords[3].x = f.r; coords[3].y = -1; coords[3].z = -f.t;
4646 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4647 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4648 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4649 coords[0].x = f.l; coords[0].y = -f.t; coords[0].z = 1;
4650 coords[1].x = f.l; coords[1].y = -f.b; coords[1].z = 1;
4651 coords[2].x = f.r; coords[2].y = -f.b; coords[2].z = 1;
4652 coords[3].x = f.r; coords[3].y = -f.t; coords[3].z = 1;
4655 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4656 bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4657 cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4658 coords[0].x = -f.l; coords[0].y = -f.t; coords[0].z = -1;
4659 coords[1].x = -f.l; coords[1].y = -f.b; coords[1].z = -1;
4660 coords[2].x = -f.r; coords[2].y = -f.b; coords[2].z = -1;
4661 coords[3].x = -f.r; coords[3].y = -f.t; coords[3].z = -1;
4665 ERR("Unexpected texture target %#x\n", This->glDescription.target);
4669 ActivateContext(device, (IWineD3DSurface*)This, CTXUSAGE_BLIT);
4672 glEnable(bind_target);
4673 checkGLcall("glEnable(bind_target)");
4674 glBindTexture(bind_target, This->glDescription.textureName);
4675 checkGLcall("bind_target, This->glDescription.textureName)");
4676 glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4677 checkGLcall("glTexParameteri");
4678 glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4679 checkGLcall("glTexParameteri");
4681 if (device->render_offscreen)
4683 LONG tmp = rect.top;
4684 rect.top = rect.bottom;
4689 glTexCoord3fv(&coords[0].x);
4690 glVertex2i(rect.left, rect.top);
4692 glTexCoord3fv(&coords[1].x);
4693 glVertex2i(rect.left, rect.bottom);
4695 glTexCoord3fv(&coords[2].x);
4696 glVertex2i(rect.right, rect.bottom);
4698 glTexCoord3fv(&coords[3].x);
4699 glVertex2i(rect.right, rect.top);
4701 checkGLcall("glEnd");
4703 glDisable(bind_target);
4704 checkGLcall("glDisable(bind_target)");
4708 if(SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface*)This, &IID_IWineD3DSwapChain, (void **) &swapchain)))
4710 /* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
4711 if(((IWineD3DSwapChainImpl*)swapchain)->frontBuffer == (IWineD3DSurface*)This ||
4712 ((IWineD3DSwapChainImpl*)swapchain)->num_contexts >= 2)
4715 IWineD3DSwapChain_Release(swapchain);
4717 /* We changed the filtering settings on the texture. Inform the container about this to get the filters
4718 * reset properly next draw
4720 if(SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface*)This, &IID_IWineD3DBaseTexture, (void **) &texture)))
4722 ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
4723 ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
4724 ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MIPFILTER] = WINED3DTEXF_NONE;
4725 IWineD3DBaseTexture_Release(texture);
4730 /*****************************************************************************
4731 * IWineD3DSurface::LoadLocation
4733 * Copies the current surface data from wherever it is to the requested
4734 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
4735 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
4736 * multiple locations, the gl texture is preferred over the drawable, which is
4737 * preferred over system memory. The PBO counts as system memory. If rect is
4738 * not NULL, only the specified rectangle is copied (only supported for
4739 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
4740 * location is marked up to date after the copy.
4743 * flag: Surface location flag to be updated
4744 * rect: rectangle to be copied
4747 * WINED3D_OK on success
4748 * WINED3DERR_DEVICELOST on an internal error
4750 *****************************************************************************/
4751 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
4752 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4753 IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4754 GLenum format, internal, type;
4755 CONVERT_TYPES convert;
4757 int width, pitch, outpitch;
4759 BOOL drawable_read_ok = TRUE;
4761 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4762 if (This->Flags & SFLAG_SWAPCHAIN)
4764 TRACE("Surface %p is an onscreen surface\n", iface);
4766 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4767 * Prefer SFLAG_INTEXTURE. */
4768 if (flag == SFLAG_INDRAWABLE) flag = SFLAG_INTEXTURE;
4769 drawable_read_ok = FALSE;
4773 TRACE("(%p)->(%s, %p)\n", iface, debug_surflocation(flag), rect);
4775 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
4778 if(This->Flags & flag) {
4779 TRACE("Location already up to date\n");
4783 if(!(This->Flags & SFLAG_LOCATIONS)) {
4784 ERR("%p: Surface does not have any up to date location\n", This);
4785 This->Flags |= SFLAG_LOST;
4786 return WINED3DERR_DEVICELOST;
4789 if(flag == SFLAG_INSYSMEM) {
4790 surface_prepare_system_memory(This);
4792 /* Download the surface to system memory */
4793 if(This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) {
4794 if(!device->isInDraw) ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4795 surface_bind_and_dirtify(This, !(This->Flags & SFLAG_INTEXTURE));
4797 surface_download_data(This);
4799 /* Note: It might be faster to download into a texture first. */
4800 read_from_framebuffer(This, rect,
4801 This->resource.allocatedMemory,
4802 IWineD3DSurface_GetPitch(iface));
4804 } else if(flag == SFLAG_INDRAWABLE) {
4805 if(This->Flags & SFLAG_INTEXTURE) {
4806 surface_blt_to_drawable(This, rect);
4808 if((This->Flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX) {
4809 /* This needs a shader to convert the srgb data sampled from the GL texture into RGB
4810 * values, otherwise we get incorrect values in the target. For now go the slow way
4811 * via a system memory copy
4813 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4816 d3dfmt_get_conv(This, TRUE /* We need color keying */, FALSE /* We won't use textures */, &format, &internal, &type, &convert, &bpp, FALSE);
4818 /* The width is in 'length' not in bytes */
4819 width = This->currentDesc.Width;
4820 pitch = IWineD3DSurface_GetPitch(iface);
4822 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4823 * but it isn't set (yet) in all cases it is getting called. */
4824 if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
4825 TRACE("Removing the pbo attached to surface %p\n", This);
4826 surface_remove_pbo(This);
4829 if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4830 int height = This->currentDesc.Height;
4832 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4833 outpitch = width * bpp;
4834 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4836 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4838 ERR("Out of memory %d, %d!\n", outpitch, height);
4839 return WINED3DERR_OUTOFVIDEOMEMORY;
4841 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4843 This->Flags |= SFLAG_CONVERTED;
4845 This->Flags &= ~SFLAG_CONVERTED;
4846 mem = This->resource.allocatedMemory;
4849 flush_to_framebuffer_drawpixels(This, format, type, bpp, mem);
4851 /* Don't delete PBO memory */
4852 if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4853 HeapFree(GetProcessHeap(), 0, mem);
4855 } else /* if(flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) */ {
4856 if (drawable_read_ok && (This->Flags & SFLAG_INDRAWABLE)) {
4857 read_from_framebuffer_texture(This, flag == SFLAG_INSRGBTEX);
4858 } else { /* Upload from system memory */
4859 BOOL srgb = flag == SFLAG_INSRGBTEX;
4860 DWORD alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
4861 d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb);
4864 if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSYSMEM)) == SFLAG_INTEXTURE) {
4865 /* Performance warning ... */
4866 FIXME("%p: Downloading rgb texture to reload it as srgb\n", This);
4867 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4870 if((This->Flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX) {
4871 /* Performance warning ... */
4872 FIXME("%p: Downloading srgb texture to reload it as rgb\n", This);
4873 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4877 if(!device->isInDraw) ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4878 surface_bind_and_dirtify(This, srgb);
4880 if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
4881 This->Flags |= SFLAG_GLCKEY;
4882 This->glCKey = This->SrcBltCKey;
4884 else This->Flags &= ~SFLAG_GLCKEY;
4886 /* The width is in 'length' not in bytes */
4887 width = This->currentDesc.Width;
4888 pitch = IWineD3DSurface_GetPitch(iface);
4890 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4891 * but it isn't set (yet) in all cases it is getting called. */
4892 if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
4893 TRACE("Removing the pbo attached to surface %p\n", This);
4894 surface_remove_pbo(This);
4897 if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4898 int height = This->currentDesc.Height;
4900 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4901 outpitch = width * bpp;
4902 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4904 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4906 ERR("Out of memory %d, %d!\n", outpitch, height);
4907 return WINED3DERR_OUTOFVIDEOMEMORY;
4909 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4911 This->Flags |= SFLAG_CONVERTED;
4913 else if ((This->resource.format_desc->format == WINED3DFMT_P8)
4914 && (GL_SUPPORT(EXT_PALETTED_TEXTURE) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM)))
4916 d3dfmt_p8_upload_palette(iface, convert);
4917 This->Flags &= ~SFLAG_CONVERTED;
4918 mem = This->resource.allocatedMemory;
4920 This->Flags &= ~SFLAG_CONVERTED;
4921 mem = This->resource.allocatedMemory;
4924 /* Make sure the correct pitch is used */
4926 glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
4929 if ((This->Flags & SFLAG_NONPOW2) && !(This->Flags & SFLAG_OVERSIZE)) {
4930 TRACE("non power of two support\n");
4931 if(!(This->Flags & alloc_flag)) {
4932 surface_allocate_surface(This, internal, This->pow2Width, This->pow2Height, format, type);
4933 This->Flags |= alloc_flag;
4935 if (mem || (This->Flags & SFLAG_PBO)) {
4936 surface_upload_data(This, internal, This->currentDesc.Width, This->currentDesc.Height, format, type, mem);
4939 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
4940 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
4942 if(!(This->Flags & alloc_flag)) {
4943 surface_allocate_surface(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type);
4944 This->Flags |= alloc_flag;
4946 if (mem || (This->Flags & SFLAG_PBO)) {
4947 surface_upload_data(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type, mem);
4951 /* Restore the default pitch */
4953 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
4956 /* Don't delete PBO memory */
4957 if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4958 HeapFree(GetProcessHeap(), 0, mem);
4963 This->Flags |= flag;
4966 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !(This->Flags & SFLAG_SWAPCHAIN)
4967 && (This->Flags & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE))) {
4968 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4969 This->Flags |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4975 static HRESULT WINAPI IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container)
4977 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4978 IWineD3DSwapChain *swapchain = NULL;
4980 /* Update the drawable size method */
4982 IWineD3DBase_QueryInterface(container, &IID_IWineD3DSwapChain, (void **) &swapchain);
4985 This->get_drawable_size = get_drawable_size_swapchain;
4986 IWineD3DSwapChain_Release(swapchain);
4987 } else if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
4988 switch(wined3d_settings.offscreen_rendering_mode) {
4989 case ORM_FBO: This->get_drawable_size = get_drawable_size_fbo; break;
4990 case ORM_PBUFFER: This->get_drawable_size = get_drawable_size_pbuffer; break;
4991 case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
4995 return IWineD3DBaseSurfaceImpl_SetContainer(iface, container);
4998 static WINED3DSURFTYPE WINAPI IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface *iface) {
4999 return SURFACE_OPENGL;
5002 static HRESULT WINAPI IWineD3DSurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
5003 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
5006 /* If there's no destination surface there is nothing to do */
5007 if(!This->overlay_dest) return WINED3D_OK;
5009 /* Blt calls ModifyLocation on the dest surface, which in turn calls DrawOverlay to
5010 * update the overlay. Prevent an endless recursion
5012 if(This->overlay_dest->Flags & SFLAG_INOVERLAYDRAW) {
5015 This->overlay_dest->Flags |= SFLAG_INOVERLAYDRAW;
5016 hr = IWineD3DSurfaceImpl_Blt((IWineD3DSurface *) This->overlay_dest, &This->overlay_destrect,
5017 iface, &This->overlay_srcrect, WINEDDBLT_WAIT,
5018 NULL, WINED3DTEXF_LINEAR);
5019 This->overlay_dest->Flags &= ~SFLAG_INOVERLAYDRAW;
5024 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
5027 IWineD3DBaseSurfaceImpl_QueryInterface,
5028 IWineD3DBaseSurfaceImpl_AddRef,
5029 IWineD3DSurfaceImpl_Release,
5030 /* IWineD3DResource */
5031 IWineD3DBaseSurfaceImpl_GetParent,
5032 IWineD3DBaseSurfaceImpl_GetDevice,
5033 IWineD3DBaseSurfaceImpl_SetPrivateData,
5034 IWineD3DBaseSurfaceImpl_GetPrivateData,
5035 IWineD3DBaseSurfaceImpl_FreePrivateData,
5036 IWineD3DBaseSurfaceImpl_SetPriority,
5037 IWineD3DBaseSurfaceImpl_GetPriority,
5038 IWineD3DSurfaceImpl_PreLoad,
5039 IWineD3DSurfaceImpl_UnLoad,
5040 IWineD3DBaseSurfaceImpl_GetType,
5041 /* IWineD3DSurface */
5042 IWineD3DBaseSurfaceImpl_GetContainer,
5043 IWineD3DBaseSurfaceImpl_GetDesc,
5044 IWineD3DSurfaceImpl_LockRect,
5045 IWineD3DSurfaceImpl_UnlockRect,
5046 IWineD3DSurfaceImpl_GetDC,
5047 IWineD3DSurfaceImpl_ReleaseDC,
5048 IWineD3DSurfaceImpl_Flip,
5049 IWineD3DSurfaceImpl_Blt,
5050 IWineD3DBaseSurfaceImpl_GetBltStatus,
5051 IWineD3DBaseSurfaceImpl_GetFlipStatus,
5052 IWineD3DBaseSurfaceImpl_IsLost,
5053 IWineD3DBaseSurfaceImpl_Restore,
5054 IWineD3DSurfaceImpl_BltFast,
5055 IWineD3DBaseSurfaceImpl_GetPalette,
5056 IWineD3DBaseSurfaceImpl_SetPalette,
5057 IWineD3DSurfaceImpl_RealizePalette,
5058 IWineD3DBaseSurfaceImpl_SetColorKey,
5059 IWineD3DBaseSurfaceImpl_GetPitch,
5060 IWineD3DSurfaceImpl_SetMem,
5061 IWineD3DBaseSurfaceImpl_SetOverlayPosition,
5062 IWineD3DBaseSurfaceImpl_GetOverlayPosition,
5063 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
5064 IWineD3DBaseSurfaceImpl_UpdateOverlay,
5065 IWineD3DBaseSurfaceImpl_SetClipper,
5066 IWineD3DBaseSurfaceImpl_GetClipper,
5068 IWineD3DSurfaceImpl_LoadTexture,
5069 IWineD3DSurfaceImpl_BindTexture,
5070 IWineD3DSurfaceImpl_SaveSnapshot,
5071 IWineD3DSurfaceImpl_SetContainer,
5072 IWineD3DSurfaceImpl_GetGlDesc,
5073 IWineD3DBaseSurfaceImpl_GetData,
5074 IWineD3DSurfaceImpl_SetFormat,
5075 IWineD3DSurfaceImpl_PrivateSetup,
5076 IWineD3DSurfaceImpl_ModifyLocation,
5077 IWineD3DSurfaceImpl_LoadLocation,
5078 IWineD3DSurfaceImpl_GetImplType,
5079 IWineD3DSurfaceImpl_DrawOverlay
5081 #undef GLINFO_LOCATION
5083 #define GLINFO_LOCATION device->adapter->gl_info
5084 static HRESULT ffp_blit_alloc(IWineD3DDevice *iface) { return WINED3D_OK; }
5085 static void ffp_blit_free(IWineD3DDevice *iface) { }
5087 static HRESULT ffp_blit_set(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
5088 GLenum textype, UINT width, UINT height)
5092 checkGLcall("glEnable(textype)");
5097 static void ffp_blit_unset(IWineD3DDevice *iface) {
5098 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
5100 glDisable(GL_TEXTURE_2D);
5101 checkGLcall("glDisable(GL_TEXTURE_2D)");
5102 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
5103 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5104 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5106 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
5107 glDisable(GL_TEXTURE_RECTANGLE_ARB);
5108 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5113 static BOOL ffp_blit_color_fixup_supported(struct color_fixup_desc fixup)
5115 if (TRACE_ON(d3d_surface) && TRACE_ON(d3d))
5117 TRACE("Checking support for fixup:\n");
5118 dump_color_fixup_desc(fixup);
5121 /* We only support identity conversions. */
5122 if (is_identity_fixup(fixup))
5128 TRACE("[FAILED]\n");
5132 const struct blit_shader ffp_blit = {
5137 ffp_blit_color_fixup_supported