wined3d: Add a method for querying the gl drawable size of rendertarget.
[wine] / dlls / wined3d / swapchain.c
1 /*
2  *IDirect3DSwapChain9 implementation
3  *
4  *Copyright 2002-2003 Jason Edmeades
5  *Copyright 2002-2003 Raphael Junqueira
6  *Copyright 2005 Oliver Stieber
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 "wined3d_private.h"
25
26
27 /*TODO: some of the additional parameters may be required to
28     set the gamma ramp (for some weird reason microsoft have left swap gammaramp in device
29     but it operates on a swapchain, it may be a good idea to move it to IWineD3DSwapChain for IWineD3D)*/
30
31
32 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
33 WINE_DECLARE_DEBUG_CHANNEL(fps);
34
35 #define GLINFO_LOCATION This->wineD3DDevice->adapter->gl_info
36
37 /* IDirect3DSwapChain IUnknown parts follow: */
38 static ULONG WINAPI IWineD3DSwapChainImpl_AddRef(IWineD3DSwapChain *iface) {
39     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
40     DWORD refCount = InterlockedIncrement(&This->ref);
41     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
42     return refCount;
43 }
44
45 static HRESULT WINAPI IWineD3DSwapChainImpl_QueryInterface(IWineD3DSwapChain *iface, REFIID riid, LPVOID *ppobj)
46 {
47     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
48     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppobj);
49     if (IsEqualGUID(riid, &IID_IUnknown)
50         || IsEqualGUID(riid, &IID_IWineD3DBase)
51         || IsEqualGUID(riid, &IID_IWineD3DSwapChain)){
52         IWineD3DSwapChainImpl_AddRef(iface);
53         if(ppobj == NULL){
54             ERR("Query interface called but now data allocated\n");
55             return E_NOINTERFACE;
56         }
57         *ppobj = This;
58         return WINED3D_OK;
59     }
60     *ppobj = NULL;
61     return E_NOINTERFACE;
62 }
63
64
65 static ULONG WINAPI IWineD3DSwapChainImpl_Release(IWineD3DSwapChain *iface) {
66     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
67     DWORD refCount;
68     refCount = InterlockedDecrement(&This->ref);
69     TRACE("(%p) : ReleaseRef to %d\n", This, refCount);
70     if (refCount == 0) {
71         IWineD3DSwapChain_Destroy(iface, D3DCB_DefaultDestroySurface);
72     }
73     return refCount;
74 }
75
76 static HRESULT WINAPI IWineD3DSwapChainImpl_GetParent(IWineD3DSwapChain *iface, IUnknown ** ppParent){
77     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
78     *ppParent = This->parent;
79     IUnknown_AddRef(*ppParent);
80     TRACE("(%p) returning %p\n", This , *ppParent);
81     return WINED3D_OK;
82 }
83
84 /*IWineD3DSwapChain parts follow: */
85 static void WINAPI IWineD3DSwapChainImpl_Destroy(IWineD3DSwapChain *iface, D3DCB_DESTROYSURFACEFN D3DCB_DestroyRenderTarget) {
86     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
87     WINED3DDISPLAYMODE mode;
88     int i;
89
90     /* release the ref to the front and back buffer parents */
91     if(This->frontBuffer) {
92         IWineD3DSurface_SetContainer(This->frontBuffer, 0);
93         if(D3DCB_DestroyRenderTarget(This->frontBuffer) > 0) {
94             FIXME("(%p) Something's still holding the front buffer\n",This);
95         }
96     }
97
98     if(This->backBuffer) {
99         int i;
100         for(i = 0; i < This->presentParms.BackBufferCount; i++) {
101             IWineD3DSurface_SetContainer(This->backBuffer[i], 0);
102             if(D3DCB_DestroyRenderTarget(This->backBuffer[i]) > 0) {
103                 FIXME("(%p) Something's still holding the back buffer\n",This);
104             }
105         }
106         HeapFree(GetProcessHeap(), 0, This->backBuffer);
107     }
108
109     for(i = 0; i < This->num_contexts; i++) {
110         DestroyContext(This->wineD3DDevice, This->context[i]);
111     }
112     /* Restore the screen resolution if we rendered in fullscreen
113      * This will restore the screen resolution to what it was before creating the swapchain. In case of d3d8 and d3d9
114      * this will be the original desktop resolution. In case of d3d7 this will be a NOP because ddraw sets the resolution
115      * before starting up Direct3D, thus orig_width and orig_height will be equal to the modes in the presentation params
116      */
117     if(This->presentParms.Windowed == FALSE) {
118         mode.Width = This->orig_width;
119         mode.Height = This->orig_height;
120         mode.RefreshRate = 0;
121         mode.Format = This->orig_fmt;
122         IWineD3DDevice_SetDisplayMode((IWineD3DDevice *) This->wineD3DDevice, 0, &mode);
123     }
124     HeapFree(GetProcessHeap(), 0, This->context);
125
126     HeapFree(GetProcessHeap(), 0, This);
127 }
128
129 static HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
130     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
131     unsigned int sync;
132     int retval;
133
134
135     ActivateContext(This->wineD3DDevice, This->backBuffer[0], CTXUSAGE_RESOURCELOAD);
136
137     /* Render the cursor onto the back buffer, using our nifty directdraw blitting code :-) */
138     if(This->wineD3DDevice->bCursorVisible && This->wineD3DDevice->cursorTexture) {
139         IWineD3DSurfaceImpl cursor;
140         RECT destRect = {This->wineD3DDevice->xScreenSpace - This->wineD3DDevice->xHotSpot,
141                          This->wineD3DDevice->yScreenSpace - This->wineD3DDevice->yHotSpot,
142                          This->wineD3DDevice->xScreenSpace + This->wineD3DDevice->cursorWidth - This->wineD3DDevice->xHotSpot,
143                          This->wineD3DDevice->yScreenSpace + This->wineD3DDevice->cursorHeight - This->wineD3DDevice->yHotSpot};
144         TRACE("Rendering the cursor. Creating fake surface at %p\n", &cursor);
145         /* Build a fake surface to call the Blitting code. It is not possible to use the interface passed by
146          * the application because we are only supposed to copy the information out. Using a fake surface
147          * allows to use the Blitting engine and avoid copying the whole texture -> render target blitting code.
148          */
149         memset(&cursor, 0, sizeof(cursor));
150         cursor.lpVtbl = &IWineD3DSurface_Vtbl;
151         cursor.resource.ref = 1;
152         cursor.resource.wineD3DDevice = This->wineD3DDevice;
153         cursor.resource.pool = WINED3DPOOL_SCRATCH;
154         cursor.resource.format = WINED3DFMT_A8R8G8B8;
155         cursor.resource.resourceType = WINED3DRTYPE_SURFACE;
156         cursor.glDescription.textureName = This->wineD3DDevice->cursorTexture;
157         cursor.glDescription.target = GL_TEXTURE_2D;
158         cursor.glDescription.level = 0;
159         cursor.currentDesc.Width = This->wineD3DDevice->cursorWidth;
160         cursor.currentDesc.Height = This->wineD3DDevice->cursorHeight;
161         cursor.glRect.left = 0;
162         cursor.glRect.top = 0;
163         cursor.glRect.right = cursor.currentDesc.Width;
164         cursor.glRect.bottom = cursor.currentDesc.Height;
165         /* The cursor must have pow2 sizes */
166         cursor.pow2Width = cursor.currentDesc.Width;
167         cursor.pow2Height = cursor.currentDesc.Height;
168         /* The surface is in the texture */
169         cursor.Flags |= SFLAG_INTEXTURE;
170         /* DDBLT_KEYSRC will cause BltOverride to enable the alpha test with GL_NOTEQUAL, 0.0,
171          * which is exactly what we want :-)
172          */
173         if (This->presentParms.Windowed) {
174             MapWindowPoints(NULL, This->win_handle, (LPPOINT)&destRect, 2);
175         }
176         IWineD3DSurface_Blt(This->backBuffer[0], &destRect, (IWineD3DSurface *) &cursor, NULL, WINEDDBLT_KEYSRC, NULL, WINED3DTEXF_NONE);
177     }
178     if(This->wineD3DDevice->logo_surface) {
179         /* Blit the logo into the upper left corner of the drawable */
180         IWineD3DSurface_BltFast(This->backBuffer[0], 0, 0, This->wineD3DDevice->logo_surface, NULL, WINEDDBLTFAST_SRCCOLORKEY);
181     }
182
183     if (pSourceRect || pDestRect) FIXME("Unhandled present options %p/%p\n", pSourceRect, pDestRect);
184     /* TODO: If only source rect or dest rect are supplied then clip the window to match */
185     TRACE("preseting HDC %p\n", This->context[0]->hdc);
186
187     /* Don't call checkGLcall, as glGetError is not applicable here */
188     if (hDestWindowOverride && This->win_handle != hDestWindowOverride) {
189         WINED3DLOCKED_RECT r;
190         BYTE *mem;
191
192         TRACE("Performing dest override of swapchain %p from window %p to %p\n", This, This->win_handle, hDestWindowOverride);
193         if(This->context[0] == This->wineD3DDevice->contexts[0]) {
194             /* The primary context 'owns' all the opengl resources. Destroying and recreating that context would require downloading
195              * all opengl resources, deleting the gl resources, destroying all other contexts, then recreating all other contexts
196              * and reload the resources
197              */
198             ERR("Cannot change the destination window of the owner of the primary context\n");
199         } else {
200             This->win_handle             = hDestWindowOverride;
201
202             /* The old back buffer has to be copied over to the new back buffer. A lockrect - switchcontext - unlockrect
203              * would suffice in theory, but it is rather nasty and may cause troubles with future changes of the locking code
204              * So lock read only, copy the surface out, then lock with the discard flag and write back
205              */
206             IWineD3DSurface_LockRect(This->backBuffer[0], &r, NULL, WINED3DLOCK_READONLY);
207             mem = HeapAlloc(GetProcessHeap(), 0, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
208             memcpy(mem, r.pBits, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
209             IWineD3DSurface_UnlockRect(This->backBuffer[0]);
210
211             DestroyContext(This->wineD3DDevice, This->context[0]);
212             This->context[0] = CreateContext(This->wineD3DDevice, (IWineD3DSurfaceImpl *) This->frontBuffer, This->win_handle, FALSE /* pbuffer */, &This->presentParms);
213
214             IWineD3DSurface_LockRect(This->backBuffer[0], &r, NULL, WINED3DLOCK_DISCARD);
215             memcpy(r.pBits, mem, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
216             HeapFree(GetProcessHeap(), 0, mem);
217             IWineD3DSurface_UnlockRect(This->backBuffer[0]);
218         }
219     }
220
221     SwapBuffers(This->context[0]->hdc); /* TODO: cycle through the swapchain buffers */
222
223     TRACE("SwapBuffers called, Starting new frame\n");
224     /* FPS support */
225     if (TRACE_ON(fps))
226     {
227         DWORD time = GetTickCount();
228         This->frames++;
229         /* every 1.5 seconds */
230         if (time - This->prev_time > 1500) {
231             TRACE_(fps)("%p @ approx %.2ffps\n", This, 1000.0*This->frames/(time - This->prev_time));
232             This->prev_time = time;
233             This->frames = 0;
234         }
235     }
236
237 #if defined(FRAME_DEBUGGING)
238 {
239     if (GetFileAttributesA("C:\\D3DTRACE") != INVALID_FILE_ATTRIBUTES) {
240         if (!isOn) {
241             isOn = TRUE;
242             FIXME("Enabling D3D Trace\n");
243             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 1);
244 #if defined(SHOW_FRAME_MAKEUP)
245             FIXME("Singe Frame snapshots Starting\n");
246             isDumpingFrames = TRUE;
247             ENTER_GL();
248             glClear(GL_COLOR_BUFFER_BIT);
249             LEAVE_GL();
250 #endif
251
252 #if defined(SINGLE_FRAME_DEBUGGING)
253         } else {
254 #if defined(SHOW_FRAME_MAKEUP)
255             FIXME("Singe Frame snapshots Finishing\n");
256             isDumpingFrames = FALSE;
257 #endif
258             FIXME("Singe Frame trace complete\n");
259             DeleteFileA("C:\\D3DTRACE");
260             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
261 #endif
262         }
263     } else {
264         if (isOn) {
265             isOn = FALSE;
266 #if defined(SHOW_FRAME_MAKEUP)
267             FIXME("Single Frame snapshots Finishing\n");
268             isDumpingFrames = FALSE;
269 #endif
270             FIXME("Disabling D3D Trace\n");
271             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
272         }
273     }
274 }
275 #endif
276
277     if (This->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD) {
278         TRACE("Clearing the color buffer with pink color\n");
279
280         IWineD3DDevice_Clear((IWineD3DDevice*)This->wineD3DDevice, 0, NULL,
281                               WINED3DCLEAR_TARGET, 0xff00ffff, 1.0, 0);
282     }
283
284     if(((IWineD3DSurfaceImpl *) This->frontBuffer)->Flags   & SFLAG_INSYSMEM ||
285        ((IWineD3DSurfaceImpl *) This->backBuffer[0])->Flags & SFLAG_INSYSMEM ) {
286         /* Both memory copies of the surfaces are ok, flip them around too instead of dirtifying */
287         IWineD3DSurfaceImpl *front = (IWineD3DSurfaceImpl *) This->frontBuffer;
288         IWineD3DSurfaceImpl *back = (IWineD3DSurfaceImpl *) This->backBuffer[0];
289         BOOL frontuptodate = front->Flags & SFLAG_INSYSMEM;
290         BOOL backuptodate = back->Flags & SFLAG_INSYSMEM;
291
292         if(front->resource.size == back->resource.size) {
293             /* Flip the DC */
294             {
295                 HDC tmp;
296                 tmp = front->hDC;
297                 front->hDC = back->hDC;
298                 back->hDC = tmp;
299             }
300
301             /* Flip the DIBsection */
302             {
303                 HBITMAP tmp;
304                 BOOL hasDib = front->Flags & SFLAG_DIBSECTION;
305                 tmp = front->dib.DIBsection;
306                 front->dib.DIBsection = back->dib.DIBsection;
307                 back->dib.DIBsection = tmp;
308
309                 if(back->Flags & SFLAG_DIBSECTION) front->Flags |= SFLAG_DIBSECTION;
310                 else front->Flags &= ~SFLAG_DIBSECTION;
311                 if(hasDib) back->Flags |= SFLAG_DIBSECTION;
312                 else back->Flags &= ~SFLAG_DIBSECTION;
313             }
314
315             /* Flip the surface data */
316             {
317                 void* tmp;
318
319                 tmp = front->dib.bitmap_data;
320                 front->dib.bitmap_data = back->dib.bitmap_data;
321                 back->dib.bitmap_data = tmp;
322
323                 tmp = front->resource.allocatedMemory;
324                 front->resource.allocatedMemory = back->resource.allocatedMemory;
325                 back->resource.allocatedMemory = tmp;
326
327                 tmp = front->resource.heapMemory;
328                 front->resource.heapMemory = back->resource.heapMemory;
329                 back->resource.heapMemory = tmp;
330             }
331
332             /* Flip the PBO */
333             {
334                 DWORD tmp_flags = front->Flags;
335
336                 GLuint tmp_pbo = front->pbo;
337                 front->pbo = back->pbo;
338                 back->pbo = tmp_pbo;
339
340                 if(back->Flags & SFLAG_PBO)
341                     front->Flags |= SFLAG_PBO;
342                 else
343                     front->Flags &= ~SFLAG_PBO;
344
345                 if(tmp_flags & SFLAG_PBO)
346                     back->Flags |= SFLAG_PBO;
347                 else
348                     back->Flags &= ~SFLAG_PBO;
349             }
350
351             /* client_memory should not be different, but just in case */
352             {
353                 BOOL tmp;
354                 tmp = front->dib.client_memory;
355                 front->dib.client_memory = back->dib.client_memory;
356                 back->dib.client_memory = tmp;
357             }
358             if(frontuptodate) back->Flags |= SFLAG_INSYSMEM;
359             else back->Flags &= ~SFLAG_INSYSMEM;
360             if(backuptodate) front->Flags |= SFLAG_INSYSMEM;
361             else front->Flags &= ~SFLAG_INSYSMEM;
362         } else {
363             IWineD3DSurface_ModifyLocation((IWineD3DSurface *) front, SFLAG_INDRAWABLE, TRUE);
364             IWineD3DSurface_ModifyLocation((IWineD3DSurface *) back, SFLAG_INDRAWABLE, TRUE);
365         }
366     }
367
368     if(This->presentParms.PresentationInterval != WINED3DPRESENT_INTERVAL_IMMEDIATE && GL_SUPPORT(SGI_VIDEO_SYNC)) {
369         retval = GL_EXTCALL(glXGetVideoSyncSGI(&sync));
370         if(retval != 0) {
371             ERR("glXGetVideoSyncSGI failed(retval = %d\n", retval);
372         }
373
374         switch(This->presentParms.PresentationInterval) {
375             case WINED3DPRESENT_INTERVAL_DEFAULT:
376             case WINED3DPRESENT_INTERVAL_ONE:
377                 if(sync <= This->vSyncCounter) {
378                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(1, 0, &This->vSyncCounter));
379                 } else {
380                     This->vSyncCounter = sync;
381                 }
382                 break;
383             case WINED3DPRESENT_INTERVAL_TWO:
384                 if(sync <= This->vSyncCounter + 1) {
385                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(2, This->vSyncCounter & 0x1, &This->vSyncCounter));
386                 } else {
387                     This->vSyncCounter = sync;
388                 }
389                 break;
390             case WINED3DPRESENT_INTERVAL_THREE:
391                 if(sync <= This->vSyncCounter + 2) {
392                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(3, This->vSyncCounter % 0x3, &This->vSyncCounter));
393                 } else {
394                     This->vSyncCounter = sync;
395                 }
396                 break;
397             case WINED3DPRESENT_INTERVAL_FOUR:
398                 if(sync <= This->vSyncCounter + 3) {
399                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(4, This->vSyncCounter & 0x3, &This->vSyncCounter));
400                 } else {
401                     This->vSyncCounter = sync;
402                 }
403                 break;
404             default:
405                 FIXME("Unknown presentation interval %08x\n", This->presentParms.PresentationInterval);
406         }
407     }
408
409     TRACE("returning\n");
410     return WINED3D_OK;
411 }
412
413 static HRESULT WINAPI IWineD3DSwapChainImpl_GetFrontBufferData(IWineD3DSwapChain *iface, IWineD3DSurface *pDestSurface) {
414     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
415     POINT start;
416
417     TRACE("(%p) : iface(%p) pDestSurface(%p)\n", This, iface, pDestSurface);
418
419     start.x = 0;
420     start.y = 0;
421
422     if (This->presentParms.Windowed) {
423         MapWindowPoints(This->win_handle, NULL, &start, 1);
424     }
425
426     IWineD3DSurface_BltFast(pDestSurface, start.x, start.y, This->frontBuffer, NULL, 0);
427     return WINED3D_OK;
428 }
429
430 static HRESULT WINAPI IWineD3DSwapChainImpl_GetBackBuffer(IWineD3DSwapChain *iface, UINT iBackBuffer, WINED3DBACKBUFFER_TYPE Type, IWineD3DSurface **ppBackBuffer) {
431
432     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
433
434     if (iBackBuffer > This->presentParms.BackBufferCount - 1) {
435         TRACE("Back buffer count out of range\n");
436         /* Native d3d9 doesn't set NULL here, just as wine's d3d9. But set it here
437          * in wined3d to avoid problems in other libs
438          */
439         *ppBackBuffer = NULL;
440         return WINED3DERR_INVALIDCALL;
441     }
442
443     *ppBackBuffer = This->backBuffer[iBackBuffer];
444     TRACE("(%p) : BackBuf %d Type %d  returning %p\n", This, iBackBuffer, Type, *ppBackBuffer);
445
446     /* Note inc ref on returned surface */
447     if(*ppBackBuffer) IWineD3DSurface_AddRef(*ppBackBuffer);
448     return WINED3D_OK;
449
450 }
451
452 static HRESULT WINAPI IWineD3DSwapChainImpl_GetRasterStatus(IWineD3DSwapChain *iface, WINED3DRASTER_STATUS *pRasterStatus) {
453     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
454     static BOOL showFixmes = TRUE;
455     pRasterStatus->InVBlank = TRUE;
456     pRasterStatus->ScanLine = 0;
457     /* No openGL equivalent */
458     if(showFixmes) {
459         FIXME("(%p) : stub (once)\n", This);
460         showFixmes = FALSE;
461     }
462     return WINED3D_OK;
463 }
464
465 static HRESULT WINAPI IWineD3DSwapChainImpl_GetDisplayMode(IWineD3DSwapChain *iface, WINED3DDISPLAYMODE*pMode) {
466     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
467     HDC                 hdc;
468     int                 bpp = 0;
469
470     pMode->Width        = GetSystemMetrics(SM_CXSCREEN);
471     pMode->Height       = GetSystemMetrics(SM_CYSCREEN);
472     pMode->RefreshRate  = 85; /* FIXME: How to identify? */
473
474     hdc = GetDC(0);
475     bpp = GetDeviceCaps(hdc, BITSPIXEL);
476     ReleaseDC(0, hdc);
477
478     switch (bpp) {
479     case  8: pMode->Format       = WINED3DFMT_R8G8B8; break;
480     case 16: pMode->Format       = WINED3DFMT_R5G6B5; break;
481     case 24: /*pMode->Format       = WINED3DFMT_R8G8B8; break; */ /* 32bpp and 24bpp can be aliased for X */
482     case 32: pMode->Format       = WINED3DFMT_A8R8G8B8; break;
483     default:
484        FIXME("Unrecognized display mode format\n");
485        pMode->Format       = WINED3DFMT_UNKNOWN;
486     }
487
488     TRACE("(%p) : returning w(%d) h(%d) rr(%d) fmt(%u,%s)\n", This, pMode->Width, pMode->Height, pMode->RefreshRate,
489     pMode->Format, debug_d3dformat(pMode->Format));
490     return WINED3D_OK;
491 }
492
493 static HRESULT WINAPI IWineD3DSwapChainImpl_GetDevice(IWineD3DSwapChain *iface, IWineD3DDevice**ppDevice) {
494     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
495
496     *ppDevice = (IWineD3DDevice *) This->wineD3DDevice;
497
498     /* Note  Calling this method will increase the internal reference count
499        on the IDirect3DDevice9 interface. */
500     IWineD3DDevice_AddRef(*ppDevice);
501     TRACE("(%p) : returning %p\n", This, *ppDevice);
502     return WINED3D_OK;
503 }
504
505 static HRESULT WINAPI IWineD3DSwapChainImpl_GetPresentParameters(IWineD3DSwapChain *iface, WINED3DPRESENT_PARAMETERS *pPresentationParameters) {
506     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
507     TRACE("(%p)\n", This);
508
509     *pPresentationParameters = This->presentParms;
510
511     return WINED3D_OK;
512 }
513
514 static HRESULT WINAPI IWineD3DSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface, DWORD Flags, CONST WINED3DGAMMARAMP *pRamp){
515
516     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
517     HDC hDC;
518     TRACE("(%p) : pRamp@%p flags(%d)\n", This, pRamp, Flags);
519     hDC = GetDC(This->win_handle);
520     SetDeviceGammaRamp(hDC, (LPVOID)pRamp);
521     ReleaseDC(This->win_handle, hDC);
522     return WINED3D_OK;
523
524 }
525
526 static HRESULT WINAPI IWineD3DSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface, WINED3DGAMMARAMP *pRamp){
527
528     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
529     HDC hDC;
530     TRACE("(%p) : pRamp@%p\n", This, pRamp);
531     hDC = GetDC(This->win_handle);
532     GetDeviceGammaRamp(hDC, pRamp);
533     ReleaseDC(This->win_handle, hDC);
534     return WINED3D_OK;
535
536 }
537
538
539 const IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl =
540 {
541     /* IUnknown */
542     IWineD3DSwapChainImpl_QueryInterface,
543     IWineD3DSwapChainImpl_AddRef,
544     IWineD3DSwapChainImpl_Release,
545     /* IWineD3DSwapChain */
546     IWineD3DSwapChainImpl_GetParent,
547     IWineD3DSwapChainImpl_Destroy,
548     IWineD3DSwapChainImpl_GetDevice,
549     IWineD3DSwapChainImpl_Present,
550     IWineD3DSwapChainImpl_GetFrontBufferData,
551     IWineD3DSwapChainImpl_GetBackBuffer,
552     IWineD3DSwapChainImpl_GetRasterStatus,
553     IWineD3DSwapChainImpl_GetDisplayMode,
554     IWineD3DSwapChainImpl_GetPresentParameters,
555     IWineD3DSwapChainImpl_SetGammaRamp,
556     IWineD3DSwapChainImpl_GetGammaRamp
557 };
558
559 WineD3DContext *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface) {
560     WineD3DContext *ctx;
561     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *) iface;
562     WineD3DContext **newArray;
563
564     TRACE("Creating a new context for swapchain %p, thread %d\n", This, GetCurrentThreadId());
565
566     ctx = CreateContext(This->wineD3DDevice, (IWineD3DSurfaceImpl *) This->frontBuffer,
567                         This->context[0]->win_handle, FALSE /* pbuffer */, &This->presentParms);
568     if(!ctx) {
569         ERR("Failed to create a new context for the swapchain\n");
570         return NULL;
571     }
572
573     newArray = HeapAlloc(GetProcessHeap(), 0, sizeof(*newArray) * This->num_contexts + 1);
574     if(!newArray) {
575         ERR("Out of memory when trying to allocate a new context array\n");
576         DestroyContext(This->wineD3DDevice, ctx);
577         return NULL;
578     }
579     memcpy(newArray, This->context, sizeof(*newArray) * This->num_contexts);
580     HeapFree(GetProcessHeap(), 0, This->context);
581     newArray[This->num_contexts] = ctx;
582     This->context = newArray;
583     This->num_contexts++;
584
585     TRACE("Returning context %p\n", ctx);
586     return ctx;
587 }
588
589 void get_drawable_size_swapchain(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
590     /* The drawable size of an onscreen drawable is the surface size.
591      * (Actually: The window size, but the surface is created in window size)
592      */
593     *width = This->currentDesc.Width;
594     *height = This->currentDesc.Height;
595 }