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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "wined3d_private.h"
  25
  26
  27 /* TODO: move to shared header (or context manager )*/
  28 /* x11drv GDI escapes */
  29 #define X11DRV_ESCAPE 6789
  30 enum x11drv_escape_codes
  31 {
  32     X11DRV_GET_DISPLAY,   /* get X11 display for a DC */
  33     X11DRV_GET_DRAWABLE,  /* get current drawable for a DC */
  34     X11DRV_GET_FONT,      /* get current X font for a DC */
  35 };
  36
  37 /* retrieve the X display to use on a given DC */
  38 inline static Display *get_display( HDC hdc )
  39 {
  40     Display *display;
  41     enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
  42
  43     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
  44                     sizeof(display), (LPSTR)&display )) display = NULL;
  45     return display;
  46 }
  47
  48 /*TODO: some of the additional parameters may be required to
  49     set the gamma ramp (for some weird reason microsoft have left swap gammaramp in device
  50     but it operates on a swapchain, it may be a good idea to move it to IWineD3DSwapChain for IWineD3D)*/
  51
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  54 WINE_DECLARE_DEBUG_CHANNEL(d3d_fps);
  55
  56
  57 /* IDirect3DSwapChain IUnknown parts follow: */
  58 ULONG WINAPI IWineD3DSwapChainImpl_AddRef(IWineD3DSwapChain *iface) {
  59     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
  60     DWORD refCount = InterlockedIncrement(&This->ref);
  61     TRACE("(%p) : AddRef increasing from %ld\n", This, refCount - 1);
  62     return refCount;
  63 }
  64
  65 HRESULT WINAPI IWineD3DSwapChainImpl_QueryInterface(IWineD3DSwapChain *iface, REFIID riid, LPVOID *ppobj)
  66 {
  67     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
  68     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppobj);
  69     if (IsEqualGUID(riid, &IID_IUnknown)
  70         || IsEqualGUID(riid, &IID_IWineD3DBase)
  71         || IsEqualGUID(riid, &IID_IWineD3DSwapChain)){
  72         IWineD3DSwapChainImpl_AddRef(iface);
  73         if(ppobj == NULL){
  74             ERR("Query interface called but now data allocated\n");
  75             return E_NOINTERFACE;
  76         }
  77         *ppobj = This;
  78         return WINED3D_OK;
  79     }
  80     *ppobj = NULL;
  81     return E_NOINTERFACE;
  82 }
  83
  84
  85 ULONG WINAPI IWineD3DSwapChainImpl_Release(IWineD3DSwapChain *iface) {
  86     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
  87     DWORD refCount;
  88     refCount = InterlockedDecrement(&This->ref);
  89     TRACE("(%p) : ReleaseRef to %ld\n", This, refCount);
  90     if (refCount == 0) {
  91         IUnknown* bufferParent;
  92
  93         /* tell the device that we've been released */
  94         IWineD3DDevice_SwapChainReleased((IWineD3DDevice *)This->wineD3DDevice, iface);
  95
  96         /* release the ref to the front and back buffer parents */
  97         if(This->frontBuffer) {
  98             IWineD3DSurface_SetContainer(This->frontBuffer, 0);
  99             IWineD3DSurface_GetParent(This->frontBuffer, &bufferParent);
 100             IUnknown_Release(bufferParent); /* once for the get parent */
 101             if(IUnknown_Release(bufferParent) > 0){
 102                 FIXME("(%p) Something's still holding the front buffer\n",This);
 103             }
 104         }
 105
 106         if(This->backBuffer) {
 107             IWineD3DSurface_SetContainer(This->backBuffer, 0);
 108             IWineD3DSurface_GetParent(This->backBuffer, &bufferParent);
 109             IUnknown_Release(bufferParent); /* once for the get parent */
 110             if(IUnknown_Release(bufferParent) > 0){
 111                 FIXME("(%p) Something's still holding the back buffer\n",This);
 112             }
 113         }
 114
 115         /* Clean up the context */
 116         /* check that we are the current context first */
 117         if(glXGetCurrentContext() == This->glCtx){
 118             glXMakeCurrent(This->display, None, NULL);
 119         }
 120         glXDestroyContext(This->display, This->glCtx);
 121         /* IUnknown_Release(This->parent); This should only apply to the primary swapchain,
 122          all others are crated by the caller, so releasing the parent should cause
 123          the child to be released, not the other way around!
 124          */
 125         HeapFree(GetProcessHeap(), 0, This);
 126     }
 127     return refCount;
 128 }
 129
 130 HRESULT WINAPI IWineD3DSwapChainImpl_GetParent(IWineD3DSwapChain *iface, IUnknown ** ppParent){
 131     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 132     *ppParent = This->parent;
 133     IUnknown_AddRef(*ppParent);
 134     TRACE("(%p) returning %p\n", This , *ppParent);
 135     return WINED3D_OK;
 136 }
 137
 138 /*IWineD3DSwapChain parts follow: */
 139 HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
 140     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 141
 142     ENTER_GL();
 143
 144     if (pSourceRect || pDestRect) FIXME("Unhandled present options %p/%p\n", pSourceRect, pDestRect);
 145     /* TODO: If only source rect or dest rect are supplied then clip the window to match */
 146     TRACE("preseting display %p, drawable %ld\n", This->display, This->drawable);
 147
 148     /* Don't call checkGLcall, as glGetError is not applicable here */
 149     if (hDestWindowOverride && This->win_handle != hDestWindowOverride) {
 150         /* Set this swapchain up to point to the new destination.. */
 151 #ifdef USE_CONTEXT_MANAGER
 152             /* TODO: use a context mamager */
 153 #endif
 154
 155             /* FIXME: Never access */
 156             IWineD3DSwapChainImpl *swapChainImpl;
 157             IWineD3DDevice_GetSwapChain((IWineD3DDevice *)This->wineD3DDevice, 0 , (IWineD3DSwapChain **)&swapChainImpl);
 158             FIXME("Unable to render to a destination window %p\n", hDestWindowOverride );
 159             if(This == swapChainImpl){
 160                 /* FIXME: this will be fixed by moving to a context management system */
 161                 FIXME("Cannot change the target of the implicit swapchain\n");
 162             }else{
 163                 HDC               hDc;
 164                 XVisualInfo       template;
 165                 int               num;
 166                 Display          *oldDisplay = This->display;
 167                 GLXContext        oldContext = This->glCtx;
 168                 IUnknown*         tmp;
 169                 GLXContext        currentContext;
 170                 Drawable          currentDrawable;
 171                 hDc                          = GetDC(hDestWindowOverride);
 172                 This->win_handle             = hDestWindowOverride;
 173                 This->win                    = (Window)GetPropA( hDestWindowOverride, "__wine_x11_whole_window" );
 174
 175                 TRACE("Creating a new context for the window %p\n", hDestWindowOverride);
 176                 ENTER_GL();
 177                 TRACE("Desctroying context %p %p\n", This->display, This->render_ctx);
 178
 179
 180
 181                 LEAVE_GL();
 182                 ENTER_GL();
 183
 184                 This->display    = get_display(hDc);
 185                 TRACE("Got display%p  for  %p %p\n",  This->display, hDc, hDestWindowOverride);
 186                 ReleaseDC(hDestWindowOverride, hDc);
 187                 template.visualid = (VisualID)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id");
 188                 This->visInfo   = XGetVisualInfo(This->display, VisualIDMask, &template, &num);
 189                 if (NULL == This->visInfo) {
 190                     ERR("cannot really get XVisual\n");
 191                     LEAVE_GL();
 192                     return WINED3DERR_NOTAVAILABLE;
 193                 }
 194                 /* Now we have problems? well not really we just need to know what the implicit context is */
 195                 /* now destroy the old context and create a new one (we should really copy the buffers over, and do the whole make current thing! */
 196                 /* destroy the active context?*/
 197                 TRACE("Creating new context for %p %p %p\n",This->display, This->visInfo, swapChainImpl->glCtx);
 198                 This->glCtx = glXCreateContext(This->display, This->visInfo, swapChainImpl->glCtx, GL_TRUE);
 199
 200                 if (NULL == This->glCtx) {
 201                     ERR("cannot create glxContext\n");
 202                 }
 203                 This->drawable     = This->win;
 204                 This->render_ctx   = This->glCtx;
 205                 /* Setup some default states TODO: apply the stateblock to the new context */
 206                 /** save current context and drawable **/
 207                 currentContext  =   glXGetCurrentContext();
 208                 currentDrawable =   glXGetCurrentDrawable();
 209
 210                 if (glXMakeCurrent(This->display, This->win, This->glCtx) == False) {
 211                     ERR("Error in setting current context (display %p context %p drawable %ld)!\n", This->display, This->glCtx, This->win);
 212                 }
 213
 214                 checkGLcall("glXMakeCurrent");
 215
 216                 /* Clear the screen */
 217                 glClearColor(0.0, 0.0, 0.0, 0.0);
 218                 checkGLcall("glClearColor");
 219                 glClearIndex(0);
 220                 glClearDepth(1);
 221                 glClearStencil(0);
 222
 223                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 224                 checkGLcall("glClear");
 225
 226                 glColor3f(1.0, 1.0, 1.0);
 227                 checkGLcall("glColor3f");
 228
 229                 glEnable(GL_LIGHTING);
 230                 checkGLcall("glEnable");
 231
 232                 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
 233                 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
 234
 235                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
 236                 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
 237
 238                 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
 239                 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
 240
 241                 /* If this swapchain is currently the active context then make this swapchain active */
 242                 if(IWineD3DSurface_GetContainer(This->wineD3DDevice->renderTarget, &IID_IWineD3DSwapChain, (void **)&tmp) == WINED3D_OK){
 243                     if(tmp != (IUnknown *)This){
 244                         glXMakeCurrent(This->display, currentDrawable, currentContext);
 245                         checkGLcall("glXMakeCurrent");
 246                     }
 247                     IUnknown_Release(tmp);
 248                 }else{
 249                     /* reset the context */
 250                     glXMakeCurrent(This->display, currentDrawable, currentContext);
 251                     checkGLcall("glXMakeCurrent");
 252                 }
 253                 /* delete the old contxt*/
 254                 glXDestroyContext(oldDisplay, oldContext); /* Should this happen on an active context? seems a bad idea */
 255                 LEAVE_GL();
 256             }
 257             IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapChainImpl);
 258
 259         }
 260
 261
 262         /* TODO: The slow way, save the data to memory, create a new context for the destination window, transfer the data cleanup, it may be a good idea to the move this swapchain over to the using the target winows context so that it runs faster in feature. */
 263
 264     glXSwapBuffers(This->display, This->drawable); /* TODO: cycle through the swapchain buffers */
 265
 266     TRACE("glXSwapBuffers called, Starting new frame\n");
 267     /* FPS support */
 268     if (TRACE_ON(d3d_fps))
 269     {
 270         static long prev_time, frames;
 271
 272         DWORD time = GetTickCount();
 273         frames++;
 274         /* every 1.5 seconds */
 275         if (time - prev_time > 1500) {
 276             TRACE_(d3d_fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
 277             prev_time = time;
 278             frames = 0;
 279         }
 280     }
 281
 282 #if defined(FRAME_DEBUGGING)
 283 {
 284     if (GetFileAttributesA("C:\\D3DTRACE") != INVALID_FILE_ATTRIBUTES) {
 285         if (!isOn) {
 286             isOn = TRUE;
 287             FIXME("Enabling D3D Trace\n");
 288             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 1);
 289 #if defined(SHOW_FRAME_MAKEUP)
 290             FIXME("Singe Frame snapshots Starting\n");
 291             isDumpingFrames = TRUE;
 292             glClear(GL_COLOR_BUFFER_BIT);
 293 #endif
 294
 295 #if defined(SINGLE_FRAME_DEBUGGING)
 296         } else {
 297 #if defined(SHOW_FRAME_MAKEUP)
 298             FIXME("Singe Frame snapshots Finishing\n");
 299             isDumpingFrames = FALSE;
 300 #endif
 301             FIXME("Singe Frame trace complete\n");
 302             DeleteFileA("C:\\D3DTRACE");
 303             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
 304 #endif
 305         }
 306     } else {
 307         if (isOn) {
 308             isOn = FALSE;
 309 #if defined(SHOW_FRAME_MAKEUP)
 310             FIXME("Single Frame snapshots Finishing\n");
 311             isDumpingFrames = FALSE;
 312 #endif
 313             FIXME("Disabling D3D Trace\n");
 314             __WINE_SET_DEBUGGING(__WINE_DBCL_TRACE, __wine_dbch_d3d, 0);
 315         }
 316     }
 317 }
 318 #endif
 319
 320     LEAVE_GL();
 321     /* Although this is not strictly required, a simple demo showed this does occur
 322        on (at least non-debug) d3d                                                  */
 323     if (This->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD) {
 324
 325         TRACE("Clearing\n");
 326
 327         IWineD3DDevice_Clear((IWineD3DDevice*)This->wineD3DDevice, 0, NULL, D3DCLEAR_STENCIL|D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET, 0x00, 1.0, 0);
 328
 329     } else {
 330         TRACE("Clearing z/stencil buffer\n");
 331
 332         IWineD3DDevice_Clear((IWineD3DDevice*)This->wineD3DDevice, 0, NULL, D3DCLEAR_STENCIL|D3DCLEAR_ZBUFFER, 0x00, 1.0, 0);
 333     }
 334
 335     TRACE("returning\n");
 336     return WINED3D_OK;
 337 }
 338
 339 HRESULT WINAPI IWineD3DSwapChainImpl_GetFrontBufferData(IWineD3DSwapChain *iface, IWineD3DSurface *pDestSurface) {
 340     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 341     WINED3DFORMAT d3dformat;
 342     UINT width;
 343     UINT height;
 344     WINED3DSURFACE_DESC desc;
 345     glDescriptor *glDescription;
 346
 347     TRACE("(%p) : iface(%p) pDestSurface(%p)\n", This, iface, pDestSurface);
 348     ENTER_GL();
 349     memset(&desc, 0, sizeof(desc));
 350     desc.Width =  &width;
 351     desc.Height = &height;
 352     desc.Format = &d3dformat;
 353 #if 0 /* TODO: make sure that this swapchains context is active */
 354     IWineD3DDevice_ActivateSwapChainContext(This->wineD3DDevice, iface);
 355 #endif
 356     IWineD3DSurface_GetDesc(pDestSurface, &desc);
 357     /* make sure that the front buffer is the active read buffer */
 358     glReadBuffer(GL_FRONT);
 359     /* Read the pixels from the buffer into the surfaces memory */
 360     IWineD3DSurface_GetGlDesc(pDestSurface, &glDescription);
 361     glReadPixels(glDescription->target,
 362                 glDescription->level,
 363                 width,
 364                 height,
 365                 glDescription->glFormat,
 366                 glDescription->glType,
 367                 (void *)IWineD3DSurface_GetData(pDestSurface));
 368     LEAVE_GL();
 369     return WINED3D_OK;
 370 }
 371
 372 HRESULT WINAPI IWineD3DSwapChainImpl_GetBackBuffer(IWineD3DSwapChain *iface, UINT iBackBuffer, WINED3DBACKBUFFER_TYPE Type, IWineD3DSurface **ppBackBuffer) {
 373
 374     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 375
 376     *ppBackBuffer = This->backBuffer;
 377     TRACE("(%p) : BackBuf %d Type %d  returning %p\n", This, iBackBuffer, Type, *ppBackBuffer);
 378
 379     if (iBackBuffer > This->presentParms.BackBufferCount - 1) {
 380         FIXME("Only one backBuffer currently supported\n");
 381         return WINED3DERR_INVALIDCALL;
 382     }
 383
 384     /* Note inc ref on returned surface */
 385     IWineD3DSurface_AddRef(*ppBackBuffer);
 386     return WINED3D_OK;
 387
 388 }
 389
 390 HRESULT WINAPI IWineD3DSwapChainImpl_GetRasterStatus(IWineD3DSwapChain *iface, WINED3DRASTER_STATUS *pRasterStatus) {
 391     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 392     static BOOL showFixmes = TRUE;
 393     pRasterStatus->InVBlank = TRUE;
 394     pRasterStatus->ScanLine = 0;
 395     /* No openGL equivalent */
 396     if(showFixmes) {
 397         FIXME("(%p) : stub (once)\n", This);
 398         showFixmes = FALSE;
 399     }
 400     return WINED3D_OK;
 401 }
 402
 403 HRESULT WINAPI IWineD3DSwapChainImpl_GetDisplayMode(IWineD3DSwapChain *iface, WINED3DDISPLAYMODE*pMode) {
 404     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 405     HDC                 hdc;
 406     int                 bpp = 0;
 407
 408     pMode->Width        = GetSystemMetrics(SM_CXSCREEN);
 409     pMode->Height       = GetSystemMetrics(SM_CYSCREEN);
 410     pMode->RefreshRate  = 85; /* FIXME: How to identify? */
 411
 412     hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
 413     bpp = GetDeviceCaps(hdc, BITSPIXEL);
 414     DeleteDC(hdc);
 415
 416     switch (bpp) {
 417     case  8: pMode->Format       = D3DFMT_R8G8B8; break;
 418     case 16: pMode->Format       = D3DFMT_R5G6B5; break;
 419     case 24: /*pMode->Format       = D3DFMT_R8G8B8; break; */ /* 32bpp and 24bpp can be aliased for X */
 420     case 32: pMode->Format       = D3DFMT_A8R8G8B8; break;
 421     default:
 422        FIXME("Unrecognized display mode format\n");
 423        pMode->Format       = D3DFMT_UNKNOWN;
 424     }
 425
 426     TRACE("(%p) : returning w(%d) h(%d) rr(%d) fmt(%u,%s)\n", This, pMode->Width, pMode->Height, pMode->RefreshRate,
 427     pMode->Format, debug_d3dformat(pMode->Format));
 428     return WINED3D_OK;
 429 }
 430
 431 HRESULT WINAPI IWineD3DSwapChainImpl_GetDevice(IWineD3DSwapChain *iface, IWineD3DDevice**ppDevice) {
 432     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 433
 434     *ppDevice = (IWineD3DDevice *) This->wineD3DDevice;
 435
 436     /* Note  Calling this method will increase the internal reference count
 437        on the IDirect3DDevice9 interface. */
 438     IWineD3DDevice_AddRef(*ppDevice);
 439     TRACE("(%p) : returning %p\n", This, *ppDevice);
 440     return WINED3D_OK;
 441 }
 442
 443 HRESULT WINAPI IWineD3DSwapChainImpl_GetPresentParameters(IWineD3DSwapChain *iface, WINED3DPRESENT_PARAMETERS *pPresentationParameters) {
 444     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 445     TRACE("(%p)\n", This);
 446     *pPresentationParameters->BackBufferWidth = This->presentParms.BackBufferWidth;
 447     *pPresentationParameters->BackBufferHeight = This->presentParms.BackBufferHeight;
 448     *pPresentationParameters->BackBufferFormat = This->presentParms.BackBufferFormat;
 449     *pPresentationParameters->BackBufferCount = This->presentParms.BackBufferCount;
 450     *pPresentationParameters->MultiSampleType = This->presentParms.MultiSampleType;
 451     *pPresentationParameters->MultiSampleQuality = This->presentParms.MultiSampleQuality;
 452     *pPresentationParameters->SwapEffect = This->presentParms.SwapEffect;
 453     *pPresentationParameters->hDeviceWindow = This->presentParms.hDeviceWindow;
 454     *pPresentationParameters->Windowed = This->presentParms.Windowed;
 455     *pPresentationParameters->EnableAutoDepthStencil = This->presentParms.EnableAutoDepthStencil;
 456     *pPresentationParameters->Flags = This->presentParms.Flags;
 457     *pPresentationParameters->FullScreen_RefreshRateInHz = This->presentParms.FullScreen_RefreshRateInHz;
 458     *pPresentationParameters->PresentationInterval = This->presentParms.PresentationInterval;
 459     return WINED3D_OK;
 460 }
 461
 462 HRESULT WINAPI IWineD3DSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface, DWORD Flags, CONST WINED3DGAMMARAMP *pRamp){
 463
 464     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 465     HDC hDC;
 466     TRACE("(%p) : pRamp@%p flags(%ld)\n", This, pRamp, Flags);
 467     hDC = GetDC(This->win_handle);
 468     SetDeviceGammaRamp(hDC, (LPVOID)pRamp);
 469     ReleaseDC(This->win_handle, hDC);
 470     return WINED3D_OK;
 471
 472 }
 473
 474 HRESULT WINAPI IWineD3DSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface, WINED3DGAMMARAMP *pRamp){
 475
 476     IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
 477     HDC hDC;
 478     TRACE("(%p) : pRamp@%p\n", This, pRamp);
 479     hDC = GetDC(This->win_handle);
 480     GetDeviceGammaRamp(hDC, pRamp);
 481     ReleaseDC(This->win_handle, hDC);
 482     return WINED3D_OK;
 483
 484 }
 485
 486
 487 IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl =
 488 {
 489     /* IUnknown */
 490     IWineD3DSwapChainImpl_QueryInterface,
 491     IWineD3DSwapChainImpl_AddRef,
 492     IWineD3DSwapChainImpl_Release,
 493     /* IWineD3DSwapChain */
 494     IWineD3DSwapChainImpl_GetParent,
 495     IWineD3DSwapChainImpl_GetDevice,
 496     IWineD3DSwapChainImpl_Present,
 497     IWineD3DSwapChainImpl_GetFrontBufferData,
 498     IWineD3DSwapChainImpl_GetBackBuffer,
 499     IWineD3DSwapChainImpl_GetRasterStatus,
 500     IWineD3DSwapChainImpl_GetDisplayMode,
 501     IWineD3DSwapChainImpl_GetPresentParameters,
 502     IWineD3DSwapChainImpl_SetGammaRamp,
 503     IWineD3DSwapChainImpl_GetGammaRamp
 504 };