dlls/d3d8/directx.c

   1 /*
   2  * IDirect3D8 implementation
   3  *
   4  * Copyright 2002 Jason Edmeades
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 #include "d3d8_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  37
  38 /* x11drv GDI escapes */
  39 #define X11DRV_ESCAPE 6789
  40 enum x11drv_escape_codes
  41 {
  42     X11DRV_GET_DISPLAY,   /* get X11 display for a DC */
  43     X11DRV_GET_DRAWABLE,  /* get current drawable for a DC */
  44     X11DRV_GET_FONT,      /* get current X font for a DC */
  45 };
  46
  47 #define NUM_FORMATS 7
  48 static const D3DFORMAT device_formats[NUM_FORMATS] = {
  49   D3DFMT_P8,
  50   D3DFMT_R3G3B2,
  51   D3DFMT_R5G6B5,
  52   D3DFMT_X1R5G5B5,
  53   D3DFMT_X4R4G4B4,
  54   D3DFMT_R8G8B8,
  55   D3DFMT_X8R8G8B8
  56 };
  57
  58
  59 /* retrieve the X display to use on a given DC */
  60 inline static Display *get_display( HDC hdc )
  61 {
  62     Display *display;
  63     enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
  64
  65     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
  66                     sizeof(display), (LPSTR)&display )) display = NULL;
  67     return display;
  68 }
  69
  70
  71 /* IDirect3D IUnknown parts follow: */
  72 HRESULT WINAPI IDirect3D8Impl_QueryInterface(LPDIRECT3D8 iface,REFIID riid,LPVOID *ppobj)
  73 {
  74     ICOM_THIS(IDirect3D8Impl,iface);
  75
  76     if (IsEqualGUID(riid, &IID_IUnknown)
  77         || IsEqualGUID(riid, &IID_IDirect3D8)) {
  78         IDirect3D8Impl_AddRef(iface);
  79         *ppobj = This;
  80         return D3D_OK;
  81     }
  82
  83     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
  84     return E_NOINTERFACE;
  85 }
  86
  87 ULONG WINAPI IDirect3D8Impl_AddRef(LPDIRECT3D8 iface) {
  88     ICOM_THIS(IDirect3D8Impl,iface);
  89     TRACE("(%p) : AddRef from %ld\n", This, This->ref);
  90     return ++(This->ref);
  91 }
  92
  93 ULONG WINAPI IDirect3D8Impl_Release(LPDIRECT3D8 iface) {
  94     ICOM_THIS(IDirect3D8Impl,iface);
  95     ULONG ref = --This->ref;
  96     TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
  97     if (ref == 0)
  98         HeapFree(GetProcessHeap(), 0, This);
  99     return ref;
 100 }
 101
 102 /* IDirect3D Interface follow: */
 103 HRESULT  WINAPI  IDirect3D8Impl_RegisterSoftwareDevice     (LPDIRECT3D8 iface, void* pInitializeFunction) {
 104     ICOM_THIS(IDirect3D8Impl,iface);
 105     FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
 106     return D3D_OK;
 107 }
 108
 109 UINT     WINAPI  IDirect3D8Impl_GetAdapterCount            (LPDIRECT3D8 iface) {
 110     ICOM_THIS(IDirect3D8Impl,iface);
 111     /* FIXME: Set to one for now to imply the display */
 112     TRACE("(%p): Mostly stub, only returns primary display\n", This);
 113     return 1;
 114 }
 115
 116 HRESULT  WINAPI  IDirect3D8Impl_GetAdapterIdentifier       (LPDIRECT3D8 iface,
 117                                                             UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) {
 118     ICOM_THIS(IDirect3D8Impl,iface);
 119
 120     TRACE("(%p}->(Adapter: %d, Flags: %lx, pId=%p)\n", This, Adapter, Flags, pIdentifier);
 121
 122     if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) {
 123         return D3DERR_INVALIDCALL;
 124     }
 125
 126     if (Adapter == 0) { /* Display */
 127         strcpy(pIdentifier->Driver, "Display");
 128         strcpy(pIdentifier->Description, "Direct3D Display");
 129         pIdentifier->DriverVersion.s.HighPart = 1;
 130         pIdentifier->DriverVersion.s.LowPart = 0;
 131         pIdentifier->VendorId = 0;
 132         pIdentifier->DeviceId = 0;
 133         pIdentifier->SubSysId = 0;
 134         pIdentifier->Revision = 0;
 135         /*FIXME: memcpy(&pIdentifier->DeviceIdentifier, ??, sizeof(??GUID)); */
 136         if (Flags & D3DENUM_NO_WHQL_LEVEL) {
 137             pIdentifier->WHQLLevel = 0;
 138         } else {
 139             pIdentifier->WHQLLevel = 1;
 140         }
 141     } else {
 142         FIXME("Adapter not primary display\n");
 143     }
 144
 145     return D3D_OK;
 146 }
 147
 148 UINT     WINAPI  IDirect3D8Impl_GetAdapterModeCount        (LPDIRECT3D8 iface,
 149                                                             UINT Adapter) {
 150     ICOM_THIS(IDirect3D8Impl,iface);
 151
 152     TRACE("(%p}->(Adapter: %d)\n", This, Adapter);
 153
 154     if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) {
 155         return D3DERR_INVALIDCALL;
 156     }
 157
 158     if (Adapter == 0) { /* Display */
 159         DEVMODEW DevModeW;
 160         int i = 0;
 161
 162         while (EnumDisplaySettingsExW(NULL, i, &DevModeW, 0)) {
 163             i++;
 164         }
 165         TRACE("(%p}->(Adapter: %d) => %d\n", This, Adapter, i);
 166         return i;
 167     } else {
 168         FIXME("Adapter not primary display\n");
 169     }
 170
 171     return 0;
 172 }
 173
 174 HRESULT  WINAPI  IDirect3D8Impl_EnumAdapterModes           (LPDIRECT3D8 iface,
 175                                                             UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode) {
 176     ICOM_THIS(IDirect3D8Impl,iface);
 177
 178     TRACE("(%p}->(Adapter:%d, mode:%d, pMode:%p)\n", This, Adapter, Mode, pMode);
 179
 180     if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) {
 181         return D3DERR_INVALIDCALL;
 182     }
 183
 184     if (Adapter == 0) { /* Display */
 185         HDC hdc;
 186         int bpp = 0;
 187         DEVMODEW DevModeW;
 188
 189         if (EnumDisplaySettingsExW(NULL, Mode, &DevModeW, 0))
 190         {
 191             pMode->Width        = DevModeW.dmPelsWidth;
 192             pMode->Height       = DevModeW.dmPelsHeight;
 193             bpp                 = DevModeW.dmBitsPerPel;
 194             pMode->RefreshRate  = D3DADAPTER_DEFAULT;
 195             if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
 196             {
 197                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
 198             }
 199         }
 200         else
 201         {
 202             TRACE("Requested mode out of range %d\n", Mode);
 203             return D3DERR_INVALIDCALL;
 204         }
 205
 206         hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
 207         bpp = min(GetDeviceCaps(hdc, BITSPIXEL), bpp);
 208         DeleteDC(hdc);
 209
 210         switch (bpp) {
 211         case  8: pMode->Format = D3DFMT_R3G3B2;   break;
 212         case 16: pMode->Format = D3DFMT_R5G6B5;   break;
 213         case 24: /* pMode->Format = D3DFMT_R5G6B5;   break;*/ /* Make 24bit appear as 32 bit */
 214         case 32: pMode->Format = D3DFMT_A8R8G8B8; break;
 215         default: pMode->Format = D3DFMT_UNKNOWN;
 216         }
 217         TRACE("W %d H %d rr %d fmt (%x,%s) bpp %u\n", pMode->Width, pMode->Height, pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format), bpp);
 218
 219     } else {
 220         FIXME("Adapter not primary display\n");
 221     }
 222
 223     return D3D_OK;
 224 }
 225
 226 HRESULT  WINAPI  IDirect3D8Impl_GetAdapterDisplayMode      (LPDIRECT3D8 iface,
 227                                                             UINT Adapter, D3DDISPLAYMODE* pMode) {
 228     ICOM_THIS(IDirect3D8Impl,iface);
 229     TRACE("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
 230
 231     if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) {
 232         return D3DERR_INVALIDCALL;
 233     }
 234
 235     if (Adapter == 0) { /* Display */
 236         int bpp = 0;
 237         DEVMODEW DevModeW;
 238
 239         EnumDisplaySettingsExW(NULL, (DWORD)-1, &DevModeW, 0);
 240         pMode->Width        = DevModeW.dmPelsWidth;
 241         pMode->Height       = DevModeW.dmPelsHeight;
 242         bpp                 = DevModeW.dmBitsPerPel;
 243         pMode->RefreshRate  = D3DADAPTER_DEFAULT;
 244         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
 245         {
 246             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
 247         }
 248
 249         switch (bpp) {
 250         case  8: pMode->Format       = D3DFMT_R3G3B2;   break;
 251         case 16: pMode->Format       = D3DFMT_R5G6B5;   break;
 252         case 24: /*pMode->Format       = D3DFMT_R5G6B5;   break;*/ /* Make 24bit appear as 32 bit */
 253         case 32: pMode->Format       = D3DFMT_A8R8G8B8; break;
 254         default: pMode->Format       = D3DFMT_UNKNOWN;
 255         }
 256
 257     } else {
 258         FIXME("Adapter not primary display\n");
 259     }
 260
 261     TRACE("returning w:%d, h:%d, ref:%d, fmt:%x\n", pMode->Width,
 262           pMode->Height, pMode->RefreshRate, pMode->Format);
 263     return D3D_OK;
 264 }
 265
 266 HRESULT  WINAPI  IDirect3D8Impl_CheckDeviceType            (LPDIRECT3D8 iface,
 267                                                             UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat,
 268                                                             D3DFORMAT BackBufferFormat, BOOL Windowed) {
 269     ICOM_THIS(IDirect3D8Impl,iface);
 270     FIXME("(%p)->(Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
 271           This,
 272           Adapter,
 273           CheckType, debug_d3ddevicetype(CheckType),
 274           DisplayFormat, debug_d3dformat(DisplayFormat),
 275           BackBufferFormat, debug_d3dformat(BackBufferFormat),
 276           Windowed);
 277     return D3D_OK;
 278 }
 279
 280 HRESULT  WINAPI  IDirect3D8Impl_CheckDeviceFormat          (LPDIRECT3D8 iface,
 281                                                             UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
 282                                                             DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
 283     ICOM_THIS(IDirect3D8Impl,iface);
 284     FIXME("(%p)->(Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%lu,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
 285           This,
 286           Adapter,
 287           DeviceType, debug_d3ddevicetype(DeviceType),
 288           AdapterFormat, debug_d3dformat(AdapterFormat),
 289           Usage, debug_d3dusage(Usage),
 290           RType, debug_d3dressourcetype(RType),
 291           CheckFormat, debug_d3dformat(CheckFormat));
 292
 293     if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
 294         switch (CheckFormat) {
 295         case D3DFMT_DXT1:
 296         case D3DFMT_DXT3:
 297         case D3DFMT_DXT5:
 298             return D3D_OK;
 299         default:
 300             break; /* Avoid compiler warnings */
 301         }
 302     }
 303
 304     switch (CheckFormat) {
 305     case D3DFMT_UYVY:
 306     case D3DFMT_YUY2:
 307     case D3DFMT_DXT1:
 308     case D3DFMT_DXT2:
 309     case D3DFMT_DXT3:
 310     case D3DFMT_DXT4:
 311     case D3DFMT_DXT5:
 312     case D3DFMT_X8L8V8U8:
 313     case D3DFMT_L6V5U5:
 314     case D3DFMT_V8U8:
 315       /* Since we do not support these formats right now, don't pretend to. */
 316       return D3DERR_NOTAVAILABLE;
 317     default:
 318       break;
 319     }
 320
 321     return D3D_OK;
 322 }
 323
 324 HRESULT  WINAPI  IDirect3D8Impl_CheckDeviceMultiSampleType(LPDIRECT3D8 iface,
 325                                                            UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat,
 326                                                            BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) {
 327     ICOM_THIS(IDirect3D8Impl,iface);
 328     FIXME("(%p)->(Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x)\n",
 329           This,
 330           Adapter,
 331           DeviceType, debug_d3ddevicetype(DeviceType),
 332           SurfaceFormat, debug_d3dformat(SurfaceFormat),
 333           Windowed,
 334           MultiSampleType);
 335
 336     if (D3DMULTISAMPLE_NONE == MultiSampleType)
 337       return D3D_OK;
 338     return D3DERR_NOTAVAILABLE;
 339 }
 340
 341 HRESULT  WINAPI  IDirect3D8Impl_CheckDepthStencilMatch(LPDIRECT3D8 iface,
 342                                                        UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
 343                                                        D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) {
 344     ICOM_THIS(IDirect3D8Impl,iface);
 345     FIXME("(%p)->(Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
 346           This,
 347           Adapter,
 348           DeviceType, debug_d3ddevicetype(DeviceType),
 349           AdapterFormat, debug_d3dformat(AdapterFormat),
 350           RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
 351           DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
 352
 353 #if 0
 354     switch (DepthStencilFormat) {
 355     case D3DFMT_D24X4S4:
 356     case D3DFMT_D24X8:
 357     case D3DFMT_D24S8:
 358     case D3DFMT_D32:
 359       /**
 360        * as i don't know how to really check hard caps of graphics cards
 361        * i prefer to not permit 32bit zbuffers enumeration (as few cards can do it)
 362        */
 363       return D3DERR_NOTAVAILABLE;
 364     default:
 365       break;
 366     }
 367 #endif
 368     return D3D_OK;
 369 }
 370
 371 HRESULT  WINAPI  IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) {
 372
 373     BOOL        gotContext  = FALSE;
 374     BOOL        created     = FALSE;
 375     GLint       gl_tex_size = 0;
 376     GLXContext  gl_context  = 0;
 377     Display    *display     = NULL;
 378     ICOM_THIS(IDirect3D8Impl,iface);
 379
 380     TRACE("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
 381
 382     /* Note: GL seems to trap if GetDeviceCaps is called before any HWND's created
 383         ie there is no GL Context - Get a default rendering context to enable the
 384         function query some info from GL                                           */
 385     if (glXGetCurrentContext() == NULL) {
 386
 387         XVisualInfo  template;
 388         XVisualInfo *vis;
 389         HDC          device_context;
 390         Visual      *visual;
 391         Drawable     drawable = (Drawable) GetPropA(GetDesktopWindow(), "__wine_x11_whole_window");
 392         XWindowAttributes win_attr;
 393         BOOL         failed = FALSE;
 394         int          num;
 395
 396         /* Get the display */
 397         device_context = GetDC(0);
 398         display = get_display(device_context);
 399         ReleaseDC(0, device_context);
 400
 401         /* Get the X visual */
 402         ENTER_GL();
 403         if (XGetWindowAttributes(display, drawable, &win_attr)) {
 404             visual = win_attr.visual;
 405         } else {
 406             visual = DefaultVisual(display, DefaultScreen(display));
 407         }
 408         template.visualid = XVisualIDFromVisual(visual);
 409         vis = XGetVisualInfo(display, VisualIDMask, &template, &num);
 410         if (vis == NULL) {
 411             LEAVE_GL();
 412             WARN("Error creating visual info for capabilities initialization\n");
 413             failed = TRUE;
 414         }
 415
 416         /* Create a GL context */
 417         if (!failed) {
 418            gl_context = glXCreateContext(display, vis, NULL, GL_TRUE);
 419
 420            if (gl_context == NULL) {
 421               LEAVE_GL();
 422               WARN("Error creating default context for capabilities initialization\n");
 423               failed = TRUE;
 424            }
 425         }
 426
 427         /* Make it the current GL context */
 428         if (!failed && glXMakeCurrent(display, drawable, gl_context) == False) {
 429             glXDestroyContext(display, gl_context);
 430             LEAVE_GL();
 431             WARN("Error setting default context as current for capabilities initialization\n");
 432             failed = TRUE;
 433         }
 434
 435         /* It worked! Wow... */
 436         if (!failed) {
 437            gotContext = TRUE;
 438            created = TRUE;
 439         }
 440     } else {
 441         gotContext = TRUE;
 442     }
 443
 444     if (gotContext == FALSE) {
 445
 446         FIXME("GetDeviceCaps called but no GL Context - Returning dummy values\n");
 447         gl_tex_size=65535;
 448         pCaps->MaxTextureBlendStages = 2;
 449         pCaps->MaxSimultaneousTextures = 2;
 450         pCaps->MaxUserClipPlanes = 8;
 451         pCaps->MaxActiveLights = 8;
 452         pCaps->MaxVertexBlendMatrices = 0;
 453         pCaps->MaxVertexBlendMatrixIndex = 1;
 454         pCaps->MaxAnisotropy = 0;
 455         pCaps->MaxPointSize = 255.0;
 456     } else {
 457         glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_tex_size);
 458     }
 459     pCaps->DeviceType = (DeviceType == D3DDEVTYPE_HAL) ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
 460     pCaps->AdapterOrdinal = Adapter;
 461
 462     pCaps->Caps = 0;
 463     pCaps->Caps2 = D3DCAPS2_CANRENDERWINDOWED;
 464     pCaps->Caps3 = D3DDEVCAPS_HWTRANSFORMANDLIGHT;
 465     pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_IMMEDIATE;
 466
 467     pCaps->CursorCaps = 0;
 468
 469     pCaps->DevCaps = D3DDEVCAPS_DRAWPRIMTLVERTEX    |
 470                      D3DDEVCAPS_HWTRANSFORMANDLIGHT |
 471                      D3DDEVCAPS_PUREDEVICE;
 472
 473     pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_CULLCCW               |
 474                                D3DPMISCCAPS_CULLCW                |
 475                                D3DPMISCCAPS_COLORWRITEENABLE      |
 476                                D3DPMISCCAPS_CLIPTLVERTS           |
 477                                D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
 478                                D3DPMISCCAPS_MASKZ;
 479                                /*NOT: D3DPMISCCAPS_TSSARGTEMP*/
 480
 481     pCaps->RasterCaps = D3DPRASTERCAPS_DITHER   |
 482                         D3DPRASTERCAPS_PAT      |
 483                         D3DPRASTERCAPS_FOGRANGE;
 484                         /* FIXME Add:
 485                            D3DPRASTERCAPS_FOGVERTEX
 486                            D3DPRASTERCAPS_FOGTABLE
 487                            D3DPRASTERCAPS_MIPMAPLODBIAS
 488                            D3DPRASTERCAPS_ZBIAS
 489                            D3DPRASTERCAPS_ANISOTROPY
 490                            D3DPRASTERCAPS_WFOG
 491                            D3DPRASTERCAPS_ZFOG
 492                            D3DPRASTERCAPS_COLORPERSPECTIVE
 493                            D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
 494                            D3DPRASTERCAPS_ANTIALIASEDGES
 495                            D3DPRASTERCAPS_ZBUFFERLESSHSR
 496                            D3DPRASTERCAPS_WBUFFER */
 497
 498     pCaps->ZCmpCaps = D3DPCMPCAPS_ALWAYS       |
 499                       D3DPCMPCAPS_EQUAL        |
 500                       D3DPCMPCAPS_GREATER      |
 501                       D3DPCMPCAPS_GREATEREQUAL |
 502                       D3DPCMPCAPS_LESS         |
 503                       D3DPCMPCAPS_LESSEQUAL    |
 504                       D3DPCMPCAPS_NEVER        |
 505                       D3DPCMPCAPS_NOTEQUAL;
 506
 507     pCaps->SrcBlendCaps  = 0xFFFFFFFF;   /*FIXME: Tidy up later */
 508     pCaps->DestBlendCaps = 0xFFFFFFFF;   /*FIXME: Tidy up later */
 509     pCaps->AlphaCmpCaps  = 0xFFFFFFFF;   /*FIXME: Tidy up later */
 510
 511     pCaps->ShadeCaps = D3DPSHADECAPS_SPECULARGOURAUDRGB |
 512                        D3DPSHADECAPS_COLORGOURAUDRGB;
 513
 514     pCaps->TextureCaps =  D3DPTEXTURECAPS_ALPHA        |
 515                           D3DPTEXTURECAPS_ALPHAPALETTE |
 516                           D3DPTEXTURECAPS_POW2         |
 517                           D3DPTEXTURECAPS_VOLUMEMAP    |
 518                           D3DPTEXTURECAPS_MIPMAP;
 519 #if defined(GL_VERSION_1_3) || defined(GL_ARB_texture_cube_map)
 520     pCaps->TextureCaps |= D3DPTEXTURECAPS_CUBEMAP      |
 521                           D3DPTEXTURECAPS_MIPCUBEMAP   |
 522                           D3DPTEXTURECAPS_CUBEMAP_POW2;
 523 #endif
 524
 525     pCaps->TextureFilterCaps = D3DPTFILTERCAPS_MAGFLINEAR |
 526                                D3DPTFILTERCAPS_MAGFPOINT  |
 527                                D3DPTFILTERCAPS_MINFLINEAR |
 528                                D3DPTFILTERCAPS_MINFPOINT  |
 529                                D3DPTFILTERCAPS_MIPFLINEAR |
 530                                D3DPTFILTERCAPS_MIPFPOINT;
 531
 532     pCaps->CubeTextureFilterCaps = 0;
 533     pCaps->VolumeTextureFilterCaps = 0;
 534
 535     pCaps->TextureAddressCaps =  D3DPTADDRESSCAPS_BORDER |
 536                                  D3DPTADDRESSCAPS_CLAMP  |
 537                                  D3DPTADDRESSCAPS_WRAP;
 538 #if defined(GL_VERSION_1_3)
 539     pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
 540 #endif
 541                                  /* FIXME: Add
 542                                     D3DPTADDRESSCAPS_BORDER
 543                                     D3DPTADDRESSCAPS_MIRRORONCE */
 544
 545     pCaps->VolumeTextureAddressCaps = 0;
 546
 547     pCaps->LineCaps = D3DLINECAPS_TEXTURE |
 548                       D3DLINECAPS_ZTEST;
 549                       /* FIXME: Add
 550                          D3DLINECAPS_BLEND
 551                          D3DLINECAPS_ALPHACMP
 552                          D3DLINECAPS_FOG */
 553
 554     pCaps->MaxTextureWidth = gl_tex_size;
 555     pCaps->MaxTextureHeight = gl_tex_size;
 556
 557     pCaps->MaxVolumeExtent = 0;
 558
 559     pCaps->MaxTextureRepeat = 32768;
 560     pCaps->MaxTextureAspectRatio = 32768;
 561     pCaps->MaxVertexW = 1.0;
 562
 563     pCaps->GuardBandLeft = 0;
 564     pCaps->GuardBandTop = 0;
 565     pCaps->GuardBandRight = 0;
 566     pCaps->GuardBandBottom = 0;
 567
 568     pCaps->ExtentsAdjust = 0;
 569
 570     pCaps->StencilCaps =  D3DSTENCILCAPS_DECRSAT |
 571                           D3DSTENCILCAPS_INCRSAT |
 572                           D3DSTENCILCAPS_INVERT  |
 573                           D3DSTENCILCAPS_KEEP    |
 574                           D3DSTENCILCAPS_REPLACE |
 575                           D3DSTENCILCAPS_ZERO;
 576 #if defined(GL_VERSION_1_4) || defined(GL_EXT_stencil_wrap)
 577     pCaps->StencilCaps |= D3DSTENCILCAPS_DECR    |
 578                           D3DSTENCILCAPS_INCR;
 579 #endif
 580
 581     pCaps->FVFCaps = D3DFVFCAPS_PSIZE | 0x80000;
 582
 583     pCaps->TextureOpCaps =  D3DTEXOPCAPS_ADD         |
 584                             D3DTEXOPCAPS_ADDSIGNED   |
 585                             D3DTEXOPCAPS_ADDSIGNED2X |
 586                             D3DTEXOPCAPS_MODULATE    |
 587                             D3DTEXOPCAPS_MODULATE2X  |
 588                             D3DTEXOPCAPS_MODULATE4X  |
 589                             D3DTEXOPCAPS_SELECTARG1  |
 590                             D3DTEXOPCAPS_SELECTARG2  |
 591                             D3DTEXOPCAPS_DISABLE;
 592 #if defined(GL_VERSION_1_3)
 593     pCaps->TextureOpCaps |= D3DTEXOPCAPS_DOTPRODUCT3 |
 594                             D3DTEXOPCAPS_SUBTRACT;
 595 #endif
 596                             /* FIXME: Add
 597                               D3DTEXOPCAPS_ADDSMOOTH
 598                               D3DTEXOPCAPS_BLENDCURRENTALPHA
 599                               D3DTEXOPCAPS_BLENDDIFFUSEALPHA
 600                               D3DTEXOPCAPS_BLENDFACTORALPHA
 601                               D3DTEXOPCAPS_BLENDTEXTUREALPHA
 602                               D3DTEXOPCAPS_BLENDTEXTUREALPHAPM
 603                               D3DTEXOPCAPS_BUMPENVMAP
 604                               D3DTEXOPCAPS_BUMPENVMAPLUMINANCE
 605                               D3DTEXOPCAPS_LERP
 606                               D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
 607                               D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
 608                               D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
 609                               D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
 610                               D3DTEXOPCAPS_MULTIPLYADD
 611                               D3DTEXOPCAPS_PREMODULATE */
 612
 613     if (gotContext) {
 614         GLint gl_max;
 615         GLfloat gl_float;
 616 #if defined(GL_VERSION_1_3)
 617         glGetIntegerv(GL_MAX_TEXTURE_UNITS, &gl_max);
 618 #else
 619         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
 620 #endif
 621         TRACE("GLCaps: GL_MAX_TEXTURE_UNITS_ARB=%d\n", gl_max);
 622         pCaps->MaxTextureBlendStages = min(8, gl_max);
 623         pCaps->MaxSimultaneousTextures = min(8, gl_max);
 624
 625         glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
 626         pCaps->MaxUserClipPlanes = min(MAX_CLIPPLANES, gl_max);
 627         TRACE("GLCaps: GL_MAX_CLIP_PLANES=%ld\n", pCaps->MaxUserClipPlanes);
 628
 629         glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
 630         pCaps->MaxActiveLights = gl_max;
 631         TRACE("GLCaps: GL_MAX_LIGHTS=%ld\n", pCaps->MaxActiveLights);
 632
 633 #if defined(GL_ARB_vertex_blend)
 634         glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
 635         pCaps->MaxVertexBlendMatrices = gl_max;
 636         pCaps->MaxVertexBlendMatrixIndex = 1;
 637 #else
 638         pCaps->MaxVertexBlendMatrices = 0;
 639         pCaps->MaxVertexBlendMatrixIndex = 1;
 640 #endif
 641
 642 #if defined(GL_EXT_texture_filter_anisotropic)
 643         glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
 644         pCaps->MaxAnisotropy = gl_max;
 645 #else
 646         pCaps->MaxAnisotropy = 0;
 647 #endif
 648
 649         glGetFloatv(GL_POINT_SIZE_RANGE, &gl_float);
 650         pCaps->MaxPointSize = gl_float;
 651     }
 652
 653     pCaps->VertexProcessingCaps = D3DVTXPCAPS_DIRECTIONALLIGHTS |
 654                                   D3DVTXPCAPS_MATERIALSOURCE7   |
 655                                   D3DVTXPCAPS_POSITIONALLIGHTS  |
 656                                   D3DVTXPCAPS_TEXGEN;
 657                                   /* FIXME: Add
 658                                      D3DVTXPCAPS_LOCALVIEWER
 659                                      D3DVTXPCAPS_TWEENING */
 660
 661     pCaps->MaxPrimitiveCount = 0xFFFFFFFF;
 662     pCaps->MaxVertexIndex = 0xFFFFFFFF;
 663     pCaps->MaxStreams = MAX_STREAMS;
 664     pCaps->MaxStreamStride = 1024;
 665
 666 #if 1
 667     pCaps->VertexShaderVersion = D3DVS_VERSION(1,1);
 668     pCaps->MaxVertexShaderConst = D3D8_VSHADER_MAX_CONSTANTS;
 669 #else
 670     pCaps->VertexShaderVersion = 0;
 671     pCaps->MaxVertexShaderConst = D3D8_VSHADER_MAX_CONSTANTS;
 672 #endif
 673
 674 #if 0
 675     pCaps->PixelShaderVersion = D3DPS_VERSION(1,1);
 676     pCaps->MaxPixelShaderValue = 1.0;
 677 #else
 678     pCaps->PixelShaderVersion = 0;
 679     pCaps->MaxPixelShaderValue = 0.0;
 680 #endif
 681
 682     /* If we created a dummy context, throw it away */
 683     if (created) {
 684         glXMakeCurrent(display, None, NULL);
 685         glXDestroyContext(display, gl_context);
 686         LEAVE_GL();
 687     }
 688     return D3D_OK;
 689 }
 690
 691 HMONITOR WINAPI  IDirect3D8Impl_GetAdapterMonitor(LPDIRECT3D8 iface, UINT Adapter) {
 692     ICOM_THIS(IDirect3D8Impl,iface);
 693     FIXME("(%p)->(Adptr:%d)\n", This, Adapter);
 694     return D3D_OK;
 695 }
 696
 697
 698 static void IDirect3D8Impl_FillGLCaps(LPDIRECT3D8 iface, Display* display) {
 699     const char *GL_Extensions = NULL;
 700     const char *GLX_Extensions = NULL;
 701     GLint gl_max;
 702     ICOM_THIS(IDirect3D8Impl,iface);
 703
 704     /*
 705      * Initialize openGL extension related variables
 706      *  with Default values
 707      */
 708     memset(&This->gl_info.supported, 0, sizeof(This->gl_info.supported));
 709     This->gl_info.max_textures   = 1;
 710     This->gl_info.ps_arb_version = PS_VERSION_NOT_SUPPORTED;
 711     This->gl_info.vs_arb_version = VS_VERSION_NOT_SUPPORTED;
 712     This->gl_info.vs_nv_version  = VS_VERSION_NOT_SUPPORTED;
 713     This->gl_info.vs_ati_version = VS_VERSION_NOT_SUPPORTED;
 714
 715 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = NULL;
 716     GL_EXT_FUNCS_GEN;
 717 #undef USE_GL_FUNC
 718
 719     /* Retrieve opengl defaults */
 720     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
 721     This->gl_info.max_clipplanes = min(MAX_CLIPPLANES, gl_max);
 722     TRACE("ClipPlanes support - num Planes=%d\n", gl_max);
 723
 724     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
 725     This->gl_info.max_lights = gl_max;
 726     TRACE("Lights support - max lights=%d\n", gl_max);
 727
 728     /* Parse the gl supported features, in theory enabling parts of our code appropriately */
 729     GL_Extensions = glGetString(GL_EXTENSIONS);
 730     FIXME("GL_Extensions reported:\n");
 731
 732     if (NULL == GL_Extensions) {
 733       ERR("   GL_Extensions returns NULL\n");
 734     } else {
 735       while (*GL_Extensions != 0x00) {
 736         const char *Start = GL_Extensions;
 737         char ThisExtn[256];
 738
 739         memset(ThisExtn, 0x00, sizeof(ThisExtn));
 740         while (*GL_Extensions != ' ' && *GL_Extensions != 0x00) {
 741           GL_Extensions++;
 742         }
 743         memcpy(ThisExtn, Start, (GL_Extensions - Start));
 744         FIXME("- %s\n", ThisExtn);
 745
 746         /**
 747          * ARB
 748          */
 749         if (strcmp(ThisExtn, "GL_ARB_fragment_program") == 0) {
 750           This->gl_info.ps_arb_version = PS_VERSION_11;
 751           FIXME(" FOUND: ARB Pixel Shader support - version=%02x\n", This->gl_info.ps_arb_version);
 752           This->gl_info.supported[ARB_FRAGMENT_PROGRAM] = TRUE;
 753         } else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
 754           FIXME(" FOUND: ARB Multisample support\n");
 755           This->gl_info.supported[ARB_MULTISAMPLE] = TRUE;
 756         } else if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
 757           glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
 758           FIXME(" FOUND: ARB Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%u\n", gl_max);
 759           This->gl_info.supported[ARB_MULTITEXTURE] = TRUE;
 760           This->gl_info.max_textures = min(8, gl_max);
 761         } else if (strcmp(ThisExtn, "GL_ARB_texture_cube_map") == 0) {
 762           FIXME(" FOUND: ARB Texture Cube Map support\n");
 763           This->gl_info.supported[ARB_TEXTURE_CUBE_MAP] = TRUE;
 764         } else if (strcmp(ThisExtn, "GL_ARB_texture_compression") == 0) {
 765           FIXME(" FOUND: ARB Texture Compression support\n");
 766           This->gl_info.supported[ARB_TEXTURE_COMPRESSION] = TRUE;
 767         } else if (strcmp(ThisExtn, "GL_ARB_texture_env_combine") == 0) {
 768           FIXME(" FOUND: EXT Texture Env combine support\n");
 769           This->gl_info.supported[ARB_TEXTURE_ENV_COMBINE] = TRUE;
 770         } else if (strcmp(ThisExtn, "GL_ARB_texture_env_dot3") == 0) {
 771           if (FALSE == This->gl_info.supported[ARB_TEXTURE_ENV_DOT3]) {
 772             FIXME(" FOUND: EXT Dot3 support\n");
 773             This->gl_info.supported[ARB_TEXTURE_ENV_DOT3] = TRUE;
 774           }
 775         } else if (strstr(ThisExtn, "GL_ARB_vertex_program")) {
 776           This->gl_info.vs_arb_version = VS_VERSION_11;
 777           FIXME(" FOUND: ARB Vertex Shader support - version=%02x\n", This->gl_info.vs_arb_version);
 778           This->gl_info.supported[ARB_VERTEX_PROGRAM] = TRUE;
 779
 780         /**
 781          * EXT
 782          */
 783         } else if (strcmp(ThisExtn, "GL_EXT_fog_coord") == 0) {
 784           FIXME(" FOUND: EXT Fog coord support\n");
 785           This->gl_info.supported[EXT_FOG_COORD] = TRUE;
 786         } else if (strcmp(ThisExtn, "GL_EXT_paletted_texture") == 0) { /* handle paletted texture extensions */
 787           FIXME(" FOUND: EXT Paletted texture support\n");
 788           This->gl_info.supported[EXT_PALETTED_TEXTURE] = TRUE;
 789         } else if (strcmp(ThisExtn, "GL_EXT_point_parameters") == 0) {
 790           FIXME(" FOUND: EXT Point parameters support\n");
 791           This->gl_info.supported[EXT_POINT_PARAMETERS] = TRUE;
 792         } else if (strcmp(ThisExtn, "GL_EXT_secondary_color") == 0) {
 793           FIXME(" FOUND: EXT Secondary coord support\n");
 794           This->gl_info.supported[EXT_SECONDARY_COLOR] = TRUE;
 795 #if defined(GL_EXT_texture_compression_s3tc)
 796         } else if (strcmp(ThisExtn, "GL_EXT_texture_compression_s3tc") == 0) {
 797           FIXME(" FOUND: EXT Texture S3TC compression support\n");
 798           This->gl_info.supported[EXT_TEXTURE_COMPRESSION_S3TC] = TRUE;
 799 #endif
 800         } else if (strcmp(ThisExtn, "GL_EXT_texture_env_dot3") == 0) {
 801           if (FALSE == This->gl_info.supported[ARB_TEXTURE_ENV_DOT3]) {
 802             FIXME(" FOUND: EXT Dot3 support\n");
 803             This->gl_info.supported[ARB_TEXTURE_ENV_DOT3] = TRUE;
 804           }
 805         } else if (strcmp(ThisExtn, "GL_EXT_texture_filter_anisotropic") == 0) {
 806           FIXME(" FOUND: EXT Texture Anisotropic filter support\n");
 807           This->gl_info.supported[EXT_TEXTURE_FILTER_ANISOTROPIC] = TRUE;
 808         } else if (strcmp(ThisExtn, "GL_EXT_texture_lod") == 0) {
 809           FIXME(" FOUND: EXT Texture LOD support\n");
 810           This->gl_info.supported[EXT_TEXTURE_LOD] = TRUE;
 811         } else if (strcmp(ThisExtn, "GL_EXT_texture_lod_bias") == 0) {
 812           FIXME(" FOUND: EXT Texture LOD bias support\n");
 813           This->gl_info.supported[EXT_TEXTURE_LOD_BIAS] = TRUE;
 814         } else if (strcmp(ThisExtn, "GL_EXT_vertex_weighting") == 0) {
 815           FIXME(" FOUND: EXT Vertex weighting support\n");
 816           This->gl_info.supported[EXT_VERTEX_WEIGHTING] = TRUE;
 817
 818         /**
 819          * NVIDIA
 820          */
 821         } else if (strstr(ThisExtn, "GL_NV_fragment_program")) {
 822           This->gl_info.ps_nv_version = PS_VERSION_11;
 823           FIXME(" FOUND: NVIDIA (NV) Pixel Shader support - version=%02x\n", This->gl_info.ps_nv_version);
 824           This->gl_info.supported[NV_FRAGMENT_PROGRAM] = TRUE;
 825         } else if (strstr(ThisExtn, "GL_NV_vertex_program")) {
 826           This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program1_1")) ? VS_VERSION_11 : VS_VERSION_10);
 827           This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program2"))   ? VS_VERSION_20 : VS_VERSION_10);
 828           FIXME(" FOUND: NVIDIA (NV) Vertex Shader support - version=%02x\n", This->gl_info.vs_nv_version);
 829           This->gl_info.supported[NV_VERTEX_PROGRAM] = TRUE;
 830
 831         /**
 832          * ATI
 833          */
 834         /** TODO */
 835         } else if (strcmp(ThisExtn, "GL_EXT_vertex_shader") == 0) {
 836           This->gl_info.vs_ati_version = VS_VERSION_11;
 837           FIXME(" FOUND: ATI (EXT) Vertex Shader support - version=%02x\n", This->gl_info.vs_ati_version);
 838           This->gl_info.supported[EXT_VERTEX_SHADER] = TRUE;
 839         }
 840
 841
 842         if (*GL_Extensions == ' ') GL_Extensions++;
 843       }
 844     }
 845
 846 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = (type) glXGetProcAddressARB(#pfn);
 847     GL_EXT_FUNCS_GEN;
 848 #undef USE_GL_FUNC
 849
 850     GLX_Extensions = glXQueryExtensionsString(display, DefaultScreen(display));
 851     FIXME("GLX_Extensions reported:\n");
 852
 853     if (NULL == GLX_Extensions) {
 854       ERR("   GLX_Extensions returns NULL\n");
 855     } else {
 856       while (*GLX_Extensions != 0x00) {
 857         const char *Start = GLX_Extensions;
 858         char ThisExtn[256];
 859
 860         memset(ThisExtn, 0x00, sizeof(ThisExtn));
 861         while (*GLX_Extensions != ' ' && *GLX_Extensions != 0x00) {
 862           GLX_Extensions++;
 863         }
 864         memcpy(ThisExtn, Start, (GLX_Extensions - Start));
 865         FIXME("- %s\n", ThisExtn);
 866         if (*GLX_Extensions == ' ') GLX_Extensions++;
 867       }
 868     }
 869
 870 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = (type) glXGetProcAddressARB(#pfn);
 871     GLX_EXT_FUNCS_GEN;
 872 #undef USE_GL_FUNC
 873
 874 }
 875
 876 HRESULT  WINAPI  IDirect3D8Impl_CreateDevice               (LPDIRECT3D8 iface,
 877                                                             UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
 878                                                             DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters,
 879                                                             IDirect3DDevice8** ppReturnedDeviceInterface) {
 880     IDirect3DDevice8Impl *object;
 881     HWND whichHWND;
 882     int num;
 883     XVisualInfo template;
 884
 885     ICOM_THIS(IDirect3D8Impl,iface);
 886     TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %lx, PresParms: %p, RetDevInt: %p)\n", This, Adapter, DeviceType,
 887           hFocusWindow, BehaviourFlags, pPresentationParameters, ppReturnedDeviceInterface);
 888
 889     /* Allocate the storage for the device */
 890     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDevice8Impl));
 891     if (NULL == object) {
 892       return D3DERR_OUTOFVIDEOMEMORY;
 893     }
 894     object->lpVtbl = &Direct3DDevice8_Vtbl;
 895     object->ref = 1;
 896     object->direct3d8 = This;
 897     /** The device AddRef the direct3d8 Interface else crash in propers clients codes */
 898     IDirect3D8_AddRef((LPDIRECT3D8) object->direct3d8);
 899
 900     /** use StateBlock Factory here, for creating the startup stateBlock */
 901     object->StateBlock = NULL;
 902     IDirect3DDeviceImpl_CreateStateBlock(object, D3DSBT_ALL, NULL);
 903     object->UpdateStateBlock = object->StateBlock;
 904
 905     /* Save the creation parameters */
 906     object->CreateParms.AdapterOrdinal = Adapter;
 907     object->CreateParms.DeviceType = DeviceType;
 908     object->CreateParms.hFocusWindow = hFocusWindow;
 909     object->CreateParms.BehaviorFlags = BehaviourFlags;
 910
 911     *ppReturnedDeviceInterface = (LPDIRECT3DDEVICE8) object;
 912
 913     /* Initialize settings */
 914     object->PresentParms.BackBufferCount = 1; /* Opengl only supports one? */
 915     object->adapterNo = Adapter;
 916     object->devType = DeviceType;
 917
 918     /* Initialize openGl */
 919     {
 920         HDC hDc;
 921         /*int dblBuf[] = {GLX_STENCIL_SIZE,8,GLX_RGBA,GLX_DEPTH_SIZE,16,GLX_DOUBLEBUFFER,None};*/
 922         int dblBuf[] = {GLX_RGBA,
 923                         GLX_STENCIL_SIZE, 8, /*  2 */
 924                         GLX_DEPTH_SIZE,  16, /*  4 */
 925                         GLX_DOUBLEBUFFER, None};
 926         /* FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat */
 927
 928         /* Which hwnd are we using? */
 929 /*      if (pPresentationParameters->Windowed) { */
 930            whichHWND = pPresentationParameters->hDeviceWindow;
 931            if (!whichHWND) {
 932                whichHWND = hFocusWindow;
 933            }
 934            object->win_handle = whichHWND;
 935            object->win     = (Window)GetPropA( whichHWND, "__wine_x11_client_window" );
 936 /*
 937  *      } else {
 938  *           whichHWND       = (HWND) GetDesktopWindow();
 939  *           object->win     = (Window)GetPropA(whichHWND, "__wine_x11_whole_window" );
 940  *         root_window
 941  *        }
 942  */
 943
 944         hDc = GetDC(whichHWND);
 945         object->display = get_display(hDc);
 946
 947
 948         TRACE("(%p)->(DepthStencil:(%u,%s), BackBufferFormat:(%u,%s))\n", This,
 949               pPresentationParameters->AutoDepthStencilFormat, debug_d3dformat(pPresentationParameters->AutoDepthStencilFormat),
 950               pPresentationParameters->BackBufferFormat, debug_d3dformat(pPresentationParameters->BackBufferFormat));
 951
 952
 953 #if 0
 954         if (TRUE == pPresentationParameters->EnableAutoDepthStencil) {
 955           switch (pPresentationParameters->AutoDepthStencilFormat) {
 956           case D3DFMT_D16_LOCKABLE: dblBuf[2] =  8; dblBuf[4] = 16; break;
 957           case D3DFMT_D16:          dblBuf[2] =  8; dblBuf[4] = 16; break;
 958           case D3DFMT_D15S1:        dblBuf[2] =  1; dblBuf[4] = 16; break;
 959           case D3DFMT_D24X4S4:      dblBuf[2] =  4; dblBuf[4] = 24; break;
 960           case D3DFMT_D24S8:        dblBuf[2] =  8; dblBuf[4] = 24; break;
 961           case D3DFMT_D24X8:        dblBuf[2] =  8; dblBuf[4] = 24; break;
 962           case D3DFMT_D32:          dblBuf[2] =  8; dblBuf[4] = 32; break;
 963           default:                  dblBuf[2] =  8; dblBuf[4] = 16; break;
 964           }
 965         }
 966
 967         switch (pPresentationParameters->BackBufferFormat) {
 968         case D3DFMT_R3G3B2:   dblBuf[6] = 3; dblBuf[8] = 3; dblBuf[10] = 2; dblBuf[12] = 0; break;
 969         case D3DFMT_R5G6B5:   dblBuf[6] = 5; dblBuf[8] = 6; dblBuf[10] = 5; dblBuf[12] = 0; break;
 970         case D3DFMT_X1R5G5B5: dblBuf[6] = 5; dblBuf[8] = 5; dblBuf[10] = 5; dblBuf[12] = 0; break;
 971         case D3DFMT_A1R5G5B5: dblBuf[6] = 5; dblBuf[8] = 5; dblBuf[10] = 5; dblBuf[12] = 1; break;
 972         case D3DFMT_X4R4G4B4: dblBuf[6] = 4; dblBuf[8] = 4; dblBuf[10] = 4; dblBuf[12] = 0; break;
 973         case D3DFMT_R8G8B8:   dblBuf[6] = 8; dblBuf[8] = 8; dblBuf[10] = 8; dblBuf[12] = 0; break;
 974         case D3DFMT_X8R8G8B8: dblBuf[6] = 8; dblBuf[8] = 8; dblBuf[10] = 8; dblBuf[12] = 0; break;
 975         case D3DFMT_A8R8G8B8: dblBuf[6] = 8; dblBuf[8] = 8; dblBuf[10] = 8; dblBuf[12] = 8; break;
 976         default:              dblBuf[6] = 5; dblBuf[8] = 6; dblBuf[10] = 5; dblBuf[12] = 0; break;
 977         }
 978 #endif
 979
 980         ENTER_GL();
 981         object->visInfo = glXChooseVisual(object->display, DefaultScreen(object->display), dblBuf);
 982         if (NULL == object->visInfo) {
 983           FIXME("cannot choose needed glxVisual with Stencil Buffer\n");
 984
 985           /**
 986            * second try using wine initialized visual ...
 987            * must be fixed reworking wine-glx init
 988            */
 989           template.visualid = (VisualID)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id");
 990           object->visInfo = XGetVisualInfo(object->display, VisualIDMask, &template, &num);
 991           if (NULL == object->visInfo) {
 992             ERR("cannot really get XVisual\n");
 993             LEAVE_GL();
 994             return D3DERR_NOTAVAILABLE;
 995           }
 996         }
 997         object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE);
 998         if (NULL == object->glCtx) {
 999           ERR("cannot create glxContext\n");
1000           LEAVE_GL();
1001           return D3DERR_NOTAVAILABLE;
1002         }
1003         LEAVE_GL();
1004
1005         ReleaseDC(whichHWND, hDc);
1006     }
1007
1008     if (object->glCtx == NULL) {
1009         ERR("Error in context creation !\n");
1010         return D3DERR_INVALIDCALL;
1011     } else {
1012         TRACE("Context created (HWND=%p, glContext=%p, Window=%ld, VisInfo=%p)\n",
1013               whichHWND, object->glCtx, object->win, object->visInfo);
1014     }
1015
1016     /* If not windowed, need to go fullscreen, and resize the HWND to the appropriate  */
1017     /*        dimensions                                                               */
1018     if (!pPresentationParameters->Windowed) {
1019 #if 1
1020         DEVMODEW devmode;
1021         HDC hdc;
1022         int bpp = 0;
1023         memset(&devmode, 0, sizeof(DEVMODEW));
1024         devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1025         MultiByteToWideChar(CP_ACP, 0, "Gamers CG", -1, devmode.dmDeviceName, CCHDEVICENAME);
1026         hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1027         bpp = GetDeviceCaps(hdc, BITSPIXEL);
1028         DeleteDC(hdc);
1029         devmode.dmBitsPerPel = (bpp >= 24) ? 32 : bpp;/*Stupid XVidMode cannot change bpp D3DFmtGetBpp(object, pPresentationParameters->BackBufferFormat);*/
1030         devmode.dmPelsWidth  = pPresentationParameters->BackBufferWidth;
1031         devmode.dmPelsHeight = pPresentationParameters->BackBufferHeight;
1032         ChangeDisplaySettingsExW(devmode.dmDeviceName, &devmode, object->win_handle, CDS_FULLSCREEN, NULL);
1033 #else
1034         FIXME("Requested full screen support not implemented, expect windowed operation\n");
1035 #endif
1036
1037         /* Make popup window */
1038         ShowWindow(whichHWND, SW_HIDE);
1039         SetWindowLongA(whichHWND, GWL_STYLE, WS_POPUP);
1040         SetWindowPos(object->win_handle, HWND_TOP, 0, 0,
1041                      pPresentationParameters->BackBufferWidth,
1042                      pPresentationParameters->BackBufferHeight, SWP_SHOWWINDOW | SWP_FRAMECHANGED);
1043         ShowWindow(whichHWND, SW_SHOW);
1044     }
1045
1046     TRACE("Creating back buffer\n");
1047     /* MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero,
1048        then the corresponding dimension of the client area of the hDeviceWindow
1049        (or the focus window, if hDeviceWindow is NULL) is taken. */
1050     if (pPresentationParameters->Windowed && ((pPresentationParameters->BackBufferWidth  == 0) ||
1051                                               (pPresentationParameters->BackBufferHeight == 0))) {
1052         RECT Rect;
1053
1054         GetClientRect(whichHWND, &Rect);
1055
1056         if (pPresentationParameters->BackBufferWidth == 0) {
1057            pPresentationParameters->BackBufferWidth = Rect.right;
1058            TRACE("Updating width to %d\n", pPresentationParameters->BackBufferWidth);
1059         }
1060         if (pPresentationParameters->BackBufferHeight == 0) {
1061            pPresentationParameters->BackBufferHeight = Rect.bottom;
1062            TRACE("Updating height to %d\n", pPresentationParameters->BackBufferHeight);
1063         }
1064     }
1065
1066     /* Save the presentation parms now filled in correctly */
1067     memcpy(&object->PresentParms, pPresentationParameters, sizeof(D3DPRESENT_PARAMETERS));
1068
1069
1070     IDirect3DDevice8Impl_CreateRenderTarget((LPDIRECT3DDEVICE8) object,
1071                                             pPresentationParameters->BackBufferWidth,
1072                                             pPresentationParameters->BackBufferHeight,
1073                                             pPresentationParameters->BackBufferFormat,
1074                                             pPresentationParameters->MultiSampleType,
1075                                             TRUE,
1076                                             (LPDIRECT3DSURFACE8*) &object->frontBuffer);
1077
1078     IDirect3DDevice8Impl_CreateRenderTarget((LPDIRECT3DDEVICE8) object,
1079                                             pPresentationParameters->BackBufferWidth,
1080                                             pPresentationParameters->BackBufferHeight,
1081                                             pPresentationParameters->BackBufferFormat,
1082                                             pPresentationParameters->MultiSampleType,
1083                                             TRUE,
1084                                             (LPDIRECT3DSURFACE8*) &object->backBuffer);
1085
1086     if (pPresentationParameters->EnableAutoDepthStencil) {
1087        IDirect3DDevice8Impl_CreateDepthStencilSurface((LPDIRECT3DDEVICE8) object,
1088                                                       pPresentationParameters->BackBufferWidth,
1089                                                       pPresentationParameters->BackBufferHeight,
1090                                                       pPresentationParameters->AutoDepthStencilFormat,
1091                                                       D3DMULTISAMPLE_NONE,
1092                                                       (LPDIRECT3DSURFACE8*) &object->depthStencilBuffer);
1093     } else {
1094       object->depthStencilBuffer = NULL;
1095     }
1096     TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil @ %p\n",object->frontBuffer, object->backBuffer, object->depthStencilBuffer);
1097
1098     /* init the default renderTarget management */
1099     object->drawable = object->win;
1100     object->render_ctx = object->glCtx;
1101     object->renderTarget = object->frontBuffer;
1102     IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) object->renderTarget);
1103     object->stencilBufferTarget = object->depthStencilBuffer;
1104     if (NULL != object->stencilBufferTarget) {
1105       IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) object->stencilBufferTarget);
1106     }
1107
1108     ENTER_GL();
1109
1110     if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) {
1111       ERR("Error in setting current context (context %p drawable %ld)!\n", object->glCtx, object->win);
1112     }
1113     checkGLcall("glXMakeCurrent");
1114
1115     /* Clear the screen */
1116     glClearColor(1.0, 0.0, 0.0, 0.0);
1117     checkGLcall("glClearColor");
1118     glColor3f(1.0, 1.0, 1.0);
1119     checkGLcall("glColor3f");
1120
1121     glEnable(GL_LIGHTING);
1122     checkGLcall("glEnable");
1123
1124     glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
1125     checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
1126
1127     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
1128     checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
1129
1130     glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1131     checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
1132
1133     /*
1134      * Initialize openGL extension related variables
1135      *  with Default values
1136      */
1137     IDirect3D8Impl_FillGLCaps(iface, object->display);
1138
1139     /* Setup all the devices defaults */
1140     IDirect3DDeviceImpl_InitStartupStateBlock(object);
1141
1142     LEAVE_GL();
1143
1144     { /* Set a default viewport */
1145        D3DVIEWPORT8 vp;
1146        vp.X      = 0;
1147        vp.Y      = 0;
1148        vp.Width  = pPresentationParameters->BackBufferWidth;
1149        vp.Height = pPresentationParameters->BackBufferHeight;
1150        vp.MinZ   = 0.0f;
1151        vp.MaxZ   = 1.0f;
1152        IDirect3DDevice8Impl_SetViewport((LPDIRECT3DDEVICE8) object, &vp);
1153     }
1154
1155     /* Initialize the current view state */
1156     object->modelview_valid = 1;
1157     object->proj_valid = 0;
1158     object->view_ident = 1;
1159     object->last_was_rhw = 0;
1160     glGetIntegerv(GL_MAX_LIGHTS, &object->maxConcurrentLights);
1161     TRACE("(%p,%d) All defaults now set up, leaving CreateDevice with %p\n", This, Adapter, object);
1162     return D3D_OK;
1163 }
1164
1165 ICOM_VTABLE(IDirect3D8) Direct3D8_Vtbl =
1166 {
1167     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1168     IDirect3D8Impl_QueryInterface,
1169     IDirect3D8Impl_AddRef,
1170     IDirect3D8Impl_Release,
1171     IDirect3D8Impl_RegisterSoftwareDevice,
1172     IDirect3D8Impl_GetAdapterCount,
1173     IDirect3D8Impl_GetAdapterIdentifier,
1174     IDirect3D8Impl_GetAdapterModeCount,
1175     IDirect3D8Impl_EnumAdapterModes,
1176     IDirect3D8Impl_GetAdapterDisplayMode,
1177     IDirect3D8Impl_CheckDeviceType,
1178     IDirect3D8Impl_CheckDeviceFormat,
1179     IDirect3D8Impl_CheckDeviceMultiSampleType,
1180     IDirect3D8Impl_CheckDepthStencilMatch,
1181     IDirect3D8Impl_GetDeviceCaps,
1182     IDirect3D8Impl_GetAdapterMonitor,
1183     IDirect3D8Impl_CreateDevice
1184 };