dlls/wined3d/surface.c

   1 /*
   2  * IWineD3DSurface Implementation
   3  *
   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
  13  *
  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.
  18  *
  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.
  23  *
  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
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31 #include "wined3d_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
  34 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  35 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
  36
  37 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey);
  38 static void d3dfmt_p8_upload_palette(IWineD3DSurface *iface, CONVERT_TYPES convert);
  39 static void surface_remove_pbo(IWineD3DSurfaceImpl *This);
  40
  41 void surface_force_reload(IWineD3DSurface *iface)
  42 {
  43     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
  44
  45     This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
  46 }
  47
  48 void surface_set_texture_name(IWineD3DSurface *iface, GLuint new_name, BOOL srgb)
  49 {
  50     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
  51     GLuint *name;
  52     DWORD flag;
  53
  54     if(srgb)
  55     {
  56         name = &This->glDescription.srgbTextureName;
  57         flag = SFLAG_INSRGBTEX;
  58     }
  59     else
  60     {
  61         name = &This->glDescription.textureName;
  62         flag = SFLAG_INTEXTURE;
  63     }
  64
  65     TRACE("(%p) : setting texture name %u\n", This, new_name);
  66
  67     if (!*name && new_name)
  68     {
  69         /* FIXME: We shouldn't need to remove SFLAG_INTEXTURE if the
  70          * surface has no texture name yet. See if we can get rid of this. */
  71         if (This->Flags & flag)
  72             ERR("Surface has SFLAG_INTEXTURE set, but no texture name\n");
  73         IWineD3DSurface_ModifyLocation(iface, flag, FALSE);
  74     }
  75
  76     *name = new_name;
  77     surface_force_reload(iface);
  78 }
  79
  80 void surface_set_texture_target(IWineD3DSurface *iface, GLenum target)
  81 {
  82     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
  83
  84     TRACE("(%p) : setting target %#x\n", This, target);
  85
  86     if (This->glDescription.target != target)
  87     {
  88         if (target == GL_TEXTURE_RECTANGLE_ARB)
  89         {
  90             This->Flags &= ~SFLAG_NORMCOORD;
  91         }
  92         else if (This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB)
  93         {
  94             This->Flags |= SFLAG_NORMCOORD;
  95         }
  96     }
  97     This->glDescription.target = target;
  98     surface_force_reload(iface);
  99 }
 100
 101 static void surface_bind_and_dirtify(IWineD3DSurfaceImpl *This, BOOL srgb) {
 102     int active_sampler;
 103
 104     /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
 105      * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
 106      * gl states. The current texture unit should always be a valid one.
 107      *
 108      * To be more specific, this is tricky because we can implicitly be called
 109      * from sampler() in state.c. This means we can't touch anything other than
 110      * whatever happens to be the currently active texture, or we would risk
 111      * marking already applied sampler states dirty again.
 112      *
 113      * TODO: Track the current active texture per GL context instead of using glGet
 114      */
 115     GLint active_texture;
 116     ENTER_GL();
 117     glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
 118     LEAVE_GL();
 119     active_sampler = This->resource.wineD3DDevice->rev_tex_unit_map[active_texture - GL_TEXTURE0_ARB];
 120
 121     if (active_sampler != -1) {
 122         IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_SAMPLER(active_sampler));
 123     }
 124     IWineD3DSurface_BindTexture((IWineD3DSurface *)This, srgb);
 125 }
 126
 127 /* This function checks if the primary render target uses the 8bit paletted format. */
 128 static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
 129 {
 130     if (device->render_targets && device->render_targets[0]) {
 131         IWineD3DSurfaceImpl* render_target = (IWineD3DSurfaceImpl*)device->render_targets[0];
 132         if ((render_target->resource.usage & WINED3DUSAGE_RENDERTARGET)
 133                 && (render_target->resource.format_desc->format == WINED3DFMT_P8))
 134             return TRUE;
 135     }
 136     return FALSE;
 137 }
 138
 139 /* This call just downloads data, the caller is responsible for activating the
 140  * right context and binding the correct texture. */
 141 static void surface_download_data(IWineD3DSurfaceImpl *This) {
 142     const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
 143
 144     /* Only support read back of converted P8 surfaces */
 145     if (This->Flags & SFLAG_CONVERTED && format_desc->format != WINED3DFMT_P8)
 146     {
 147         FIXME("Read back converted textures unsupported, format=%s\n", debug_d3dformat(format_desc->format));
 148         return;
 149     }
 150
 151     ENTER_GL();
 152
 153     if (format_desc->format == WINED3DFMT_DXT1 || format_desc->format == WINED3DFMT_DXT2
 154             || format_desc->format == WINED3DFMT_DXT3 || format_desc->format == WINED3DFMT_DXT4
 155             || format_desc->format == WINED3DFMT_DXT5 || format_desc->format == WINED3DFMT_ATI2N)
 156     {
 157         if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) { /* We can assume this as the texture would not have been created otherwise */
 158             FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This);
 159         } else {
 160             TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n",
 161                     This, This->glDescription.level, format_desc->glFormat, format_desc->glType,
 162                     This->resource.allocatedMemory);
 163
 164             if(This->Flags & SFLAG_PBO) {
 165                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 166                 checkGLcall("glBindBufferARB");
 167                 GL_EXTCALL(glGetCompressedTexImageARB(This->glDescription.target, This->glDescription.level, NULL));
 168                 checkGLcall("glGetCompressedTexImageARB()");
 169                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 170                 checkGLcall("glBindBufferARB");
 171             } else {
 172                 GL_EXTCALL(glGetCompressedTexImageARB(This->glDescription.target, This->glDescription.level, This->resource.allocatedMemory));
 173                 checkGLcall("glGetCompressedTexImageARB()");
 174             }
 175         }
 176         LEAVE_GL();
 177     } else {
 178         void *mem;
 179         GLenum format = format_desc->glFormat;
 180         GLenum type = format_desc->glType;
 181         int src_pitch = 0;
 182         int dst_pitch = 0;
 183
 184         /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
 185         if (format_desc->format == WINED3DFMT_P8 && primary_render_target_is_p8(This->resource.wineD3DDevice))
 186         {
 187             format = GL_ALPHA;
 188             type = GL_UNSIGNED_BYTE;
 189         }
 190
 191         if (This->Flags & SFLAG_NONPOW2) {
 192             unsigned char alignment = This->resource.wineD3DDevice->surface_alignment;
 193             src_pitch = This->bytesPerPixel * This->pow2Width;
 194             dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
 195             src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
 196             mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
 197         } else {
 198             mem = This->resource.allocatedMemory;
 199         }
 200
 201         TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This, This->glDescription.level,
 202                 format, type, mem);
 203
 204         if(This->Flags & SFLAG_PBO) {
 205             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 206             checkGLcall("glBindBufferARB");
 207
 208             glGetTexImage(This->glDescription.target, This->glDescription.level, format,
 209                           type, NULL);
 210             checkGLcall("glGetTexImage()");
 211
 212             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 213             checkGLcall("glBindBufferARB");
 214         } else {
 215             glGetTexImage(This->glDescription.target, This->glDescription.level, format,
 216                           type, mem);
 217             checkGLcall("glGetTexImage()");
 218         }
 219         LEAVE_GL();
 220
 221         if (This->Flags & SFLAG_NONPOW2) {
 222             const BYTE *src_data;
 223             BYTE *dst_data;
 224             UINT y;
 225             /*
 226              * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
 227              * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
 228              * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
 229              *
 230              * We're doing this...
 231              *
 232              * instead of boxing the texture :
 233              * |<-texture width ->|  -->pow2width|   /\
 234              * |111111111111111111|              |   |
 235              * |222 Texture 222222| boxed empty  | texture height
 236              * |3333 Data 33333333|              |   |
 237              * |444444444444444444|              |   \/
 238              * -----------------------------------   |
 239              * |     boxed  empty | boxed empty  | pow2height
 240              * |                  |              |   \/
 241              * -----------------------------------
 242              *
 243              *
 244              * we're repacking the data to the expected texture width
 245              *
 246              * |<-texture width ->|  -->pow2width|   /\
 247              * |111111111111111111222222222222222|   |
 248              * |222333333333333333333444444444444| texture height
 249              * |444444                           |   |
 250              * |                                 |   \/
 251              * |                                 |   |
 252              * |            empty                | pow2height
 253              * |                                 |   \/
 254              * -----------------------------------
 255              *
 256              * == is the same as
 257              *
 258              * |<-texture width ->|    /\
 259              * |111111111111111111|
 260              * |222222222222222222|texture height
 261              * |333333333333333333|
 262              * |444444444444444444|    \/
 263              * --------------------
 264              *
 265              * this also means that any references to allocatedMemory should work with the data as if were a
 266              * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
 267              *
 268              * internally the texture is still stored in a boxed format so any references to textureName will
 269              * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
 270              *
 271              * Performance should not be an issue, because applications normally do not lock the surfaces when
 272              * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
 273              * and doesn't have to be re-read.
 274              */
 275             src_data = mem;
 276             dst_data = This->resource.allocatedMemory;
 277             TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This, src_pitch, dst_pitch);
 278             for (y = 1 ; y < This->currentDesc.Height; y++) {
 279                 /* skip the first row */
 280                 src_data += src_pitch;
 281                 dst_data += dst_pitch;
 282                 memcpy(dst_data, src_data, dst_pitch);
 283             }
 284
 285             HeapFree(GetProcessHeap(), 0, mem);
 286         }
 287     }
 288
 289     /* Surface has now been downloaded */
 290     This->Flags |= SFLAG_INSYSMEM;
 291 }
 292
 293 /* This call just uploads data, the caller is responsible for activating the
 294  * right context and binding the correct texture. */
 295 static void surface_upload_data(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) {
 296     const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
 297
 298     if (format_desc->heightscale != 1.0 && format_desc->heightscale != 0.0) height *= format_desc->heightscale;
 299
 300     if (format_desc->format == WINED3DFMT_DXT1 || format_desc->format == WINED3DFMT_DXT2
 301             || format_desc->format == WINED3DFMT_DXT3 || format_desc->format == WINED3DFMT_DXT4
 302             || format_desc->format == WINED3DFMT_DXT5 || format_desc->format == WINED3DFMT_ATI2N)
 303     {
 304         if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
 305             FIXME("Using DXT1/3/5 without advertized support\n");
 306         } else {
 307             /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
 308              * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
 309              * function uses glCompressedTexImage2D instead of the SubImage call
 310              */
 311             TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This, width, height, data);
 312             ENTER_GL();
 313
 314             if(This->Flags & SFLAG_PBO) {
 315                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 316                 checkGLcall("glBindBufferARB");
 317                 TRACE("(%p) pbo: %#x, data: %p\n", This, This->pbo, data);
 318
 319                 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
 320                         width, height, 0 /* border */, This->resource.size, NULL));
 321                 checkGLcall("glCompressedTexSubImage2D");
 322
 323                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 324                 checkGLcall("glBindBufferARB");
 325             } else {
 326                 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
 327                         width, height, 0 /* border */, This->resource.size, data));
 328                 checkGLcall("glCompressedTexSubImage2D");
 329             }
 330             LEAVE_GL();
 331         }
 332     } else {
 333         TRACE("(%p) : Calling glTexSubImage2D w %d,  h %d, data, %p\n", This, width, height, data);
 334         ENTER_GL();
 335
 336         if(This->Flags & SFLAG_PBO) {
 337             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 338             checkGLcall("glBindBufferARB");
 339             TRACE("(%p) pbo: %#x, data: %p\n", This, This->pbo, data);
 340
 341             glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, NULL);
 342             checkGLcall("glTexSubImage2D");
 343
 344             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 345             checkGLcall("glBindBufferARB");
 346         }
 347         else {
 348             glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, data);
 349             checkGLcall("glTexSubImage2D");
 350         }
 351
 352         LEAVE_GL();
 353     }
 354 }
 355
 356 /* This call just allocates the texture, the caller is responsible for
 357  * activating the right context and binding the correct texture. */
 358 static void surface_allocate_surface(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type) {
 359     const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
 360     BOOL enable_client_storage = FALSE;
 361     const BYTE *mem = NULL;
 362
 363     if (format_desc->heightscale != 1.0 && format_desc->heightscale != 0.0) height *= format_desc->heightscale;
 364
 365     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",
 366             This, This->glDescription.target, This->glDescription.level, debug_d3dformat(format_desc->format),
 367             internal, width, height, format, type);
 368
 369     if (format_desc->format == WINED3DFMT_DXT1 || format_desc->format == WINED3DFMT_DXT2
 370             || format_desc->format == WINED3DFMT_DXT3 || format_desc->format == WINED3DFMT_DXT4
 371             || format_desc->format == WINED3DFMT_DXT5 || format_desc->format == WINED3DFMT_ATI2N)
 372     {
 373         /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
 374         TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
 375
 376         /* We have to point GL to the client storage memory here, because upload_data might use a PBO. This means a double upload
 377          * once, unfortunately
 378          */
 379         if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
 380             /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
 381             This->Flags |= SFLAG_CLIENT;
 382             mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 383             ENTER_GL();
 384             GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
 385                        width, height, 0 /* border */, This->resource.size, mem));
 386             LEAVE_GL();
 387         }
 388
 389         return;
 390     }
 391
 392     ENTER_GL();
 393
 394     if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
 395         if(This->Flags & (SFLAG_NONPOW2 | SFLAG_DIBSECTION | SFLAG_OVERSIZE | SFLAG_CONVERTED) || This->resource.allocatedMemory == NULL) {
 396             /* In some cases we want to disable client storage.
 397              * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
 398              * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
 399              * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
 400              * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
 401              * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
 402              */
 403             glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
 404             checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
 405             This->Flags &= ~SFLAG_CLIENT;
 406             enable_client_storage = TRUE;
 407         } else {
 408             This->Flags |= SFLAG_CLIENT;
 409
 410             /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
 411              * it might point into a pbo. Instead use heapMemory, but get the alignment right.
 412              */
 413             mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 414         }
 415     }
 416     glTexImage2D(This->glDescription.target, This->glDescription.level, internal, width, height, 0, format, type, mem);
 417     checkGLcall("glTexImage2D");
 418
 419     if(enable_client_storage) {
 420         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
 421         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
 422     }
 423     LEAVE_GL();
 424 }
 425
 426 /* In D3D the depth stencil dimensions have to be greater than or equal to the
 427  * render target dimensions. With FBOs, the dimensions have to be an exact match. */
 428 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
 429 void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height) {
 430     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 431     renderbuffer_entry_t *entry;
 432     GLuint renderbuffer = 0;
 433     unsigned int src_width, src_height;
 434
 435     src_width = This->pow2Width;
 436     src_height = This->pow2Height;
 437
 438     /* A depth stencil smaller than the render target is not valid */
 439     if (width > src_width || height > src_height) return;
 440
 441     /* Remove any renderbuffer set if the sizes match */
 442     if (width == src_width && height == src_height) {
 443         This->current_renderbuffer = NULL;
 444         return;
 445     }
 446
 447     /* Look if we've already got a renderbuffer of the correct dimensions */
 448     LIST_FOR_EACH_ENTRY(entry, &This->renderbuffers, renderbuffer_entry_t, entry) {
 449         if (entry->width == width && entry->height == height) {
 450             renderbuffer = entry->id;
 451             This->current_renderbuffer = entry;
 452             break;
 453         }
 454     }
 455
 456     if (!renderbuffer) {
 457         GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer));
 458         GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer));
 459         GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
 460                 This->resource.format_desc->glInternal, width, height));
 461
 462         entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
 463         entry->width = width;
 464         entry->height = height;
 465         entry->id = renderbuffer;
 466         list_add_head(&This->renderbuffers, &entry->entry);
 467
 468         This->current_renderbuffer = entry;
 469     }
 470
 471     checkGLcall("set_compatible_renderbuffer");
 472 }
 473
 474 GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain) {
 475     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 476     IWineD3DSwapChainImpl *swapchain_impl = (IWineD3DSwapChainImpl *)swapchain;
 477
 478     TRACE("(%p) : swapchain %p\n", This, swapchain);
 479
 480     if (swapchain_impl->backBuffer && swapchain_impl->backBuffer[0] == iface) {
 481         TRACE("Returning GL_BACK\n");
 482         return GL_BACK;
 483     } else if (swapchain_impl->frontBuffer == iface) {
 484         TRACE("Returning GL_FRONT\n");
 485         return GL_FRONT;
 486     }
 487
 488     FIXME("Higher back buffer, returning GL_BACK\n");
 489     return GL_BACK;
 490 }
 491
 492 /* Slightly inefficient way to handle multiple dirty rects but it works :) */
 493 void surface_add_dirty_rect(IWineD3DSurface *iface, const RECT *dirty_rect)
 494 {
 495     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 496     IWineD3DBaseTexture *baseTexture = NULL;
 497
 498     if (!(This->Flags & SFLAG_INSYSMEM) && (This->Flags & SFLAG_INTEXTURE))
 499         IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL /* no partial locking for textures yet */);
 500
 501     IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
 502     if (dirty_rect)
 503     {
 504         This->dirtyRect.left = min(This->dirtyRect.left, dirty_rect->left);
 505         This->dirtyRect.top = min(This->dirtyRect.top, dirty_rect->top);
 506         This->dirtyRect.right = max(This->dirtyRect.right, dirty_rect->right);
 507         This->dirtyRect.bottom = max(This->dirtyRect.bottom, dirty_rect->bottom);
 508     }
 509     else
 510     {
 511         This->dirtyRect.left = 0;
 512         This->dirtyRect.top = 0;
 513         This->dirtyRect.right = This->currentDesc.Width;
 514         This->dirtyRect.bottom = This->currentDesc.Height;
 515     }
 516
 517     TRACE("(%p) : Dirty: yes, Rect:(%d, %d, %d, %d)\n", This, This->dirtyRect.left,
 518             This->dirtyRect.top, This->dirtyRect.right, This->dirtyRect.bottom);
 519
 520     /* if the container is a basetexture then mark it dirty. */
 521     if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture)))
 522     {
 523         TRACE("Passing to container\n");
 524         IWineD3DBaseTexture_SetDirty(baseTexture, TRUE);
 525         IWineD3DBaseTexture_Release(baseTexture);
 526     }
 527 }
 528
 529 static ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface)
 530 {
 531     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 532     ULONG ref = InterlockedDecrement(&This->resource.ref);
 533     TRACE("(%p) : Releasing from %d\n", This, ref + 1);
 534     if (ref == 0) {
 535         IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 536         renderbuffer_entry_t *entry, *entry2;
 537         TRACE("(%p) : cleaning up\n", This);
 538
 539         /* Need a context to destroy the texture. Use the currently active render target, but only if
 540          * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
 541          * When destroying the primary rt, Uninit3D will activate a context before doing anything
 542          */
 543         if(device->render_targets && device->render_targets[0]) {
 544             ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 545         }
 546
 547         ENTER_GL();
 548         if (This->glDescription.textureName != 0) { /* release the openGL texture.. */
 549             TRACE("Deleting texture %d\n", This->glDescription.textureName);
 550             glDeleteTextures(1, &This->glDescription.textureName);
 551         }
 552
 553         if(This->Flags & SFLAG_PBO) {
 554             /* Delete the PBO */
 555             GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
 556         }
 557
 558         LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry) {
 559             GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry->id));
 560             HeapFree(GetProcessHeap(), 0, entry);
 561         }
 562         LEAVE_GL();
 563
 564         if(This->Flags & SFLAG_DIBSECTION) {
 565             /* Release the DC */
 566             SelectObject(This->hDC, This->dib.holdbitmap);
 567             DeleteDC(This->hDC);
 568             /* Release the DIB section */
 569             DeleteObject(This->dib.DIBsection);
 570             This->dib.bitmap_data = NULL;
 571             This->resource.allocatedMemory = NULL;
 572         }
 573         if(This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem(iface, NULL);
 574
 575         HeapFree(GetProcessHeap(), 0, This->palette9);
 576
 577         resource_cleanup((IWineD3DResource *)iface);
 578
 579         if(This->overlay_dest) {
 580             list_remove(&This->overlay_entry);
 581         }
 582
 583         TRACE("(%p) Released\n", This);
 584         HeapFree(GetProcessHeap(), 0, This);
 585
 586     }
 587     return ref;
 588 }
 589
 590 /* ****************************************************
 591    IWineD3DSurface IWineD3DResource parts follow
 592    **************************************************** */
 593
 594 void surface_internal_preload(IWineD3DSurface *iface, enum WINED3DSRGB srgb)
 595 {
 596     /* TODO: check for locks */
 597     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 598     IWineD3DBaseTexture *baseTexture = NULL;
 599     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 600
 601     TRACE("(%p)Checking to see if the container is a base texture\n", This);
 602     if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
 603         IWineD3DBaseTextureImpl *tex_impl = (IWineD3DBaseTextureImpl *) baseTexture;
 604         TRACE("Passing to container\n");
 605         tex_impl->baseTexture.internal_preload(baseTexture, SRGB_RGB);
 606         IWineD3DBaseTexture_Release(baseTexture);
 607     } else {
 608         TRACE("(%p) : About to load surface\n", This);
 609
 610         if(!device->isInDraw) {
 611             ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 612         }
 613
 614         if (This->resource.format_desc->format == WINED3DFMT_P8
 615                 || This->resource.format_desc->format == WINED3DFMT_A8P8)
 616         {
 617             if(palette9_changed(This)) {
 618                 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
 619                 /* TODO: This is not necessarily needed with hw palettized texture support */
 620                 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
 621                 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
 622                 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
 623             }
 624         }
 625
 626         IWineD3DSurface_LoadTexture(iface, srgb == SRGB_SRGB ? TRUE : FALSE);
 627
 628         if (This->resource.pool == WINED3DPOOL_DEFAULT) {
 629             /* Tell opengl to try and keep this texture in video ram (well mostly) */
 630             GLclampf tmp;
 631             tmp = 0.9f;
 632             ENTER_GL();
 633             glPrioritizeTextures(1, &This->glDescription.textureName, &tmp);
 634             LEAVE_GL();
 635         }
 636     }
 637     return;
 638 }
 639
 640 static void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface) {
 641     surface_internal_preload(iface, SRGB_ANY);
 642 }
 643
 644 static void surface_remove_pbo(IWineD3DSurfaceImpl *This) {
 645     This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
 646     This->resource.allocatedMemory =
 647             (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 648
 649     ENTER_GL();
 650     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 651     checkGLcall("glBindBuffer(GL_PIXEL_UNPACK_BUFFER, This->pbo)");
 652     GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0, This->resource.size, This->resource.allocatedMemory));
 653     checkGLcall("glGetBufferSubData");
 654     GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
 655     checkGLcall("glDeleteBuffers");
 656     LEAVE_GL();
 657
 658     This->pbo = 0;
 659     This->Flags &= ~SFLAG_PBO;
 660 }
 661
 662 static void WINAPI IWineD3DSurfaceImpl_UnLoad(IWineD3DSurface *iface) {
 663     IWineD3DBaseTexture *texture = NULL;
 664     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
 665     renderbuffer_entry_t *entry, *entry2;
 666     TRACE("(%p)\n", iface);
 667
 668     if(This->resource.pool == WINED3DPOOL_DEFAULT) {
 669         /* Default pool resources are supposed to be destroyed before Reset is called.
 670          * Implicit resources stay however. So this means we have an implicit render target
 671          * or depth stencil. The content may be destroyed, but we still have to tear down
 672          * opengl resources, so we cannot leave early.
 673          *
 674          * Put the most up to date surface location into the drawable. D3D-wise this content
 675          * is undefined, so it would be nowhere, but that would make the location management
 676          * more complicated. The drawable is a sane location, because if we mark sysmem or
 677          * texture up to date, drawPrim will copy the uninitialized texture or sysmem to the
 678          * uninitialized drawable. That's pointless and we'd have to allocate the texture /
 679          * sysmem copy here.
 680          */
 681         if (This->resource.usage & WINED3DUSAGE_DEPTHSTENCIL) {
 682             IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
 683         } else {
 684             IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, TRUE);
 685         }
 686     } else {
 687         /* Load the surface into system memory */
 688         IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
 689         IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
 690     }
 691     IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
 692     This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
 693
 694     /* Destroy PBOs, but load them into real sysmem before */
 695     if(This->Flags & SFLAG_PBO) {
 696         surface_remove_pbo(This);
 697     }
 698
 699     /* Destroy fbo render buffers. This is needed for implicit render targets, for
 700      * all application-created targets the application has to release the surface
 701      * before calling _Reset
 702      */
 703     LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry) {
 704         ENTER_GL();
 705         GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry->id));
 706         LEAVE_GL();
 707         list_remove(&entry->entry);
 708         HeapFree(GetProcessHeap(), 0, entry);
 709     }
 710     list_init(&This->renderbuffers);
 711     This->current_renderbuffer = NULL;
 712
 713     /* If we're in a texture, the texture name belongs to the texture. Otherwise,
 714      * destroy it
 715      */
 716     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **) &texture);
 717     if(!texture) {
 718         ENTER_GL();
 719         glDeleteTextures(1, &This->glDescription.textureName);
 720         This->glDescription.textureName = 0;
 721         LEAVE_GL();
 722     } else {
 723         IWineD3DBaseTexture_Release(texture);
 724     }
 725     return;
 726 }
 727
 728 /* ******************************************************
 729    IWineD3DSurface IWineD3DSurface parts follow
 730    ****************************************************** */
 731
 732 static void WINAPI IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription)
 733 {
 734     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 735     TRACE("(%p) : returning %p\n", This, &This->glDescription);
 736     *glDescription = &This->glDescription;
 737 }
 738
 739 /* Read the framebuffer back into the surface */
 740 static void read_from_framebuffer(IWineD3DSurfaceImpl *This, CONST RECT *rect, void *dest, UINT pitch) {
 741     IWineD3DSwapChainImpl *swapchain;
 742     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
 743     BYTE *mem;
 744     GLint fmt;
 745     GLint type;
 746     BYTE *row, *top, *bottom;
 747     int i;
 748     BOOL bpp;
 749     RECT local_rect;
 750     BOOL srcIsUpsideDown;
 751     GLint rowLen = 0;
 752     GLint skipPix = 0;
 753     GLint skipRow = 0;
 754
 755     if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
 756         static BOOL warned = FALSE;
 757         if(!warned) {
 758             ERR("The application tries to lock the render target, but render target locking is disabled\n");
 759             warned = TRUE;
 760         }
 761         return;
 762     }
 763
 764     /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
 765      * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
 766      * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
 767      * context->last_was_blit set on the unlock.
 768      */
 769     ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
 770     ENTER_GL();
 771
 772     /* Select the correct read buffer, and give some debug output.
 773      * There is no need to keep track of the current read buffer or reset it, every part of the code
 774      * that reads sets the read buffer as desired.
 775      */
 776     if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&swapchain)))
 777     {
 778         GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
 779         TRACE("Locking %#x buffer\n", buffer);
 780         glReadBuffer(buffer);
 781         checkGLcall("glReadBuffer");
 782
 783         IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
 784         srcIsUpsideDown = FALSE;
 785     } else {
 786         /* Locking the primary render target which is not on a swapchain(=offscreen render target).
 787          * Read from the back buffer
 788          */
 789         TRACE("Locking offscreen render target\n");
 790         glReadBuffer(myDevice->offscreenBuffer);
 791         srcIsUpsideDown = TRUE;
 792     }
 793
 794     /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
 795     if(!rect) {
 796         local_rect.left = 0;
 797         local_rect.top = 0;
 798         local_rect.right = This->currentDesc.Width;
 799         local_rect.bottom = This->currentDesc.Height;
 800     } else {
 801         local_rect = *rect;
 802     }
 803     /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
 804
 805     switch(This->resource.format_desc->format)
 806     {
 807         case WINED3DFMT_P8:
 808         {
 809             if(primary_render_target_is_p8(myDevice)) {
 810                 /* In case of P8 render targets the index is stored in the alpha component */
 811                 fmt = GL_ALPHA;
 812                 type = GL_UNSIGNED_BYTE;
 813                 mem = dest;
 814                 bpp = This->bytesPerPixel;
 815             } else {
 816                 /* GL can't return palettized data, so read ARGB pixels into a
 817                  * separate block of memory and convert them into palettized format
 818                  * in software. Slow, but if the app means to use palettized render
 819                  * targets and locks it...
 820                  *
 821                  * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
 822                  * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
 823                  * for the color channels when palettizing the colors.
 824                  */
 825                 fmt = GL_RGB;
 826                 type = GL_UNSIGNED_BYTE;
 827                 pitch *= 3;
 828                 mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * 3);
 829                 if(!mem) {
 830                     ERR("Out of memory\n");
 831                     LEAVE_GL();
 832                     return;
 833                 }
 834                 bpp = This->bytesPerPixel * 3;
 835             }
 836         }
 837         break;
 838
 839         default:
 840             mem = dest;
 841             fmt = This->resource.format_desc->glFormat;
 842             type = This->resource.format_desc->glType;
 843             bpp = This->bytesPerPixel;
 844     }
 845
 846     if(This->Flags & SFLAG_PBO) {
 847         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 848         checkGLcall("glBindBufferARB");
 849         if(mem != NULL) {
 850             ERR("mem not null for pbo -- unexpected\n");
 851             mem = NULL;
 852         }
 853     }
 854
 855     /* Save old pixel store pack state */
 856     glGetIntegerv(GL_PACK_ROW_LENGTH, &rowLen);
 857     checkGLcall("glIntegerv");
 858     glGetIntegerv(GL_PACK_SKIP_PIXELS, &skipPix);
 859     checkGLcall("glIntegerv");
 860     glGetIntegerv(GL_PACK_SKIP_ROWS, &skipRow);
 861     checkGLcall("glIntegerv");
 862
 863     /* Setup pixel store pack state -- to glReadPixels into the correct place */
 864     glPixelStorei(GL_PACK_ROW_LENGTH, This->currentDesc.Width);
 865     checkGLcall("glPixelStorei");
 866     glPixelStorei(GL_PACK_SKIP_PIXELS, local_rect.left);
 867     checkGLcall("glPixelStorei");
 868     glPixelStorei(GL_PACK_SKIP_ROWS, local_rect.top);
 869     checkGLcall("glPixelStorei");
 870
 871     glReadPixels(local_rect.left, (!srcIsUpsideDown) ? (This->currentDesc.Height - local_rect.bottom) : local_rect.top ,
 872                  local_rect.right - local_rect.left,
 873                  local_rect.bottom - local_rect.top,
 874                  fmt, type, mem);
 875     checkGLcall("glReadPixels");
 876
 877     /* Reset previous pixel store pack state */
 878     glPixelStorei(GL_PACK_ROW_LENGTH, rowLen);
 879     checkGLcall("glPixelStorei");
 880     glPixelStorei(GL_PACK_SKIP_PIXELS, skipPix);
 881     checkGLcall("glPixelStorei");
 882     glPixelStorei(GL_PACK_SKIP_ROWS, skipRow);
 883     checkGLcall("glPixelStorei");
 884
 885     if(This->Flags & SFLAG_PBO) {
 886         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 887         checkGLcall("glBindBufferARB");
 888
 889         /* Check if we need to flip the image. If we need to flip use glMapBufferARB
 890          * to get a pointer to it and perform the flipping in software. This is a lot
 891          * faster than calling glReadPixels for each line. In case we want more speed
 892          * we should rerender it flipped in a FBO and read the data back from the FBO. */
 893         if(!srcIsUpsideDown) {
 894             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 895             checkGLcall("glBindBufferARB");
 896
 897             mem = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
 898             checkGLcall("glMapBufferARB");
 899         }
 900     }
 901
 902     /* TODO: Merge this with the palettization loop below for P8 targets */
 903     if(!srcIsUpsideDown) {
 904         UINT len, off;
 905         /* glReadPixels returns the image upside down, and there is no way to prevent this.
 906             Flip the lines in software */
 907         len = (local_rect.right - local_rect.left) * bpp;
 908         off = local_rect.left * bpp;
 909
 910         row = HeapAlloc(GetProcessHeap(), 0, len);
 911         if(!row) {
 912             ERR("Out of memory\n");
 913             if (This->resource.format_desc->format == WINED3DFMT_P8) HeapFree(GetProcessHeap(), 0, mem);
 914             LEAVE_GL();
 915             return;
 916         }
 917
 918         top = mem + pitch * local_rect.top;
 919         bottom = mem + pitch * (local_rect.bottom - 1);
 920         for(i = 0; i < (local_rect.bottom - local_rect.top) / 2; i++) {
 921             memcpy(row, top + off, len);
 922             memcpy(top + off, bottom + off, len);
 923             memcpy(bottom + off, row, len);
 924             top += pitch;
 925             bottom -= pitch;
 926         }
 927         HeapFree(GetProcessHeap(), 0, row);
 928
 929         /* Unmap the temp PBO buffer */
 930         if(This->Flags & SFLAG_PBO) {
 931             GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
 932             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 933         }
 934     }
 935
 936     LEAVE_GL();
 937
 938     /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
 939      * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
 940      * the same color but we have no choice.
 941      * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
 942      */
 943     if ((This->resource.format_desc->format == WINED3DFMT_P8) && !primary_render_target_is_p8(myDevice))
 944     {
 945         const PALETTEENTRY *pal = NULL;
 946         DWORD width = pitch / 3;
 947         int x, y, c;
 948
 949         if(This->palette) {
 950             pal = This->palette->palents;
 951         } else {
 952             ERR("Palette is missing, cannot perform inverse palette lookup\n");
 953             HeapFree(GetProcessHeap(), 0, mem);
 954             return ;
 955         }
 956
 957         for(y = local_rect.top; y < local_rect.bottom; y++) {
 958             for(x = local_rect.left; x < local_rect.right; x++) {
 959                 /*                      start              lines            pixels      */
 960                 const BYTE *blue = mem + y * pitch + x * (sizeof(BYTE) * 3);
 961                 const BYTE *green = blue  + 1;
 962                 const BYTE *red = green + 1;
 963
 964                 for(c = 0; c < 256; c++) {
 965                     if(*red   == pal[c].peRed   &&
 966                        *green == pal[c].peGreen &&
 967                        *blue  == pal[c].peBlue)
 968                     {
 969                         *((BYTE *) dest + y * width + x) = c;
 970                         break;
 971                     }
 972                 }
 973             }
 974         }
 975         HeapFree(GetProcessHeap(), 0, mem);
 976     }
 977 }
 978
 979 /* Read the framebuffer contents into a texture */
 980 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl *This, BOOL srgb)
 981 {
 982     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 983     IWineD3DSwapChainImpl *swapchain;
 984     int bpp;
 985     GLenum format, internal, type;
 986     CONVERT_TYPES convert;
 987     GLint prevRead;
 988     BOOL alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
 989
 990     d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb);
 991
 992     /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
 993      * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
 994      * states in the stateblock, and no driver was found yet that had bugs in that regard.
 995      */
 996     ActivateContext(device, (IWineD3DSurface *) This, CTXUSAGE_RESOURCELOAD);
 997     surface_bind_and_dirtify(This, srgb);
 998
 999     ENTER_GL();
1000     glGetIntegerv(GL_READ_BUFFER, &prevRead);
1001     LEAVE_GL();
1002
1003     /* Select the correct read buffer, and give some debug output.
1004      * There is no need to keep track of the current read buffer or reset it, every part of the code
1005      * that reads sets the read buffer as desired.
1006      */
1007     if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)This, &IID_IWineD3DSwapChain, (void **)&swapchain)))
1008     {
1009         GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
1010         TRACE("Locking %#x buffer\n", buffer);
1011
1012         ENTER_GL();
1013         glReadBuffer(buffer);
1014         checkGLcall("glReadBuffer");
1015         LEAVE_GL();
1016
1017         IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
1018     } else {
1019         /* Locking the primary render target which is not on a swapchain(=offscreen render target).
1020          * Read from the back buffer
1021          */
1022         TRACE("Locking offscreen render target\n");
1023         ENTER_GL();
1024         glReadBuffer(device->offscreenBuffer);
1025         checkGLcall("glReadBuffer");
1026         LEAVE_GL();
1027     }
1028
1029     if(!(This->Flags & alloc_flag)) {
1030         surface_allocate_surface(This, internal, This->pow2Width,
1031                                  This->pow2Height, format, type);
1032         This->Flags |= alloc_flag;
1033     }
1034
1035     ENTER_GL();
1036     /* If !SrcIsUpsideDown we should flip the surface.
1037      * This can be done using glCopyTexSubImage2D but this
1038      * is VERY slow, so don't do that. We should prevent
1039      * this code from getting called in such cases or perhaps
1040      * we can use FBOs */
1041
1042     glCopyTexSubImage2D(This->glDescription.target,
1043                         This->glDescription.level,
1044                         0, 0, 0, 0,
1045                         This->currentDesc.Width,
1046                         This->currentDesc.Height);
1047     checkGLcall("glCopyTexSubImage2D");
1048
1049     glReadBuffer(prevRead);
1050     checkGLcall("glReadBuffer");
1051
1052     LEAVE_GL();
1053     TRACE("Updated target %d\n", This->glDescription.target);
1054 }
1055
1056 static void surface_prepare_system_memory(IWineD3DSurfaceImpl *This) {
1057     /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
1058      * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
1059      * changed
1060      */
1061     if(!(This->Flags & SFLAG_DYNLOCK)) {
1062         This->lockCount++;
1063         /* MAXLOCKCOUNT is defined in wined3d_private.h */
1064         if(This->lockCount > MAXLOCKCOUNT) {
1065             TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
1066             This->Flags |= SFLAG_DYNLOCK;
1067         }
1068     }
1069
1070     /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
1071      * Also don't create a PBO for systemmem surfaces.
1072      */
1073     if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT) && (This->Flags & SFLAG_DYNLOCK) && !(This->Flags & (SFLAG_PBO | SFLAG_CONVERTED | SFLAG_NONPOW2)) && (This->resource.pool != WINED3DPOOL_SYSTEMMEM)) {
1074         GLenum error;
1075         IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1076
1077         ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1078         ENTER_GL();
1079
1080         GL_EXTCALL(glGenBuffersARB(1, &This->pbo));
1081         error = glGetError();
1082         if(This->pbo == 0 || error != GL_NO_ERROR) {
1083             ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error), error);
1084         }
1085
1086         TRACE("Attaching pbo=%#x to (%p)\n", This->pbo, This);
1087
1088         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1089         checkGLcall("glBindBufferARB");
1090
1091         GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->resource.size + 4, This->resource.allocatedMemory, GL_STREAM_DRAW_ARB));
1092         checkGLcall("glBufferDataARB");
1093
1094         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1095         checkGLcall("glBindBufferARB");
1096
1097         /* We don't need the system memory anymore and we can't even use it for PBOs */
1098         if(!(This->Flags & SFLAG_CLIENT)) {
1099             HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
1100             This->resource.heapMemory = NULL;
1101         }
1102         This->resource.allocatedMemory = NULL;
1103         This->Flags |= SFLAG_PBO;
1104         LEAVE_GL();
1105     } else if(!(This->resource.allocatedMemory || This->Flags & SFLAG_PBO)) {
1106         /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
1107          * or a pbo to map
1108          */
1109         if(!This->resource.heapMemory) {
1110             This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
1111         }
1112         This->resource.allocatedMemory =
1113                 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1114         if(This->Flags & SFLAG_INSYSMEM) {
1115             ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1116         }
1117     }
1118 }
1119
1120 static HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
1121     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1122     IWineD3DDeviceImpl  *myDevice = This->resource.wineD3DDevice;
1123     IWineD3DSwapChain *swapchain = NULL;
1124
1125     TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This, pRect, Flags, pLockedRect, This->resource.allocatedMemory);
1126
1127     /* This is also done in the base class, but we have to verify this before loading any data from
1128      * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1129      * may interfere, and all other bad things may happen
1130      */
1131     if (This->Flags & SFLAG_LOCKED) {
1132         WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1133         return WINED3DERR_INVALIDCALL;
1134     }
1135     This->Flags |= SFLAG_LOCKED;
1136
1137     if (!(This->Flags & SFLAG_LOCKABLE))
1138     {
1139         TRACE("Warning: trying to lock unlockable surf@%p\n", This);
1140     }
1141
1142     if (Flags & WINED3DLOCK_DISCARD) {
1143         /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
1144         TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
1145         surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1146         This->Flags |= SFLAG_INSYSMEM;
1147         goto lock_end;
1148     }
1149
1150     if (This->Flags & SFLAG_INSYSMEM) {
1151         TRACE("Local copy is up to date, not downloading data\n");
1152         surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1153         goto lock_end;
1154     }
1155
1156     /* Now download the surface content from opengl
1157      * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
1158      * Offscreen targets which are not active at the moment or are higher targets(FBOs) can be locked with the texture path
1159      */
1160     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain);
1161     if(swapchain || iface == myDevice->render_targets[0]) {
1162         const RECT *pass_rect = pRect;
1163
1164         /* IWineD3DSurface_LoadLocation does not check if the rectangle specifies the full surfaces
1165          * because most caller functions do not need that. So do that here
1166          */
1167         if(pRect &&
1168            pRect->top    == 0 &&
1169            pRect->left   == 0 &&
1170            pRect->right  == This->currentDesc.Width &&
1171            pRect->bottom == This->currentDesc.Height) {
1172             pass_rect = NULL;
1173         }
1174
1175         switch(wined3d_settings.rendertargetlock_mode) {
1176             case RTL_TEXDRAW:
1177             case RTL_TEXTEX:
1178                 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
1179 #if 0
1180                 /* Disabled for now. LoadLocation prefers the texture over the drawable as the source. So if we copy to the
1181                  * texture first, then to sysmem, we'll avoid glReadPixels and use glCopyTexImage and glGetTexImage2D instead.
1182                  * This may be faster on some cards
1183                  */
1184                 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL /* No partial texture copy yet */);
1185 #endif
1186                 /* drop through */
1187
1188             case RTL_AUTO:
1189             case RTL_READDRAW:
1190             case RTL_READTEX:
1191                 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, pass_rect);
1192                 break;
1193
1194             case RTL_DISABLE:
1195                 break;
1196         }
1197         if(swapchain) IWineD3DSwapChain_Release(swapchain);
1198
1199     } else if(iface == myDevice->stencilBufferTarget) {
1200         /** the depth stencil in openGL has a format of GL_FLOAT
1201          * which should be good for WINED3DFMT_D16_LOCKABLE
1202          * and WINED3DFMT_D16
1203          * it is unclear what format the stencil buffer is in except.
1204          * 'Each index is converted to fixed point...
1205          * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
1206          * mappings in the table GL_PIXEL_MAP_S_TO_S.
1207          * glReadPixels(This->lockedRect.left,
1208          *             This->lockedRect.bottom - j - 1,
1209          *             This->lockedRect.right - This->lockedRect.left,
1210          *             1,
1211          *             GL_DEPTH_COMPONENT,
1212          *             type,
1213          *             (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
1214          *
1215          * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
1216          * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
1217          * none of that is the case the problem is not in this function :-)
1218          ********************************************/
1219         FIXME("Depth stencil locking not supported yet\n");
1220     } else {
1221         /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
1222         TRACE("locking an ordinary surface\n");
1223         IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL /* no partial locking for textures yet */);
1224     }
1225
1226 lock_end:
1227     if(This->Flags & SFLAG_PBO) {
1228         ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1229         ENTER_GL();
1230         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1231         checkGLcall("glBindBufferARB");
1232
1233         /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1234         if(This->resource.allocatedMemory) {
1235             ERR("The surface already has PBO memory allocated!\n");
1236         }
1237
1238         This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1239         checkGLcall("glMapBufferARB");
1240
1241         /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1242         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1243         checkGLcall("glBindBufferARB");
1244
1245         LEAVE_GL();
1246     }
1247
1248     if (Flags & (WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY)) {
1249         /* Don't dirtify */
1250     } else {
1251         IWineD3DBaseTexture *pBaseTexture;
1252         /**
1253          * Dirtify on lock
1254          * as seen in msdn docs
1255          */
1256         surface_add_dirty_rect(iface, pRect);
1257
1258         /** Dirtify Container if needed */
1259         if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&pBaseTexture))) {
1260             TRACE("Making container dirty\n");
1261             IWineD3DBaseTexture_SetDirty(pBaseTexture, TRUE);
1262             IWineD3DBaseTexture_Release(pBaseTexture);
1263         } else {
1264             TRACE("Surface is standalone, no need to dirty the container\n");
1265         }
1266     }
1267
1268     return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
1269 }
1270
1271 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This, GLenum fmt, GLenum type, UINT bpp, const BYTE *mem) {
1272     GLint  prev_store;
1273     GLint  prev_rasterpos[4];
1274     GLint skipBytes = 0;
1275     UINT pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);    /* target is argb, 4 byte */
1276     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
1277     IWineD3DSwapChainImpl *swapchain;
1278
1279     /* Activate the correct context for the render target */
1280     ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
1281     ENTER_GL();
1282
1283     if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)This, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
1284         GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *) This, (IWineD3DSwapChain *)swapchain);
1285         TRACE("Unlocking %#x buffer\n", buffer);
1286         glDrawBuffer(buffer);
1287         checkGLcall("glDrawBuffer");
1288
1289         IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
1290     } else {
1291         /* Primary offscreen render target */
1292         TRACE("Offscreen render target\n");
1293         glDrawBuffer(myDevice->offscreenBuffer);
1294         checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1295     }
1296
1297     glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
1298     checkGLcall("glIntegerv");
1299     glGetIntegerv(GL_CURRENT_RASTER_POSITION, &prev_rasterpos[0]);
1300     checkGLcall("glIntegerv");
1301     glPixelZoom(1.0, -1.0);
1302     checkGLcall("glPixelZoom");
1303
1304     /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
1305     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &skipBytes);
1306     glPixelStorei(GL_UNPACK_ROW_LENGTH, This->currentDesc.Width);
1307
1308     glRasterPos3i(This->lockedRect.left, This->lockedRect.top, 1);
1309     checkGLcall("glRasterPos2f");
1310
1311     /* Some drivers(radeon dri, others?) don't like exceptions during
1312      * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
1313      * after ReleaseDC. Reading it will cause an exception, which x11drv will
1314      * catch to put the dib section in InSync mode, which leads to a crash
1315      * and a blocked x server on my radeon card.
1316      *
1317      * The following lines read the dib section so it is put in InSync mode
1318      * before glDrawPixels is called and the crash is prevented. There won't
1319      * be any interfering gdi accesses, because UnlockRect is called from
1320      * ReleaseDC, and the app won't use the dc any more afterwards.
1321      */
1322     if((This->Flags & SFLAG_DIBSECTION) && !(This->Flags & SFLAG_PBO)) {
1323         volatile BYTE read;
1324         read = This->resource.allocatedMemory[0];
1325     }
1326
1327     if(This->Flags & SFLAG_PBO) {
1328         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1329         checkGLcall("glBindBufferARB");
1330     }
1331
1332     /* When the surface is locked we only have to refresh the locked part else we need to update the whole image */
1333     if(This->Flags & SFLAG_LOCKED) {
1334         glDrawPixels(This->lockedRect.right - This->lockedRect.left,
1335                      (This->lockedRect.bottom - This->lockedRect.top)-1,
1336                      fmt, type,
1337                      mem + bpp * This->lockedRect.left + pitch * This->lockedRect.top);
1338         checkGLcall("glDrawPixels");
1339     } else {
1340         glDrawPixels(This->currentDesc.Width,
1341                      This->currentDesc.Height,
1342                      fmt, type, mem);
1343         checkGLcall("glDrawPixels");
1344     }
1345
1346     if(This->Flags & SFLAG_PBO) {
1347         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1348         checkGLcall("glBindBufferARB");
1349     }
1350
1351     glPixelZoom(1.0,1.0);
1352     checkGLcall("glPixelZoom");
1353
1354     glRasterPos3iv(&prev_rasterpos[0]);
1355     checkGLcall("glRasterPos3iv");
1356
1357     /* Reset to previous pack row length */
1358     glPixelStorei(GL_UNPACK_ROW_LENGTH, skipBytes);
1359     checkGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1360
1361     if(!swapchain) {
1362         glDrawBuffer(myDevice->offscreenBuffer);
1363         checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1364     } else if(swapchain->backBuffer) {
1365         glDrawBuffer(GL_BACK);
1366         checkGLcall("glDrawBuffer(GL_BACK)");
1367     } else {
1368         glDrawBuffer(GL_FRONT);
1369         checkGLcall("glDrawBuffer(GL_FRONT)");
1370     }
1371     LEAVE_GL();
1372
1373     return;
1374 }
1375
1376 static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) {
1377     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1378     IWineD3DDeviceImpl  *myDevice = This->resource.wineD3DDevice;
1379     IWineD3DSwapChainImpl *swapchain = NULL;
1380     BOOL fullsurface;
1381
1382     if (!(This->Flags & SFLAG_LOCKED)) {
1383         WARN("trying to Unlock an unlocked surf@%p\n", This);
1384         return WINEDDERR_NOTLOCKED;
1385     }
1386
1387     if (This->Flags & SFLAG_PBO) {
1388         TRACE("Freeing PBO memory\n");
1389         ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1390         ENTER_GL();
1391         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1392         GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1393         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1394         checkGLcall("glUnmapBufferARB");
1395         LEAVE_GL();
1396         This->resource.allocatedMemory = NULL;
1397     }
1398
1399     TRACE("(%p) : dirtyfied(%d)\n", This, This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
1400
1401     if (This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE)) {
1402         TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This);
1403         goto unlock_end;
1404     }
1405
1406     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain);
1407     if(swapchain || (myDevice->render_targets && iface == myDevice->render_targets[0])) {
1408         if(swapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
1409
1410         if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1411             static BOOL warned = FALSE;
1412             if(!warned) {
1413                 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1414                 warned = TRUE;
1415             }
1416             goto unlock_end;
1417         }
1418
1419         if(This->dirtyRect.left   == 0 &&
1420            This->dirtyRect.top    == 0 &&
1421            This->dirtyRect.right  == This->currentDesc.Width &&
1422            This->dirtyRect.bottom == This->currentDesc.Height) {
1423             fullsurface = TRUE;
1424         } else {
1425             /* TODO: Proper partial rectangle tracking */
1426             fullsurface = FALSE;
1427             This->Flags |= SFLAG_INSYSMEM;
1428         }
1429
1430         switch(wined3d_settings.rendertargetlock_mode) {
1431             case RTL_READTEX:
1432             case RTL_TEXTEX:
1433                 ActivateContext(myDevice, iface, CTXUSAGE_BLIT);
1434                 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL /* partial texture loading not supported yet */);
1435                 /* drop through */
1436
1437             case RTL_AUTO:
1438             case RTL_READDRAW:
1439             case RTL_TEXDRAW:
1440                 IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, fullsurface ? NULL : &This->dirtyRect);
1441                 break;
1442         }
1443
1444         if(!fullsurface) {
1445             /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1446              * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1447              * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1448              * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1449              * not fully up to date because only a subrectangle was read in LockRect.
1450              */
1451             This->Flags &= ~SFLAG_INSYSMEM;
1452             This->Flags |= SFLAG_INDRAWABLE;
1453         }
1454
1455         This->dirtyRect.left   = This->currentDesc.Width;
1456         This->dirtyRect.top    = This->currentDesc.Height;
1457         This->dirtyRect.right  = 0;
1458         This->dirtyRect.bottom = 0;
1459     } else if(iface == myDevice->stencilBufferTarget) {
1460         FIXME("Depth Stencil buffer locking is not implemented\n");
1461     } else {
1462         /* The rest should be a normal texture */
1463         IWineD3DBaseTextureImpl *impl;
1464         /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1465          * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1466          * states need resetting
1467          */
1468         if(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&impl) == WINED3D_OK) {
1469             if(impl->baseTexture.bindCount) {
1470                 IWineD3DDeviceImpl_MarkStateDirty(myDevice, STATE_SAMPLER(impl->baseTexture.sampler));
1471             }
1472             IWineD3DBaseTexture_Release((IWineD3DBaseTexture *) impl);
1473         }
1474     }
1475
1476     unlock_end:
1477     This->Flags &= ~SFLAG_LOCKED;
1478     memset(&This->lockedRect, 0, sizeof(RECT));
1479
1480     /* Overlays have to be redrawn manually after changes with the GL implementation */
1481     if(This->overlay_dest) {
1482         IWineD3DSurface_DrawOverlay(iface);
1483     }
1484     return WINED3D_OK;
1485 }
1486
1487 static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC)
1488 {
1489     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1490     WINED3DLOCKED_RECT lock;
1491     HRESULT hr;
1492     RGBQUAD col[256];
1493
1494     TRACE("(%p)->(%p)\n",This,pHDC);
1495
1496     if(This->Flags & SFLAG_USERPTR) {
1497         ERR("Not supported on surfaces with an application-provided surfaces\n");
1498         return WINEDDERR_NODC;
1499     }
1500
1501     /* Give more detailed info for ddraw */
1502     if (This->Flags & SFLAG_DCINUSE)
1503         return WINEDDERR_DCALREADYCREATED;
1504
1505     /* Can't GetDC if the surface is locked */
1506     if (This->Flags & SFLAG_LOCKED)
1507         return WINED3DERR_INVALIDCALL;
1508
1509     /* According to Direct3D9 docs, only these formats are supported */
1510     if (((IWineD3DImpl *)This->resource.wineD3DDevice->wineD3D)->dxVersion > 7) {
1511         if (This->resource.format_desc->format != WINED3DFMT_R5G6B5
1512                 && This->resource.format_desc->format != WINED3DFMT_X1R5G5B5
1513                 && This->resource.format_desc->format != WINED3DFMT_R8G8B8
1514                 && This->resource.format_desc->format != WINED3DFMT_X8R8G8B8)
1515             return WINED3DERR_INVALIDCALL;
1516     }
1517
1518     memset(&lock, 0, sizeof(lock)); /* To be sure */
1519
1520     /* Create a DIB section if there isn't a hdc yet */
1521     if(!This->hDC) {
1522         IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
1523         if(This->Flags & SFLAG_CLIENT) {
1524             surface_internal_preload(iface, SRGB_RGB);
1525         }
1526
1527         /* Use the dib section from now on if we are not using a PBO */
1528         if(!(This->Flags & SFLAG_PBO))
1529             This->resource.allocatedMemory = This->dib.bitmap_data;
1530     }
1531
1532     /* Lock the surface */
1533     hr = IWineD3DSurface_LockRect(iface,
1534                                   &lock,
1535                                   NULL,
1536                                   0);
1537
1538     if(This->Flags & SFLAG_PBO) {
1539         /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1540         memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
1541     }
1542
1543     if(FAILED(hr)) {
1544         ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
1545         /* keep the dib section */
1546         return hr;
1547     }
1548
1549     if (This->resource.format_desc->format == WINED3DFMT_P8
1550             || This->resource.format_desc->format == WINED3DFMT_A8P8)
1551     {
1552         /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
1553             D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
1554         unsigned int n;
1555         const PALETTEENTRY *pal = NULL;
1556
1557         if(This->palette) {
1558             pal = This->palette->palents;
1559         } else {
1560             IWineD3DSurfaceImpl *dds_primary;
1561             IWineD3DSwapChainImpl *swapchain;
1562             swapchain = (IWineD3DSwapChainImpl *)This->resource.wineD3DDevice->swapchains[0];
1563             dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
1564             if (dds_primary && dds_primary->palette)
1565                 pal = dds_primary->palette->palents;
1566         }
1567
1568         if (pal) {
1569             for (n=0; n<256; n++) {
1570                 col[n].rgbRed   = pal[n].peRed;
1571                 col[n].rgbGreen = pal[n].peGreen;
1572                 col[n].rgbBlue  = pal[n].peBlue;
1573                 col[n].rgbReserved = 0;
1574             }
1575             SetDIBColorTable(This->hDC, 0, 256, col);
1576         }
1577     }
1578
1579     *pHDC = This->hDC;
1580     TRACE("returning %p\n",*pHDC);
1581     This->Flags |= SFLAG_DCINUSE;
1582
1583     return WINED3D_OK;
1584 }
1585
1586 static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC)
1587 {
1588     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1589
1590     TRACE("(%p)->(%p)\n",This,hDC);
1591
1592     if (!(This->Flags & SFLAG_DCINUSE))
1593         return WINEDDERR_NODC;
1594
1595     if (This->hDC !=hDC) {
1596         WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
1597         return WINEDDERR_NODC;
1598     }
1599
1600     if((This->Flags & SFLAG_PBO) && This->resource.allocatedMemory) {
1601         /* Copy the contents of the DIB over to the PBO */
1602         memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
1603     }
1604
1605     /* we locked first, so unlock now */
1606     IWineD3DSurface_UnlockRect(iface);
1607
1608     This->Flags &= ~SFLAG_DCINUSE;
1609
1610     return WINED3D_OK;
1611 }
1612
1613 /* ******************************************************
1614    IWineD3DSurface Internal (No mapping to directx api) parts follow
1615    ****************************************************** */
1616
1617 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) {
1618     BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
1619     const struct GlPixelFormatDesc *glDesc = This->resource.format_desc;
1620     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1621
1622     /* Default values: From the surface */
1623     *format = glDesc->glFormat;
1624     *type = glDesc->glType;
1625     *convert = NO_CONVERSION;
1626     *target_bpp = This->bytesPerPixel;
1627
1628     if(srgb_mode) {
1629         *internal = glDesc->glGammaInternal;
1630     } else if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
1631         *internal = glDesc->rtInternal;
1632     } else {
1633         *internal = glDesc->glInternal;
1634     }
1635
1636     /* Ok, now look if we have to do any conversion */
1637     switch(This->resource.format_desc->format)
1638     {
1639         case WINED3DFMT_P8:
1640             /* ****************
1641                 Paletted Texture
1642                 **************** */
1643
1644              /* Use conversion when the paletted texture extension OR fragment shaders are available. When either
1645              * of the two is available make sure texturing is requested as neither of the two works in
1646              * conjunction with calls like glDraw-/glReadPixels. Further also use conversion in case of color keying.
1647              * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
1648              * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
1649              * conflicts with this.
1650              */
1651             if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE) ||
1652                   (GL_SUPPORT(ARB_FRAGMENT_PROGRAM) &&
1653                    device->render_targets &&
1654                    This == (IWineD3DSurfaceImpl*)device->render_targets[0])) ||
1655                 colorkey_active || !use_texturing ) {
1656                 *format = GL_RGBA;
1657                 *internal = GL_RGBA;
1658                 *type = GL_UNSIGNED_BYTE;
1659                 *target_bpp = 4;
1660                 if(colorkey_active) {
1661                     *convert = CONVERT_PALETTED_CK;
1662                 } else {
1663                     *convert = CONVERT_PALETTED;
1664                 }
1665             }
1666             else if(!GL_SUPPORT(EXT_PALETTED_TEXTURE) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
1667                 *format = GL_ALPHA;
1668                 *internal = GL_RGBA;
1669                 *type = GL_UNSIGNED_BYTE;
1670                 *target_bpp = 1;
1671             }
1672
1673             break;
1674
1675         case WINED3DFMT_R3G3B2:
1676             /* **********************
1677                 GL_UNSIGNED_BYTE_3_3_2
1678                 ********************** */
1679             if (colorkey_active) {
1680                 /* This texture format will never be used.. So do not care about color keying
1681                     up until the point in time it will be needed :-) */
1682                 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1683             }
1684             break;
1685
1686         case WINED3DFMT_R5G6B5:
1687             if (colorkey_active) {
1688                 *convert = CONVERT_CK_565;
1689                 *format = GL_RGBA;
1690                 *internal = GL_RGBA;
1691                 *type = GL_UNSIGNED_SHORT_5_5_5_1;
1692             }
1693             break;
1694
1695         case WINED3DFMT_X1R5G5B5:
1696             if (colorkey_active) {
1697                 *convert = CONVERT_CK_5551;
1698                 *format = GL_BGRA;
1699                 *internal = GL_RGBA;
1700                 *type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1701             }
1702             break;
1703
1704         case WINED3DFMT_R8G8B8:
1705             if (colorkey_active) {
1706                 *convert = CONVERT_CK_RGB24;
1707                 *format = GL_RGBA;
1708                 *internal = GL_RGBA;
1709                 *type = GL_UNSIGNED_INT_8_8_8_8;
1710                 *target_bpp = 4;
1711             }
1712             break;
1713
1714         case WINED3DFMT_X8R8G8B8:
1715             if (colorkey_active) {
1716                 *convert = CONVERT_RGB32_888;
1717                 *format = GL_RGBA;
1718                 *internal = GL_RGBA;
1719                 *type = GL_UNSIGNED_INT_8_8_8_8;
1720             }
1721             break;
1722
1723         case WINED3DFMT_R8G8_SNORM:
1724             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1725             *convert = CONVERT_V8U8;
1726             *format = GL_BGR;
1727             *internal = GL_RGB8;
1728             *type = GL_UNSIGNED_BYTE;
1729             *target_bpp = 3;
1730             break;
1731
1732         case WINED3DFMT_L6V5U5:
1733             *convert = CONVERT_L6V5U5;
1734             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1735                 *target_bpp = 3;
1736                 /* Use format and types from table */
1737             } else {
1738                 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1739                 *target_bpp = 2;
1740                 *format = GL_RGB;
1741                 *internal = GL_RGB5;
1742                 *type = GL_UNSIGNED_SHORT_5_6_5;
1743             }
1744             break;
1745
1746         case WINED3DFMT_X8L8V8U8:
1747             *convert = CONVERT_X8L8V8U8;
1748             *target_bpp = 4;
1749             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1750                 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1751                  * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1752                  * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1753                  * the needed type and format parameter, so the internal format contains a
1754                  * 4th component, which is returned as alpha
1755                  */
1756             } else {
1757                 *format = GL_BGRA;
1758                 *internal = GL_RGB8;
1759                 *type = GL_UNSIGNED_INT_8_8_8_8_REV;
1760             }
1761             break;
1762
1763         case WINED3DFMT_R8G8B8A8_SNORM:
1764             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1765             *convert = CONVERT_Q8W8V8U8;
1766             *format = GL_BGRA;
1767             *internal = GL_RGBA8;
1768             *type = GL_UNSIGNED_BYTE;
1769             *target_bpp = 4;
1770             break;
1771
1772         case WINED3DFMT_R16G16_SNORM:
1773             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1774             *convert = CONVERT_V16U16;
1775             *format = GL_BGR;
1776             *internal = GL_RGB16_EXT;
1777             *type = GL_UNSIGNED_SHORT;
1778             *target_bpp = 6;
1779             break;
1780
1781         case WINED3DFMT_A4L4:
1782             /* A4L4 exists as an internal gl format, but for some reason there is not
1783              * format+type combination to load it. Thus convert it to A8L8, then load it
1784              * with A4L4 internal, but A8L8 format+type
1785              */
1786             *convert = CONVERT_A4L4;
1787             *format = GL_LUMINANCE_ALPHA;
1788             *internal = GL_LUMINANCE4_ALPHA4;
1789             *type = GL_UNSIGNED_BYTE;
1790             *target_bpp = 2;
1791             break;
1792
1793         case WINED3DFMT_R16G16_UNORM:
1794             *convert = CONVERT_G16R16;
1795             *format = GL_RGB;
1796             *internal = GL_RGB16_EXT;
1797             *type = GL_UNSIGNED_SHORT;
1798             *target_bpp = 6;
1799             break;
1800
1801         default:
1802             break;
1803     }
1804
1805     return WINED3D_OK;
1806 }
1807
1808 static HRESULT d3dfmt_convert_surface(const BYTE *src, BYTE *dst, UINT pitch, UINT width,
1809         UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This)
1810 {
1811     const BYTE *source;
1812     BYTE *dest;
1813     TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
1814
1815     switch (convert) {
1816         case NO_CONVERSION:
1817         {
1818             memcpy(dst, src, pitch * height);
1819             break;
1820         }
1821         case CONVERT_PALETTED:
1822         case CONVERT_PALETTED_CK:
1823         {
1824             IWineD3DPaletteImpl* pal = This->palette;
1825             BYTE table[256][4];
1826             unsigned int x, y;
1827
1828             if( pal == NULL) {
1829                 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1830             }
1831
1832             d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
1833
1834             for (y = 0; y < height; y++)
1835             {
1836                 source = src + pitch * y;
1837                 dest = dst + outpitch * y;
1838                 /* This is an 1 bpp format, using the width here is fine */
1839                 for (x = 0; x < width; x++) {
1840                     BYTE color = *source++;
1841                     *dest++ = table[color][0];
1842                     *dest++ = table[color][1];
1843                     *dest++ = table[color][2];
1844                     *dest++ = table[color][3];
1845                 }
1846             }
1847         }
1848         break;
1849
1850         case CONVERT_CK_565:
1851         {
1852             /* Converting the 565 format in 5551 packed to emulate color-keying.
1853
1854               Note : in all these conversion, it would be best to average the averaging
1855                       pixels to get the color of the pixel that will be color-keyed to
1856                       prevent 'color bleeding'. This will be done later on if ever it is
1857                       too visible.
1858
1859               Note2: Nvidia documents say that their driver does not support alpha + color keying
1860                      on the same surface and disables color keying in such a case
1861             */
1862             unsigned int x, y;
1863             const WORD *Source;
1864             WORD *Dest;
1865
1866             TRACE("Color keyed 565\n");
1867
1868             for (y = 0; y < height; y++) {
1869                 Source = (const WORD *)(src + y * pitch);
1870                 Dest = (WORD *) (dst + y * outpitch);
1871                 for (x = 0; x < width; x++ ) {
1872                     WORD color = *Source++;
1873                     *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
1874                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1875                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1876                         *Dest |= 0x0001;
1877                     }
1878                     Dest++;
1879                 }
1880             }
1881         }
1882         break;
1883
1884         case CONVERT_CK_5551:
1885         {
1886             /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1887             unsigned int x, y;
1888             const WORD *Source;
1889             WORD *Dest;
1890             TRACE("Color keyed 5551\n");
1891             for (y = 0; y < height; y++) {
1892                 Source = (const WORD *)(src + y * pitch);
1893                 Dest = (WORD *) (dst + y * outpitch);
1894                 for (x = 0; x < width; x++ ) {
1895                     WORD color = *Source++;
1896                     *Dest = color;
1897                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1898                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1899                         *Dest |= (1 << 15);
1900                     }
1901                     else {
1902                         *Dest &= ~(1 << 15);
1903                     }
1904                     Dest++;
1905                 }
1906             }
1907         }
1908         break;
1909
1910         case CONVERT_CK_RGB24:
1911         {
1912             /* Converting R8G8B8 format to R8G8B8A8 with color-keying. */
1913             unsigned int x, y;
1914             for (y = 0; y < height; y++)
1915             {
1916                 source = src + pitch * y;
1917                 dest = dst + outpitch * y;
1918                 for (x = 0; x < width; x++) {
1919                     DWORD color = ((DWORD)source[0] << 16) + ((DWORD)source[1] << 8) + (DWORD)source[2] ;
1920                     DWORD dstcolor = color << 8;
1921                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1922                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1923                         dstcolor |= 0xff;
1924                     }
1925                     *(DWORD*)dest = dstcolor;
1926                     source += 3;
1927                     dest += 4;
1928                 }
1929             }
1930         }
1931         break;
1932
1933         case CONVERT_RGB32_888:
1934         {
1935             /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
1936             unsigned int x, y;
1937             for (y = 0; y < height; y++)
1938             {
1939                 source = src + pitch * y;
1940                 dest = dst + outpitch * y;
1941                 for (x = 0; x < width; x++) {
1942                     DWORD color = 0xffffff & *(const DWORD*)source;
1943                     DWORD dstcolor = color << 8;
1944                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1945                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1946                         dstcolor |= 0xff;
1947                     }
1948                     *(DWORD*)dest = dstcolor;
1949                     source += 4;
1950                     dest += 4;
1951                 }
1952             }
1953         }
1954         break;
1955
1956         case CONVERT_V8U8:
1957         {
1958             unsigned int x, y;
1959             const short *Source;
1960             unsigned char *Dest;
1961             for(y = 0; y < height; y++) {
1962                 Source = (const short *)(src + y * pitch);
1963                 Dest = dst + y * outpitch;
1964                 for (x = 0; x < width; x++ ) {
1965                     long color = (*Source++);
1966                     /* B */ Dest[0] = 0xff;
1967                     /* G */ Dest[1] = (color >> 8) + 128; /* V */
1968                     /* R */ Dest[2] = (color) + 128;      /* U */
1969                     Dest += 3;
1970                 }
1971             }
1972             break;
1973         }
1974
1975         case CONVERT_V16U16:
1976         {
1977             unsigned int x, y;
1978             const DWORD *Source;
1979             unsigned short *Dest;
1980             for(y = 0; y < height; y++) {
1981                 Source = (const DWORD *)(src + y * pitch);
1982                 Dest = (unsigned short *) (dst + y * outpitch);
1983                 for (x = 0; x < width; x++ ) {
1984                     DWORD color = (*Source++);
1985                     /* B */ Dest[0] = 0xffff;
1986                     /* G */ Dest[1] = (color >> 16) + 32768; /* V */
1987                     /* R */ Dest[2] = (color      ) + 32768; /* U */
1988                     Dest += 3;
1989                 }
1990             }
1991             break;
1992         }
1993
1994         case CONVERT_Q8W8V8U8:
1995         {
1996             unsigned int x, y;
1997             const DWORD *Source;
1998             unsigned char *Dest;
1999             for(y = 0; y < height; y++) {
2000                 Source = (const DWORD *)(src + y * pitch);
2001                 Dest = dst + y * outpitch;
2002                 for (x = 0; x < width; x++ ) {
2003                     long color = (*Source++);
2004                     /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
2005                     /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
2006                     /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
2007                     /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
2008                     Dest += 4;
2009                 }
2010             }
2011             break;
2012         }
2013
2014         case CONVERT_L6V5U5:
2015         {
2016             unsigned int x, y;
2017             const WORD *Source;
2018             unsigned char *Dest;
2019
2020             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
2021                 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
2022                  * fixed function and shaders without further conversion once the surface is
2023                  * loaded
2024                  */
2025                 for(y = 0; y < height; y++) {
2026                     Source = (const WORD *)(src + y * pitch);
2027                     Dest = dst + y * outpitch;
2028                     for (x = 0; x < width; x++ ) {
2029                         short color = (*Source++);
2030                         unsigned char l = ((color >> 10) & 0xfc);
2031                                   char v = ((color >>  5) & 0x3e);
2032                                   char u = ((color      ) & 0x1f);
2033
2034                         /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
2035                          * and doubles the positive range. Thus shift left only once, gl does the 2nd
2036                          * shift. GL reads a signed value and converts it into an unsigned value.
2037                          */
2038                         /* M */ Dest[2] = l << 1;
2039
2040                         /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
2041                          * from 5 bit values to 8 bit values.
2042                          */
2043                         /* V */ Dest[1] = v << 3;
2044                         /* U */ Dest[0] = u << 3;
2045                         Dest += 3;
2046                     }
2047                 }
2048             } else {
2049                 for(y = 0; y < height; y++) {
2050                     unsigned short *Dest_s = (unsigned short *) (dst + y * outpitch);
2051                     Source = (const WORD *)(src + y * pitch);
2052                     for (x = 0; x < width; x++ ) {
2053                         short color = (*Source++);
2054                         unsigned char l = ((color >> 10) & 0xfc);
2055                                  short v = ((color >>  5) & 0x3e);
2056                                  short u = ((color      ) & 0x1f);
2057                         short v_conv = v + 16;
2058                         short u_conv = u + 16;
2059
2060                         *Dest_s = ((v_conv << 11) & 0xf800) | ((l << 5) & 0x7e0) | (u_conv & 0x1f);
2061                         Dest_s += 1;
2062                     }
2063                 }
2064             }
2065             break;
2066         }
2067
2068         case CONVERT_X8L8V8U8:
2069         {
2070             unsigned int x, y;
2071             const DWORD *Source;
2072             unsigned char *Dest;
2073
2074             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
2075                 /* This implementation works with the fixed function pipeline and shaders
2076                  * without further modification after converting the surface.
2077                  */
2078                 for(y = 0; y < height; y++) {
2079                     Source = (const DWORD *)(src + y * pitch);
2080                     Dest = dst + y * outpitch;
2081                     for (x = 0; x < width; x++ ) {
2082                         long color = (*Source++);
2083                         /* L */ Dest[2] = ((color >> 16) & 0xff);   /* L */
2084                         /* V */ Dest[1] = ((color >> 8 ) & 0xff);   /* V */
2085                         /* U */ Dest[0] = (color         & 0xff);   /* U */
2086                         /* I */ Dest[3] = 255;                      /* X */
2087                         Dest += 4;
2088                     }
2089                 }
2090             } else {
2091                 /* Doesn't work correctly with the fixed function pipeline, but can work in
2092                  * shaders if the shader is adjusted. (There's no use for this format in gl's
2093                  * standard fixed function pipeline anyway).
2094                  */
2095                 for(y = 0; y < height; y++) {
2096                     Source = (const DWORD *)(src + y * pitch);
2097                     Dest = dst + y * outpitch;
2098                     for (x = 0; x < width; x++ ) {
2099                         long color = (*Source++);
2100                         /* B */ Dest[0] = ((color >> 16) & 0xff);       /* L */
2101                         /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
2102                         /* R */ Dest[2] = (color         & 0xff) + 128;  /* U */
2103                         Dest += 4;
2104                     }
2105                 }
2106             }
2107             break;
2108         }
2109
2110         case CONVERT_A4L4:
2111         {
2112             unsigned int x, y;
2113             const unsigned char *Source;
2114             unsigned char *Dest;
2115             for(y = 0; y < height; y++) {
2116                 Source = src + y * pitch;
2117                 Dest = dst + y * outpitch;
2118                 for (x = 0; x < width; x++ ) {
2119                     unsigned char color = (*Source++);
2120                     /* A */ Dest[1] = (color & 0xf0) << 0;
2121                     /* L */ Dest[0] = (color & 0x0f) << 4;
2122                     Dest += 2;
2123                 }
2124             }
2125             break;
2126         }
2127
2128         case CONVERT_G16R16:
2129         {
2130             unsigned int x, y;
2131             const WORD *Source;
2132             WORD *Dest;
2133
2134             for(y = 0; y < height; y++) {
2135                 Source = (const WORD *)(src + y * pitch);
2136                 Dest = (WORD *) (dst + y * outpitch);
2137                 for (x = 0; x < width; x++ ) {
2138                     WORD green = (*Source++);
2139                     WORD red = (*Source++);
2140                     Dest[0] = green;
2141                     Dest[1] = red;
2142                     Dest[2] = 0xffff;
2143                     Dest += 3;
2144                 }
2145             }
2146             break;
2147         }
2148
2149         default:
2150             ERR("Unsupported conversation type %d\n", convert);
2151     }
2152     return WINED3D_OK;
2153 }
2154
2155 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey) {
2156     IWineD3DPaletteImpl* pal = This->palette;
2157     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2158     BOOL index_in_alpha = FALSE;
2159     int dxVersion = ( (IWineD3DImpl *) device->wineD3D)->dxVersion;
2160     unsigned int i;
2161
2162     /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
2163     * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
2164     * is slow. Further RGB->P8 conversion is not possible because palettes can have
2165     * duplicate entries. Store the color key in the unused alpha component to speed the
2166     * download up and to make conversion unneeded. */
2167     index_in_alpha = primary_render_target_is_p8(device);
2168
2169     if (pal == NULL) {
2170         /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
2171         if(dxVersion <= 7) {
2172             ERR("This code should never get entered for DirectDraw!, expect problems\n");
2173             if(index_in_alpha) {
2174                 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
2175                    there's no palette at this time. */
2176                 for (i = 0; i < 256; i++) table[i][3] = i;
2177             }
2178         } else {
2179             /*  Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
2180                 alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
2181                 capability flag is present (wine does advertise this capability) */
2182             for (i = 0; i < 256; i++) {
2183                 table[i][0] = device->palettes[device->currentPalette][i].peRed;
2184                 table[i][1] = device->palettes[device->currentPalette][i].peGreen;
2185                 table[i][2] = device->palettes[device->currentPalette][i].peBlue;
2186                 table[i][3] = device->palettes[device->currentPalette][i].peFlags;
2187             }
2188         }
2189     } else {
2190         TRACE("Using surface palette %p\n", pal);
2191         /* Get the surface's palette */
2192         for (i = 0; i < 256; i++) {
2193             table[i][0] = pal->palents[i].peRed;
2194             table[i][1] = pal->palents[i].peGreen;
2195             table[i][2] = pal->palents[i].peBlue;
2196
2197             /* When index_in_alpha is the palette index is stored in the alpha component. In case of a readback
2198                we can then read GL_ALPHA. Color keying is handled in BltOverride using a GL_ALPHA_TEST using GL_NOT_EQUAL.
2199                In case of index_in_alpha the color key itself is passed to glAlphaFunc in other cases the alpha component
2200                of pixels that should be masked away is set to 0. */
2201             if(index_in_alpha) {
2202                 table[i][3] = i;
2203             } else if(colorkey && (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&  (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
2204                 table[i][3] = 0x00;
2205             } else if(pal->Flags & WINEDDPCAPS_ALPHA) {
2206                 table[i][3] = pal->palents[i].peFlags;
2207             } else {
2208                 table[i][3] = 0xFF;
2209             }
2210         }
2211     }
2212 }
2213
2214 /* This function is used in case of 8bit paletted textures to upload the palette.
2215    It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
2216    extensions like ATI_fragment_shaders is possible.
2217 */
2218 static void d3dfmt_p8_upload_palette(IWineD3DSurface *iface, CONVERT_TYPES convert) {
2219     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2220     BYTE table[256][4];
2221     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2222
2223     d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
2224
2225     /* Try to use the paletted texture extension */
2226     if(GL_SUPPORT(EXT_PALETTED_TEXTURE))
2227     {
2228         TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2229         GL_EXTCALL(glColorTableEXT(This->glDescription.target,GL_RGBA,256,GL_RGBA,GL_UNSIGNED_BYTE, table));
2230     }
2231     else
2232     {
2233         /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2234          * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2235         TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2236
2237         /* Create the fragment program if we don't have it */
2238         if(!device->paletteConversionShader)
2239         {
2240             const char *fragment_palette_conversion =
2241                 "!!ARBfp1.0\n"
2242                 "TEMP index;\n"
2243                 /* { 255/256, 0.5/255*255/256, 0, 0 } */
2244                 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n"
2245                 /* The alpha-component contains the palette index */
2246                 "TEX index, fragment.texcoord[0], texture[0], 2D;\n"
2247                 /* Scale the index by 255/256 and add a bias of '0.5' in order to sample in the middle */
2248                 "MAD index.a, index.a, constants.x, constants.y;\n"
2249                 /* Use the alpha-component as an index in the palette to get the final color */
2250                 "TEX result.color, index.a, texture[1], 1D;\n"
2251                 "END";
2252
2253             glEnable(GL_FRAGMENT_PROGRAM_ARB);
2254             GL_EXTCALL(glGenProgramsARB(1, &device->paletteConversionShader));
2255             GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, device->paletteConversionShader));
2256             GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(fragment_palette_conversion), fragment_palette_conversion));
2257             glDisable(GL_FRAGMENT_PROGRAM_ARB);
2258         }
2259
2260         glEnable(GL_FRAGMENT_PROGRAM_ARB);
2261         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, device->paletteConversionShader));
2262
2263         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1));
2264         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2265
2266         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2267         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); /* Make sure we have discrete color levels. */
2268         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2269         glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, table); /* Upload the palette */
2270
2271         /* Switch back to unit 0 in which the 2D texture will be stored. */
2272         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0));
2273
2274         /* Rebind the texture because it isn't bound anymore */
2275         glBindTexture(This->glDescription.target, This->glDescription.textureName);
2276     }
2277 }
2278
2279 BOOL palette9_changed(IWineD3DSurfaceImpl *This) {
2280     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2281
2282     if (This->palette || (This->resource.format_desc->format != WINED3DFMT_P8
2283             && This->resource.format_desc->format != WINED3DFMT_A8P8))
2284     {
2285         /* If a ddraw-style palette is attached assume no d3d9 palette change.
2286          * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2287          */
2288         return FALSE;
2289     }
2290
2291     if(This->palette9) {
2292         if(memcmp(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256) == 0) {
2293             return FALSE;
2294         }
2295     } else {
2296         This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2297     }
2298     memcpy(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
2299     return TRUE;
2300 }
2301
2302 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) {
2303     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2304     DWORD flag = srgb_mode ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE;
2305
2306     if (!(This->Flags & flag)) {
2307         TRACE("Reloading because surface is dirty\n");
2308     } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2309               ((This->Flags & SFLAG_GLCKEY) && (!(This->CKeyFlags & WINEDDSD_CKSRCBLT))) ||
2310               /* Reload: vice versa  OR */
2311               ((!(This->Flags & SFLAG_GLCKEY)) && (This->CKeyFlags & WINEDDSD_CKSRCBLT)) ||
2312               /* Also reload: Color key is active AND the color key has changed */
2313               ((This->CKeyFlags & WINEDDSD_CKSRCBLT) && (
2314                 (This->glCKey.dwColorSpaceLowValue != This->SrcBltCKey.dwColorSpaceLowValue) ||
2315                 (This->glCKey.dwColorSpaceHighValue != This->SrcBltCKey.dwColorSpaceHighValue)))) {
2316         TRACE("Reloading because of color keying\n");
2317         /* To perform the color key conversion we need a sysmem copy of
2318          * the surface. Make sure we have it
2319          */
2320
2321         IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
2322         /* Make sure the texture is reloaded because of the color key change, this kills performance though :( */
2323         /* TODO: This is not necessarily needed with hw palettized texture support */
2324         IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2325     } else {
2326         TRACE("surface is already in texture\n");
2327         return WINED3D_OK;
2328     }
2329
2330     /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2331      *  These resources are not bound by device size or format restrictions. Because of this,
2332      *  these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2333      *  However, these resources can always be created, locked, and copied.
2334      */
2335     if (This->resource.pool == WINED3DPOOL_SCRATCH )
2336     {
2337         FIXME("(%p) Operation not supported for scratch textures\n",This);
2338         return WINED3DERR_INVALIDCALL;
2339     }
2340
2341     IWineD3DSurface_LoadLocation(iface, flag, NULL /* no partial locking for textures yet */);
2342
2343 #if 0
2344     {
2345         static unsigned int gen = 0;
2346         char buffer[4096];
2347         ++gen;
2348         if ((gen % 10) == 0) {
2349             snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
2350             IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
2351         }
2352         /*
2353          * debugging crash code
2354          if (gen == 250) {
2355          void** test = NULL;
2356          *test = 0;
2357          }
2358          */
2359     }
2360 #endif
2361
2362     if (!(This->Flags & SFLAG_DONOTFREE)) {
2363         HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
2364         This->resource.allocatedMemory = NULL;
2365         This->resource.heapMemory = NULL;
2366         IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, FALSE);
2367     }
2368
2369     return WINED3D_OK;
2370 }
2371
2372 static void WINAPI IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface *iface, BOOL srgb) {
2373     /* TODO: check for locks */
2374     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2375     IWineD3DBaseTexture *baseTexture = NULL;
2376     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2377
2378     TRACE("(%p)Checking to see if the container is a base texture\n", This);
2379     if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
2380         TRACE("Passing to container\n");
2381         IWineD3DBaseTexture_BindTexture(baseTexture, srgb);
2382         IWineD3DBaseTexture_Release(baseTexture);
2383     } else {
2384         GLuint *name;
2385         TRACE("(%p) : Binding surface\n", This);
2386
2387         name = srgb ? &This->glDescription.srgbTextureName : &This->glDescription.textureName;
2388         if(!device->isInDraw) {
2389             ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
2390         }
2391
2392         ENTER_GL();
2393
2394         if (!This->glDescription.level) {
2395             if (!*name) {
2396                 glGenTextures(1, name);
2397                 checkGLcall("glGenTextures");
2398                 TRACE("Surface %p given name %d\n", This, *name);
2399
2400                 glBindTexture(This->glDescription.target, *name);
2401                 checkGLcall("glBindTexture");
2402                 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2403                 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)");
2404                 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2405                 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)");
2406                 glTexParameteri(This->glDescription.target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2407                 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)");
2408                 glTexParameteri(This->glDescription.target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2409                 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MIN_FILTER, GL_NEAREST)");
2410                 glTexParameteri(This->glDescription.target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2411                 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MAG_FILTER, GL_NEAREST)");
2412             }
2413             /* This is where we should be reducing the amount of GLMemoryUsed */
2414         } else if (*name) {
2415             /* Mipmap surfaces should have a base texture container */
2416             ERR("Mipmap surface has a glTexture bound to it!\n");
2417         }
2418
2419         glBindTexture(This->glDescription.target, This->glDescription.textureName);
2420         checkGLcall("glBindTexture");
2421
2422         LEAVE_GL();
2423     }
2424     return;
2425 }
2426
2427 #include <errno.h>
2428 #include <stdio.h>
2429 static HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename)
2430 {
2431     FILE* f = NULL;
2432     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2433     char *allocatedMemory;
2434     const char *textureRow;
2435     IWineD3DSwapChain *swapChain = NULL;
2436     int width, height, i, y;
2437     GLuint tmpTexture = 0;
2438     DWORD color;
2439     /*FIXME:
2440     Textures may not be stored in ->allocatedgMemory and a GlTexture
2441     so we should lock the surface before saving a snapshot, or at least check that
2442     */
2443     /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2444     by calling GetTexImage and in compressed form by calling
2445     GetCompressedTexImageARB.  Queried compressed images can be saved and
2446     later reused by calling CompressedTexImage[123]DARB.  Pre-compressed
2447     texture images do not need to be processed by the GL and should
2448     significantly improve texture loading performance relative to uncompressed
2449     images. */
2450
2451 /* Setup the width and height to be the internal texture width and height. */
2452     width  = This->pow2Width;
2453     height = This->pow2Height;
2454 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2455     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapChain);
2456
2457     if (This->Flags & SFLAG_INDRAWABLE && !(This->Flags & SFLAG_INTEXTURE)) {
2458         /* if were not a real texture then read the back buffer into a real texture */
2459         /* we don't want to interfere with the back buffer so read the data into a temporary
2460          * texture and then save the data out of the temporary texture
2461          */
2462         GLint prevRead;
2463         ENTER_GL();
2464         TRACE("(%p) Reading render target into texture\n", This);
2465
2466         glGenTextures(1, &tmpTexture);
2467         glBindTexture(GL_TEXTURE_2D, tmpTexture);
2468
2469         glTexImage2D(GL_TEXTURE_2D,
2470                         0,
2471                         GL_RGBA,
2472                         width,
2473                         height,
2474                         0/*border*/,
2475                         GL_RGBA,
2476                         GL_UNSIGNED_INT_8_8_8_8_REV,
2477                         NULL);
2478
2479         glGetIntegerv(GL_READ_BUFFER, &prevRead);
2480         checkGLcall("glGetIntegerv");
2481         glReadBuffer(swapChain ? GL_BACK : This->resource.wineD3DDevice->offscreenBuffer);
2482         checkGLcall("glReadBuffer");
2483         glCopyTexImage2D(GL_TEXTURE_2D,
2484                             0,
2485                             GL_RGBA,
2486                             0,
2487                             0,
2488                             width,
2489                             height,
2490                             0);
2491
2492         checkGLcall("glCopyTexImage2D");
2493         glReadBuffer(prevRead);
2494         LEAVE_GL();
2495
2496     } else { /* bind the real texture, and make sure it up to date */
2497         surface_internal_preload(iface, SRGB_RGB);
2498         surface_bind_and_dirtify(This, FALSE);
2499     }
2500     allocatedMemory = HeapAlloc(GetProcessHeap(), 0, width  * height * 4);
2501     ENTER_GL();
2502     FIXME("Saving texture level %d width %d height %d\n", This->glDescription.level, width, height);
2503     glGetTexImage(GL_TEXTURE_2D,
2504                 This->glDescription.level,
2505                 GL_RGBA,
2506                 GL_UNSIGNED_INT_8_8_8_8_REV,
2507                 allocatedMemory);
2508     checkGLcall("glTexImage2D");
2509     if (tmpTexture) {
2510         glBindTexture(GL_TEXTURE_2D, 0);
2511         glDeleteTextures(1, &tmpTexture);
2512     }
2513     LEAVE_GL();
2514
2515     f = fopen(filename, "w+");
2516     if (NULL == f) {
2517         ERR("opening of %s failed with: %s\n", filename, strerror(errno));
2518         return WINED3DERR_INVALIDCALL;
2519     }
2520 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2521     TRACE("(%p) opened %s with format %s\n", This, filename, debug_d3dformat(This->resource.format_desc->format));
2522 /* TGA header */
2523     fputc(0,f);
2524     fputc(0,f);
2525     fputc(2,f);
2526     fputc(0,f);
2527     fputc(0,f);
2528     fputc(0,f);
2529     fputc(0,f);
2530     fputc(0,f);
2531     fputc(0,f);
2532     fputc(0,f);
2533     fputc(0,f);
2534     fputc(0,f);
2535 /* short width*/
2536     fwrite(&width,2,1,f);
2537 /* short height */
2538     fwrite(&height,2,1,f);
2539 /* format rgba */
2540     fputc(0x20,f);
2541     fputc(0x28,f);
2542 /* raw data */
2543     /* 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 */
2544     if(swapChain)
2545         textureRow = allocatedMemory + (width * (height - 1) *4);
2546     else
2547         textureRow = allocatedMemory;
2548     for (y = 0 ; y < height; y++) {
2549         for (i = 0; i < width;  i++) {
2550             color = *((const DWORD*)textureRow);
2551             fputc((color >> 16) & 0xFF, f); /* B */
2552             fputc((color >>  8) & 0xFF, f); /* G */
2553             fputc((color >>  0) & 0xFF, f); /* R */
2554             fputc((color >> 24) & 0xFF, f); /* A */
2555             textureRow += 4;
2556         }
2557         /* take two rows of the pointer to the texture memory */
2558         if(swapChain)
2559             (textureRow-= width << 3);
2560
2561     }
2562     TRACE("Closing file\n");
2563     fclose(f);
2564
2565     if(swapChain) {
2566         IWineD3DSwapChain_Release(swapChain);
2567     }
2568     HeapFree(GetProcessHeap(), 0, allocatedMemory);
2569     return WINED3D_OK;
2570 }
2571
2572 static HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) {
2573     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2574     HRESULT hr;
2575
2576     TRACE("(%p) : Calling base function first\n", This);
2577     hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2578     if(SUCCEEDED(hr)) {
2579         This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2580         TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format_desc->glFormat,
2581                 This->resource.format_desc->glInternal, This->resource.format_desc->glType);
2582     }
2583     return hr;
2584 }
2585
2586 static HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2587     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2588
2589     if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
2590         WARN("Surface is locked or the HDC is in use\n");
2591         return WINED3DERR_INVALIDCALL;
2592     }
2593
2594     if(Mem && Mem != This->resource.allocatedMemory) {
2595         void *release = NULL;
2596
2597         /* Do I have to copy the old surface content? */
2598         if(This->Flags & SFLAG_DIBSECTION) {
2599                 /* Release the DC. No need to hold the critical section for the update
2600                  * Thread because this thread runs only on front buffers, but this method
2601                  * fails for render targets in the check above.
2602                  */
2603                 SelectObject(This->hDC, This->dib.holdbitmap);
2604                 DeleteDC(This->hDC);
2605                 /* Release the DIB section */
2606                 DeleteObject(This->dib.DIBsection);
2607                 This->dib.bitmap_data = NULL;
2608                 This->resource.allocatedMemory = NULL;
2609                 This->hDC = NULL;
2610                 This->Flags &= ~SFLAG_DIBSECTION;
2611         } else if(!(This->Flags & SFLAG_USERPTR)) {
2612             release = This->resource.heapMemory;
2613             This->resource.heapMemory = NULL;
2614         }
2615         This->resource.allocatedMemory = Mem;
2616         This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
2617
2618         /* Now the surface memory is most up do date. Invalidate drawable and texture */
2619         IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2620
2621         /* For client textures opengl has to be notified */
2622         if(This->Flags & SFLAG_CLIENT) {
2623             DWORD oldFlags = This->Flags;
2624             This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2625             if(oldFlags & SFLAG_ALLOCATED) surface_internal_preload(iface, SRGB_RGB);
2626             if(oldFlags & SFLAG_SRGBALLOCATED) surface_internal_preload(iface, SRGB_SRGB);
2627             /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2628         }
2629
2630         /* Now free the old memory if any */
2631         HeapFree(GetProcessHeap(), 0, release);
2632     } else if(This->Flags & SFLAG_USERPTR) {
2633         /* LockRect and GetDC will re-create the dib section and allocated memory */
2634         This->resource.allocatedMemory = NULL;
2635         /* HeapMemory should be NULL already */
2636         if(This->resource.heapMemory != NULL) ERR("User pointer surface has heap memory allocated\n");
2637         This->Flags &= ~SFLAG_USERPTR;
2638
2639         if(This->Flags & SFLAG_CLIENT) {
2640             DWORD oldFlags = This->Flags;
2641             This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2642             /* This respecifies an empty texture and opengl knows that the old memory is gone */
2643             if(oldFlags & SFLAG_ALLOCATED) surface_internal_preload(iface, SRGB_RGB);
2644             if(oldFlags & SFLAG_SRGBALLOCATED) surface_internal_preload(iface, SRGB_SRGB);
2645         }
2646     }
2647     return WINED3D_OK;
2648 }
2649
2650 void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) {
2651
2652     /* Flip the surface contents */
2653     /* Flip the DC */
2654     {
2655         HDC tmp;
2656         tmp = front->hDC;
2657         front->hDC = back->hDC;
2658         back->hDC = tmp;
2659     }
2660
2661     /* Flip the DIBsection */
2662     {
2663         HBITMAP tmp;
2664         BOOL hasDib = front->Flags & SFLAG_DIBSECTION;
2665         tmp = front->dib.DIBsection;
2666         front->dib.DIBsection = back->dib.DIBsection;
2667         back->dib.DIBsection = tmp;
2668
2669         if(back->Flags & SFLAG_DIBSECTION) front->Flags |= SFLAG_DIBSECTION;
2670         else front->Flags &= ~SFLAG_DIBSECTION;
2671         if(hasDib) back->Flags |= SFLAG_DIBSECTION;
2672         else back->Flags &= ~SFLAG_DIBSECTION;
2673     }
2674
2675     /* Flip the surface data */
2676     {
2677         void* tmp;
2678
2679         tmp = front->dib.bitmap_data;
2680         front->dib.bitmap_data = back->dib.bitmap_data;
2681         back->dib.bitmap_data = tmp;
2682
2683         tmp = front->resource.allocatedMemory;
2684         front->resource.allocatedMemory = back->resource.allocatedMemory;
2685         back->resource.allocatedMemory = tmp;
2686
2687         tmp = front->resource.heapMemory;
2688         front->resource.heapMemory = back->resource.heapMemory;
2689         back->resource.heapMemory = tmp;
2690     }
2691
2692     /* Flip the PBO */
2693     {
2694         GLuint tmp_pbo = front->pbo;
2695         front->pbo = back->pbo;
2696         back->pbo = tmp_pbo;
2697     }
2698
2699     /* client_memory should not be different, but just in case */
2700     {
2701         BOOL tmp;
2702         tmp = front->dib.client_memory;
2703         front->dib.client_memory = back->dib.client_memory;
2704         back->dib.client_memory = tmp;
2705     }
2706
2707     /* Flip the opengl texture */
2708     {
2709         glDescriptor tmp_desc = back->glDescription;
2710         back->glDescription = front->glDescription;
2711         front->glDescription = tmp_desc;
2712     }
2713
2714     {
2715         DWORD tmp_flags = back->Flags;
2716         back->Flags = front->Flags;
2717         front->Flags = tmp_flags;
2718     }
2719 }
2720
2721 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD Flags) {
2722     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2723     IWineD3DSwapChainImpl *swapchain = NULL;
2724     HRESULT hr;
2725     TRACE("(%p)->(%p,%x)\n", This, override, Flags);
2726
2727     /* Flipping is only supported on RenderTargets and overlays*/
2728     if( !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_OVERLAY)) ) {
2729         WARN("Tried to flip a non-render target, non-overlay surface\n");
2730         return WINEDDERR_NOTFLIPPABLE;
2731     }
2732
2733     if(This->resource.usage & WINED3DUSAGE_OVERLAY) {
2734         flip_surface(This, (IWineD3DSurfaceImpl *) override);
2735
2736         /* Update the overlay if it is visible */
2737         if(This->overlay_dest) {
2738             return IWineD3DSurface_DrawOverlay((IWineD3DSurface *) This);
2739         } else {
2740             return WINED3D_OK;
2741         }
2742     }
2743
2744     if(override) {
2745         /* DDraw sets this for the X11 surfaces, so don't confuse the user
2746          * FIXME("(%p) Target override is not supported by now\n", This);
2747          * Additionally, it isn't really possible to support triple-buffering
2748          * properly on opengl at all
2749          */
2750     }
2751
2752     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **) &swapchain);
2753     if(!swapchain) {
2754         ERR("Flipped surface is not on a swapchain\n");
2755         return WINEDDERR_NOTFLIPPABLE;
2756     }
2757
2758     /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2759      * and only d3d8 and d3d9 apps specify the presentation interval
2760      */
2761     if((Flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)) == 0) {
2762         /* Most common case first to avoid wasting time on all the other cases */
2763         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
2764     } else if(Flags & WINEDDFLIP_NOVSYNC) {
2765         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2766     } else if(Flags & WINEDDFLIP_INTERVAL2) {
2767         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
2768     } else if(Flags & WINEDDFLIP_INTERVAL3) {
2769         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
2770     } else {
2771         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
2772     }
2773
2774     /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2775     hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *) swapchain, NULL, NULL, 0, NULL, 0);
2776     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
2777     return hr;
2778 }
2779
2780 /* Does a direct frame buffer -> texture copy. Stretching is done
2781  * with single pixel copy calls
2782  */
2783 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
2784         IWineD3DSwapChainImpl *swapchain, const WINED3DRECT *srect, const WINED3DRECT *drect,
2785         BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter)
2786 {
2787     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2788     float xrel, yrel;
2789     UINT row;
2790     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2791
2792
2793     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2794     surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
2795     ENTER_GL();
2796
2797     /* Bind the target texture */
2798     glBindTexture(This->glDescription.target, This->glDescription.textureName);
2799     checkGLcall("glBindTexture");
2800     if(!swapchain) {
2801         TRACE("Reading from an offscreen target\n");
2802         upsidedown = !upsidedown;
2803         glReadBuffer(myDevice->offscreenBuffer);
2804     } else {
2805         GLenum buffer = surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain);
2806         glReadBuffer(buffer);
2807     }
2808     checkGLcall("glReadBuffer");
2809
2810     xrel = (float) (srect->x2 - srect->x1) / (float) (drect->x2 - drect->x1);
2811     yrel = (float) (srect->y2 - srect->y1) / (float) (drect->y2 - drect->y1);
2812
2813     if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2814         FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2815
2816         if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
2817             ERR("Texture filtering not supported in direct blit\n");
2818         }
2819     } else if((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) && ((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2820         ERR("Texture filtering not supported in direct blit\n");
2821     }
2822
2823     if(upsidedown &&
2824        !((xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) &&
2825        !((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2826         /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2827
2828         glCopyTexSubImage2D(This->glDescription.target,
2829                             This->glDescription.level,
2830                             drect->x1, drect->y1, /* xoffset, yoffset */
2831                             srect->x1, Src->currentDesc.Height - srect->y2,
2832                             drect->x2 - drect->x1, drect->y2 - drect->y1);
2833     } else {
2834         UINT yoffset = Src->currentDesc.Height - srect->y1 + drect->y1 - 1;
2835         /* I have to process this row by row to swap the image,
2836          * otherwise it would be upside down, so stretching in y direction
2837          * doesn't cost extra time
2838          *
2839          * However, stretching in x direction can be avoided if not necessary
2840          */
2841         for(row = drect->y1; row < drect->y2; row++) {
2842             if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2843                 /* Well, that stuff works, but it's very slow.
2844                  * find a better way instead
2845                  */
2846                 UINT col;
2847
2848                 for(col = drect->x1; col < drect->x2; col++) {
2849                     glCopyTexSubImage2D(This->glDescription.target,
2850                                         This->glDescription.level,
2851                                         drect->x1 + col, row, /* xoffset, yoffset */
2852                                         srect->x1 + col * xrel, yoffset - (int) (row * yrel),
2853                                         1, 1);
2854                 }
2855             } else {
2856                 glCopyTexSubImage2D(This->glDescription.target,
2857                                     This->glDescription.level,
2858                                     drect->x1, row, /* xoffset, yoffset */
2859                                     srect->x1, yoffset - (int) (row * yrel),
2860                                     drect->x2-drect->x1, 1);
2861             }
2862         }
2863     }
2864     checkGLcall("glCopyTexSubImage2D");
2865
2866     LEAVE_GL();
2867 }
2868
2869 /* Uses the hardware to stretch and flip the image */
2870 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
2871         IWineD3DSwapChainImpl *swapchain, const WINED3DRECT *srect, const WINED3DRECT *drect,
2872         BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter)
2873 {
2874     GLuint src, backup = 0;
2875     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2876     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2877     float left, right, top, bottom; /* Texture coordinates */
2878     UINT fbwidth = Src->currentDesc.Width;
2879     UINT fbheight = Src->currentDesc.Height;
2880     GLenum drawBuffer = GL_BACK;
2881     GLenum texture_target;
2882     BOOL noBackBufferBackup;
2883
2884     TRACE("Using hwstretch blit\n");
2885     /* Activate the Proper context for reading from the source surface, set it up for blitting */
2886     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2887     surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
2888
2889     noBackBufferBackup = !swapchain && wined3d_settings.offscreen_rendering_mode == ORM_FBO;
2890     if(!noBackBufferBackup && Src->glDescription.textureName == 0) {
2891         /* Get it a description */
2892         surface_internal_preload(SrcSurface, SRGB_RGB);
2893     }
2894     ENTER_GL();
2895
2896     /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2897      * This way we don't have to wait for the 2nd readback to finish to leave this function.
2898      */
2899     if(myDevice->activeContext->aux_buffers >= 2) {
2900         /* Got more than one aux buffer? Use the 2nd aux buffer */
2901         drawBuffer = GL_AUX1;
2902     } else if((swapchain || myDevice->offscreenBuffer == GL_BACK) && myDevice->activeContext->aux_buffers >= 1) {
2903         /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2904         drawBuffer = GL_AUX0;
2905     }
2906
2907     if(noBackBufferBackup) {
2908         glGenTextures(1, &backup);
2909         checkGLcall("glGenTextures\n");
2910         glBindTexture(GL_TEXTURE_2D, backup);
2911         checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2912         texture_target = GL_TEXTURE_2D;
2913     } else {
2914         /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2915          * we are reading from the back buffer, the backup can be used as source texture
2916          */
2917         texture_target = Src->glDescription.target;
2918         glBindTexture(texture_target, Src->glDescription.textureName);
2919         checkGLcall("glBindTexture(texture_target, Src->glDescription.textureName)");
2920         glEnable(texture_target);
2921         checkGLcall("glEnable(texture_target)");
2922
2923         /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2924         Src->Flags &= ~SFLAG_INTEXTURE;
2925     }
2926
2927     if(swapchain) {
2928         glReadBuffer(surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain));
2929     } else {
2930         TRACE("Reading from an offscreen target\n");
2931         upsidedown = !upsidedown;
2932         glReadBuffer(myDevice->offscreenBuffer);
2933     }
2934
2935     /* TODO: Only back up the part that will be overwritten */
2936     glCopyTexSubImage2D(texture_target, 0,
2937                         0, 0 /* read offsets */,
2938                         0, 0,
2939                         fbwidth,
2940                         fbheight);
2941
2942     checkGLcall("glCopyTexSubImage2D");
2943
2944     /* No issue with overriding these - the sampler is dirty due to blit usage */
2945     glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER,
2946                     magLookup[Filter - WINED3DTEXF_NONE]);
2947     checkGLcall("glTexParameteri");
2948     glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER,
2949                     minMipLookup[Filter].mip[WINED3DTEXF_NONE]);
2950     checkGLcall("glTexParameteri");
2951
2952     if(!swapchain || (IWineD3DSurface *) Src == swapchain->backBuffer[0]) {
2953         src = backup ? backup : Src->glDescription.textureName;
2954     } else {
2955         glReadBuffer(GL_FRONT);
2956         checkGLcall("glReadBuffer(GL_FRONT)");
2957
2958         glGenTextures(1, &src);
2959         checkGLcall("glGenTextures(1, &src)");
2960         glBindTexture(GL_TEXTURE_2D, src);
2961         checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2962
2963         /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2964          * out for power of 2 sizes
2965          */
2966         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Src->pow2Width, Src->pow2Height, 0,
2967                     GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2968         checkGLcall("glTexImage2D");
2969         glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
2970                             0, 0 /* read offsets */,
2971                             0, 0,
2972                             fbwidth,
2973                             fbheight);
2974
2975         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2976         checkGLcall("glTexParameteri");
2977         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2978         checkGLcall("glTexParameteri");
2979
2980         glReadBuffer(GL_BACK);
2981         checkGLcall("glReadBuffer(GL_BACK)");
2982
2983         if(texture_target != GL_TEXTURE_2D) {
2984             glDisable(texture_target);
2985             glEnable(GL_TEXTURE_2D);
2986             texture_target = GL_TEXTURE_2D;
2987         }
2988     }
2989     checkGLcall("glEnd and previous");
2990
2991     left = srect->x1;
2992     right = srect->x2;
2993
2994     if(upsidedown) {
2995         top = Src->currentDesc.Height - srect->y1;
2996         bottom = Src->currentDesc.Height - srect->y2;
2997     } else {
2998         top = Src->currentDesc.Height - srect->y2;
2999         bottom = Src->currentDesc.Height - srect->y1;
3000     }
3001
3002     if(Src->Flags & SFLAG_NORMCOORD) {
3003         left /= Src->pow2Width;
3004         right /= Src->pow2Width;
3005         top /= Src->pow2Height;
3006         bottom /= Src->pow2Height;
3007     }
3008
3009     /* draw the source texture stretched and upside down. The correct surface is bound already */
3010     glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3011     glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3012
3013     glDrawBuffer(drawBuffer);
3014     glReadBuffer(drawBuffer);
3015
3016     glBegin(GL_QUADS);
3017         /* bottom left */
3018         glTexCoord2f(left, bottom);
3019         glVertex2i(0, fbheight);
3020
3021         /* top left */
3022         glTexCoord2f(left, top);
3023         glVertex2i(0, fbheight - drect->y2 - drect->y1);
3024
3025         /* top right */
3026         glTexCoord2f(right, top);
3027         glVertex2i(drect->x2 - drect->x1, fbheight - drect->y2 - drect->y1);
3028
3029         /* bottom right */
3030         glTexCoord2f(right, bottom);
3031         glVertex2i(drect->x2 - drect->x1, fbheight);
3032     glEnd();
3033     checkGLcall("glEnd and previous");
3034
3035     if(texture_target != This->glDescription.target) {
3036         glDisable(texture_target);
3037         glEnable(This->glDescription.target);
3038         texture_target = This->glDescription.target;
3039     }
3040
3041     /* Now read the stretched and upside down image into the destination texture */
3042     glBindTexture(texture_target, This->glDescription.textureName);
3043     checkGLcall("glBindTexture");
3044     glCopyTexSubImage2D(texture_target,
3045                         0,
3046                         drect->x1, drect->y1, /* xoffset, yoffset */
3047                         0, 0, /* We blitted the image to the origin */
3048                         drect->x2 - drect->x1, drect->y2 - drect->y1);
3049     checkGLcall("glCopyTexSubImage2D");
3050
3051     if(drawBuffer == GL_BACK) {
3052         /* Write the back buffer backup back */
3053         if(backup) {
3054             if(texture_target != GL_TEXTURE_2D) {
3055                 glDisable(texture_target);
3056                 glEnable(GL_TEXTURE_2D);
3057                 texture_target = GL_TEXTURE_2D;
3058             }
3059             glBindTexture(GL_TEXTURE_2D, backup);
3060             checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3061         } else {
3062             if(texture_target != Src->glDescription.target) {
3063                 glDisable(texture_target);
3064                 glEnable(Src->glDescription.target);
3065                 texture_target = Src->glDescription.target;
3066             }
3067             glBindTexture(Src->glDescription.target, Src->glDescription.textureName);
3068             checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
3069         }
3070
3071         glBegin(GL_QUADS);
3072             /* top left */
3073             glTexCoord2f(0.0, (float) fbheight / (float) Src->pow2Height);
3074             glVertex2i(0, 0);
3075
3076             /* bottom left */
3077             glTexCoord2f(0.0, 0.0);
3078             glVertex2i(0, fbheight);
3079
3080             /* bottom right */
3081             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, 0.0);
3082             glVertex2i(fbwidth, Src->currentDesc.Height);
3083
3084             /* top right */
3085             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, (float) fbheight / (float) Src->pow2Height);
3086             glVertex2i(fbwidth, 0);
3087         glEnd();
3088     } else {
3089         /* Restore the old draw buffer */
3090         glDrawBuffer(GL_BACK);
3091     }
3092     glDisable(texture_target);
3093     checkGLcall("glDisable(texture_target)");
3094
3095     /* Cleanup */
3096     if(src != Src->glDescription.textureName && src != backup) {
3097         glDeleteTextures(1, &src);
3098         checkGLcall("glDeleteTextures(1, &src)");
3099     }
3100     if(backup) {
3101         glDeleteTextures(1, &backup);
3102         checkGLcall("glDeleteTextures(1, &backup)");
3103     }
3104
3105     LEAVE_GL();
3106 }
3107
3108 /* Not called from the VTable */
3109 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3110         IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx,
3111         WINED3DTEXTUREFILTERTYPE Filter)
3112 {
3113     WINED3DRECT rect;
3114     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3115     IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
3116     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3117
3118     TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3119
3120     /* Get the swapchain. One of the surfaces has to be a primary surface */
3121     if(This->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3122         WARN("Destination is in sysmem, rejecting gl blt\n");
3123         return WINED3DERR_INVALIDCALL;
3124     }
3125     IWineD3DSurface_GetContainer( (IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&dstSwapchain);
3126     if(dstSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) dstSwapchain);
3127     if(Src) {
3128         if(Src->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3129             WARN("Src is in sysmem, rejecting gl blt\n");
3130             return WINED3DERR_INVALIDCALL;
3131         }
3132         IWineD3DSurface_GetContainer( (IWineD3DSurface *) Src, &IID_IWineD3DSwapChain, (void **)&srcSwapchain);
3133         if(srcSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) srcSwapchain);
3134     }
3135
3136     /* Early sort out of cases where no render target is used */
3137     if(!dstSwapchain && !srcSwapchain &&
3138         SrcSurface != myDevice->render_targets[0] && This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3139         TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src, This);
3140         return WINED3DERR_INVALIDCALL;
3141     }
3142
3143     /* No destination color keying supported */
3144     if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
3145         /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3146         TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3147         return WINED3DERR_INVALIDCALL;
3148     }
3149
3150     if (DestRect) {
3151         rect.x1 = DestRect->left;
3152         rect.y1 = DestRect->top;
3153         rect.x2 = DestRect->right;
3154         rect.y2 = DestRect->bottom;
3155     } else {
3156         rect.x1 = 0;
3157         rect.y1 = 0;
3158         rect.x2 = This->currentDesc.Width;
3159         rect.y2 = This->currentDesc.Height;
3160     }
3161
3162     /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3163     if(dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->backBuffer &&
3164        ((IWineD3DSurface *) This == dstSwapchain->frontBuffer) && SrcSurface == dstSwapchain->backBuffer[0]) {
3165         /* Half-life does a Blt from the back buffer to the front buffer,
3166          * Full surface size, no flags... Use present instead
3167          *
3168          * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3169          */
3170
3171         /* Check rects - IWineD3DDevice_Present doesn't handle them */
3172         while(1)
3173         {
3174             RECT mySrcRect;
3175             TRACE("Looking if a Present can be done...\n");
3176             /* Source Rectangle must be full surface */
3177             if( SrcRect ) {
3178                 if(SrcRect->left != 0 || SrcRect->top != 0 ||
3179                    SrcRect->right != Src->currentDesc.Width || SrcRect->bottom != Src->currentDesc.Height) {
3180                     TRACE("No, Source rectangle doesn't match\n");
3181                     break;
3182                 }
3183             }
3184             mySrcRect.left = 0;
3185             mySrcRect.top = 0;
3186             mySrcRect.right = Src->currentDesc.Width;
3187             mySrcRect.bottom = Src->currentDesc.Height;
3188
3189             /* No stretching may occur */
3190             if(mySrcRect.right != rect.x2 - rect.x1 ||
3191                mySrcRect.bottom != rect.y2 - rect.y1) {
3192                 TRACE("No, stretching is done\n");
3193                 break;
3194             }
3195
3196             /* Destination must be full surface or match the clipping rectangle */
3197             if(This->clipper && ((IWineD3DClipperImpl *) This->clipper)->hWnd)
3198             {
3199                 RECT cliprect;
3200                 POINT pos[2];
3201                 GetClientRect(((IWineD3DClipperImpl *) This->clipper)->hWnd, &cliprect);
3202                 pos[0].x = rect.x1;
3203                 pos[0].y = rect.y1;
3204                 pos[1].x = rect.x2;
3205                 pos[1].y = rect.y2;
3206                 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl *) This->clipper)->hWnd,
3207                                 pos, 2);
3208
3209                 if(pos[0].x != cliprect.left  || pos[0].y != cliprect.top   ||
3210                    pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
3211                 {
3212                     TRACE("No, dest rectangle doesn't match(clipper)\n");
3213                     TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect.left, cliprect.top, cliprect.right, cliprect.bottom);
3214                     TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect.x1, rect.y1, rect.x2, rect.y2);
3215                     break;
3216                 }
3217             }
3218             else
3219             {
3220                 if(rect.x1 != 0 || rect.y1 != 0 ||
3221                    rect.x2 != This->currentDesc.Width || rect.y2 != This->currentDesc.Height) {
3222                     TRACE("No, dest rectangle doesn't match(surface size)\n");
3223                     break;
3224                 }
3225             }
3226
3227             TRACE("Yes\n");
3228
3229             /* These flags are unimportant for the flag check, remove them */
3230             if((Flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)) == 0) {
3231                 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
3232
3233                 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3234                     * take very long, while a flip is fast.
3235                     * This applies to Half-Life, which does such Blts every time it finished
3236                     * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3237                     * menu. This is also used by all apps when they do windowed rendering
3238                     *
3239                     * The problem is that flipping is not really the same as copying. After a
3240                     * Blt the front buffer is a copy of the back buffer, and the back buffer is
3241                     * untouched. Therefore it's necessary to override the swap effect
3242                     * and to set it back after the flip.
3243                     *
3244                     * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3245                     * testcases.
3246                     */
3247
3248                 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
3249                 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3250
3251                 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3252                 IWineD3DSwapChain_Present((IWineD3DSwapChain *) dstSwapchain, NULL, NULL, 0, NULL, 0);
3253
3254                 dstSwapchain->presentParms.SwapEffect = orig_swap;
3255
3256                 return WINED3D_OK;
3257             }
3258             break;
3259         }
3260
3261         TRACE("Unsupported blit between buffers on the same swapchain\n");
3262         return WINED3DERR_INVALIDCALL;
3263     } else if(dstSwapchain && dstSwapchain == srcSwapchain) {
3264         FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3265         return WINED3DERR_INVALIDCALL;
3266     } else if(dstSwapchain && srcSwapchain) {
3267         FIXME("Implement hardware blit between two different swapchains\n");
3268         return WINED3DERR_INVALIDCALL;
3269     } else if(dstSwapchain) {
3270         if(SrcSurface == myDevice->render_targets[0]) {
3271             TRACE("Blit from active render target to a swapchain\n");
3272             /* Handled with regular texture -> swapchain blit */
3273         }
3274     } else if(srcSwapchain && This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3275         FIXME("Implement blit from a swapchain to the active render target\n");
3276         return WINED3DERR_INVALIDCALL;
3277     }
3278
3279     if((srcSwapchain || SrcSurface == myDevice->render_targets[0]) && !dstSwapchain) {
3280         /* Blit from render target to texture */
3281         WINED3DRECT srect;
3282         BOOL upsideDown, stretchx;
3283         BOOL paletteOverride = FALSE;
3284
3285         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3286             TRACE("Color keying not supported by frame buffer to texture blit\n");
3287             return WINED3DERR_INVALIDCALL;
3288             /* Destination color key is checked above */
3289         }
3290
3291         /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3292          * glCopyTexSubImage is a bit picky about the parameters we pass to it
3293          */
3294         if(SrcRect) {
3295             if(SrcRect->top < SrcRect->bottom) {
3296                 srect.y1 = SrcRect->top;
3297                 srect.y2 = SrcRect->bottom;
3298                 upsideDown = FALSE;
3299             } else {
3300                 srect.y1 = SrcRect->bottom;
3301                 srect.y2 = SrcRect->top;
3302                 upsideDown = TRUE;
3303             }
3304             srect.x1 = SrcRect->left;
3305             srect.x2 = SrcRect->right;
3306         } else {
3307             srect.x1 = 0;
3308             srect.y1 = 0;
3309             srect.x2 = Src->currentDesc.Width;
3310             srect.y2 = Src->currentDesc.Height;
3311             upsideDown = FALSE;
3312         }
3313         if(rect.x1 > rect.x2) {
3314             UINT tmp = rect.x2;
3315             rect.x2 = rect.x1;
3316             rect.x1 = tmp;
3317             upsideDown = !upsideDown;
3318         }
3319
3320         if(rect.x2 - rect.x1 != srect.x2 - srect.x1) {
3321             stretchx = TRUE;
3322         } else {
3323             stretchx = FALSE;
3324         }
3325
3326         /* When blitting from a render target a texture, the texture isn't required to have a palette.
3327          * In this case grab the palette from the render target. */
3328         if ((This->resource.format_desc->format == WINED3DFMT_P8) && (This->palette == NULL))
3329         {
3330             paletteOverride = TRUE;
3331             TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src, This->palette, This);
3332             This->palette = Src->palette;
3333         }
3334
3335         /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3336          * flip the image nor scale it.
3337          *
3338          * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3339          * -> If the app wants a image width an unscaled width, copy it line per line
3340          * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3341          *    than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3342          *    back buffer. This is slower than reading line per line, thus not used for flipping
3343          * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3344          *    pixel by pixel
3345          *
3346          * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3347          * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3348          * backends.
3349          */
3350         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT)) {
3351             stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &srect,
3352                     (IWineD3DSurface *)This, &rect, Filter, upsideDown);
3353         } else if((!stretchx) || rect.x2 - rect.x1 > Src->currentDesc.Width ||
3354                                     rect.y2 - rect.y1 > Src->currentDesc.Height) {
3355             TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3356             fb_copy_to_texture_direct(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3357         } else {
3358             TRACE("Using hardware stretching to flip / stretch the texture\n");
3359             fb_copy_to_texture_hwstretch(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3360         }
3361
3362         /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3363         if(paletteOverride)
3364             This->palette = NULL;
3365
3366         if(!(This->Flags & SFLAG_DONOTFREE)) {
3367             HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
3368             This->resource.allocatedMemory = NULL;
3369             This->resource.heapMemory = NULL;
3370         } else {
3371             This->Flags &= ~SFLAG_INSYSMEM;
3372         }
3373         /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3374          * path is never entered
3375          */
3376         IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INTEXTURE, TRUE);
3377
3378         return WINED3D_OK;
3379     } else if(Src) {
3380         /* Blit from offscreen surface to render target */
3381         float glTexCoord[4];
3382         DWORD oldCKeyFlags = Src->CKeyFlags;
3383         WINEDDCOLORKEY oldBltCKey = Src->SrcBltCKey;
3384         RECT SourceRectangle;
3385         BOOL paletteOverride = FALSE;
3386
3387         TRACE("Blt from surface %p to rendertarget %p\n", Src, This);
3388
3389         if(SrcRect) {
3390             SourceRectangle.left = SrcRect->left;
3391             SourceRectangle.right = SrcRect->right;
3392             SourceRectangle.top = SrcRect->top;
3393             SourceRectangle.bottom = SrcRect->bottom;
3394         } else {
3395             SourceRectangle.left = 0;
3396             SourceRectangle.right = Src->currentDesc.Width;
3397             SourceRectangle.top = 0;
3398             SourceRectangle.bottom = Src->currentDesc.Height;
3399         }
3400
3401         /* When blitting from an offscreen surface to a rendertarget, the source
3402          * surface is not required to have a palette. Our rendering / conversion
3403          * code further down the road retrieves the palette from the surface, so
3404          * it must have a palette set. */
3405         if ((Src->resource.format_desc->format == WINED3DFMT_P8) && (Src->palette == NULL))
3406         {
3407             paletteOverride = TRUE;
3408             TRACE("Source surface (%p) lacks palette, overriding palette with palette %p of destination surface (%p)\n", Src, This->palette, This);
3409             Src->palette = This->palette;
3410         }
3411
3412         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT) &&
3413             (Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) == 0) {
3414             TRACE("Using stretch_rect_fbo\n");
3415             /* The source is always a texture, but never the currently active render target, and the texture
3416              * contents are never upside down
3417              */
3418             stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, (WINED3DRECT *) &SourceRectangle,
3419                               (IWineD3DSurface *)This, &rect, Filter, FALSE);
3420
3421             /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3422             if(paletteOverride)
3423                 Src->palette = NULL;
3424             return WINED3D_OK;
3425         }
3426
3427         if(!CalculateTexRect(Src, &SourceRectangle, glTexCoord)) {
3428             /* Fall back to software */
3429             WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src,
3430                     SourceRectangle.left, SourceRectangle.top,
3431                     SourceRectangle.right, SourceRectangle.bottom);
3432             return WINED3DERR_INVALIDCALL;
3433         }
3434
3435         /* Color keying: Check if we have to do a color keyed blt,
3436          * and if not check if a color key is activated.
3437          *
3438          * Just modify the color keying parameters in the surface and restore them afterwards
3439          * The surface keeps track of the color key last used to load the opengl surface.
3440          * PreLoad will catch the change to the flags and color key and reload if necessary.
3441          */
3442         if(Flags & WINEDDBLT_KEYSRC) {
3443             /* Use color key from surface */
3444         } else if(Flags & WINEDDBLT_KEYSRCOVERRIDE) {
3445             /* Use color key from DDBltFx */
3446             Src->CKeyFlags |= WINEDDSD_CKSRCBLT;
3447             Src->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3448         } else {
3449             /* Do not use color key */
3450             Src->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3451         }
3452
3453         /* Now load the surface */
3454         surface_internal_preload((IWineD3DSurface *) Src, SRGB_RGB);
3455
3456         /* Activate the destination context, set it up for blitting */
3457         ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
3458
3459         /* The coordinates of the ddraw front buffer are always fullscreen ('screen coordinates',
3460          * while OpenGL coordinates are window relative.
3461          * Also beware of the origin difference(top left vs bottom left).
3462          * Also beware that the front buffer's surface size is screen width x screen height,
3463          * whereas the real gl drawable size is the size of the window.
3464          */
3465         if (dstSwapchain && (IWineD3DSurface *)This == dstSwapchain->frontBuffer) {
3466             RECT windowsize;
3467             POINT offset = {0,0};
3468             UINT h;
3469             ClientToScreen(dstSwapchain->win_handle, &offset);
3470             GetClientRect(dstSwapchain->win_handle, &windowsize);
3471             h = windowsize.bottom - windowsize.top;
3472             rect.x1 -= offset.x; rect.x2 -=offset.x;
3473             rect.y1 -= offset.y; rect.y2 -=offset.y;
3474             rect.y1 += This->currentDesc.Height - h; rect.y2 += This->currentDesc.Height - h;
3475         }
3476
3477         myDevice->blitter->set_shader((IWineD3DDevice *) myDevice, Src->resource.format_desc->format,
3478                                        Src->glDescription.target, Src->pow2Width, Src->pow2Height);
3479
3480         ENTER_GL();
3481
3482         /* Bind the texture */
3483         glBindTexture(Src->glDescription.target, Src->glDescription.textureName);
3484         checkGLcall("glBindTexture");
3485
3486         /* Filtering for StretchRect */
3487         glTexParameteri(Src->glDescription.target, GL_TEXTURE_MAG_FILTER,
3488                         magLookup[Filter - WINED3DTEXF_NONE]);
3489         checkGLcall("glTexParameteri");
3490         glTexParameteri(Src->glDescription.target, GL_TEXTURE_MIN_FILTER,
3491                         minMipLookup[Filter].mip[WINED3DTEXF_NONE]);
3492         checkGLcall("glTexParameteri");
3493         glTexParameteri(Src->glDescription.target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3494         glTexParameteri(Src->glDescription.target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3495         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
3496         checkGLcall("glTexEnvi");
3497
3498         /* This is for color keying */
3499         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3500             glEnable(GL_ALPHA_TEST);
3501             checkGLcall("glEnable GL_ALPHA_TEST");
3502
3503             /* When the primary render target uses P8, the alpha component contains the palette index.
3504              * Which means that the colorkey is one of the palette entries. In other cases pixels that
3505              * should be masked away have alpha set to 0. */
3506             if(primary_render_target_is_p8(myDevice))
3507                 glAlphaFunc(GL_NOTEQUAL, (float)Src->SrcBltCKey.dwColorSpaceLowValue / 256.0);
3508             else
3509                 glAlphaFunc(GL_NOTEQUAL, 0.0);
3510             checkGLcall("glAlphaFunc\n");
3511         } else {
3512             glDisable(GL_ALPHA_TEST);
3513             checkGLcall("glDisable GL_ALPHA_TEST");
3514         }
3515
3516         /* Draw a textured quad
3517          */
3518         glBegin(GL_QUADS);
3519
3520         glColor3d(1.0f, 1.0f, 1.0f);
3521         glTexCoord2f(glTexCoord[0], glTexCoord[2]);
3522         glVertex3f(rect.x1,
3523                     rect.y1,
3524                     0.0);
3525
3526         glTexCoord2f(glTexCoord[0], glTexCoord[3]);
3527         glVertex3f(rect.x1, rect.y2, 0.0);
3528
3529         glTexCoord2f(glTexCoord[1], glTexCoord[3]);
3530         glVertex3f(rect.x2,
3531                     rect.y2,
3532                     0.0);
3533
3534         glTexCoord2f(glTexCoord[1], glTexCoord[2]);
3535         glVertex3f(rect.x2,
3536                     rect.y1,
3537                     0.0);
3538         glEnd();
3539         checkGLcall("glEnd");
3540
3541         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3542             glDisable(GL_ALPHA_TEST);
3543             checkGLcall("glDisable(GL_ALPHA_TEST)");
3544         }
3545
3546         glBindTexture(Src->glDescription.target, 0);
3547         checkGLcall("glBindTexture(Src->glDescription.target, 0)");
3548
3549         /* Restore the color key parameters */
3550         Src->CKeyFlags = oldCKeyFlags;
3551         Src->SrcBltCKey = oldBltCKey;
3552
3553         /* Clear the palette as the surface didn't have a palette attached, it would confuse GetPalette and other calls */
3554         if(paletteOverride)
3555             Src->palette = NULL;
3556
3557         LEAVE_GL();
3558
3559         /* Leave the opengl state valid for blitting */
3560         myDevice->blitter->unset_shader((IWineD3DDevice *) myDevice);
3561
3562         /* Flush in case the drawable is used by multiple GL contexts */
3563         if(dstSwapchain && (This == (IWineD3DSurfaceImpl *) dstSwapchain->frontBuffer || dstSwapchain->num_contexts >= 2))
3564             glFlush();
3565
3566         /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3567         /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3568          * is outdated now
3569          */
3570         IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INDRAWABLE, TRUE);
3571
3572         return WINED3D_OK;
3573     } else {
3574         /* Source-Less Blit to render target */
3575         if (Flags & WINEDDBLT_COLORFILL) {
3576             /* This is easy to handle for the D3D Device... */
3577             DWORD color;
3578
3579             TRACE("Colorfill\n");
3580
3581             /* This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0] || dstSwapchain
3582                 must be true if we are here */
3583             if (This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0] &&
3584                     !(This == (IWineD3DSurfaceImpl*) dstSwapchain->frontBuffer ||
3585                       (dstSwapchain->backBuffer && This == (IWineD3DSurfaceImpl*) dstSwapchain->backBuffer[0]))) {
3586                 TRACE("Surface is higher back buffer, falling back to software\n");
3587                 return WINED3DERR_INVALIDCALL;
3588             }
3589
3590             /* The color as given in the Blt function is in the format of the frame-buffer...
3591              * 'clear' expect it in ARGB format => we need to do some conversion :-)
3592              */
3593             if (This->resource.format_desc->format == WINED3DFMT_P8)
3594             {
3595                 DWORD alpha;
3596
3597                 if (primary_render_target_is_p8(myDevice)) alpha = DDBltFx->u5.dwFillColor << 24;
3598                 else alpha = 0xFF000000;
3599
3600                 if (This->palette) {
3601                     color = (alpha |
3602                             (This->palette->palents[DDBltFx->u5.dwFillColor].peRed << 16) |
3603                             (This->palette->palents[DDBltFx->u5.dwFillColor].peGreen << 8) |
3604                             (This->palette->palents[DDBltFx->u5.dwFillColor].peBlue));
3605                 } else {
3606                     color = alpha;
3607                 }
3608             }
3609             else if (This->resource.format_desc->format == WINED3DFMT_R5G6B5)
3610             {
3611                 if (DDBltFx->u5.dwFillColor == 0xFFFF) {
3612                     color = 0xFFFFFFFF;
3613                 } else {
3614                     color = ((0xFF000000) |
3615                             ((DDBltFx->u5.dwFillColor & 0xF800) << 8) |
3616                             ((DDBltFx->u5.dwFillColor & 0x07E0) << 5) |
3617                             ((DDBltFx->u5.dwFillColor & 0x001F) << 3));
3618                 }
3619             }
3620             else if ((This->resource.format_desc->format == WINED3DFMT_R8G8B8)
3621                     || (This->resource.format_desc->format == WINED3DFMT_X8R8G8B8))
3622             {
3623                 color = 0xFF000000 | DDBltFx->u5.dwFillColor;
3624             }
3625             else if (This->resource.format_desc->format == WINED3DFMT_A8R8G8B8)
3626             {
3627                 color = DDBltFx->u5.dwFillColor;
3628             }
3629             else {
3630                 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3631                 return WINED3DERR_INVALIDCALL;
3632             }
3633
3634             TRACE("(%p) executing Render Target override, color = %x\n", This, color);
3635             IWineD3DDeviceImpl_ClearSurface(myDevice, This,
3636                                             1, /* Number of rectangles */
3637                                             &rect, WINED3DCLEAR_TARGET, color,
3638                                             0.0 /* Z */,
3639                                             0 /* Stencil */);
3640             return WINED3D_OK;
3641         }
3642     }
3643
3644     /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3645     TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3646     return WINED3DERR_INVALIDCALL;
3647 }
3648
3649 static HRESULT IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3650         IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx)
3651 {
3652     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3653     float depth;
3654
3655     if (Flags & WINEDDBLT_DEPTHFILL) {
3656         switch(This->resource.format_desc->format)
3657         {
3658             case WINED3DFMT_D16_UNORM:
3659                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
3660                 break;
3661             case WINED3DFMT_D15S1:
3662                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000fffe;
3663                 break;
3664             case WINED3DFMT_D24S8:
3665             case WINED3DFMT_D24X8:
3666                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x00ffffff;
3667                 break;
3668             case WINED3DFMT_D32:
3669                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0xffffffff;
3670                 break;
3671             default:
3672                 depth = 0.0;
3673                 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This->resource.format_desc->format));
3674         }
3675
3676         return IWineD3DDevice_Clear((IWineD3DDevice *) myDevice,
3677                                     DestRect == NULL ? 0 : 1,
3678                                     (const WINED3DRECT *)DestRect,
3679                                     WINED3DCLEAR_ZBUFFER,
3680                                     0x00000000,
3681                                     depth,
3682                                     0x00000000);
3683     }
3684
3685     FIXME("(%p): Unsupp depthstencil blit\n", This);
3686     return WINED3DERR_INVALIDCALL;
3687 }
3688
3689 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect, IWineD3DSurface *SrcSurface,
3690         const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
3691     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
3692     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3693     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3694     TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3695     TRACE("(%p): Usage is %s\n", This, debug_d3dusage(This->resource.usage));
3696
3697     if ( (This->Flags & SFLAG_LOCKED) || ((Src != NULL) && (Src->Flags & SFLAG_LOCKED)))
3698     {
3699         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3700         return WINEDDERR_SURFACEBUSY;
3701     }
3702
3703     /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3704      * except depth blits, which seem to work
3705      */
3706     if(iface == myDevice->stencilBufferTarget || (SrcSurface && SrcSurface == myDevice->stencilBufferTarget)) {
3707         if(myDevice->inScene && !(Flags & WINEDDBLT_DEPTHFILL)) {
3708             TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3709             return WINED3DERR_INVALIDCALL;
3710         } else if(IWineD3DSurfaceImpl_BltZ(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx) == WINED3D_OK) {
3711             TRACE("Z Blit override handled the blit\n");
3712             return WINED3D_OK;
3713         }
3714     }
3715
3716     /* Special cases for RenderTargets */
3717     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3718         ( Src && (Src->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3719         if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
3720     }
3721
3722     /* For the rest call the X11 surface implementation.
3723      * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3724      * other Blts are rather rare
3725      */
3726     return IWineD3DBaseSurfaceImpl_Blt(iface, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter);
3727 }
3728
3729 static HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
3730         IWineD3DSurface *Source, const RECT *rsrc, DWORD trans)
3731 {
3732     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3733     IWineD3DSurfaceImpl *srcImpl = (IWineD3DSurfaceImpl *) Source;
3734     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3735     TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface, dstx, dsty, Source, rsrc, trans);
3736
3737     if ( (This->Flags & SFLAG_LOCKED) || ((srcImpl != NULL) && (srcImpl->Flags & SFLAG_LOCKED)))
3738     {
3739         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3740         return WINEDDERR_SURFACEBUSY;
3741     }
3742
3743     if(myDevice->inScene &&
3744        (iface == myDevice->stencilBufferTarget ||
3745        (Source && Source == myDevice->stencilBufferTarget))) {
3746         TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3747         return WINED3DERR_INVALIDCALL;
3748     }
3749
3750     /* Special cases for RenderTargets */
3751     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3752         ( srcImpl && (srcImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3753
3754         RECT SrcRect, DstRect;
3755         DWORD Flags=0;
3756
3757         if(rsrc) {
3758             SrcRect.left = rsrc->left;
3759             SrcRect.top= rsrc->top;
3760             SrcRect.bottom = rsrc->bottom;
3761             SrcRect.right = rsrc->right;
3762         } else {
3763             SrcRect.left = 0;
3764             SrcRect.top = 0;
3765             SrcRect.right = srcImpl->currentDesc.Width;
3766             SrcRect.bottom = srcImpl->currentDesc.Height;
3767         }
3768
3769         DstRect.left = dstx;
3770         DstRect.top=dsty;
3771         DstRect.right = dstx + SrcRect.right - SrcRect.left;
3772         DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
3773
3774         /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3775         if(trans & WINEDDBLTFAST_SRCCOLORKEY)
3776             Flags |= WINEDDBLT_KEYSRC;
3777         if(trans & WINEDDBLTFAST_DESTCOLORKEY)
3778             Flags |= WINEDDBLT_KEYDEST;
3779         if(trans & WINEDDBLTFAST_WAIT)
3780             Flags |= WINEDDBLT_WAIT;
3781         if(trans & WINEDDBLTFAST_DONOTWAIT)
3782             Flags |= WINEDDBLT_DONOTWAIT;
3783
3784         if(IWineD3DSurfaceImpl_BltOverride(This, &DstRect, Source, &SrcRect, Flags, NULL, WINED3DTEXF_POINT) == WINED3D_OK) return WINED3D_OK;
3785     }
3786
3787
3788     return IWineD3DBaseSurfaceImpl_BltFast(iface, dstx, dsty, Source, rsrc, trans);
3789 }
3790
3791 static HRESULT WINAPI IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface *iface)
3792 {
3793     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3794     RGBQUAD col[256];
3795     IWineD3DPaletteImpl *pal = This->palette;
3796     unsigned int n;
3797     TRACE("(%p)\n", This);
3798
3799     if (!pal) return WINED3D_OK;
3800
3801     if (This->resource.format_desc->format == WINED3DFMT_P8
3802             || This->resource.format_desc->format == WINED3DFMT_A8P8)
3803     {
3804         int bpp;
3805         GLenum format, internal, type;
3806         CONVERT_TYPES convert;
3807
3808         /* Check if we are using a RTL mode which uses texturing for uploads */
3809         BOOL use_texture = (wined3d_settings.rendertargetlock_mode == RTL_READTEX || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX);
3810
3811         /* Check if we have hardware palette conversion if we have convert is set to NO_CONVERSION */
3812         d3dfmt_get_conv(This, TRUE, use_texture, &format, &internal, &type, &convert, &bpp, FALSE);
3813
3814         if((This->resource.usage & WINED3DUSAGE_RENDERTARGET) && (convert == NO_CONVERSION))
3815         {
3816             /* Make sure the texture is up to date. This call doesn't do anything if the texture is already up to date. */
3817             IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL);
3818
3819             /* We want to force a palette refresh, so mark the drawable as not being up to date */
3820             IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
3821
3822             /* Re-upload the palette */
3823             d3dfmt_p8_upload_palette(iface, convert);
3824         } else {
3825             if(!(This->Flags & SFLAG_INSYSMEM)) {
3826                 TRACE("Palette changed with surface that does not have an up to date system memory copy\n");
3827                 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
3828             }
3829             TRACE("Dirtifying surface\n");
3830             IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
3831         }
3832     }
3833
3834     if(This->Flags & SFLAG_DIBSECTION) {
3835         TRACE("(%p): Updating the hdc's palette\n", This);
3836         for (n=0; n<256; n++) {
3837             col[n].rgbRed   = pal->palents[n].peRed;
3838             col[n].rgbGreen = pal->palents[n].peGreen;
3839             col[n].rgbBlue  = pal->palents[n].peBlue;
3840             col[n].rgbReserved = 0;
3841         }
3842         SetDIBColorTable(This->hDC, 0, 256, col);
3843     }
3844
3845     /* Propagate the changes to the drawable when we have a palette. */
3846     if(This->resource.usage & WINED3DUSAGE_RENDERTARGET)
3847         IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, NULL);
3848
3849     return WINED3D_OK;
3850 }
3851
3852 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
3853     /** Check against the maximum texture sizes supported by the video card **/
3854     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3855     unsigned int pow2Width, pow2Height;
3856
3857     This->glDescription.textureName      = 0;
3858     This->glDescription.target           = GL_TEXTURE_2D;
3859
3860     /* Non-power2 support */
3861     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) || GL_SUPPORT(WINE_NORMALIZED_TEXRECT)) {
3862         pow2Width = This->currentDesc.Width;
3863         pow2Height = This->currentDesc.Height;
3864     } else {
3865         /* Find the nearest pow2 match */
3866         pow2Width = pow2Height = 1;
3867         while (pow2Width < This->currentDesc.Width) pow2Width <<= 1;
3868         while (pow2Height < This->currentDesc.Height) pow2Height <<= 1;
3869     }
3870     This->pow2Width  = pow2Width;
3871     This->pow2Height = pow2Height;
3872
3873     if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
3874         WINED3DFORMAT Format = This->resource.format_desc->format;
3875         /** TODO: add support for non power two compressed textures **/
3876         if (Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3
3877             || Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5
3878             || Format == WINED3DFMT_ATI2N)
3879         {
3880             FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3881                   This, This->currentDesc.Width, This->currentDesc.Height);
3882             return WINED3DERR_NOTAVAILABLE;
3883         }
3884     }
3885
3886     if(pow2Width != This->currentDesc.Width ||
3887        pow2Height != This->currentDesc.Height) {
3888         This->Flags |= SFLAG_NONPOW2;
3889     }
3890
3891     TRACE("%p\n", This);
3892     if ((This->pow2Width > GL_LIMITS(texture_size) || This->pow2Height > GL_LIMITS(texture_size)) && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))) {
3893         /* one of three options
3894         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)
3895         2: Set the texture to the maximum size (bad idea)
3896         3:    WARN and return WINED3DERR_NOTAVAILABLE;
3897         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.
3898         */
3899         WARN("(%p) Creating an oversized surface: %ux%u (texture is %ux%u)\n",
3900              This, This->pow2Width, This->pow2Height, This->currentDesc.Width, This->currentDesc.Height);
3901         This->Flags |= SFLAG_OVERSIZE;
3902
3903         /* This will be initialized on the first blt */
3904         This->glRect.left = 0;
3905         This->glRect.top = 0;
3906         This->glRect.right = 0;
3907         This->glRect.bottom = 0;
3908     } else {
3909         /* Check this after the oversize check - do not make an oversized surface a texture_rectangle one.
3910            Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
3911            is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
3912            doesn't work in combination with ARB_TEXTURE_RECTANGLE.
3913         */
3914         if(This->Flags & SFLAG_NONPOW2 && GL_SUPPORT(ARB_TEXTURE_RECTANGLE)
3915                 && !((This->resource.format_desc->format == WINED3DFMT_P8) && GL_SUPPORT(EXT_PALETTED_TEXTURE)
3916                 && (wined3d_settings.rendertargetlock_mode == RTL_READTEX
3917                 || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX)))
3918         {
3919             This->glDescription.target = GL_TEXTURE_RECTANGLE_ARB;
3920             This->pow2Width  = This->currentDesc.Width;
3921             This->pow2Height = This->currentDesc.Height;
3922             This->Flags &= ~(SFLAG_NONPOW2 | SFLAG_NORMCOORD);
3923         }
3924
3925         /* No oversize, gl rect is the full texture size */
3926         This->Flags &= ~SFLAG_OVERSIZE;
3927         This->glRect.left = 0;
3928         This->glRect.top = 0;
3929         This->glRect.right = This->pow2Width;
3930         This->glRect.bottom = This->pow2Height;
3931     }
3932
3933     if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
3934         switch(wined3d_settings.offscreen_rendering_mode) {
3935             case ORM_FBO:        This->get_drawable_size = get_drawable_size_fbo;        break;
3936             case ORM_PBUFFER:    This->get_drawable_size = get_drawable_size_pbuffer;    break;
3937             case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
3938         }
3939     }
3940
3941     This->Flags |= SFLAG_INSYSMEM;
3942
3943     return WINED3D_OK;
3944 }
3945
3946 struct depth_blt_info
3947 {
3948     GLenum binding;
3949     GLenum bind_target;
3950     enum tex_types tex_type;
3951     GLfloat coords[4][3];
3952 };
3953
3954 static void surface_get_depth_blt_info(GLenum target, GLsizei w, GLsizei h, struct depth_blt_info *info)
3955 {
3956     GLfloat (*coords)[3] = info->coords;
3957
3958     switch (target)
3959     {
3960         default:
3961             FIXME("Unsupported texture target %#x\n", target);
3962             /* Fall back to GL_TEXTURE_2D */
3963         case GL_TEXTURE_2D:
3964             info->binding = GL_TEXTURE_BINDING_2D;
3965             info->bind_target = GL_TEXTURE_2D;
3966             info->tex_type = tex_2d;
3967             coords[0][0] = 0.0f;    coords[0][1] = 1.0f;    coords[0][2] = 0.0f;
3968             coords[1][0] = 1.0f;    coords[1][1] = 1.0f;    coords[1][2] = 0.0f;
3969             coords[2][0] = 0.0f;    coords[2][1] = 0.0f;    coords[2][2] = 0.0f;
3970             coords[3][0] = 1.0f;    coords[3][1] = 0.0f;    coords[3][2] = 0.0f;
3971             break;
3972
3973         case GL_TEXTURE_RECTANGLE_ARB:
3974             info->binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
3975             info->bind_target = GL_TEXTURE_RECTANGLE_ARB;
3976             info->tex_type = tex_rect;
3977             coords[0][0] = 0.0f;    coords[0][1] = h;       coords[0][2] = 0.0f;
3978             coords[1][0] = w;       coords[1][1] = h;       coords[1][2] = 0.0f;
3979             coords[2][0] = 0.0f;    coords[2][1] = 0.0f;    coords[2][2] = 0.0f;
3980             coords[3][0] = w;       coords[3][1] = 0.0f;    coords[3][2] = 0.0f;
3981             break;
3982
3983         case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
3984             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
3985             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
3986             info->tex_type = tex_cube;
3987             coords[0][0] =  1.0f;   coords[0][1] = -1.0f;   coords[0][2] =  1.0f;
3988             coords[1][0] =  1.0f;   coords[1][1] = -1.0f;   coords[1][2] = -1.0f;
3989             coords[2][0] =  1.0f;   coords[2][1] =  1.0f;   coords[2][2] =  1.0f;
3990             coords[3][0] =  1.0f;   coords[3][1] =  1.0f;   coords[3][2] = -1.0f;
3991
3992         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
3993             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
3994             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
3995             info->tex_type = tex_cube;
3996             coords[0][0] = -1.0f;   coords[0][1] = -1.0f;   coords[0][2] = -1.0f;
3997             coords[1][0] = -1.0f;   coords[1][1] = -1.0f;   coords[1][2] =  1.0f;
3998             coords[2][0] = -1.0f;   coords[2][1] =  1.0f;   coords[2][2] = -1.0f;
3999             coords[3][0] = -1.0f;   coords[3][1] =  1.0f;   coords[3][2] =  1.0f;
4000
4001         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4002             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4003             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4004             info->tex_type = tex_cube;
4005             coords[0][0] = -1.0f;   coords[0][1] =  1.0f;   coords[0][2] =  1.0f;
4006             coords[1][0] =  1.0f;   coords[1][1] =  1.0f;   coords[1][2] =  1.0f;
4007             coords[2][0] = -1.0f;   coords[2][1] =  1.0f;   coords[2][2] = -1.0f;
4008             coords[3][0] =  1.0f;   coords[3][1] =  1.0f;   coords[3][2] = -1.0f;
4009
4010         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4011             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4012             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4013             info->tex_type = tex_cube;
4014             coords[0][0] = -1.0f;   coords[0][1] = -1.0f;   coords[0][2] = -1.0f;
4015             coords[1][0] =  1.0f;   coords[1][1] = -1.0f;   coords[1][2] = -1.0f;
4016             coords[2][0] = -1.0f;   coords[2][1] = -1.0f;   coords[2][2] =  1.0f;
4017             coords[3][0] =  1.0f;   coords[3][1] = -1.0f;   coords[3][2] =  1.0f;
4018
4019         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4020             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4021             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4022             info->tex_type = tex_cube;
4023             coords[0][0] = -1.0f;   coords[0][1] = -1.0f;   coords[0][2] =  1.0f;
4024             coords[1][0] =  1.0f;   coords[1][1] = -1.0f;   coords[1][2] =  1.0f;
4025             coords[2][0] = -1.0f;   coords[2][1] =  1.0f;   coords[2][2] =  1.0f;
4026             coords[3][0] =  1.0f;   coords[3][1] =  1.0f;   coords[3][2] =  1.0f;
4027
4028         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4029             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
4030             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4031             info->tex_type = tex_cube;
4032             coords[0][0] =  1.0f;   coords[0][1] = -1.0f;   coords[0][2] = -1.0f;
4033             coords[1][0] = -1.0f;   coords[1][1] = -1.0f;   coords[1][2] = -1.0f;
4034             coords[2][0] =  1.0f;   coords[2][1] =  1.0f;   coords[2][2] = -1.0f;
4035             coords[3][0] = -1.0f;   coords[3][1] =  1.0f;   coords[3][2] = -1.0f;
4036     }
4037 }
4038
4039 static void surface_depth_blt(IWineD3DSurfaceImpl *This, GLuint texture, GLsizei w, GLsizei h, GLenum target)
4040 {
4041     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4042     struct depth_blt_info info;
4043     GLint old_binding = 0;
4044
4045     glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_VIEWPORT_BIT);
4046
4047     glDisable(GL_CULL_FACE);
4048     glEnable(GL_BLEND);
4049     glDisable(GL_ALPHA_TEST);
4050     glDisable(GL_SCISSOR_TEST);
4051     glDisable(GL_STENCIL_TEST);
4052     glEnable(GL_DEPTH_TEST);
4053     glDepthFunc(GL_ALWAYS);
4054     glDepthMask(GL_TRUE);
4055     glBlendFunc(GL_ZERO, GL_ONE);
4056     glViewport(0, 0, w, h);
4057
4058     surface_get_depth_blt_info(target, w, h, &info);
4059     GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
4060     glGetIntegerv(info.binding, &old_binding);
4061     glBindTexture(info.bind_target, texture);
4062
4063     device->shader_backend->shader_select_depth_blt((IWineD3DDevice *)device, info.tex_type);
4064
4065     glBegin(GL_TRIANGLE_STRIP);
4066     glTexCoord3fv(info.coords[0]);
4067     glVertex2f(-1.0f, -1.0f);
4068     glTexCoord3fv(info.coords[1]);
4069     glVertex2f(1.0f, -1.0f);
4070     glTexCoord3fv(info.coords[2]);
4071     glVertex2f(-1.0f, 1.0f);
4072     glTexCoord3fv(info.coords[3]);
4073     glVertex2f(1.0f, 1.0f);
4074     glEnd();
4075
4076     glBindTexture(info.bind_target, old_binding);
4077
4078     glPopAttrib();
4079
4080     device->shader_backend->shader_deselect_depth_blt((IWineD3DDevice *)device);
4081 }
4082
4083 void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location) {
4084     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4085
4086     TRACE("(%p) New location %#x\n", This, location);
4087
4088     if (location & ~SFLAG_DS_LOCATIONS) {
4089         FIXME("(%p) Invalid location (%#x) specified\n", This, location);
4090     }
4091
4092     This->Flags &= ~SFLAG_DS_LOCATIONS;
4093     This->Flags |= location;
4094 }
4095
4096 void surface_load_ds_location(IWineD3DSurface *iface, DWORD location) {
4097     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4098     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4099
4100     TRACE("(%p) New location %#x\n", This, location);
4101
4102     /* TODO: Make this work for modes other than FBO */
4103     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return;
4104
4105     if (This->Flags & location) {
4106         TRACE("(%p) Location (%#x) is already up to date\n", This, location);
4107         return;
4108     }
4109
4110     if (This->current_renderbuffer) {
4111         FIXME("(%p) Not supported with fixed up depth stencil\n", This);
4112         return;
4113     }
4114
4115     if (location == SFLAG_DS_OFFSCREEN) {
4116         if (This->Flags & SFLAG_DS_ONSCREEN) {
4117             GLint old_binding = 0;
4118             GLenum bind_target;
4119
4120             TRACE("(%p) Copying onscreen depth buffer to depth texture\n", This);
4121
4122             ENTER_GL();
4123
4124             if (!device->depth_blt_texture) {
4125                 glGenTextures(1, &device->depth_blt_texture);
4126             }
4127
4128             /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
4129              * directly on the FBO texture. That's because we need to flip. */
4130             GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4131             if (This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
4132                 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
4133                 bind_target = GL_TEXTURE_RECTANGLE_ARB;
4134             } else {
4135                 glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
4136                 bind_target = GL_TEXTURE_2D;
4137             }
4138             glBindTexture(bind_target, device->depth_blt_texture);
4139             glCopyTexImage2D(bind_target,
4140                     This->glDescription.level,
4141                     This->resource.format_desc->glInternal,
4142                     0,
4143                     0,
4144                     This->currentDesc.Width,
4145                     This->currentDesc.Height,
4146                     0);
4147             glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4148             glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4149             glTexParameteri(bind_target, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
4150             glBindTexture(bind_target, old_binding);
4151
4152             /* Setup the destination */
4153             if (!device->depth_blt_rb) {
4154                 GL_EXTCALL(glGenRenderbuffersEXT(1, &device->depth_blt_rb));
4155                 checkGLcall("glGenRenderbuffersEXT");
4156             }
4157             if (device->depth_blt_rb_w != This->currentDesc.Width
4158                     || device->depth_blt_rb_h != This->currentDesc.Height) {
4159                 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, device->depth_blt_rb));
4160                 checkGLcall("glBindRenderbufferEXT");
4161                 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, This->currentDesc.Width, This->currentDesc.Height));
4162                 checkGLcall("glRenderbufferStorageEXT");
4163                 device->depth_blt_rb_w = This->currentDesc.Width;
4164                 device->depth_blt_rb_h = This->currentDesc.Height;
4165             }
4166
4167             context_bind_fbo((IWineD3DDevice *)device, GL_FRAMEBUFFER_EXT, &device->activeContext->dst_fbo);
4168             GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, device->depth_blt_rb));
4169             checkGLcall("glFramebufferRenderbufferEXT");
4170             context_attach_depth_stencil_fbo(device, GL_FRAMEBUFFER_EXT, iface, FALSE);
4171
4172             /* Do the actual blit */
4173             surface_depth_blt(This, device->depth_blt_texture, This->currentDesc.Width, This->currentDesc.Height, bind_target);
4174             checkGLcall("depth_blt");
4175
4176             if (device->activeContext->current_fbo) {
4177                 context_bind_fbo((IWineD3DDevice *)device, GL_FRAMEBUFFER_EXT, &device->activeContext->current_fbo->id);
4178             } else {
4179                 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4180                 checkGLcall("glBindFramebuffer()");
4181             }
4182
4183             LEAVE_GL();
4184         } else {
4185             FIXME("No up to date depth stencil location\n");
4186         }
4187     } else if (location == SFLAG_DS_ONSCREEN) {
4188         if (This->Flags & SFLAG_DS_OFFSCREEN) {
4189             TRACE("(%p) Copying depth texture to onscreen depth buffer\n", This);
4190
4191             ENTER_GL();
4192
4193             GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
4194             checkGLcall("glBindFramebuffer()");
4195             surface_depth_blt(This, This->glDescription.textureName, This->currentDesc.Width, This->currentDesc.Height, This->glDescription.target);
4196             checkGLcall("depth_blt");
4197
4198             if (device->activeContext->current_fbo) {
4199                 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, device->activeContext->current_fbo->id));
4200                 checkGLcall("glBindFramebuffer()");
4201             }
4202
4203             LEAVE_GL();
4204         } else {
4205             FIXME("No up to date depth stencil location\n");
4206         }
4207     } else {
4208         ERR("(%p) Invalid location (%#x) specified\n", This, location);
4209     }
4210
4211     This->Flags |= location;
4212 }
4213
4214 static void WINAPI IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
4215     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4216     IWineD3DBaseTexture *texture;
4217     IWineD3DSurfaceImpl *overlay;
4218
4219     TRACE("(%p)->(%s, %s)\n", iface, debug_surflocation(flag),
4220           persistent ? "TRUE" : "FALSE");
4221
4222     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4223         IWineD3DSwapChain *swapchain = NULL;
4224
4225         if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
4226             TRACE("Surface %p is an onscreen surface\n", iface);
4227
4228             IWineD3DSwapChain_Release(swapchain);
4229         } else {
4230             /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4231             if (flag & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)) flag |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4232         }
4233     }
4234
4235     if(persistent) {
4236         if(((This->Flags & SFLAG_INTEXTURE) && !(flag & SFLAG_INTEXTURE)) ||
4237            ((This->Flags & SFLAG_INSRGBTEX) && !(flag & SFLAG_INSRGBTEX))) {
4238             if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4239                 TRACE("Passing to container\n");
4240                 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4241                 IWineD3DBaseTexture_Release(texture);
4242             }
4243         }
4244         This->Flags &= ~SFLAG_LOCATIONS;
4245         This->Flags |= flag;
4246
4247         /* Redraw emulated overlays, if any */
4248         if(flag & SFLAG_INDRAWABLE && !list_empty(&This->overlays)) {
4249             LIST_FOR_EACH_ENTRY(overlay, &This->overlays, IWineD3DSurfaceImpl, overlay_entry) {
4250                 IWineD3DSurface_DrawOverlay((IWineD3DSurface *) overlay);
4251             }
4252         }
4253     } else {
4254         if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) && (flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX))) {
4255             if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4256                 TRACE("Passing to container\n");
4257                 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4258                 IWineD3DBaseTexture_Release(texture);
4259             }
4260         }
4261         This->Flags &= ~flag;
4262     }
4263
4264     if(!(This->Flags & SFLAG_LOCATIONS)) {
4265         ERR("%p: Surface does not have any up to date location\n", This);
4266     }
4267 }
4268
4269 struct coords {
4270     GLfloat x, y, z;
4271 };
4272
4273 struct float_rect
4274 {
4275     float l;
4276     float t;
4277     float r;
4278     float b;
4279 };
4280
4281 static inline void cube_coords_float(const RECT *r, UINT w, UINT h, struct float_rect *f)
4282 {
4283     f->l = ((r->left * 2.0f) / w) - 1.0f;
4284     f->t = ((r->top * 2.0f) / h) - 1.0f;
4285     f->r = ((r->right * 2.0f) / w) - 1.0f;
4286     f->b = ((r->bottom * 2.0f) / h) - 1.0f;
4287 }
4288
4289 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT *rect_in) {
4290     struct coords coords[4];
4291     RECT rect;
4292     IWineD3DSwapChain *swapchain;
4293     IWineD3DBaseTexture *texture;
4294     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4295     GLenum bind_target;
4296     struct float_rect f;
4297
4298     if(rect_in) {
4299         rect = *rect_in;
4300     } else {
4301         rect.left = 0;
4302         rect.top = 0;
4303         rect.right = This->currentDesc.Width;
4304         rect.bottom = This->currentDesc.Height;
4305     }
4306
4307     switch(This->glDescription.target)
4308     {
4309         case GL_TEXTURE_2D:
4310             bind_target = GL_TEXTURE_2D;
4311
4312             coords[0].x = (float)rect.left / This->pow2Width;
4313             coords[0].y = (float)rect.top / This->pow2Height;
4314             coords[0].z = 0;
4315
4316             coords[1].x = (float)rect.left / This->pow2Width;
4317             coords[1].y = (float)rect.bottom / This->pow2Height;
4318             coords[1].z = 0;
4319
4320             coords[2].x = (float)rect.right / This->pow2Width;
4321             coords[2].y = (float)rect.bottom / This->pow2Height;
4322             coords[2].z = 0;
4323
4324             coords[3].x = (float)rect.right / This->pow2Width;
4325             coords[3].y = (float)rect.top / This->pow2Height;
4326             coords[3].z = 0;
4327             break;
4328
4329         case GL_TEXTURE_RECTANGLE_ARB:
4330             bind_target = GL_TEXTURE_RECTANGLE_ARB;
4331             coords[0].x = rect.left;    coords[0].y = rect.top;     coords[0].z = 0;
4332             coords[1].x = rect.left;    coords[1].y = rect.bottom;  coords[1].z = 0;
4333             coords[2].x = rect.right;   coords[2].y = rect.bottom;  coords[2].z = 0;
4334             coords[3].x = rect.right;   coords[3].y = rect.top;     coords[3].z = 0;
4335             break;
4336
4337         case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
4338             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4339             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4340             coords[0].x =    1; coords[0].y = -f.t; coords[0].z = -f.l;
4341             coords[1].x =    1; coords[1].y = -f.b; coords[1].z = -f.l;
4342             coords[2].x =    1; coords[2].y = -f.b; coords[2].z = -f.r;
4343             coords[3].x =    1; coords[3].y = -f.t; coords[3].z = -f.r;
4344             break;
4345
4346         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
4347             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4348             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4349             coords[0].x =   -1; coords[0].y = -f.t; coords[0].z =  f.l;
4350             coords[1].x =   -1; coords[1].y = -f.b; coords[1].z =  f.l;
4351             coords[2].x =   -1; coords[2].y = -f.b; coords[2].z =  f.r;
4352             coords[3].x =   -1; coords[3].y = -f.t; coords[3].z =  f.r;
4353             break;
4354
4355         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4356             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4357             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4358             coords[0].x =  f.l; coords[0].y =    1; coords[0].z =  f.t;
4359             coords[1].x =  f.l; coords[1].y =    1; coords[1].z =  f.b;
4360             coords[2].x =  f.r; coords[2].y =    1; coords[2].z =  f.b;
4361             coords[3].x =  f.r; coords[3].y =    1; coords[3].z =  f.t;
4362             break;
4363
4364         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4365             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4366             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4367             coords[0].x =  f.l; coords[0].y =   -1; coords[0].z = -f.t;
4368             coords[1].x =  f.l; coords[1].y =   -1; coords[1].z = -f.b;
4369             coords[2].x =  f.r; coords[2].y =   -1; coords[2].z = -f.b;
4370             coords[3].x =  f.r; coords[3].y =   -1; coords[3].z = -f.t;
4371             break;
4372
4373         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4374             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4375             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4376             coords[0].x =  f.l; coords[0].y = -f.t; coords[0].z =    1;
4377             coords[1].x =  f.l; coords[1].y = -f.b; coords[1].z =    1;
4378             coords[2].x =  f.r; coords[2].y = -f.b; coords[2].z =    1;
4379             coords[3].x =  f.r; coords[3].y = -f.t; coords[3].z =    1;
4380             break;
4381
4382         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4383             bind_target = GL_TEXTURE_CUBE_MAP_ARB;
4384             cube_coords_float(&rect, This->pow2Width, This->pow2Height, &f);
4385             coords[0].x = -f.l; coords[0].y = -f.t; coords[0].z =   -1;
4386             coords[1].x = -f.l; coords[1].y = -f.b; coords[1].z =   -1;
4387             coords[2].x = -f.r; coords[2].y = -f.b; coords[2].z =   -1;
4388             coords[3].x = -f.r; coords[3].y = -f.t; coords[3].z =   -1;
4389             break;
4390
4391         default:
4392             ERR("Unexpected texture target %#x\n", This->glDescription.target);
4393             return;
4394     }
4395
4396     ActivateContext(device, (IWineD3DSurface*)This, CTXUSAGE_BLIT);
4397     ENTER_GL();
4398
4399     glEnable(bind_target);
4400     checkGLcall("glEnable(bind_target)");
4401     glBindTexture(bind_target, This->glDescription.textureName);
4402     checkGLcall("bind_target, This->glDescription.textureName)");
4403     glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4404     checkGLcall("glTexParameteri");
4405     glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4406     checkGLcall("glTexParameteri");
4407
4408     if (device->render_offscreen)
4409     {
4410         LONG tmp = rect.top;
4411         rect.top = rect.bottom;
4412         rect.bottom = tmp;
4413     }
4414
4415     glBegin(GL_QUADS);
4416     glTexCoord3fv(&coords[0].x);
4417     glVertex2i(rect.left, rect.top);
4418
4419     glTexCoord3fv(&coords[1].x);
4420     glVertex2i(rect.left, rect.bottom);
4421
4422     glTexCoord3fv(&coords[2].x);
4423     glVertex2i(rect.right, rect.bottom);
4424
4425     glTexCoord3fv(&coords[3].x);
4426     glVertex2i(rect.right, rect.top);
4427     glEnd();
4428     checkGLcall("glEnd");
4429
4430     glDisable(bind_target);
4431     checkGLcall("glDisable(bind_target)");
4432
4433     LEAVE_GL();
4434
4435     if(SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface*)This, &IID_IWineD3DSwapChain, (void **) &swapchain)))
4436     {
4437         /* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
4438         if(((IWineD3DSwapChainImpl*)swapchain)->frontBuffer == (IWineD3DSurface*)This ||
4439            ((IWineD3DSwapChainImpl*)swapchain)->num_contexts >= 2)
4440             glFlush();
4441
4442         IWineD3DSwapChain_Release(swapchain);
4443     } else {
4444         /* We changed the filtering settings on the texture. Inform the container about this to get the filters
4445          * reset properly next draw
4446          */
4447         if(SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface*)This, &IID_IWineD3DBaseTexture, (void **) &texture)))
4448         {
4449             ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
4450             ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
4451             ((IWineD3DBaseTextureImpl *) texture)->baseTexture.states[WINED3DTEXSTA_MIPFILTER] = WINED3DTEXF_NONE;
4452             IWineD3DBaseTexture_Release(texture);
4453         }
4454     }
4455 }
4456
4457 /*****************************************************************************
4458  * IWineD3DSurface::LoadLocation
4459  *
4460  * Copies the current surface data from wherever it is to the requested
4461  * location. The location is one of the surface flags, SFLAG_INSYSMEM,
4462  * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
4463  * multiple locations, the gl texture is preferred over the drawable, which is
4464  * preferred over system memory. The PBO counts as system memory. If rect is
4465  * not NULL, only the specified rectangle is copied (only supported for
4466  * sysmem<->drawable copies at the moment). If rect is NULL, the destination
4467  * location is marked up to date after the copy.
4468  *
4469  * Parameters:
4470  *  flag: Surface location flag to be updated
4471  *  rect: rectangle to be copied
4472  *
4473  * Returns:
4474  *  WINED3D_OK on success
4475  *  WINED3DERR_DEVICELOST on an internal error
4476  *
4477  *****************************************************************************/
4478 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
4479     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4480     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
4481     IWineD3DSwapChain *swapchain = NULL;
4482     GLenum format, internal, type;
4483     CONVERT_TYPES convert;
4484     int bpp;
4485     int width, pitch, outpitch;
4486     BYTE *mem;
4487     BOOL drawable_read_ok = TRUE;
4488
4489     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4490         if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
4491             TRACE("Surface %p is an onscreen surface\n", iface);
4492
4493             IWineD3DSwapChain_Release(swapchain);
4494         } else {
4495             /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4496              * Prefer SFLAG_INTEXTURE. */
4497             if (flag == SFLAG_INDRAWABLE) flag = SFLAG_INTEXTURE;
4498             drawable_read_ok = FALSE;
4499         }
4500     }
4501
4502     TRACE("(%p)->(%s, %p)\n", iface, debug_surflocation(flag), rect);
4503     if(rect) {
4504         TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
4505     }
4506
4507     if(This->Flags & flag) {
4508         TRACE("Location already up to date\n");
4509         return WINED3D_OK;
4510     }
4511
4512     if(!(This->Flags & SFLAG_LOCATIONS)) {
4513         ERR("%p: Surface does not have any up to date location\n", This);
4514         This->Flags |= SFLAG_LOST;
4515         return WINED3DERR_DEVICELOST;
4516     }
4517
4518     if(flag == SFLAG_INSYSMEM) {
4519         surface_prepare_system_memory(This);
4520
4521         /* Download the surface to system memory */
4522         if(This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) {
4523             if(!device->isInDraw) ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4524             surface_bind_and_dirtify(This, !(This->Flags & SFLAG_INTEXTURE));
4525
4526             surface_download_data(This);
4527         } else {
4528             read_from_framebuffer(This, rect,
4529                                   This->resource.allocatedMemory,
4530                                   IWineD3DSurface_GetPitch(iface));
4531         }
4532     } else if(flag == SFLAG_INDRAWABLE) {
4533         if(This->Flags & SFLAG_INTEXTURE) {
4534             surface_blt_to_drawable(This, rect);
4535         } else {
4536             if((This->Flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX) {
4537                 /* This needs a shader to convert the srgb data sampled from the GL texture into RGB
4538                  * values, otherwise we get incorrect values in the target. For now go the slow way
4539                  * via a system memory copy
4540                  */
4541                 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4542             }
4543
4544             d3dfmt_get_conv(This, TRUE /* We need color keying */, FALSE /* We won't use textures */, &format, &internal, &type, &convert, &bpp, FALSE);
4545
4546             /* The width is in 'length' not in bytes */
4547             width = This->currentDesc.Width;
4548             pitch = IWineD3DSurface_GetPitch(iface);
4549
4550             /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4551              * but it isn't set (yet) in all cases it is getting called. */
4552             if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
4553                 TRACE("Removing the pbo attached to surface %p\n", This);
4554                 surface_remove_pbo(This);
4555             }
4556
4557             if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4558                 int height = This->currentDesc.Height;
4559
4560                 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4561                 outpitch = width * bpp;
4562                 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4563
4564                 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4565                 if(!mem) {
4566                     ERR("Out of memory %d, %d!\n", outpitch, height);
4567                     return WINED3DERR_OUTOFVIDEOMEMORY;
4568                 }
4569                 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4570
4571                 This->Flags |= SFLAG_CONVERTED;
4572             } else {
4573                 This->Flags &= ~SFLAG_CONVERTED;
4574                 mem = This->resource.allocatedMemory;
4575             }
4576
4577             flush_to_framebuffer_drawpixels(This, format, type, bpp, mem);
4578
4579             /* Don't delete PBO memory */
4580             if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4581                 HeapFree(GetProcessHeap(), 0, mem);
4582         }
4583     } else /* if(flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) */ {
4584         if (drawable_read_ok && (This->Flags & SFLAG_INDRAWABLE)) {
4585             read_from_framebuffer_texture(This, flag == SFLAG_INSRGBTEX);
4586         } else { /* Upload from system memory */
4587             BOOL srgb = flag == SFLAG_INSRGBTEX;
4588             DWORD alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
4589             d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb);
4590
4591             if(srgb) {
4592                 if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSYSMEM)) == SFLAG_INTEXTURE) {
4593                     /* Performance warning ... */
4594                     FIXME("%p: Downloading rgb texture to reload it as srgb\n", This);
4595                     IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4596                 }
4597             } else {
4598                 if((This->Flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX) {
4599                     /* Performance warning ... */
4600                     FIXME("%p: Downloading srgb texture to reload it as rgb\n", This);
4601                     IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4602                 }
4603             }
4604
4605             if(!device->isInDraw) ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4606             surface_bind_and_dirtify(This, srgb);
4607
4608             if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
4609                 This->Flags |= SFLAG_GLCKEY;
4610                 This->glCKey = This->SrcBltCKey;
4611             }
4612             else This->Flags &= ~SFLAG_GLCKEY;
4613
4614             /* The width is in 'length' not in bytes */
4615             width = This->currentDesc.Width;
4616             pitch = IWineD3DSurface_GetPitch(iface);
4617
4618             /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4619              * but it isn't set (yet) in all cases it is getting called. */
4620             if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
4621                 TRACE("Removing the pbo attached to surface %p\n", This);
4622                 surface_remove_pbo(This);
4623             }
4624
4625             if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4626                 int height = This->currentDesc.Height;
4627
4628                 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4629                 outpitch = width * bpp;
4630                 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4631
4632                 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4633                 if(!mem) {
4634                     ERR("Out of memory %d, %d!\n", outpitch, height);
4635                     return WINED3DERR_OUTOFVIDEOMEMORY;
4636                 }
4637                 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4638
4639                 This->Flags |= SFLAG_CONVERTED;
4640             }
4641             else if ((This->resource.format_desc->format == WINED3DFMT_P8)
4642                     && (GL_SUPPORT(EXT_PALETTED_TEXTURE) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM)))
4643             {
4644                 d3dfmt_p8_upload_palette(iface, convert);
4645                 This->Flags &= ~SFLAG_CONVERTED;
4646                 mem = This->resource.allocatedMemory;
4647             } else {
4648                 This->Flags &= ~SFLAG_CONVERTED;
4649                 mem = This->resource.allocatedMemory;
4650             }
4651
4652             /* Make sure the correct pitch is used */
4653             ENTER_GL();
4654             glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
4655             LEAVE_GL();
4656
4657             if ((This->Flags & SFLAG_NONPOW2) && !(This->Flags & SFLAG_OVERSIZE)) {
4658                 TRACE("non power of two support\n");
4659                 if(!(This->Flags & alloc_flag)) {
4660                     surface_allocate_surface(This, internal, This->pow2Width, This->pow2Height, format, type);
4661                     This->Flags |= alloc_flag;
4662                 }
4663                 if (mem || (This->Flags & SFLAG_PBO)) {
4664                     surface_upload_data(This, internal, This->currentDesc.Width, This->currentDesc.Height, format, type, mem);
4665                 }
4666             } else {
4667                 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
4668                  * changed. So also keep track of memory changes. In this case the texture has to be reallocated
4669                  */
4670                 if(!(This->Flags & alloc_flag)) {
4671                     surface_allocate_surface(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type);
4672                     This->Flags |= alloc_flag;
4673                 }
4674                 if (mem || (This->Flags & SFLAG_PBO)) {
4675                     surface_upload_data(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type, mem);
4676                 }
4677             }
4678
4679             /* Restore the default pitch */
4680             ENTER_GL();
4681             glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
4682             LEAVE_GL();
4683
4684             /* Don't delete PBO memory */
4685             if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4686                 HeapFree(GetProcessHeap(), 0, mem);
4687         }
4688     }
4689
4690     if(rect == NULL) {
4691         This->Flags |= flag;
4692     }
4693
4694     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !swapchain
4695             && (This->Flags & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE))) {
4696         /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4697         This->Flags |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4698     }
4699
4700     return WINED3D_OK;
4701 }
4702
4703 static HRESULT WINAPI IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container)
4704 {
4705     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4706     IWineD3DSwapChain *swapchain = NULL;
4707
4708     /* Update the drawable size method */
4709     if(container) {
4710         IWineD3DBase_QueryInterface(container, &IID_IWineD3DSwapChain, (void **) &swapchain);
4711     }
4712     if(swapchain) {
4713         This->get_drawable_size = get_drawable_size_swapchain;
4714         IWineD3DSwapChain_Release(swapchain);
4715     } else if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
4716         switch(wined3d_settings.offscreen_rendering_mode) {
4717             case ORM_FBO:        This->get_drawable_size = get_drawable_size_fbo;        break;
4718             case ORM_PBUFFER:    This->get_drawable_size = get_drawable_size_pbuffer;    break;
4719             case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
4720         }
4721     }
4722
4723     return IWineD3DBaseSurfaceImpl_SetContainer(iface, container);
4724 }
4725
4726 static WINED3DSURFTYPE WINAPI IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface *iface) {
4727     return SURFACE_OPENGL;
4728 }
4729
4730 static HRESULT WINAPI IWineD3DSurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
4731     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4732     HRESULT hr;
4733
4734     /* If there's no destination surface there is nothing to do */
4735     if(!This->overlay_dest) return WINED3D_OK;
4736
4737     /* Blt calls ModifyLocation on the dest surface, which in turn calls DrawOverlay to
4738      * update the overlay. Prevent an endless recursion
4739      */
4740     if(This->overlay_dest->Flags & SFLAG_INOVERLAYDRAW) {
4741         return WINED3D_OK;
4742     }
4743     This->overlay_dest->Flags |= SFLAG_INOVERLAYDRAW;
4744     hr = IWineD3DSurfaceImpl_Blt((IWineD3DSurface *) This->overlay_dest, &This->overlay_destrect,
4745                                  iface, &This->overlay_srcrect, WINEDDBLT_WAIT,
4746                                  NULL, WINED3DTEXF_LINEAR);
4747     This->overlay_dest->Flags &= ~SFLAG_INOVERLAYDRAW;
4748
4749     return hr;
4750 }
4751
4752 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
4753 {
4754     /* IUnknown */
4755     IWineD3DBaseSurfaceImpl_QueryInterface,
4756     IWineD3DBaseSurfaceImpl_AddRef,
4757     IWineD3DSurfaceImpl_Release,
4758     /* IWineD3DResource */
4759     IWineD3DBaseSurfaceImpl_GetParent,
4760     IWineD3DBaseSurfaceImpl_GetDevice,
4761     IWineD3DBaseSurfaceImpl_SetPrivateData,
4762     IWineD3DBaseSurfaceImpl_GetPrivateData,
4763     IWineD3DBaseSurfaceImpl_FreePrivateData,
4764     IWineD3DBaseSurfaceImpl_SetPriority,
4765     IWineD3DBaseSurfaceImpl_GetPriority,
4766     IWineD3DSurfaceImpl_PreLoad,
4767     IWineD3DSurfaceImpl_UnLoad,
4768     IWineD3DBaseSurfaceImpl_GetType,
4769     /* IWineD3DSurface */
4770     IWineD3DBaseSurfaceImpl_GetContainer,
4771     IWineD3DBaseSurfaceImpl_GetDesc,
4772     IWineD3DSurfaceImpl_LockRect,
4773     IWineD3DSurfaceImpl_UnlockRect,
4774     IWineD3DSurfaceImpl_GetDC,
4775     IWineD3DSurfaceImpl_ReleaseDC,
4776     IWineD3DSurfaceImpl_Flip,
4777     IWineD3DSurfaceImpl_Blt,
4778     IWineD3DBaseSurfaceImpl_GetBltStatus,
4779     IWineD3DBaseSurfaceImpl_GetFlipStatus,
4780     IWineD3DBaseSurfaceImpl_IsLost,
4781     IWineD3DBaseSurfaceImpl_Restore,
4782     IWineD3DSurfaceImpl_BltFast,
4783     IWineD3DBaseSurfaceImpl_GetPalette,
4784     IWineD3DBaseSurfaceImpl_SetPalette,
4785     IWineD3DSurfaceImpl_RealizePalette,
4786     IWineD3DBaseSurfaceImpl_SetColorKey,
4787     IWineD3DBaseSurfaceImpl_GetPitch,
4788     IWineD3DSurfaceImpl_SetMem,
4789     IWineD3DBaseSurfaceImpl_SetOverlayPosition,
4790     IWineD3DBaseSurfaceImpl_GetOverlayPosition,
4791     IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
4792     IWineD3DBaseSurfaceImpl_UpdateOverlay,
4793     IWineD3DBaseSurfaceImpl_SetClipper,
4794     IWineD3DBaseSurfaceImpl_GetClipper,
4795     /* Internal use: */
4796     IWineD3DSurfaceImpl_LoadTexture,
4797     IWineD3DSurfaceImpl_BindTexture,
4798     IWineD3DSurfaceImpl_SaveSnapshot,
4799     IWineD3DSurfaceImpl_SetContainer,
4800     IWineD3DSurfaceImpl_GetGlDesc,
4801     IWineD3DBaseSurfaceImpl_GetData,
4802     IWineD3DSurfaceImpl_SetFormat,
4803     IWineD3DSurfaceImpl_PrivateSetup,
4804     IWineD3DSurfaceImpl_ModifyLocation,
4805     IWineD3DSurfaceImpl_LoadLocation,
4806     IWineD3DSurfaceImpl_GetImplType,
4807     IWineD3DSurfaceImpl_DrawOverlay
4808 };
4809 #undef GLINFO_LOCATION
4810
4811 #define GLINFO_LOCATION device->adapter->gl_info
4812 static HRESULT ffp_blit_alloc(IWineD3DDevice *iface) { return WINED3D_OK; }
4813 static void ffp_blit_free(IWineD3DDevice *iface) { }
4814
4815 static HRESULT ffp_blit_set(IWineD3DDevice *iface, WINED3DFORMAT fmt, GLenum textype, UINT width, UINT height) {
4816     glEnable(textype);
4817     checkGLcall("glEnable(textype)");
4818     return WINED3D_OK;
4819 }
4820
4821 static void ffp_blit_unset(IWineD3DDevice *iface) {
4822     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
4823     glDisable(GL_TEXTURE_2D);
4824     checkGLcall("glDisable(GL_TEXTURE_2D)");
4825     if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
4826         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
4827         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4828     }
4829     if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
4830         glDisable(GL_TEXTURE_RECTANGLE_ARB);
4831         checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
4832     }
4833 }
4834
4835 static BOOL ffp_blit_color_fixup_supported(struct color_fixup_desc fixup)
4836 {
4837     if (TRACE_ON(d3d_surface) && TRACE_ON(d3d))
4838     {
4839         TRACE("Checking support for fixup:\n");
4840         dump_color_fixup_desc(fixup);
4841     }
4842
4843     /* We only support identity conversions. */
4844     if (is_identity_fixup(fixup))
4845     {
4846         TRACE("[OK]\n");
4847         return TRUE;
4848     }
4849
4850     TRACE("[FAILED]\n");
4851     return FALSE;
4852 }
4853
4854 const struct blit_shader ffp_blit =  {
4855     ffp_blit_alloc,
4856     ffp_blit_free,
4857     ffp_blit_set,
4858     ffp_blit_unset,
4859     ffp_blit_color_fixup_supported
4860 };