wined3d: Get rid of ENTER_GL / LEAVE_GL.
[wine] / dlls / wined3d / swapchain.c
1 /*
2  * Copyright 2002-2003 Jason Edmeades
3  * Copyright 2002-2003 Raphael Junqueira
4  * Copyright 2005 Oliver Stieber
5  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
6  * Copyright 2011 Henri Verbeet for CodeWeavers
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25 #include "wined3d_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
28 WINE_DECLARE_DEBUG_CHANNEL(fps);
29
30 /* Do not call while under the GL lock. */
31 static void swapchain_cleanup(struct wined3d_swapchain *swapchain)
32 {
33     struct wined3d_display_mode mode;
34     HRESULT hr;
35     UINT i;
36
37     TRACE("Destroying swapchain %p.\n", swapchain);
38
39     wined3d_swapchain_set_gamma_ramp(swapchain, 0, &swapchain->orig_gamma);
40
41     /* Release the swapchain's draw buffers. Make sure swapchain->back_buffers[0]
42      * is the last buffer to be destroyed, FindContext() depends on that. */
43     if (swapchain->front_buffer)
44     {
45         if (swapchain->front_buffer->container.type == WINED3D_CONTAINER_SWAPCHAIN)
46             surface_set_container(swapchain->front_buffer, WINED3D_CONTAINER_NONE, NULL);
47         if (wined3d_surface_decref(swapchain->front_buffer))
48             WARN("Something's still holding the front buffer (%p).\n", swapchain->front_buffer);
49         swapchain->front_buffer = NULL;
50     }
51
52     if (swapchain->back_buffers)
53     {
54         i = swapchain->desc.backbuffer_count;
55
56         while (i--)
57         {
58             if (swapchain->back_buffers[i]->container.type == WINED3D_CONTAINER_SWAPCHAIN)
59                 surface_set_container(swapchain->back_buffers[i], WINED3D_CONTAINER_NONE, NULL);
60             if (wined3d_surface_decref(swapchain->back_buffers[i]))
61                 WARN("Something's still holding back buffer %u (%p).\n", i, swapchain->back_buffers[i]);
62         }
63         HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);
64         swapchain->back_buffers = NULL;
65     }
66
67     for (i = 0; i < swapchain->num_contexts; ++i)
68     {
69         context_destroy(swapchain->device, swapchain->context[i]);
70     }
71     HeapFree(GetProcessHeap(), 0, swapchain->context);
72
73     /* Restore the screen resolution if we rendered in fullscreen.
74      * This will restore the screen resolution to what it was before creating
75      * the swapchain. In case of d3d8 and d3d9 this will be the original
76      * desktop resolution. In case of d3d7 this will be a NOP because ddraw
77      * sets the resolution before starting up Direct3D, thus orig_width and
78      * orig_height will be equal to the modes in the presentation params. */
79     if (!swapchain->desc.windowed && swapchain->desc.auto_restore_display_mode)
80     {
81         mode.width = swapchain->orig_width;
82         mode.height = swapchain->orig_height;
83         mode.refresh_rate = 0;
84         mode.format_id = swapchain->orig_fmt;
85         mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
86         if (FAILED(hr = wined3d_set_adapter_display_mode(swapchain->device->wined3d,
87                 swapchain->device->adapter->ordinal, &mode)))
88             ERR("Failed to restore display mode, hr %#x.\n", hr);
89     }
90
91     if (swapchain->backup_dc)
92     {
93         TRACE("Destroying backup wined3d window %p, dc %p.\n", swapchain->backup_wnd, swapchain->backup_dc);
94
95         ReleaseDC(swapchain->backup_wnd, swapchain->backup_dc);
96         DestroyWindow(swapchain->backup_wnd);
97     }
98 }
99
100 ULONG CDECL wined3d_swapchain_incref(struct wined3d_swapchain *swapchain)
101 {
102     ULONG refcount = InterlockedIncrement(&swapchain->ref);
103
104     TRACE("%p increasing refcount to %u.\n", swapchain, refcount);
105
106     return refcount;
107 }
108
109 /* Do not call while under the GL lock. */
110 ULONG CDECL wined3d_swapchain_decref(struct wined3d_swapchain *swapchain)
111 {
112     ULONG refcount = InterlockedDecrement(&swapchain->ref);
113
114     TRACE("%p decreasing refcount to %u.\n", swapchain, refcount);
115
116     if (!refcount)
117     {
118         swapchain_cleanup(swapchain);
119         swapchain->parent_ops->wined3d_object_destroyed(swapchain->parent);
120         HeapFree(GetProcessHeap(), 0, swapchain);
121     }
122
123     return refcount;
124 }
125
126 void * CDECL wined3d_swapchain_get_parent(const struct wined3d_swapchain *swapchain)
127 {
128     TRACE("swapchain %p.\n", swapchain);
129
130     return swapchain->parent;
131 }
132
133 void CDECL wined3d_swapchain_set_window(struct wined3d_swapchain *swapchain, HWND window)
134 {
135     if (!window)
136         window = swapchain->device_window;
137     if (window == swapchain->win_handle)
138         return;
139
140     TRACE("Setting swapchain %p window from %p to %p.\n",
141             swapchain, swapchain->win_handle, window);
142     swapchain->win_handle = window;
143 }
144
145 HRESULT CDECL wined3d_swapchain_present(struct wined3d_swapchain *swapchain,
146         const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override,
147         const RGNDATA *dirty_region, DWORD flags)
148 {
149     TRACE("swapchain %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p, flags %#x.\n",
150             swapchain, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect),
151             dst_window_override, dirty_region, flags);
152
153     if (flags)
154         FIXME("Ignoring flags %#x.\n", flags);
155
156     if (!swapchain->back_buffers)
157     {
158         WARN("Swapchain doesn't have a backbuffer, returning WINED3DERR_INVALIDCALL\n");
159         return WINED3DERR_INVALIDCALL;
160     }
161
162     wined3d_swapchain_set_window(swapchain, dst_window_override);
163
164     swapchain->swapchain_ops->swapchain_present(swapchain, src_rect, dst_rect, dirty_region, flags);
165
166     return WINED3D_OK;
167 }
168
169 HRESULT CDECL wined3d_swapchain_get_front_buffer_data(const struct wined3d_swapchain *swapchain,
170         struct wined3d_surface *dst_surface)
171 {
172     struct wined3d_surface *src_surface;
173     RECT src_rect, dst_rect;
174
175     TRACE("swapchain %p, dst_surface %p.\n", swapchain, dst_surface);
176
177     src_surface = swapchain->front_buffer;
178     SetRect(&src_rect, 0, 0, src_surface->resource.width, src_surface->resource.height);
179     dst_rect = src_rect;
180
181     if (swapchain->desc.windowed)
182     {
183         MapWindowPoints(swapchain->win_handle, NULL, (POINT *)&dst_rect, 2);
184         FIXME("Using destination rect %s in windowed mode, this is likely wrong.\n",
185                 wine_dbgstr_rect(&dst_rect));
186     }
187
188     return wined3d_surface_blt(dst_surface, &dst_rect, src_surface, &src_rect, 0, NULL, WINED3D_TEXF_POINT);
189 }
190
191 struct wined3d_surface * CDECL wined3d_swapchain_get_back_buffer(const struct wined3d_swapchain *swapchain,
192         UINT back_buffer_idx, enum wined3d_backbuffer_type type)
193 {
194     TRACE("swapchain %p, back_buffer_idx %u, type %#x.\n",
195             swapchain, back_buffer_idx, type);
196
197     /* Return invalid if there is no backbuffer array, otherwise it will
198      * crash when ddraw is used (there swapchain->back_buffers is always
199      * NULL). We need this because this function is called from
200      * stateblock_init_default_state() to get the default scissorrect
201      * dimensions. */
202     if (!swapchain->back_buffers || back_buffer_idx >= swapchain->desc.backbuffer_count)
203     {
204         WARN("Invalid back buffer index.\n");
205         /* Native d3d9 doesn't set NULL here, just as wine's d3d9. But set it
206          * here in wined3d to avoid problems in other libs. */
207         return NULL;
208     }
209
210     TRACE("Returning back buffer %p.\n", swapchain->back_buffers[back_buffer_idx]);
211
212     return swapchain->back_buffers[back_buffer_idx];
213 }
214
215 HRESULT CDECL wined3d_swapchain_get_raster_status(const struct wined3d_swapchain *swapchain,
216         struct wined3d_raster_status *raster_status)
217 {
218     TRACE("swapchain %p, raster_status %p.\n", swapchain, raster_status);
219
220     return wined3d_get_adapter_raster_status(swapchain->device->wined3d,
221             swapchain->device->adapter->ordinal, raster_status);
222 }
223
224 HRESULT CDECL wined3d_swapchain_get_display_mode(const struct wined3d_swapchain *swapchain,
225         struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation)
226 {
227     HRESULT hr;
228
229     TRACE("swapchain %p, mode %p, rotation %p.\n", swapchain, mode, rotation);
230
231     hr = wined3d_get_adapter_display_mode(swapchain->device->wined3d,
232             swapchain->device->adapter->ordinal, mode, rotation);
233
234     TRACE("Returning w %u, h %u, refresh rate %u, format %s.\n",
235             mode->width, mode->height, mode->refresh_rate, debug_d3dformat(mode->format_id));
236
237     return hr;
238 }
239
240 struct wined3d_device * CDECL wined3d_swapchain_get_device(const struct wined3d_swapchain *swapchain)
241 {
242     TRACE("swapchain %p.\n", swapchain);
243
244     return swapchain->device;
245 }
246
247 void CDECL wined3d_swapchain_get_desc(const struct wined3d_swapchain *swapchain,
248         struct wined3d_swapchain_desc *desc)
249 {
250     TRACE("swapchain %p, desc %p.\n", swapchain, desc);
251
252     *desc = swapchain->desc;
253 }
254
255 HRESULT CDECL wined3d_swapchain_set_gamma_ramp(const struct wined3d_swapchain *swapchain,
256         DWORD flags, const struct wined3d_gamma_ramp *ramp)
257 {
258     HDC dc;
259
260     TRACE("swapchain %p, flags %#x, ramp %p.\n", swapchain, flags, ramp);
261
262     if (flags)
263         FIXME("Ignoring flags %#x.\n", flags);
264
265     dc = GetDC(swapchain->device_window);
266     SetDeviceGammaRamp(dc, (void *)ramp);
267     ReleaseDC(swapchain->device_window, dc);
268
269     return WINED3D_OK;
270 }
271
272 HRESULT CDECL wined3d_swapchain_get_gamma_ramp(const struct wined3d_swapchain *swapchain,
273         struct wined3d_gamma_ramp *ramp)
274 {
275     HDC dc;
276
277     TRACE("swapchain %p, ramp %p.\n", swapchain, ramp);
278
279     dc = GetDC(swapchain->device_window);
280     GetDeviceGammaRamp(dc, ramp);
281     ReleaseDC(swapchain->device_window, dc);
282
283     return WINED3D_OK;
284 }
285
286 /* A GL context is provided by the caller */
287 static void swapchain_blit(const struct wined3d_swapchain *swapchain,
288         struct wined3d_context *context, const RECT *src_rect, const RECT *dst_rect)
289 {
290     struct wined3d_surface *backbuffer = swapchain->back_buffers[0];
291     UINT src_w = src_rect->right - src_rect->left;
292     UINT src_h = src_rect->bottom - src_rect->top;
293     GLenum gl_filter;
294     const struct wined3d_gl_info *gl_info = context->gl_info;
295     RECT win_rect;
296     UINT win_h;
297
298     TRACE("swapchain %p, context %p, src_rect %s, dst_rect %s.\n",
299             swapchain, context, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect));
300
301     if (src_w == dst_rect->right - dst_rect->left && src_h == dst_rect->bottom - dst_rect->top)
302         gl_filter = GL_NEAREST;
303     else
304         gl_filter = GL_LINEAR;
305
306     GetClientRect(swapchain->win_handle, &win_rect);
307     win_h = win_rect.bottom - win_rect.top;
308
309     if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format->color_fixup))
310     {
311         DWORD location = SFLAG_INTEXTURE;
312
313         if (backbuffer->resource.multisample_type)
314         {
315             location = SFLAG_INRB_RESOLVED;
316             surface_load_location(backbuffer, location, NULL);
317         }
318
319         context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, backbuffer, NULL, location);
320         gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0);
321         context_check_fbo_status(context, GL_READ_FRAMEBUFFER);
322
323         context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE);
324         context_set_draw_buffer(context, GL_BACK);
325         context_invalidate_state(context, STATE_FRAMEBUFFER);
326
327         gl_info->gl_ops.gl.p_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
328         context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
329         context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
330         context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
331         context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
332
333         gl_info->gl_ops.gl.p_glDisable(GL_SCISSOR_TEST);
334         context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
335
336         /* Note that the texture is upside down */
337         gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom,
338                 dst_rect->left, win_h - dst_rect->top, dst_rect->right, win_h - dst_rect->bottom,
339                 GL_COLOR_BUFFER_BIT, gl_filter);
340         checkGLcall("Swapchain present blit(EXT_framebuffer_blit)\n");
341     }
342     else
343     {
344         struct wined3d_device *device = swapchain->device;
345         struct wined3d_context *context2;
346         float tex_left = src_rect->left;
347         float tex_top = src_rect->top;
348         float tex_right = src_rect->right;
349         float tex_bottom = src_rect->bottom;
350
351         context2 = context_acquire(device, swapchain->back_buffers[0]);
352         context_apply_blit_state(context2, device);
353
354         if (backbuffer->flags & SFLAG_NORMCOORD)
355         {
356             tex_left /= src_w;
357             tex_right /= src_w;
358             tex_top /= src_h;
359             tex_bottom /= src_h;
360         }
361
362         if (is_complex_fixup(backbuffer->resource.format->color_fixup))
363             gl_filter = GL_NEAREST;
364
365         context_apply_fbo_state_blit(context2, GL_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE);
366         context_bind_texture(context2, backbuffer->texture_target, backbuffer->texture_name);
367
368         /* Set up the texture. The surface is not in a wined3d_texture
369          * container, so there are no D3D texture settings to dirtify. */
370         device->blitter->set_shader(device->blit_priv, context2, backbuffer);
371         gl_info->gl_ops.gl.p_glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MIN_FILTER, gl_filter);
372         gl_info->gl_ops.gl.p_glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MAG_FILTER, gl_filter);
373
374         context_set_draw_buffer(context, GL_BACK);
375
376         /* Set the viewport to the destination rectandle, disable any projection
377          * transformation set up by context_apply_blit_state(), and draw a
378          * (-1,-1)-(1,1) quad.
379          *
380          * Back up viewport and matrix to avoid breaking last_was_blit
381          *
382          * Note that context_apply_blit_state() set up viewport and ortho to
383          * match the surface size - we want the GL drawable(=window) size. */
384         gl_info->gl_ops.gl.p_glPushAttrib(GL_VIEWPORT_BIT);
385         gl_info->gl_ops.gl.p_glViewport(dst_rect->left, win_h - dst_rect->bottom,
386                 dst_rect->right, win_h - dst_rect->top);
387         gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
388         gl_info->gl_ops.gl.p_glPushMatrix();
389         gl_info->gl_ops.gl.p_glLoadIdentity();
390
391         gl_info->gl_ops.gl.p_glBegin(GL_QUADS);
392             /* bottom left */
393             gl_info->gl_ops.gl.p_glTexCoord2f(tex_left, tex_bottom);
394             gl_info->gl_ops.gl.p_glVertex2i(-1, -1);
395
396             /* top left */
397             gl_info->gl_ops.gl.p_glTexCoord2f(tex_left, tex_top);
398             gl_info->gl_ops.gl.p_glVertex2i(-1, 1);
399
400             /* top right */
401             gl_info->gl_ops.gl.p_glTexCoord2f(tex_right, tex_top);
402             gl_info->gl_ops.gl.p_glVertex2i(1, 1);
403
404             /* bottom right */
405             gl_info->gl_ops.gl.p_glTexCoord2f(tex_right, tex_bottom);
406             gl_info->gl_ops.gl.p_glVertex2i(1, -1);
407         gl_info->gl_ops.gl.p_glEnd();
408
409         gl_info->gl_ops.gl.p_glPopMatrix();
410         gl_info->gl_ops.gl.p_glPopAttrib();
411
412         device->blitter->unset_shader(context->gl_info);
413         checkGLcall("Swapchain present blit(manual)\n");
414
415         context_release(context2);
416     }
417 }
418
419 static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT *src_rect_in,
420         const RECT *dst_rect_in, const RGNDATA *dirty_region, DWORD flags)
421 {
422     struct wined3d_surface *back_buffer = swapchain->back_buffers[0];
423     const struct wined3d_fb_state *fb = &swapchain->device->fb;
424     const struct wined3d_gl_info *gl_info;
425     struct wined3d_context *context;
426     RECT src_rect, dst_rect;
427     BOOL render_to_fbo;
428
429     context = context_acquire(swapchain->device, back_buffer);
430     if (!context->valid)
431     {
432         context_release(context);
433         WARN("Invalid context, skipping present.\n");
434         return;
435     }
436
437     gl_info = context->gl_info;
438
439     /* Render the cursor onto the back buffer, using our nifty directdraw blitting code :-) */
440     if (swapchain->device->bCursorVisible &&
441         swapchain->device->cursorTexture &&
442         !swapchain->device->hardwareCursor)
443     {
444         struct wined3d_surface cursor;
445         RECT destRect =
446         {
447             swapchain->device->xScreenSpace - swapchain->device->xHotSpot,
448             swapchain->device->yScreenSpace - swapchain->device->yHotSpot,
449             swapchain->device->xScreenSpace + swapchain->device->cursorWidth - swapchain->device->xHotSpot,
450             swapchain->device->yScreenSpace + swapchain->device->cursorHeight - swapchain->device->yHotSpot,
451         };
452         TRACE("Rendering the cursor. Creating fake surface at %p\n", &cursor);
453         /* Build a fake surface to call the Blitting code. It is not possible to use the interface passed by
454          * the application because we are only supposed to copy the information out. Using a fake surface
455          * allows us to use the Blitting engine and avoid copying the whole texture -> render target blitting code.
456          */
457         memset(&cursor, 0, sizeof(cursor));
458         cursor.resource.ref = 1;
459         cursor.resource.device = swapchain->device;
460         cursor.resource.pool = WINED3D_POOL_SCRATCH;
461         cursor.resource.format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
462         cursor.resource.type = WINED3D_RTYPE_SURFACE;
463         cursor.texture_name = swapchain->device->cursorTexture;
464         cursor.texture_target = GL_TEXTURE_2D;
465         cursor.texture_level = 0;
466         cursor.resource.width = swapchain->device->cursorWidth;
467         cursor.resource.height = swapchain->device->cursorHeight;
468         /* The cursor must have pow2 sizes */
469         cursor.pow2Width = cursor.resource.width;
470         cursor.pow2Height = cursor.resource.height;
471         /* The surface is in the texture */
472         cursor.flags |= SFLAG_INTEXTURE;
473         /* DDBLT_KEYSRC will cause BltOverride to enable the alpha test with GL_NOTEQUAL, 0.0,
474          * which is exactly what we want :-)
475          */
476         if (swapchain->desc.windowed)
477             MapWindowPoints(NULL, swapchain->win_handle, (POINT *)&destRect, 2);
478         wined3d_surface_blt(back_buffer, &destRect, &cursor, NULL, WINEDDBLT_KEYSRC,
479                 NULL, WINED3D_TEXF_POINT);
480     }
481
482     if (swapchain->device->logo_surface)
483     {
484         struct wined3d_surface *src_surface = swapchain->device->logo_surface;
485         RECT rect = {0, 0, src_surface->resource.width, src_surface->resource.height};
486
487         /* Blit the logo into the upper left corner of the drawable. */
488         wined3d_surface_blt(back_buffer, &rect, src_surface, &rect, WINEDDBLT_KEYSRC,
489                 NULL, WINED3D_TEXF_POINT);
490     }
491
492     TRACE("Presenting HDC %p.\n", context->hdc);
493
494     render_to_fbo = swapchain->render_to_fbo;
495
496     if (src_rect_in)
497     {
498         src_rect = *src_rect_in;
499         if (!render_to_fbo && (src_rect.left || src_rect.top
500                 || src_rect.right != swapchain->desc.backbuffer_width
501                 || src_rect.bottom != swapchain->desc.backbuffer_height))
502         {
503             render_to_fbo = TRUE;
504         }
505     }
506     else
507     {
508         src_rect.left = 0;
509         src_rect.top = 0;
510         src_rect.right = swapchain->desc.backbuffer_width;
511         src_rect.bottom = swapchain->desc.backbuffer_height;
512     }
513
514     if (dst_rect_in)
515         dst_rect = *dst_rect_in;
516     else
517         GetClientRect(swapchain->win_handle, &dst_rect);
518
519     if (!render_to_fbo && (dst_rect.left || dst_rect.top
520             || dst_rect.right != swapchain->desc.backbuffer_width
521             || dst_rect.bottom != swapchain->desc.backbuffer_height))
522         render_to_fbo = TRUE;
523
524     /* Rendering to a window of different size, presenting partial rectangles,
525      * or rendering to a different window needs help from FBO_blit or a textured
526      * draw. Render the swapchain to a FBO in the future.
527      *
528      * Note that FBO_blit from the backbuffer to the frontbuffer cannot solve
529      * all these issues - this fails if the window is smaller than the backbuffer.
530      */
531     if (!swapchain->render_to_fbo && render_to_fbo && wined3d_settings.offscreen_rendering_mode == ORM_FBO)
532     {
533         surface_load_location(back_buffer, SFLAG_INTEXTURE, NULL);
534         surface_modify_location(back_buffer, SFLAG_INDRAWABLE, FALSE);
535         swapchain->render_to_fbo = TRUE;
536         swapchain_update_draw_bindings(swapchain);
537     }
538     else
539     {
540         surface_load_location(back_buffer, back_buffer->draw_binding, NULL);
541     }
542
543     if (swapchain->render_to_fbo)
544     {
545         /* This codepath should only be hit with the COPY swapeffect. Otherwise a backbuffer-
546          * window size mismatch is impossible(fullscreen) and src and dst rectangles are
547          * not allowed(they need the COPY swapeffect)
548          *
549          * The DISCARD swap effect is ok as well since any backbuffer content is allowed after
550          * the swap. */
551         if (swapchain->desc.swap_effect == WINED3D_SWAP_EFFECT_FLIP)
552             FIXME("Render-to-fbo with WINED3D_SWAP_EFFECT_FLIP\n");
553
554         swapchain_blit(swapchain, context, &src_rect, &dst_rect);
555     }
556
557     if (swapchain->num_contexts > 1)
558         gl_info->gl_ops.gl.p_glFinish();
559
560     /* call wglSwapBuffers through the gl table to avoid confusing the Steam overlay */
561     gl_info->gl_ops.wgl.p_wglSwapBuffers(context->hdc); /* TODO: cycle through the swapchain buffers */
562
563     TRACE("SwapBuffers called, Starting new frame\n");
564     /* FPS support */
565     if (TRACE_ON(fps))
566     {
567         DWORD time = GetTickCount();
568         ++swapchain->frames;
569
570         /* every 1.5 seconds */
571         if (time - swapchain->prev_time > 1500)
572         {
573             TRACE_(fps)("%p @ approx %.2ffps\n",
574                     swapchain, 1000.0 * swapchain->frames / (time - swapchain->prev_time));
575             swapchain->prev_time = time;
576             swapchain->frames = 0;
577         }
578     }
579
580     /* This is disabled, but the code left in for debug purposes.
581      *
582      * Since we're allowed to modify the new back buffer on a D3DSWAPEFFECT_DISCARD flip,
583      * we can clear it with some ugly color to make bad drawing visible and ease debugging.
584      * The Debug runtime does the same on Windows. However, a few games do not redraw the
585      * screen properly, like Max Payne 2, which leaves a few pixels undefined.
586      *
587      * Tests show that the content of the back buffer after a discard flip is indeed not
588      * reliable, so no game can depend on the exact content. However, it resembles the
589      * old contents in some way, for example by showing fragments at other locations. In
590      * general, the color theme is still intact. So Max payne, which draws rather dark scenes
591      * gets a dark background image. If we clear it with a bright ugly color, the game's
592      * bug shows up much more than it does on Windows, and the players see single pixels
593      * with wrong colors.
594      * (The Max Payne bug has been confirmed on Windows with the debug runtime) */
595     if (FALSE && swapchain->desc.swap_effect == WINED3D_SWAP_EFFECT_DISCARD)
596     {
597         static const struct wined3d_color cyan = {0.0f, 1.0f, 1.0f, 1.0f};
598
599         TRACE("Clearing the color buffer with cyan color\n");
600
601         wined3d_device_clear(swapchain->device, 0, NULL,
602                 WINED3DCLEAR_TARGET, &cyan, 1.0f, 0);
603     }
604
605     if (!swapchain->render_to_fbo && ((swapchain->front_buffer->flags & SFLAG_INSYSMEM)
606             || (back_buffer->flags & SFLAG_INSYSMEM)))
607     {
608         /* Both memory copies of the surfaces are ok, flip them around too instead of dirtifying
609          * Doesn't work with render_to_fbo because we're not flipping
610          */
611         struct wined3d_surface *front = swapchain->front_buffer;
612
613         if (front->resource.size == back_buffer->resource.size)
614         {
615             DWORD fbflags;
616             flip_surface(front, back_buffer);
617
618             /* Tell the front buffer surface that is has been modified. However,
619              * the other locations were preserved during that, so keep the flags.
620              * This serves to update the emulated overlay, if any. */
621             fbflags = front->flags;
622             surface_modify_location(front, SFLAG_INDRAWABLE, TRUE);
623             front->flags = fbflags;
624         }
625         else
626         {
627             surface_modify_location(front, SFLAG_INDRAWABLE, TRUE);
628             surface_modify_location(back_buffer, SFLAG_INDRAWABLE, TRUE);
629         }
630     }
631     else
632     {
633         surface_modify_location(swapchain->front_buffer, SFLAG_INDRAWABLE, TRUE);
634         /* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM
635          * and INTEXTURE copies can keep their old content if they have any defined content.
636          * If the swapeffect is COPY, the content remains the same. If it is FLIP however,
637          * the texture / sysmem copy needs to be reloaded from the drawable
638          */
639         if (swapchain->desc.swap_effect == WINED3D_SWAP_EFFECT_FLIP)
640             surface_modify_location(back_buffer, back_buffer->draw_binding, TRUE);
641     }
642
643     if (fb->depth_stencil)
644     {
645         if (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
646                 || fb->depth_stencil->flags & SFLAG_DISCARD)
647         {
648             surface_modify_ds_location(fb->depth_stencil, SFLAG_DISCARDED,
649                     fb->depth_stencil->resource.width,
650                     fb->depth_stencil->resource.height);
651             if (fb->depth_stencil == swapchain->device->onscreen_depth_stencil)
652             {
653                 wined3d_surface_decref(swapchain->device->onscreen_depth_stencil);
654                 swapchain->device->onscreen_depth_stencil = NULL;
655             }
656         }
657     }
658
659     context_release(context);
660 }
661
662 static const struct wined3d_swapchain_ops swapchain_gl_ops =
663 {
664     swapchain_gl_present,
665 };
666
667 /* Helper function that blits the front buffer contents to the target window. */
668 void x11_copy_to_screen(const struct wined3d_swapchain *swapchain, const RECT *rect)
669 {
670     const struct wined3d_surface *front;
671     POINT offset = {0, 0};
672     HDC src_dc, dst_dc;
673     RECT draw_rect;
674     HWND window;
675
676     TRACE("swapchain %p, rect %s.\n", swapchain, wine_dbgstr_rect(rect));
677
678     front = swapchain->front_buffer;
679     if (!(front->resource.usage & WINED3DUSAGE_RENDERTARGET))
680         return;
681
682     if (front->resource.map_count)
683         ERR("Trying to blit a mapped surface.\n");
684
685     TRACE("Copying surface %p to screen.\n", front);
686
687     src_dc = front->hDC;
688     window = swapchain->win_handle;
689     dst_dc = GetDCEx(window, 0, DCX_CLIPSIBLINGS | DCX_CACHE);
690
691     /* Front buffer coordinates are screen coordinates. Map them to the
692      * destination window if not fullscreened. */
693     if (swapchain->desc.windowed)
694         ClientToScreen(window, &offset);
695
696     TRACE("offset %s.\n", wine_dbgstr_point(&offset));
697
698     draw_rect.left = 0;
699     draw_rect.right = front->resource.width;
700     draw_rect.top = 0;
701     draw_rect.bottom = front->resource.height;
702
703     if (rect)
704         IntersectRect(&draw_rect, &draw_rect, rect);
705
706     BitBlt(dst_dc, draw_rect.left - offset.x, draw_rect.top - offset.y,
707             draw_rect.right - draw_rect.left, draw_rect.bottom - draw_rect.top,
708             src_dc, draw_rect.left, draw_rect.top, SRCCOPY);
709     ReleaseDC(window, dst_dc);
710 }
711
712 static void swapchain_gdi_present(struct wined3d_swapchain *swapchain, const RECT *src_rect_in,
713         const RECT *dst_rect_in, const RGNDATA *dirty_region, DWORD flags)
714 {
715     struct wined3d_surface *front, *back;
716
717     front = swapchain->front_buffer;
718     back = swapchain->back_buffers[0];
719
720     /* Flip the DC. */
721     {
722         HDC tmp;
723         tmp = front->hDC;
724         front->hDC = back->hDC;
725         back->hDC = tmp;
726     }
727
728     /* Flip the DIBsection. */
729     {
730         HBITMAP tmp;
731         tmp = front->dib.DIBsection;
732         front->dib.DIBsection = back->dib.DIBsection;
733         back->dib.DIBsection = tmp;
734     }
735
736     /* Flip the surface data. */
737     {
738         void *tmp;
739
740         tmp = front->dib.bitmap_data;
741         front->dib.bitmap_data = back->dib.bitmap_data;
742         back->dib.bitmap_data = tmp;
743
744         tmp = front->resource.allocatedMemory;
745         front->resource.allocatedMemory = back->resource.allocatedMemory;
746         back->resource.allocatedMemory = tmp;
747
748         if (front->resource.heapMemory)
749             ERR("GDI Surface %p has heap memory allocated.\n", front);
750
751         if (back->resource.heapMemory)
752             ERR("GDI Surface %p has heap memory allocated.\n", back);
753     }
754
755     /* FPS support */
756     if (TRACE_ON(fps))
757     {
758         static LONG prev_time, frames;
759         DWORD time = GetTickCount();
760
761         ++frames;
762
763         /* every 1.5 seconds */
764         if (time - prev_time > 1500)
765         {
766             TRACE_(fps)("@ approx %.2ffps\n", 1000.0 * frames / (time - prev_time));
767             prev_time = time;
768             frames = 0;
769         }
770     }
771
772     x11_copy_to_screen(swapchain, NULL);
773 }
774
775 static const struct wined3d_swapchain_ops swapchain_gdi_ops =
776 {
777     swapchain_gdi_present,
778 };
779
780 void swapchain_update_render_to_fbo(struct wined3d_swapchain *swapchain)
781 {
782     RECT client_rect;
783
784     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
785         return;
786
787     if (!swapchain->desc.backbuffer_count)
788     {
789         TRACE("Single buffered rendering.\n");
790         swapchain->render_to_fbo = FALSE;
791         return;
792     }
793
794     GetClientRect(swapchain->win_handle, &client_rect);
795
796     TRACE("Backbuffer %ux%u, window %ux%u.\n",
797             swapchain->desc.backbuffer_width,
798             swapchain->desc.backbuffer_height,
799             client_rect.right, client_rect.bottom);
800     TRACE("Multisample type %#x, quality %#x.\n",
801             swapchain->desc.multisample_type,
802             swapchain->desc.multisample_quality);
803
804     if (!wined3d_settings.always_offscreen && !swapchain->desc.multisample_type
805             && swapchain->desc.backbuffer_width == client_rect.right
806             && swapchain->desc.backbuffer_height == client_rect.bottom)
807     {
808         TRACE("Backbuffer dimensions match window dimensions, rendering onscreen.\n");
809         swapchain->render_to_fbo = FALSE;
810         return;
811     }
812
813     TRACE("Rendering to FBO.\n");
814     swapchain->render_to_fbo = TRUE;
815 }
816
817 /* Do not call while under the GL lock. */
818 static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, enum wined3d_surface_type surface_type,
819         struct wined3d_device *device, struct wined3d_swapchain_desc *desc,
820         void *parent, const struct wined3d_parent_ops *parent_ops)
821 {
822     const struct wined3d_adapter *adapter = device->adapter;
823     const struct wined3d_format *format;
824     struct wined3d_display_mode mode;
825     BOOL displaymode_set = FALSE;
826     RECT client_rect;
827     HWND window;
828     HRESULT hr;
829     UINT i;
830
831     if (desc->backbuffer_count > WINED3DPRESENT_BACK_BUFFER_MAX)
832     {
833         FIXME("The application requested %u back buffers, this is not supported.\n",
834                 desc->backbuffer_count);
835         return WINED3DERR_INVALIDCALL;
836     }
837
838     if (desc->backbuffer_count > 1)
839     {
840         FIXME("The application requested more than one back buffer, this is not properly supported.\n"
841                 "Please configure the application to use double buffering (1 back buffer) if possible.\n");
842     }
843
844     switch (surface_type)
845     {
846         case WINED3D_SURFACE_TYPE_GDI:
847             swapchain->swapchain_ops = &swapchain_gdi_ops;
848             break;
849
850         case WINED3D_SURFACE_TYPE_OPENGL:
851             swapchain->swapchain_ops = &swapchain_gl_ops;
852             break;
853
854         default:
855             ERR("Invalid surface type %#x.\n", surface_type);
856             return WINED3DERR_INVALIDCALL;
857     }
858
859     window = desc->device_window ? desc->device_window : device->create_parms.focus_window;
860
861     swapchain->device = device;
862     swapchain->parent = parent;
863     swapchain->parent_ops = parent_ops;
864     swapchain->ref = 1;
865     swapchain->win_handle = window;
866     swapchain->device_window = window;
867
868     wined3d_get_adapter_display_mode(device->wined3d, adapter->ordinal, &mode, NULL);
869     swapchain->orig_width = mode.width;
870     swapchain->orig_height = mode.height;
871     swapchain->orig_fmt = mode.format_id;
872     format = wined3d_get_format(&adapter->gl_info, mode.format_id);
873
874     GetClientRect(window, &client_rect);
875     if (desc->windowed
876             && (!desc->backbuffer_width || !desc->backbuffer_height
877             || desc->backbuffer_format == WINED3DFMT_UNKNOWN))
878     {
879
880         if (!desc->backbuffer_width)
881         {
882             desc->backbuffer_width = client_rect.right;
883             TRACE("Updating width to %u.\n", desc->backbuffer_width);
884         }
885
886         if (!desc->backbuffer_height)
887         {
888             desc->backbuffer_height = client_rect.bottom;
889             TRACE("Updating height to %u.\n", desc->backbuffer_height);
890         }
891
892         if (desc->backbuffer_format == WINED3DFMT_UNKNOWN)
893         {
894             desc->backbuffer_format = swapchain->orig_fmt;
895             TRACE("Updating format to %s.\n", debug_d3dformat(swapchain->orig_fmt));
896         }
897     }
898     swapchain->desc = *desc;
899     swapchain_update_render_to_fbo(swapchain);
900
901     TRACE("Creating front buffer.\n");
902     if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent, parent,
903             swapchain->desc.backbuffer_width, swapchain->desc.backbuffer_height,
904             swapchain->desc.backbuffer_format, WINED3DUSAGE_RENDERTARGET,
905             swapchain->desc.multisample_type, swapchain->desc.multisample_quality,
906             &swapchain->front_buffer)))
907     {
908         WARN("Failed to create front buffer, hr %#x.\n", hr);
909         goto err;
910     }
911
912     if (swapchain->front_buffer->container.type == WINED3D_CONTAINER_NONE)
913         surface_set_container(swapchain->front_buffer, WINED3D_CONTAINER_SWAPCHAIN, swapchain);
914     if (surface_type == WINED3D_SURFACE_TYPE_OPENGL)
915         surface_modify_location(swapchain->front_buffer, SFLAG_INDRAWABLE, TRUE);
916
917     /* MSDN says we're only allowed a single fullscreen swapchain per device,
918      * so we should really check to see if there is a fullscreen swapchain
919      * already. Does a single head count as full screen? */
920
921     if (!desc->windowed)
922     {
923         struct wined3d_display_mode mode;
924
925         /* Change the display settings */
926         mode.width = desc->backbuffer_width;
927         mode.height = desc->backbuffer_height;
928         mode.format_id = desc->backbuffer_format;
929         mode.refresh_rate = desc->refresh_rate;
930         mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
931
932         if (FAILED(hr = wined3d_set_adapter_display_mode(device->wined3d, device->adapter->ordinal, &mode)))
933         {
934             WARN("Failed to set display mode, hr %#x.\n", hr);
935             goto err;
936         }
937         displaymode_set = TRUE;
938     }
939
940     if (surface_type == WINED3D_SURFACE_TYPE_OPENGL)
941     {
942         static const enum wined3d_format_id formats[] =
943         {
944             WINED3DFMT_D24_UNORM_S8_UINT,
945             WINED3DFMT_D32_UNORM,
946             WINED3DFMT_R24_UNORM_X8_TYPELESS,
947             WINED3DFMT_D16_UNORM,
948             WINED3DFMT_S1_UINT_D15_UNORM
949         };
950
951         const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
952
953         swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
954         if (!swapchain->context)
955         {
956             ERR("Failed to create the context array.\n");
957             hr = E_OUTOFMEMORY;
958             goto err;
959         }
960         swapchain->num_contexts = 1;
961
962         /* In WGL both color, depth and stencil are features of a pixel format. In case of D3D they are separate.
963          * You are able to add a depth + stencil surface at a later stage when you need it.
964          * In order to support this properly in WineD3D we need the ability to recreate the opengl context and
965          * drawable when this is required. This is very tricky as we need to reapply ALL opengl states for the new
966          * context, need torecreate shaders, textures and other resources.
967          *
968          * The context manager already takes care of the state problem and for the other tasks code from Reset
969          * can be used. These changes are way to risky during the 1.0 code freeze which is taking place right now.
970          * Likely a lot of other new bugs will be exposed. For that reason request a depth stencil surface all the
971          * time. It can cause a slight performance hit but fixes a lot of regressions. A fixme reminds of that this
972          * issue needs to be fixed. */
973         for (i = 0; i < (sizeof(formats) / sizeof(*formats)); i++)
974         {
975             swapchain->ds_format = wined3d_get_format(gl_info, formats[i]);
976             swapchain->context[0] = context_create(swapchain, swapchain->front_buffer, swapchain->ds_format);
977             if (swapchain->context[0]) break;
978             TRACE("Depth stencil format %s is not supported, trying next format\n",
979                   debug_d3dformat(formats[i]));
980         }
981
982         if (!swapchain->context[0])
983         {
984             WARN("Failed to create context.\n");
985             hr = WINED3DERR_NOTAVAILABLE;
986             goto err;
987         }
988
989         if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
990                 && (!desc->enable_auto_depth_stencil
991                 || swapchain->desc.auto_depth_stencil_format != swapchain->ds_format->id))
992         {
993             FIXME("Add OpenGL context recreation support to context_validate_onscreen_formats\n");
994         }
995         context_release(swapchain->context[0]);
996     }
997
998     if (swapchain->desc.backbuffer_count > 0)
999     {
1000         swapchain->back_buffers = HeapAlloc(GetProcessHeap(), 0,
1001                 sizeof(*swapchain->back_buffers) * swapchain->desc.backbuffer_count);
1002         if (!swapchain->back_buffers)
1003         {
1004             ERR("Failed to allocate backbuffer array memory.\n");
1005             hr = E_OUTOFMEMORY;
1006             goto err;
1007         }
1008
1009         for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
1010         {
1011             TRACE("Creating back buffer %u.\n", i);
1012             if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent, parent,
1013                     swapchain->desc.backbuffer_width, swapchain->desc.backbuffer_height,
1014                     swapchain->desc.backbuffer_format, WINED3DUSAGE_RENDERTARGET,
1015                     swapchain->desc.multisample_type, swapchain->desc.multisample_quality,
1016                     &swapchain->back_buffers[i])))
1017             {
1018                 WARN("Failed to create back buffer %u, hr %#x.\n", i, hr);
1019                 goto err;
1020             }
1021             if (swapchain->back_buffers[i]->container.type == WINED3D_CONTAINER_NONE)
1022                 surface_set_container(swapchain->back_buffers[i], WINED3D_CONTAINER_SWAPCHAIN, swapchain);
1023         }
1024     }
1025
1026     /* Swapchains share the depth/stencil buffer, so only create a single depthstencil surface. */
1027     if (desc->enable_auto_depth_stencil && surface_type == WINED3D_SURFACE_TYPE_OPENGL)
1028     {
1029         TRACE("Creating depth/stencil buffer.\n");
1030         if (!device->auto_depth_stencil)
1031         {
1032             if (FAILED(hr = device->device_parent->ops->create_swapchain_surface(device->device_parent,
1033                     device->device_parent, swapchain->desc.backbuffer_width, swapchain->desc.backbuffer_height,
1034                     swapchain->desc.auto_depth_stencil_format, WINED3DUSAGE_DEPTHSTENCIL,
1035                     swapchain->desc.multisample_type, swapchain->desc.multisample_quality,
1036                     &device->auto_depth_stencil)))
1037             {
1038                 WARN("Failed to create the auto depth stencil, hr %#x.\n", hr);
1039                 goto err;
1040             }
1041
1042             surface_set_container(device->auto_depth_stencil, WINED3D_CONTAINER_NONE, NULL);
1043         }
1044     }
1045
1046     wined3d_swapchain_get_gamma_ramp(swapchain, &swapchain->orig_gamma);
1047
1048     return WINED3D_OK;
1049
1050 err:
1051     if (displaymode_set)
1052     {
1053         DEVMODEW devmode;
1054
1055         ClipCursor(NULL);
1056
1057         /* Change the display settings */
1058         memset(&devmode, 0, sizeof(devmode));
1059         devmode.dmSize = sizeof(devmode);
1060         devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1061         devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
1062         devmode.dmPelsWidth = swapchain->orig_width;
1063         devmode.dmPelsHeight = swapchain->orig_height;
1064         ChangeDisplaySettingsExW(adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
1065     }
1066
1067     if (swapchain->back_buffers)
1068     {
1069         for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
1070         {
1071             if (swapchain->back_buffers[i])
1072             {
1073                 surface_set_container(swapchain->back_buffers[i], WINED3D_CONTAINER_NONE, NULL);
1074                 wined3d_surface_decref(swapchain->back_buffers[i]);
1075             }
1076         }
1077         HeapFree(GetProcessHeap(), 0, swapchain->back_buffers);
1078     }
1079
1080     if (swapchain->context)
1081     {
1082         if (swapchain->context[0])
1083         {
1084             context_release(swapchain->context[0]);
1085             context_destroy(device, swapchain->context[0]);
1086             swapchain->num_contexts = 0;
1087         }
1088         HeapFree(GetProcessHeap(), 0, swapchain->context);
1089     }
1090
1091     if (swapchain->front_buffer)
1092     {
1093         surface_set_container(swapchain->front_buffer, WINED3D_CONTAINER_NONE, NULL);
1094         wined3d_surface_decref(swapchain->front_buffer);
1095     }
1096
1097     return hr;
1098 }
1099
1100 /* Do not call while under the GL lock. */
1101 HRESULT CDECL wined3d_swapchain_create(struct wined3d_device *device,
1102         struct wined3d_swapchain_desc *desc, enum wined3d_surface_type surface_type,
1103         void *parent, const struct wined3d_parent_ops *parent_ops,
1104         struct wined3d_swapchain **swapchain)
1105 {
1106     struct wined3d_swapchain *object;
1107     HRESULT hr;
1108
1109     TRACE("device %p, desc %p, swapchain %p, parent %p, surface_type %#x.\n",
1110             device, desc, swapchain, parent, surface_type);
1111
1112     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1113     if (!object)
1114     {
1115         ERR("Failed to allocate swapchain memory.\n");
1116         return E_OUTOFMEMORY;
1117     }
1118
1119     hr = swapchain_init(object, surface_type, device, desc, parent, parent_ops);
1120     if (FAILED(hr))
1121     {
1122         WARN("Failed to initialize swapchain, hr %#x.\n", hr);
1123         HeapFree(GetProcessHeap(), 0, object);
1124         return hr;
1125     }
1126
1127     TRACE("Created swapchain %p.\n", object);
1128     *swapchain = object;
1129
1130     return WINED3D_OK;
1131 }
1132
1133 /* Do not call while under the GL lock. */
1134 static struct wined3d_context *swapchain_create_context(struct wined3d_swapchain *swapchain)
1135 {
1136     struct wined3d_context **newArray;
1137     struct wined3d_context *ctx;
1138
1139     TRACE("Creating a new context for swapchain %p, thread %u.\n", swapchain, GetCurrentThreadId());
1140
1141     if (!(ctx = context_create(swapchain, swapchain->front_buffer, swapchain->ds_format)))
1142     {
1143         ERR("Failed to create a new context for the swapchain\n");
1144         return NULL;
1145     }
1146     context_release(ctx);
1147
1148     newArray = HeapAlloc(GetProcessHeap(), 0, sizeof(*newArray) * (swapchain->num_contexts + 1));
1149     if(!newArray) {
1150         ERR("Out of memory when trying to allocate a new context array\n");
1151         context_destroy(swapchain->device, ctx);
1152         return NULL;
1153     }
1154     memcpy(newArray, swapchain->context, sizeof(*newArray) * swapchain->num_contexts);
1155     HeapFree(GetProcessHeap(), 0, swapchain->context);
1156     newArray[swapchain->num_contexts] = ctx;
1157     swapchain->context = newArray;
1158     swapchain->num_contexts++;
1159
1160     TRACE("Returning context %p\n", ctx);
1161     return ctx;
1162 }
1163
1164 void swapchain_destroy_contexts(struct wined3d_swapchain *swapchain)
1165 {
1166     unsigned int i;
1167
1168     for (i = 0; i < swapchain->num_contexts; ++i)
1169     {
1170         context_destroy(swapchain->device, swapchain->context[i]);
1171     }
1172     swapchain->num_contexts = 0;
1173 }
1174
1175 struct wined3d_context *swapchain_get_context(struct wined3d_swapchain *swapchain)
1176 {
1177     DWORD tid = GetCurrentThreadId();
1178     unsigned int i;
1179
1180     for (i = 0; i < swapchain->num_contexts; ++i)
1181     {
1182         if (swapchain->context[i]->tid == tid)
1183             return swapchain->context[i];
1184     }
1185
1186     /* Create a new context for the thread */
1187     return swapchain_create_context(swapchain);
1188 }
1189
1190 void get_drawable_size_swapchain(const struct wined3d_context *context, UINT *width, UINT *height)
1191 {
1192     /* The drawable size of an onscreen drawable is the surface size.
1193      * (Actually: The window size, but the surface is created in window size) */
1194     *width = context->current_rt->resource.width;
1195     *height = context->current_rt->resource.height;
1196 }
1197
1198 HDC swapchain_get_backup_dc(struct wined3d_swapchain *swapchain)
1199 {
1200     if (!swapchain->backup_dc)
1201     {
1202         TRACE("Creating the backup window for swapchain %p.\n", swapchain);
1203
1204         if (!(swapchain->backup_wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
1205                 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL)))
1206         {
1207             ERR("Failed to create a window.\n");
1208             return NULL;
1209         }
1210
1211         if (!(swapchain->backup_dc = GetDC(swapchain->backup_wnd)))
1212         {
1213             ERR("Failed to get a DC.\n");
1214             DestroyWindow(swapchain->backup_wnd);
1215             swapchain->backup_wnd = NULL;
1216             return NULL;
1217         }
1218     }
1219
1220     return swapchain->backup_dc;
1221 }
1222
1223 void swapchain_update_draw_bindings(struct wined3d_swapchain *swapchain)
1224 {
1225     UINT i;
1226
1227     surface_update_draw_binding(swapchain->front_buffer);
1228
1229     for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
1230     {
1231         surface_update_draw_binding(swapchain->back_buffers[i]);
1232     }
1233 }