git.oblomov.eu Git - wine/blob - 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  *Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   8  *
   9  *This library is free software; you can redistribute it and/or
  10  *modify it under the terms of the GNU Lesser General Public
  11  *License as published by the Free Software Foundation; either
  12  *version 2.1 of the License, or (at your option) any later version.
  13  *
  14  *This library is distributed in the hope that it will be useful,
  15  *but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *Lesser General Public License for more details.
  18  *
  19  *You should have received a copy of the GNU Lesser General Public
  20  *License along with this library; if not, write to the Free Software
  21  *Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wined3d_private.h"
  26
  27
  28 /*TODO: some of the additional parameters may be required to
  29     set the gamma ramp (for some weird reason microsoft have left swap gammaramp in device
  30     but it operates on a swapchain, it may be a good idea to move it to IWineD3DSwapChain for IWineD3D)*/
  31
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  34 WINE_DECLARE_DEBUG_CHANNEL(fps);
  35
  36 #define GLINFO_LOCATION This->wineD3DDevice->adapter->gl_info
  37
  38 /*IWineD3DSwapChain parts follow: */
  39 static void WINAPI IWineD3DSwapChainImpl_Destroy(IWineD3DSwapChain *iface)
  40 {
  41     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
  42     WINED3DDISPLAYMODE mode;
  43     unsigned int i;
  44
  45     TRACE("Destroying swapchain %p\n", iface);
  46
  47     IWineD3DSwapChain_SetGammaRamp(iface, 0, &This->orig_gamma);
  48
  49     /* Release the swapchain's draw buffers. Make sure This->backBuffer[0] is
  50      * the last buffer to be destroyed, FindContext() depends on that. */
  51     if (This->frontBuffer)
  52     {
  53         IWineD3DSurface_SetContainer(This->frontBuffer, 0);
  54         if (IWineD3DSurface_Release(This->frontBuffer))
  55         {
  56             WARN("(%p) Something's still holding the front buffer (%p).\n",
  57                     This, This->frontBuffer);
  58         }
  59         This->frontBuffer = NULL;
  60     }
  61
  62     if (This->backBuffer)
  63     {
  64         UINT i = This->presentParms.BackBufferCount;
  65
  66         while (i--)
  67         {
  68             IWineD3DSurface_SetContainer(This->backBuffer[i], 0);
  69             if (IWineD3DSurface_Release(This->backBuffer[i]))
  70                 WARN("(%p) Something's still holding back buffer %u (%p).\n",
  71                         This, i, This->backBuffer[i]);
  72         }
  73         HeapFree(GetProcessHeap(), 0, This->backBuffer);
  74         This->backBuffer = NULL;
  75     }
  76
  77     for (i = 0; i < This->num_contexts; ++i)
  78     {
  79         DestroyContext(This->wineD3DDevice, This->context[i]);
  80     }
  81     /* Restore the screen resolution if we rendered in fullscreen
  82      * This will restore the screen resolution to what it was before creating the swapchain. In case of d3d8 and d3d9
  83      * this will be the original desktop resolution. In case of d3d7 this will be a NOP because ddraw sets the resolution
  84      * before starting up Direct3D, thus orig_width and orig_height will be equal to the modes in the presentation params
  85      */
  86     if(This->presentParms.Windowed == FALSE && This->presentParms.AutoRestoreDisplayMode) {
  87         mode.Width = This->orig_width;
  88         mode.Height = This->orig_height;
  89         mode.RefreshRate = 0;
  90         mode.Format = This->orig_fmt;
  91         IWineD3DDevice_SetDisplayMode((IWineD3DDevice *) This->wineD3DDevice, 0, &mode);
  92     }
  93     HeapFree(GetProcessHeap(), 0, This->context);
  94
  95     HeapFree(GetProcessHeap(), 0, This);
  96 }
  97
  98 static HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
  99     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 100     unsigned int sync;
 101     int retval;
 102
 103
 104     ActivateContext(This->wineD3DDevice, This->backBuffer[0], CTXUSAGE_RESOURCELOAD);
 105
 106     /* Render the cursor onto the back buffer, using our nifty directdraw blitting code :-) */
 107     if(This->wineD3DDevice->bCursorVisible && This->wineD3DDevice->cursorTexture) {
 108         IWineD3DSurfaceImpl cursor;
 109         RECT destRect = {This->wineD3DDevice->xScreenSpace - This->wineD3DDevice->xHotSpot,
 110                          This->wineD3DDevice->yScreenSpace - This->wineD3DDevice->yHotSpot,
 111                          This->wineD3DDevice->xScreenSpace + This->wineD3DDevice->cursorWidth - This->wineD3DDevice->xHotSpot,
 112                          This->wineD3DDevice->yScreenSpace + This->wineD3DDevice->cursorHeight - This->wineD3DDevice->yHotSpot};
 113         TRACE("Rendering the cursor. Creating fake surface at %p\n", &cursor);
 114         /* Build a fake surface to call the Blitting code. It is not possible to use the interface passed by
 115          * the application because we are only supposed to copy the information out. Using a fake surface
 116          * allows to use the Blitting engine and avoid copying the whole texture -> render target blitting code.
 117          */
 118         memset(&cursor, 0, sizeof(cursor));
 119         cursor.lpVtbl = &IWineD3DSurface_Vtbl;
 120         cursor.resource.ref = 1;
 121         cursor.resource.wineD3DDevice = This->wineD3DDevice;
 122         cursor.resource.pool = WINED3DPOOL_SCRATCH;
 123         cursor.resource.format_desc =
 124                 getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, &This->wineD3DDevice->adapter->gl_info);
 125         cursor.resource.resourceType = WINED3DRTYPE_SURFACE;
 126         cursor.texture_name = This->wineD3DDevice->cursorTexture;
 127         cursor.texture_target = GL_TEXTURE_2D;
 128         cursor.texture_level = 0;
 129         cursor.currentDesc.Width = This->wineD3DDevice->cursorWidth;
 130         cursor.currentDesc.Height = This->wineD3DDevice->cursorHeight;
 131         cursor.glRect.left = 0;
 132         cursor.glRect.top = 0;
 133         cursor.glRect.right = cursor.currentDesc.Width;
 134         cursor.glRect.bottom = cursor.currentDesc.Height;
 135         /* The cursor must have pow2 sizes */
 136         cursor.pow2Width = cursor.currentDesc.Width;
 137         cursor.pow2Height = cursor.currentDesc.Height;
 138         /* The surface is in the texture */
 139         cursor.Flags |= SFLAG_INTEXTURE;
 140         /* DDBLT_KEYSRC will cause BltOverride to enable the alpha test with GL_NOTEQUAL, 0.0,
 141          * which is exactly what we want :-)
 142          */
 143         if (This->presentParms.Windowed) {
 144             MapWindowPoints(NULL, This->win_handle, (LPPOINT)&destRect, 2);
 145         }
 146         IWineD3DSurface_Blt(This->backBuffer[0], &destRect, (IWineD3DSurface *)&cursor,
 147                 NULL, WINEDDBLT_KEYSRC, NULL, WINED3DTEXF_POINT);
 148     }
 149     if(This->wineD3DDevice->logo_surface) {
 150         /* Blit the logo into the upper left corner of the drawable */
 151         IWineD3DSurface_BltFast(This->backBuffer[0], 0, 0, This->wineD3DDevice->logo_surface, NULL, WINEDDBLTFAST_SRCCOLORKEY);
 152     }
 153
 154     if (pSourceRect || pDestRect) FIXME("Unhandled present rects %s/%s\n", wine_dbgstr_rect(pSourceRect), wine_dbgstr_rect(pDestRect));
 155     /* TODO: If only source rect or dest rect are supplied then clip the window to match */
 156     TRACE("presetting HDC %p\n", This->context[0]->hdc);
 157
 158     /* Don't call checkGLcall, as glGetError is not applicable here */
 159     if (hDestWindowOverride && This->win_handle != hDestWindowOverride) {
 160         IWineD3DSwapChain_SetDestWindowOverride(iface, hDestWindowOverride);
 161     }
 162
 163     SwapBuffers(This->context[0]->hdc); /* TODO: cycle through the swapchain buffers */
 164
 165     TRACE("SwapBuffers called, Starting new frame\n");
 166     /* FPS support */
 167     if (TRACE_ON(fps))
 168     {
 169         DWORD time = GetTickCount();
 170         This->frames++;
 171         /* every 1.5 seconds */
 172         if (time - This->prev_time > 1500) {
 173             TRACE_(fps)("%p @ approx %.2ffps\n", This, 1000.0*This->frames/(time - This->prev_time));
 174             This->prev_time = time;
 175             This->frames = 0;
 176         }
 177     }
 178
 179 #if defined(FRAME_DEBUGGING)
 180 {
 181     if (GetFileAttributesA("C:\\D3DTRACE") != INVALID_FILE_ATTRIBUTES) {
 182         if (!isOn) {
 183             isOn = TRUE;
 184             FIXME("Enabling D3D Trace\n");
 185             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 1);
 186 #if defined(SHOW_FRAME_MAKEUP)
 187             FIXME("Singe Frame snapshots Starting\n");
 188             isDumpingFrames = TRUE;
 189             ENTER_GL();
 190             glClear(GL_COLOR_BUFFER_BIT);
 191             LEAVE_GL();
 192 #endif
 193
 194 #if defined(SINGLE_FRAME_DEBUGGING)
 195         } else {
 196 #if defined(SHOW_FRAME_MAKEUP)
 197             FIXME("Singe Frame snapshots Finishing\n");
 198             isDumpingFrames = FALSE;
 199 #endif
 200             FIXME("Singe Frame trace complete\n");
 201             DeleteFileA("C:\\D3DTRACE");
 202             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
 203 #endif
 204         }
 205     } else {
 206         if (isOn) {
 207             isOn = FALSE;
 208 #if defined(SHOW_FRAME_MAKEUP)
 209             FIXME("Single Frame snapshots Finishing\n");
 210             isDumpingFrames = FALSE;
 211 #endif
 212             FIXME("Disabling D3D Trace\n");
 213             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
 214         }
 215     }
 216 }
 217 #endif
 218
 219     /* This is disabled, but the code left in for debug purposes.
 220      *
 221      * Since we're allowed to modify the new back buffer on a D3DSWAPEFFECT_DISCARD flip,
 222      * we can clear it with some ugly color to make bad drawing visible and ease debugging.
 223      * The Debug runtime does the same on Windows. However, a few games do not redraw the
 224      * screen properly, like Max Payne 2, which leaves a few pixels undefined.
 225      *
 226      * Tests show that the content of the back buffer after a discard flip is indeed not
 227      * reliable, so no game can depend on the exact content. However, it resembles the
 228      * old contents in some way, for example by showing fragments at other locations. In
 229      * general, the color theme is still intact. So Max payne, which draws rather dark scenes
 230      * gets a dark background image. If we clear it with a bright ugly color, the game's
 231      * bug shows up much more than it does on Windows, and the players see single pixels
 232      * with wrong colors.
 233      * (The Max Payne bug has been confirmed on Windows with the debug runtime)
 234      */
 235     if (FALSE && This->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD) {
 236         TRACE("Clearing the color buffer with cyan color\n");
 237
 238         IWineD3DDevice_Clear((IWineD3DDevice*)This->wineD3DDevice, 0, NULL,
 239                 WINED3DCLEAR_TARGET, 0xff00ffff, 1.0f, 0);
 240     }
 241
 242     if(((IWineD3DSurfaceImpl *) This->frontBuffer)->Flags   & SFLAG_INSYSMEM ||
 243        ((IWineD3DSurfaceImpl *) This->backBuffer[0])->Flags & SFLAG_INSYSMEM ) {
 244         /* Both memory copies of the surfaces are ok, flip them around too instead of dirtifying */
 245         IWineD3DSurfaceImpl *front = (IWineD3DSurfaceImpl *) This->frontBuffer;
 246         IWineD3DSurfaceImpl *back = (IWineD3DSurfaceImpl *) This->backBuffer[0];
 247
 248         if(front->resource.size == back->resource.size) {
 249             DWORD fbflags;
 250             flip_surface(front, back);
 251
 252             /* Tell the front buffer surface that is has been modified. However,
 253              * the other locations were preserved during that, so keep the flags.
 254              * This serves to update the emulated overlay, if any
 255              */
 256             fbflags = front->Flags;
 257             IWineD3DSurface_ModifyLocation(This->frontBuffer, SFLAG_INDRAWABLE, TRUE);
 258             front->Flags = fbflags;
 259         } else {
 260             IWineD3DSurface_ModifyLocation((IWineD3DSurface *) front, SFLAG_INDRAWABLE, TRUE);
 261             IWineD3DSurface_ModifyLocation((IWineD3DSurface *) back, SFLAG_INDRAWABLE, TRUE);
 262         }
 263     } else {
 264         IWineD3DSurface_ModifyLocation(This->frontBuffer, SFLAG_INDRAWABLE, TRUE);
 265         /* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM
 266          * and INTEXTURE copies can keep their old content if they have any defined content.
 267          * If the swapeffect is COPY, the content remains the same. If it is FLIP however,
 268          * the texture / sysmem copy needs to be reloaded from the drawable
 269          */
 270         if(This->presentParms.SwapEffect == WINED3DSWAPEFFECT_FLIP) {
 271             IWineD3DSurface_ModifyLocation(This->backBuffer[0], SFLAG_INDRAWABLE, TRUE);
 272         }
 273     }
 274
 275     if (This->wineD3DDevice->stencilBufferTarget) {
 276         if (This->presentParms.Flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
 277                 || ((IWineD3DSurfaceImpl *)This->wineD3DDevice->stencilBufferTarget)->Flags & SFLAG_DISCARD) {
 278             surface_modify_ds_location(This->wineD3DDevice->stencilBufferTarget, SFLAG_DS_DISCARDED);
 279         }
 280     }
 281
 282     if(This->presentParms.PresentationInterval != WINED3DPRESENT_INTERVAL_IMMEDIATE && GL_SUPPORT(SGI_VIDEO_SYNC)) {
 283         retval = GL_EXTCALL(glXGetVideoSyncSGI(&sync));
 284         if(retval != 0) {
 285             ERR("glXGetVideoSyncSGI failed(retval = %d\n", retval);
 286         }
 287
 288         switch(This->presentParms.PresentationInterval) {
 289             case WINED3DPRESENT_INTERVAL_DEFAULT:
 290             case WINED3DPRESENT_INTERVAL_ONE:
 291                 if(sync <= This->vSyncCounter) {
 292                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(1, 0, &This->vSyncCounter));
 293                 } else {
 294                     This->vSyncCounter = sync;
 295                 }
 296                 break;
 297             case WINED3DPRESENT_INTERVAL_TWO:
 298                 if(sync <= This->vSyncCounter + 1) {
 299                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(2, This->vSyncCounter & 0x1, &This->vSyncCounter));
 300                 } else {
 301                     This->vSyncCounter = sync;
 302                 }
 303                 break;
 304             case WINED3DPRESENT_INTERVAL_THREE:
 305                 if(sync <= This->vSyncCounter + 2) {
 306                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(3, This->vSyncCounter % 0x3, &This->vSyncCounter));
 307                 } else {
 308                     This->vSyncCounter = sync;
 309                 }
 310                 break;
 311             case WINED3DPRESENT_INTERVAL_FOUR:
 312                 if(sync <= This->vSyncCounter + 3) {
 313                     retval = GL_EXTCALL(glXWaitVideoSyncSGI(4, This->vSyncCounter & 0x3, &This->vSyncCounter));
 314                 } else {
 315                     This->vSyncCounter = sync;
 316                 }
 317                 break;
 318             default:
 319                 FIXME("Unknown presentation interval %08x\n", This->presentParms.PresentationInterval);
 320         }
 321     }
 322
 323     TRACE("returning\n");
 324     return WINED3D_OK;
 325 }
 326
 327 static HRESULT WINAPI IWineD3DSwapChainImpl_SetDestWindowOverride(IWineD3DSwapChain *iface, HWND window) {
 328     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 329     WINED3DLOCKED_RECT r;
 330     BYTE *mem;
 331
 332     if(window == This->win_handle) return WINED3D_OK;
 333
 334     TRACE("Performing dest override of swapchain %p from window %p to %p\n", This, This->win_handle, window);
 335     if(This->context[0] == This->wineD3DDevice->contexts[0]) {
 336         /* The primary context 'owns' all the opengl resources. Destroying and recreating that context requires downloading
 337          * all opengl resources, deleting the gl resources, destroying all other contexts, then recreating all other contexts
 338          * and reload the resources
 339          */
 340         delete_opengl_contexts((IWineD3DDevice *) This->wineD3DDevice, iface);
 341         This->win_handle             = window;
 342         create_primary_opengl_context((IWineD3DDevice *) This->wineD3DDevice, iface);
 343     } else {
 344         This->win_handle             = window;
 345
 346         /* The old back buffer has to be copied over to the new back buffer. A lockrect - switchcontext - unlockrect
 347          * would suffice in theory, but it is rather nasty and may cause troubles with future changes of the locking code
 348          * So lock read only, copy the surface out, then lock with the discard flag and write back
 349          */
 350         IWineD3DSurface_LockRect(This->backBuffer[0], &r, NULL, WINED3DLOCK_READONLY);
 351         mem = HeapAlloc(GetProcessHeap(), 0, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
 352         memcpy(mem, r.pBits, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
 353         IWineD3DSurface_UnlockRect(This->backBuffer[0]);
 354
 355         DestroyContext(This->wineD3DDevice, This->context[0]);
 356         This->context[0] = CreateContext(This->wineD3DDevice, (IWineD3DSurfaceImpl *) This->frontBuffer, This->win_handle, FALSE /* pbuffer */, &This->presentParms);
 357
 358         IWineD3DSurface_LockRect(This->backBuffer[0], &r, NULL, WINED3DLOCK_DISCARD);
 359         memcpy(r.pBits, mem, r.Pitch * ((IWineD3DSurfaceImpl *) This->backBuffer[0])->currentDesc.Height);
 360         HeapFree(GetProcessHeap(), 0, mem);
 361         IWineD3DSurface_UnlockRect(This->backBuffer[0]);
 362     }
 363     return WINED3D_OK;
 364 }
 365
 366 const IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl =
 367 {
 368     /* IUnknown */
 369     IWineD3DBaseSwapChainImpl_QueryInterface,
 370     IWineD3DBaseSwapChainImpl_AddRef,
 371     IWineD3DBaseSwapChainImpl_Release,
 372     /* IWineD3DSwapChain */
 373     IWineD3DBaseSwapChainImpl_GetParent,
 374     IWineD3DSwapChainImpl_Destroy,
 375     IWineD3DBaseSwapChainImpl_GetDevice,
 376     IWineD3DSwapChainImpl_Present,
 377     IWineD3DSwapChainImpl_SetDestWindowOverride,
 378     IWineD3DBaseSwapChainImpl_GetFrontBufferData,
 379     IWineD3DBaseSwapChainImpl_GetBackBuffer,
 380     IWineD3DBaseSwapChainImpl_GetRasterStatus,
 381     IWineD3DBaseSwapChainImpl_GetDisplayMode,
 382     IWineD3DBaseSwapChainImpl_GetPresentParameters,
 383     IWineD3DBaseSwapChainImpl_SetGammaRamp,
 384     IWineD3DBaseSwapChainImpl_GetGammaRamp
 385 };
 386
 387 struct wined3d_context *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface)
 388 {
 389     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *) iface;
 390     struct wined3d_context **newArray;
 391     struct wined3d_context *ctx;
 392
 393     TRACE("Creating a new context for swapchain %p, thread %d\n", This, GetCurrentThreadId());
 394
 395     ctx = CreateContext(This->wineD3DDevice, (IWineD3DSurfaceImpl *) This->frontBuffer,
 396                         This->context[0]->win_handle, FALSE /* pbuffer */, &This->presentParms);
 397     if(!ctx) {
 398         ERR("Failed to create a new context for the swapchain\n");
 399         return NULL;
 400     }
 401
 402     newArray = HeapAlloc(GetProcessHeap(), 0, sizeof(*newArray) * This->num_contexts + 1);
 403     if(!newArray) {
 404         ERR("Out of memory when trying to allocate a new context array\n");
 405         DestroyContext(This->wineD3DDevice, ctx);
 406         return NULL;
 407     }
 408     memcpy(newArray, This->context, sizeof(*newArray) * This->num_contexts);
 409     HeapFree(GetProcessHeap(), 0, This->context);
 410     newArray[This->num_contexts] = ctx;
 411     This->context = newArray;
 412     This->num_contexts++;
 413
 414     TRACE("Returning context %p\n", ctx);
 415     return ctx;
 416 }
 417
 418 void get_drawable_size_swapchain(struct wined3d_context *context, UINT *width, UINT *height)
 419 {
 420     IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)context->current_rt;
 421     /* The drawable size of an onscreen drawable is the surface size.
 422      * (Actually: The window size, but the surface is created in window size) */
 423     *width = surface->currentDesc.Width;
 424     *height = surface->currentDesc.Height;
 425 }