2 * IWineD3DSurface Implementation
4 * Copyright 1998 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2002-2005 Jason Edmeades
7 * Copyright 2002-2003 Raphael Junqueira
8 * Copyright 2004 Christian Costa
9 * Copyright 2005 Oliver Stieber
10 * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
11 * Copyright 2007-2008 Henri Verbeet
12 * Copyright 2006-2008 Roderick Colenbrander
13 * Copyright 2009 Henri Verbeet for CodeWeavers
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
31 #include "wine/port.h"
32 #include "wined3d_private.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
35 WINE_DECLARE_DEBUG_CHANNEL(d3d);
37 #define GLINFO_LOCATION (*gl_info)
39 static void surface_cleanup(IWineD3DSurfaceImpl *This)
41 IWineD3DDeviceImpl *device = This->resource.device;
42 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
43 struct wined3d_context *context = NULL;
44 renderbuffer_entry_t *entry, *entry2;
46 TRACE("(%p) : Cleaning up.\n", This);
48 /* Need a context to destroy the texture. Use the currently active render
49 * target, but only if the primary render target exists. Otherwise
50 * lastActiveRenderTarget is garbage. When destroying the primary render
51 * target, Uninit3D() will activate a context before doing anything. */
52 if (device->render_targets && device->render_targets[0])
54 context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
59 if (This->texture_name)
61 /* Release the OpenGL texture. */
62 TRACE("Deleting texture %u.\n", This->texture_name);
63 glDeleteTextures(1, &This->texture_name);
66 if (This->Flags & SFLAG_PBO)
69 GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
72 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry)
74 gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
75 HeapFree(GetProcessHeap(), 0, entry);
80 if (This->Flags & SFLAG_DIBSECTION)
83 SelectObject(This->hDC, This->dib.holdbitmap);
85 /* Release the DIB section. */
86 DeleteObject(This->dib.DIBsection);
87 This->dib.bitmap_data = NULL;
88 This->resource.allocatedMemory = NULL;
91 if (This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
92 if (This->overlay_dest) list_remove(&This->overlay_entry);
94 HeapFree(GetProcessHeap(), 0, This->palette9);
96 resource_cleanup((IWineD3DResource *)This);
98 if (context) context_release(context);
101 UINT surface_calculate_size(const struct wined3d_format_desc *format_desc, UINT alignment, UINT width, UINT height)
105 if (format_desc->format == WINED3DFMT_UNKNOWN)
109 else if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
111 UINT row_block_count = (width + format_desc->block_width - 1) / format_desc->block_width;
112 UINT row_count = (height + format_desc->block_height - 1) / format_desc->block_height;
113 size = row_count * row_block_count * format_desc->block_byte_count;
117 /* The pitch is a multiple of 4 bytes. */
118 size = height * (((width * format_desc->byte_count) + alignment - 1) & ~(alignment - 1));
121 if (format_desc->heightscale != 0.0f) size *= format_desc->heightscale;
130 enum tex_types tex_type;
131 GLfloat coords[4][3];
142 static inline void cube_coords_float(const RECT *r, UINT w, UINT h, struct float_rect *f)
144 f->l = ((r->left * 2.0f) / w) - 1.0f;
145 f->t = ((r->top * 2.0f) / h) - 1.0f;
146 f->r = ((r->right * 2.0f) / w) - 1.0f;
147 f->b = ((r->bottom * 2.0f) / h) - 1.0f;
150 static void surface_get_blt_info(GLenum target, const RECT *rect_in, GLsizei w, GLsizei h, struct blt_info *info)
152 GLfloat (*coords)[3] = info->coords;
169 FIXME("Unsupported texture target %#x\n", target);
170 /* Fall back to GL_TEXTURE_2D */
172 info->binding = GL_TEXTURE_BINDING_2D;
173 info->bind_target = GL_TEXTURE_2D;
174 info->tex_type = tex_2d;
175 coords[0][0] = (float)rect.left / w;
176 coords[0][1] = (float)rect.top / h;
179 coords[1][0] = (float)rect.right / w;
180 coords[1][1] = (float)rect.top / h;
183 coords[2][0] = (float)rect.left / w;
184 coords[2][1] = (float)rect.bottom / h;
187 coords[3][0] = (float)rect.right / w;
188 coords[3][1] = (float)rect.bottom / h;
192 case GL_TEXTURE_RECTANGLE_ARB:
193 info->binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
194 info->bind_target = GL_TEXTURE_RECTANGLE_ARB;
195 info->tex_type = tex_rect;
196 coords[0][0] = rect.left; coords[0][1] = rect.top; coords[0][2] = 0.0f;
197 coords[1][0] = rect.right; coords[1][1] = rect.top; coords[1][2] = 0.0f;
198 coords[2][0] = rect.left; coords[2][1] = rect.bottom; coords[2][2] = 0.0f;
199 coords[3][0] = rect.right; coords[3][1] = rect.bottom; coords[3][2] = 0.0f;
202 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
203 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
204 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
205 info->tex_type = tex_cube;
206 cube_coords_float(&rect, w, h, &f);
208 coords[0][0] = 1.0f; coords[0][1] = -f.t; coords[0][2] = -f.l;
209 coords[1][0] = 1.0f; coords[1][1] = -f.t; coords[1][2] = -f.r;
210 coords[2][0] = 1.0f; coords[2][1] = -f.b; coords[2][2] = -f.l;
211 coords[3][0] = 1.0f; coords[3][1] = -f.b; coords[3][2] = -f.r;
214 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
215 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
216 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
217 info->tex_type = tex_cube;
218 cube_coords_float(&rect, w, h, &f);
220 coords[0][0] = -1.0f; coords[0][1] = -f.t; coords[0][2] = f.l;
221 coords[1][0] = -1.0f; coords[1][1] = -f.t; coords[1][2] = f.r;
222 coords[2][0] = -1.0f; coords[2][1] = -f.b; coords[2][2] = f.l;
223 coords[3][0] = -1.0f; coords[3][1] = -f.b; coords[3][2] = f.r;
226 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
227 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
228 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
229 info->tex_type = tex_cube;
230 cube_coords_float(&rect, w, h, &f);
232 coords[0][0] = f.l; coords[0][1] = 1.0f; coords[0][2] = f.t;
233 coords[1][0] = f.r; coords[1][1] = 1.0f; coords[1][2] = f.t;
234 coords[2][0] = f.l; coords[2][1] = 1.0f; coords[2][2] = f.b;
235 coords[3][0] = f.r; coords[3][1] = 1.0f; coords[3][2] = f.b;
238 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
239 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
240 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
241 info->tex_type = tex_cube;
242 cube_coords_float(&rect, w, h, &f);
244 coords[0][0] = f.l; coords[0][1] = -1.0f; coords[0][2] = -f.t;
245 coords[1][0] = f.r; coords[1][1] = -1.0f; coords[1][2] = -f.t;
246 coords[2][0] = f.l; coords[2][1] = -1.0f; coords[2][2] = -f.b;
247 coords[3][0] = f.r; coords[3][1] = -1.0f; coords[3][2] = -f.b;
250 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
251 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
252 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
253 info->tex_type = tex_cube;
254 cube_coords_float(&rect, w, h, &f);
256 coords[0][0] = f.l; coords[0][1] = -f.t; coords[0][2] = 1.0f;
257 coords[1][0] = f.r; coords[1][1] = -f.t; coords[1][2] = 1.0f;
258 coords[2][0] = f.l; coords[2][1] = -f.b; coords[2][2] = 1.0f;
259 coords[3][0] = f.r; coords[3][1] = -f.b; coords[3][2] = 1.0f;
262 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
263 info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
264 info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
265 info->tex_type = tex_cube;
266 cube_coords_float(&rect, w, h, &f);
268 coords[0][0] = -f.l; coords[0][1] = -f.t; coords[0][2] = -1.0f;
269 coords[1][0] = -f.r; coords[1][1] = -f.t; coords[1][2] = -1.0f;
270 coords[2][0] = -f.l; coords[2][1] = -f.b; coords[2][2] = -1.0f;
271 coords[3][0] = -f.r; coords[3][1] = -f.b; coords[3][2] = -1.0f;
276 static inline void surface_get_rect(IWineD3DSurfaceImpl *This, const RECT *rect_in, RECT *rect_out)
279 *rect_out = *rect_in;
284 rect_out->right = This->currentDesc.Width;
285 rect_out->bottom = This->currentDesc.Height;
289 /* GL locking and context activation is done by the caller */
290 void draw_textured_quad(IWineD3DSurfaceImpl *src_surface, const RECT *src_rect, const RECT *dst_rect, WINED3DTEXTUREFILTERTYPE Filter)
292 IWineD3DBaseTextureImpl *texture;
293 struct blt_info info;
295 surface_get_blt_info(src_surface->texture_target, src_rect, src_surface->pow2Width, src_surface->pow2Height, &info);
297 glEnable(info.bind_target);
298 checkGLcall("glEnable(bind_target)");
300 /* Bind the texture */
301 glBindTexture(info.bind_target, src_surface->texture_name);
302 checkGLcall("glBindTexture");
304 /* Filtering for StretchRect */
305 glTexParameteri(info.bind_target, GL_TEXTURE_MAG_FILTER,
306 wined3d_gl_mag_filter(magLookup, Filter));
307 checkGLcall("glTexParameteri");
308 glTexParameteri(info.bind_target, GL_TEXTURE_MIN_FILTER,
309 wined3d_gl_min_mip_filter(minMipLookup, Filter, WINED3DTEXF_NONE));
310 checkGLcall("glTexParameteri");
311 glTexParameteri(info.bind_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
312 glTexParameteri(info.bind_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
313 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
314 checkGLcall("glTexEnvi");
317 glBegin(GL_TRIANGLE_STRIP);
318 glTexCoord3fv(info.coords[0]);
319 glVertex2i(dst_rect->left, dst_rect->top);
321 glTexCoord3fv(info.coords[1]);
322 glVertex2i(dst_rect->right, dst_rect->top);
324 glTexCoord3fv(info.coords[2]);
325 glVertex2i(dst_rect->left, dst_rect->bottom);
327 glTexCoord3fv(info.coords[3]);
328 glVertex2i(dst_rect->right, dst_rect->bottom);
331 /* Unbind the texture */
332 glBindTexture(info.bind_target, 0);
333 checkGLcall("glBindTexture(info->bind_target, 0)");
335 /* We changed the filtering settings on the texture. Inform the
336 * container about this to get the filters reset properly next draw. */
337 if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)src_surface, &IID_IWineD3DBaseTexture, (void **)&texture)))
339 texture->baseTexture.texture_rgb.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
340 texture->baseTexture.texture_rgb.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
341 texture->baseTexture.texture_rgb.states[WINED3DTEXSTA_MIPFILTER] = WINED3DTEXF_NONE;
342 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)texture);
346 HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
347 UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
348 UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
349 WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
351 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
352 const struct wined3d_format_desc *format_desc = getFormatDescEntry(format, gl_info);
353 void (*cleanup)(IWineD3DSurfaceImpl *This);
354 unsigned int resource_size;
357 if (multisample_quality > 0)
359 FIXME("multisample_quality set to %u, substituting 0\n", multisample_quality);
360 multisample_quality = 0;
363 /* FIXME: Check that the format is supported by the device. */
365 resource_size = surface_calculate_size(format_desc, alignment, width, height);
367 /* Look at the implementation and set the correct Vtable. */
368 switch (surface_type)
371 surface->lpVtbl = &IWineD3DSurface_Vtbl;
372 cleanup = surface_cleanup;
376 surface->lpVtbl = &IWineGDISurface_Vtbl;
377 cleanup = surface_gdi_cleanup;
381 ERR("Requested unknown surface implementation %#x.\n", surface_type);
382 return WINED3DERR_INVALIDCALL;
385 hr = resource_init((IWineD3DResource *)surface, WINED3DRTYPE_SURFACE,
386 device, resource_size, usage, format_desc, pool, parent, parent_ops);
389 WARN("Failed to initialize resource, returning %#x.\n", hr);
393 /* "Standalone" surface. */
394 IWineD3DSurface_SetContainer((IWineD3DSurface *)surface, NULL);
396 surface->currentDesc.Width = width;
397 surface->currentDesc.Height = height;
398 surface->currentDesc.MultiSampleType = multisample_type;
399 surface->currentDesc.MultiSampleQuality = multisample_quality;
400 surface->texture_level = level;
401 list_init(&surface->overlays);
404 surface->Flags = SFLAG_NORMCOORD; /* Default to normalized coords. */
405 if (discard) surface->Flags |= SFLAG_DISCARD;
406 if (lockable || format == WINED3DFMT_D16_LOCKABLE) surface->Flags |= SFLAG_LOCKABLE;
408 /* Quick lockable sanity check.
409 * TODO: remove this after surfaces, usage and lockability have been debugged properly
410 * this function is too deep to need to care about things like this.
411 * Levels need to be checked too, since they all affect what can be done. */
414 case WINED3DPOOL_SCRATCH:
417 FIXME("Called with a pool of SCRATCH and a lockable of FALSE "
418 "which are mutually exclusive, setting lockable to TRUE.\n");
423 case WINED3DPOOL_SYSTEMMEM:
425 FIXME("Called with a pool of SYSTEMMEM and a lockable of FALSE, this is acceptable but unexpected.\n");
428 case WINED3DPOOL_MANAGED:
429 if (usage & WINED3DUSAGE_DYNAMIC)
430 FIXME("Called with a pool of MANAGED and a usage of DYNAMIC which are mutually exclusive.\n");
433 case WINED3DPOOL_DEFAULT:
434 if (lockable && !(usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL)))
435 WARN("Creating a lockable surface with a POOL of DEFAULT, that doesn't specify DYNAMIC usage.\n");
439 FIXME("Unknown pool %#x.\n", pool);
443 if (usage & WINED3DUSAGE_RENDERTARGET && pool != WINED3DPOOL_DEFAULT)
445 FIXME("Trying to create a render target that isn't in the default pool.\n");
448 /* Mark the texture as dirty so that it gets loaded first time around. */
449 surface_add_dirty_rect((IWineD3DSurface *)surface, NULL);
450 list_init(&surface->renderbuffers);
452 TRACE("surface %p, memory %p, size %u\n", surface, surface->resource.allocatedMemory, surface->resource.size);
454 /* Call the private setup routine */
455 hr = IWineD3DSurface_PrivateSetup((IWineD3DSurface *)surface);
458 ERR("Private setup failed, returning %#x\n", hr);
466 static void surface_force_reload(IWineD3DSurface *iface)
468 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
470 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
473 void surface_set_texture_name(IWineD3DSurface *iface, GLuint new_name, BOOL srgb)
475 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
481 name = &This->texture_name_srgb;
482 flag = SFLAG_INSRGBTEX;
486 name = &This->texture_name;
487 flag = SFLAG_INTEXTURE;
490 TRACE("(%p) : setting texture name %u\n", This, new_name);
492 if (!*name && new_name)
494 /* FIXME: We shouldn't need to remove SFLAG_INTEXTURE if the
495 * surface has no texture name yet. See if we can get rid of this. */
496 if (This->Flags & flag)
497 ERR("Surface has SFLAG_INTEXTURE set, but no texture name\n");
498 IWineD3DSurface_ModifyLocation(iface, flag, FALSE);
502 surface_force_reload(iface);
505 void surface_set_texture_target(IWineD3DSurface *iface, GLenum target)
507 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
509 TRACE("(%p) : setting target %#x\n", This, target);
511 if (This->texture_target != target)
513 if (target == GL_TEXTURE_RECTANGLE_ARB)
515 This->Flags &= ~SFLAG_NORMCOORD;
517 else if (This->texture_target == GL_TEXTURE_RECTANGLE_ARB)
519 This->Flags |= SFLAG_NORMCOORD;
522 This->texture_target = target;
523 surface_force_reload(iface);
526 /* Context activation is done by the caller. */
527 static void surface_bind_and_dirtify(IWineD3DSurfaceImpl *This, BOOL srgb) {
528 DWORD active_sampler;
530 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
531 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
532 * gl states. The current texture unit should always be a valid one.
534 * To be more specific, this is tricky because we can implicitly be called
535 * from sampler() in state.c. This means we can't touch anything other than
536 * whatever happens to be the currently active texture, or we would risk
537 * marking already applied sampler states dirty again.
539 * TODO: Track the current active texture per GL context instead of using glGet
541 GLint active_texture;
543 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
545 active_sampler = This->resource.device->rev_tex_unit_map[active_texture - GL_TEXTURE0_ARB];
547 if (active_sampler != WINED3D_UNMAPPED_STAGE)
549 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_SAMPLER(active_sampler));
551 IWineD3DSurface_BindTexture((IWineD3DSurface *)This, srgb);
554 /* This function checks if the primary render target uses the 8bit paletted format. */
555 static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
557 if (device->render_targets && device->render_targets[0]) {
558 IWineD3DSurfaceImpl* render_target = (IWineD3DSurfaceImpl*)device->render_targets[0];
559 if ((render_target->resource.usage & WINED3DUSAGE_RENDERTARGET)
560 && (render_target->resource.format_desc->format == WINED3DFMT_P8_UINT))
566 /* This call just downloads data, the caller is responsible for binding the
567 * correct texture. */
568 /* Context activation is done by the caller. */
569 static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info)
571 const struct wined3d_format_desc *format_desc = This->resource.format_desc;
573 /* Only support read back of converted P8 surfaces */
574 if (This->Flags & SFLAG_CONVERTED && format_desc->format != WINED3DFMT_P8_UINT)
576 FIXME("Read back converted textures unsupported, format=%s\n", debug_d3dformat(format_desc->format));
582 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
584 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p.\n",
585 This, This->texture_level, format_desc->glFormat, format_desc->glType,
586 This->resource.allocatedMemory);
588 if (This->Flags & SFLAG_PBO)
590 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
591 checkGLcall("glBindBufferARB");
592 GL_EXTCALL(glGetCompressedTexImageARB(This->texture_target, This->texture_level, NULL));
593 checkGLcall("glGetCompressedTexImageARB");
594 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
595 checkGLcall("glBindBufferARB");
599 GL_EXTCALL(glGetCompressedTexImageARB(This->texture_target,
600 This->texture_level, This->resource.allocatedMemory));
601 checkGLcall("glGetCompressedTexImageARB");
607 GLenum format = format_desc->glFormat;
608 GLenum type = format_desc->glType;
612 /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
613 if (format_desc->format == WINED3DFMT_P8_UINT && primary_render_target_is_p8(This->resource.device))
616 type = GL_UNSIGNED_BYTE;
619 if (This->Flags & SFLAG_NONPOW2) {
620 unsigned char alignment = This->resource.device->surface_alignment;
621 src_pitch = format_desc->byte_count * This->pow2Width;
622 dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
623 src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
624 mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
626 mem = This->resource.allocatedMemory;
629 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n",
630 This, This->texture_level, format, type, mem);
632 if(This->Flags & SFLAG_PBO) {
633 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
634 checkGLcall("glBindBufferARB");
636 glGetTexImage(This->texture_target, This->texture_level, format, type, NULL);
637 checkGLcall("glGetTexImage");
639 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
640 checkGLcall("glBindBufferARB");
642 glGetTexImage(This->texture_target, This->texture_level, format, type, mem);
643 checkGLcall("glGetTexImage");
647 if (This->Flags & SFLAG_NONPOW2) {
648 const BYTE *src_data;
652 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
653 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
654 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
656 * We're doing this...
658 * instead of boxing the texture :
659 * |<-texture width ->| -->pow2width| /\
660 * |111111111111111111| | |
661 * |222 Texture 222222| boxed empty | texture height
662 * |3333 Data 33333333| | |
663 * |444444444444444444| | \/
664 * ----------------------------------- |
665 * | boxed empty | boxed empty | pow2height
667 * -----------------------------------
670 * we're repacking the data to the expected texture width
672 * |<-texture width ->| -->pow2width| /\
673 * |111111111111111111222222222222222| |
674 * |222333333333333333333444444444444| texture height
678 * | empty | pow2height
680 * -----------------------------------
684 * |<-texture width ->| /\
685 * |111111111111111111|
686 * |222222222222222222|texture height
687 * |333333333333333333|
688 * |444444444444444444| \/
689 * --------------------
691 * this also means that any references to allocatedMemory should work with the data as if were a
692 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
694 * internally the texture is still stored in a boxed format so any references to textureName will
695 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
697 * Performance should not be an issue, because applications normally do not lock the surfaces when
698 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
699 * and doesn't have to be re-read.
702 dst_data = This->resource.allocatedMemory;
703 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This, src_pitch, dst_pitch);
704 for (y = 1 ; y < This->currentDesc.Height; y++) {
705 /* skip the first row */
706 src_data += src_pitch;
707 dst_data += dst_pitch;
708 memcpy(dst_data, src_data, dst_pitch);
711 HeapFree(GetProcessHeap(), 0, mem);
715 /* Surface has now been downloaded */
716 This->Flags |= SFLAG_INSYSMEM;
719 /* This call just uploads data, the caller is responsible for binding the
720 * correct texture. */
721 /* Context activation is done by the caller. */
722 static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
723 const struct wined3d_format_desc *format_desc, BOOL srgb, GLsizei width, GLsizei height, const GLvoid *data)
729 internal = format_desc->glGammaInternal;
731 else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET
732 && surface_is_offscreen((IWineD3DSurface *)This))
734 internal = format_desc->rtInternal;
738 internal = format_desc->glInternal;
741 TRACE("This %p, internal %#x, width %d, height %d, format %#x, type %#x, data %p.\n",
742 This, internal, width, height, format_desc->glFormat, format_desc->glType, data);
743 TRACE("target %#x, level %u, resource size %u.\n",
744 This->texture_target, This->texture_level, This->resource.size);
746 if (format_desc->heightscale != 1.0f && format_desc->heightscale != 0.0f) height *= format_desc->heightscale;
750 if (This->Flags & SFLAG_PBO)
752 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
753 checkGLcall("glBindBufferARB");
755 TRACE("(%p) pbo: %#x, data: %p.\n", This, This->pbo, data);
759 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
761 TRACE("Calling glCompressedTexSubImage2DARB.\n");
763 GL_EXTCALL(glCompressedTexSubImage2DARB(This->texture_target, This->texture_level,
764 0, 0, width, height, internal, This->resource.size, data));
765 checkGLcall("glCompressedTexSubImage2DARB");
769 TRACE("Calling glTexSubImage2D.\n");
771 glTexSubImage2D(This->texture_target, This->texture_level,
772 0, 0, width, height, format_desc->glFormat, format_desc->glType, data);
773 checkGLcall("glTexSubImage2D");
776 if (This->Flags & SFLAG_PBO)
778 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
779 checkGLcall("glBindBufferARB");
784 if (gl_info->quirks & WINED3D_QUIRK_FBO_TEX_UPDATE)
786 IWineD3DDeviceImpl *device = This->resource.device;
789 for (i = 0; i < device->numContexts; ++i)
791 context_surface_update(device->contexts[i], This);
796 /* This call just allocates the texture, the caller is responsible for binding
797 * the correct texture. */
798 /* Context activation is done by the caller. */
799 static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
800 const struct wined3d_format_desc *format_desc, BOOL srgb, GLsizei width, GLsizei height)
802 BOOL enable_client_storage = FALSE;
803 const BYTE *mem = NULL;
808 internal = format_desc->glGammaInternal;
810 else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET
811 && surface_is_offscreen((IWineD3DSurface *)This))
813 internal = format_desc->rtInternal;
817 internal = format_desc->glInternal;
820 if (format_desc->heightscale != 1.0f && format_desc->heightscale != 0.0f) height *= format_desc->heightscale;
822 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",
823 This, This->texture_target, This->texture_level, debug_d3dformat(format_desc->format),
824 internal, width, height, format_desc->glFormat, format_desc->glType);
828 if (gl_info->supported[APPLE_CLIENT_STORAGE])
830 if(This->Flags & (SFLAG_NONPOW2 | SFLAG_DIBSECTION | SFLAG_CONVERTED) || This->resource.allocatedMemory == NULL) {
831 /* In some cases we want to disable client storage.
832 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
833 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
834 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
835 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
837 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
838 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
839 This->Flags &= ~SFLAG_CLIENT;
840 enable_client_storage = TRUE;
842 This->Flags |= SFLAG_CLIENT;
844 /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
845 * it might point into a pbo. Instead use heapMemory, but get the alignment right.
847 mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
851 if (format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED && mem)
853 GL_EXTCALL(glCompressedTexImage2DARB(This->texture_target, This->texture_level,
854 internal, width, height, 0, This->resource.size, mem));
858 glTexImage2D(This->texture_target, This->texture_level,
859 internal, width, height, 0, format_desc->glFormat, format_desc->glType, mem);
860 checkGLcall("glTexImage2D");
863 if(enable_client_storage) {
864 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
865 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
870 /* In D3D the depth stencil dimensions have to be greater than or equal to the
871 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
872 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
873 /* GL locking is done by the caller */
874 void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height) {
875 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
876 const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
877 renderbuffer_entry_t *entry;
878 GLuint renderbuffer = 0;
879 unsigned int src_width, src_height;
881 src_width = This->pow2Width;
882 src_height = This->pow2Height;
884 /* A depth stencil smaller than the render target is not valid */
885 if (width > src_width || height > src_height) return;
887 /* Remove any renderbuffer set if the sizes match */
888 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
889 || (width == src_width && height == src_height))
891 This->current_renderbuffer = NULL;
895 /* Look if we've already got a renderbuffer of the correct dimensions */
896 LIST_FOR_EACH_ENTRY(entry, &This->renderbuffers, renderbuffer_entry_t, entry) {
897 if (entry->width == width && entry->height == height) {
898 renderbuffer = entry->id;
899 This->current_renderbuffer = entry;
905 gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer);
906 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
907 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
908 This->resource.format_desc->glInternal, width, height);
910 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
911 entry->width = width;
912 entry->height = height;
913 entry->id = renderbuffer;
914 list_add_head(&This->renderbuffers, &entry->entry);
916 This->current_renderbuffer = entry;
919 checkGLcall("set_compatible_renderbuffer");
922 GLenum surface_get_gl_buffer(IWineD3DSurface *iface)
924 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
925 IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *)This->container;
927 TRACE("iface %p.\n", iface);
929 if (!(This->Flags & SFLAG_SWAPCHAIN))
931 ERR("Surface %p is not on a swapchain.\n", iface);
935 if (swapchain->backBuffer && swapchain->backBuffer[0] == iface)
937 if (swapchain->render_to_fbo)
939 TRACE("Returning GL_COLOR_ATTACHMENT0\n");
940 return GL_COLOR_ATTACHMENT0;
942 TRACE("Returning GL_BACK\n");
945 else if (swapchain->frontBuffer == iface)
947 TRACE("Returning GL_FRONT\n");
951 FIXME("Higher back buffer, returning GL_BACK\n");
955 /* Slightly inefficient way to handle multiple dirty rects but it works :) */
956 void surface_add_dirty_rect(IWineD3DSurface *iface, const RECT *dirty_rect)
958 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
959 IWineD3DBaseTexture *baseTexture = NULL;
961 if (!(This->Flags & SFLAG_INSYSMEM) && (This->Flags & SFLAG_INTEXTURE))
962 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL /* no partial locking for textures yet */);
964 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
967 This->dirtyRect.left = min(This->dirtyRect.left, dirty_rect->left);
968 This->dirtyRect.top = min(This->dirtyRect.top, dirty_rect->top);
969 This->dirtyRect.right = max(This->dirtyRect.right, dirty_rect->right);
970 This->dirtyRect.bottom = max(This->dirtyRect.bottom, dirty_rect->bottom);
974 This->dirtyRect.left = 0;
975 This->dirtyRect.top = 0;
976 This->dirtyRect.right = This->currentDesc.Width;
977 This->dirtyRect.bottom = This->currentDesc.Height;
980 TRACE("(%p) : Dirty: yes, Rect:(%d, %d, %d, %d)\n", This, This->dirtyRect.left,
981 This->dirtyRect.top, This->dirtyRect.right, This->dirtyRect.bottom);
983 /* if the container is a basetexture then mark it dirty. */
984 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture)))
986 TRACE("Passing to container\n");
987 IWineD3DBaseTexture_SetDirty(baseTexture, TRUE);
988 IWineD3DBaseTexture_Release(baseTexture);
992 static BOOL surface_convert_color_to_argb(IWineD3DSurfaceImpl *This, DWORD color, DWORD *argb_color)
994 IWineD3DDeviceImpl *device = This->resource.device;
996 switch(This->resource.format_desc->format)
998 case WINED3DFMT_P8_UINT:
1002 if (primary_render_target_is_p8(device))
1003 alpha = color << 24;
1007 if (This->palette) {
1008 *argb_color = (alpha |
1009 (This->palette->palents[color].peRed << 16) |
1010 (This->palette->palents[color].peGreen << 8) |
1011 (This->palette->palents[color].peBlue));
1013 *argb_color = alpha;
1018 case WINED3DFMT_B5G6R5_UNORM:
1020 if (color == 0xFFFF) {
1021 *argb_color = 0xFFFFFFFF;
1023 *argb_color = ((0xFF000000) |
1024 ((color & 0xF800) << 8) |
1025 ((color & 0x07E0) << 5) |
1026 ((color & 0x001F) << 3));
1031 case WINED3DFMT_B8G8R8_UNORM:
1032 case WINED3DFMT_B8G8R8X8_UNORM:
1033 *argb_color = 0xFF000000 | color;
1036 case WINED3DFMT_B8G8R8A8_UNORM:
1037 *argb_color = color;
1041 ERR("Unhandled conversion from %s to ARGB!\n", debug_d3dformat(This->resource.format_desc->format));
1047 static ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface)
1049 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1050 ULONG ref = InterlockedDecrement(&This->resource.ref);
1051 TRACE("(%p) : Releasing from %d\n", This, ref + 1);
1055 surface_cleanup(This);
1056 This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
1058 TRACE("(%p) Released.\n", This);
1059 HeapFree(GetProcessHeap(), 0, This);
1065 /* ****************************************************
1066 IWineD3DSurface IWineD3DResource parts follow
1067 **************************************************** */
1069 void surface_internal_preload(IWineD3DSurface *iface, enum WINED3DSRGB srgb)
1071 /* TODO: check for locks */
1072 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1073 IWineD3DDeviceImpl *device = This->resource.device;
1074 IWineD3DBaseTexture *baseTexture = NULL;
1076 TRACE("(%p)Checking to see if the container is a base texture\n", This);
1077 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
1078 IWineD3DBaseTextureImpl *tex_impl = (IWineD3DBaseTextureImpl *) baseTexture;
1079 TRACE("Passing to container\n");
1080 tex_impl->baseTexture.internal_preload(baseTexture, srgb);
1081 IWineD3DBaseTexture_Release(baseTexture);
1083 struct wined3d_context *context = NULL;
1085 TRACE("(%p) : About to load surface\n", This);
1087 if (!device->isInDraw) context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
1089 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
1090 || This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
1092 if(palette9_changed(This)) {
1093 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
1094 /* TODO: This is not necessarily needed with hw palettized texture support */
1095 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
1096 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
1097 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
1101 IWineD3DSurface_LoadTexture(iface, srgb == SRGB_SRGB ? TRUE : FALSE);
1103 if (This->resource.pool == WINED3DPOOL_DEFAULT) {
1104 /* Tell opengl to try and keep this texture in video ram (well mostly) */
1108 glPrioritizeTextures(1, &This->texture_name, &tmp);
1112 if (context) context_release(context);
1116 static void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface) {
1117 surface_internal_preload(iface, SRGB_ANY);
1120 /* Context activation is done by the caller. */
1121 static void surface_remove_pbo(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info)
1123 This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
1124 This->resource.allocatedMemory =
1125 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1128 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1129 checkGLcall("glBindBufferARB(GL_PIXEL_UNPACK_BUFFER, This->pbo)");
1130 GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0, This->resource.size, This->resource.allocatedMemory));
1131 checkGLcall("glGetBufferSubDataARB");
1132 GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
1133 checkGLcall("glDeleteBuffersARB");
1137 This->Flags &= ~SFLAG_PBO;
1140 BOOL surface_init_sysmem(IWineD3DSurface *iface)
1142 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
1144 if(!This->resource.allocatedMemory)
1146 This->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + RESOURCE_ALIGNMENT);
1147 if(!This->resource.heapMemory)
1149 ERR("Out of memory\n");
1152 This->resource.allocatedMemory =
1153 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1157 memset(This->resource.allocatedMemory, 0, This->resource.size);
1160 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
1164 static void WINAPI IWineD3DSurfaceImpl_UnLoad(IWineD3DSurface *iface) {
1165 IWineD3DBaseTexture *texture = NULL;
1166 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
1167 IWineD3DDeviceImpl *device = This->resource.device;
1168 const struct wined3d_gl_info *gl_info;
1169 renderbuffer_entry_t *entry, *entry2;
1170 struct wined3d_context *context;
1172 TRACE("(%p)\n", iface);
1174 if(This->resource.pool == WINED3DPOOL_DEFAULT) {
1175 /* Default pool resources are supposed to be destroyed before Reset is called.
1176 * Implicit resources stay however. So this means we have an implicit render target
1177 * or depth stencil. The content may be destroyed, but we still have to tear down
1178 * opengl resources, so we cannot leave early.
1180 * Put the surfaces into sysmem, and reset the content. The D3D content is undefined,
1181 * but we can't set the sysmem INDRAWABLE because when we're rendering the swapchain
1182 * or the depth stencil into an FBO the texture or render buffer will be removed
1183 * and all flags get lost
1185 surface_init_sysmem(iface);
1187 /* Load the surface into system memory */
1188 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
1189 IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
1191 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
1192 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSRGBTEX, FALSE);
1193 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
1195 context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
1196 gl_info = context->gl_info;
1198 /* Destroy PBOs, but load them into real sysmem before */
1199 if (This->Flags & SFLAG_PBO)
1200 surface_remove_pbo(This, gl_info);
1202 /* Destroy fbo render buffers. This is needed for implicit render targets, for
1203 * all application-created targets the application has to release the surface
1204 * before calling _Reset
1206 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry) {
1208 gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
1210 list_remove(&entry->entry);
1211 HeapFree(GetProcessHeap(), 0, entry);
1213 list_init(&This->renderbuffers);
1214 This->current_renderbuffer = NULL;
1216 /* If we're in a texture, the texture name belongs to the texture. Otherwise,
1219 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **) &texture);
1222 glDeleteTextures(1, &This->texture_name);
1223 This->texture_name = 0;
1224 glDeleteTextures(1, &This->texture_name_srgb);
1225 This->texture_name_srgb = 0;
1228 IWineD3DBaseTexture_Release(texture);
1231 context_release(context);
1234 /* ******************************************************
1235 IWineD3DSurface IWineD3DSurface parts follow
1236 ****************************************************** */
1238 /* Read the framebuffer back into the surface */
1239 static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, void *dest, UINT pitch)
1241 IWineD3DDeviceImpl *myDevice = This->resource.device;
1242 const struct wined3d_gl_info *gl_info;
1243 struct wined3d_context *context;
1247 BYTE *row, *top, *bottom;
1251 BOOL srcIsUpsideDown;
1256 if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1257 static BOOL warned = FALSE;
1259 ERR("The application tries to lock the render target, but render target locking is disabled\n");
1265 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
1266 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
1267 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
1268 * context->last_was_blit set on the unlock.
1270 context = context_acquire(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
1271 gl_info = context->gl_info;
1275 /* Select the correct read buffer, and give some debug output.
1276 * There is no need to keep track of the current read buffer or reset it, every part of the code
1277 * that reads sets the read buffer as desired.
1279 if (surface_is_offscreen((IWineD3DSurface *) This))
1281 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
1282 * Read from the back buffer
1284 TRACE("Locking offscreen render target\n");
1285 glReadBuffer(myDevice->offscreenBuffer);
1286 srcIsUpsideDown = TRUE;
1290 /* Onscreen surfaces are always part of a swapchain */
1291 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *)This);
1292 TRACE("Locking %#x buffer\n", buffer);
1293 glReadBuffer(buffer);
1294 checkGLcall("glReadBuffer");
1295 srcIsUpsideDown = FALSE;
1298 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
1300 local_rect.left = 0;
1302 local_rect.right = This->currentDesc.Width;
1303 local_rect.bottom = This->currentDesc.Height;
1307 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
1309 switch(This->resource.format_desc->format)
1311 case WINED3DFMT_P8_UINT:
1313 if(primary_render_target_is_p8(myDevice)) {
1314 /* In case of P8 render targets the index is stored in the alpha component */
1316 type = GL_UNSIGNED_BYTE;
1318 bpp = This->resource.format_desc->byte_count;
1320 /* GL can't return palettized data, so read ARGB pixels into a
1321 * separate block of memory and convert them into palettized format
1322 * in software. Slow, but if the app means to use palettized render
1323 * targets and locks it...
1325 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
1326 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
1327 * for the color channels when palettizing the colors.
1330 type = GL_UNSIGNED_BYTE;
1332 mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * 3);
1334 ERR("Out of memory\n");
1338 bpp = This->resource.format_desc->byte_count * 3;
1345 fmt = This->resource.format_desc->glFormat;
1346 type = This->resource.format_desc->glType;
1347 bpp = This->resource.format_desc->byte_count;
1350 if(This->Flags & SFLAG_PBO) {
1351 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
1352 checkGLcall("glBindBufferARB");
1354 ERR("mem not null for pbo -- unexpected\n");
1359 /* Save old pixel store pack state */
1360 glGetIntegerv(GL_PACK_ROW_LENGTH, &rowLen);
1361 checkGLcall("glGetIntegerv");
1362 glGetIntegerv(GL_PACK_SKIP_PIXELS, &skipPix);
1363 checkGLcall("glGetIntegerv");
1364 glGetIntegerv(GL_PACK_SKIP_ROWS, &skipRow);
1365 checkGLcall("glGetIntegerv");
1367 /* Setup pixel store pack state -- to glReadPixels into the correct place */
1368 glPixelStorei(GL_PACK_ROW_LENGTH, This->currentDesc.Width);
1369 checkGLcall("glPixelStorei");
1370 glPixelStorei(GL_PACK_SKIP_PIXELS, local_rect.left);
1371 checkGLcall("glPixelStorei");
1372 glPixelStorei(GL_PACK_SKIP_ROWS, local_rect.top);
1373 checkGLcall("glPixelStorei");
1375 glReadPixels(local_rect.left, (!srcIsUpsideDown) ? (This->currentDesc.Height - local_rect.bottom) : local_rect.top ,
1376 local_rect.right - local_rect.left,
1377 local_rect.bottom - local_rect.top,
1379 checkGLcall("glReadPixels");
1381 /* Reset previous pixel store pack state */
1382 glPixelStorei(GL_PACK_ROW_LENGTH, rowLen);
1383 checkGLcall("glPixelStorei");
1384 glPixelStorei(GL_PACK_SKIP_PIXELS, skipPix);
1385 checkGLcall("glPixelStorei");
1386 glPixelStorei(GL_PACK_SKIP_ROWS, skipRow);
1387 checkGLcall("glPixelStorei");
1389 if(This->Flags & SFLAG_PBO) {
1390 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
1391 checkGLcall("glBindBufferARB");
1393 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
1394 * to get a pointer to it and perform the flipping in software. This is a lot
1395 * faster than calling glReadPixels for each line. In case we want more speed
1396 * we should rerender it flipped in a FBO and read the data back from the FBO. */
1397 if(!srcIsUpsideDown) {
1398 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1399 checkGLcall("glBindBufferARB");
1401 mem = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1402 checkGLcall("glMapBufferARB");
1406 /* TODO: Merge this with the palettization loop below for P8 targets */
1407 if(!srcIsUpsideDown) {
1409 /* glReadPixels returns the image upside down, and there is no way to prevent this.
1410 Flip the lines in software */
1411 len = (local_rect.right - local_rect.left) * bpp;
1412 off = local_rect.left * bpp;
1414 row = HeapAlloc(GetProcessHeap(), 0, len);
1416 ERR("Out of memory\n");
1417 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT) HeapFree(GetProcessHeap(), 0, mem);
1422 top = mem + pitch * local_rect.top;
1423 bottom = mem + pitch * (local_rect.bottom - 1);
1424 for(i = 0; i < (local_rect.bottom - local_rect.top) / 2; i++) {
1425 memcpy(row, top + off, len);
1426 memcpy(top + off, bottom + off, len);
1427 memcpy(bottom + off, row, len);
1431 HeapFree(GetProcessHeap(), 0, row);
1433 /* Unmap the temp PBO buffer */
1434 if(This->Flags & SFLAG_PBO) {
1435 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1436 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1441 context_release(context);
1443 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
1444 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
1445 * the same color but we have no choice.
1446 * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
1448 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT && !primary_render_target_is_p8(myDevice))
1450 const PALETTEENTRY *pal = NULL;
1451 DWORD width = pitch / 3;
1455 pal = This->palette->palents;
1457 ERR("Palette is missing, cannot perform inverse palette lookup\n");
1458 HeapFree(GetProcessHeap(), 0, mem);
1462 for(y = local_rect.top; y < local_rect.bottom; y++) {
1463 for(x = local_rect.left; x < local_rect.right; x++) {
1464 /* start lines pixels */
1465 const BYTE *blue = mem + y * pitch + x * (sizeof(BYTE) * 3);
1466 const BYTE *green = blue + 1;
1467 const BYTE *red = green + 1;
1469 for(c = 0; c < 256; c++) {
1470 if(*red == pal[c].peRed &&
1471 *green == pal[c].peGreen &&
1472 *blue == pal[c].peBlue)
1474 *((BYTE *) dest + y * width + x) = c;
1480 HeapFree(GetProcessHeap(), 0, mem);
1484 /* Read the framebuffer contents into a texture */
1485 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl *This, BOOL srgb)
1487 IWineD3DDeviceImpl *device = This->resource.device;
1488 const struct wined3d_gl_info *gl_info;
1489 struct wined3d_context *context;
1491 BOOL alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
1493 /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
1494 * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
1495 * states in the stateblock, and no driver was found yet that had bugs in that regard.
1497 context = context_acquire(device, (IWineD3DSurface *) This, CTXUSAGE_RESOURCELOAD);
1498 gl_info = context->gl_info;
1500 surface_bind_and_dirtify(This, srgb);
1503 glGetIntegerv(GL_READ_BUFFER, &prevRead);
1506 /* Select the correct read buffer, and give some debug output.
1507 * There is no need to keep track of the current read buffer or reset it, every part of the code
1508 * that reads sets the read buffer as desired.
1510 if (!surface_is_offscreen((IWineD3DSurface *)This))
1512 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *)This);
1513 TRACE("Locking %#x buffer\n", buffer);
1516 glReadBuffer(buffer);
1517 checkGLcall("glReadBuffer");
1522 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
1523 * Read from the back buffer
1525 TRACE("Locking offscreen render target\n");
1527 glReadBuffer(device->offscreenBuffer);
1528 checkGLcall("glReadBuffer");
1532 if (!(This->Flags & alloc_flag))
1534 surface_allocate_surface(This, gl_info, This->resource.format_desc, srgb, This->pow2Width, This->pow2Height);
1535 This->Flags |= alloc_flag;
1539 /* If !SrcIsUpsideDown we should flip the surface.
1540 * This can be done using glCopyTexSubImage2D but this
1541 * is VERY slow, so don't do that. We should prevent
1542 * this code from getting called in such cases or perhaps
1543 * we can use FBOs */
1545 glCopyTexSubImage2D(This->texture_target, This->texture_level,
1546 0, 0, 0, 0, This->currentDesc.Width, This->currentDesc.Height);
1547 checkGLcall("glCopyTexSubImage2D");
1549 glReadBuffer(prevRead);
1550 checkGLcall("glReadBuffer");
1554 context_release(context);
1556 TRACE("Updated target %d\n", This->texture_target);
1559 /* Context activation is done by the caller. */
1560 void surface_prepare_texture(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info, BOOL srgb)
1562 DWORD alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
1563 CONVERT_TYPES convert;
1564 struct wined3d_format_desc desc;
1566 if (surface->Flags & alloc_flag) return;
1568 d3dfmt_get_conv(surface, TRUE, TRUE, &desc, &convert);
1569 if(convert != NO_CONVERSION) surface->Flags |= SFLAG_CONVERTED;
1570 else surface->Flags &= ~SFLAG_CONVERTED;
1572 surface_bind_and_dirtify(surface, srgb);
1573 surface_allocate_surface(surface, gl_info, &desc, srgb,
1574 surface->pow2Width, surface->pow2Height);
1575 surface->Flags |= alloc_flag;
1578 static void surface_prepare_system_memory(IWineD3DSurfaceImpl *This)
1580 IWineD3DDeviceImpl *device = This->resource.device;
1581 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1583 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
1584 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
1587 if(!(This->Flags & SFLAG_DYNLOCK)) {
1589 /* MAXLOCKCOUNT is defined in wined3d_private.h */
1590 if(This->lockCount > MAXLOCKCOUNT) {
1591 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
1592 This->Flags |= SFLAG_DYNLOCK;
1596 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
1597 * Also don't create a PBO for systemmem surfaces.
1599 if (gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] && (This->Flags & SFLAG_DYNLOCK)
1600 && !(This->Flags & (SFLAG_PBO | SFLAG_CONVERTED | SFLAG_NONPOW2))
1601 && (This->resource.pool != WINED3DPOOL_SYSTEMMEM))
1604 struct wined3d_context *context;
1606 context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
1609 GL_EXTCALL(glGenBuffersARB(1, &This->pbo));
1610 error = glGetError();
1611 if(This->pbo == 0 || error != GL_NO_ERROR) {
1612 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error), error);
1615 TRACE("Attaching pbo=%#x to (%p)\n", This->pbo, This);
1617 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1618 checkGLcall("glBindBufferARB");
1620 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->resource.size + 4, This->resource.allocatedMemory, GL_STREAM_DRAW_ARB));
1621 checkGLcall("glBufferDataARB");
1623 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1624 checkGLcall("glBindBufferARB");
1626 /* We don't need the system memory anymore and we can't even use it for PBOs */
1627 if(!(This->Flags & SFLAG_CLIENT)) {
1628 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
1629 This->resource.heapMemory = NULL;
1631 This->resource.allocatedMemory = NULL;
1632 This->Flags |= SFLAG_PBO;
1634 context_release(context);
1636 else if (!(This->resource.allocatedMemory || This->Flags & SFLAG_PBO))
1638 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
1641 if(!This->resource.heapMemory) {
1642 This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
1644 This->resource.allocatedMemory =
1645 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1646 if(This->Flags & SFLAG_INSYSMEM) {
1647 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1652 static HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
1653 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1654 IWineD3DDeviceImpl *myDevice = This->resource.device;
1655 const RECT *pass_rect = pRect;
1657 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This, pRect, Flags, pLockedRect, This->resource.allocatedMemory);
1659 /* This is also done in the base class, but we have to verify this before loading any data from
1660 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1661 * may interfere, and all other bad things may happen
1663 if (This->Flags & SFLAG_LOCKED) {
1664 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1665 return WINED3DERR_INVALIDCALL;
1667 This->Flags |= SFLAG_LOCKED;
1669 if (!(This->Flags & SFLAG_LOCKABLE))
1671 TRACE("Warning: trying to lock unlockable surf@%p\n", This);
1674 if (Flags & WINED3DLOCK_DISCARD) {
1675 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
1676 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
1677 surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1678 This->Flags |= SFLAG_INSYSMEM;
1682 if (This->Flags & SFLAG_INSYSMEM) {
1683 TRACE("Local copy is up to date, not downloading data\n");
1684 surface_prepare_system_memory(This); /* Makes sure memory is allocated */
1688 /* IWineD3DSurface_LoadLocation() does not check if the rectangle specifies
1689 * the full surface. Most callers don't need that, so do it here. */
1690 if (pRect && pRect->top == 0 && pRect->left == 0
1691 && pRect->right == This->currentDesc.Width
1692 && pRect->bottom == This->currentDesc.Height)
1697 if (!(wined3d_settings.rendertargetlock_mode == RTL_DISABLE
1698 && ((This->Flags & SFLAG_SWAPCHAIN) || iface == myDevice->render_targets[0])))
1700 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, pass_rect);
1704 if (This->Flags & SFLAG_PBO)
1706 const struct wined3d_gl_info *gl_info;
1707 struct wined3d_context *context;
1709 context = context_acquire(myDevice, NULL, CTXUSAGE_RESOURCELOAD);
1710 gl_info = context->gl_info;
1713 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1714 checkGLcall("glBindBufferARB");
1716 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1717 if(This->resource.allocatedMemory) {
1718 ERR("The surface already has PBO memory allocated!\n");
1721 This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1722 checkGLcall("glMapBufferARB");
1724 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1725 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1726 checkGLcall("glBindBufferARB");
1729 context_release(context);
1732 if (Flags & (WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY)) {
1735 IWineD3DBaseTexture *pBaseTexture;
1738 * as seen in msdn docs
1740 surface_add_dirty_rect(iface, pRect);
1742 /** Dirtify Container if needed */
1743 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&pBaseTexture))) {
1744 TRACE("Making container dirty\n");
1745 IWineD3DBaseTexture_SetDirty(pBaseTexture, TRUE);
1746 IWineD3DBaseTexture_Release(pBaseTexture);
1748 TRACE("Surface is standalone, no need to dirty the container\n");
1752 return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
1755 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This, GLenum fmt, GLenum type, UINT bpp, const BYTE *mem) {
1757 GLint prev_rasterpos[4];
1758 GLint skipBytes = 0;
1759 UINT pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This); /* target is argb, 4 byte */
1760 IWineD3DDeviceImpl *myDevice = This->resource.device;
1761 const struct wined3d_gl_info *gl_info;
1762 struct wined3d_context *context;
1764 /* Activate the correct context for the render target */
1765 context = context_acquire(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
1766 gl_info = context->gl_info;
1770 if (!surface_is_offscreen((IWineD3DSurface *)This))
1772 GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *)This);
1773 TRACE("Unlocking %#x buffer.\n", buffer);
1774 context_set_draw_buffer(context, buffer);
1778 /* Primary offscreen render target */
1779 TRACE("Offscreen render target.\n");
1780 context_set_draw_buffer(context, myDevice->offscreenBuffer);
1783 glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
1784 checkGLcall("glGetIntegerv");
1785 glGetIntegerv(GL_CURRENT_RASTER_POSITION, &prev_rasterpos[0]);
1786 checkGLcall("glGetIntegerv");
1787 glPixelZoom(1.0f, -1.0f);
1788 checkGLcall("glPixelZoom");
1790 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
1791 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &skipBytes);
1792 glPixelStorei(GL_UNPACK_ROW_LENGTH, This->currentDesc.Width);
1794 glRasterPos3i(This->lockedRect.left, This->lockedRect.top, 1);
1795 checkGLcall("glRasterPos3i");
1797 /* Some drivers(radeon dri, others?) don't like exceptions during
1798 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
1799 * after ReleaseDC. Reading it will cause an exception, which x11drv will
1800 * catch to put the dib section in InSync mode, which leads to a crash
1801 * and a blocked x server on my radeon card.
1803 * The following lines read the dib section so it is put in InSync mode
1804 * before glDrawPixels is called and the crash is prevented. There won't
1805 * be any interfering gdi accesses, because UnlockRect is called from
1806 * ReleaseDC, and the app won't use the dc any more afterwards.
1808 if((This->Flags & SFLAG_DIBSECTION) && !(This->Flags & SFLAG_PBO)) {
1810 read = This->resource.allocatedMemory[0];
1813 if(This->Flags & SFLAG_PBO) {
1814 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1815 checkGLcall("glBindBufferARB");
1818 /* When the surface is locked we only have to refresh the locked part else we need to update the whole image */
1819 if(This->Flags & SFLAG_LOCKED) {
1820 glDrawPixels(This->lockedRect.right - This->lockedRect.left,
1821 (This->lockedRect.bottom - This->lockedRect.top)-1,
1823 mem + bpp * This->lockedRect.left + pitch * This->lockedRect.top);
1824 checkGLcall("glDrawPixels");
1826 glDrawPixels(This->currentDesc.Width,
1827 This->currentDesc.Height,
1829 checkGLcall("glDrawPixels");
1832 if(This->Flags & SFLAG_PBO) {
1833 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1834 checkGLcall("glBindBufferARB");
1837 glPixelZoom(1.0f, 1.0f);
1838 checkGLcall("glPixelZoom");
1840 glRasterPos3iv(&prev_rasterpos[0]);
1841 checkGLcall("glRasterPos3iv");
1843 /* Reset to previous pack row length */
1844 glPixelStorei(GL_UNPACK_ROW_LENGTH, skipBytes);
1845 checkGLcall("glPixelStorei(GL_UNPACK_ROW_LENGTH)");
1848 context_release(context);
1851 static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) {
1852 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1853 IWineD3DDeviceImpl *myDevice = This->resource.device;
1856 if (!(This->Flags & SFLAG_LOCKED)) {
1857 WARN("trying to Unlock an unlocked surf@%p\n", This);
1858 return WINEDDERR_NOTLOCKED;
1861 if (This->Flags & SFLAG_PBO)
1863 const struct wined3d_gl_info *gl_info;
1864 struct wined3d_context *context;
1866 TRACE("Freeing PBO memory\n");
1868 context = context_acquire(myDevice, NULL, CTXUSAGE_RESOURCELOAD);
1869 gl_info = context->gl_info;
1872 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1873 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1874 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1875 checkGLcall("glUnmapBufferARB");
1877 context_release(context);
1879 This->resource.allocatedMemory = NULL;
1882 TRACE("(%p) : dirtyfied(%d)\n", This, This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
1884 if (This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE)) {
1885 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This);
1889 if ((This->Flags & SFLAG_SWAPCHAIN) || (myDevice->render_targets && iface == myDevice->render_targets[0]))
1891 if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1892 static BOOL warned = FALSE;
1894 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1900 if(This->dirtyRect.left == 0 &&
1901 This->dirtyRect.top == 0 &&
1902 This->dirtyRect.right == This->currentDesc.Width &&
1903 This->dirtyRect.bottom == This->currentDesc.Height) {
1906 /* TODO: Proper partial rectangle tracking */
1907 fullsurface = FALSE;
1908 This->Flags |= SFLAG_INSYSMEM;
1911 switch(wined3d_settings.rendertargetlock_mode) {
1913 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL /* partial texture loading not supported yet */);
1917 IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, fullsurface ? NULL : &This->dirtyRect);
1922 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1923 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1924 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1925 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1926 * not fully up to date because only a subrectangle was read in LockRect.
1928 This->Flags &= ~SFLAG_INSYSMEM;
1929 This->Flags |= SFLAG_INDRAWABLE;
1932 This->dirtyRect.left = This->currentDesc.Width;
1933 This->dirtyRect.top = This->currentDesc.Height;
1934 This->dirtyRect.right = 0;
1935 This->dirtyRect.bottom = 0;
1936 } else if(iface == myDevice->stencilBufferTarget) {
1937 FIXME("Depth Stencil buffer locking is not implemented\n");
1939 /* The rest should be a normal texture */
1940 IWineD3DBaseTextureImpl *impl;
1941 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1942 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1943 * states need resetting
1945 if(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&impl) == WINED3D_OK) {
1946 if(impl->baseTexture.bindCount) {
1947 IWineD3DDeviceImpl_MarkStateDirty(myDevice, STATE_SAMPLER(impl->baseTexture.sampler));
1949 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *) impl);
1954 This->Flags &= ~SFLAG_LOCKED;
1955 memset(&This->lockedRect, 0, sizeof(RECT));
1957 /* Overlays have to be redrawn manually after changes with the GL implementation */
1958 if(This->overlay_dest) {
1959 IWineD3DSurface_DrawOverlay(iface);
1964 static void surface_release_client_storage(IWineD3DSurface *iface)
1966 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
1967 struct wined3d_context *context;
1969 context = context_acquire(This->resource.device, NULL, CTXUSAGE_RESOURCELOAD);
1972 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
1973 if(This->texture_name)
1975 surface_bind_and_dirtify(This, FALSE);
1976 glTexImage2D(This->texture_target, This->texture_level,
1977 GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
1979 if(This->texture_name_srgb)
1981 surface_bind_and_dirtify(This, TRUE);
1982 glTexImage2D(This->texture_target, This->texture_level,
1983 GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
1985 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
1988 context_release(context);
1990 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSRGBTEX, FALSE);
1991 IWineD3DSurface_ModifyLocation(iface, SFLAG_INTEXTURE, FALSE);
1992 surface_force_reload(iface);
1995 static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC)
1997 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1998 WINED3DLOCKED_RECT lock;
2002 TRACE("(%p)->(%p)\n",This,pHDC);
2004 if(This->Flags & SFLAG_USERPTR) {
2005 ERR("Not supported on surfaces with an application-provided surfaces\n");
2006 return WINEDDERR_NODC;
2009 /* Give more detailed info for ddraw */
2010 if (This->Flags & SFLAG_DCINUSE)
2011 return WINEDDERR_DCALREADYCREATED;
2013 /* Can't GetDC if the surface is locked */
2014 if (This->Flags & SFLAG_LOCKED)
2015 return WINED3DERR_INVALIDCALL;
2017 memset(&lock, 0, sizeof(lock)); /* To be sure */
2019 /* Create a DIB section if there isn't a hdc yet */
2021 if(This->Flags & SFLAG_CLIENT) {
2022 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
2023 surface_release_client_storage(iface);
2025 hr = IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
2026 if(FAILED(hr)) return WINED3DERR_INVALIDCALL;
2028 /* Use the dib section from now on if we are not using a PBO */
2029 if(!(This->Flags & SFLAG_PBO))
2030 This->resource.allocatedMemory = This->dib.bitmap_data;
2033 /* Lock the surface */
2034 hr = IWineD3DSurface_LockRect(iface,
2039 if(This->Flags & SFLAG_PBO) {
2040 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
2041 memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
2045 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
2046 /* keep the dib section */
2050 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
2051 || This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
2053 /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
2054 D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
2056 const PALETTEENTRY *pal = NULL;
2059 pal = This->palette->palents;
2061 IWineD3DSurfaceImpl *dds_primary;
2062 IWineD3DSwapChainImpl *swapchain;
2063 swapchain = (IWineD3DSwapChainImpl *)This->resource.device->swapchains[0];
2064 dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
2065 if (dds_primary && dds_primary->palette)
2066 pal = dds_primary->palette->palents;
2070 for (n=0; n<256; n++) {
2071 col[n].rgbRed = pal[n].peRed;
2072 col[n].rgbGreen = pal[n].peGreen;
2073 col[n].rgbBlue = pal[n].peBlue;
2074 col[n].rgbReserved = 0;
2076 SetDIBColorTable(This->hDC, 0, 256, col);
2081 TRACE("returning %p\n",*pHDC);
2082 This->Flags |= SFLAG_DCINUSE;
2087 static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC)
2089 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2091 TRACE("(%p)->(%p)\n",This,hDC);
2093 if (!(This->Flags & SFLAG_DCINUSE))
2094 return WINEDDERR_NODC;
2096 if (This->hDC !=hDC) {
2097 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
2098 return WINEDDERR_NODC;
2101 if((This->Flags & SFLAG_PBO) && This->resource.allocatedMemory) {
2102 /* Copy the contents of the DIB over to the PBO */
2103 memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
2106 /* we locked first, so unlock now */
2107 IWineD3DSurface_UnlockRect(iface);
2109 This->Flags &= ~SFLAG_DCINUSE;
2114 /* ******************************************************
2115 IWineD3DSurface Internal (No mapping to directx api) parts follow
2116 ****************************************************** */
2118 HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, struct wined3d_format_desc *desc, CONVERT_TYPES *convert)
2120 BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
2121 IWineD3DDeviceImpl *device = This->resource.device;
2122 BOOL blit_supported = FALSE;
2123 RECT rect = {0, 0, This->pow2Width, This->pow2Height};
2125 /* Copy the default values from the surface. Below we might perform fixups */
2126 /* TODO: get rid of color keying desc fixups by using e.g. a table. */
2127 *desc = *This->resource.format_desc;
2128 *convert = NO_CONVERSION;
2130 /* Ok, now look if we have to do any conversion */
2131 switch(This->resource.format_desc->format)
2133 case WINED3DFMT_P8_UINT:
2138 blit_supported = device->blitter->blit_supported(&device->adapter->gl_info, BLIT_OP_BLIT,
2139 &rect, This->resource.usage, This->resource.pool,
2140 This->resource.format_desc, &rect, This->resource.usage,
2141 This->resource.pool, This->resource.format_desc);
2143 /* Use conversion when the blit_shader backend supports it. It only supports this in case of
2144 * texturing. Further also use conversion in case of color keying.
2145 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
2146 * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
2147 * conflicts with this.
2149 if (!((blit_supported && device->render_targets && This == (IWineD3DSurfaceImpl*)device->render_targets[0]))
2150 || colorkey_active || !use_texturing)
2152 desc->glFormat = GL_RGBA;
2153 desc->glInternal = GL_RGBA;
2154 desc->glType = GL_UNSIGNED_BYTE;
2155 desc->conv_byte_count = 4;
2156 if(colorkey_active) {
2157 *convert = CONVERT_PALETTED_CK;
2159 *convert = CONVERT_PALETTED;
2164 case WINED3DFMT_B2G3R3_UNORM:
2165 /* **********************
2166 GL_UNSIGNED_BYTE_3_3_2
2167 ********************** */
2168 if (colorkey_active) {
2169 /* This texture format will never be used.. So do not care about color keying
2170 up until the point in time it will be needed :-) */
2171 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
2175 case WINED3DFMT_B5G6R5_UNORM:
2176 if (colorkey_active) {
2177 *convert = CONVERT_CK_565;
2178 desc->glFormat = GL_RGBA;
2179 desc->glInternal = GL_RGB5_A1;
2180 desc->glType = GL_UNSIGNED_SHORT_5_5_5_1;
2181 desc->conv_byte_count = 2;
2185 case WINED3DFMT_B5G5R5X1_UNORM:
2186 if (colorkey_active) {
2187 *convert = CONVERT_CK_5551;
2188 desc->glFormat = GL_BGRA;
2189 desc->glInternal = GL_RGB5_A1;
2190 desc->glType = GL_UNSIGNED_SHORT_1_5_5_5_REV;
2191 desc->conv_byte_count = 2;
2195 case WINED3DFMT_B8G8R8_UNORM:
2196 if (colorkey_active) {
2197 *convert = CONVERT_CK_RGB24;
2198 desc->glFormat = GL_RGBA;
2199 desc->glInternal = GL_RGBA8;
2200 desc->glType = GL_UNSIGNED_INT_8_8_8_8;
2201 desc->conv_byte_count = 4;
2205 case WINED3DFMT_B8G8R8X8_UNORM:
2206 if (colorkey_active) {
2207 *convert = CONVERT_RGB32_888;
2208 desc->glFormat = GL_RGBA;
2209 desc->glInternal = GL_RGBA8;
2210 desc->glType = GL_UNSIGNED_INT_8_8_8_8;
2211 desc->conv_byte_count = 4;
2222 void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey)
2224 IWineD3DDeviceImpl *device = This->resource.device;
2225 IWineD3DPaletteImpl *pal = This->palette;
2226 BOOL index_in_alpha = FALSE;
2229 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
2230 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
2231 * is slow. Further RGB->P8 conversion is not possible because palettes can have
2232 * duplicate entries. Store the color key in the unused alpha component to speed the
2233 * download up and to make conversion unneeded. */
2234 index_in_alpha = primary_render_target_is_p8(device);
2238 UINT dxVersion = ((IWineD3DImpl *)device->wined3d)->dxVersion;
2240 /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
2243 ERR("This code should never get entered for DirectDraw!, expect problems\n");
2246 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
2247 * there's no palette at this time. */
2248 for (i = 0; i < 256; i++) table[i][3] = i;
2253 /* Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
2254 * alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
2255 * capability flag is present (wine does advertise this capability) */
2256 for (i = 0; i < 256; ++i)
2258 table[i][0] = device->palettes[device->currentPalette][i].peRed;
2259 table[i][1] = device->palettes[device->currentPalette][i].peGreen;
2260 table[i][2] = device->palettes[device->currentPalette][i].peBlue;
2261 table[i][3] = device->palettes[device->currentPalette][i].peFlags;
2267 TRACE("Using surface palette %p\n", pal);
2268 /* Get the surface's palette */
2269 for (i = 0; i < 256; ++i)
2271 table[i][0] = pal->palents[i].peRed;
2272 table[i][1] = pal->palents[i].peGreen;
2273 table[i][2] = pal->palents[i].peBlue;
2275 /* When index_in_alpha is set the palette index is stored in the
2276 * alpha component. In case of a readback we can then read
2277 * GL_ALPHA. Color keying is handled in BltOverride using a
2278 * GL_ALPHA_TEST using GL_NOT_EQUAL. In case of index_in_alpha the
2279 * color key itself is passed to glAlphaFunc in other cases the
2280 * alpha component of pixels that should be masked away is set to 0. */
2285 else if (colorkey && (i >= This->SrcBltCKey.dwColorSpaceLowValue)
2286 && (i <= This->SrcBltCKey.dwColorSpaceHighValue))
2290 else if(pal->Flags & WINEDDPCAPS_ALPHA)
2292 table[i][3] = pal->palents[i].peFlags;
2302 static HRESULT d3dfmt_convert_surface(const BYTE *src, BYTE *dst, UINT pitch, UINT width,
2303 UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This)
2307 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
2312 memcpy(dst, src, pitch * height);
2315 case CONVERT_PALETTED:
2316 case CONVERT_PALETTED_CK:
2318 IWineD3DPaletteImpl* pal = This->palette;
2323 /* TODO: If we are a sublevel, try to get the palette from level 0 */
2326 d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
2328 for (y = 0; y < height; y++)
2330 source = src + pitch * y;
2331 dest = dst + outpitch * y;
2332 /* This is an 1 bpp format, using the width here is fine */
2333 for (x = 0; x < width; x++) {
2334 BYTE color = *source++;
2335 *dest++ = table[color][0];
2336 *dest++ = table[color][1];
2337 *dest++ = table[color][2];
2338 *dest++ = table[color][3];
2344 case CONVERT_CK_565:
2346 /* Converting the 565 format in 5551 packed to emulate color-keying.
2348 Note : in all these conversion, it would be best to average the averaging
2349 pixels to get the color of the pixel that will be color-keyed to
2350 prevent 'color bleeding'. This will be done later on if ever it is
2353 Note2: Nvidia documents say that their driver does not support alpha + color keying
2354 on the same surface and disables color keying in such a case
2360 TRACE("Color keyed 565\n");
2362 for (y = 0; y < height; y++) {
2363 Source = (const WORD *)(src + y * pitch);
2364 Dest = (WORD *) (dst + y * outpitch);
2365 for (x = 0; x < width; x++ ) {
2366 WORD color = *Source++;
2367 *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
2368 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2369 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2378 case CONVERT_CK_5551:
2380 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
2384 TRACE("Color keyed 5551\n");
2385 for (y = 0; y < height; y++) {
2386 Source = (const WORD *)(src + y * pitch);
2387 Dest = (WORD *) (dst + y * outpitch);
2388 for (x = 0; x < width; x++ ) {
2389 WORD color = *Source++;
2391 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2392 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2396 *Dest &= ~(1 << 15);
2404 case CONVERT_CK_RGB24:
2406 /* Converting R8G8B8 format to R8G8B8A8 with color-keying. */
2408 for (y = 0; y < height; y++)
2410 source = src + pitch * y;
2411 dest = dst + outpitch * y;
2412 for (x = 0; x < width; x++) {
2413 DWORD color = ((DWORD)source[0] << 16) + ((DWORD)source[1] << 8) + (DWORD)source[2] ;
2414 DWORD dstcolor = color << 8;
2415 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2416 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2419 *(DWORD*)dest = dstcolor;
2427 case CONVERT_RGB32_888:
2429 /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
2431 for (y = 0; y < height; y++)
2433 source = src + pitch * y;
2434 dest = dst + outpitch * y;
2435 for (x = 0; x < width; x++) {
2436 DWORD color = 0xffffff & *(const DWORD*)source;
2437 DWORD dstcolor = color << 8;
2438 if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2439 (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2442 *(DWORD*)dest = dstcolor;
2451 ERR("Unsupported conversion type %#x.\n", convert);
2456 BOOL palette9_changed(IWineD3DSurfaceImpl *This)
2458 IWineD3DDeviceImpl *device = This->resource.device;
2460 if (This->palette || (This->resource.format_desc->format != WINED3DFMT_P8_UINT
2461 && This->resource.format_desc->format != WINED3DFMT_P8_UINT_A8_UNORM))
2463 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2464 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2471 if (!memcmp(This->palette9, device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256))
2476 This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2478 memcpy(This->palette9, device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
2482 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) {
2483 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2484 DWORD flag = srgb_mode ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE;
2486 if (!(This->Flags & flag)) {
2487 TRACE("Reloading because surface is dirty\n");
2488 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2489 ((This->Flags & SFLAG_GLCKEY) && (!(This->CKeyFlags & WINEDDSD_CKSRCBLT))) ||
2490 /* Reload: vice versa OR */
2491 ((!(This->Flags & SFLAG_GLCKEY)) && (This->CKeyFlags & WINEDDSD_CKSRCBLT)) ||
2492 /* Also reload: Color key is active AND the color key has changed */
2493 ((This->CKeyFlags & WINEDDSD_CKSRCBLT) && (
2494 (This->glCKey.dwColorSpaceLowValue != This->SrcBltCKey.dwColorSpaceLowValue) ||
2495 (This->glCKey.dwColorSpaceHighValue != This->SrcBltCKey.dwColorSpaceHighValue)))) {
2496 TRACE("Reloading because of color keying\n");
2497 /* To perform the color key conversion we need a sysmem copy of
2498 * the surface. Make sure we have it
2501 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
2502 /* Make sure the texture is reloaded because of the color key change, this kills performance though :( */
2503 /* TODO: This is not necessarily needed with hw palettized texture support */
2504 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2506 TRACE("surface is already in texture\n");
2510 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2511 * These resources are not bound by device size or format restrictions. Because of this,
2512 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2513 * However, these resources can always be created, locked, and copied.
2515 if (This->resource.pool == WINED3DPOOL_SCRATCH )
2517 FIXME("(%p) Operation not supported for scratch textures\n",This);
2518 return WINED3DERR_INVALIDCALL;
2521 IWineD3DSurface_LoadLocation(iface, flag, NULL /* no partial locking for textures yet */);
2525 static unsigned int gen = 0;
2528 if ((gen % 10) == 0) {
2529 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm",
2530 This, This->texture_target, This->texture_level, gen);
2531 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
2534 * debugging crash code
2543 if (!(This->Flags & SFLAG_DONOTFREE)) {
2544 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
2545 This->resource.allocatedMemory = NULL;
2546 This->resource.heapMemory = NULL;
2547 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, FALSE);
2553 /* Context activation is done by the caller. */
2554 static void WINAPI IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface *iface, BOOL srgb) {
2555 /* TODO: check for locks */
2556 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2557 IWineD3DBaseTexture *baseTexture = NULL;
2559 TRACE("(%p)Checking to see if the container is a base texture\n", This);
2560 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
2561 TRACE("Passing to container\n");
2562 IWineD3DBaseTexture_BindTexture(baseTexture, srgb);
2563 IWineD3DBaseTexture_Release(baseTexture);
2569 TRACE("(%p) : Binding surface\n", This);
2571 name = srgb ? &This->texture_name_srgb : &This->texture_name;
2575 if (!This->texture_level)
2578 glGenTextures(1, name);
2579 checkGLcall("glGenTextures");
2580 TRACE("Surface %p given name %d\n", This, *name);
2582 glBindTexture(This->texture_target, *name);
2583 checkGLcall("glBindTexture");
2584 glTexParameteri(This->texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2585 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)");
2586 glTexParameteri(This->texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2587 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)");
2588 glTexParameteri(This->texture_target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2589 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)");
2590 glTexParameteri(This->texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2591 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MIN_FILTER, GL_NEAREST)");
2592 glTexParameteri(This->texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2593 checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MAG_FILTER, GL_NEAREST)");
2595 /* This is where we should be reducing the amount of GLMemoryUsed */
2597 /* Mipmap surfaces should have a base texture container */
2598 ERR("Mipmap surface has a glTexture bound to it!\n");
2601 glBindTexture(This->texture_target, *name);
2602 checkGLcall("glBindTexture");
2610 static HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename)
2613 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2614 char *allocatedMemory;
2615 const char *textureRow;
2616 IWineD3DSwapChain *swapChain = NULL;
2617 int width, height, i, y;
2618 GLuint tmpTexture = 0;
2621 Textures may not be stored in ->allocatedgMemory and a GlTexture
2622 so we should lock the surface before saving a snapshot, or at least check that
2624 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2625 by calling GetTexImage and in compressed form by calling
2626 GetCompressedTexImageARB. Queried compressed images can be saved and
2627 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2628 texture images do not need to be processed by the GL and should
2629 significantly improve texture loading performance relative to uncompressed
2632 /* Setup the width and height to be the internal texture width and height. */
2633 width = This->pow2Width;
2634 height = This->pow2Height;
2635 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2636 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapChain);
2638 if (This->Flags & SFLAG_INDRAWABLE && !(This->Flags & SFLAG_INTEXTURE)) {
2639 /* if were not a real texture then read the back buffer into a real texture */
2640 /* we don't want to interfere with the back buffer so read the data into a temporary
2641 * texture and then save the data out of the temporary texture
2645 TRACE("(%p) Reading render target into texture\n", This);
2647 glGenTextures(1, &tmpTexture);
2648 glBindTexture(GL_TEXTURE_2D, tmpTexture);
2650 glTexImage2D(GL_TEXTURE_2D,
2657 GL_UNSIGNED_INT_8_8_8_8_REV,
2660 glGetIntegerv(GL_READ_BUFFER, &prevRead);
2661 checkGLcall("glGetIntegerv");
2662 glReadBuffer(swapChain ? GL_BACK : This->resource.device->offscreenBuffer);
2663 checkGLcall("glReadBuffer");
2664 glCopyTexImage2D(GL_TEXTURE_2D,
2673 checkGLcall("glCopyTexImage2D");
2674 glReadBuffer(prevRead);
2677 } else { /* bind the real texture, and make sure it up to date */
2678 surface_internal_preload(iface, SRGB_RGB);
2679 surface_bind_and_dirtify(This, FALSE);
2681 allocatedMemory = HeapAlloc(GetProcessHeap(), 0, width * height * 4);
2683 FIXME("Saving texture level %d width %d height %d\n", This->texture_level, width, height);
2684 glGetTexImage(GL_TEXTURE_2D, This->texture_level, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, allocatedMemory);
2685 checkGLcall("glGetTexImage");
2687 glBindTexture(GL_TEXTURE_2D, 0);
2688 glDeleteTextures(1, &tmpTexture);
2692 f = fopen(filename, "w+");
2694 ERR("opening of %s failed with: %s\n", filename, strerror(errno));
2695 return WINED3DERR_INVALIDCALL;
2697 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2698 TRACE("(%p) opened %s with format %s\n", This, filename, debug_d3dformat(This->resource.format_desc->format));
2713 fwrite(&width,2,1,f);
2715 fwrite(&height,2,1,f);
2720 /* 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 */
2722 textureRow = allocatedMemory + (width * (height - 1) *4);
2724 textureRow = allocatedMemory;
2725 for (y = 0 ; y < height; y++) {
2726 for (i = 0; i < width; i++) {
2727 color = *((const DWORD*)textureRow);
2728 fputc((color >> 16) & 0xFF, f); /* B */
2729 fputc((color >> 8) & 0xFF, f); /* G */
2730 fputc((color >> 0) & 0xFF, f); /* R */
2731 fputc((color >> 24) & 0xFF, f); /* A */
2734 /* take two rows of the pointer to the texture memory */
2736 (textureRow-= width << 3);
2739 TRACE("Closing file\n");
2743 IWineD3DSwapChain_Release(swapChain);
2745 HeapFree(GetProcessHeap(), 0, allocatedMemory);
2749 static HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) {
2750 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2753 TRACE("(%p) : Calling base function first\n", This);
2754 hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2756 This->Flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2757 TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format_desc->glFormat,
2758 This->resource.format_desc->glInternal, This->resource.format_desc->glType);
2763 static HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2764 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2766 if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
2767 WARN("Surface is locked or the HDC is in use\n");
2768 return WINED3DERR_INVALIDCALL;
2771 if(Mem && Mem != This->resource.allocatedMemory) {
2772 void *release = NULL;
2774 /* Do I have to copy the old surface content? */
2775 if(This->Flags & SFLAG_DIBSECTION) {
2776 /* Release the DC. No need to hold the critical section for the update
2777 * Thread because this thread runs only on front buffers, but this method
2778 * fails for render targets in the check above.
2780 SelectObject(This->hDC, This->dib.holdbitmap);
2781 DeleteDC(This->hDC);
2782 /* Release the DIB section */
2783 DeleteObject(This->dib.DIBsection);
2784 This->dib.bitmap_data = NULL;
2785 This->resource.allocatedMemory = NULL;
2787 This->Flags &= ~SFLAG_DIBSECTION;
2788 } else if(!(This->Flags & SFLAG_USERPTR)) {
2789 release = This->resource.heapMemory;
2790 This->resource.heapMemory = NULL;
2792 This->resource.allocatedMemory = Mem;
2793 This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
2795 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2796 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
2798 /* For client textures opengl has to be notified */
2799 if(This->Flags & SFLAG_CLIENT) {
2800 surface_release_client_storage(iface);
2803 /* Now free the old memory if any */
2804 HeapFree(GetProcessHeap(), 0, release);
2805 } else if(This->Flags & SFLAG_USERPTR) {
2806 /* LockRect and GetDC will re-create the dib section and allocated memory */
2807 This->resource.allocatedMemory = NULL;
2808 /* HeapMemory should be NULL already */
2809 if(This->resource.heapMemory != NULL) ERR("User pointer surface has heap memory allocated\n");
2810 This->Flags &= ~SFLAG_USERPTR;
2812 if(This->Flags & SFLAG_CLIENT) {
2813 surface_release_client_storage(iface);
2819 void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) {
2821 /* Flip the surface contents */
2826 front->hDC = back->hDC;
2830 /* Flip the DIBsection */
2833 BOOL hasDib = front->Flags & SFLAG_DIBSECTION;
2834 tmp = front->dib.DIBsection;
2835 front->dib.DIBsection = back->dib.DIBsection;
2836 back->dib.DIBsection = tmp;
2838 if(back->Flags & SFLAG_DIBSECTION) front->Flags |= SFLAG_DIBSECTION;
2839 else front->Flags &= ~SFLAG_DIBSECTION;
2840 if(hasDib) back->Flags |= SFLAG_DIBSECTION;
2841 else back->Flags &= ~SFLAG_DIBSECTION;
2844 /* Flip the surface data */
2848 tmp = front->dib.bitmap_data;
2849 front->dib.bitmap_data = back->dib.bitmap_data;
2850 back->dib.bitmap_data = tmp;
2852 tmp = front->resource.allocatedMemory;
2853 front->resource.allocatedMemory = back->resource.allocatedMemory;
2854 back->resource.allocatedMemory = tmp;
2856 tmp = front->resource.heapMemory;
2857 front->resource.heapMemory = back->resource.heapMemory;
2858 back->resource.heapMemory = tmp;
2863 GLuint tmp_pbo = front->pbo;
2864 front->pbo = back->pbo;
2865 back->pbo = tmp_pbo;
2868 /* client_memory should not be different, but just in case */
2871 tmp = front->dib.client_memory;
2872 front->dib.client_memory = back->dib.client_memory;
2873 back->dib.client_memory = tmp;
2876 /* Flip the opengl texture */
2880 tmp = back->texture_name;
2881 back->texture_name = front->texture_name;
2882 front->texture_name = tmp;
2884 tmp = back->texture_name_srgb;
2885 back->texture_name_srgb = front->texture_name_srgb;
2886 front->texture_name_srgb = tmp;
2890 DWORD tmp_flags = back->Flags;
2891 back->Flags = front->Flags;
2892 front->Flags = tmp_flags;
2896 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD Flags) {
2897 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2898 IWineD3DSwapChainImpl *swapchain = NULL;
2900 TRACE("(%p)->(%p,%x)\n", This, override, Flags);
2902 /* Flipping is only supported on RenderTargets and overlays*/
2903 if( !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_OVERLAY)) ) {
2904 WARN("Tried to flip a non-render target, non-overlay surface\n");
2905 return WINEDDERR_NOTFLIPPABLE;
2908 if(This->resource.usage & WINED3DUSAGE_OVERLAY) {
2909 flip_surface(This, (IWineD3DSurfaceImpl *) override);
2911 /* Update the overlay if it is visible */
2912 if(This->overlay_dest) {
2913 return IWineD3DSurface_DrawOverlay((IWineD3DSurface *) This);
2920 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2921 * FIXME("(%p) Target override is not supported by now\n", This);
2922 * Additionally, it isn't really possible to support triple-buffering
2923 * properly on opengl at all
2927 IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **) &swapchain);
2929 ERR("Flipped surface is not on a swapchain\n");
2930 return WINEDDERR_NOTFLIPPABLE;
2933 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2934 * and only d3d8 and d3d9 apps specify the presentation interval
2936 if((Flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)) == 0) {
2937 /* Most common case first to avoid wasting time on all the other cases */
2938 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
2939 } else if(Flags & WINEDDFLIP_NOVSYNC) {
2940 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2941 } else if(Flags & WINEDDFLIP_INTERVAL2) {
2942 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
2943 } else if(Flags & WINEDDFLIP_INTERVAL3) {
2944 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
2946 swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
2949 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2950 hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *)swapchain,
2951 NULL, NULL, swapchain->win_handle, NULL, 0);
2952 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
2956 /* Does a direct frame buffer -> texture copy. Stretching is done
2957 * with single pixel copy calls
2959 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
2960 const RECT *src_rect, const RECT *dst_rect_in, WINED3DTEXTUREFILTERTYPE Filter)
2962 IWineD3DDeviceImpl *myDevice = This->resource.device;
2965 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2966 struct wined3d_context *context;
2967 BOOL upsidedown = FALSE;
2968 RECT dst_rect = *dst_rect_in;
2970 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2971 * glCopyTexSubImage is a bit picky about the parameters we pass to it
2973 if(dst_rect.top > dst_rect.bottom) {
2974 UINT tmp = dst_rect.bottom;
2975 dst_rect.bottom = dst_rect.top;
2980 context = context_acquire(myDevice, SrcSurface, CTXUSAGE_BLIT);
2981 surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
2984 /* Bind the target texture */
2985 glBindTexture(This->texture_target, This->texture_name);
2986 checkGLcall("glBindTexture");
2987 if(surface_is_offscreen(SrcSurface)) {
2988 TRACE("Reading from an offscreen target\n");
2989 upsidedown = !upsidedown;
2990 glReadBuffer(myDevice->offscreenBuffer);
2994 glReadBuffer(surface_get_gl_buffer(SrcSurface));
2996 checkGLcall("glReadBuffer");
2998 xrel = (float) (src_rect->right - src_rect->left) / (float) (dst_rect.right - dst_rect.left);
2999 yrel = (float) (src_rect->bottom - src_rect->top) / (float) (dst_rect.bottom - dst_rect.top);
3001 if ((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
3003 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
3005 if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
3006 ERR("Texture filtering not supported in direct blit\n");
3009 else if ((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT)
3010 && ((yrel - 1.0f < -eps) || (yrel - 1.0f > eps)))
3012 ERR("Texture filtering not supported in direct blit\n");
3016 && !((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
3017 && !((yrel - 1.0f < -eps) || (yrel - 1.0f > eps)))
3019 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
3021 glCopyTexSubImage2D(This->texture_target, This->texture_level,
3022 dst_rect.left /*xoffset */, dst_rect.top /* y offset */,
3023 src_rect->left, Src->currentDesc.Height - src_rect->bottom,
3024 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top);
3026 UINT yoffset = Src->currentDesc.Height - src_rect->top + dst_rect.top - 1;
3027 /* I have to process this row by row to swap the image,
3028 * otherwise it would be upside down, so stretching in y direction
3029 * doesn't cost extra time
3031 * However, stretching in x direction can be avoided if not necessary
3033 for(row = dst_rect.top; row < dst_rect.bottom; row++) {
3034 if ((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
3036 /* Well, that stuff works, but it's very slow.
3037 * find a better way instead
3041 for(col = dst_rect.left; col < dst_rect.right; col++) {
3042 glCopyTexSubImage2D(This->texture_target, This->texture_level,
3043 dst_rect.left + col /* x offset */, row /* y offset */,
3044 src_rect->left + col * xrel, yoffset - (int) (row * yrel), 1, 1);
3047 glCopyTexSubImage2D(This->texture_target, This->texture_level,
3048 dst_rect.left /* x offset */, row /* y offset */,
3049 src_rect->left, yoffset - (int) (row * yrel), dst_rect.right - dst_rect.left, 1);
3053 checkGLcall("glCopyTexSubImage2D");
3056 context_release(context);
3058 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3059 * path is never entered
3061 IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INTEXTURE, TRUE);
3064 /* Uses the hardware to stretch and flip the image */
3065 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface,
3066 const RECT *src_rect, const RECT *dst_rect_in, WINED3DTEXTUREFILTERTYPE Filter)
3068 IWineD3DDeviceImpl *myDevice = This->resource.device;
3069 GLuint src, backup = 0;
3070 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3071 IWineD3DSwapChainImpl *src_swapchain = NULL;
3072 float left, right, top, bottom; /* Texture coordinates */
3073 UINT fbwidth = Src->currentDesc.Width;
3074 UINT fbheight = Src->currentDesc.Height;
3075 struct wined3d_context *context;
3076 GLenum drawBuffer = GL_BACK;
3077 GLenum texture_target;
3078 BOOL noBackBufferBackup;
3080 BOOL upsidedown = FALSE;
3081 RECT dst_rect = *dst_rect_in;
3083 TRACE("Using hwstretch blit\n");
3084 /* Activate the Proper context for reading from the source surface, set it up for blitting */
3085 context = context_acquire(myDevice, SrcSurface, CTXUSAGE_BLIT);
3086 surface_internal_preload((IWineD3DSurface *) This, SRGB_RGB);
3088 src_offscreen = surface_is_offscreen(SrcSurface);
3089 noBackBufferBackup = src_offscreen && wined3d_settings.offscreen_rendering_mode == ORM_FBO;
3090 if (!noBackBufferBackup && !Src->texture_name)
3092 /* Get it a description */
3093 surface_internal_preload(SrcSurface, SRGB_RGB);
3097 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
3098 * This way we don't have to wait for the 2nd readback to finish to leave this function.
3100 if (context->aux_buffers >= 2)
3102 /* Got more than one aux buffer? Use the 2nd aux buffer */
3103 drawBuffer = GL_AUX1;
3105 else if ((!src_offscreen || myDevice->offscreenBuffer == GL_BACK) && context->aux_buffers >= 1)
3107 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
3108 drawBuffer = GL_AUX0;
3111 if(noBackBufferBackup) {
3112 glGenTextures(1, &backup);
3113 checkGLcall("glGenTextures");
3114 glBindTexture(GL_TEXTURE_2D, backup);
3115 checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3116 texture_target = GL_TEXTURE_2D;
3118 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
3119 * we are reading from the back buffer, the backup can be used as source texture
3121 texture_target = Src->texture_target;
3122 glBindTexture(texture_target, Src->texture_name);
3123 checkGLcall("glBindTexture(texture_target, Src->texture_name)");
3124 glEnable(texture_target);
3125 checkGLcall("glEnable(texture_target)");
3127 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
3128 Src->Flags &= ~SFLAG_INTEXTURE;
3131 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3132 * glCopyTexSubImage is a bit picky about the parameters we pass to it
3134 if(dst_rect.top > dst_rect.bottom) {
3135 UINT tmp = dst_rect.bottom;
3136 dst_rect.bottom = dst_rect.top;
3143 TRACE("Reading from an offscreen target\n");
3144 upsidedown = !upsidedown;
3145 glReadBuffer(myDevice->offscreenBuffer);
3149 glReadBuffer(surface_get_gl_buffer(SrcSurface));
3152 /* TODO: Only back up the part that will be overwritten */
3153 glCopyTexSubImage2D(texture_target, 0,
3154 0, 0 /* read offsets */,
3159 checkGLcall("glCopyTexSubImage2D");
3161 /* No issue with overriding these - the sampler is dirty due to blit usage */
3162 glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER,
3163 wined3d_gl_mag_filter(magLookup, Filter));
3164 checkGLcall("glTexParameteri");
3165 glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER,
3166 wined3d_gl_min_mip_filter(minMipLookup, Filter, WINED3DTEXF_NONE));
3167 checkGLcall("glTexParameteri");
3169 IWineD3DSurface_GetContainer((IWineD3DSurface *)SrcSurface, &IID_IWineD3DSwapChain, (void **)&src_swapchain);
3170 if (src_swapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *)src_swapchain);
3171 if (!src_swapchain || (IWineD3DSurface *) Src == src_swapchain->backBuffer[0]) {
3172 src = backup ? backup : Src->texture_name;
3174 glReadBuffer(GL_FRONT);
3175 checkGLcall("glReadBuffer(GL_FRONT)");
3177 glGenTextures(1, &src);
3178 checkGLcall("glGenTextures(1, &src)");
3179 glBindTexture(GL_TEXTURE_2D, src);
3180 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
3182 /* TODO: Only copy the part that will be read. Use src_rect->left, src_rect->bottom as origin, but with the width watch
3183 * out for power of 2 sizes
3185 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Src->pow2Width, Src->pow2Height, 0,
3186 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
3187 checkGLcall("glTexImage2D");
3188 glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
3189 0, 0 /* read offsets */,
3194 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3195 checkGLcall("glTexParameteri");
3196 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3197 checkGLcall("glTexParameteri");
3199 glReadBuffer(GL_BACK);
3200 checkGLcall("glReadBuffer(GL_BACK)");
3202 if(texture_target != GL_TEXTURE_2D) {
3203 glDisable(texture_target);
3204 glEnable(GL_TEXTURE_2D);
3205 texture_target = GL_TEXTURE_2D;
3208 checkGLcall("glEnd and previous");
3210 left = src_rect->left;
3211 right = src_rect->right;
3214 top = Src->currentDesc.Height - src_rect->top;
3215 bottom = Src->currentDesc.Height - src_rect->bottom;
3217 top = Src->currentDesc.Height - src_rect->bottom;
3218 bottom = Src->currentDesc.Height - src_rect->top;
3221 if(Src->Flags & SFLAG_NORMCOORD) {
3222 left /= Src->pow2Width;
3223 right /= Src->pow2Width;
3224 top /= Src->pow2Height;
3225 bottom /= Src->pow2Height;
3228 /* draw the source texture stretched and upside down. The correct surface is bound already */
3229 glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3230 glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3232 context_set_draw_buffer(context, drawBuffer);
3233 glReadBuffer(drawBuffer);
3237 glTexCoord2f(left, bottom);
3238 glVertex2i(0, fbheight);
3241 glTexCoord2f(left, top);
3242 glVertex2i(0, fbheight - dst_rect.bottom - dst_rect.top);
3245 glTexCoord2f(right, top);
3246 glVertex2i(dst_rect.right - dst_rect.left, fbheight - dst_rect.bottom - dst_rect.top);
3249 glTexCoord2f(right, bottom);
3250 glVertex2i(dst_rect.right - dst_rect.left, fbheight);
3252 checkGLcall("glEnd and previous");
3254 if (texture_target != This->texture_target)
3256 glDisable(texture_target);
3257 glEnable(This->texture_target);
3258 texture_target = This->texture_target;
3261 /* Now read the stretched and upside down image into the destination texture */
3262 glBindTexture(texture_target, This->texture_name);
3263 checkGLcall("glBindTexture");
3264 glCopyTexSubImage2D(texture_target,
3266 dst_rect.left, dst_rect.top, /* xoffset, yoffset */
3267 0, 0, /* We blitted the image to the origin */
3268 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top);
3269 checkGLcall("glCopyTexSubImage2D");
3271 if(drawBuffer == GL_BACK) {
3272 /* Write the back buffer backup back */
3274 if(texture_target != GL_TEXTURE_2D) {
3275 glDisable(texture_target);
3276 glEnable(GL_TEXTURE_2D);
3277 texture_target = GL_TEXTURE_2D;
3279 glBindTexture(GL_TEXTURE_2D, backup);
3280 checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3282 if (texture_target != Src->texture_target)
3284 glDisable(texture_target);
3285 glEnable(Src->texture_target);
3286 texture_target = Src->texture_target;
3288 glBindTexture(Src->texture_target, Src->texture_name);
3289 checkGLcall("glBindTexture(Src->texture_target, Src->texture_name)");
3294 glTexCoord2f(0.0f, (float)fbheight / (float)Src->pow2Height);
3298 glTexCoord2f(0.0f, 0.0f);
3299 glVertex2i(0, fbheight);
3302 glTexCoord2f((float)fbwidth / (float)Src->pow2Width, 0.0f);
3303 glVertex2i(fbwidth, Src->currentDesc.Height);
3306 glTexCoord2f((float) fbwidth / (float) Src->pow2Width, (float) fbheight / (float) Src->pow2Height);
3307 glVertex2i(fbwidth, 0);
3310 glDisable(texture_target);
3311 checkGLcall("glDisable(texture_target)");
3314 if (src != Src->texture_name && src != backup)
3316 glDeleteTextures(1, &src);
3317 checkGLcall("glDeleteTextures(1, &src)");
3320 glDeleteTextures(1, &backup);
3321 checkGLcall("glDeleteTextures(1, &backup)");
3326 if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
3328 context_release(context);
3330 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3331 * path is never entered
3333 IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INTEXTURE, TRUE);
3336 /* Until the blit_shader is ready, define some prototypes here. */
3337 static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
3338 const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
3339 const struct wined3d_format_desc *src_format_desc,
3340 const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
3341 const struct wined3d_format_desc *dst_format_desc);
3343 /* Not called from the VTable */
3344 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3345 IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx,
3346 WINED3DTEXTUREFILTERTYPE Filter)
3348 IWineD3DDeviceImpl *myDevice = This->resource.device;
3349 IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
3350 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3351 RECT dst_rect, src_rect;
3353 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3355 /* Get the swapchain. One of the surfaces has to be a primary surface */
3356 if(This->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3357 WARN("Destination is in sysmem, rejecting gl blt\n");
3358 return WINED3DERR_INVALIDCALL;
3360 IWineD3DSurface_GetContainer( (IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&dstSwapchain);
3361 if(dstSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) dstSwapchain);
3363 if(Src->resource.pool == WINED3DPOOL_SYSTEMMEM) {
3364 WARN("Src is in sysmem, rejecting gl blt\n");
3365 return WINED3DERR_INVALIDCALL;
3367 IWineD3DSurface_GetContainer( (IWineD3DSurface *) Src, &IID_IWineD3DSwapChain, (void **)&srcSwapchain);
3368 if(srcSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) srcSwapchain);
3371 /* Early sort out of cases where no render target is used */
3372 if(!dstSwapchain && !srcSwapchain &&
3373 SrcSurface != myDevice->render_targets[0] && This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3374 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src, This);
3375 return WINED3DERR_INVALIDCALL;
3378 /* No destination color keying supported */
3379 if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
3380 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3381 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3382 return WINED3DERR_INVALIDCALL;
3385 surface_get_rect(This, DestRect, &dst_rect);
3386 if(Src) surface_get_rect(Src, SrcRect, &src_rect);
3388 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3389 if(dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->backBuffer &&
3390 ((IWineD3DSurface *) This == dstSwapchain->frontBuffer) && SrcSurface == dstSwapchain->backBuffer[0]) {
3391 /* Half-life does a Blt from the back buffer to the front buffer,
3392 * Full surface size, no flags... Use present instead
3394 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3397 /* Check rects - IWineD3DDevice_Present doesn't handle them */
3400 TRACE("Looking if a Present can be done...\n");
3401 /* Source Rectangle must be full surface */
3402 if(src_rect.left != 0 || src_rect.top != 0 ||
3403 src_rect.right != Src->currentDesc.Width || src_rect.bottom != Src->currentDesc.Height) {
3404 TRACE("No, Source rectangle doesn't match\n");
3408 /* No stretching may occur */
3409 if(src_rect.right != dst_rect.right - dst_rect.left ||
3410 src_rect.bottom != dst_rect.bottom - dst_rect.top) {
3411 TRACE("No, stretching is done\n");
3415 /* Destination must be full surface or match the clipping rectangle */
3416 if(This->clipper && ((IWineD3DClipperImpl *) This->clipper)->hWnd)
3420 GetClientRect(((IWineD3DClipperImpl *) This->clipper)->hWnd, &cliprect);
3421 pos[0].x = dst_rect.left;
3422 pos[0].y = dst_rect.top;
3423 pos[1].x = dst_rect.right;
3424 pos[1].y = dst_rect.bottom;
3425 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl *) This->clipper)->hWnd,
3428 if(pos[0].x != cliprect.left || pos[0].y != cliprect.top ||
3429 pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
3431 TRACE("No, dest rectangle doesn't match(clipper)\n");
3432 TRACE("Clip rect at %s\n", wine_dbgstr_rect(&cliprect));
3433 TRACE("Blt dest: %s\n", wine_dbgstr_rect(&dst_rect));
3439 if(dst_rect.left != 0 || dst_rect.top != 0 ||
3440 dst_rect.right != This->currentDesc.Width || dst_rect.bottom != This->currentDesc.Height) {
3441 TRACE("No, dest rectangle doesn't match(surface size)\n");
3448 /* These flags are unimportant for the flag check, remove them */
3449 if((Flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)) == 0) {
3450 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
3452 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3453 * take very long, while a flip is fast.
3454 * This applies to Half-Life, which does such Blts every time it finished
3455 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3456 * menu. This is also used by all apps when they do windowed rendering
3458 * The problem is that flipping is not really the same as copying. After a
3459 * Blt the front buffer is a copy of the back buffer, and the back buffer is
3460 * untouched. Therefore it's necessary to override the swap effect
3461 * and to set it back after the flip.
3463 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3467 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
3468 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3470 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3471 IWineD3DSwapChain_Present((IWineD3DSwapChain *)dstSwapchain,
3472 NULL, NULL, dstSwapchain->win_handle, NULL, 0);
3474 dstSwapchain->presentParms.SwapEffect = orig_swap;
3481 TRACE("Unsupported blit between buffers on the same swapchain\n");
3482 return WINED3DERR_INVALIDCALL;
3483 } else if(dstSwapchain && dstSwapchain == srcSwapchain) {
3484 FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3485 return WINED3DERR_INVALIDCALL;
3486 } else if(dstSwapchain && srcSwapchain) {
3487 FIXME("Implement hardware blit between two different swapchains\n");
3488 return WINED3DERR_INVALIDCALL;
3489 } else if(dstSwapchain) {
3490 if(SrcSurface == myDevice->render_targets[0]) {
3491 TRACE("Blit from active render target to a swapchain\n");
3492 /* Handled with regular texture -> swapchain blit */
3494 } else if(srcSwapchain && This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3495 FIXME("Implement blit from a swapchain to the active render target\n");
3496 return WINED3DERR_INVALIDCALL;
3499 if((srcSwapchain || SrcSurface == myDevice->render_targets[0]) && !dstSwapchain) {
3500 /* Blit from render target to texture */
3503 /* P8 read back is not implemented */
3504 if (Src->resource.format_desc->format == WINED3DFMT_P8_UINT ||
3505 This->resource.format_desc->format == WINED3DFMT_P8_UINT)
3507 TRACE("P8 read back not supported by frame buffer to texture blit\n");
3508 return WINED3DERR_INVALIDCALL;
3511 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3512 TRACE("Color keying not supported by frame buffer to texture blit\n");
3513 return WINED3DERR_INVALIDCALL;
3514 /* Destination color key is checked above */
3517 if(dst_rect.right - dst_rect.left != src_rect.right - src_rect.left) {
3523 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3524 * flip the image nor scale it.
3526 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3527 * -> If the app wants a image width an unscaled width, copy it line per line
3528 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3529 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3530 * back buffer. This is slower than reading line per line, thus not used for flipping
3531 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3534 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3535 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3538 if (fbo_blit_supported(&myDevice->adapter->gl_info, BLIT_OP_BLIT,
3539 &src_rect, Src->resource.usage, Src->resource.pool, Src->resource.format_desc,
3540 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3542 stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &src_rect,
3543 (IWineD3DSurface *)This, &dst_rect, Filter);
3544 } else if((!stretchx) || dst_rect.right - dst_rect.left > Src->currentDesc.Width ||
3545 dst_rect.bottom - dst_rect.top > Src->currentDesc.Height) {
3546 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3547 fb_copy_to_texture_direct(This, SrcSurface, &src_rect, &dst_rect, Filter);
3549 TRACE("Using hardware stretching to flip / stretch the texture\n");
3550 fb_copy_to_texture_hwstretch(This, SrcSurface, &src_rect, &dst_rect, Filter);
3553 if(!(This->Flags & SFLAG_DONOTFREE)) {
3554 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
3555 This->resource.allocatedMemory = NULL;
3556 This->resource.heapMemory = NULL;
3558 This->Flags &= ~SFLAG_INSYSMEM;
3563 /* Blit from offscreen surface to render target */
3564 DWORD oldCKeyFlags = Src->CKeyFlags;
3565 WINEDDCOLORKEY oldBltCKey = Src->SrcBltCKey;
3566 struct wined3d_context *context;
3568 TRACE("Blt from surface %p to rendertarget %p\n", Src, This);
3570 if (!(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3571 && fbo_blit_supported(&myDevice->adapter->gl_info, BLIT_OP_BLIT,
3572 &src_rect, Src->resource.usage, Src->resource.pool, Src->resource.format_desc,
3573 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3575 TRACE("Using stretch_rect_fbo\n");
3576 /* The source is always a texture, but never the currently active render target, and the texture
3577 * contents are never upside down
3579 stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &src_rect,
3580 (IWineD3DSurface *)This, &dst_rect, Filter);
3584 if (!(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3585 && arbfp_blit.blit_supported(&myDevice->adapter->gl_info, BLIT_OP_BLIT,
3586 &src_rect, Src->resource.usage, Src->resource.pool, Src->resource.format_desc,
3587 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3589 return arbfp_blit_surface(myDevice, Src, &src_rect, This, &dst_rect, BLIT_OP_BLIT, Filter);
3592 /* Color keying: Check if we have to do a color keyed blt,
3593 * and if not check if a color key is activated.
3595 * Just modify the color keying parameters in the surface and restore them afterwards
3596 * The surface keeps track of the color key last used to load the opengl surface.
3597 * PreLoad will catch the change to the flags and color key and reload if necessary.
3599 if(Flags & WINEDDBLT_KEYSRC) {
3600 /* Use color key from surface */
3601 } else if(Flags & WINEDDBLT_KEYSRCOVERRIDE) {
3602 /* Use color key from DDBltFx */
3603 Src->CKeyFlags |= WINEDDSD_CKSRCBLT;
3604 Src->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3606 /* Do not use color key */
3607 Src->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3610 /* Now load the surface */
3611 surface_internal_preload((IWineD3DSurface *) Src, SRGB_RGB);
3613 /* Activate the destination context, set it up for blitting */
3614 context = context_acquire(myDevice, (IWineD3DSurface *)This, CTXUSAGE_BLIT);
3616 /* The coordinates of the ddraw front buffer are always fullscreen ('screen coordinates',
3617 * while OpenGL coordinates are window relative.
3618 * Also beware of the origin difference(top left vs bottom left).
3619 * Also beware that the front buffer's surface size is screen width x screen height,
3620 * whereas the real gl drawable size is the size of the window.
3622 if (dstSwapchain && (IWineD3DSurface *)This == dstSwapchain->frontBuffer) {
3624 POINT offset = {0,0};
3626 ClientToScreen(context->win_handle, &offset);
3627 GetClientRect(context->win_handle, &windowsize);
3628 h = windowsize.bottom - windowsize.top;
3629 dst_rect.left -= offset.x; dst_rect.right -=offset.x;
3630 dst_rect.top -= offset.y; dst_rect.bottom -=offset.y;
3631 dst_rect.top += This->currentDesc.Height - h; dst_rect.bottom += This->currentDesc.Height - h;
3634 if (!myDevice->blitter->blit_supported(&myDevice->adapter->gl_info, BLIT_OP_BLIT,
3635 &src_rect, Src->resource.usage, Src->resource.pool, Src->resource.format_desc,
3636 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3638 FIXME("Unsupported blit operation falling back to software\n");
3639 return WINED3DERR_INVALIDCALL;
3642 myDevice->blitter->set_shader((IWineD3DDevice *) myDevice, Src);
3646 /* This is for color keying */
3647 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3648 glEnable(GL_ALPHA_TEST);
3649 checkGLcall("glEnable(GL_ALPHA_TEST)");
3651 /* When the primary render target uses P8, the alpha component contains the palette index.
3652 * Which means that the colorkey is one of the palette entries. In other cases pixels that
3653 * should be masked away have alpha set to 0. */
3654 if(primary_render_target_is_p8(myDevice))
3655 glAlphaFunc(GL_NOTEQUAL, (float)Src->SrcBltCKey.dwColorSpaceLowValue / 256.0f);
3657 glAlphaFunc(GL_NOTEQUAL, 0.0f);
3658 checkGLcall("glAlphaFunc");
3660 glDisable(GL_ALPHA_TEST);
3661 checkGLcall("glDisable(GL_ALPHA_TEST)");
3664 /* Draw a textured quad
3666 draw_textured_quad(Src, &src_rect, &dst_rect, Filter);
3668 if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3669 glDisable(GL_ALPHA_TEST);
3670 checkGLcall("glDisable(GL_ALPHA_TEST)");
3673 /* Restore the color key parameters */
3674 Src->CKeyFlags = oldCKeyFlags;
3675 Src->SrcBltCKey = oldBltCKey;
3679 /* Leave the opengl state valid for blitting */
3680 myDevice->blitter->unset_shader((IWineD3DDevice *) myDevice);
3682 if (wined3d_settings.strict_draw_ordering || (dstSwapchain
3683 && ((IWineD3DSurface *)This == dstSwapchain->frontBuffer
3684 || dstSwapchain->num_contexts > 1)))
3685 wglFlush(); /* Flush to ensure ordering across contexts. */
3687 context_release(context);
3689 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3690 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3693 IWineD3DSurface_ModifyLocation((IWineD3DSurface *) This, SFLAG_INDRAWABLE, TRUE);
3697 /* Source-Less Blit to render target */
3698 if (Flags & WINEDDBLT_COLORFILL) {
3701 TRACE("Colorfill\n");
3703 /* The color as given in the Blt function is in the format of the frame-buffer...
3704 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3706 if (!surface_convert_color_to_argb(This, DDBltFx->u5.dwFillColor, &color))
3708 /* The color conversion function already prints an error, so need to do it here */
3709 return WINED3DERR_INVALIDCALL;
3712 if (ffp_blit.blit_supported(&myDevice->adapter->gl_info, BLIT_OP_COLOR_FILL,
3714 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3716 return ffp_blit.color_fill(myDevice, This, &dst_rect, color);
3718 else if (cpu_blit.blit_supported(&myDevice->adapter->gl_info, BLIT_OP_COLOR_FILL,
3720 &dst_rect, This->resource.usage, This->resource.pool, This->resource.format_desc))
3722 return cpu_blit.color_fill(myDevice, This, &dst_rect, color);
3724 return WINED3DERR_INVALIDCALL;
3728 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3729 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3730 return WINED3DERR_INVALIDCALL;
3733 static HRESULT IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, const RECT *DestRect,
3734 IWineD3DSurface *SrcSurface, const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx)
3736 IWineD3DDeviceImpl *myDevice = This->resource.device;
3739 if (Flags & WINEDDBLT_DEPTHFILL) {
3740 switch(This->resource.format_desc->format)
3742 case WINED3DFMT_D16_UNORM:
3743 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
3745 case WINED3DFMT_S1_UINT_D15_UNORM:
3746 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000fffe;
3748 case WINED3DFMT_D24_UNORM_S8_UINT:
3749 case WINED3DFMT_X8D24_UNORM:
3750 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x00ffffff;
3752 case WINED3DFMT_D32_UNORM:
3753 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0xffffffff;
3757 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This->resource.format_desc->format));
3760 return IWineD3DDevice_Clear((IWineD3DDevice *) myDevice,
3761 DestRect == NULL ? 0 : 1,
3762 (const WINED3DRECT *)DestRect,
3763 WINED3DCLEAR_ZBUFFER,
3769 FIXME("(%p): Unsupp depthstencil blit\n", This);
3770 return WINED3DERR_INVALIDCALL;
3773 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect, IWineD3DSurface *SrcSurface,
3774 const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
3775 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
3776 IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3777 IWineD3DDeviceImpl *myDevice = This->resource.device;
3779 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3780 TRACE("(%p): Usage is %s\n", This, debug_d3dusage(This->resource.usage));
3782 if ( (This->Flags & SFLAG_LOCKED) || ((Src != NULL) && (Src->Flags & SFLAG_LOCKED)))
3784 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3785 return WINEDDERR_SURFACEBUSY;
3788 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3789 * except depth blits, which seem to work
3791 if(iface == myDevice->stencilBufferTarget || (SrcSurface && SrcSurface == myDevice->stencilBufferTarget)) {
3792 if(myDevice->inScene && !(Flags & WINEDDBLT_DEPTHFILL)) {
3793 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3794 return WINED3DERR_INVALIDCALL;
3795 } else if(IWineD3DSurfaceImpl_BltZ(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx) == WINED3D_OK) {
3796 TRACE("Z Blit override handled the blit\n");
3801 /* Special cases for RenderTargets */
3802 if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3803 ( Src && (Src->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3804 if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
3807 /* For the rest call the X11 surface implementation.
3808 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3809 * other Blts are rather rare
3811 return IWineD3DBaseSurfaceImpl_Blt(iface, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter);
3814 static HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
3815 IWineD3DSurface *Source, const RECT *rsrc, DWORD trans)
3817 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3818 IWineD3DSurfaceImpl *srcImpl = (IWineD3DSurfaceImpl *) Source;
3819 IWineD3DDeviceImpl *myDevice = This->resource.device;
3821 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface, dstx, dsty, Source, rsrc, trans);
3823 if ( (This->Flags & SFLAG_LOCKED) || (srcImpl->Flags & SFLAG_LOCKED))
3825 WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
3826 return WINEDDERR_SURFACEBUSY;
3829 if(myDevice->inScene &&
3830 (iface == myDevice->stencilBufferTarget ||
3831 (Source == myDevice->stencilBufferTarget))) {
3832 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3833 return WINED3DERR_INVALIDCALL;
3836 /* Special cases for RenderTargets */
3837 if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3838 (srcImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) ) {
3840 RECT SrcRect, DstRect;
3843 surface_get_rect(srcImpl, rsrc, &SrcRect);
3845 DstRect.left = dstx;
3847 DstRect.right = dstx + SrcRect.right - SrcRect.left;
3848 DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
3850 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3851 if(trans & WINEDDBLTFAST_SRCCOLORKEY)
3852 Flags |= WINEDDBLT_KEYSRC;
3853 if(trans & WINEDDBLTFAST_DESTCOLORKEY)
3854 Flags |= WINEDDBLT_KEYDEST;
3855 if(trans & WINEDDBLTFAST_WAIT)
3856 Flags |= WINEDDBLT_WAIT;
3857 if(trans & WINEDDBLTFAST_DONOTWAIT)
3858 Flags |= WINEDDBLT_DONOTWAIT;
3860 if(IWineD3DSurfaceImpl_BltOverride(This, &DstRect, Source, &SrcRect, Flags, NULL, WINED3DTEXF_POINT) == WINED3D_OK) return WINED3D_OK;
3864 return IWineD3DBaseSurfaceImpl_BltFast(iface, dstx, dsty, Source, rsrc, trans);
3867 static HRESULT WINAPI IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface *iface)
3869 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3871 IWineD3DPaletteImpl *pal = This->palette;
3873 TRACE("(%p)\n", This);
3875 if (!pal) return WINED3D_OK;
3877 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
3878 || This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
3880 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET)
3882 /* Make sure the texture is up to date. This call doesn't do anything if the texture is already up to date. */
3883 IWineD3DSurface_LoadLocation(iface, SFLAG_INTEXTURE, NULL);
3885 /* We want to force a palette refresh, so mark the drawable as not being up to date */
3886 IWineD3DSurface_ModifyLocation(iface, SFLAG_INDRAWABLE, FALSE);
3888 if(!(This->Flags & SFLAG_INSYSMEM)) {
3889 TRACE("Palette changed with surface that does not have an up to date system memory copy\n");
3890 IWineD3DSurface_LoadLocation(iface, SFLAG_INSYSMEM, NULL);
3892 TRACE("Dirtifying surface\n");
3893 IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE);
3897 if(This->Flags & SFLAG_DIBSECTION) {
3898 TRACE("(%p): Updating the hdc's palette\n", This);
3899 for (n=0; n<256; n++) {
3900 col[n].rgbRed = pal->palents[n].peRed;
3901 col[n].rgbGreen = pal->palents[n].peGreen;
3902 col[n].rgbBlue = pal->palents[n].peBlue;
3903 col[n].rgbReserved = 0;
3905 SetDIBColorTable(This->hDC, 0, 256, col);
3908 /* Propagate the changes to the drawable when we have a palette. */
3909 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET)
3910 IWineD3DSurface_LoadLocation(iface, SFLAG_INDRAWABLE, NULL);
3915 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
3916 /** Check against the maximum texture sizes supported by the video card **/
3917 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3918 const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
3919 unsigned int pow2Width, pow2Height;
3921 This->texture_name = 0;
3922 This->texture_target = GL_TEXTURE_2D;
3924 /* Non-power2 support */
3925 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] || gl_info->supported[WINE_NORMALIZED_TEXRECT])
3927 pow2Width = This->currentDesc.Width;
3928 pow2Height = This->currentDesc.Height;
3932 /* Find the nearest pow2 match */
3933 pow2Width = pow2Height = 1;
3934 while (pow2Width < This->currentDesc.Width) pow2Width <<= 1;
3935 while (pow2Height < This->currentDesc.Height) pow2Height <<= 1;
3937 This->pow2Width = pow2Width;
3938 This->pow2Height = pow2Height;
3940 if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
3941 /** TODO: add support for non power two compressed textures **/
3942 if (This->resource.format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
3944 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3945 This, This->currentDesc.Width, This->currentDesc.Height);
3946 return WINED3DERR_NOTAVAILABLE;
3950 if(pow2Width != This->currentDesc.Width ||
3951 pow2Height != This->currentDesc.Height) {
3952 This->Flags |= SFLAG_NONPOW2;
3955 TRACE("%p\n", This);
3956 if ((This->pow2Width > gl_info->limits.texture_size || This->pow2Height > gl_info->limits.texture_size)
3957 && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL)))
3959 /* one of three options
3960 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)
3961 2: Set the texture to the maximum size (bad idea)
3962 3: WARN and return WINED3DERR_NOTAVAILABLE;
3963 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.
3965 if(This->resource.pool == WINED3DPOOL_DEFAULT || This->resource.pool == WINED3DPOOL_MANAGED)
3967 WARN("(%p) Unable to allocate a surface which exceeds the maximum OpenGL texture size\n", This);
3968 return WINED3DERR_NOTAVAILABLE;
3971 /* We should never use this surface in combination with OpenGL! */
3972 TRACE("(%p) Creating an oversized surface: %ux%u\n", This, This->pow2Width, This->pow2Height);
3976 /* Don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
3977 is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
3978 doesn't work in combination with ARB_TEXTURE_RECTANGLE.
3980 if (This->Flags & SFLAG_NONPOW2 && gl_info->supported[ARB_TEXTURE_RECTANGLE]
3981 && !(This->resource.format_desc->format == WINED3DFMT_P8_UINT
3982 && gl_info->supported[EXT_PALETTED_TEXTURE]
3983 && wined3d_settings.rendertargetlock_mode == RTL_READTEX))
3985 This->texture_target = GL_TEXTURE_RECTANGLE_ARB;
3986 This->pow2Width = This->currentDesc.Width;
3987 This->pow2Height = This->currentDesc.Height;
3988 This->Flags &= ~(SFLAG_NONPOW2 | SFLAG_NORMCOORD);
3992 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
3993 switch(wined3d_settings.offscreen_rendering_mode) {
3994 case ORM_FBO: This->get_drawable_size = get_drawable_size_fbo; break;
3995 case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
3999 This->Flags |= SFLAG_INSYSMEM;
4004 /* GL locking is done by the caller */
4005 static void surface_depth_blt(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
4006 GLuint texture, GLsizei w, GLsizei h, GLenum target)
4008 IWineD3DDeviceImpl *device = This->resource.device;
4009 struct blt_info info;
4010 GLint old_binding = 0;
4012 glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_VIEWPORT_BIT);
4014 glDisable(GL_CULL_FACE);
4015 glDisable(GL_BLEND);
4016 glDisable(GL_ALPHA_TEST);
4017 glDisable(GL_SCISSOR_TEST);
4018 glDisable(GL_STENCIL_TEST);
4019 glEnable(GL_DEPTH_TEST);
4020 glDepthFunc(GL_ALWAYS);
4021 glDepthMask(GL_TRUE);
4022 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
4023 glViewport(0, 0, w, h);
4025 surface_get_blt_info(target, NULL, w, h, &info);
4026 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
4027 glGetIntegerv(info.binding, &old_binding);
4028 glBindTexture(info.bind_target, texture);
4030 device->shader_backend->shader_select_depth_blt((IWineD3DDevice *)device, info.tex_type);
4032 glBegin(GL_TRIANGLE_STRIP);
4033 glTexCoord3fv(info.coords[0]);
4034 glVertex2f(-1.0f, -1.0f);
4035 glTexCoord3fv(info.coords[1]);
4036 glVertex2f(1.0f, -1.0f);
4037 glTexCoord3fv(info.coords[2]);
4038 glVertex2f(-1.0f, 1.0f);
4039 glTexCoord3fv(info.coords[3]);
4040 glVertex2f(1.0f, 1.0f);
4043 glBindTexture(info.bind_target, old_binding);
4047 device->shader_backend->shader_deselect_depth_blt((IWineD3DDevice *)device);
4050 void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location) {
4051 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4053 TRACE("(%p) New location %#x\n", This, location);
4055 if (location & ~SFLAG_DS_LOCATIONS) {
4056 FIXME("(%p) Invalid location (%#x) specified\n", This, location);
4059 This->Flags &= ~SFLAG_DS_LOCATIONS;
4060 This->Flags |= location;
4063 /* Context activation is done by the caller. */
4064 void surface_load_ds_location(IWineD3DSurface *iface, struct wined3d_context *context, DWORD location)
4066 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4067 IWineD3DDeviceImpl *device = This->resource.device;
4068 const struct wined3d_gl_info *gl_info = context->gl_info;
4070 TRACE("(%p) New location %#x\n", This, location);
4072 /* TODO: Make this work for modes other than FBO */
4073 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return;
4075 if (This->Flags & location) {
4076 TRACE("(%p) Location (%#x) is already up to date\n", This, location);
4080 if (This->current_renderbuffer) {
4081 FIXME("(%p) Not supported with fixed up depth stencil\n", This);
4085 if (location == SFLAG_DS_OFFSCREEN) {
4086 if (This->Flags & SFLAG_DS_ONSCREEN) {
4087 GLint old_binding = 0;
4090 TRACE("(%p) Copying onscreen depth buffer to depth texture\n", This);
4094 if (!device->depth_blt_texture) {
4095 glGenTextures(1, &device->depth_blt_texture);
4098 /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
4099 * directly on the FBO texture. That's because we need to flip. */
4100 context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4101 if (This->texture_target == GL_TEXTURE_RECTANGLE_ARB)
4103 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
4104 bind_target = GL_TEXTURE_RECTANGLE_ARB;
4106 glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
4107 bind_target = GL_TEXTURE_2D;
4109 glBindTexture(bind_target, device->depth_blt_texture);
4110 glCopyTexImage2D(bind_target, This->texture_level, This->resource.format_desc->glInternal,
4111 0, 0, This->currentDesc.Width, This->currentDesc.Height, 0);
4112 glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4113 glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4114 glTexParameteri(bind_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
4115 glTexParameteri(bind_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
4116 glTexParameteri(bind_target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
4117 glTexParameteri(bind_target, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
4118 glBindTexture(bind_target, old_binding);
4120 /* Setup the destination */
4121 if (!device->depth_blt_rb) {
4122 gl_info->fbo_ops.glGenRenderbuffers(1, &device->depth_blt_rb);
4123 checkGLcall("glGenRenderbuffersEXT");
4125 if (device->depth_blt_rb_w != This->currentDesc.Width
4126 || device->depth_blt_rb_h != This->currentDesc.Height) {
4127 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, device->depth_blt_rb);
4128 checkGLcall("glBindRenderbufferEXT");
4129 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8,
4130 This->currentDesc.Width, This->currentDesc.Height);
4131 checkGLcall("glRenderbufferStorageEXT");
4132 device->depth_blt_rb_w = This->currentDesc.Width;
4133 device->depth_blt_rb_h = This->currentDesc.Height;
4136 context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
4137 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
4138 GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, device->depth_blt_rb);
4139 checkGLcall("glFramebufferRenderbufferEXT");
4140 context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, iface, FALSE);
4142 /* Do the actual blit */
4143 surface_depth_blt(This, gl_info, device->depth_blt_texture,
4144 This->currentDesc.Width, This->currentDesc.Height, bind_target);
4145 checkGLcall("depth_blt");
4147 if (context->current_fbo) context_bind_fbo(context, GL_FRAMEBUFFER, &context->current_fbo->id);
4148 else context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4152 if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
4156 FIXME("No up to date depth stencil location\n");
4158 } else if (location == SFLAG_DS_ONSCREEN) {
4159 if (This->Flags & SFLAG_DS_OFFSCREEN) {
4160 TRACE("(%p) Copying depth texture to onscreen depth buffer\n", This);
4164 context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4165 surface_depth_blt(This, gl_info, This->texture_name,
4166 This->currentDesc.Width, This->currentDesc.Height, This->texture_target);
4167 checkGLcall("depth_blt");
4169 if (context->current_fbo) context_bind_fbo(context, GL_FRAMEBUFFER, &context->current_fbo->id);
4173 if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
4177 FIXME("No up to date depth stencil location\n");
4180 ERR("(%p) Invalid location (%#x) specified\n", This, location);
4183 This->Flags |= location;
4186 static void WINAPI IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
4187 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4188 IWineD3DBaseTexture *texture;
4189 IWineD3DSurfaceImpl *overlay;
4191 TRACE("(%p)->(%s, %s)\n", iface, debug_surflocation(flag),
4192 persistent ? "TRUE" : "FALSE");
4194 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4195 if (surface_is_offscreen(iface))
4197 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4198 if (flag & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)) flag |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4202 TRACE("Surface %p is an onscreen surface\n", iface);
4207 if(((This->Flags & SFLAG_INTEXTURE) && !(flag & SFLAG_INTEXTURE)) ||
4208 ((This->Flags & SFLAG_INSRGBTEX) && !(flag & SFLAG_INSRGBTEX))) {
4209 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4210 TRACE("Passing to container\n");
4211 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4212 IWineD3DBaseTexture_Release(texture);
4215 This->Flags &= ~SFLAG_LOCATIONS;
4216 This->Flags |= flag;
4218 /* Redraw emulated overlays, if any */
4219 if(flag & SFLAG_INDRAWABLE && !list_empty(&This->overlays)) {
4220 LIST_FOR_EACH_ENTRY(overlay, &This->overlays, IWineD3DSurfaceImpl, overlay_entry) {
4221 IWineD3DSurface_DrawOverlay((IWineD3DSurface *) overlay);
4225 if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) && (flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX))) {
4226 if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&texture) == WINED3D_OK) {
4227 TRACE("Passing to container\n");
4228 IWineD3DBaseTexture_SetDirty(texture, TRUE);
4229 IWineD3DBaseTexture_Release(texture);
4232 This->Flags &= ~flag;
4235 if(!(This->Flags & SFLAG_LOCATIONS)) {
4236 ERR("%p: Surface does not have any up to date location\n", This);
4240 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl *This, const RECT *rect_in)
4242 IWineD3DDeviceImpl *device = This->resource.device;
4243 IWineD3DSwapChainImpl *swapchain;
4244 struct wined3d_context *context;
4245 RECT src_rect, dst_rect;
4247 surface_get_rect(This, rect_in, &src_rect);
4249 context = context_acquire(device, (IWineD3DSurface*)This, CTXUSAGE_BLIT);
4250 if (context->render_offscreen)
4252 dst_rect.left = src_rect.left;
4253 dst_rect.right = src_rect.right;
4254 dst_rect.top = src_rect.bottom;
4255 dst_rect.bottom = src_rect.top;
4259 dst_rect = src_rect;
4262 device->blitter->set_shader((IWineD3DDevice *) device, This);
4265 draw_textured_quad(This, &src_rect, &dst_rect, WINED3DTEXF_POINT);
4268 device->blitter->set_shader((IWineD3DDevice *) device, This);
4270 swapchain = (This->Flags & SFLAG_SWAPCHAIN) ? (IWineD3DSwapChainImpl *)This->container : NULL;
4271 if (wined3d_settings.strict_draw_ordering || (swapchain
4272 && ((IWineD3DSurface *)This == swapchain->frontBuffer
4273 || swapchain->num_contexts > 1)))
4274 wglFlush(); /* Flush to ensure ordering across contexts. */
4276 context_release(context);
4279 /*****************************************************************************
4280 * IWineD3DSurface::LoadLocation
4282 * Copies the current surface data from wherever it is to the requested
4283 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
4284 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
4285 * multiple locations, the gl texture is preferred over the drawable, which is
4286 * preferred over system memory. The PBO counts as system memory. If rect is
4287 * not NULL, only the specified rectangle is copied (only supported for
4288 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
4289 * location is marked up to date after the copy.
4292 * flag: Surface location flag to be updated
4293 * rect: rectangle to be copied
4296 * WINED3D_OK on success
4297 * WINED3DERR_DEVICELOST on an internal error
4299 *****************************************************************************/
4300 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
4301 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4302 IWineD3DDeviceImpl *device = This->resource.device;
4303 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4304 struct wined3d_format_desc desc;
4305 CONVERT_TYPES convert;
4306 int width, pitch, outpitch;
4308 BOOL drawable_read_ok = TRUE;
4309 BOOL in_fbo = FALSE;
4311 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4312 if (surface_is_offscreen(iface))
4314 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4315 * Prefer SFLAG_INTEXTURE. */
4316 if (flag == SFLAG_INDRAWABLE) flag = SFLAG_INTEXTURE;
4317 drawable_read_ok = FALSE;
4322 TRACE("Surface %p is an onscreen surface\n", iface);
4326 TRACE("(%p)->(%s, %p)\n", iface, debug_surflocation(flag), rect);
4328 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
4331 if(This->Flags & flag) {
4332 TRACE("Location already up to date\n");
4336 if(!(This->Flags & SFLAG_LOCATIONS)) {
4337 ERR("%p: Surface does not have any up to date location\n", This);
4338 This->Flags |= SFLAG_LOST;
4339 return WINED3DERR_DEVICELOST;
4342 if(flag == SFLAG_INSYSMEM) {
4343 surface_prepare_system_memory(This);
4345 /* Download the surface to system memory */
4346 if (This->Flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX))
4348 struct wined3d_context *context = NULL;
4350 if (!device->isInDraw) context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
4352 surface_bind_and_dirtify(This, !(This->Flags & SFLAG_INTEXTURE));
4353 surface_download_data(This, gl_info);
4355 if (context) context_release(context);
4359 /* Note: It might be faster to download into a texture first. */
4360 read_from_framebuffer(This, rect,
4361 This->resource.allocatedMemory,
4362 IWineD3DSurface_GetPitch(iface));
4364 } else if(flag == SFLAG_INDRAWABLE) {
4365 if(This->Flags & SFLAG_INTEXTURE) {
4366 surface_blt_to_drawable(This, rect);
4369 if((This->Flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX) {
4370 /* This needs a shader to convert the srgb data sampled from the GL texture into RGB
4371 * values, otherwise we get incorrect values in the target. For now go the slow way
4372 * via a system memory copy
4374 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4377 d3dfmt_get_conv(This, FALSE /* We need color keying */, FALSE /* We won't use textures */, &desc, &convert);
4379 /* The width is in 'length' not in bytes */
4380 width = This->currentDesc.Width;
4381 pitch = IWineD3DSurface_GetPitch(iface);
4383 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4384 * but it isn't set (yet) in all cases it is getting called. */
4385 if ((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO))
4387 struct wined3d_context *context = NULL;
4389 TRACE("Removing the pbo attached to surface %p\n", This);
4391 if (!device->isInDraw) context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
4392 surface_remove_pbo(This, gl_info);
4393 if (context) context_release(context);
4396 if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4397 int height = This->currentDesc.Height;
4398 byte_count = desc.conv_byte_count;
4400 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4401 outpitch = width * byte_count;
4402 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4404 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4406 ERR("Out of memory %d, %d!\n", outpitch, height);
4407 return WINED3DERR_OUTOFVIDEOMEMORY;
4409 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4411 This->Flags |= SFLAG_CONVERTED;
4413 This->Flags &= ~SFLAG_CONVERTED;
4414 mem = This->resource.allocatedMemory;
4415 byte_count = desc.byte_count;
4418 flush_to_framebuffer_drawpixels(This, desc.glFormat, desc.glType, byte_count, mem);
4420 /* Don't delete PBO memory */
4421 if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4422 HeapFree(GetProcessHeap(), 0, mem);
4424 } else /* if(flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) */ {
4425 if (drawable_read_ok && (This->Flags & SFLAG_INDRAWABLE)) {
4426 read_from_framebuffer_texture(This, flag == SFLAG_INSRGBTEX);
4430 /* Upload from system memory */
4431 BOOL srgb = flag == SFLAG_INSRGBTEX;
4432 struct wined3d_context *context = NULL;
4434 d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */,
4438 if((This->Flags & (SFLAG_INTEXTURE | SFLAG_INSYSMEM)) == SFLAG_INTEXTURE) {
4439 /* Performance warning ... */
4440 FIXME("%p: Downloading rgb texture to reload it as srgb\n", This);
4441 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4444 if((This->Flags & (SFLAG_INSRGBTEX | SFLAG_INSYSMEM)) == SFLAG_INSRGBTEX) {
4445 /* Performance warning ... */
4446 FIXME("%p: Downloading srgb texture to reload it as rgb\n", This);
4447 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4450 if(!(This->Flags & SFLAG_INSYSMEM)) {
4451 /* Should not happen */
4452 ERR("Trying to load a texture from sysmem, but SFLAG_INSYSMEM is not set\n");
4453 /* Lets hope we get it from somewhere... */
4454 IWineD3DSurfaceImpl_LoadLocation(iface, SFLAG_INSYSMEM, rect);
4457 if (!device->isInDraw) context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
4459 surface_prepare_texture(This, gl_info, srgb);
4460 surface_bind_and_dirtify(This, srgb);
4462 if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
4463 This->Flags |= SFLAG_GLCKEY;
4464 This->glCKey = This->SrcBltCKey;
4466 else This->Flags &= ~SFLAG_GLCKEY;
4468 /* The width is in 'length' not in bytes */
4469 width = This->currentDesc.Width;
4470 pitch = IWineD3DSurface_GetPitch(iface);
4472 /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4473 * but it isn't set (yet) in all cases it is getting called. */
4474 if((convert != NO_CONVERSION) && (This->Flags & SFLAG_PBO)) {
4475 TRACE("Removing the pbo attached to surface %p\n", This);
4476 surface_remove_pbo(This, gl_info);
4480 /* This code is entered for texture formats which need a fixup. */
4481 int height = This->currentDesc.Height;
4483 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4484 outpitch = width * desc.conv_byte_count;
4485 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4487 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4489 ERR("Out of memory %d, %d!\n", outpitch, height);
4490 if (context) context_release(context);
4491 return WINED3DERR_OUTOFVIDEOMEMORY;
4493 desc.convert(This->resource.allocatedMemory, mem, pitch, width, height);
4494 } else if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
4495 /* This code is only entered for color keying fixups */
4496 int height = This->currentDesc.Height;
4498 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4499 outpitch = width * desc.conv_byte_count;
4500 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4502 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4504 ERR("Out of memory %d, %d!\n", outpitch, height);
4505 if (context) context_release(context);
4506 return WINED3DERR_OUTOFVIDEOMEMORY;
4508 d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
4510 mem = This->resource.allocatedMemory;
4513 /* Make sure the correct pitch is used */
4515 glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
4518 if (mem || (This->Flags & SFLAG_PBO))
4520 surface_upload_data(This, gl_info, &desc, srgb,
4521 This->currentDesc.Width, This->currentDesc.Height, mem);
4524 /* Restore the default pitch */
4526 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
4529 if (context) context_release(context);
4531 /* Don't delete PBO memory */
4532 if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
4533 HeapFree(GetProcessHeap(), 0, mem);
4538 This->Flags |= flag;
4541 if (in_fbo && (This->Flags & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE))) {
4542 /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4543 This->Flags |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4549 static HRESULT WINAPI IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container)
4551 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4552 IWineD3DSwapChain *swapchain = NULL;
4554 /* Update the drawable size method */
4556 IWineD3DBase_QueryInterface(container, &IID_IWineD3DSwapChain, (void **) &swapchain);
4559 This->get_drawable_size = get_drawable_size_swapchain;
4560 IWineD3DSwapChain_Release(swapchain);
4561 } else if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
4562 switch(wined3d_settings.offscreen_rendering_mode) {
4563 case ORM_FBO: This->get_drawable_size = get_drawable_size_fbo; break;
4564 case ORM_BACKBUFFER: This->get_drawable_size = get_drawable_size_backbuffer; break;
4568 return IWineD3DBaseSurfaceImpl_SetContainer(iface, container);
4571 static WINED3DSURFTYPE WINAPI IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface *iface) {
4572 return SURFACE_OPENGL;
4575 static HRESULT WINAPI IWineD3DSurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
4576 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4579 /* If there's no destination surface there is nothing to do */
4580 if(!This->overlay_dest) return WINED3D_OK;
4582 /* Blt calls ModifyLocation on the dest surface, which in turn calls DrawOverlay to
4583 * update the overlay. Prevent an endless recursion
4585 if(This->overlay_dest->Flags & SFLAG_INOVERLAYDRAW) {
4588 This->overlay_dest->Flags |= SFLAG_INOVERLAYDRAW;
4589 hr = IWineD3DSurfaceImpl_Blt((IWineD3DSurface *) This->overlay_dest, &This->overlay_destrect,
4590 iface, &This->overlay_srcrect, WINEDDBLT_WAIT,
4591 NULL, WINED3DTEXF_LINEAR);
4592 This->overlay_dest->Flags &= ~SFLAG_INOVERLAYDRAW;
4597 BOOL surface_is_offscreen(IWineD3DSurface *iface)
4599 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4600 IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) This->container;
4602 /* Not on a swapchain - must be offscreen */
4603 if (!(This->Flags & SFLAG_SWAPCHAIN)) return TRUE;
4605 /* The front buffer is always onscreen */
4606 if(iface == swapchain->frontBuffer) return FALSE;
4608 /* If the swapchain is rendered to an FBO, the backbuffer is
4609 * offscreen, otherwise onscreen */
4610 return swapchain->render_to_fbo;
4613 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
4616 IWineD3DBaseSurfaceImpl_QueryInterface,
4617 IWineD3DBaseSurfaceImpl_AddRef,
4618 IWineD3DSurfaceImpl_Release,
4619 /* IWineD3DResource */
4620 IWineD3DBaseSurfaceImpl_GetParent,
4621 IWineD3DBaseSurfaceImpl_SetPrivateData,
4622 IWineD3DBaseSurfaceImpl_GetPrivateData,
4623 IWineD3DBaseSurfaceImpl_FreePrivateData,
4624 IWineD3DBaseSurfaceImpl_SetPriority,
4625 IWineD3DBaseSurfaceImpl_GetPriority,
4626 IWineD3DSurfaceImpl_PreLoad,
4627 IWineD3DSurfaceImpl_UnLoad,
4628 IWineD3DBaseSurfaceImpl_GetType,
4629 /* IWineD3DSurface */
4630 IWineD3DBaseSurfaceImpl_GetContainer,
4631 IWineD3DBaseSurfaceImpl_GetDesc,
4632 IWineD3DSurfaceImpl_LockRect,
4633 IWineD3DSurfaceImpl_UnlockRect,
4634 IWineD3DSurfaceImpl_GetDC,
4635 IWineD3DSurfaceImpl_ReleaseDC,
4636 IWineD3DSurfaceImpl_Flip,
4637 IWineD3DSurfaceImpl_Blt,
4638 IWineD3DBaseSurfaceImpl_GetBltStatus,
4639 IWineD3DBaseSurfaceImpl_GetFlipStatus,
4640 IWineD3DBaseSurfaceImpl_IsLost,
4641 IWineD3DBaseSurfaceImpl_Restore,
4642 IWineD3DSurfaceImpl_BltFast,
4643 IWineD3DBaseSurfaceImpl_GetPalette,
4644 IWineD3DBaseSurfaceImpl_SetPalette,
4645 IWineD3DSurfaceImpl_RealizePalette,
4646 IWineD3DBaseSurfaceImpl_SetColorKey,
4647 IWineD3DBaseSurfaceImpl_GetPitch,
4648 IWineD3DSurfaceImpl_SetMem,
4649 IWineD3DBaseSurfaceImpl_SetOverlayPosition,
4650 IWineD3DBaseSurfaceImpl_GetOverlayPosition,
4651 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
4652 IWineD3DBaseSurfaceImpl_UpdateOverlay,
4653 IWineD3DBaseSurfaceImpl_SetClipper,
4654 IWineD3DBaseSurfaceImpl_GetClipper,
4656 IWineD3DSurfaceImpl_LoadTexture,
4657 IWineD3DSurfaceImpl_BindTexture,
4658 IWineD3DSurfaceImpl_SaveSnapshot,
4659 IWineD3DSurfaceImpl_SetContainer,
4660 IWineD3DBaseSurfaceImpl_GetData,
4661 IWineD3DSurfaceImpl_SetFormat,
4662 IWineD3DSurfaceImpl_PrivateSetup,
4663 IWineD3DSurfaceImpl_ModifyLocation,
4664 IWineD3DSurfaceImpl_LoadLocation,
4665 IWineD3DSurfaceImpl_GetImplType,
4666 IWineD3DSurfaceImpl_DrawOverlay
4669 static HRESULT ffp_blit_alloc(IWineD3DDevice *iface) { return WINED3D_OK; }
4670 /* Context activation is done by the caller. */
4671 static void ffp_blit_free(IWineD3DDevice *iface) { }
4673 /* This function is used in case of 8bit paletted textures using GL_EXT_paletted_texture */
4674 /* Context activation is done by the caller. */
4675 static void ffp_blit_p8_upload_palette(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info)
4678 BOOL colorkey_active = (surface->CKeyFlags & WINEDDSD_CKSRCBLT) ? TRUE : FALSE;
4680 d3dfmt_p8_init_palette(surface, table, colorkey_active);
4682 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
4684 GL_EXTCALL(glColorTableEXT(surface->texture_target, GL_RGBA, 256, GL_RGBA, GL_UNSIGNED_BYTE, table));
4688 /* Context activation is done by the caller. */
4689 static HRESULT ffp_blit_set(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surface)
4691 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
4692 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4693 enum complex_fixup fixup = get_complex_fixup(surface->resource.format_desc->color_fixup);
4695 /* When EXT_PALETTED_TEXTURE is around, palette conversion is done by the GPU
4696 * else the surface is converted in software at upload time in LoadLocation.
4698 if(fixup == COMPLEX_FIXUP_P8 && gl_info->supported[EXT_PALETTED_TEXTURE])
4699 ffp_blit_p8_upload_palette(surface, gl_info);
4702 glEnable(surface->texture_target);
4703 checkGLcall("glEnable(surface->texture_target)");
4708 /* Context activation is done by the caller. */
4709 static void ffp_blit_unset(IWineD3DDevice *iface)
4711 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
4712 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4715 glDisable(GL_TEXTURE_2D);
4716 checkGLcall("glDisable(GL_TEXTURE_2D)");
4717 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4719 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
4720 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
4722 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
4724 glDisable(GL_TEXTURE_RECTANGLE_ARB);
4725 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
4730 static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
4731 const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
4732 const struct wined3d_format_desc *src_format_desc,
4733 const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
4734 const struct wined3d_format_desc *dst_format_desc)
4736 enum complex_fixup src_fixup;
4738 if (blit_op == BLIT_OP_COLOR_FILL)
4740 if (!(dst_usage & WINED3DUSAGE_RENDERTARGET))
4742 TRACE("Color fill not supported\n");
4749 src_fixup = get_complex_fixup(src_format_desc->color_fixup);
4750 if (TRACE_ON(d3d_surface) && TRACE_ON(d3d))
4752 TRACE("Checking support for fixup:\n");
4753 dump_color_fixup_desc(src_format_desc->color_fixup);
4756 if (blit_op != BLIT_OP_BLIT)
4758 TRACE("Unsupported blit_op=%d\n", blit_op);
4762 if (!is_identity_fixup(dst_format_desc->color_fixup))
4764 TRACE("Destination fixups are not supported\n");
4768 if (src_fixup == COMPLEX_FIXUP_P8 && gl_info->supported[EXT_PALETTED_TEXTURE])
4770 TRACE("P8 fixup supported\n");
4774 /* We only support identity conversions. */
4775 if (is_identity_fixup(src_format_desc->color_fixup))
4781 TRACE("[FAILED]\n");
4785 static HRESULT ffp_blit_color_fill(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect, DWORD fill_color)
4787 return IWineD3DDeviceImpl_ClearSurface(device, dst_surface, 1 /* Number of rectangles */,
4788 (const WINED3DRECT*)dst_rect, WINED3DCLEAR_TARGET, fill_color, 0.0f /* Z */, 0 /* Stencil */);
4791 const struct blit_shader ffp_blit = {
4800 static HRESULT cpu_blit_alloc(IWineD3DDevice *iface)
4805 /* Context activation is done by the caller. */
4806 static void cpu_blit_free(IWineD3DDevice *iface)
4810 /* Context activation is done by the caller. */
4811 static HRESULT cpu_blit_set(IWineD3DDevice *iface, IWineD3DSurfaceImpl *surface)
4816 /* Context activation is done by the caller. */
4817 static void cpu_blit_unset(IWineD3DDevice *iface)
4821 static BOOL cpu_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
4822 const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
4823 const struct wined3d_format_desc *src_format_desc,
4824 const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
4825 const struct wined3d_format_desc *dst_format_desc)
4827 if (blit_op == BLIT_OP_COLOR_FILL)
4835 static HRESULT cpu_blit_color_fill(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect, DWORD fill_color)
4838 memset(&BltFx, 0, sizeof(BltFx));
4839 BltFx.dwSize = sizeof(BltFx);
4840 BltFx.u5.dwFillColor = color_convert_argb_to_fmt(fill_color, dst_surface->resource.format_desc->format);
4841 return IWineD3DBaseSurfaceImpl_Blt((IWineD3DSurface*)dst_surface, dst_rect, NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
4844 const struct blit_shader cpu_blit = {
4853 static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
4854 const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool,
4855 const struct wined3d_format_desc *src_format_desc,
4856 const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool,
4857 const struct wined3d_format_desc *dst_format_desc)
4859 if ((wined3d_settings.offscreen_rendering_mode != ORM_FBO) || !gl_info->fbo_ops.glBlitFramebuffer)
4862 /* We only support blitting. Things like color keying / color fill should
4863 * be handled by other blitters.
4865 if (blit_op != BLIT_OP_BLIT)
4868 /* Source and/or destination need to be on the GL side */
4869 if (src_pool == WINED3DPOOL_SYSTEMMEM || dst_pool == WINED3DPOOL_SYSTEMMEM)
4872 if(!((src_format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (src_usage & WINED3DUSAGE_RENDERTARGET))
4873 && ((dst_format_desc->Flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (dst_usage & WINED3DUSAGE_RENDERTARGET)))
4876 if (!is_identity_fixup(src_format_desc->color_fixup) ||
4877 !is_identity_fixup(dst_format_desc->color_fixup))
4880 if (!(src_format_desc->format == dst_format_desc->format
4881 || (is_identity_fixup(src_format_desc->color_fixup)
4882 && is_identity_fixup(dst_format_desc->color_fixup))))