git.oblomov.eu Git - wine/blob - dlls/ddraw/d3ddevice/mesa.c

   1 /* Direct3D Device
   2  * Copyright (c) 1998 Lionel ULMER
   3  *
   4  * This file contains the MESA implementation of all the D3D devices that
   5  * Wine supports.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include "windef.h"
  27 #include "winerror.h"
  28 #include "objbase.h"
  29 #include "ddraw.h"
  30 #include "d3d.h"
  31 #include "wine/debug.h"
  32
  33 #include "mesa_private.h"
  34 #include "main.h"
  35
  36 #include "x11drv.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  39
  40 /* They are non-static as they are used by Direct3D in the creation function */
  41 const GUID IID_D3DDEVICE_OpenGL = {
  42   0x31416d44,
  43   0x86ae,
  44   0x11d2,
  45   { 0x82,0x2d,0xa8,0xd5,0x31,0x87,0xca,0xfa }
  46 };
  47
  48 #ifndef HAVE_GLEXT_PROTOTYPES
  49 /* This is for non-OpenGL ABI compliant glext.h headers :-) */
  50 typedef void (* PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat,
  51                                          GLsizei width, GLenum format, GLenum type,
  52                                          const GLvoid *table);
  53 #endif
  54
  55 static const float id_mat[16] = {
  56     1.0, 0.0, 0.0, 0.0,
  57     0.0, 1.0, 0.0, 0.0,
  58     0.0, 0.0, 1.0, 0.0,
  59     0.0, 0.0, 0.0, 1.0
  60 };
  61
  62 static void draw_primitive_strided_7(IDirect3DDeviceImpl *This,
  63                                      D3DPRIMITIVETYPE d3dptPrimitiveType,
  64                                      DWORD d3dvtVertexType,
  65                                      LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
  66                                      DWORD dwStartVertex,
  67                                      DWORD dwVertexCount,
  68                                      LPWORD dwIndices,
  69                                      DWORD dwIndexCount,
  70                                      DWORD dwFlags) ;
  71
  72 /* retrieve the X display to use on a given DC */
  73 inline static Display *get_display( HDC hdc )
  74 {
  75     Display *display;
  76     enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
  77
  78     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
  79                     sizeof(display), (LPSTR)&display )) display = NULL;
  80
  81     return display;
  82 }
  83
  84
  85 /* retrieve the X drawable to use on a given DC */
  86 inline static Drawable get_drawable( HDC hdc )
  87 {
  88     Drawable drawable;
  89     enum x11drv_escape_codes escape = X11DRV_GET_DRAWABLE;
  90
  91     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
  92                     sizeof(drawable), (LPSTR)&drawable )) drawable = 0;
  93
  94     return drawable;
  95 }
  96
  97
  98 static BOOL opengl_flip( LPVOID display, LPVOID drawable)
  99 {
 100     TRACE("(%p, %ld)\n",(Display*)display,(Drawable)drawable);
 101     ENTER_GL();
 102     glXSwapBuffers((Display*)display,(Drawable)drawable);
 103     LEAVE_GL();
 104     return TRUE;
 105 }
 106
 107
 108 /*******************************************************************************
 109  *                              OpenGL static functions
 110  */
 111 static void set_context(IDirect3DDeviceImpl* This)
 112 {
 113     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
 114
 115     ENTER_GL();
 116     TRACE("glxMakeCurrent %p, %ld, %p\n",glThis->display,glThis->drawable, glThis->gl_context);
 117     if (glXMakeCurrent(glThis->display, glThis->drawable, glThis->gl_context) == False) {
 118         ERR("Error in setting current context (context %p drawable %ld)!\n",
 119             glThis->gl_context, glThis->drawable);
 120     }
 121     LEAVE_GL();
 122 }
 123
 124 static void fill_opengl_primcaps(D3DPRIMCAPS *pc)
 125 {
 126     pc->dwSize = sizeof(*pc);
 127     pc->dwMiscCaps = D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLCCW | D3DPMISCCAPS_CULLCW |
 128       D3DPMISCCAPS_LINEPATTERNREP | D3DPMISCCAPS_MASKZ;
 129     pc->dwRasterCaps = D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_FOGTABLE |
 130       D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL;
 131     pc->dwZCmpCaps = D3DPCMPCAPS_ALWAYS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_GREATEREQUAL |
 132       D3DPCMPCAPS_LESS | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_NEVER | D3DPCMPCAPS_NOTEQUAL;
 133     pc->dwSrcBlendCaps  = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_DESTCOLOR | D3DPBLENDCAPS_INVDESTCOLOR |
 134       D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_SRCALPHASAT |
 135         D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA;
 136     pc->dwDestBlendCaps = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | D3DPBLENDCAPS_INVSRCCOLOR |
 137       D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_SRCALPHASAT |
 138         D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA;
 139     pc->dwAlphaCmpCaps  = D3DPCMPCAPS_ALWAYS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_GREATEREQUAL |
 140       D3DPCMPCAPS_LESS | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_NEVER | D3DPCMPCAPS_NOTEQUAL;
 141     pc->dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDRGB |
 142       D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDRGB;
 143     pc->dwTextureCaps = D3DPTEXTURECAPS_ALPHA | D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_PERSPECTIVE |
 144       D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_TRANSPARENCY;
 145     pc->dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_LINEARMIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST |
 146       D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_MIPNEAREST | D3DPTFILTERCAPS_NEAREST;
 147     pc->dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL | D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
 148       D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA | D3DPTBLENDCAPS_MODULATEMASK;
 149     pc->dwTextureAddressCaps = D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_CLAMP | D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_INDEPENDENTUV;
 150     pc->dwStippleWidth = 32;
 151     pc->dwStippleHeight = 32;
 152 }
 153
 154 static void fill_opengl_caps(D3DDEVICEDESC *d1)
 155 {
 156     /* GLint maxlight; */
 157
 158     d1->dwSize  = sizeof(*d1);
 159     d1->dwFlags = D3DDD_DEVCAPS | D3DDD_BCLIPPING | D3DDD_COLORMODEL | D3DDD_DEVICERENDERBITDEPTH | D3DDD_DEVICEZBUFFERBITDEPTH
 160       | D3DDD_LIGHTINGCAPS | D3DDD_LINECAPS | D3DDD_MAXBUFFERSIZE | D3DDD_MAXVERTEXCOUNT | D3DDD_TRANSFORMCAPS | D3DDD_TRICAPS;
 161     d1->dcmColorModel = D3DCOLOR_RGB;
 162     d1->dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_EXECUTESYSTEMMEMORY |
 163       D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_TEXTURESYSTEMMEMORY |
 164       D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY |
 165       /* D3D 7 capabilities */
 166       D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_HWRASTERIZATION;
 167     d1->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
 168     d1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
 169     d1->bClipping = TRUE;
 170     d1->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
 171     d1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL | D3DLIGHTCAPS_PARALLELPOINT | D3DLIGHTCAPS_POINT | D3DLIGHTCAPS_SPOT;
 172     d1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
 173     d1->dlcLightingCaps.dwNumLights = 16; /* glGetIntegerv(GL_MAX_LIGHTS, &maxlight); d1->dlcLightingCaps.dwNumLights = maxlight; */
 174     fill_opengl_primcaps(&(d1->dpcLineCaps));
 175     fill_opengl_primcaps(&(d1->dpcTriCaps));
 176     d1->dwDeviceRenderBitDepth  = DDBD_16|DDBD_24|DDBD_32;
 177     d1->dwDeviceZBufferBitDepth = DDBD_16|DDBD_24|DDBD_32;
 178     d1->dwMaxBufferSize = 0;
 179     d1->dwMaxVertexCount = 65536;
 180     d1->dwMinTextureWidth  = 1;
 181     d1->dwMinTextureHeight = 1;
 182     d1->dwMaxTextureWidth  = 1024;
 183     d1->dwMaxTextureHeight = 1024;
 184     d1->dwMinStippleWidth  = 1;
 185     d1->dwMinStippleHeight = 1;
 186     d1->dwMaxStippleWidth  = 32;
 187     d1->dwMaxStippleHeight = 32;
 188     d1->dwMaxTextureRepeat = 16;
 189     d1->dwMaxTextureAspectRatio = 1024;
 190     d1->dwMaxAnisotropy = 0;
 191     d1->dvGuardBandLeft = 0.0;
 192     d1->dvGuardBandRight = 0.0;
 193     d1->dvGuardBandTop = 0.0;
 194     d1->dvGuardBandBottom = 0.0;
 195     d1->dvExtentsAdjust = 0.0;
 196     d1->dwStencilCaps = D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_INVERT | D3DSTENCILCAPS_KEEP |
 197       D3DSTENCILCAPS_REPLACE | D3DSTENCILCAPS_ZERO;
 198     d1->dwFVFCaps = D3DFVFCAPS_DONOTSTRIPELEMENTS | 1;
 199     d1->dwTextureOpCaps = 0; /* TODO add proper caps according to OpenGL multi-texture stuff */
 200     d1->wMaxTextureBlendStages = 1;  /* TODO add proper caps according to OpenGL multi-texture stuff */
 201     d1->wMaxSimultaneousTextures = 1;  /* TODO add proper caps according to OpenGL multi-texture stuff */
 202 }
 203
 204 static void fill_opengl_caps_7(D3DDEVICEDESC7 *d)
 205 {
 206     D3DDEVICEDESC d1;
 207
 208     /* Copy first D3D1/2/3 capabilities */
 209     fill_opengl_caps(&d1);
 210
 211     /* And fill the D3D7 one with it */
 212     d->dwDevCaps = d1.dwDevCaps;
 213     d->dpcLineCaps = d1.dpcLineCaps;
 214     d->dpcTriCaps = d1.dpcTriCaps;
 215     d->dwDeviceRenderBitDepth = d1.dwDeviceRenderBitDepth;
 216     d->dwDeviceZBufferBitDepth = d1.dwDeviceZBufferBitDepth;
 217     d->dwMinTextureWidth = d1.dwMinTextureWidth;
 218     d->dwMinTextureHeight = d1.dwMinTextureHeight;
 219     d->dwMaxTextureWidth = d1.dwMaxTextureWidth;
 220     d->dwMaxTextureHeight = d1.dwMaxTextureHeight;
 221     d->dwMaxTextureRepeat = d1.dwMaxTextureRepeat;
 222     d->dwMaxTextureAspectRatio = d1.dwMaxTextureAspectRatio;
 223     d->dwMaxAnisotropy = d1.dwMaxAnisotropy;
 224     d->dvGuardBandLeft = d1.dvGuardBandLeft;
 225     d->dvGuardBandTop = d1.dvGuardBandTop;
 226     d->dvGuardBandRight = d1.dvGuardBandRight;
 227     d->dvGuardBandBottom = d1.dvGuardBandBottom;
 228     d->dvExtentsAdjust = d1.dvExtentsAdjust;
 229     d->dwStencilCaps = d1.dwStencilCaps;
 230     d->dwFVFCaps = d1.dwFVFCaps;
 231     d->dwTextureOpCaps = d1.dwTextureOpCaps;
 232     d->wMaxTextureBlendStages = d1.wMaxTextureBlendStages;
 233     d->wMaxSimultaneousTextures = d1.wMaxSimultaneousTextures;
 234     d->dwMaxActiveLights = d1.dlcLightingCaps.dwNumLights;
 235     d->dvMaxVertexW = 100000000.0; /* No idea exactly what to put here... */
 236     d->deviceGUID = IID_IDirect3DTnLHalDevice;
 237     d->wMaxUserClipPlanes = 1;
 238     d->wMaxVertexBlendMatrices = 0;
 239     d->dwVertexProcessingCaps = D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG | D3DVTXPCAPS_DIRECTIONALLIGHTS |
 240       D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER;
 241     d->dwReserved1 = 0;
 242     d->dwReserved2 = 0;
 243     d->dwReserved3 = 0;
 244     d->dwReserved4 = 0;
 245 }
 246
 247 #if 0 /* TODO : fix this and add multitexturing and other needed stuff */
 248 static void fill_device_capabilities(IDirectDrawImpl* ddraw)
 249 {
 250     x11_dd_private *private = (x11_dd_private *) ddraw->d->private;
 251     const char *ext_string;
 252     Mesa_DeviceCapabilities *devcap;
 253
 254     private->device_capabilities = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(Mesa_DeviceCapabilities));
 255     devcap = (Mesa_DeviceCapabilities *) private->device_capabilities;
 256
 257     ENTER_GL();
 258     ext_string = glGetString(GL_EXTENSIONS);
 259     /* Query for the ColorTable Extension */
 260     if (strstr(ext_string, "GL_EXT_paletted_texture")) {
 261         devcap->ptr_ColorTableEXT = (PFNGLCOLORTABLEEXTPROC) glXGetProcAddressARB("glColorTableEXT");
 262         TRACE("Color table extension supported (function at %p)\n", devcap->ptr_ColorTableEXT);
 263     } else {
 264         TRACE("Color table extension not found.\n");
 265     }
 266     LEAVE_GL();
 267 }
 268 #endif
 269
 270
 271
 272 HRESULT d3ddevice_enumerate(LPD3DENUMDEVICESCALLBACK cb, LPVOID context)
 273 {
 274     D3DDEVICEDESC d1, d2;
 275
 276     fill_opengl_caps(&d1);
 277     d2 = d1;
 278
 279     TRACE(" enumerating OpenGL D3DDevice interface (IID %s).\n", debugstr_guid(&IID_D3DDEVICE_OpenGL));
 280     return cb((LPIID) &IID_D3DDEVICE_OpenGL, "WINE Direct3DX using OpenGL", "direct3d", &d1, &d2, context);
 281 }
 282
 283 HRESULT d3ddevice_enumerate7(LPD3DENUMDEVICESCALLBACK7 cb, LPVOID context)
 284 {
 285     D3DDEVICEDESC7 ddesc;
 286
 287     fill_opengl_caps_7(&ddesc);
 288
 289     TRACE(" enumerating OpenGL D3DDevice7 interface.\n");
 290
 291     return cb("WINE Direct3D7 using OpenGL", "Wine D3D7 device", &ddesc, context);
 292 }
 293
 294 ULONG WINAPI
 295 GL_IDirect3DDeviceImpl_7_3T_2T_1T_Release(LPDIRECT3DDEVICE7 iface)
 296 {
 297     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 298     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
 299
 300     TRACE("(%p/%p)->() decrementing from %lu.\n", This, iface, This->ref);
 301     if (!--(This->ref)) {
 302         /* Release texture associated with the device */
 303         if (This->current_texture[0] != NULL)
 304             IDirect3DTexture2_Release(ICOM_INTERFACE(This->current_texture[0], IDirect3DTexture2));
 305
 306         /* And warn the D3D object that this device is no longer active... */
 307         This->d3d->removed_device(This->d3d, This);
 308
 309         HeapFree(GetProcessHeap(), 0, This->world_mat);
 310         HeapFree(GetProcessHeap(), 0, This->view_mat);
 311         HeapFree(GetProcessHeap(), 0, This->proj_mat);
 312
 313         ENTER_GL();
 314         glXDestroyContext(glThis->display, glThis->gl_context);
 315         LEAVE_GL();
 316
 317         HeapFree(GetProcessHeap(), 0, This);
 318         return 0;
 319     }
 320     return This->ref;
 321 }
 322
 323 HRESULT WINAPI
 324 GL_IDirect3DDeviceImpl_3_2T_1T_GetCaps(LPDIRECT3DDEVICE3 iface,
 325                                        LPD3DDEVICEDESC lpD3DHWDevDesc,
 326                                        LPD3DDEVICEDESC lpD3DHELDevDesc)
 327 {
 328     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 329     D3DDEVICEDESC desc;
 330     DWORD dwSize;
 331
 332     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DHWDevDesc, lpD3DHELDevDesc);
 333
 334     fill_opengl_caps(&desc);
 335     dwSize = lpD3DHWDevDesc->dwSize;
 336     memset(lpD3DHWDevDesc, 0, dwSize);
 337     memcpy(lpD3DHWDevDesc, &desc, (dwSize <= desc.dwSize ? dwSize : desc.dwSize));
 338
 339     dwSize = lpD3DHELDevDesc->dwSize;
 340     memset(lpD3DHELDevDesc, 0, dwSize);
 341     memcpy(lpD3DHELDevDesc, &desc, (dwSize <= desc.dwSize ? dwSize : desc.dwSize));
 342
 343     TRACE(" returning caps : (no dump function yet)\n");
 344
 345     return DD_OK;
 346 }
 347
 348 static HRESULT enum_texture_format_OpenGL(LPD3DENUMTEXTUREFORMATSCALLBACK cb_1,
 349                                           LPD3DENUMPIXELFORMATSCALLBACK cb_2,
 350                                           LPVOID context)
 351 {
 352     DDSURFACEDESC sdesc;
 353     LPDDPIXELFORMAT pformat;
 354
 355     /* Do the texture enumeration */
 356     sdesc.dwSize = sizeof(DDSURFACEDESC);
 357     sdesc.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
 358     sdesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
 359     pformat = &(sdesc.ddpfPixelFormat);
 360     pformat->dwSize = sizeof(DDPIXELFORMAT);
 361     pformat->dwFourCC = 0;
 362
 363     TRACE("Enumerating GL_RGBA unpacked (32)\n");
 364     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 365     pformat->u1.dwRGBBitCount = 32;
 366     pformat->u2.dwRBitMask =        0xFF000000;
 367     pformat->u3.dwGBitMask =        0x00FF0000;
 368     pformat->u4.dwBBitMask =        0x0000FF00;
 369     pformat->u5.dwRGBAlphaBitMask = 0x000000FF;
 370     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 371     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 372
 373     TRACE("Enumerating GL_RGB unpacked (24)\n");
 374     pformat->dwFlags = DDPF_RGB;
 375     pformat->u1.dwRGBBitCount = 24;
 376     pformat->u2.dwRBitMask = 0x00FF0000;
 377     pformat->u3.dwGBitMask = 0x0000FF00;
 378     pformat->u4.dwBBitMask = 0x000000FF;
 379     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 380     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 381     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 382
 383     TRACE("Enumerating GL_RGB packed GL_UNSIGNED_SHORT_5_6_5 (16)\n");
 384     pformat->dwFlags = DDPF_RGB;
 385     pformat->u1.dwRGBBitCount = 16;
 386     pformat->u2.dwRBitMask = 0x0000F800;
 387     pformat->u3.dwGBitMask = 0x000007E0;
 388     pformat->u4.dwBBitMask = 0x0000001F;
 389     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 390     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 391     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 392
 393     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_5_5_5_1 (16)\n");
 394     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 395     pformat->u1.dwRGBBitCount = 16;
 396     pformat->u2.dwRBitMask =        0x0000F800;
 397     pformat->u3.dwGBitMask =        0x000007C0;
 398     pformat->u4.dwBBitMask =        0x0000003E;
 399     pformat->u5.dwRGBAlphaBitMask = 0x00000001;
 400     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 401     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 402
 403     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_4_4_4_4 (16)\n");
 404     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 405     pformat->u1.dwRGBBitCount = 16;
 406     pformat->u2.dwRBitMask =        0x0000F000;
 407     pformat->u3.dwGBitMask =        0x00000F00;
 408     pformat->u4.dwBBitMask =        0x000000F0;
 409     pformat->u5.dwRGBAlphaBitMask = 0x0000000F;
 410     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 411     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 412
 413     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_1_5_5_5 (16)\n");
 414     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 415     pformat->u1.dwRGBBitCount = 16;
 416     pformat->u2.dwRBitMask =        0x00007C00;
 417     pformat->u3.dwGBitMask =        0x000003E0;
 418     pformat->u4.dwBBitMask =        0x0000001F;
 419     pformat->u5.dwRGBAlphaBitMask = 0x00008000;
 420     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 421     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 422
 423     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_4_4_4_4 (ARGB) (16)\n");
 424     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 425     pformat->u1.dwRGBBitCount = 16;
 426     pformat->u2.dwRBitMask =        0x00000F00;
 427     pformat->u3.dwGBitMask =        0x000000F0;
 428     pformat->u4.dwBBitMask =        0x0000000F;
 429     pformat->u5.dwRGBAlphaBitMask = 0x0000F000;
 430     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 431     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 432
 433     TRACE("Enumerating GL_RGB packed GL_UNSIGNED_BYTE_3_3_2 (8)\n");
 434     pformat->dwFlags = DDPF_RGB;
 435     pformat->u1.dwRGBBitCount = 8;
 436     pformat->u2.dwRBitMask =        0x000000E0;
 437     pformat->u3.dwGBitMask =        0x0000001C;
 438     pformat->u4.dwBBitMask =        0x00000003;
 439     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 440     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 441     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 442
 443     TRACE("Enumerating GL_ARGB (no direct OpenGL equivalent - conversion needed)\n");
 444     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 445     pformat->u1.dwRGBBitCount = 16;
 446     pformat->u2.dwRBitMask =         0x00007C00;
 447     pformat->u3.dwGBitMask =         0x000003E0;
 448     pformat->u4.dwBBitMask =         0x0000001F;
 449     pformat->u5.dwRGBAlphaBitMask =  0x00008000;
 450     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 451     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 452
 453     TRACE("Enumerating Paletted (8)\n");
 454     pformat->dwFlags = DDPF_PALETTEINDEXED8;
 455     pformat->u1.dwRGBBitCount = 8;
 456     pformat->u2.dwRBitMask =        0x00000000;
 457     pformat->u3.dwGBitMask =        0x00000000;
 458     pformat->u4.dwBBitMask =        0x00000000;
 459     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 460     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 461     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 462
 463     TRACE("End of enumeration\n");
 464     return DD_OK;
 465 }
 466
 467
 468 HRESULT
 469 d3ddevice_find(IDirect3DImpl *d3d,
 470                LPD3DFINDDEVICESEARCH lpD3DDFS,
 471                LPD3DFINDDEVICERESULT lplpD3DDevice)
 472 {
 473     D3DDEVICEDESC desc;
 474
 475     if ((lpD3DDFS->dwFlags & D3DFDS_COLORMODEL) &&
 476         (lpD3DDFS->dcmColorModel != D3DCOLOR_RGB)) {
 477         TRACE(" trying to request a non-RGB D3D color model. Not supported.\n");
 478         return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
 479     }
 480     if (lpD3DDFS->dwFlags & D3DFDS_GUID) {
 481         TRACE(" trying to match guid %s.\n", debugstr_guid(&(lpD3DDFS->guid)));
 482         if ((IsEqualGUID( &IID_D3DDEVICE_OpenGL, &(lpD3DDFS->guid)) == 0) &&
 483             (IsEqualGUID(&IID_IDirect3DHALDevice, &(lpD3DDFS->guid)) == 0)) {
 484             TRACE(" no match for this GUID.\n");
 485             return DDERR_INVALIDPARAMS;
 486         }
 487     }
 488
 489     /* Now return our own GUID */
 490     lplpD3DDevice->guid = IID_D3DDEVICE_OpenGL;
 491     fill_opengl_caps(&desc);
 492     lplpD3DDevice->ddHwDesc = desc;
 493     lplpD3DDevice->ddSwDesc = desc;
 494
 495     TRACE(" returning Wine's OpenGL device with (undumped) capabilities\n");
 496
 497     return D3D_OK;
 498 }
 499
 500 HRESULT WINAPI
 501 GL_IDirect3DDeviceImpl_2_1T_EnumTextureFormats(LPDIRECT3DDEVICE2 iface,
 502                                                LPD3DENUMTEXTUREFORMATSCALLBACK lpD3DEnumTextureProc,
 503                                                LPVOID lpArg)
 504 {
 505     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 506     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DEnumTextureProc, lpArg);
 507     return enum_texture_format_OpenGL(lpD3DEnumTextureProc, NULL, lpArg);
 508 }
 509
 510 HRESULT WINAPI
 511 GL_IDirect3DDeviceImpl_7_3T_EnumTextureFormats(LPDIRECT3DDEVICE7 iface,
 512                                                LPD3DENUMPIXELFORMATSCALLBACK lpD3DEnumPixelProc,
 513                                                LPVOID lpArg)
 514 {
 515     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 516     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DEnumPixelProc, lpArg);
 517     return enum_texture_format_OpenGL(NULL, lpD3DEnumPixelProc, lpArg);
 518 }
 519
 520 HRESULT WINAPI
 521 GL_IDirect3DDeviceImpl_7_3T_2T_SetRenderState(LPDIRECT3DDEVICE7 iface,
 522                                               D3DRENDERSTATETYPE dwRenderStateType,
 523                                               DWORD dwRenderState)
 524 {
 525     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 526     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
 527     TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwRenderStateType, dwRenderState);
 528
 529     /* Call the render state functions */
 530     set_render_state(dwRenderStateType, dwRenderState, &(glThis->render_state));
 531
 532     return DD_OK;
 533 }
 534
 535 HRESULT WINAPI
 536 GL_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface,
 537                                           D3DLIGHTSTATETYPE dwLightStateType,
 538                                           DWORD dwLightState)
 539 {
 540     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 541     TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwLightStateType, dwLightState);
 542
 543     switch (dwLightStateType) {
 544         case D3DLIGHTSTATE_MATERIAL: {  /* 1 */
 545             IDirect3DMaterialImpl *mat = (IDirect3DMaterialImpl *) dwLightState;
 546
 547             if (mat != NULL) {
 548                 ENTER_GL();
 549                 mat->activate(mat);
 550                 LEAVE_GL();
 551             } else {
 552                 ERR(" D3DLIGHTSTATE_MATERIAL called with NULL material !!!\n");
 553             }
 554         } break;
 555
 556         case D3DLIGHTSTATE_AMBIENT: {   /* 2 */
 557             float light[4];
 558
 559             light[0] = ((dwLightState >> 16) & 0xFF) / 255.0;
 560             light[1] = ((dwLightState >>  8) & 0xFF) / 255.0;
 561             light[2] = ((dwLightState >>  0) & 0xFF) / 255.0;
 562             light[3] = 1.0;
 563             ENTER_GL();
 564             glLightModelfv(GL_LIGHT_MODEL_AMBIENT, (float *) light);
 565             LEAVE_GL();
 566         } break;
 567
 568 #define UNSUP(x) case D3DLIGHTSTATE_##x: FIXME("unsupported D3DLIGHTSTATE_" #x "!\n");break;
 569         UNSUP(COLORMODEL);
 570         UNSUP(FOGMODE);
 571         UNSUP(FOGSTART);
 572         UNSUP(FOGEND);
 573         UNSUP(FOGDENSITY);
 574         UNSUP(COLORVERTEX);
 575 #undef UNSUP
 576
 577         default:
 578             TRACE("Unexpected Light State Type\n");
 579             return DDERR_INVALIDPARAMS;
 580     }
 581
 582     return DD_OK;
 583 }
 584
 585 HRESULT WINAPI
 586 GL_IDirect3DDeviceImpl_7_3T_2T_SetTransform(LPDIRECT3DDEVICE7 iface,
 587                                             D3DTRANSFORMSTATETYPE dtstTransformStateType,
 588                                             LPD3DMATRIX lpD3DMatrix)
 589 {
 590     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 591     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
 592
 593     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dtstTransformStateType, lpD3DMatrix);
 594
 595     ENTER_GL();
 596
 597     /* Using a trial and failure approach, I found that the order of
 598        Direct3D transformations that works best is :
 599
 600        ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
 601
 602        As OpenGL uses only two matrices, I combined PROJECTION and VIEW into
 603        OpenGL's GL_PROJECTION matrix and the WORLD into GL_MODELVIEW.
 604
 605        If anyone has a good explanation of the three different matrices in
 606        the SDK online documentation, feel free to point it to me. For example,
 607        which matrices transform lights ? In OpenGL only the PROJECTION matrix
 608        transform the lights, not the MODELVIEW. Using the matrix names, I
 609        supposed that PROJECTION and VIEW (all 'camera' related names) do
 610        transform lights, but WORLD do not. It may be wrong though... */
 611
 612     /* After reading through both OpenGL and Direct3D documentations, I
 613        thought that D3D matrices were written in 'line major mode' transposed
 614        from OpenGL's 'column major mode'. But I found out that a simple memcpy
 615        works fine to transfer one matrix format to the other (it did not work
 616        when transposing)....
 617
 618        So :
 619          1) are the documentations wrong
 620          2) does the matrix work even if they are not read correctly
 621          3) is Mesa's implementation of OpenGL not compliant regarding Matrix
 622             loading using glLoadMatrix ?
 623
 624        Anyway, I always use 'conv_mat' to transfer the matrices from one format
 625        to the other so that if I ever find out that I need to transpose them, I
 626        will able to do it quickly, only by changing the macro conv_mat. */
 627
 628     switch (dtstTransformStateType) {
 629         case D3DTRANSFORMSTATE_WORLD: {
 630             TRACE(" D3DTRANSFORMSTATE_WORLD :\n");
 631             conv_mat(lpD3DMatrix, This->world_mat);
 632             if (glThis->last_vertices_transformed == FALSE) {
 633                 glMatrixMode(GL_MODELVIEW);
 634                 glLoadMatrixf((float *) This->view_mat);
 635                 glMultMatrixf((float *) This->world_mat);
 636             }
 637         } break;
 638
 639         case D3DTRANSFORMSTATE_VIEW: {
 640             TRACE(" D3DTRANSFORMSTATE_VIEW :\n");
 641             conv_mat(lpD3DMatrix, This->view_mat);
 642             if (glThis->last_vertices_transformed == FALSE) {
 643                 glMatrixMode(GL_MODELVIEW);
 644                 glLoadMatrixf((float *) This->view_mat);
 645                 glMultMatrixf((float *) This->world_mat);
 646             }
 647         } break;
 648
 649         case D3DTRANSFORMSTATE_PROJECTION: {
 650             TRACE(" D3DTRANSFORMSTATE_PROJECTION :\n");
 651             conv_mat(lpD3DMatrix, This->proj_mat);
 652             if (glThis->last_vertices_transformed == FALSE) {
 653                 glMatrixMode(GL_PROJECTION);
 654                 glLoadMatrixf((float *) This->proj_mat);
 655             }
 656         } break;
 657
 658         default:
 659             ERR("Unknown transform type %08x !!!\n", dtstTransformStateType);
 660             break;
 661     }
 662     LEAVE_GL();
 663
 664     return DD_OK;
 665 }
 666
 667 static void draw_primitive_start_GL(D3DPRIMITIVETYPE d3dpt)
 668 {
 669     switch (d3dpt) {
 670         case D3DPT_POINTLIST:
 671             TRACE("Start POINTS\n");
 672             glBegin(GL_POINTS);
 673             break;
 674
 675         case D3DPT_LINELIST:
 676             TRACE("Start LINES\n");
 677             glBegin(GL_LINES);
 678             break;
 679
 680         case D3DPT_LINESTRIP:
 681             TRACE("Start LINE_STRIP\n");
 682             glBegin(GL_LINE_STRIP);
 683             break;
 684
 685         case D3DPT_TRIANGLELIST:
 686             TRACE("Start TRIANGLES\n");
 687             glBegin(GL_TRIANGLES);
 688             break;
 689
 690         case D3DPT_TRIANGLESTRIP:
 691             TRACE("Start TRIANGLE_STRIP\n");
 692             glBegin(GL_TRIANGLE_STRIP);
 693             break;
 694
 695         case D3DPT_TRIANGLEFAN:
 696             TRACE("Start TRIANGLE_FAN\n");
 697             glBegin(GL_TRIANGLE_FAN);
 698             break;
 699
 700         default:
 701             TRACE("Unhandled primitive\n");
 702             break;
 703     }
 704 }
 705
 706 static void draw_primitive_handle_GL_state(IDirect3DDeviceImpl *This,
 707                                            BOOLEAN vertex_transformed,
 708                                            BOOLEAN vertex_lit) {
 709     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
 710
 711     /* Puts GL in the correct lighting / transformation mode */
 712     if ((vertex_transformed == FALSE) &&
 713         (glThis->last_vertices_transformed == TRUE)) {
 714         /* Need to put the correct transformation again if we go from Transformed
 715            vertices to non-transformed ones.
 716         */
 717         glMatrixMode(GL_MODELVIEW);
 718         glLoadMatrixf((float *) This->view_mat);
 719         glMultMatrixf((float *) This->world_mat);
 720         glMatrixMode(GL_PROJECTION);
 721         glLoadMatrixf((float *) This->proj_mat);
 722
 723         if (glThis->render_state.fog_on == TRUE) glEnable(GL_FOG);
 724     } else if ((vertex_transformed == TRUE) &&
 725                (glThis->last_vertices_transformed == FALSE)) {
 726         GLfloat height, width;
 727         GLfloat trans_mat[16];
 728
 729         width = glThis->parent.surface->surface_desc.dwWidth;
 730         height = glThis->parent.surface->surface_desc.dwHeight;
 731
 732         /* The X axis is straighforward.. For the Y axis, we need to convert 'D3D' screen coordinates
 733            to OpenGL screen coordinates (ie the upper left corner is not the same).
 734            For Z, the mystery is what should it be mapped to ? Ie should the resulting range be between
 735            -1.0 and 1.0 (as the X and Y coordinates) or between 0.0 and 1.0 ? */
 736         trans_mat[ 0] = 2.0 / width;  trans_mat[ 4] = 0.0;  trans_mat[ 8] = 0.0; trans_mat[12] = -1.0;
 737         trans_mat[ 1] = 0.0; trans_mat[ 5] = -2.0 / height; trans_mat[ 9] = 0.0; trans_mat[13] =  1.0;
 738         trans_mat[ 2] = 0.0; trans_mat[ 6] = 0.0; trans_mat[10] = 1.0;           trans_mat[14] = -1.0;
 739         trans_mat[ 3] = 0.0; trans_mat[ 7] = 0.0; trans_mat[11] = 0.0;           trans_mat[15] =  1.0;
 740
 741         glMatrixMode(GL_MODELVIEW);
 742         glLoadIdentity();
 743         glMatrixMode(GL_PROJECTION);
 744         glLoadMatrixf(trans_mat);
 745
 746         /* Remove also fogging... */
 747         glDisable(GL_FOG);
 748     }
 749
 750     if ((glThis->last_vertices_lit == TRUE) && (vertex_lit == FALSE)) {
 751         glEnable(GL_LIGHTING);
 752     } else if ((glThis->last_vertices_lit == TRUE) && (vertex_lit == TRUE)) {
 753         glDisable(GL_LIGHTING);
 754     }
 755
 756     /* And save the current state */
 757     glThis->last_vertices_transformed = vertex_transformed;
 758     glThis->last_vertices_lit = vertex_lit;
 759 }
 760
 761
 762 inline static void draw_primitive(IDirect3DDeviceImpl *This, DWORD maxvert, WORD *index,
 763                                   D3DVERTEXTYPE d3dvt, D3DPRIMITIVETYPE d3dpt, void *lpvertex)
 764 {
 765     D3DDRAWPRIMITIVESTRIDEDDATA strided;
 766
 767     switch (d3dvt) {
 768         case D3DVT_VERTEX: {
 769             strided.position.lpvData = &((D3DVERTEX *) lpvertex)->u1.x;
 770             strided.position.dwStride = sizeof(D3DVERTEX);
 771             strided.normal.lpvData = &((D3DVERTEX *) lpvertex)->u4.nx;
 772             strided.normal.dwStride = sizeof(D3DVERTEX);
 773             strided.textureCoords[0].lpvData = &((D3DVERTEX *) lpvertex)->u7.tu;
 774             strided.textureCoords[0].dwStride = sizeof(D3DVERTEX);
 775             draw_primitive_strided_7(This, d3dpt, D3DFVF_VERTEX, &strided, 0, 0 /* Unused */, index, maxvert, 0 /* Unused */);
 776         } break;
 777
 778         case D3DVT_LVERTEX: {
 779             strided.position.lpvData = &((D3DLVERTEX *) lpvertex)->u1.x;
 780             strided.position.dwStride = sizeof(D3DLVERTEX);
 781             strided.diffuse.lpvData = &((D3DLVERTEX *) lpvertex)->u4.color;
 782             strided.diffuse.dwStride = sizeof(D3DLVERTEX);
 783             strided.specular.lpvData = &((D3DLVERTEX *) lpvertex)->u5.specular;
 784             strided.specular.dwStride = sizeof(D3DLVERTEX);
 785             strided.textureCoords[0].lpvData = &((D3DLVERTEX *) lpvertex)->u6.tu;
 786             strided.textureCoords[0].dwStride = sizeof(D3DLVERTEX);
 787             draw_primitive_strided_7(This, d3dpt, D3DFVF_LVERTEX, &strided, 0, 0 /* Unused */, index, maxvert, 0 /* Unused */);
 788         } break;
 789
 790         case D3DVT_TLVERTEX: {
 791             strided.position.lpvData = &((D3DTLVERTEX *) lpvertex)->u1.sx;
 792             strided.position.dwStride = sizeof(D3DTLVERTEX);
 793             strided.diffuse.lpvData = &((D3DTLVERTEX *) lpvertex)->u5.color;
 794             strided.diffuse.dwStride = sizeof(D3DTLVERTEX);
 795             strided.specular.lpvData = &((D3DTLVERTEX *) lpvertex)->u6.specular;
 796             strided.specular.dwStride = sizeof(D3DTLVERTEX);
 797             strided.textureCoords[0].lpvData = &((D3DTLVERTEX *) lpvertex)->u7.tu;
 798             strided.textureCoords[0].dwStride = sizeof(D3DTLVERTEX);
 799             draw_primitive_strided_7(This, d3dpt, D3DFVF_TLVERTEX, &strided, 0, 0 /* Unused */, index, maxvert, 0 /* Unused */);
 800         } break;
 801
 802         default:
 803             FIXME("Unhandled vertex type\n");
 804             break;
 805     }
 806 }
 807
 808 HRESULT WINAPI
 809 GL_IDirect3DDeviceImpl_2_DrawPrimitive(LPDIRECT3DDEVICE2 iface,
 810                                        D3DPRIMITIVETYPE d3dptPrimitiveType,
 811                                        D3DVERTEXTYPE d3dvtVertexType,
 812                                        LPVOID lpvVertices,
 813                                        DWORD dwVertexCount,
 814                                        DWORD dwFlags)
 815 {
 816     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 817     TRACE("(%p/%p)->(%08x,%08x,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
 818
 819     ENTER_GL();
 820     draw_primitive(This, dwVertexCount, NULL, d3dvtVertexType, d3dptPrimitiveType, lpvVertices);
 821     LEAVE_GL();
 822
 823     return DD_OK;
 824 }
 825
 826 HRESULT WINAPI
 827 GL_IDirect3DDeviceImpl_2_DrawIndexedPrimitive(LPDIRECT3DDEVICE2 iface,
 828                                               D3DPRIMITIVETYPE d3dptPrimitiveType,
 829                                               D3DVERTEXTYPE d3dvtVertexType,
 830                                               LPVOID lpvVertices,
 831                                               DWORD dwVertexCount,
 832                                               LPWORD dwIndices,
 833                                               DWORD dwIndexCount,
 834                                               DWORD dwFlags)
 835 {
 836     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 837     TRACE("(%p/%p)->(%08x,%08x,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
 838
 839     ENTER_GL();
 840     draw_primitive(This, dwIndexCount, dwIndices, d3dvtVertexType, d3dptPrimitiveType, lpvVertices);
 841     LEAVE_GL();
 842
 843     return DD_OK;
 844 }
 845
 846 HRESULT WINAPI
 847 GL_IDirect3DDeviceImpl_1_CreateExecuteBuffer(LPDIRECT3DDEVICE iface,
 848                                              LPD3DEXECUTEBUFFERDESC lpDesc,
 849                                              LPDIRECT3DEXECUTEBUFFER* lplpDirect3DExecuteBuffer,
 850                                              IUnknown* pUnkOuter)
 851 {
 852     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 853     IDirect3DExecuteBufferImpl *ret;
 854     HRESULT ret_value;
 855
 856     TRACE("(%p/%p)->(%p,%p,%p)\n", This, iface, lpDesc, lplpDirect3DExecuteBuffer, pUnkOuter);
 857
 858     ret_value = d3dexecutebuffer_create(&ret, This->d3d, This, lpDesc);
 859     *lplpDirect3DExecuteBuffer = ICOM_INTERFACE(ret, IDirect3DExecuteBuffer);
 860
 861     TRACE(" returning %p.\n", *lplpDirect3DExecuteBuffer);
 862
 863     return ret_value;
 864 }
 865
 866 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType, DWORD *elements)
 867 {
 868     DWORD size = 0;
 869     DWORD elts = 0;
 870
 871     if (d3dvtVertexType & D3DFVF_NORMAL) { size += 3 * sizeof(D3DVALUE); elts += 1; }
 872     if (d3dvtVertexType & D3DFVF_DIFFUSE) { size += sizeof(DWORD); elts += 1; }
 873     if (d3dvtVertexType & D3DFVF_SPECULAR) { size += sizeof(DWORD); elts += 1; }
 874     switch (d3dvtVertexType & D3DFVF_POSITION_MASK) {
 875         case D3DFVF_XYZ: size += 3 * sizeof(D3DVALUE); elts += 1; break;
 876         case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); elts += 1; break;
 877         default: TRACE(" matrix weighting not handled yet...\n");
 878     }
 879     size += 2 * sizeof(D3DVALUE) * ((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT);
 880     elts += (d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
 881
 882     if (elements) *elements = elts;
 883
 884     return size;
 885 }
 886
 887 void dump_flexible_vertex(DWORD d3dvtVertexType)
 888 {
 889     static const flag_info flags[] = {
 890         FE(D3DFVF_NORMAL),
 891         FE(D3DFVF_RESERVED1),
 892         FE(D3DFVF_DIFFUSE),
 893         FE(D3DFVF_SPECULAR)
 894     };
 895     if (d3dvtVertexType & D3DFVF_RESERVED0) DPRINTF("D3DFVF_RESERVED0 ");
 896     switch (d3dvtVertexType & D3DFVF_POSITION_MASK) {
 897 #define GEN_CASE(a) case a: DPRINTF(#a " "); break
 898         GEN_CASE(D3DFVF_XYZ);
 899         GEN_CASE(D3DFVF_XYZRHW);
 900         GEN_CASE(D3DFVF_XYZB1);
 901         GEN_CASE(D3DFVF_XYZB2);
 902         GEN_CASE(D3DFVF_XYZB3);
 903         GEN_CASE(D3DFVF_XYZB4);
 904         GEN_CASE(D3DFVF_XYZB5);
 905     }
 906     DDRAW_dump_flags_(d3dvtVertexType, flags, sizeof(flags)/sizeof(flags[0]), FALSE);
 907     switch (d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) {
 908         GEN_CASE(D3DFVF_TEX0);
 909         GEN_CASE(D3DFVF_TEX1);
 910         GEN_CASE(D3DFVF_TEX2);
 911         GEN_CASE(D3DFVF_TEX3);
 912         GEN_CASE(D3DFVF_TEX4);
 913         GEN_CASE(D3DFVF_TEX5);
 914         GEN_CASE(D3DFVF_TEX6);
 915         GEN_CASE(D3DFVF_TEX7);
 916         GEN_CASE(D3DFVF_TEX8);
 917     }
 918 #undef GEN_CASE
 919     DPRINTF("\n");
 920 }
 921
 922 /* These are the various handler used in the generic path */
 923 inline static void handle_xyz(D3DVALUE *coords) {
 924     glVertex3fv(coords);
 925 }
 926 inline static void handle_xyzrhw(D3DVALUE *coords) {
 927     if (coords[3] < 1e-8)
 928         glVertex3fv(coords);
 929     else {
 930         GLfloat w = 1.0 / coords[3];
 931
 932         glVertex4f(coords[0] * w,
 933                    coords[1] * w,
 934                    coords[2] * w,
 935                    w);
 936     }
 937 }
 938 inline static void handle_normal(D3DVALUE *coords) {
 939     glNormal3fv(coords);
 940 }
 941 inline static void handle_specular(DWORD *color) {
 942     /* Specular not handled yet properly... */
 943 }
 944 inline static void handle_diffuse(DWORD *color) {
 945     glColor4ub((*color >> 16) & 0xFF,
 946                (*color >>  8) & 0xFF,
 947                (*color >>  0) & 0xFF,
 948                (*color >> 24) & 0xFF);
 949 }
 950 inline static void handle_diffuse_and_specular(DWORD *color_d, DWORD *color_s) {
 951     handle_diffuse(color_d);
 952 }
 953 inline static void handle_diffuse_no_alpha(DWORD *color) {
 954     glColor3ub((*color >> 16) & 0xFF,
 955                (*color >>  8) & 0xFF,
 956                (*color >>  0) & 0xFF);
 957 }
 958 inline static void handle_diffuse_and_specular_no_alpha(DWORD *color_d, DWORD *color_s) {
 959     handle_diffuse_no_alpha(color_d);
 960 }
 961 inline static void handle_texture(D3DVALUE *coords) {
 962     glTexCoord2fv(coords);
 963 }
 964 inline static void handle_textures(D3DVALUE *coords, int tex_index) {
 965     /* For the moment, draw only the first texture.. */
 966     if (tex_index == 0) glTexCoord2fv(coords);
 967 }
 968
 969 static void draw_primitive_strided_7(IDirect3DDeviceImpl *This,
 970                                      D3DPRIMITIVETYPE d3dptPrimitiveType,
 971                                      DWORD d3dvtVertexType,
 972                                      LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
 973                                      DWORD dwStartVertex,
 974                                      DWORD dwVertexCount,
 975                                      LPWORD dwIndices,
 976                                      DWORD dwIndexCount,
 977                                      DWORD dwFlags)
 978 {
 979     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
 980     if (TRACE_ON(ddraw)) {
 981         TRACE(" Vertex format : "); dump_flexible_vertex(d3dvtVertexType);
 982     }
 983
 984     ENTER_GL();
 985     draw_primitive_handle_GL_state(This,
 986                                    (d3dvtVertexType & D3DFVF_POSITION_MASK) != D3DFVF_XYZ,
 987                                    (d3dvtVertexType & D3DFVF_NORMAL) == 0);
 988     draw_primitive_start_GL(d3dptPrimitiveType);
 989
 990     /* Some fast paths first before the generic case.... */
 991     if (d3dvtVertexType == D3DFVF_VERTEX) {
 992         int index;
 993
 994         for (index = 0; index < dwIndexCount; index++) {
 995             int i = (dwIndices == NULL) ? index : dwIndices[index];
 996             D3DVALUE *normal =
 997               (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
 998             D3DVALUE *tex_coord =
 999               (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[0].lpvData) + i * lpD3DDrawPrimStrideData->textureCoords[0].dwStride);
1000             D3DVALUE *position =
1001               (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1002
1003             handle_normal(normal);
1004             handle_texture(tex_coord);
1005             handle_xyz(position);
1006
1007             TRACE(" %f %f %f / %f %f %f (%f %f)\n",
1008                   position[0], position[1], position[2],
1009                   normal[0], normal[1], normal[2],
1010                   tex_coord[0], tex_coord[1]);
1011         }
1012     } else if (d3dvtVertexType == D3DFVF_TLVERTEX) {
1013         int index;
1014
1015         for (index = 0; index < dwIndexCount; index++) {
1016             int i = (dwIndices == NULL) ? index : dwIndices[index];
1017             DWORD *color_d =
1018               (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1019             DWORD *color_s =
1020               (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1021             D3DVALUE *tex_coord =
1022               (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[0].lpvData) + i * lpD3DDrawPrimStrideData->textureCoords[0].dwStride);
1023             D3DVALUE *position =
1024               (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1025
1026             if (glThis->render_state.alpha_blend_enable == TRUE)
1027                 handle_diffuse_and_specular(color_d, color_s);
1028             else
1029                 handle_diffuse_and_specular_no_alpha(color_d, color_s);
1030             handle_texture(tex_coord);
1031             handle_xyzrhw(position);
1032
1033             TRACE(" %f %f %f %f / %02lx %02lx %02lx %02lx - %02lx %02lx %02lx %02lx (%f %f)\n",
1034                   position[0], position[1], position[2], position[3],
1035                   (*color_d >> 16) & 0xFF,
1036                   (*color_d >>  8) & 0xFF,
1037                   (*color_d >>  0) & 0xFF,
1038                   (*color_d >> 24) & 0xFF,
1039                   (*color_s >> 16) & 0xFF,
1040                   (*color_s >>  8) & 0xFF,
1041                   (*color_s >>  0) & 0xFF,
1042                   (*color_s >> 24) & 0xFF,
1043                   tex_coord[0], tex_coord[1]);
1044         }
1045     } else if (((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) ||
1046                ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW)) {
1047         /* This is the 'slow path' but that should support all possible vertex formats out there...
1048            Note that people should write a fast path for all vertex formats out there...
1049         */
1050         int index;
1051         for (index = 0; index < dwIndexCount; index++) {
1052             int i = (dwIndices == NULL) ? index : dwIndices[index];
1053
1054             if (d3dvtVertexType & D3DFVF_NORMAL) {
1055                 D3DVALUE *normal =
1056                   (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
1057                 handle_normal(normal);
1058             }
1059             if ((d3dvtVertexType & (D3DFVF_DIFFUSE|D3DFVF_SPECULAR)) == (D3DFVF_DIFFUSE|D3DFVF_SPECULAR)) {
1060                 DWORD *color_d =
1061                   (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1062                 DWORD *color_s =
1063                   (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1064                 if (glThis->render_state.alpha_blend_enable == TRUE)
1065                     handle_diffuse_and_specular(color_d, color_s);
1066                 else
1067                     handle_diffuse_and_specular_no_alpha(color_d, color_s);
1068             } else {
1069                 if (d3dvtVertexType & D3DFVF_SPECULAR) {
1070                     DWORD *color_s =
1071                       (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1072                     handle_specular(color_s);
1073                 } else if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1074                     DWORD *color_d =
1075                       (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1076                     if (glThis->render_state.alpha_blend_enable == TRUE)
1077                         handle_diffuse(color_d);
1078                     else
1079                         handle_diffuse_no_alpha(color_d);
1080                 }
1081             }
1082
1083             if (((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT) == 1) {
1084                 /* Special case for single texture... */
1085                 D3DVALUE *tex_coord =
1086                   (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[0].lpvData) + i * lpD3DDrawPrimStrideData->textureCoords[0].dwStride);
1087                 handle_texture(tex_coord);
1088             } else {
1089                 int tex_index;
1090                 for (tex_index = 0; tex_index < ((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT); tex_index++) {
1091                     D3DVALUE *tex_coord =
1092                       (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[tex_index].lpvData) +
1093                                     i * lpD3DDrawPrimStrideData->textureCoords[tex_index].dwStride);
1094                     handle_textures(tex_coord, tex_index);
1095                 }
1096             }
1097             if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) {
1098                 D3DVALUE *position =
1099                   (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1100                 handle_xyz(position);
1101             } else if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW) {
1102                 D3DVALUE *position =
1103                   (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1104                 handle_xyzrhw(position);
1105             }
1106
1107             if (TRACE_ON(ddraw)) {
1108                 int tex_index;
1109
1110                 if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) {
1111                     D3DVALUE *position =
1112                       (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1113                     TRACE(" %f %f %f", position[0], position[1], position[2]);
1114                 } else if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW) {
1115                     D3DVALUE *position =
1116                       (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1117                     TRACE(" %f %f %f %f", position[0], position[1], position[2], position[3]);
1118                 }
1119                 if (d3dvtVertexType & D3DFVF_NORMAL) {
1120                     D3DVALUE *normal =
1121                       (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
1122                     DPRINTF(" / %f %f %f", normal[0], normal[1], normal[2]);
1123                 }
1124                 if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1125                     DWORD *color_d =
1126                       (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1127                     DPRINTF(" / %02lx %02lx %02lx %02lx",
1128                             (*color_d >> 16) & 0xFF,
1129                             (*color_d >>  8) & 0xFF,
1130                             (*color_d >>  0) & 0xFF,
1131                             (*color_d >> 24) & 0xFF);
1132                 }
1133                 if (d3dvtVertexType & D3DFVF_SPECULAR) {
1134                     DWORD *color_s =
1135                       (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1136                     DPRINTF(" / %02lx %02lx %02lx %02lx",
1137                             (*color_s >> 16) & 0xFF,
1138                             (*color_s >>  8) & 0xFF,
1139                             (*color_s >>  0) & 0xFF,
1140                             (*color_s >> 24) & 0xFF);
1141                 }
1142                 for (tex_index = 0; tex_index < ((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT); tex_index++) {
1143                     D3DVALUE *tex_coord =
1144                       (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[tex_index].lpvData) +
1145                                     i * lpD3DDrawPrimStrideData->textureCoords[tex_index].dwStride);
1146                     DPRINTF(" / %f %f", tex_coord[0], tex_coord[1]);
1147                 }
1148                 DPRINTF("\n");
1149             }
1150         }
1151     } else {
1152         ERR(" matrix weighting not handled yet....\n");
1153     }
1154
1155     glEnd();
1156     LEAVE_GL();
1157     TRACE("End\n");
1158 }
1159
1160 static void draw_primitive_7(IDirect3DDeviceImpl *This,
1161                              D3DPRIMITIVETYPE d3dptPrimitiveType,
1162                              DWORD d3dvtVertexType,
1163                              LPVOID lpvVertices,
1164                              DWORD dwStartVertex,
1165                              DWORD dwVertexCount,
1166                              LPWORD dwIndices,
1167                              DWORD dwIndexCount,
1168                              DWORD dwFlags)
1169 {
1170     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1171     int current_offset = 0;
1172     int tex_index;
1173
1174     if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) {
1175         strided.position.lpvData = lpvVertices;
1176         current_offset += 3 * sizeof(D3DVALUE);
1177     } else {
1178         strided.position.lpvData  = lpvVertices;
1179         current_offset += 4 * sizeof(D3DVALUE);
1180     }
1181     if (d3dvtVertexType & D3DFVF_NORMAL) {
1182         strided.normal.lpvData  = ((char *) lpvVertices) + current_offset;
1183         current_offset += 3 * sizeof(D3DVALUE);
1184     }
1185     if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1186         strided.diffuse.lpvData  = ((char *) lpvVertices) + current_offset;
1187         current_offset += sizeof(DWORD);
1188     }
1189     if (d3dvtVertexType & D3DFVF_SPECULAR) {
1190         strided.specular.lpvData  = ((char *) lpvVertices) + current_offset;
1191         current_offset += sizeof(DWORD);
1192     }
1193     for (tex_index = 0; tex_index < ((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT); tex_index++) {
1194         strided.textureCoords[tex_index].lpvData  = ((char *) lpvVertices) + current_offset;
1195         current_offset += 2 * sizeof(D3DVALUE);
1196     }
1197     strided.position.dwStride = current_offset;
1198     strided.normal.dwStride   = current_offset;
1199     strided.diffuse.dwStride  = current_offset;
1200     strided.specular.dwStride = current_offset;
1201     for (tex_index = 0; tex_index < ((d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT); tex_index++)
1202         strided.textureCoords[tex_index].dwStride  = current_offset;
1203
1204     draw_primitive_strided_7(This, d3dptPrimitiveType, d3dvtVertexType, &strided, dwStartVertex, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1205 }
1206
1207 HRESULT WINAPI
1208 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitive(LPDIRECT3DDEVICE7 iface,
1209                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
1210                                           DWORD d3dvtVertexType,
1211                                           LPVOID lpvVertices,
1212                                           DWORD dwVertexCount,
1213                                           DWORD dwFlags)
1214 {
1215     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1216     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
1217
1218     draw_primitive_7(This, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, 0, dwVertexCount, NULL, dwVertexCount, dwFlags);
1219
1220     return DD_OK;
1221 }
1222
1223 HRESULT WINAPI
1224 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitive(LPDIRECT3DDEVICE7 iface,
1225                                                  D3DPRIMITIVETYPE d3dptPrimitiveType,
1226                                                  DWORD d3dvtVertexType,
1227                                                  LPVOID lpvVertices,
1228                                                  DWORD dwVertexCount,
1229                                                  LPWORD dwIndices,
1230                                                  DWORD dwIndexCount,
1231                                                  DWORD dwFlags)
1232 {
1233     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1234     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1235
1236     draw_primitive_7(This, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, 0, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1237
1238     return DD_OK;
1239 }
1240
1241 HRESULT WINAPI
1242 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
1243                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
1244                                                    DWORD dwVertexType,
1245                                                    LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1246                                                    DWORD dwVertexCount,
1247                                                    DWORD dwFlags)
1248 {
1249     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1250     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, dwFlags);
1251     draw_primitive_strided_7(This, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, 0, dwVertexCount, NULL, dwVertexCount, dwFlags);
1252     return DD_OK;
1253 }
1254
1255 HRESULT WINAPI
1256 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
1257                                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
1258                                                           DWORD dwVertexType,
1259                                                           LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1260                                                           DWORD dwVertexCount,
1261                                                           LPWORD lpIndex,
1262                                                           DWORD dwIndexCount,
1263                                                           DWORD dwFlags)
1264 {
1265     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1266     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
1267     draw_primitive_strided_7(This, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, 0, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
1268     return DD_OK;
1269 }
1270
1271 HRESULT WINAPI
1272 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveVB(LPDIRECT3DDEVICE7 iface,
1273                                             D3DPRIMITIVETYPE d3dptPrimitiveType,
1274                                             LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
1275                                             DWORD dwStartVertex,
1276                                             DWORD dwNumVertices,
1277                                             DWORD dwFlags)
1278 {
1279     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1280     IDirect3DVertexBufferImpl *vb_impl = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, lpD3DVertexBuf);
1281
1282     TRACE("(%p/%p)->(%08x,%p,%08lx,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, dwFlags);
1283
1284     draw_primitive_7(This, d3dptPrimitiveType, vb_impl->desc.dwFVF, vb_impl->vertices, dwStartVertex, dwNumVertices, NULL, dwNumVertices, dwFlags);
1285
1286     return DD_OK;
1287 }
1288
1289 HRESULT WINAPI
1290 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB(LPDIRECT3DDEVICE7 iface,
1291                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
1292                                                    LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
1293                                                    DWORD dwStartVertex,
1294                                                    DWORD dwNumVertices,
1295                                                    LPWORD lpwIndices,
1296                                                    DWORD dwIndexCount,
1297                                                    DWORD dwFlags)
1298 {
1299     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1300     IDirect3DVertexBufferImpl *vb_impl = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, lpD3DVertexBuf);
1301
1302     TRACE("(%p/%p)->(%08x,%p,%08lx,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
1303
1304     draw_primitive_7(This, d3dptPrimitiveType, vb_impl->desc.dwFVF, vb_impl->vertices, dwStartVertex, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
1305
1306     return DD_OK;
1307 }
1308
1309 HRESULT WINAPI
1310 GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface,
1311                                                  DWORD dwStage,
1312                                                  D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
1313                                                  DWORD dwState)
1314 {
1315     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1316     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
1317     GLenum gl_state;
1318
1319     TRACE("(%p/%p)->(%08lx,%08x,%08lx)\n", This, iface, dwStage, d3dTexStageStateType, dwState);
1320
1321     if (TRACE_ON(ddraw)) {
1322         TRACE(" Stage type is : ");
1323         switch (d3dTexStageStateType) {
1324 #define GEN_CASE(a) case a: DPRINTF(#a " "); break
1325             GEN_CASE(D3DTSS_COLOROP);
1326             GEN_CASE(D3DTSS_COLORARG1);
1327             GEN_CASE(D3DTSS_COLORARG2);
1328             GEN_CASE(D3DTSS_ALPHAOP);
1329             GEN_CASE(D3DTSS_ALPHAARG1);
1330             GEN_CASE(D3DTSS_ALPHAARG2);
1331             GEN_CASE(D3DTSS_BUMPENVMAT00);
1332             GEN_CASE(D3DTSS_BUMPENVMAT01);
1333             GEN_CASE(D3DTSS_BUMPENVMAT10);
1334             GEN_CASE(D3DTSS_BUMPENVMAT11);
1335             GEN_CASE(D3DTSS_TEXCOORDINDEX);
1336             GEN_CASE(D3DTSS_ADDRESS);
1337             GEN_CASE(D3DTSS_ADDRESSU);
1338             GEN_CASE(D3DTSS_ADDRESSV);
1339             GEN_CASE(D3DTSS_BORDERCOLOR);
1340             GEN_CASE(D3DTSS_MAGFILTER);
1341             GEN_CASE(D3DTSS_MINFILTER);
1342             GEN_CASE(D3DTSS_MIPFILTER);
1343             GEN_CASE(D3DTSS_MIPMAPLODBIAS);
1344             GEN_CASE(D3DTSS_MAXMIPLEVEL);
1345             GEN_CASE(D3DTSS_MAXANISOTROPY);
1346             GEN_CASE(D3DTSS_BUMPENVLSCALE);
1347             GEN_CASE(D3DTSS_BUMPENVLOFFSET);
1348             GEN_CASE(D3DTSS_TEXTURETRANSFORMFLAGS);
1349 #undef GEN_CASE
1350             default: DPRINTF("UNKNOWN !!!");
1351         }
1352         DPRINTF(" => ");
1353     }
1354
1355     switch (d3dTexStageStateType) {
1356         case D3DTSS_MINFILTER:
1357             switch ((D3DTEXTUREMINFILTER) dwState) {
1358                 case D3DTFN_POINT:
1359                     if (TRACE_ON(ddraw)) DPRINTF("D3DTFN_POINT\n");
1360                     gl_state = GL_NEAREST;
1361                     break;
1362                 case D3DTFN_LINEAR:
1363                     if (TRACE_ON(ddraw)) DPRINTF("D3DTFN_LINEAR\n");
1364                     gl_state = GL_LINEAR;
1365                     break;
1366                 default:
1367                     if (TRACE_ON(ddraw)) DPRINTF(" state unhandled (%ld).\n", dwState);
1368                     gl_state = GL_LINEAR;
1369                     break;
1370             }
1371             glThis->render_state.min = gl_state;
1372             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_state);
1373             break;
1374
1375         case D3DTSS_MAGFILTER:
1376             switch ((D3DTEXTUREMAGFILTER) dwState) {
1377                 case D3DTFG_POINT:
1378                     if (TRACE_ON(ddraw)) DPRINTF("D3DTFG_POINT\n");
1379                     gl_state = GL_NEAREST;
1380                     break;
1381                 case D3DTFG_LINEAR:
1382                     if (TRACE_ON(ddraw)) DPRINTF("D3DTFG_LINEAR\n");
1383                     gl_state = GL_LINEAR;
1384                     break;
1385                 default:
1386                     if (TRACE_ON(ddraw)) DPRINTF(" state unhandled (%ld).\n", dwState);
1387                     gl_state = GL_LINEAR;
1388                     break;
1389             }
1390             glThis->render_state.mag = gl_state;
1391             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_state);
1392             break;
1393
1394         case D3DTSS_ADDRESS:
1395         case D3DTSS_ADDRESSU:
1396         case D3DTSS_ADDRESSV: {
1397             GLenum arg = GL_REPEAT; /* Default value */
1398             switch ((D3DTEXTUREADDRESS) dwState) {
1399                 case D3DTADDRESS_WRAP:   if (TRACE_ON(ddraw)) DPRINTF("D3DTADDRESS_WRAP\n"); arg = GL_REPEAT; break;
1400                 case D3DTADDRESS_CLAMP:  if (TRACE_ON(ddraw)) DPRINTF("D3DTADDRESS_CLAMP\n"); arg = GL_CLAMP; break;
1401                 case D3DTADDRESS_BORDER: if (TRACE_ON(ddraw)) DPRINTF("D3DTADDRESS_BORDER\n"); arg = GL_CLAMP_TO_EDGE; break;
1402                 default: DPRINTF(" state unhandled (%ld).\n", dwState);
1403             }
1404             if ((d3dTexStageStateType == D3DTSS_ADDRESS) ||
1405                 (d3dTexStageStateType == D3DTSS_ADDRESSU))
1406                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, arg);
1407             if ((d3dTexStageStateType == D3DTSS_ADDRESS) ||
1408                 (d3dTexStageStateType == D3DTSS_ADDRESSV))
1409                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, arg);
1410         } break;
1411
1412         default:
1413             if (TRACE_ON(ddraw)) DPRINTF(" unhandled.\n");
1414     }
1415
1416     return DD_OK;
1417 }
1418
1419 HRESULT WINAPI
1420 GL_IDirect3DDeviceImpl_7_3T_SetTexture(LPDIRECT3DDEVICE7 iface,
1421                                        DWORD dwStage,
1422                                        LPDIRECTDRAWSURFACE7 lpTexture2)
1423 {
1424     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1425
1426     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwStage, lpTexture2);
1427
1428     if (This->current_texture[dwStage] != NULL) {
1429         /* Seems that this is not right... Need to test in real Windows
1430            IDirect3DTexture2_Release(ICOM_INTERFACE(This->current_texture[dwStage], IDirect3DTexture2)); */
1431     }
1432
1433     ENTER_GL();
1434     if (lpTexture2 == NULL) {
1435         TRACE(" disabling 2D texturing.\n");
1436         glBindTexture(GL_TEXTURE_2D, 0);
1437         glDisable(GL_TEXTURE_2D);
1438     } else {
1439         IDirectDrawSurfaceImpl *tex_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, lpTexture2);
1440         IDirect3DTextureGLImpl *tex_glimpl = (IDirect3DTextureGLImpl *) tex_impl->tex_private;
1441
1442         This->current_texture[dwStage] = tex_impl;
1443         IDirectDrawSurface7_AddRef(ICOM_INTERFACE(tex_impl, IDirectDrawSurface7)); /* Not sure about this either */
1444
1445         TRACE(" activating OpenGL texture %d.\n", tex_glimpl->tex_name);
1446
1447         glEnable(GL_TEXTURE_2D);
1448         glBindTexture(GL_TEXTURE_2D, tex_glimpl->tex_name);
1449     }
1450     LEAVE_GL();
1451
1452     return DD_OK;
1453 }
1454
1455 HRESULT WINAPI
1456 GL_IDirect3DDeviceImpl_7_GetCaps(LPDIRECT3DDEVICE7 iface,
1457                                  LPD3DDEVICEDESC7 lpD3DHELDevDesc)
1458 {
1459     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1460     TRACE("(%p/%p)->(%p)\n", This, iface, lpD3DHELDevDesc);
1461
1462     fill_opengl_caps_7(lpD3DHELDevDesc);
1463
1464     TRACE(" returning caps : no dump function yet.\n");
1465
1466     return DD_OK;
1467 }
1468
1469 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1470 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice7.fun))
1471 #else
1472 # define XCAST(fun)     (void*)
1473 #endif
1474
1475 ICOM_VTABLE(IDirect3DDevice7) VTABLE_IDirect3DDevice7 =
1476 {
1477     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1478     XCAST(QueryInterface) Main_IDirect3DDeviceImpl_7_3T_2T_1T_QueryInterface,
1479     XCAST(AddRef) Main_IDirect3DDeviceImpl_7_3T_2T_1T_AddRef,
1480     XCAST(Release) GL_IDirect3DDeviceImpl_7_3T_2T_1T_Release,
1481     XCAST(GetCaps) GL_IDirect3DDeviceImpl_7_GetCaps,
1482     XCAST(EnumTextureFormats) GL_IDirect3DDeviceImpl_7_3T_EnumTextureFormats,
1483     XCAST(BeginScene) Main_IDirect3DDeviceImpl_7_3T_2T_1T_BeginScene,
1484     XCAST(EndScene) Main_IDirect3DDeviceImpl_7_3T_2T_1T_EndScene,
1485     XCAST(GetDirect3D) Main_IDirect3DDeviceImpl_7_3T_2T_1T_GetDirect3D,
1486     XCAST(SetRenderTarget) Main_IDirect3DDeviceImpl_7_3T_2T_SetRenderTarget,
1487     XCAST(GetRenderTarget) Main_IDirect3DDeviceImpl_7_3T_2T_GetRenderTarget,
1488     XCAST(Clear) Main_IDirect3DDeviceImpl_7_Clear,
1489     XCAST(SetTransform) GL_IDirect3DDeviceImpl_7_3T_2T_SetTransform,
1490     XCAST(GetTransform) Main_IDirect3DDeviceImpl_7_3T_2T_GetTransform,
1491     XCAST(SetViewport) Main_IDirect3DDeviceImpl_7_SetViewport,
1492     XCAST(MultiplyTransform) Main_IDirect3DDeviceImpl_7_3T_2T_MultiplyTransform,
1493     XCAST(GetViewport) Main_IDirect3DDeviceImpl_7_GetViewport,
1494     XCAST(SetMaterial) Main_IDirect3DDeviceImpl_7_SetMaterial,
1495     XCAST(GetMaterial) Main_IDirect3DDeviceImpl_7_GetMaterial,
1496     XCAST(SetLight) Main_IDirect3DDeviceImpl_7_SetLight,
1497     XCAST(GetLight) Main_IDirect3DDeviceImpl_7_GetLight,
1498     XCAST(SetRenderState) GL_IDirect3DDeviceImpl_7_3T_2T_SetRenderState,
1499     XCAST(GetRenderState) Main_IDirect3DDeviceImpl_7_3T_2T_GetRenderState,
1500     XCAST(BeginStateBlock) Main_IDirect3DDeviceImpl_7_BeginStateBlock,
1501     XCAST(EndStateBlock) Main_IDirect3DDeviceImpl_7_EndStateBlock,
1502     XCAST(PreLoad) Main_IDirect3DDeviceImpl_7_PreLoad,
1503     XCAST(DrawPrimitive) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitive,
1504     XCAST(DrawIndexedPrimitive) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitive,
1505     XCAST(SetClipStatus) Main_IDirect3DDeviceImpl_7_3T_2T_SetClipStatus,
1506     XCAST(GetClipStatus) Main_IDirect3DDeviceImpl_7_3T_2T_GetClipStatus,
1507     XCAST(DrawPrimitiveStrided) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveStrided,
1508     XCAST(DrawIndexedPrimitiveStrided) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveStrided,
1509     XCAST(DrawPrimitiveVB) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveVB,
1510     XCAST(DrawIndexedPrimitiveVB) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB,
1511     XCAST(ComputeSphereVisibility) Main_IDirect3DDeviceImpl_7_3T_ComputeSphereVisibility,
1512     XCAST(GetTexture) Main_IDirect3DDeviceImpl_7_3T_GetTexture,
1513     XCAST(SetTexture) GL_IDirect3DDeviceImpl_7_3T_SetTexture,
1514     XCAST(GetTextureStageState) Main_IDirect3DDeviceImpl_7_3T_GetTextureStageState,
1515     XCAST(SetTextureStageState) GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState,
1516     XCAST(ValidateDevice) Main_IDirect3DDeviceImpl_7_3T_ValidateDevice,
1517     XCAST(ApplyStateBlock) Main_IDirect3DDeviceImpl_7_ApplyStateBlock,
1518     XCAST(CaptureStateBlock) Main_IDirect3DDeviceImpl_7_CaptureStateBlock,
1519     XCAST(DeleteStateBlock) Main_IDirect3DDeviceImpl_7_DeleteStateBlock,
1520     XCAST(CreateStateBlock) Main_IDirect3DDeviceImpl_7_CreateStateBlock,
1521     XCAST(Load) Main_IDirect3DDeviceImpl_7_Load,
1522     XCAST(LightEnable) Main_IDirect3DDeviceImpl_7_LightEnable,
1523     XCAST(GetLightEnable) Main_IDirect3DDeviceImpl_7_GetLightEnable,
1524     XCAST(SetClipPlane) Main_IDirect3DDeviceImpl_7_SetClipPlane,
1525     XCAST(GetClipPlane) Main_IDirect3DDeviceImpl_7_GetClipPlane,
1526     XCAST(GetInfo) Main_IDirect3DDeviceImpl_7_GetInfo,
1527 };
1528
1529 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1530 #undef XCAST
1531 #endif
1532
1533
1534 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1535 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice3.fun))
1536 #else
1537 # define XCAST(fun)     (void*)
1538 #endif
1539
1540 ICOM_VTABLE(IDirect3DDevice3) VTABLE_IDirect3DDevice3 =
1541 {
1542     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1543     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_3_QueryInterface,
1544     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_3_AddRef,
1545     XCAST(Release) Thunk_IDirect3DDeviceImpl_3_Release,
1546     XCAST(GetCaps) GL_IDirect3DDeviceImpl_3_2T_1T_GetCaps,
1547     XCAST(GetStats) Main_IDirect3DDeviceImpl_3_2T_1T_GetStats,
1548     XCAST(AddViewport) Main_IDirect3DDeviceImpl_3_2T_1T_AddViewport,
1549     XCAST(DeleteViewport) Main_IDirect3DDeviceImpl_3_2T_1T_DeleteViewport,
1550     XCAST(NextViewport) Main_IDirect3DDeviceImpl_3_2T_1T_NextViewport,
1551     XCAST(EnumTextureFormats) Thunk_IDirect3DDeviceImpl_3_EnumTextureFormats,
1552     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_3_BeginScene,
1553     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_3_EndScene,
1554     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_3_GetDirect3D,
1555     XCAST(SetCurrentViewport) Main_IDirect3DDeviceImpl_3_2T_SetCurrentViewport,
1556     XCAST(GetCurrentViewport) Main_IDirect3DDeviceImpl_3_2T_GetCurrentViewport,
1557     XCAST(SetRenderTarget) Thunk_IDirect3DDeviceImpl_3_SetRenderTarget,
1558     XCAST(GetRenderTarget) Thunk_IDirect3DDeviceImpl_3_GetRenderTarget,
1559     XCAST(Begin) Main_IDirect3DDeviceImpl_3_Begin,
1560     XCAST(BeginIndexed) Main_IDirect3DDeviceImpl_3_BeginIndexed,
1561     XCAST(Vertex) Main_IDirect3DDeviceImpl_3_2T_Vertex,
1562     XCAST(Index) Main_IDirect3DDeviceImpl_3_2T_Index,
1563     XCAST(End) Main_IDirect3DDeviceImpl_3_2T_End,
1564     XCAST(GetRenderState) Thunk_IDirect3DDeviceImpl_3_GetRenderState,
1565     XCAST(SetRenderState) Thunk_IDirect3DDeviceImpl_3_SetRenderState,
1566     XCAST(GetLightState) Main_IDirect3DDeviceImpl_3_2T_GetLightState,
1567     XCAST(SetLightState) GL_IDirect3DDeviceImpl_3_2T_SetLightState,
1568     XCAST(SetTransform) Thunk_IDirect3DDeviceImpl_3_SetTransform,
1569     XCAST(GetTransform) Thunk_IDirect3DDeviceImpl_3_GetTransform,
1570     XCAST(MultiplyTransform) Thunk_IDirect3DDeviceImpl_3_MultiplyTransform,
1571     XCAST(DrawPrimitive) Thunk_IDirect3DDeviceImpl_3_DrawPrimitive,
1572     XCAST(DrawIndexedPrimitive) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitive,
1573     XCAST(SetClipStatus) Thunk_IDirect3DDeviceImpl_3_SetClipStatus,
1574     XCAST(GetClipStatus) Thunk_IDirect3DDeviceImpl_3_GetClipStatus,
1575     XCAST(DrawPrimitiveStrided) Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveStrided,
1576     XCAST(DrawIndexedPrimitiveStrided) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveStrided,
1577     XCAST(DrawPrimitiveVB) Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveVB,
1578     XCAST(DrawIndexedPrimitiveVB) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveVB,
1579     XCAST(ComputeSphereVisibility) Thunk_IDirect3DDeviceImpl_3_ComputeSphereVisibility,
1580     XCAST(GetTexture) Thunk_IDirect3DDeviceImpl_3_GetTexture,
1581     XCAST(SetTexture) Thunk_IDirect3DDeviceImpl_3_SetTexture,
1582     XCAST(GetTextureStageState) Thunk_IDirect3DDeviceImpl_3_GetTextureStageState,
1583     XCAST(SetTextureStageState) Thunk_IDirect3DDeviceImpl_3_SetTextureStageState,
1584     XCAST(ValidateDevice) Thunk_IDirect3DDeviceImpl_3_ValidateDevice,
1585 };
1586
1587 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1588 #undef XCAST
1589 #endif
1590
1591
1592 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1593 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice2.fun))
1594 #else
1595 # define XCAST(fun)     (void*)
1596 #endif
1597
1598 ICOM_VTABLE(IDirect3DDevice2) VTABLE_IDirect3DDevice2 =
1599 {
1600     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1601     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_2_QueryInterface,
1602     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_2_AddRef,
1603     XCAST(Release) Thunk_IDirect3DDeviceImpl_2_Release,
1604     XCAST(GetCaps) Thunk_IDirect3DDeviceImpl_2_GetCaps,
1605     XCAST(SwapTextureHandles) Main_IDirect3DDeviceImpl_2_SwapTextureHandles,
1606     XCAST(GetStats) Thunk_IDirect3DDeviceImpl_2_GetStats,
1607     XCAST(AddViewport) Thunk_IDirect3DDeviceImpl_2_AddViewport,
1608     XCAST(DeleteViewport) Thunk_IDirect3DDeviceImpl_2_DeleteViewport,
1609     XCAST(NextViewport) Thunk_IDirect3DDeviceImpl_2_NextViewport,
1610     XCAST(EnumTextureFormats) GL_IDirect3DDeviceImpl_2_1T_EnumTextureFormats,
1611     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_2_BeginScene,
1612     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_2_EndScene,
1613     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_2_GetDirect3D,
1614     XCAST(SetCurrentViewport) Thunk_IDirect3DDeviceImpl_2_SetCurrentViewport,
1615     XCAST(GetCurrentViewport) Thunk_IDirect3DDeviceImpl_2_GetCurrentViewport,
1616     XCAST(SetRenderTarget) Thunk_IDirect3DDeviceImpl_2_SetRenderTarget,
1617     XCAST(GetRenderTarget) Thunk_IDirect3DDeviceImpl_2_GetRenderTarget,
1618     XCAST(Begin) Main_IDirect3DDeviceImpl_2_Begin,
1619     XCAST(BeginIndexed) Main_IDirect3DDeviceImpl_2_BeginIndexed,
1620     XCAST(Vertex) Thunk_IDirect3DDeviceImpl_2_Vertex,
1621     XCAST(Index) Thunk_IDirect3DDeviceImpl_2_Index,
1622     XCAST(End) Thunk_IDirect3DDeviceImpl_2_End,
1623     XCAST(GetRenderState) Thunk_IDirect3DDeviceImpl_2_GetRenderState,
1624     XCAST(SetRenderState) Thunk_IDirect3DDeviceImpl_2_SetRenderState,
1625     XCAST(GetLightState) Thunk_IDirect3DDeviceImpl_2_GetLightState,
1626     XCAST(SetLightState) Thunk_IDirect3DDeviceImpl_2_SetLightState,
1627     XCAST(SetTransform) Thunk_IDirect3DDeviceImpl_2_SetTransform,
1628     XCAST(GetTransform) Thunk_IDirect3DDeviceImpl_2_GetTransform,
1629     XCAST(MultiplyTransform) Thunk_IDirect3DDeviceImpl_2_MultiplyTransform,
1630     XCAST(DrawPrimitive) GL_IDirect3DDeviceImpl_2_DrawPrimitive,
1631     XCAST(DrawIndexedPrimitive) GL_IDirect3DDeviceImpl_2_DrawIndexedPrimitive,
1632     XCAST(SetClipStatus) Thunk_IDirect3DDeviceImpl_2_SetClipStatus,
1633     XCAST(GetClipStatus) Thunk_IDirect3DDeviceImpl_2_GetClipStatus,
1634 };
1635
1636 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1637 #undef XCAST
1638 #endif
1639
1640
1641 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1642 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice.fun))
1643 #else
1644 # define XCAST(fun)     (void*)
1645 #endif
1646
1647 ICOM_VTABLE(IDirect3DDevice) VTABLE_IDirect3DDevice =
1648 {
1649     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1650     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_1_QueryInterface,
1651     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_1_AddRef,
1652     XCAST(Release) Thunk_IDirect3DDeviceImpl_1_Release,
1653     XCAST(Initialize) Main_IDirect3DDeviceImpl_1_Initialize,
1654     XCAST(GetCaps) Thunk_IDirect3DDeviceImpl_1_GetCaps,
1655     XCAST(SwapTextureHandles) Main_IDirect3DDeviceImpl_1_SwapTextureHandles,
1656     XCAST(CreateExecuteBuffer) GL_IDirect3DDeviceImpl_1_CreateExecuteBuffer,
1657     XCAST(GetStats) Thunk_IDirect3DDeviceImpl_1_GetStats,
1658     XCAST(Execute) Main_IDirect3DDeviceImpl_1_Execute,
1659     XCAST(AddViewport) Thunk_IDirect3DDeviceImpl_1_AddViewport,
1660     XCAST(DeleteViewport) Thunk_IDirect3DDeviceImpl_1_DeleteViewport,
1661     XCAST(NextViewport) Thunk_IDirect3DDeviceImpl_1_NextViewport,
1662     XCAST(Pick) Main_IDirect3DDeviceImpl_1_Pick,
1663     XCAST(GetPickRecords) Main_IDirect3DDeviceImpl_1_GetPickRecords,
1664     XCAST(EnumTextureFormats) Thunk_IDirect3DDeviceImpl_1_EnumTextureFormats,
1665     XCAST(CreateMatrix) Main_IDirect3DDeviceImpl_1_CreateMatrix,
1666     XCAST(SetMatrix) Main_IDirect3DDeviceImpl_1_SetMatrix,
1667     XCAST(GetMatrix) Main_IDirect3DDeviceImpl_1_GetMatrix,
1668     XCAST(DeleteMatrix) Main_IDirect3DDeviceImpl_1_DeleteMatrix,
1669     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_1_BeginScene,
1670     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_1_EndScene,
1671     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_1_GetDirect3D,
1672 };
1673
1674 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1675 #undef XCAST
1676 #endif
1677
1678 static HRESULT d3ddevice_clear(IDirect3DDeviceImpl *This,
1679                                DWORD dwCount,
1680                                LPD3DRECT lpRects,
1681                                DWORD dwFlags,
1682                                DWORD dwColor,
1683                                D3DVALUE dvZ,
1684                                DWORD dwStencil)
1685 {
1686     GLboolean ztest;
1687     GLfloat old_z_clear_value;
1688     GLbitfield bitfield = 0;
1689     GLint old_stencil_clear_value;
1690     GLfloat old_color_clear_value[4];
1691
1692     TRACE("(%p)->(%08lx,%p,%08lx,%08lx,%f,%08lx)\n", This, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil);
1693     if (TRACE_ON(ddraw)) {
1694         if (dwCount > 0) {
1695             int i;
1696             TRACE(" rectangles : \n");
1697             for (i = 0; i < dwCount; i++) {
1698                 TRACE("  - %ld x %ld     %ld x %ld\n", lpRects[i].u1.x1, lpRects[i].u2.y1, lpRects[i].u3.x2, lpRects[i].u4.y2);
1699             }
1700         }
1701     }
1702
1703     if (dwCount > 1) {
1704         WARN("  Warning, this function only for now clears the whole screen...\n");
1705     }
1706
1707     /* Clears the screen */
1708     ENTER_GL();
1709     if (dwFlags & D3DCLEAR_ZBUFFER) {
1710         bitfield |= GL_DEPTH_BUFFER_BIT;
1711         glGetBooleanv(GL_DEPTH_WRITEMASK, &ztest);
1712         glDepthMask(GL_TRUE); /* Enables Z writing to be sure to delete also the Z buffer */
1713         glGetFloatv(GL_DEPTH_CLEAR_VALUE, &old_z_clear_value);
1714         glClearDepth(dvZ);
1715         TRACE(" depth value : %f\n", dvZ);
1716     }
1717     if (dwFlags & D3DCLEAR_STENCIL) {
1718         bitfield |= GL_STENCIL_BUFFER_BIT;
1719         glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &old_stencil_clear_value);
1720         glClearStencil(dwStencil);
1721         TRACE(" stencil value : %ld\n", dwStencil);
1722     }
1723     if (dwFlags & D3DCLEAR_TARGET) {
1724         bitfield |= GL_COLOR_BUFFER_BIT;
1725         glGetFloatv(GL_COLOR_CLEAR_VALUE, old_color_clear_value);
1726         glClearColor(((dwColor >> 16) & 0xFF) / 255.0,
1727                      ((dwColor >>  8) & 0xFF) / 255.0,
1728                      ((dwColor >>  0) & 0xFF) / 255.0,
1729                      ((dwColor >> 24) & 0xFF) / 255.0);
1730         TRACE(" color value (ARGB) : %08lx\n", dwColor);
1731     }
1732
1733     glClear(bitfield);
1734
1735     if (dwFlags & D3DCLEAR_ZBUFFER) {
1736         glDepthMask(ztest);
1737         glClearDepth(old_z_clear_value);
1738     }
1739      if (dwFlags & D3DCLEAR_STENCIL) {
1740         bitfield |= GL_STENCIL_BUFFER_BIT;
1741         glClearStencil(old_stencil_clear_value);
1742     }
1743     if (dwFlags & D3DCLEAR_TARGET) {
1744         bitfield |= GL_COLOR_BUFFER_BIT;
1745         glClearColor(old_color_clear_value[0],
1746                      old_color_clear_value[1],
1747                      old_color_clear_value[2],
1748                      old_color_clear_value[3]);
1749     }
1750
1751     LEAVE_GL();
1752
1753     return DD_OK;
1754 }
1755
1756 HRESULT
1757 d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst,
1758               LPDIRECTDRAWSURFACE7 src, LPRECT rsrc,
1759               DWORD dwFlags, LPDDBLTFX lpbltfx)
1760 {
1761     if (dwFlags & DDBLT_COLORFILL) {
1762         /* This is easy to handle for the D3D Device... */
1763         DWORD color = lpbltfx->u5.dwFillColor;
1764         TRACE(" executing D3D Device override.\n");
1765         d3ddevice_clear(This->d3ddevice, 0, NULL, D3DCLEAR_TARGET, color, 0.0, 0x00000000);
1766         return DD_OK;
1767     }
1768     return DDERR_INVALIDPARAMS;
1769 }
1770
1771 HRESULT
1772 d3ddevice_bltfast(IDirectDrawSurfaceImpl *This, DWORD dstx,
1773                   DWORD dsty, LPDIRECTDRAWSURFACE7 src,
1774                   LPRECT rsrc, DWORD trans)
1775 {
1776      return DDERR_INVALIDPARAMS;
1777 }
1778
1779
1780 /* TODO for both these functions :
1781     - change / restore OpenGL parameters for pictures transfers in case they are ever modified
1782       by other OpenGL code in D3D
1783     - handle the case where no 'Begin / EndScene' was done between two locks
1784     - handle the rectangles in the unlock too
1785     - handle pitch correctly...
1786 */
1787 static void d3ddevice_lock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect, DWORD dwFlags)
1788 {
1789     /* First, check if we need to do anything */
1790     if ((This->lastlocktype & DDLOCK_WRITEONLY) == 0) {
1791         GLenum buffer_type;
1792         GLenum prev_read;
1793         RECT loc_rect;
1794
1795         ENTER_GL();
1796
1797         glGetIntegerv(GL_READ_BUFFER, &prev_read);
1798         glFlush();
1799
1800         WARN(" application does a lock on a 3D surface - expect slow downs.\n");
1801         if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
1802             /* Application wants to lock the front buffer */
1803             glReadBuffer(GL_FRONT);
1804         } else if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) == (DDSCAPS_BACKBUFFER)) {
1805             /* Application wants to lock the back buffer */
1806             glReadBuffer(GL_BACK);
1807         } else {
1808             WARN(" do not support 3D surface locking for this surface type - trying to use default buffer.\n");
1809         }
1810
1811         if (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 16) {
1812             buffer_type = GL_UNSIGNED_SHORT_5_6_5;
1813         } else {
1814             WARN(" unsupported pixel format.\n");
1815             LEAVE_GL();
1816             return;
1817         }
1818         if (pRect == NULL) {
1819             loc_rect.top = 0;
1820             loc_rect.left = 0;
1821             loc_rect.bottom = This->surface_desc.dwHeight;
1822             loc_rect.right = This->surface_desc.dwWidth;
1823         } else {
1824             loc_rect = *pRect;
1825         }
1826         glReadPixels(loc_rect.left, loc_rect.top, loc_rect.right, loc_rect.bottom,
1827                      GL_RGB, buffer_type, ((char *)This->surface_desc.lpSurface
1828                                            + loc_rect.top * This->surface_desc.u1.lPitch
1829                                            + loc_rect.left * GET_BPP(This->surface_desc)));
1830         glReadBuffer(prev_read);
1831         LEAVE_GL();
1832     }
1833 }
1834
1835 static void d3ddevice_unlock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect)
1836 {
1837     /* First, check if we need to do anything */
1838     if ((This->lastlocktype & DDLOCK_READONLY) == 0) {
1839         GLenum buffer_type;
1840         GLenum prev_draw;
1841
1842         ENTER_GL();
1843
1844         glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
1845
1846         WARN(" application does an unlock on a 3D surface - expect slow downs.\n");
1847         if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
1848             /* Application wants to lock the front buffer */
1849             glDrawBuffer(GL_FRONT);
1850         } else if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) == (DDSCAPS_BACKBUFFER)) {
1851             /* Application wants to lock the back buffer */
1852             glDrawBuffer(GL_BACK);
1853         } else {
1854             WARN(" do not support 3D surface unlocking for this surface type - trying to use default buffer.\n");
1855         }
1856
1857         if (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 16) {
1858             buffer_type = GL_UNSIGNED_SHORT_5_6_5;
1859         } else {
1860             WARN(" unsupported pixel format.\n");
1861             LEAVE_GL();
1862             return;
1863         }
1864         glRasterPos2f(0.0, 0.0);
1865         glDrawPixels(This->surface_desc.dwWidth, This->surface_desc.dwHeight,
1866                      GL_RGB, buffer_type, This->surface_desc.lpSurface);
1867         glDrawBuffer(prev_draw);
1868
1869         LEAVE_GL();
1870    }
1871 }
1872
1873 HRESULT
1874 d3ddevice_create(IDirect3DDeviceImpl **obj, IDirect3DImpl *d3d, IDirectDrawSurfaceImpl *surface)
1875 {
1876     IDirect3DDeviceImpl *object;
1877     IDirect3DDeviceGLImpl *gl_object;
1878     IDirectDrawSurfaceImpl *surf;
1879     HDC device_context;
1880     XVisualInfo *vis;
1881     int num;
1882     XVisualInfo template;
1883     GLenum buffer;
1884
1885     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDeviceGLImpl));
1886     if (object == NULL) return DDERR_OUTOFMEMORY;
1887
1888     gl_object = (IDirect3DDeviceGLImpl *) object;
1889
1890     object->ref = 1;
1891     object->d3d = d3d;
1892     object->surface = surface;
1893     object->set_context = set_context;
1894     object->clear = d3ddevice_clear;
1895
1896     TRACE(" creating OpenGL device for surface = %p, d3d = %p\n", surface, d3d);
1897
1898     device_context = GetDC(surface->ddraw_owner->window);
1899     gl_object->display = get_display(device_context);
1900     gl_object->drawable = get_drawable(device_context);
1901     ReleaseDC(surface->ddraw_owner->window,device_context);
1902
1903     ENTER_GL();
1904     template.visualid = (VisualID)GetPropA( GetDesktopWindow(), "__wine_x11_visual_id" );
1905     vis = XGetVisualInfo(gl_object->display, VisualIDMask, &template, &num);
1906     if (vis == NULL) {
1907         HeapFree(GetProcessHeap(), 0, object);
1908         ERR("No visual found !\n");
1909         LEAVE_GL();
1910         return DDERR_INVALIDPARAMS;
1911     } else {
1912         TRACE(" visual found\n");
1913     }
1914
1915     gl_object->gl_context = glXCreateContext(gl_object->display, vis,
1916                                              NULL, GL_TRUE);
1917
1918     if (gl_object->gl_context == NULL) {
1919         HeapFree(GetProcessHeap(), 0, object);
1920         ERR("Error in context creation !\n");
1921         LEAVE_GL();
1922         return DDERR_INVALIDPARAMS;
1923     } else {
1924         TRACE(" context created (%p)\n", gl_object->gl_context);
1925     }
1926
1927     /* Look for the front buffer and override its surface's Flip method (if in double buffering) */
1928     for (surf = surface; surf != NULL; surf = surf->surface_owner) {
1929         if ((surf->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) == (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) {
1930             surf->aux_ctx  = (LPVOID) gl_object->display;
1931             surf->aux_data = (LPVOID) gl_object->drawable;
1932             surf->aux_flip = opengl_flip;
1933             buffer =  GL_BACK;
1934             break;
1935         }
1936     }
1937     /* We are not doing any double buffering.. Then force OpenGL to draw on the front buffer */
1938     if (surf == NULL) {
1939         TRACE(" no double buffering : drawing on the front buffer\n");
1940         buffer = GL_FRONT;
1941     }
1942
1943     for (surf = surface; surf->prev_attached != NULL; surf = surf->prev_attached) ;
1944     for (; surf != NULL; surf = surf->next_attached) {
1945         if (((surf->surface_desc.ddsCaps.dwCaps & (DDSCAPS_3DDEVICE)) == (DDSCAPS_3DDEVICE)) &&
1946             ((surf->surface_desc.ddsCaps.dwCaps & (DDSCAPS_ZBUFFER)) != (DDSCAPS_ZBUFFER))) {
1947             /* Override the Lock / Unlock function for all these surfaces */
1948             surf->lock_update = d3ddevice_lock_update;
1949             surf->unlock_update = d3ddevice_unlock_update;
1950             /* And install also the blt / bltfast overrides */
1951             surf->aux_blt = d3ddevice_blt;
1952             surf->aux_bltfast = d3ddevice_bltfast;
1953         }
1954         surf->d3ddevice = object;
1955     }
1956
1957     gl_object->render_state.src = GL_ONE;
1958     gl_object->render_state.dst = GL_ZERO;
1959     gl_object->render_state.mag = GL_NEAREST;
1960     gl_object->render_state.min = GL_NEAREST;
1961     gl_object->render_state.alpha_ref = 0.0; /* No actual idea about the real default value... */
1962     gl_object->render_state.alpha_func = GL_ALWAYS; /* Here either but it seems logical */
1963     gl_object->render_state.alpha_blend_enable = FALSE;
1964     gl_object->render_state.fog_on = FALSE;
1965
1966     /* Allocate memory for the matrices */
1967     object->world_mat = (D3DMATRIX *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
1968     object->view_mat  = (D3DMATRIX *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
1969     object->proj_mat  = (D3DMATRIX *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
1970     memcpy(object->world_mat, id_mat, 16 * sizeof(float));
1971     memcpy(object->view_mat , id_mat, 16 * sizeof(float));
1972     memcpy(object->proj_mat , id_mat, 16 * sizeof(float));
1973
1974     /* Initialisation */
1975     TRACE(" setting current context\n");
1976     LEAVE_GL();
1977     object->set_context(object);
1978     ENTER_GL();
1979     TRACE(" current context set\n");
1980     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1981     glClearColor(0.0, 0.0, 0.0, 0.0);
1982     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
1983     glDrawBuffer(buffer);
1984     glReadBuffer(buffer);
1985     /* glDisable(GL_DEPTH_TEST); Need here to check for the presence of a ZBuffer and to reenable it when the ZBuffer is attached */
1986     LEAVE_GL();
1987
1988     /* fill_device_capabilities(d3d->ddraw); */
1989
1990     ICOM_INIT_INTERFACE(object, IDirect3DDevice,  VTABLE_IDirect3DDevice);
1991     ICOM_INIT_INTERFACE(object, IDirect3DDevice2, VTABLE_IDirect3DDevice2);
1992     ICOM_INIT_INTERFACE(object, IDirect3DDevice3, VTABLE_IDirect3DDevice3);
1993     ICOM_INIT_INTERFACE(object, IDirect3DDevice7, VTABLE_IDirect3DDevice7);
1994
1995     *obj = object;
1996
1997     TRACE(" creating implementation at %p.\n", *obj);
1998
1999     /* And finally warn D3D that this device is now present */
2000     object->d3d->added_device(object->d3d, object);
2001
2002     return DD_OK;
2003 }