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

   1 /*
   2  * Direct3D Device
   3  *
   4  * Copyright (c) 1998-2004 Lionel Ulmer
   5  * Copyright (c) 2002-2005 Christian Costa
   6  *
   7  * This file contains the MESA implementation of all the D3D devices that
   8  * Wine supports.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <math.h>
  31
  32 #define NONAMELESSUNION
  33 #define NONAMELESSSTRUCT
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winerror.h"
  38 #include "objbase.h"
  39 #include "wingdi.h"
  40 #include "ddraw.h"
  41 #include "d3d.h"
  42 #include "wine/debug.h"
  43 #include "wine/library.h"
  44
  45 #include "d3d_private.h"
  46 #include "opengl_private.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  49 WINE_DECLARE_DEBUG_CHANNEL(ddraw_geom);
  50
  51 /* x11drv GDI escapes */
  52 #define X11DRV_ESCAPE 6789
  53 enum x11drv_escape_codes
  54 {
  55     X11DRV_GET_DISPLAY,   /* get X11 display for a DC */
  56     X11DRV_GET_DRAWABLE,  /* get current drawable for a DC */
  57     X11DRV_GET_FONT,      /* get current X font for a DC */
  58 };
  59
  60 /* They are non-static as they are used by Direct3D in the creation function */
  61 const GUID IID_D3DDEVICE_OpenGL = {
  62   0x31416d44,
  63   0x86ae,
  64   0x11d2,
  65   { 0x82,0x2d,0xa8,0xd5,0x31,0x87,0xca,0xfa }
  66 };
  67
  68 const float id_mat[16] = {
  69     1.0, 0.0, 0.0, 0.0,
  70     0.0, 1.0, 0.0, 0.0,
  71     0.0, 0.0, 1.0, 0.0,
  72     0.0, 0.0, 0.0, 1.0
  73 };
  74
  75 /* This is filled at DLL loading time */
  76 static D3DDEVICEDESC7 opengl_device_caps;
  77 GL_EXTENSIONS_LIST GL_extensions;
  78
  79 static void draw_primitive_strided(IDirect3DDeviceImpl *This,
  80                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
  81                                    DWORD d3dvtVertexType,
  82                                    LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
  83                                    DWORD dwVertexCount,
  84                                    LPWORD dwIndices,
  85                                    DWORD dwIndexCount,
  86                                    DWORD dwFlags) ;
  87
  88 static DWORD draw_primitive_handle_textures(IDirect3DDeviceImpl *This);
  89
  90 /* retrieve the X display to use on a given DC */
  91 inline static Display *get_display( HDC hdc )
  92 {
  93     Display *display;
  94     enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
  95
  96     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
  97                     sizeof(display), (LPSTR)&display )) display = NULL;
  98
  99     return display;
 100 }
 101
 102 #define UNLOCK_TEX_SIZE 256
 103
 104 #define DEPTH_RANGE_BIT (0x00000001 << 0)
 105 #define VIEWPORT_BIT    (0x00000001 << 1)
 106
 107 static DWORD d3ddevice_set_state_for_flush(IDirect3DDeviceImpl *d3d_dev, LPCRECT pRect, BOOLEAN use_alpha, BOOLEAN *initial) {
 108     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
 109     DWORD opt_bitmap = 0x00000000;
 110
 111     if ((gl_d3d_dev->current_bound_texture[1] != NULL) &&
 112         ((d3d_dev->state_block.texture_stage_state[1][D3DTSS_COLOROP - 1] != D3DTOP_DISABLE))) {
 113         if (gl_d3d_dev->current_active_tex_unit != GL_TEXTURE1_WINE) {
 114             GL_extensions.glActiveTexture(GL_TEXTURE1_WINE);
 115             gl_d3d_dev->current_active_tex_unit = GL_TEXTURE1_WINE;
 116         }
 117         /* Disable multi-texturing for level 1 to disable all others */
 118         glDisable(GL_TEXTURE_2D);
 119     }
 120     if (gl_d3d_dev->current_active_tex_unit != GL_TEXTURE0_WINE) {
 121         GL_extensions.glActiveTexture(GL_TEXTURE0_WINE);
 122         gl_d3d_dev->current_active_tex_unit = GL_TEXTURE0_WINE;
 123     }
 124     if ((gl_d3d_dev->current_bound_texture[0] == NULL) ||
 125         (d3d_dev->state_block.texture_stage_state[0][D3DTSS_COLOROP - 1] == D3DTOP_DISABLE))
 126         glEnable(GL_TEXTURE_2D);
 127     if (gl_d3d_dev->unlock_tex == 0) {
 128         glGenTextures(1, &gl_d3d_dev->unlock_tex);
 129         glBindTexture(GL_TEXTURE_2D, gl_d3d_dev->unlock_tex);
 130         *initial = TRUE;
 131         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 132         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 133         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 134         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 135     } else {
 136         glBindTexture(GL_TEXTURE_2D, gl_d3d_dev->unlock_tex);
 137         *initial = FALSE;
 138     }
 139     if (d3d_dev->tex_mat_is_identity[0] == FALSE) {
 140         glMatrixMode(GL_TEXTURE);
 141         glLoadIdentity();
 142     }
 143
 144     if (gl_d3d_dev->transform_state != GL_TRANSFORM_ORTHO) {
 145         gl_d3d_dev->transform_state = GL_TRANSFORM_ORTHO;
 146         d3ddevice_set_ortho(d3d_dev);
 147     }
 148
 149     if (gl_d3d_dev->depth_test != FALSE) glDisable(GL_DEPTH_TEST);
 150     glEnable(GL_SCISSOR_TEST);
 151     if ((d3d_dev->active_viewport.dvMinZ != 0.0) ||
 152         (d3d_dev->active_viewport.dvMaxZ != 1.0)) {
 153         glDepthRange(0.0, 1.0);
 154         opt_bitmap |= DEPTH_RANGE_BIT;
 155     }
 156     if ((d3d_dev->active_viewport.dwX != 0) ||
 157         (d3d_dev->active_viewport.dwY != 0) ||
 158         (d3d_dev->active_viewport.dwWidth != d3d_dev->surface->surface_desc.dwWidth) ||
 159         (d3d_dev->active_viewport.dwHeight != d3d_dev->surface->surface_desc.dwHeight)) {
 160         glViewport(0, 0, d3d_dev->surface->surface_desc.dwWidth, d3d_dev->surface->surface_desc.dwHeight);
 161         opt_bitmap |= VIEWPORT_BIT;
 162     }
 163     glScissor(pRect->left, d3d_dev->surface->surface_desc.dwHeight - pRect->bottom,
 164               pRect->right - pRect->left, pRect->bottom - pRect->top);
 165     if (gl_d3d_dev->lighting != FALSE) glDisable(GL_LIGHTING);
 166     if (gl_d3d_dev->cull_face != FALSE) glDisable(GL_CULL_FACE);
 167     if (use_alpha) {
 168         if (gl_d3d_dev->alpha_test == FALSE) glEnable(GL_ALPHA_TEST);
 169         if ((gl_d3d_dev->current_alpha_test_func != GL_NOTEQUAL) || (gl_d3d_dev->current_alpha_test_ref != 0.0))
 170             glAlphaFunc(GL_NOTEQUAL, 0.0);
 171     } else {
 172         if (gl_d3d_dev->alpha_test != FALSE) glDisable(GL_ALPHA_TEST);
 173     }
 174     if (gl_d3d_dev->stencil_test != FALSE) glDisable(GL_STENCIL_TEST);
 175     if (gl_d3d_dev->blending != FALSE) glDisable(GL_BLEND);
 176     if (gl_d3d_dev->fogging != FALSE) glDisable(GL_FOG);
 177     if (gl_d3d_dev->current_tex_env != GL_REPLACE)
 178         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 179
 180     return opt_bitmap;
 181 }
 182
 183 static void d3ddevice_restore_state_after_flush(IDirect3DDeviceImpl *d3d_dev, DWORD opt_bitmap, BOOLEAN use_alpha) {
 184     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
 185
 186     /* And restore all the various states modified by this code */
 187     if (gl_d3d_dev->depth_test != 0) glEnable(GL_DEPTH_TEST);
 188     if (gl_d3d_dev->lighting != 0) glEnable(GL_LIGHTING);
 189     if ((gl_d3d_dev->alpha_test != 0) && (use_alpha == 0))
 190         glEnable(GL_ALPHA_TEST);
 191     else if ((gl_d3d_dev->alpha_test == 0) && (use_alpha != 0))
 192         glDisable(GL_ALPHA_TEST);
 193     if (use_alpha) {
 194         if ((gl_d3d_dev->current_alpha_test_func != GL_NOTEQUAL) || (gl_d3d_dev->current_alpha_test_ref != 0.0))
 195             glAlphaFunc(gl_d3d_dev->current_alpha_test_func, gl_d3d_dev->current_alpha_test_ref);
 196     }
 197     if (gl_d3d_dev->stencil_test != 0) glEnable(GL_STENCIL_TEST);
 198     if (gl_d3d_dev->cull_face != 0) glEnable(GL_CULL_FACE);
 199     if (gl_d3d_dev->blending != 0) glEnable(GL_BLEND);
 200     if (gl_d3d_dev->fogging != 0) glEnable(GL_FOG);
 201     glDisable(GL_SCISSOR_TEST);
 202     if (opt_bitmap & DEPTH_RANGE_BIT) {
 203         glDepthRange(d3d_dev->active_viewport.dvMinZ, d3d_dev->active_viewport.dvMaxZ);
 204     }
 205     if (opt_bitmap & VIEWPORT_BIT) {
 206         glViewport(d3d_dev->active_viewport.dwX,
 207                    d3d_dev->surface->surface_desc.dwHeight - (d3d_dev->active_viewport.dwHeight + d3d_dev->active_viewport.dwY),
 208                    d3d_dev->active_viewport.dwWidth, d3d_dev->active_viewport.dwHeight);
 209     }
 210     if (d3d_dev->tex_mat_is_identity[0] == FALSE) {
 211         d3d_dev->matrices_updated(d3d_dev, TEXMAT0_CHANGED);
 212     }
 213
 214     if (gl_d3d_dev->current_active_tex_unit != GL_TEXTURE0_WINE) {
 215         GL_extensions.glActiveTexture(GL_TEXTURE0_WINE);
 216         gl_d3d_dev->current_active_tex_unit = GL_TEXTURE0_WINE;
 217     }
 218     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, gl_d3d_dev->current_tex_env);
 219     /* Note that here we could directly re-bind the previous texture... But it would in some case be a spurious
 220        bind if ever the game changes the texture just after.
 221
 222        So choose 0x00000001 to postpone the binding to the next time we draw something on screen. */
 223     gl_d3d_dev->current_bound_texture[0] = (IDirectDrawSurfaceImpl *) 0x00000001;
 224     if (d3d_dev->state_block.texture_stage_state[0][D3DTSS_COLOROP - 1] == D3DTOP_DISABLE) glDisable(GL_TEXTURE_2D);
 225
 226     /* And re-enabled if needed texture level 1 */
 227     if ((gl_d3d_dev->current_bound_texture[1] != NULL) &&
 228         (d3d_dev->state_block.texture_stage_state[1][D3DTSS_COLOROP - 1] != D3DTOP_DISABLE)) {
 229         if (gl_d3d_dev->current_active_tex_unit != GL_TEXTURE1_WINE) {
 230             GL_extensions.glActiveTexture(GL_TEXTURE1_WINE);
 231             gl_d3d_dev->current_active_tex_unit = GL_TEXTURE1_WINE;
 232         }
 233         glEnable(GL_TEXTURE_2D);
 234     }
 235 }
 236
 237 /* retrieve the X drawable to use on a given DC */
 238 inline static Drawable get_drawable( HDC hdc )
 239 {
 240     Drawable drawable;
 241     enum x11drv_escape_codes escape = X11DRV_GET_DRAWABLE;
 242
 243     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
 244                     sizeof(drawable), (LPSTR)&drawable )) drawable = 0;
 245
 246     return drawable;
 247 }
 248
 249 static BOOL opengl_flip( LPVOID dev, LPVOID drawable)
 250 {
 251     IDirect3DDeviceImpl *d3d_dev = (IDirect3DDeviceImpl *) dev;
 252     IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) dev;
 253
 254     TRACE("(%p, %ld)\n", gl_d3d_dev->display,(Drawable)drawable);
 255     ENTER_GL();
 256     if (gl_d3d_dev->state[WINE_GL_BUFFER_BACK] == SURFACE_MEMORY_DIRTY) {
 257         d3d_dev->flush_to_framebuffer(d3d_dev, &(gl_d3d_dev->lock_rect[WINE_GL_BUFFER_BACK]), gl_d3d_dev->lock_surf[WINE_GL_BUFFER_BACK]);
 258     }
 259     gl_d3d_dev->state[WINE_GL_BUFFER_BACK] = SURFACE_GL;
 260     gl_d3d_dev->state[WINE_GL_BUFFER_FRONT] = SURFACE_GL;
 261     glXSwapBuffers(gl_d3d_dev->display, (Drawable)drawable);
 262     LEAVE_GL();
 263
 264     return TRUE;
 265 }
 266
 267
 268 /*******************************************************************************
 269  *                              OpenGL static functions
 270  */
 271 static void set_context(IDirect3DDeviceImpl* This)
 272 {
 273     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
 274
 275     TRACE("glxMakeCurrent %p, %ld, %p\n",glThis->display,glThis->drawable, glThis->gl_context);
 276     ENTER_GL();
 277     if (glXMakeCurrent(glThis->display, glThis->drawable, glThis->gl_context) == False) {
 278         ERR("Error in setting current context (context %p drawable %ld)!\n",
 279             glThis->gl_context, glThis->drawable);
 280     }
 281     LEAVE_GL();
 282 }
 283
 284 static void fill_opengl_caps(D3DDEVICEDESC *d1)
 285 {
 286     d1->dwSize  = sizeof(*d1);
 287     d1->dwFlags = D3DDD_COLORMODEL | D3DDD_DEVCAPS | D3DDD_TRANSFORMCAPS | D3DDD_BCLIPPING | D3DDD_LIGHTINGCAPS |
 288         D3DDD_LINECAPS | D3DDD_TRICAPS | D3DDD_DEVICERENDERBITDEPTH | D3DDD_DEVICEZBUFFERBITDEPTH |
 289         D3DDD_MAXBUFFERSIZE | D3DDD_MAXVERTEXCOUNT;
 290     d1->dcmColorModel = D3DCOLOR_RGB;
 291     d1->dwDevCaps = opengl_device_caps.dwDevCaps;
 292     d1->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
 293     d1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
 294     d1->bClipping = TRUE;
 295     d1->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
 296     d1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL | D3DLIGHTCAPS_PARALLELPOINT | D3DLIGHTCAPS_POINT | D3DLIGHTCAPS_SPOT;
 297     d1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
 298     d1->dlcLightingCaps.dwNumLights = opengl_device_caps.dwMaxActiveLights;
 299     d1->dpcLineCaps = opengl_device_caps.dpcLineCaps;
 300     d1->dpcTriCaps = opengl_device_caps.dpcTriCaps;
 301     d1->dwDeviceRenderBitDepth  = opengl_device_caps.dwDeviceRenderBitDepth;
 302     d1->dwDeviceZBufferBitDepth = opengl_device_caps.dwDeviceZBufferBitDepth;
 303     d1->dwMaxBufferSize = 0;
 304     d1->dwMaxVertexCount = 65536;
 305     d1->dwMinTextureWidth  = opengl_device_caps.dwMinTextureWidth;
 306     d1->dwMinTextureHeight = opengl_device_caps.dwMinTextureHeight;
 307     d1->dwMaxTextureWidth  = opengl_device_caps.dwMaxTextureWidth;
 308     d1->dwMaxTextureHeight = opengl_device_caps.dwMaxTextureHeight;
 309     d1->dwMinStippleWidth  = 1;
 310     d1->dwMinStippleHeight = 1;
 311     d1->dwMaxStippleWidth  = 32;
 312     d1->dwMaxStippleHeight = 32;
 313     d1->dwMaxTextureRepeat = opengl_device_caps.dwMaxTextureRepeat;
 314     d1->dwMaxTextureAspectRatio = opengl_device_caps.dwMaxTextureAspectRatio;
 315     d1->dwMaxAnisotropy = opengl_device_caps.dwMaxAnisotropy;
 316     d1->dvGuardBandLeft = opengl_device_caps.dvGuardBandLeft;
 317     d1->dvGuardBandRight = opengl_device_caps.dvGuardBandRight;
 318     d1->dvGuardBandTop = opengl_device_caps.dvGuardBandTop;
 319     d1->dvGuardBandBottom = opengl_device_caps.dvGuardBandBottom;
 320     d1->dvExtentsAdjust = opengl_device_caps.dvExtentsAdjust;
 321     d1->dwStencilCaps = opengl_device_caps.dwStencilCaps;
 322     d1->dwFVFCaps = opengl_device_caps.dwFVFCaps;
 323     d1->dwTextureOpCaps = opengl_device_caps.dwTextureOpCaps;
 324     d1->wMaxTextureBlendStages = opengl_device_caps.wMaxTextureBlendStages;
 325     d1->wMaxSimultaneousTextures = opengl_device_caps.wMaxSimultaneousTextures;
 326 }
 327
 328 static void fill_opengl_caps_7(D3DDEVICEDESC7 *d)
 329 {
 330     *d = opengl_device_caps;
 331 }
 332
 333 HRESULT d3ddevice_enumerate(LPD3DENUMDEVICESCALLBACK cb, LPVOID context, DWORD version)
 334 {
 335     D3DDEVICEDESC dref, d1, d2;
 336     HRESULT ret_value;
 337
 338     /* Some games (Motoracer 2 demo) have the bad idea to modify the device name string.
 339        Let's put the string in a sufficiently sized array in writable memory. */
 340     char device_name[50];
 341     strcpy(device_name,"direct3d");
 342
 343     fill_opengl_caps(&dref);
 344
 345     if (version > 1) {
 346         /* It seems that enumerating the reference IID on Direct3D 1 games (AvP / Motoracer2) breaks them */
 347         char interface_name[] = "WINE Reference Direct3DX using OpenGL";
 348         TRACE(" enumerating OpenGL D3DDevice interface using reference IID (IID %s).\n", debugstr_guid(&IID_IDirect3DRefDevice));
 349         d1 = dref;
 350         d2 = dref;
 351         ret_value = cb((LPIID) &IID_IDirect3DRefDevice, interface_name, device_name, &d1, &d2, context);
 352         if (ret_value != D3DENUMRET_OK)
 353             return ret_value;
 354     }
 355
 356     {
 357         char interface_name[] = "WINE Direct3DX using OpenGL";
 358         TRACE(" enumerating OpenGL D3DDevice interface (IID %s).\n", debugstr_guid(&IID_D3DDEVICE_OpenGL));
 359         d1 = dref;
 360         d2 = dref;
 361         ret_value = cb((LPIID) &IID_D3DDEVICE_OpenGL, interface_name, device_name, &d1, &d2, context);
 362         if (ret_value != D3DENUMRET_OK)
 363             return ret_value;
 364     }
 365
 366     return D3DENUMRET_OK;
 367 }
 368
 369 HRESULT d3ddevice_enumerate7(LPD3DENUMDEVICESCALLBACK7 cb, LPVOID context)
 370 {
 371     D3DDEVICEDESC7 ddesc;
 372     char interface_name[] = "WINE Direct3D7 using OpenGL";
 373     char device_name[] = "Wine D3D7 device";
 374
 375     fill_opengl_caps_7(&ddesc);
 376
 377     TRACE(" enumerating OpenGL D3DDevice7 interface.\n");
 378
 379     return cb(interface_name, device_name, &ddesc, context);
 380 }
 381
 382 static ULONG WINAPI
 383 GL_IDirect3DDeviceImpl_7_3T_2T_1T_Release(LPDIRECT3DDEVICE7 iface)
 384 {
 385     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 386     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
 387     ULONG ref = InterlockedDecrement(&This->ref);
 388
 389     TRACE("(%p/%p)->() decrementing from %lu.\n", This, iface, ref + 1);
 390
 391     if (!ref) {
 392         int i;
 393         IDirectDrawSurfaceImpl *surface = This->surface, *surf;
 394
 395         /* Release texture associated with the device */
 396         for (i = 0; i < MAX_TEXTURES; i++) {
 397             if (This->current_texture[i] != NULL)
 398                 IDirectDrawSurface7_Release(ICOM_INTERFACE(This->current_texture[i], IDirectDrawSurface7));
 399             HeapFree(GetProcessHeap(), 0, This->tex_mat[i]);
 400         }
 401
 402         /* Look for the front buffer and override its surface's Flip method (if in double buffering) */
 403         for (surf = surface; surf != NULL; surf = surf->surface_owner) {
 404             if ((surf->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) == (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) {
 405                 surf->aux_ctx  = NULL;
 406                 surf->aux_data = NULL;
 407                 surf->aux_flip = NULL;
 408                 break;
 409             }
 410         }
 411         for (surf = surface; surf != NULL; surf = surf->surface_owner) {
 412             IDirectDrawSurfaceImpl *surf2;
 413             for (surf2 = surf; surf2->prev_attached != NULL; surf2 = surf2->prev_attached) ;
 414             for (; surf2 != NULL; surf2 = surf2->next_attached) {
 415                 if (((surf2->surface_desc.ddsCaps.dwCaps & (DDSCAPS_3DDEVICE)) == (DDSCAPS_3DDEVICE)) &&
 416                     ((surf2->surface_desc.ddsCaps.dwCaps & (DDSCAPS_ZBUFFER)) != (DDSCAPS_ZBUFFER))) {
 417                     /* Override the Lock / Unlock function for all these surfaces */
 418                     surf2->lock_update = surf2->lock_update_prev;
 419                     surf2->unlock_update = surf2->unlock_update_prev;
 420                     /* And install also the blt / bltfast overrides */
 421                     surf2->aux_blt = NULL;
 422                     surf2->aux_bltfast = NULL;
 423                 }
 424                 surf2->d3ddevice = NULL;
 425             }
 426         }
 427
 428         /* And warn the D3D object that this device is no longer active... */
 429         This->d3d->d3d_removed_device(This->d3d, This);
 430
 431         /* Free light arrays */
 432         HeapFree(GetProcessHeap(), 0, This->light_parameters);
 433         HeapFree(GetProcessHeap(), 0, This->active_lights);
 434
 435         HeapFree(GetProcessHeap(), 0, This->world_mat);
 436         HeapFree(GetProcessHeap(), 0, This->view_mat);
 437         HeapFree(GetProcessHeap(), 0, This->proj_mat);
 438
 439         HeapFree(GetProcessHeap(), 0, glThis->surface_ptr);
 440
 441         DeleteCriticalSection(&(This->crit));
 442
 443         ENTER_GL();
 444         if (glThis->unlock_tex)
 445             glDeleteTextures(1, &(glThis->unlock_tex));
 446         glXDestroyContext(glThis->display, glThis->gl_context);
 447         LEAVE_GL();
 448         HeapFree(GetProcessHeap(), 0, This->clipping_planes);
 449         HeapFree(GetProcessHeap(), 0, This->vertex_buffer);
 450
 451         HeapFree(GetProcessHeap(), 0, This);
 452         return 0;
 453     }
 454     return ref;
 455 }
 456
 457 HRESULT WINAPI
 458 GL_IDirect3DDeviceImpl_3_2T_1T_GetCaps(LPDIRECT3DDEVICE3 iface,
 459                                        LPD3DDEVICEDESC lpD3DHWDevDesc,
 460                                        LPD3DDEVICEDESC lpD3DHELDevDesc)
 461 {
 462     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 463     D3DDEVICEDESC desc;
 464     DWORD dwSize;
 465
 466     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DHWDevDesc, lpD3DHELDevDesc);
 467
 468     fill_opengl_caps(&desc);
 469     dwSize = lpD3DHWDevDesc->dwSize;
 470     memset(lpD3DHWDevDesc, 0, dwSize);
 471     memcpy(lpD3DHWDevDesc, &desc, (dwSize <= desc.dwSize ? dwSize : desc.dwSize));
 472
 473     dwSize = lpD3DHELDevDesc->dwSize;
 474     memset(lpD3DHELDevDesc, 0, dwSize);
 475     memcpy(lpD3DHELDevDesc, &desc, (dwSize <= desc.dwSize ? dwSize : desc.dwSize));
 476
 477     TRACE(" returning caps : (no dump function yet)\n");
 478
 479     return DD_OK;
 480 }
 481
 482 static HRESULT enum_texture_format_OpenGL(LPD3DENUMTEXTUREFORMATSCALLBACK cb_1,
 483                                           LPD3DENUMPIXELFORMATSCALLBACK cb_2,
 484                                           LPVOID context, int version)
 485 {
 486     DDSURFACEDESC sdesc;
 487     LPDDPIXELFORMAT pformat;
 488
 489     /* Do the texture enumeration */
 490     sdesc.dwSize = sizeof(DDSURFACEDESC);
 491     sdesc.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
 492     sdesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
 493     pformat = &(sdesc.ddpfPixelFormat);
 494     pformat->dwSize = sizeof(DDPIXELFORMAT);
 495     pformat->dwFourCC = 0;
 496
 497     TRACE("Enumerating GL_RGBA unpacked (32)\n");
 498     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 499     pformat->u1.dwRGBBitCount = 32;
 500     pformat->u2.dwRBitMask =        0x00FF0000;
 501     pformat->u3.dwGBitMask =        0x0000FF00;
 502     pformat->u4.dwBBitMask =        0x000000FF;
 503     pformat->u5.dwRGBAlphaBitMask = 0xFF000000;
 504     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 505     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 506
 507     TRACE("Enumerating GL_RGB unpacked (32)\n");
 508     pformat->dwFlags = DDPF_RGB;
 509     pformat->u1.dwRGBBitCount = 32;
 510     pformat->u2.dwRBitMask =        0x00FF0000;
 511     pformat->u3.dwGBitMask =        0x0000FF00;
 512     pformat->u4.dwBBitMask =        0x000000FF;
 513     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 514     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 515     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 516
 517     TRACE("Enumerating GL_RGB unpacked (24)\n");
 518     pformat->dwFlags = DDPF_RGB;
 519     pformat->u1.dwRGBBitCount = 24;
 520     pformat->u2.dwRBitMask = 0x00FF0000;
 521     pformat->u3.dwGBitMask = 0x0000FF00;
 522     pformat->u4.dwBBitMask = 0x000000FF;
 523     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 524     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 525     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 526
 527     /* Note : even if this is an 'emulated' texture format, it needs to be first
 528               as some dumb applications seem to rely on that. */
 529     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_1_5_5_5 (ARGB) (16)\n");
 530     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 531     pformat->u1.dwRGBBitCount = 16;
 532     pformat->u2.dwRBitMask =        0x00007C00;
 533     pformat->u3.dwGBitMask =        0x000003E0;
 534     pformat->u4.dwBBitMask =        0x0000001F;
 535     pformat->u5.dwRGBAlphaBitMask = 0x00008000;
 536     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 537     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 538
 539     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_4_4_4_4 (ARGB) (16)\n");
 540     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 541     pformat->u1.dwRGBBitCount = 16;
 542     pformat->u2.dwRBitMask =        0x00000F00;
 543     pformat->u3.dwGBitMask =        0x000000F0;
 544     pformat->u4.dwBBitMask =        0x0000000F;
 545     pformat->u5.dwRGBAlphaBitMask = 0x0000F000;
 546     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 547     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 548
 549     TRACE("Enumerating GL_RGB packed GL_UNSIGNED_SHORT_5_6_5 (16)\n");
 550     pformat->dwFlags = DDPF_RGB;
 551     pformat->u1.dwRGBBitCount = 16;
 552     pformat->u2.dwRBitMask = 0x0000F800;
 553     pformat->u3.dwGBitMask = 0x000007E0;
 554     pformat->u4.dwBBitMask = 0x0000001F;
 555     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 556     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 557     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 558
 559     TRACE("Enumerating GL_RGB packed GL_UNSIGNED_SHORT_5_5_5 (16)\n");
 560     pformat->dwFlags = DDPF_RGB;
 561     pformat->u1.dwRGBBitCount = 16;
 562     pformat->u2.dwRBitMask = 0x00007C00;
 563     pformat->u3.dwGBitMask = 0x000003E0;
 564     pformat->u4.dwBBitMask = 0x0000001F;
 565     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 566     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 567     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 568
 569 #if 0
 570     /* This is a compromise : some games choose the first 16 bit texture format with alpha they
 571        find enumerated, others the last one. And both want to have the ARGB one.
 572
 573        So basically, forget our OpenGL roots and do not even enumerate our RGBA ones.
 574     */
 575     /* See argument about the RGBA format for 'packed' texture formats */
 576     TRACE("Enumerating GL_RGBA unpacked (32)\n");
 577     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 578     pformat->u1.dwRGBBitCount = 32;
 579     pformat->u2.dwRBitMask =        0xFF000000;
 580     pformat->u3.dwGBitMask =        0x00FF0000;
 581     pformat->u4.dwBBitMask =        0x0000FF00;
 582     pformat->u5.dwRGBAlphaBitMask = 0x000000FF;
 583     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 584     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 585
 586     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_4_4_4_4 (16)\n");
 587     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 588     pformat->u1.dwRGBBitCount = 16;
 589     pformat->u2.dwRBitMask =        0x0000F000;
 590     pformat->u3.dwGBitMask =        0x00000F00;
 591     pformat->u4.dwBBitMask =        0x000000F0;
 592     pformat->u5.dwRGBAlphaBitMask = 0x0000000F;
 593     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 594     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 595
 596     TRACE("Enumerating GL_RGBA packed GL_UNSIGNED_SHORT_5_5_5_1 (16)\n");
 597     pformat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
 598     pformat->u1.dwRGBBitCount = 16;
 599     pformat->u2.dwRBitMask =        0x0000F800;
 600     pformat->u3.dwGBitMask =        0x000007C0;
 601     pformat->u4.dwBBitMask =        0x0000003E;
 602     pformat->u5.dwRGBAlphaBitMask = 0x00000001;
 603     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 604     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 605 #endif
 606
 607     TRACE("Enumerating GL_RGB packed GL_UNSIGNED_BYTE_3_3_2 (8)\n");
 608     pformat->dwFlags = DDPF_RGB;
 609     pformat->u1.dwRGBBitCount = 8;
 610     pformat->u2.dwRBitMask =        0x000000E0;
 611     pformat->u3.dwGBitMask =        0x0000001C;
 612     pformat->u4.dwBBitMask =        0x00000003;
 613     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 614     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 615     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 616
 617     TRACE("Enumerating Paletted (8)\n");
 618     pformat->dwFlags = DDPF_PALETTEINDEXED8;
 619     pformat->u1.dwRGBBitCount = 8;
 620     pformat->u2.dwRBitMask =        0x00000000;
 621     pformat->u3.dwGBitMask =        0x00000000;
 622     pformat->u4.dwBBitMask =        0x00000000;
 623     pformat->u5.dwRGBAlphaBitMask = 0x00000000;
 624     if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 625     if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 626
 627     /* DXT textures only exist for devices created from IDirect3D3 and above */
 628     if ((version >= 3) && GL_extensions.s3tc_compressed_texture) {
 629         TRACE("Enumerating DXT1\n");
 630         pformat->dwFlags = DDPF_FOURCC;
 631         pformat->dwFourCC = MAKE_FOURCC('D','X','T','1');
 632         if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 633         if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 634
 635         TRACE("Enumerating DXT3\n");
 636         pformat->dwFlags = DDPF_FOURCC;
 637         pformat->dwFourCC = MAKE_FOURCC('D','X','T','3');
 638         if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 639         if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 640
 641         TRACE("Enumerating DXT5\n");
 642         pformat->dwFlags = DDPF_FOURCC;
 643         pformat->dwFourCC = MAKE_FOURCC('D','X','T','5');
 644         if (cb_1) if (cb_1(&sdesc , context) == 0) return DD_OK;
 645         if (cb_2) if (cb_2(pformat, context) == 0) return DD_OK;
 646     }
 647
 648     TRACE("End of enumeration\n");
 649     return DD_OK;
 650 }
 651
 652
 653 HRESULT
 654 d3ddevice_find(IDirectDrawImpl *d3d,
 655                LPD3DFINDDEVICESEARCH lpD3DDFS,
 656                LPD3DFINDDEVICERESULT lplpD3DDevice)
 657 {
 658     D3DDEVICEDESC desc;
 659
 660     if ((lpD3DDFS->dwFlags & D3DFDS_COLORMODEL) &&
 661         (lpD3DDFS->dcmColorModel != D3DCOLOR_RGB)) {
 662         TRACE(" trying to request a non-RGB D3D color model. Not supported.\n");
 663         return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
 664     }
 665     if (lpD3DDFS->dwFlags & D3DFDS_GUID) {
 666         TRACE(" trying to match guid %s.\n", debugstr_guid(&(lpD3DDFS->guid)));
 667         if ((IsEqualGUID(&IID_D3DDEVICE_OpenGL, &(lpD3DDFS->guid)) == 0) &&
 668             (IsEqualGUID(&IID_IDirect3DHALDevice, &(lpD3DDFS->guid)) == 0) &&
 669             (IsEqualGUID(&IID_IDirect3DRefDevice, &(lpD3DDFS->guid)) == 0)) {
 670             TRACE(" no match for this GUID.\n");
 671             return DDERR_INVALIDPARAMS;
 672         }
 673     }
 674
 675     /* Now return our own GUID */
 676     lplpD3DDevice->guid = IID_D3DDEVICE_OpenGL;
 677     fill_opengl_caps(&desc);
 678     lplpD3DDevice->ddHwDesc = desc;
 679     lplpD3DDevice->ddSwDesc = desc;
 680
 681     TRACE(" returning Wine's OpenGL device with (undumped) capabilities\n");
 682
 683     return D3D_OK;
 684 }
 685
 686 HRESULT WINAPI
 687 GL_IDirect3DDeviceImpl_2_1T_EnumTextureFormats(LPDIRECT3DDEVICE2 iface,
 688                                                LPD3DENUMTEXTUREFORMATSCALLBACK lpD3DEnumTextureProc,
 689                                                LPVOID lpArg)
 690 {
 691     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 692     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DEnumTextureProc, lpArg);
 693     return enum_texture_format_OpenGL(lpD3DEnumTextureProc, NULL, lpArg, This->version);
 694 }
 695
 696 static HRESULT WINAPI
 697 GL_IDirect3DDeviceImpl_7_3T_EnumTextureFormats(LPDIRECT3DDEVICE7 iface,
 698                                                LPD3DENUMPIXELFORMATSCALLBACK lpD3DEnumPixelProc,
 699                                                LPVOID lpArg)
 700 {
 701     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 702     TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpD3DEnumPixelProc, lpArg);
 703     return enum_texture_format_OpenGL(NULL, lpD3DEnumPixelProc, lpArg, This->version);
 704 }
 705
 706 static HRESULT WINAPI
 707 GL_IDirect3DDeviceImpl_7_3T_2T_SetRenderState(LPDIRECT3DDEVICE7 iface,
 708                                               D3DRENDERSTATETYPE dwRenderStateType,
 709                                               DWORD dwRenderState)
 710 {
 711     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 712     TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwRenderStateType, dwRenderState);
 713
 714     /* Call the render state functions */
 715     store_render_state(This, dwRenderStateType, dwRenderState, &This->state_block);
 716     set_render_state(This, dwRenderStateType, &This->state_block);
 717
 718     return DD_OK;
 719 }
 720
 721 static HRESULT WINAPI
 722 GL_IDirect3DDeviceImpl_7_3T_2T_GetRenderState(LPDIRECT3DDEVICE7 iface,
 723                                               D3DRENDERSTATETYPE dwRenderStateType,
 724                                               LPDWORD lpdwRenderState)
 725 {
 726     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 727     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dwRenderStateType, lpdwRenderState);
 728
 729     /* Call the render state functions */
 730     get_render_state(This, dwRenderStateType, lpdwRenderState, &This->state_block);
 731
 732     TRACE(" - asked for rendering state : %s, returning value %08lx.\n", _get_renderstate(dwRenderStateType), *lpdwRenderState);
 733
 734     return DD_OK;
 735 }
 736
 737 static HRESULT WINAPI
 738 GL_IDirect3DDeviceImpl_3_2T_GetLightState(LPDIRECT3DDEVICE3 iface,
 739                                           D3DLIGHTSTATETYPE dwLightStateType,
 740                                           LPDWORD lpdwLightState)
 741 {
 742     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 743
 744     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dwLightStateType, lpdwLightState);
 745
 746     if (!dwLightStateType && (dwLightStateType > D3DLIGHTSTATE_COLORVERTEX)) {
 747         TRACE("Unexpected Light State Type\n");
 748         return DDERR_INVALIDPARAMS;
 749     }
 750
 751     if (dwLightStateType == D3DLIGHTSTATE_MATERIAL /* 1 */) {
 752         *lpdwLightState = This->material;
 753     } else if (dwLightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */) {
 754         *lpdwLightState = D3DCOLOR_RGB;
 755     } else {
 756         D3DRENDERSTATETYPE rs;
 757         switch (dwLightStateType) {
 758             case D3DLIGHTSTATE_AMBIENT:       /* 2 */
 759                 rs = D3DRENDERSTATE_AMBIENT;
 760                 break;
 761             case D3DLIGHTSTATE_FOGMODE:       /* 4 */
 762                 rs = D3DRENDERSTATE_FOGVERTEXMODE;
 763                 break;
 764             case D3DLIGHTSTATE_FOGSTART:      /* 5 */
 765                 rs = D3DRENDERSTATE_FOGSTART;
 766                 break;
 767             case D3DLIGHTSTATE_FOGEND:        /* 6 */
 768                 rs = D3DRENDERSTATE_FOGEND;
 769                 break;
 770             case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
 771                 rs = D3DRENDERSTATE_FOGDENSITY;
 772                 break;
 773             case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
 774                 rs = D3DRENDERSTATE_COLORVERTEX;
 775                 break;
 776             default:
 777                 ERR("Unknown D3DLIGHTSTATETYPE %d.\n", dwLightStateType);
 778                 return DDERR_INVALIDPARAMS;
 779         }
 780
 781         IDirect3DDevice7_GetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
 782                                         rs,lpdwLightState);
 783     }
 784
 785     return DD_OK;
 786 }
 787
 788 static HRESULT WINAPI
 789 GL_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface,
 790                                           D3DLIGHTSTATETYPE dwLightStateType,
 791                                           DWORD dwLightState)
 792 {
 793     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 794
 795     TRACE("(%p/%p)->(%08x,%08lx)\n", This, iface, dwLightStateType, dwLightState);
 796
 797     if (!dwLightStateType && (dwLightStateType > D3DLIGHTSTATE_COLORVERTEX)) {
 798         TRACE("Unexpected Light State Type\n");
 799         return DDERR_INVALIDPARAMS;
 800     }
 801
 802     if (dwLightStateType == D3DLIGHTSTATE_MATERIAL /* 1 */) {
 803         IDirect3DMaterialImpl *mat = (IDirect3DMaterialImpl *) dwLightState;
 804
 805         if (mat != NULL) {
 806             TRACE(" activating material %p.\n", mat);
 807             mat->activate(mat);
 808         } else {
 809             FIXME(" D3DLIGHTSTATE_MATERIAL called with NULL material !!!\n");
 810         }
 811         This->material = dwLightState;
 812     } else if (dwLightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */) {
 813         switch (dwLightState) {
 814             case D3DCOLOR_MONO:
 815                ERR("DDCOLOR_MONO should not happen!\n");
 816                break;
 817             case D3DCOLOR_RGB:
 818                /* We are already in this mode */
 819                TRACE("Setting color model to RGB (no-op).\n");
 820                break;
 821             default:
 822                ERR("Unknown color model!\n");
 823                return DDERR_INVALIDPARAMS;
 824         }
 825     } else {
 826         D3DRENDERSTATETYPE rs;
 827         switch (dwLightStateType) {
 828             case D3DLIGHTSTATE_AMBIENT:       /* 2 */
 829                 rs = D3DRENDERSTATE_AMBIENT;
 830                 break;
 831             case D3DLIGHTSTATE_FOGMODE:       /* 4 */
 832                 rs = D3DRENDERSTATE_FOGVERTEXMODE;
 833                 break;
 834             case D3DLIGHTSTATE_FOGSTART:      /* 5 */
 835                 rs = D3DRENDERSTATE_FOGSTART;
 836                 break;
 837             case D3DLIGHTSTATE_FOGEND:        /* 6 */
 838                 rs = D3DRENDERSTATE_FOGEND;
 839                 break;
 840             case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
 841                 rs = D3DRENDERSTATE_FOGDENSITY;
 842                 break;
 843             case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
 844                 rs = D3DRENDERSTATE_COLORVERTEX;
 845                 break;
 846             default:
 847                 ERR("Unknown D3DLIGHTSTATETYPE %d.\n", dwLightStateType);
 848                 return DDERR_INVALIDPARAMS;
 849         }
 850
 851         IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
 852                                         rs,dwLightState);
 853     }
 854
 855     return DD_OK;
 856 }
 857
 858 static GLenum convert_D3D_ptype_to_GL(D3DPRIMITIVETYPE d3dpt)
 859 {
 860     switch (d3dpt) {
 861         case D3DPT_POINTLIST:
 862             TRACE(" primitive type is POINTS\n");
 863             return GL_POINTS;
 864
 865         case D3DPT_LINELIST:
 866             TRACE(" primitive type is LINES\n");
 867             return GL_LINES;
 868
 869         case D3DPT_LINESTRIP:
 870             TRACE(" primitive type is LINE_STRIP\n");
 871             return GL_LINE_STRIP;
 872
 873         case D3DPT_TRIANGLELIST:
 874             TRACE(" primitive type is TRIANGLES\n");
 875             return GL_TRIANGLES;
 876
 877         case D3DPT_TRIANGLESTRIP:
 878             TRACE(" primitive type is TRIANGLE_STRIP\n");
 879             return GL_TRIANGLE_STRIP;
 880
 881         case D3DPT_TRIANGLEFAN:
 882             TRACE(" primitive type is TRIANGLE_FAN\n");
 883             return GL_TRIANGLE_FAN;
 884
 885         default:
 886             FIXME("Unhandled primitive %08x\n", d3dpt);
 887             return GL_POINTS;
 888     }
 889 }
 890
 891 /* This function calculate the Z coordinate from Zproj */
 892 static float ZfromZproj(IDirect3DDeviceImpl *This, D3DVALUE Zproj)
 893 {
 894     float a,b,c,d;
 895     /* Assume that X = Y = 0 and W = 1 */
 896     a = This->proj_mat->_33;
 897     b = This->proj_mat->_34;
 898     c = This->proj_mat->_43;
 899     d = This->proj_mat->_44;
 900     /* We have in homogenous coordinates Z' = a * Z + c and W' = b * Z + d
 901      * So in non homogenous coordinates we have Zproj = (a * Z + c) / (b * Z + d)
 902      * And finally Z = (d * Zproj - c) / (a - b * Zproj)
 903      */
 904     return (d*Zproj - c) / (a - b*Zproj);
 905 }
 906
 907 static void build_fog_table(BYTE *fog_table, DWORD fog_color) {
 908     int i;
 909
 910     TRACE(" rebuilding fog table (%06lx)...\n", fog_color & 0x00FFFFFF);
 911
 912     for (i = 0; i < 3; i++) {
 913         BYTE fog_color_component = (fog_color >> (8 * i)) & 0xFF;
 914         DWORD elt;
 915         for (elt = 0; elt < 0x10000; elt++) {
 916             /* We apply the fog transformation and cache the result */
 917             DWORD fog_intensity = elt & 0xFF;
 918             DWORD vertex_color = (elt >> 8) & 0xFF;
 919             fog_table[(i * 0x10000) + elt] = ((fog_intensity * vertex_color) + ((0xFF - fog_intensity) * fog_color_component)) / 0xFF;
 920         }
 921     }
 922 }
 923
 924 static void draw_primitive_handle_GL_state(IDirect3DDeviceImpl *This,
 925                                            BOOLEAN vertex_transformed,
 926                                            BOOLEAN vertex_lit) {
 927     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
 928
 929     /* Puts GL in the correct lighting / transformation mode */
 930     if ((vertex_transformed == FALSE) &&
 931         (glThis->transform_state != GL_TRANSFORM_NORMAL)) {
 932         /* Need to put the correct transformation again if we go from Transformed
 933            vertices to non-transformed ones.
 934         */
 935         This->set_matrices(This, VIEWMAT_CHANGED|WORLDMAT_CHANGED|PROJMAT_CHANGED,
 936                            This->world_mat, This->view_mat, This->proj_mat);
 937         glThis->transform_state = GL_TRANSFORM_NORMAL;
 938
 939     } else if (vertex_transformed &&
 940                (glThis->transform_state != GL_TRANSFORM_ORTHO)) {
 941         /* Set our orthographic projection */
 942         if (glThis->transform_state != GL_TRANSFORM_ORTHO) {
 943             glThis->transform_state = GL_TRANSFORM_ORTHO;
 944             d3ddevice_set_ortho(This);
 945         }
 946     }
 947
 948     /* TODO: optimize this to not always reset all the fog stuff on all DrawPrimitive call
 949              if no fogging state change occurred */
 950     if (This->state_block.render_state[D3DRENDERSTATE_FOGENABLE - 1]) {
 951         if (vertex_transformed) {
 952             if (glThis->fogging != 0) {
 953                 glDisable(GL_FOG);
 954                 glThis->fogging = 0;
 955             }
 956             /* Now check if our fog_table still corresponds to the current vertex color.
 957                Element '0x..00' is always the fog color as it corresponds to maximum fog intensity */
 958             if ((glThis->fog_table[0 * 0x10000 + 0x0000] != ((This->state_block.render_state[D3DRENDERSTATE_FOGCOLOR - 1] >>  0) & 0xFF)) ||
 959                 (glThis->fog_table[1 * 0x10000 + 0x0000] != ((This->state_block.render_state[D3DRENDERSTATE_FOGCOLOR - 1] >>  8) & 0xFF)) ||
 960                 (glThis->fog_table[2 * 0x10000 + 0x0000] != ((This->state_block.render_state[D3DRENDERSTATE_FOGCOLOR - 1] >> 16) & 0xFF))) {
 961                 /* We need to rebuild our fog table.... */
 962                 build_fog_table(glThis->fog_table, This->state_block.render_state[D3DRENDERSTATE_FOGCOLOR - 1]);
 963             }
 964         } else {
 965             if (This->state_block.render_state[D3DRENDERSTATE_FOGTABLEMODE - 1] != D3DFOG_NONE) {
 966                 switch (This->state_block.render_state[D3DRENDERSTATE_FOGTABLEMODE - 1]) {
 967                     case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); break;
 968                     case D3DFOG_EXP:    glFogi(GL_FOG_MODE, GL_EXP); break;
 969                     case D3DFOG_EXP2:   glFogi(GL_FOG_MODE, GL_EXP2); break;
 970                 }
 971                 if (vertex_lit == FALSE) {
 972                     glFogf(GL_FOG_START, *(float*)&This->state_block.render_state[D3DRENDERSTATE_FOGSTART - 1]);
 973                     glFogf(GL_FOG_END, *(float*)&This->state_block.render_state[D3DRENDERSTATE_FOGEND - 1]);
 974                 } else {
 975                     /* Special case of 'pixel fog' */
 976                     glFogf(GL_FOG_START, ZfromZproj(This, *(float*)&This->state_block.render_state[D3DRENDERSTATE_FOGSTART - 1]));
 977                     glFogf(GL_FOG_END, ZfromZproj(This, *(float*)&This->state_block.render_state[D3DRENDERSTATE_FOGEND - 1]));
 978                 }
 979                 if (glThis->fogging == 0) {
 980                     glEnable(GL_FOG);
 981                     glThis->fogging = 1;
 982                 }
 983             } else {
 984                 if (glThis->fogging != 0) {
 985                     glDisable(GL_FOG);
 986                     glThis->fogging = 0;
 987                 }
 988             }
 989         }
 990     } else {
 991         if (glThis->fogging != 0) {
 992             glDisable(GL_FOG);
 993             glThis->fogging = 0;
 994         }
 995     }
 996
 997     /* Handle the 'no-normal' case */
 998     if ((vertex_lit == FALSE) && This->state_block.render_state[D3DRENDERSTATE_LIGHTING - 1]) {
 999         if (glThis->lighting == 0) {
1000             glEnable(GL_LIGHTING);
1001             glThis->lighting = 1;
1002         }
1003     } else {
1004         if (glThis->lighting != 0) {
1005             glDisable(GL_LIGHTING);
1006             glThis->lighting = 0;
1007         }
1008     }
1009
1010     /* Handle the code for pre-vertex material properties */
1011     if (vertex_transformed == FALSE) {
1012         if (This->state_block.render_state[D3DRENDERSTATE_LIGHTING - 1] &&
1013             This->state_block.render_state[D3DRENDERSTATE_COLORVERTEX - 1]) {
1014             if ((This->state_block.render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] != D3DMCS_MATERIAL) ||
1015                 (This->state_block.render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] != D3DMCS_MATERIAL) ||
1016                 (This->state_block.render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] != D3DMCS_MATERIAL) ||
1017                 (This->state_block.render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] != D3DMCS_MATERIAL)) {
1018                 glEnable(GL_COLOR_MATERIAL);
1019             }
1020         }
1021     }
1022 }
1023
1024
1025 inline static void draw_primitive(IDirect3DDeviceImpl *This, DWORD maxvert, WORD *index,
1026                                   D3DVERTEXTYPE d3dvt, D3DPRIMITIVETYPE d3dpt, void *lpvertex)
1027 {
1028     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1029
1030     switch (d3dvt) {
1031         case D3DVT_VERTEX: {
1032             strided.position.lpvData = &((D3DVERTEX *) lpvertex)->u1.x;
1033             strided.position.dwStride = sizeof(D3DVERTEX);
1034             strided.normal.lpvData = &((D3DVERTEX *) lpvertex)->u4.nx;
1035             strided.normal.dwStride = sizeof(D3DVERTEX);
1036             strided.textureCoords[0].lpvData = &((D3DVERTEX *) lpvertex)->u7.tu;
1037             strided.textureCoords[0].dwStride = sizeof(D3DVERTEX);
1038             draw_primitive_strided(This, d3dpt, D3DFVF_VERTEX, &strided, 0 /* Unused */, index, maxvert, 0 /* Unused */);
1039         } break;
1040
1041         case D3DVT_LVERTEX: {
1042             strided.position.lpvData = &((D3DLVERTEX *) lpvertex)->u1.x;
1043             strided.position.dwStride = sizeof(D3DLVERTEX);
1044             strided.diffuse.lpvData = &((D3DLVERTEX *) lpvertex)->u4.color;
1045             strided.diffuse.dwStride = sizeof(D3DLVERTEX);
1046             strided.specular.lpvData = &((D3DLVERTEX *) lpvertex)->u5.specular;
1047             strided.specular.dwStride = sizeof(D3DLVERTEX);
1048             strided.textureCoords[0].lpvData = &((D3DLVERTEX *) lpvertex)->u6.tu;
1049             strided.textureCoords[0].dwStride = sizeof(D3DLVERTEX);
1050             draw_primitive_strided(This, d3dpt, D3DFVF_LVERTEX, &strided, 0 /* Unused */, index, maxvert, 0 /* Unused */);
1051         } break;
1052
1053         case D3DVT_TLVERTEX: {
1054             strided.position.lpvData = &((D3DTLVERTEX *) lpvertex)->u1.sx;
1055             strided.position.dwStride = sizeof(D3DTLVERTEX);
1056             strided.diffuse.lpvData = &((D3DTLVERTEX *) lpvertex)->u5.color;
1057             strided.diffuse.dwStride = sizeof(D3DTLVERTEX);
1058             strided.specular.lpvData = &((D3DTLVERTEX *) lpvertex)->u6.specular;
1059             strided.specular.dwStride = sizeof(D3DTLVERTEX);
1060             strided.textureCoords[0].lpvData = &((D3DTLVERTEX *) lpvertex)->u7.tu;
1061             strided.textureCoords[0].dwStride = sizeof(D3DTLVERTEX);
1062             draw_primitive_strided(This, d3dpt, D3DFVF_TLVERTEX, &strided, 0 /* Unused */, index, maxvert, 0 /* Unused */);
1063         } break;
1064
1065         default:
1066             FIXME("Unhandled vertex type %08x\n", d3dvt);
1067             break;
1068     }
1069 }
1070
1071 HRESULT WINAPI
1072 GL_IDirect3DDeviceImpl_2_DrawPrimitive(LPDIRECT3DDEVICE2 iface,
1073                                        D3DPRIMITIVETYPE d3dptPrimitiveType,
1074                                        D3DVERTEXTYPE d3dvtVertexType,
1075                                        LPVOID lpvVertices,
1076                                        DWORD dwVertexCount,
1077                                        DWORD dwFlags)
1078 {
1079     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1080
1081     TRACE("(%p/%p)->(%08x,%08x,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
1082     if (TRACE_ON(ddraw)) {
1083         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1084     }
1085
1086     draw_primitive(This, dwVertexCount, NULL, d3dvtVertexType, d3dptPrimitiveType, lpvVertices);
1087
1088     return DD_OK;
1089 }
1090
1091 HRESULT WINAPI
1092 GL_IDirect3DDeviceImpl_2_DrawIndexedPrimitive(LPDIRECT3DDEVICE2 iface,
1093                                               D3DPRIMITIVETYPE d3dptPrimitiveType,
1094                                               D3DVERTEXTYPE d3dvtVertexType,
1095                                               LPVOID lpvVertices,
1096                                               DWORD dwVertexCount,
1097                                               LPWORD dwIndices,
1098                                               DWORD dwIndexCount,
1099                                               DWORD dwFlags)
1100 {
1101     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1102     TRACE("(%p/%p)->(%08x,%08x,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1103     if (TRACE_ON(ddraw)) {
1104         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1105     }
1106
1107     draw_primitive(This, dwIndexCount, dwIndices, d3dvtVertexType, d3dptPrimitiveType, lpvVertices);
1108
1109     return DD_OK;
1110 }
1111
1112 HRESULT WINAPI
1113 GL_IDirect3DDeviceImpl_1_CreateExecuteBuffer(LPDIRECT3DDEVICE iface,
1114                                              LPD3DEXECUTEBUFFERDESC lpDesc,
1115                                              LPDIRECT3DEXECUTEBUFFER* lplpDirect3DExecuteBuffer,
1116                                              IUnknown* pUnkOuter)
1117 {
1118     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1119     IDirect3DExecuteBufferImpl *ret;
1120     HRESULT ret_value;
1121
1122     TRACE("(%p/%p)->(%p,%p,%p)\n", This, iface, lpDesc, lplpDirect3DExecuteBuffer, pUnkOuter);
1123
1124     ret_value = d3dexecutebuffer_create(&ret, This->d3d, This, lpDesc);
1125     *lplpDirect3DExecuteBuffer = ICOM_INTERFACE(ret, IDirect3DExecuteBuffer);
1126
1127     TRACE(" returning %p.\n", *lplpDirect3DExecuteBuffer);
1128
1129     return ret_value;
1130 }
1131
1132 static void flush_zbuffer_to_GL(IDirect3DDeviceImpl *d3d_dev, LPCRECT pRect, IDirectDrawSurfaceImpl *surf) {
1133     static BOOLEAN first = TRUE;
1134     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
1135     unsigned int row;
1136     GLenum type;
1137
1138     if (first) {
1139         MESSAGE("Warning : application does direct locking of ZBuffer - expect slowdowns on many GL implementations :-)\n");
1140         first = FALSE;
1141     }
1142
1143     TRACE("flushing ZBuffer back to GL\n");
1144
1145     if (gl_d3d_dev->transform_state != GL_TRANSFORM_ORTHO) {
1146         gl_d3d_dev->transform_state = GL_TRANSFORM_ORTHO;
1147         d3ddevice_set_ortho(d3d_dev);
1148     }
1149
1150     glMatrixMode(GL_MODELVIEW);
1151     glLoadIdentity();
1152
1153     if (gl_d3d_dev->depth_test == 0) glEnable(GL_DEPTH_TEST);
1154     if (d3d_dev->state_block.render_state[D3DRENDERSTATE_ZFUNC - 1] != D3DCMP_ALWAYS) glDepthFunc(GL_ALWAYS);
1155     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1156
1157     /* This loop here is to prevent using PixelZoom that may be unoptimized for the 1.0 / -1.0 case
1158        in some drivers...
1159     */
1160     switch (surf->surface_desc.u4.ddpfPixelFormat.u1.dwZBufferBitDepth) {
1161         case 16: type = GL_UNSIGNED_SHORT; break;
1162         case 32: type = GL_UNSIGNED_INT; break;
1163         default: FIXME("Unhandled ZBuffer format !\n"); goto restore_state;
1164     }
1165
1166     for (row = 0; row < surf->surface_desc.dwHeight; row++) {
1167         /* glRasterPos3d(0.0, row + 1.0, 0.5); */
1168         glRasterPos2i(0, row + 1);
1169         glDrawPixels(surf->surface_desc.dwWidth, 1, GL_DEPTH_COMPONENT, type,
1170                      ((unsigned char *) surf->surface_desc.lpSurface) + (row * surf->surface_desc.u1.lPitch));
1171     }
1172
1173   restore_state:
1174     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1175     if (d3d_dev->state_block.render_state[D3DRENDERSTATE_ZFUNC - 1] != D3DCMP_ALWAYS)
1176         glDepthFunc(convert_D3D_compare_to_GL(d3d_dev->state_block.render_state[D3DRENDERSTATE_ZFUNC - 1]));
1177     if (gl_d3d_dev->depth_test == 0) glDisable(GL_DEPTH_TEST);
1178 }
1179
1180 /* These are the various handler used in the generic path */
1181 inline static void handle_xyz(D3DVALUE *coords) {
1182     glVertex3fv(coords);
1183 }
1184 inline static void handle_xyzrhw(D3DVALUE *coords) {
1185     if ((coords[3] < 1e-8) && (coords[3] > -1e-8))
1186         glVertex3fv(coords);
1187     else {
1188         GLfloat w = 1.0 / coords[3];
1189
1190         glVertex4f(coords[0] * w,
1191                    coords[1] * w,
1192                    coords[2] * w,
1193                    w);
1194     }
1195 }
1196 inline static void handle_normal(D3DVALUE *coords) {
1197     glNormal3fv(coords);
1198 }
1199
1200 inline static void handle_diffuse_base(STATEBLOCK *sb, DWORD *color) {
1201     if (sb->render_state[D3DRENDERSTATE_ALPHATESTENABLE - 1] ||
1202         sb->render_state[D3DRENDERSTATE_ALPHABLENDENABLE - 1]) {
1203         glColor4ub((*color >> 16) & 0xFF,
1204                    (*color >>  8) & 0xFF,
1205                    (*color >>  0) & 0xFF,
1206                    (*color >> 24) & 0xFF);
1207     } else {
1208         glColor3ub((*color >> 16) & 0xFF,
1209                    (*color >>  8) & 0xFF,
1210                    (*color >>  0) & 0xFF);
1211     }
1212 }
1213
1214 inline static void handle_specular_base(STATEBLOCK *sb, DWORD *color) {
1215     glColor4ub((*color >> 16) & 0xFF,
1216                (*color >>  8) & 0xFF,
1217                (*color >>  0) & 0xFF,
1218                (*color >> 24) & 0xFF); /* No idea if the alpha field is really used.. */
1219 }
1220
1221 inline static void handle_diffuse(STATEBLOCK *sb, DWORD *color, BOOLEAN lighted) {
1222     if ((lighted == FALSE) &&
1223         sb->render_state[D3DRENDERSTATE_LIGHTING - 1] &&
1224         sb->render_state[D3DRENDERSTATE_COLORVERTEX - 1]) {
1225         if (sb->render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] == D3DMCS_COLOR1) {
1226             glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
1227             handle_diffuse_base(sb, color);
1228         }
1229         if (sb->render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] == D3DMCS_COLOR1) {
1230             glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
1231             handle_diffuse_base(sb, color);
1232         }
1233         if ((sb->render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] == D3DMCS_COLOR1) &&
1234             sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1]) {
1235             glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
1236             handle_diffuse_base(sb, color);
1237         }
1238         if (sb->render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] == D3DMCS_COLOR1) {
1239             glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION);
1240             handle_diffuse_base(sb, color);
1241         }
1242     } else {
1243         handle_diffuse_base(sb, color);
1244     }
1245 }
1246
1247 inline static void handle_specular(STATEBLOCK *sb, DWORD *color, BOOLEAN lighted) {
1248     if ((lighted == FALSE) &&
1249         sb->render_state[D3DRENDERSTATE_LIGHTING - 1] &&
1250         sb->render_state[D3DRENDERSTATE_COLORVERTEX - 1]) {
1251         if (sb->render_state[D3DRENDERSTATE_DIFFUSEMATERIALSOURCE - 1] == D3DMCS_COLOR2) {
1252             glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
1253             handle_specular_base(sb, color);
1254         }
1255         if (sb->render_state[D3DRENDERSTATE_AMBIENTMATERIALSOURCE - 1] == D3DMCS_COLOR2) {
1256             glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
1257             handle_specular_base(sb, color);
1258         }
1259         if ((sb->render_state[D3DRENDERSTATE_SPECULARMATERIALSOURCE - 1] == D3DMCS_COLOR2) &&
1260             sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1]) {
1261             glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
1262             handle_specular_base(sb, color);
1263         }
1264         if (sb->render_state[D3DRENDERSTATE_EMISSIVEMATERIALSOURCE - 1] == D3DMCS_COLOR2) {
1265             glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION);
1266             handle_specular_base(sb, color);
1267         }
1268     }
1269     /* No else here as we do not know how to handle 'specular' on its own in any case.. */
1270 }
1271
1272 inline static void handle_diffuse_and_specular(STATEBLOCK *sb, BYTE *fog_table, DWORD *color_d, DWORD *color_s, BOOLEAN lighted) {
1273     if (lighted) {
1274         DWORD color = *color_d;
1275         if (sb->render_state[D3DRENDERSTATE_FOGENABLE - 1]) {
1276             /* Special case where the specular value is used to do fogging */
1277             BYTE fog_intensity = *color_s >> 24; /* The alpha value of the specular component is the fog 'intensity' for this vertex */
1278             color &= 0xFF000000; /* Only keep the alpha component */
1279             color |= fog_table[((*color_d >>  0) & 0xFF) << 8 | fog_intensity] <<  0;
1280             color |= fog_table[((*color_d >>  8) & 0xFF) << 8 | fog_intensity] <<  8;
1281             color |= fog_table[((*color_d >> 16) & 0xFF) << 8 | fog_intensity] << 16;
1282         }
1283         if (sb->render_state[D3DRENDERSTATE_SPECULARENABLE - 1]) {
1284             /* Standard specular value in transformed mode. TODO */
1285         }
1286         handle_diffuse_base(sb, &color);
1287     } else {
1288         if (sb->render_state[D3DRENDERSTATE_LIGHTING - 1]) {
1289             handle_diffuse(sb, color_d, FALSE);
1290             handle_specular(sb, color_s, FALSE);
1291         } else {
1292             /* In that case, only put the diffuse color... */
1293             handle_diffuse_base(sb, color_d);
1294         }
1295     }
1296 }
1297
1298 static void handle_texture(DWORD size, const D3DVALUE *coords) {
1299     switch (size) {
1300         case 1: glTexCoord1fv(coords); break;
1301         case 2: glTexCoord2fv(coords); break;
1302         case 3: glTexCoord3fv(coords); break;
1303         case 4: glTexCoord4fv(coords); break;
1304     }
1305 }
1306
1307 inline static void handle_textures(DWORD size, const D3DVALUE *coords, int tex_stage) {
1308     if (GL_extensions.max_texture_units > 0) {
1309         GL_extensions.glMultiTexCoord[size - 1](GL_TEXTURE0_WINE + tex_stage, coords);
1310     } else {
1311         if (tex_stage == 0) handle_texture(size, coords);
1312     }
1313 }
1314
1315 static void draw_primitive_strided(IDirect3DDeviceImpl *This,
1316                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
1317                                    DWORD d3dvtVertexType,
1318                                    LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1319                                    DWORD dwVertexCount,
1320                                    LPWORD dwIndices,
1321                                    DWORD dwIndexCount,
1322                                    DWORD dwFlags)
1323 {
1324     BOOLEAN vertex_lighted = FALSE;
1325     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
1326     int num_active_stages = 0;
1327     int num_tex_index = GET_TEXCOUNT_FROM_FVF(d3dvtVertexType);
1328     BOOL reenable_depth_test = FALSE;
1329
1330     /* I put the trace before the various locks... So as to better understand where locks occur :-) */
1331     if (TRACE_ON(ddraw)) {
1332         TRACE(" Vertex format : "); dump_flexible_vertex(d3dvtVertexType);
1333     }
1334
1335     /* This is to prevent 'thread contention' between a thread locking the device and another
1336        doing 3D display on it... */
1337     EnterCriticalSection(&(This->crit));
1338
1339     ENTER_GL();
1340     if (glThis->state[WINE_GL_BUFFER_BACK] == SURFACE_MEMORY_DIRTY) {
1341         This->flush_to_framebuffer(This, &(glThis->lock_rect[WINE_GL_BUFFER_BACK]), glThis->lock_surf[WINE_GL_BUFFER_BACK]);
1342     }
1343     glThis->state[WINE_GL_BUFFER_BACK] = SURFACE_GL;
1344
1345     if (This->current_zbuffer == NULL) {
1346         /* Search for an attached ZBuffer */
1347         static const DDSCAPS2 zbuf_caps = { DDSCAPS_ZBUFFER, 0, 0, 0 };
1348         LPDIRECTDRAWSURFACE7 zbuf;
1349         HRESULT hr;
1350
1351         hr = IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This->surface, IDirectDrawSurface7),
1352                                                     (DDSCAPS2 *) &zbuf_caps, &zbuf);
1353         if (SUCCEEDED(hr)) {
1354             This->current_zbuffer = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, zbuf);
1355             IDirectDrawSurface7_Release(zbuf);
1356         } else if (glThis->depth_test) {
1357             glDisable(GL_DEPTH_TEST);
1358             reenable_depth_test = TRUE;
1359         }
1360     }
1361     if (This->current_zbuffer != NULL) {
1362         if (This->current_zbuffer->get_dirty_status(This->current_zbuffer, NULL)) {
1363             flush_zbuffer_to_GL(This, NULL, This->current_zbuffer);
1364         }
1365     }
1366
1367     if ( ((d3dvtVertexType & D3DFVF_POSITION_MASK) != D3DFVF_XYZ) ||
1368          ((d3dvtVertexType & D3DFVF_NORMAL) == 0) )
1369         vertex_lighted = TRUE;
1370
1371     /* Compute the number of active texture stages and set the various texture parameters */
1372     num_active_stages = draw_primitive_handle_textures(This);
1373
1374     /* And restore to handle '0' in the case we use glTexCoord calls */
1375     if (glThis->current_active_tex_unit != GL_TEXTURE0_WINE) {
1376         GL_extensions.glActiveTexture(GL_TEXTURE0_WINE);
1377         glThis->current_active_tex_unit = GL_TEXTURE0_WINE;
1378     }
1379
1380     draw_primitive_handle_GL_state(This,
1381                                    (d3dvtVertexType & D3DFVF_POSITION_MASK) != D3DFVF_XYZ,
1382                                    vertex_lighted);
1383
1384     /* First, see if we can use the OpenGL vertex arrays... This is very limited
1385        for now to some 'special' cases where we can do a direct mapping between D3D
1386        types and GL types.
1387
1388        Note: in the future all calls will go through vertex arrays but the arrays
1389              will be generated by this function.
1390
1391        Note2: colours cannot be mapped directly because they are stored as BGRA in memory
1392               (ie not as an array of R, G, B, A as OpenGL does it but as a LWORD 0xAARRGGBB
1393               which, as we are little indian, gives a B, G, R, A storage in memory.
1394     */
1395     if (((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) && /* Standard XYZ vertices */
1396         ((d3dvtVertexType & (D3DFVF_DIFFUSE|D3DFVF_SPECULAR)) == 0)) {
1397         int tex_stage;
1398         TRACE(" using GL vertex arrays for performance !\n");
1399         /* First, the vertices (we are sure we have some :-) */
1400         glEnableClientState(GL_VERTEX_ARRAY);
1401         glVertexPointer(3, GL_FLOAT, lpD3DDrawPrimStrideData->position.dwStride, lpD3DDrawPrimStrideData->position.lpvData);
1402         /* Then the normals */
1403         if (d3dvtVertexType & D3DFVF_NORMAL) {
1404             glEnableClientState(GL_NORMAL_ARRAY);
1405             glNormalPointer(GL_FLOAT, lpD3DDrawPrimStrideData->normal.dwStride, lpD3DDrawPrimStrideData->normal.lpvData);
1406         }
1407         /* Then the diffuse colour */
1408         if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1409             glEnableClientState(GL_COLOR_ARRAY);
1410             glColorPointer(3, GL_UNSIGNED_BYTE, lpD3DDrawPrimStrideData->normal.dwStride,
1411                            ((char *) lpD3DDrawPrimStrideData->diffuse.lpvData));
1412         }
1413         /* Then the various textures */
1414         for (tex_stage = 0; tex_stage < num_active_stages; tex_stage++) {
1415             int tex_index = This->state_block.texture_stage_state[tex_stage][D3DTSS_TEXCOORDINDEX - 1] & 0x0000FFFF;
1416             if (tex_index >= num_tex_index) {
1417                 WARN("Default texture coordinate not handled in the vertex array path !!!\n");
1418                 tex_index = num_tex_index - 1;
1419             }
1420             if (GL_extensions.glClientActiveTexture) {
1421                 GL_extensions.glClientActiveTexture(GL_TEXTURE0_WINE + tex_stage);
1422             }
1423             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1424             glTexCoordPointer(GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_index), GL_FLOAT, lpD3DDrawPrimStrideData->textureCoords[tex_index].dwStride,
1425                               lpD3DDrawPrimStrideData->textureCoords[tex_index].lpvData);
1426         }
1427         if (dwIndices != NULL) {
1428             glDrawElements(convert_D3D_ptype_to_GL(d3dptPrimitiveType), dwIndexCount, GL_UNSIGNED_SHORT, dwIndices);
1429         } else {
1430             glDrawArrays(convert_D3D_ptype_to_GL(d3dptPrimitiveType), 0, dwIndexCount);
1431         }
1432         glDisableClientState(GL_VERTEX_ARRAY);
1433         if (d3dvtVertexType & D3DFVF_NORMAL) {
1434             glDisableClientState(GL_NORMAL_ARRAY);
1435         }
1436         if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1437             glDisableClientState(GL_COLOR_ARRAY);
1438         }
1439         for (tex_stage = 0; tex_stage < num_active_stages; tex_stage++) {
1440             if (GL_extensions.glClientActiveTexture) {
1441                 GL_extensions.glClientActiveTexture(GL_TEXTURE0_WINE + tex_stage);
1442             }
1443             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1444         }
1445     } else {
1446         glBegin(convert_D3D_ptype_to_GL(d3dptPrimitiveType));
1447
1448         /* Some fast paths first before the generic case.... */
1449         if ((d3dvtVertexType == D3DFVF_VERTEX) && (num_active_stages <= 1)) {
1450             unsigned int index;
1451
1452             for (index = 0; index < dwIndexCount; index++) {
1453                 int i = (dwIndices == NULL) ? index : dwIndices[index];
1454                 D3DVALUE *normal =
1455                     (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
1456                 D3DVALUE *tex_coord =
1457                     (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[0].lpvData) + i * lpD3DDrawPrimStrideData->textureCoords[0].dwStride);
1458                 D3DVALUE *position =
1459                     (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1460
1461                 handle_normal(normal);
1462                 handle_texture(2, tex_coord);
1463                 handle_xyz(position);
1464
1465                 TRACE_(ddraw_geom)(" %f %f %f / %f %f %f (%f %f)\n",
1466                                    position[0], position[1], position[2],
1467                                    normal[0], normal[1], normal[2],
1468                                    tex_coord[0], tex_coord[1]);
1469             }
1470         } else if ((d3dvtVertexType == D3DFVF_TLVERTEX) && (num_active_stages <= 1)) {
1471             unsigned int index;
1472
1473             for (index = 0; index < dwIndexCount; index++) {
1474                 int i = (dwIndices == NULL) ? index : dwIndices[index];
1475                 DWORD *color_d =
1476                     (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1477                 DWORD *color_s =
1478                     (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1479                 D3DVALUE *tex_coord =
1480                     (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[0].lpvData) + i * lpD3DDrawPrimStrideData->textureCoords[0].dwStride);
1481                 D3DVALUE *position =
1482                     (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1483
1484                 handle_diffuse_and_specular(&(This->state_block), glThis->fog_table, color_d, color_s, TRUE);
1485                 handle_texture(2, tex_coord);
1486                 handle_xyzrhw(position);
1487
1488                 TRACE_(ddraw_geom)(" %f %f %f %f / %02lx %02lx %02lx %02lx - %02lx %02lx %02lx %02lx (%f %f)\n",
1489                                    position[0], position[1], position[2], position[3],
1490                                    (*color_d >> 16) & 0xFF,
1491                                    (*color_d >>  8) & 0xFF,
1492                                    (*color_d >>  0) & 0xFF,
1493                                    (*color_d >> 24) & 0xFF,
1494                                    (*color_s >> 16) & 0xFF,
1495                                    (*color_s >>  8) & 0xFF,
1496                                    (*color_s >>  0) & 0xFF,
1497                                    (*color_s >> 24) & 0xFF,
1498                                    tex_coord[0], tex_coord[1]);
1499             }
1500         } else if (((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) ||
1501                    ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW)) {
1502             /* This is the 'slow path' but that should support all possible vertex formats out there...
1503                Note that people should write a fast path for all vertex formats out there...
1504                */
1505             unsigned int index;
1506             /* static const D3DVALUE no_index[] = { 0.0, 0.0, 0.0, 0.0 }; */
1507
1508             for (index = 0; index < dwIndexCount; index++) {
1509                 int i = (dwIndices == NULL) ? index : dwIndices[index];
1510                 int tex_stage;
1511
1512                 if (d3dvtVertexType & D3DFVF_NORMAL) {
1513                     D3DVALUE *normal =
1514                         (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
1515                     handle_normal(normal);
1516                 }
1517                 if ((d3dvtVertexType & (D3DFVF_DIFFUSE|D3DFVF_SPECULAR)) == (D3DFVF_DIFFUSE|D3DFVF_SPECULAR)) {
1518                     DWORD *color_d =
1519                         (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1520                     DWORD *color_s =
1521                         (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1522                     handle_diffuse_and_specular(&(This->state_block), glThis->fog_table, color_d, color_s, vertex_lighted);
1523                 } else {
1524                     if (d3dvtVertexType & D3DFVF_SPECULAR) {
1525                         DWORD *color_s =
1526                             (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1527                         handle_specular(&(This->state_block), color_s, vertex_lighted);
1528                     } else if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1529                         DWORD *color_d =
1530                             (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1531                         handle_diffuse(&(This->state_block), color_d, vertex_lighted);
1532                     }
1533                 }
1534
1535                 for (tex_stage = 0; tex_stage < num_active_stages; tex_stage++) {
1536                     int tex_index = This->state_block.texture_stage_state[tex_stage][D3DTSS_TEXCOORDINDEX - 1] & 0x0000FFFF;
1537                     D3DVALUE *tex_coord;
1538
1539                     if (tex_index >= num_tex_index) {
1540                         /* This will have to be checked on Windows. RealMYST uses this feature and I would find it more
1541                          * logical to re-use the index of the previous stage than a default index of '0'.
1542                          */
1543
1544                         /* handle_textures((const D3DVALUE *) no_index, tex_stage); */
1545                         tex_index = num_tex_index - 1;
1546                     }
1547                     tex_coord = (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[tex_index].lpvData) +
1548                                               i * lpD3DDrawPrimStrideData->textureCoords[tex_index].dwStride);
1549                     handle_textures(GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_index), tex_coord, tex_stage);
1550                 }
1551
1552                 if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) {
1553                     D3DVALUE *position =
1554                         (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1555                     handle_xyz(position);
1556                 } else if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW) {
1557                     D3DVALUE *position =
1558                         (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1559                     handle_xyzrhw(position);
1560                 }
1561
1562                 if (TRACE_ON(ddraw_geom)) {
1563                     unsigned int tex_index;
1564
1565                     if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) {
1566                         D3DVALUE *position =
1567                             (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1568                         TRACE_(ddraw_geom)(" %f %f %f", position[0], position[1], position[2]);
1569                     } else if ((d3dvtVertexType & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW) {
1570                         D3DVALUE *position =
1571                             (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->position.lpvData) + i * lpD3DDrawPrimStrideData->position.dwStride);
1572                         TRACE_(ddraw_geom)(" %f %f %f %f", position[0], position[1], position[2], position[3]);
1573                     }
1574                     if (d3dvtVertexType & D3DFVF_NORMAL) {
1575                         D3DVALUE *normal =
1576                             (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->normal.lpvData) + i * lpD3DDrawPrimStrideData->normal.dwStride);
1577                         TRACE_(ddraw_geom)(" / %f %f %f", normal[0], normal[1], normal[2]);
1578                     }
1579                     if (d3dvtVertexType & D3DFVF_DIFFUSE) {
1580                         DWORD *color_d =
1581                             (DWORD *) (((char *) lpD3DDrawPrimStrideData->diffuse.lpvData) + i * lpD3DDrawPrimStrideData->diffuse.dwStride);
1582                         TRACE_(ddraw_geom)(" / %02lx %02lx %02lx %02lx",
1583                                            (*color_d >> 16) & 0xFF,
1584                                            (*color_d >>  8) & 0xFF,
1585                                            (*color_d >>  0) & 0xFF,
1586                                            (*color_d >> 24) & 0xFF);
1587                     }
1588                     if (d3dvtVertexType & D3DFVF_SPECULAR) {
1589                         DWORD *color_s =
1590                             (DWORD *) (((char *) lpD3DDrawPrimStrideData->specular.lpvData) + i * lpD3DDrawPrimStrideData->specular.dwStride);
1591                         TRACE_(ddraw_geom)(" / %02lx %02lx %02lx %02lx",
1592                                            (*color_s >> 16) & 0xFF,
1593                                            (*color_s >>  8) & 0xFF,
1594                                            (*color_s >>  0) & 0xFF,
1595                                            (*color_s >> 24) & 0xFF);
1596                     }
1597                     for (tex_index = 0; tex_index < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); tex_index++) {
1598                         D3DVALUE *tex_coord =
1599                             (D3DVALUE *) (((char *) lpD3DDrawPrimStrideData->textureCoords[tex_index].lpvData) +
1600                                           i * lpD3DDrawPrimStrideData->textureCoords[tex_index].dwStride);
1601                         switch (GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_index)) {
1602                             case 1: TRACE_(ddraw_geom)(" / %f", tex_coord[0]); break;
1603                             case 2: TRACE_(ddraw_geom)(" / %f %f", tex_coord[0], tex_coord[1]); break;
1604                             case 3: TRACE_(ddraw_geom)(" / %f %f %f", tex_coord[0], tex_coord[1], tex_coord[2]); break;
1605                             case 4: TRACE_(ddraw_geom)(" / %f %f %f %f", tex_coord[0], tex_coord[1], tex_coord[2], tex_coord[3]); break;
1606                             default: TRACE_(ddraw_geom)("Invalid texture size (%ld) !!!", GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_index)); break;
1607                         }
1608                     }
1609                     TRACE_(ddraw_geom)("\n");
1610                 }
1611             }
1612         } else {
1613             ERR(" matrix weighting not handled yet....\n");
1614         }
1615
1616         glEnd();
1617     }
1618
1619     /* Whatever the case, disable the color material stuff */
1620     glDisable(GL_COLOR_MATERIAL);
1621
1622     if (reenable_depth_test)
1623         glEnable(GL_DEPTH_TEST);
1624
1625     LEAVE_GL();
1626     TRACE("End\n");
1627
1628     LeaveCriticalSection(&(This->crit));
1629 }
1630
1631 HRESULT WINAPI
1632 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitive(LPDIRECT3DDEVICE7 iface,
1633                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
1634                                           DWORD d3dvtVertexType,
1635                                           LPVOID lpvVertices,
1636                                           DWORD dwVertexCount,
1637                                           DWORD dwFlags)
1638 {
1639     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1640     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1641
1642     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
1643     if (TRACE_ON(ddraw)) {
1644         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1645     }
1646
1647     convert_FVF_to_strided_data(d3dvtVertexType, lpvVertices, &strided, 0);
1648     draw_primitive_strided(This, d3dptPrimitiveType, d3dvtVertexType, &strided, dwVertexCount, NULL, dwVertexCount, dwFlags);
1649
1650     return DD_OK;
1651 }
1652
1653 HRESULT WINAPI
1654 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitive(LPDIRECT3DDEVICE7 iface,
1655                                                  D3DPRIMITIVETYPE d3dptPrimitiveType,
1656                                                  DWORD d3dvtVertexType,
1657                                                  LPVOID lpvVertices,
1658                                                  DWORD dwVertexCount,
1659                                                  LPWORD dwIndices,
1660                                                  DWORD dwIndexCount,
1661                                                  DWORD dwFlags)
1662 {
1663     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1664     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1665
1666     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1667     if (TRACE_ON(ddraw)) {
1668         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1669     }
1670
1671     convert_FVF_to_strided_data(d3dvtVertexType, lpvVertices, &strided, 0);
1672     draw_primitive_strided(This, d3dptPrimitiveType, d3dvtVertexType, &strided, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1673
1674     return DD_OK;
1675 }
1676
1677 HRESULT WINAPI
1678 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
1679                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
1680                                                    DWORD dwVertexType,
1681                                                    LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1682                                                    DWORD dwVertexCount,
1683                                                    DWORD dwFlags)
1684 {
1685     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1686
1687     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, dwFlags);
1688     if (TRACE_ON(ddraw)) {
1689         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1690     }
1691     draw_primitive_strided(This, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, NULL, dwVertexCount, dwFlags);
1692
1693     return DD_OK;
1694 }
1695
1696 HRESULT WINAPI
1697 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
1698                                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
1699                                                           DWORD dwVertexType,
1700                                                           LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1701                                                           DWORD dwVertexCount,
1702                                                           LPWORD lpIndex,
1703                                                           DWORD dwIndexCount,
1704                                                           DWORD dwFlags)
1705 {
1706     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1707
1708     TRACE("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
1709     if (TRACE_ON(ddraw)) {
1710         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1711     }
1712
1713     draw_primitive_strided(This, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
1714
1715     return DD_OK;
1716 }
1717
1718 HRESULT WINAPI
1719 GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveVB(LPDIRECT3DDEVICE7 iface,
1720                                             D3DPRIMITIVETYPE d3dptPrimitiveType,
1721                                             LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
1722                                             DWORD dwStartVertex,
1723                                             DWORD dwNumVertices,
1724                                             DWORD dwFlags)
1725 {
1726     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1727     IDirect3DVertexBufferImpl *vb_impl = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, lpD3DVertexBuf);
1728     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1729
1730     TRACE("(%p/%p)->(%08x,%p,%08lx,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, dwFlags);
1731     if (TRACE_ON(ddraw)) {
1732         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1733     }
1734
1735     if (vb_impl->processed) {
1736         IDirect3DVertexBufferGLImpl *vb_glimp = (IDirect3DVertexBufferGLImpl *) vb_impl;
1737         IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
1738
1739         glThis->transform_state = GL_TRANSFORM_VERTEXBUFFER;
1740         This->set_matrices(This, VIEWMAT_CHANGED|WORLDMAT_CHANGED|PROJMAT_CHANGED,
1741                            &(vb_glimp->world_mat), &(vb_glimp->view_mat), &(vb_glimp->proj_mat));
1742
1743         convert_FVF_to_strided_data(vb_glimp->dwVertexTypeDesc, vb_glimp->vertices, &strided, dwStartVertex);
1744         draw_primitive_strided(This, d3dptPrimitiveType, vb_glimp->dwVertexTypeDesc, &strided, dwNumVertices, NULL, dwNumVertices, dwFlags);
1745
1746     } else {
1747         convert_FVF_to_strided_data(vb_impl->desc.dwFVF, vb_impl->vertices, &strided, dwStartVertex);
1748         draw_primitive_strided(This, d3dptPrimitiveType, vb_impl->desc.dwFVF, &strided, dwNumVertices, NULL, dwNumVertices, dwFlags);
1749     }
1750
1751     return DD_OK;
1752 }
1753
1754 HRESULT WINAPI
1755 GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB(LPDIRECT3DDEVICE7 iface,
1756                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
1757                                                    LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
1758                                                    DWORD dwStartVertex,
1759                                                    DWORD dwNumVertices,
1760                                                    LPWORD lpwIndices,
1761                                                    DWORD dwIndexCount,
1762                                                    DWORD dwFlags)
1763 {
1764     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1765     IDirect3DVertexBufferImpl *vb_impl = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, lpD3DVertexBuf);
1766     D3DDRAWPRIMITIVESTRIDEDDATA strided;
1767
1768     TRACE("(%p/%p)->(%08x,%p,%08lx,%08lx,%p,%08lx,%08lx)\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
1769     if (TRACE_ON(ddraw)) {
1770         TRACE(" - flags : "); dump_DPFLAGS(dwFlags);
1771     }
1772
1773     if (vb_impl->processed) {
1774         IDirect3DVertexBufferGLImpl *vb_glimp = (IDirect3DVertexBufferGLImpl *) vb_impl;
1775         IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
1776
1777         glThis->transform_state = GL_TRANSFORM_VERTEXBUFFER;
1778         This->set_matrices(This, VIEWMAT_CHANGED|WORLDMAT_CHANGED|PROJMAT_CHANGED,
1779                            &(vb_glimp->world_mat), &(vb_glimp->view_mat), &(vb_glimp->proj_mat));
1780
1781         convert_FVF_to_strided_data(vb_glimp->dwVertexTypeDesc, vb_glimp->vertices, &strided, dwStartVertex);
1782         draw_primitive_strided(This, d3dptPrimitiveType, vb_glimp->dwVertexTypeDesc, &strided, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
1783
1784     } else {
1785         convert_FVF_to_strided_data(vb_impl->desc.dwFVF, vb_impl->vertices, &strided, dwStartVertex);
1786         draw_primitive_strided(This, d3dptPrimitiveType, vb_impl->desc.dwFVF, &strided, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
1787     }
1788
1789     return DD_OK;
1790 }
1791
1792 /* We need a static function for that to handle the 'special' case of 'SELECT_ARG2' */
1793 static BOOLEAN
1794 handle_color_alpha_args(IDirect3DDeviceImpl *This, DWORD dwStage, D3DTEXTURESTAGESTATETYPE d3dTexStageStateType, DWORD dwState, D3DTEXTUREOP tex_op)
1795 {
1796     BOOLEAN is_complement = FALSE;
1797     BOOLEAN is_alpha_replicate = FALSE;
1798     BOOLEAN handled = TRUE;
1799     GLenum src;
1800     BOOLEAN is_color = ((d3dTexStageStateType == D3DTSS_COLORARG1) || (d3dTexStageStateType == D3DTSS_COLORARG2));
1801     int num;
1802
1803     if (is_color) {
1804         if (d3dTexStageStateType == D3DTSS_COLORARG1) num = 0;
1805         else if (d3dTexStageStateType == D3DTSS_COLORARG2) num = 1;
1806         else {
1807             handled = FALSE;
1808             num = 0;
1809         }
1810         if (tex_op == D3DTOP_SELECTARG2) {
1811             num = 1 - num;
1812         }
1813     } else {
1814         if (d3dTexStageStateType == D3DTSS_ALPHAARG1) num = 0;
1815         else if (d3dTexStageStateType == D3DTSS_ALPHAARG2) num = 1;
1816         else {
1817             handled = FALSE;
1818             num = 0;
1819         }
1820         if (tex_op == D3DTOP_SELECTARG2) {
1821             num = 1 - num;
1822         }
1823     }
1824
1825     if (dwState & D3DTA_COMPLEMENT) {
1826         is_complement = TRUE;
1827     }
1828     if (dwState & D3DTA_ALPHAREPLICATE) {
1829         is_alpha_replicate = TRUE;
1830     }
1831     dwState &= D3DTA_SELECTMASK;
1832     if ((dwStage == 0) && (dwState == D3DTA_CURRENT)) {
1833         dwState = D3DTA_DIFFUSE;
1834     }
1835
1836     switch (dwState) {
1837         case D3DTA_CURRENT: src = GL_PREVIOUS_EXT; break;
1838         case D3DTA_DIFFUSE: src = GL_PRIMARY_COLOR_EXT; break;
1839         case D3DTA_TEXTURE: src = GL_TEXTURE; break;
1840         case D3DTA_TFACTOR: {
1841             /* Get the constant value from the current rendering state */
1842             GLfloat color[4];
1843             DWORD col = This->state_block.render_state[D3DRENDERSTATE_TEXTUREFACTOR - 1];
1844
1845             color[0] = ((col >> 16) & 0xFF) / 255.0f;
1846             color[1] = ((col >>  8) & 0xFF) / 255.0f;
1847             color[2] = ((col >>  0) & 0xFF) / 255.0f;
1848             color[3] = ((col >> 24) & 0xFF) / 255.0f;
1849             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
1850
1851             src = GL_CONSTANT_EXT;
1852         } break;
1853         default: src = GL_TEXTURE; handled = FALSE; break;
1854     }
1855
1856     if (is_color) {
1857         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT + num, src);
1858         if (is_alpha_replicate) {
1859             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT + num, is_complement ? GL_ONE_MINUS_SRC_ALPHA : GL_SRC_ALPHA);
1860         } else {
1861             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT + num, is_complement ? GL_ONE_MINUS_SRC_COLOR : GL_SRC_COLOR);
1862         }
1863     } else {
1864         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT + num, src);
1865         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT + num, is_complement ? GL_ONE_MINUS_SRC_ALPHA : GL_SRC_ALPHA);
1866     }
1867
1868     return handled;
1869 }
1870
1871 HRESULT WINAPI
1872 GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface,
1873                                                  DWORD dwStage,
1874                                                  D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
1875                                                  DWORD dwState)
1876 {
1877     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1878     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
1879     const char *type;
1880     DWORD prev_state;
1881     GLenum unit;
1882
1883     TRACE("(%p/%p)->(%08lx,%08x,%08lx)\n", This, iface, dwStage, d3dTexStageStateType, dwState);
1884
1885     if (((GL_extensions.max_texture_units == 0) && (dwStage > 0)) ||
1886         ((GL_extensions.max_texture_units != 0) && (dwStage >= GL_extensions.max_texture_units))) {
1887         return DD_OK;
1888     }
1889
1890     unit = GL_TEXTURE0_WINE + dwStage;
1891     if (unit != glThis->current_active_tex_unit) {
1892         GL_extensions.glActiveTexture(unit);
1893         glThis->current_active_tex_unit = unit;
1894     }
1895
1896     switch (d3dTexStageStateType) {
1897 #define GEN_CASE(a) case a: type = #a; break
1898         GEN_CASE(D3DTSS_COLOROP);
1899         GEN_CASE(D3DTSS_COLORARG1);
1900         GEN_CASE(D3DTSS_COLORARG2);
1901         GEN_CASE(D3DTSS_ALPHAOP);
1902         GEN_CASE(D3DTSS_ALPHAARG1);
1903         GEN_CASE(D3DTSS_ALPHAARG2);
1904         GEN_CASE(D3DTSS_BUMPENVMAT00);
1905         GEN_CASE(D3DTSS_BUMPENVMAT01);
1906         GEN_CASE(D3DTSS_BUMPENVMAT10);
1907         GEN_CASE(D3DTSS_BUMPENVMAT11);
1908         GEN_CASE(D3DTSS_TEXCOORDINDEX);
1909         GEN_CASE(D3DTSS_ADDRESS);
1910         GEN_CASE(D3DTSS_ADDRESSU);
1911         GEN_CASE(D3DTSS_ADDRESSV);
1912         GEN_CASE(D3DTSS_BORDERCOLOR);
1913         GEN_CASE(D3DTSS_MAGFILTER);
1914         GEN_CASE(D3DTSS_MINFILTER);
1915         GEN_CASE(D3DTSS_MIPFILTER);
1916         GEN_CASE(D3DTSS_MIPMAPLODBIAS);
1917         GEN_CASE(D3DTSS_MAXMIPLEVEL);
1918         GEN_CASE(D3DTSS_MAXANISOTROPY);
1919         GEN_CASE(D3DTSS_BUMPENVLSCALE);
1920         GEN_CASE(D3DTSS_BUMPENVLOFFSET);
1921         GEN_CASE(D3DTSS_TEXTURETRANSFORMFLAGS);
1922 #undef GEN_CASE
1923         default: type = "UNKNOWN";
1924     }
1925
1926     /* Store the values in the state array */
1927     prev_state = This->state_block.texture_stage_state[dwStage][d3dTexStageStateType - 1];
1928     This->state_block.texture_stage_state[dwStage][d3dTexStageStateType - 1] = dwState;
1929     /* Some special cases when one state modifies more than one... */
1930     if (d3dTexStageStateType == D3DTSS_ADDRESS) {
1931         This->state_block.texture_stage_state[dwStage][D3DTSS_ADDRESSU - 1] = dwState;
1932         This->state_block.texture_stage_state[dwStage][D3DTSS_ADDRESSV - 1] = dwState;
1933     }
1934
1935     ENTER_GL();
1936
1937     switch (d3dTexStageStateType) {
1938         case D3DTSS_MINFILTER:
1939         case D3DTSS_MIPFILTER:
1940             if (TRACE_ON(ddraw)) {
1941                 if (d3dTexStageStateType == D3DTSS_MINFILTER) {
1942                     switch ((D3DTEXTUREMINFILTER) dwState) {
1943                         case D3DTFN_POINT:  TRACE(" Stage type is : D3DTSS_MINFILTER => D3DTFN_POINT\n"); break;
1944                         case D3DTFN_LINEAR: TRACE(" Stage type is : D3DTSS_MINFILTER => D3DTFN_LINEAR\n"); break;
1945                         default: FIXME(" Unhandled stage type : D3DTSS_MINFILTER => %08lx\n", dwState); break;
1946                     }
1947                 } else {
1948                     switch ((D3DTEXTUREMIPFILTER) dwState) {
1949                         case D3DTFP_NONE:   TRACE(" Stage type is : D3DTSS_MIPFILTER => D3DTFP_NONE\n"); break;
1950                         case D3DTFP_POINT:  TRACE(" Stage type is : D3DTSS_MIPFILTER => D3DTFP_POINT\n"); break;
1951                         case D3DTFP_LINEAR: TRACE(" Stage type is : D3DTSS_MIPFILTER => D3DTFP_LINEAR\n"); break;
1952                         default: FIXME(" Unhandled stage type : D3DTSS_MIPFILTER => %08lx\n", dwState); break;
1953                     }
1954                 }
1955             }
1956             break;
1957
1958         case D3DTSS_MAGFILTER:
1959             if (TRACE_ON(ddraw)) {
1960                 switch ((D3DTEXTUREMAGFILTER) dwState) {
1961                     case D3DTFG_POINT:  TRACE(" Stage type is : D3DTSS_MAGFILTER => D3DTFG_POINT\n"); break;
1962                     case D3DTFG_LINEAR: TRACE(" Stage type is : D3DTSS_MAGFILTER => D3DTFG_LINEAR\n"); break;
1963                     default: FIXME(" Unhandled stage type : D3DTSS_MAGFILTER => %08lx\n", dwState); break;
1964                 }
1965             }
1966             break;
1967
1968         case D3DTSS_ADDRESS:
1969         case D3DTSS_ADDRESSU:
1970         case D3DTSS_ADDRESSV: {
1971             switch ((D3DTEXTUREADDRESS) dwState) {
1972                 case D3DTADDRESS_WRAP:   TRACE(" Stage type is : %s => D3DTADDRESS_WRAP\n", type); break;
1973                 case D3DTADDRESS_CLAMP:  TRACE(" Stage type is : %s => D3DTADDRESS_CLAMP\n", type); break;
1974                 case D3DTADDRESS_BORDER: TRACE(" Stage type is : %s => D3DTADDRESS_BORDER\n", type); break;
1975                 case D3DTADDRESS_MIRROR:
1976                     if (GL_extensions.mirrored_repeat) {
1977                         TRACE(" Stage type is : %s => D3DTADDRESS_MIRROR\n", type);
1978                     } else {
1979                         FIXME(" Stage type is : %s => D3DTADDRESS_MIRROR - not supported by GL !\n", type);
1980                     }
1981                     break;
1982                 default: FIXME(" Unhandled stage type : %s => %08lx\n", type, dwState); break;
1983             }
1984         } break;
1985
1986         case D3DTSS_ALPHAOP:
1987         case D3DTSS_COLOROP: {
1988             int scale = 1;
1989             GLenum parm = (d3dTexStageStateType == D3DTSS_ALPHAOP) ? GL_COMBINE_ALPHA_EXT : GL_COMBINE_RGB_EXT;
1990             const char *value;
1991             int handled = 1;
1992
1993             switch (dwState) {
1994 #define GEN_CASE(a) case a: value = #a; break
1995                 GEN_CASE(D3DTOP_DISABLE);
1996                 GEN_CASE(D3DTOP_SELECTARG1);
1997                 GEN_CASE(D3DTOP_SELECTARG2);
1998                 GEN_CASE(D3DTOP_MODULATE);
1999                 GEN_CASE(D3DTOP_MODULATE2X);
2000                 GEN_CASE(D3DTOP_MODULATE4X);
2001                 GEN_CASE(D3DTOP_ADD);
2002                 GEN_CASE(D3DTOP_ADDSIGNED);
2003                 GEN_CASE(D3DTOP_ADDSIGNED2X);
2004                 GEN_CASE(D3DTOP_SUBTRACT);
2005                 GEN_CASE(D3DTOP_ADDSMOOTH);
2006                 GEN_CASE(D3DTOP_BLENDDIFFUSEALPHA);
2007                 GEN_CASE(D3DTOP_BLENDTEXTUREALPHA);
2008                 GEN_CASE(D3DTOP_BLENDFACTORALPHA);
2009                 GEN_CASE(D3DTOP_BLENDTEXTUREALPHAPM);
2010                 GEN_CASE(D3DTOP_BLENDCURRENTALPHA);
2011                 GEN_CASE(D3DTOP_PREMODULATE);
2012                 GEN_CASE(D3DTOP_MODULATEALPHA_ADDCOLOR);
2013                 GEN_CASE(D3DTOP_MODULATECOLOR_ADDALPHA);
2014                 GEN_CASE(D3DTOP_MODULATEINVALPHA_ADDCOLOR);
2015                 GEN_CASE(D3DTOP_MODULATEINVCOLOR_ADDALPHA);
2016                 GEN_CASE(D3DTOP_BUMPENVMAP);
2017                 GEN_CASE(D3DTOP_BUMPENVMAPLUMINANCE);
2018                 GEN_CASE(D3DTOP_DOTPRODUCT3);
2019                 GEN_CASE(D3DTOP_FORCE_DWORD);
2020 #undef GEN_CASE
2021                 default: value = "UNKNOWN";
2022             }
2023
2024             if ((d3dTexStageStateType == D3DTSS_COLOROP) && (dwState == D3DTOP_DISABLE)) {
2025                 glDisable(GL_TEXTURE_2D);
2026                 TRACE(" disabling 2D texturing.\n");
2027             } else {
2028                 /* Re-enable texturing only if COLOROP was not already disabled... */
2029                 if ((glThis->current_bound_texture[dwStage] != NULL) &&
2030                     (This->state_block.texture_stage_state[dwStage][D3DTSS_COLOROP - 1] != D3DTOP_DISABLE)) {
2031                     glEnable(GL_TEXTURE_2D);
2032                     TRACE(" enabling 2D texturing.\n");
2033                 }
2034
2035                 /* Re-Enable GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT */
2036                 if ((dwState != D3DTOP_DISABLE) &&
2037                     (This->state_block.texture_stage_state[dwStage][D3DTSS_COLOROP - 1] != D3DTOP_DISABLE)) {
2038                     if (glThis->current_tex_env != GL_COMBINE_EXT) {
2039                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
2040                         glThis->current_tex_env = GL_COMBINE_EXT;
2041                     }
2042                 }
2043
2044                 /* Now set up the operand correctly */
2045                 switch (dwState) {
2046                     case D3DTOP_DISABLE:
2047                         /* Contrary to the docs, alpha can be disabled when colorop is enabled
2048                            and it works, so ignore this op */
2049                         TRACE(" Note : disable ALPHAOP but COLOROP enabled!\n");
2050                         break;
2051
2052                     case D3DTOP_SELECTARG1:
2053                     case D3DTOP_SELECTARG2:
2054                         glTexEnvi(GL_TEXTURE_ENV, parm, GL_REPLACE);
2055                         break;
2056
2057                     case D3DTOP_MODULATE4X:
2058                         scale = scale * 2;  /* Drop through */
2059                     case D3DTOP_MODULATE2X:
2060                         scale = scale * 2;  /* Drop through */
2061                     case D3DTOP_MODULATE:
2062                         glTexEnvi(GL_TEXTURE_ENV, parm, GL_MODULATE);
2063                         break;
2064
2065                     case D3DTOP_ADD:
2066                         glTexEnvi(GL_TEXTURE_ENV, parm, GL_ADD);
2067                         break;
2068
2069                     case D3DTOP_ADDSIGNED2X:
2070                         scale = scale * 2;  /* Drop through */
2071                     case D3DTOP_ADDSIGNED:
2072                         glTexEnvi(GL_TEXTURE_ENV, parm, GL_ADD_SIGNED_EXT);
2073                         break;
2074
2075                         /* For the four blending modes, use the Arg2 parameter */
2076                     case D3DTOP_BLENDDIFFUSEALPHA:
2077                     case D3DTOP_BLENDTEXTUREALPHA:
2078                     case D3DTOP_BLENDFACTORALPHA:
2079                     case D3DTOP_BLENDCURRENTALPHA: {
2080                         GLenum src = GL_PRIMARY_COLOR_EXT; /* Just to prevent a compiler warning.. */
2081
2082                         switch (dwState) {
2083                             case D3DTOP_BLENDDIFFUSEALPHA: src = GL_PRIMARY_COLOR_EXT;
2084                             case D3DTOP_BLENDTEXTUREALPHA: src = GL_TEXTURE;
2085                             case D3DTOP_BLENDFACTORALPHA:  src = GL_CONSTANT_EXT;
2086                             case D3DTOP_BLENDCURRENTALPHA: src = GL_PREVIOUS_EXT;
2087                         }
2088
2089                         glTexEnvi(GL_TEXTURE_ENV, parm, GL_INTERPOLATE_EXT);
2090                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, src);
2091                         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_ALPHA);
2092                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, src);
2093                         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_ALPHA);
2094                     } break;
2095
2096                     default:
2097                         handled = FALSE;
2098                         break;
2099                 }
2100             }
2101
2102             if (((prev_state == D3DTOP_SELECTARG2) && (dwState != D3DTOP_SELECTARG2)) ||
2103                 ((dwState == D3DTOP_SELECTARG2) && (prev_state != D3DTOP_SELECTARG2))) {
2104                 /* Switch the arguments if needed... */
2105                 if (d3dTexStageStateType == D3DTSS_COLOROP) {
2106                     handle_color_alpha_args(This, dwStage, D3DTSS_COLORARG1,
2107                                             This->state_block.texture_stage_state[dwStage][D3DTSS_COLORARG1 - 1],
2108                                             dwState);
2109                     handle_color_alpha_args(This, dwStage, D3DTSS_COLORARG2,
2110                                             This->state_block.texture_stage_state[dwStage][D3DTSS_COLORARG2 - 1],
2111                                             dwState);
2112                 } else {
2113                     handle_color_alpha_args(This, dwStage, D3DTSS_ALPHAARG1,
2114                                             This->state_block.texture_stage_state[dwStage][D3DTSS_ALPHAARG1 - 1],
2115                                             dwState);
2116                     handle_color_alpha_args(This, dwStage, D3DTSS_ALPHAARG2,
2117                                             This->state_block.texture_stage_state[dwStage][D3DTSS_ALPHAARG2 - 1],
2118                                             dwState);
2119                 }
2120             }
2121
2122             if (handled) {
2123                 if (d3dTexStageStateType == D3DTSS_ALPHAOP) {
2124                     glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, scale);
2125                 } else {
2126                     glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, scale);
2127                 }
2128                 TRACE(" Stage type is : %s => %s\n", type, value);
2129             } else {
2130                 FIXME(" Unhandled stage type is : %s => %s\n", type, value);
2131             }
2132         } break;
2133
2134         case D3DTSS_COLORARG1:
2135         case D3DTSS_COLORARG2:
2136         case D3DTSS_ALPHAARG1:
2137         case D3DTSS_ALPHAARG2: {
2138             const char *value, *value_comp = "", *value_alpha = "";
2139             BOOLEAN handled;
2140             D3DTEXTUREOP tex_op;
2141
2142             switch (dwState & D3DTA_SELECTMASK) {
2143 #define GEN_CASE(a) case a: value = #a; break
2144                 GEN_CASE(D3DTA_DIFFUSE);
2145                 GEN_CASE(D3DTA_CURRENT);
2146                 GEN_CASE(D3DTA_TEXTURE);
2147                 GEN_CASE(D3DTA_TFACTOR);
2148                 GEN_CASE(D3DTA_SPECULAR);
2149 #undef GEN_CASE
2150                 default: value = "UNKNOWN";
2151             }
2152             if (dwState & D3DTA_COMPLEMENT) {
2153                 value_comp = " | D3DTA_COMPLEMENT";
2154             }
2155             if (dwState & D3DTA_ALPHAREPLICATE) {
2156                 value_alpha = " | D3DTA_ALPHAREPLICATE";
2157             }
2158
2159             if ((d3dTexStageStateType == D3DTSS_COLORARG1) || (d3dTexStageStateType == D3DTSS_COLORARG2)) {
2160                 tex_op = This->state_block.texture_stage_state[dwStage][D3DTSS_COLOROP - 1];
2161             } else {
2162                 tex_op = This->state_block.texture_stage_state[dwStage][D3DTSS_ALPHAOP - 1];
2163             }
2164
2165             handled = handle_color_alpha_args(This, dwStage, d3dTexStageStateType, dwState, tex_op);
2166
2167             if (handled) {
2168                 TRACE(" Stage type : %s => %s%s%s\n", type, value, value_comp, value_alpha);
2169             } else {
2170                 FIXME(" Unhandled stage type : %s => %s%s%s\n", type, value, value_comp, value_alpha);
2171             }
2172         } break;
2173
2174         case D3DTSS_MIPMAPLODBIAS: {
2175             D3DVALUE value = *((D3DVALUE *) &dwState);
2176             BOOLEAN handled = TRUE;
2177
2178             if ((value != 0.0) && (GL_extensions.mipmap_lodbias == FALSE))
2179                 handled = FALSE;
2180
2181             if (handled) {
2182                 TRACE(" Stage type : D3DTSS_MIPMAPLODBIAS => %f\n", value);
2183                 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_WINE, GL_TEXTURE_LOD_BIAS_WINE, value);
2184             } else {
2185                 FIXME(" Unhandled stage type : D3DTSS_MIPMAPLODBIAS => %f\n", value);
2186             }
2187         } break;
2188
2189         case D3DTSS_MAXMIPLEVEL:
2190             TRACE(" Stage type : D3DTSS_MAXMIPLEVEL => %ld\n", dwState);
2191             break;
2192
2193         case D3DTSS_BORDERCOLOR:
2194             TRACE(" Stage type : D3DTSS_BORDERCOLOR => %02lx %02lx %02lx %02lx (RGBA)\n",
2195                   ((dwState >> 16) & 0xFF),
2196                   ((dwState >>  8) & 0xFF),
2197                   ((dwState >>  0) & 0xFF),
2198                   ((dwState >> 24) & 0xFF));
2199             break;
2200
2201         case D3DTSS_TEXCOORDINDEX: {
2202             BOOLEAN handled = TRUE;
2203             const char *value;
2204
2205             switch (dwState & 0xFFFF0000) {
2206 #define GEN_CASE(a) case a: value = #a; break
2207                 GEN_CASE(D3DTSS_TCI_PASSTHRU);
2208                 GEN_CASE(D3DTSS_TCI_CAMERASPACENORMAL);
2209                 GEN_CASE(D3DTSS_TCI_CAMERASPACEPOSITION);
2210                 GEN_CASE(D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
2211 #undef GEN_CASE
2212                 default: value = "UNKNOWN";
2213             }
2214             if ((dwState & 0xFFFF0000) != D3DTSS_TCI_PASSTHRU)
2215                 handled = FALSE;
2216
2217             if (handled) {
2218                 TRACE(" Stage type : D3DTSS_TEXCOORDINDEX => %ld | %s\n", dwState & 0x0000FFFF, value);
2219             } else {
2220                 FIXME(" Unhandled stage type : D3DTSS_TEXCOORDINDEX => %ld | %s\n", dwState & 0x0000FFFF, value);
2221             }
2222         } break;
2223
2224         case D3DTSS_TEXTURETRANSFORMFLAGS: {
2225             const char *projected = "", *value;
2226             BOOLEAN handled = TRUE;
2227             switch (dwState & 0xFF) {
2228 #define GEN_CASE(a) case a: value = #a; break
2229                 GEN_CASE(D3DTTFF_DISABLE);
2230                 GEN_CASE(D3DTTFF_COUNT1);
2231                 GEN_CASE(D3DTTFF_COUNT2);
2232                 GEN_CASE(D3DTTFF_COUNT3);
2233                 GEN_CASE(D3DTTFF_COUNT4);
2234 #undef GEN_CASE
2235                 default: value = "UNKNOWN";
2236             }
2237             if (dwState & D3DTTFF_PROJECTED) {
2238                 projected = " | D3DTTFF_PROJECTED";
2239                 handled = FALSE;
2240             }
2241
2242             if ((dwState & 0xFF) != D3DTTFF_DISABLE) {
2243                 This->matrices_updated(This, TEXMAT0_CHANGED << dwStage);
2244             }
2245
2246             if (handled) {
2247                 TRACE(" Stage type : D3DTSS_TEXTURETRANSFORMFLAGS => %s%s\n", value, projected);
2248             } else {
2249                 FIXME(" Unhandled stage type : D3DTSS_TEXTURETRANSFORMFLAGS => %s%s\n", value, projected);
2250             }
2251         } break;
2252
2253         default:
2254             FIXME(" Unhandled stage type : %s => %08lx\n", type, dwState);
2255             break;
2256     }
2257
2258     LEAVE_GL();
2259
2260     return DD_OK;
2261 }
2262
2263 static DWORD
2264 draw_primitive_handle_textures(IDirect3DDeviceImpl *This)
2265 {
2266     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
2267     DWORD stage;
2268     BOOLEAN enable_colorkey = FALSE;
2269
2270     for (stage = 0; stage < MAX_TEXTURES; stage++) {
2271         IDirectDrawSurfaceImpl *surf_ptr = This->current_texture[stage];
2272         GLenum unit;
2273
2274         /* If this stage is disabled, no need to go further... */
2275         if (This->state_block.texture_stage_state[stage][D3DTSS_COLOROP - 1] == D3DTOP_DISABLE)
2276             break;
2277
2278         /* First check if we need to bind any other texture for this stage */
2279         if (This->current_texture[stage] != glThis->current_bound_texture[stage]) {
2280             if (This->current_texture[stage] == NULL) {
2281                 TRACE(" disabling 2D texturing for stage %ld.\n", stage);
2282
2283                 unit = GL_TEXTURE0_WINE + stage;
2284                 if (unit != glThis->current_active_tex_unit) {
2285                     GL_extensions.glActiveTexture(unit);
2286                     glThis->current_active_tex_unit = unit;
2287                 }
2288                 glBindTexture(GL_TEXTURE_2D, 0);
2289                 glDisable(GL_TEXTURE_2D);
2290             } else {
2291                 GLenum tex_name = gltex_get_tex_name(surf_ptr);
2292
2293                 unit = GL_TEXTURE0_WINE + stage;
2294                 if (unit != glThis->current_active_tex_unit) {
2295                     GL_extensions.glActiveTexture(unit);
2296                     glThis->current_active_tex_unit = unit;
2297                 }
2298
2299                 if (glThis->current_bound_texture[stage] == NULL) {
2300                     if (This->state_block.texture_stage_state[stage][D3DTSS_COLOROP - 1] != D3DTOP_DISABLE) {
2301                         TRACE(" enabling 2D texturing and");
2302                         glEnable(GL_TEXTURE_2D);
2303                     }
2304                 }
2305                 TRACE(" activating OpenGL texture id %d for stage %ld.\n", tex_name, stage);
2306                 glBindTexture(GL_TEXTURE_2D, tex_name);
2307             }
2308
2309             glThis->current_bound_texture[stage] = This->current_texture[stage];
2310         } else {
2311             if (glThis->current_bound_texture[stage] == NULL) {
2312                 TRACE(" displaying without texturing activated for stage %ld.\n", stage);
2313             } else {
2314                 TRACE(" using already bound texture id %d for stage %ld.\n",
2315                       ((IDirect3DTextureGLImpl *) (glThis->current_bound_texture[stage])->tex_private)->tex_name, stage);
2316             }
2317         }
2318
2319         /* If no texure valid for this stage, go out of the loop */
2320         if (This->current_texture[stage] == NULL) break;
2321
2322         /* Then check if we need to flush this texture to GL or not (ie did it change) ?.
2323            This will also update the various texture parameters if needed.
2324         */
2325         gltex_upload_texture(surf_ptr, This, stage);
2326
2327         /* And finally check for color-keying (only on first stage) */
2328         if (This->current_texture[stage]->surface_desc.dwFlags & DDSD_CKSRCBLT) {
2329             if (stage == 0) {
2330                 enable_colorkey = TRUE;
2331             } else {
2332                 static BOOL warn = FALSE;
2333                 if (warn == FALSE) {
2334                     warn = TRUE;
2335                     WARN(" Surface has color keying on stage different from 0 (%ld) !", stage);
2336                 }
2337             }
2338         } else {
2339             if (stage == 0) {
2340                 enable_colorkey = FALSE;
2341             }
2342         }
2343     }
2344
2345     /* Apparently, whatever the state of BLEND, color keying is always activated for 'old' D3D versions */
2346     if (((This->state_block.render_state[D3DRENDERSTATE_COLORKEYENABLE - 1]) ||
2347          (glThis->parent.version == 1)) &&
2348         (enable_colorkey)) {
2349         TRACE(" colorkey activated.\n");
2350
2351         if (glThis->alpha_test == FALSE) {
2352             glEnable(GL_ALPHA_TEST);
2353             glThis->alpha_test = TRUE;
2354         }
2355         if ((glThis->current_alpha_test_func != GL_NOTEQUAL) || (glThis->current_alpha_test_ref != 0.0)) {
2356             if (This->state_block.render_state[D3DRENDERSTATE_ALPHATESTENABLE - 1]) {
2357                 static BOOL warn = FALSE;
2358                 if (warn == FALSE) {
2359                     warn = TRUE;
2360                     WARN(" Overriding application-given alpha test values - some graphical glitches may appear !\n");
2361                 }
2362             }
2363             glThis->current_alpha_test_func = GL_NOTEQUAL;
2364             glThis->current_alpha_test_ref = 0.0;
2365             glAlphaFunc(GL_NOTEQUAL, 0.0);
2366         }
2367         /* Some sanity checks should be added here if a game mixes alphatest + color keying...
2368            Only one has been found for now, and the ALPHAFUNC is 'Always' so it works :-) */
2369     } else {
2370         if (This->state_block.render_state[D3DRENDERSTATE_ALPHATESTENABLE - 1] == FALSE) {
2371             glDisable(GL_ALPHA_TEST);
2372             glThis->alpha_test = FALSE;
2373         }
2374         /* Maybe we should restore here the application-given alpha test states ? */
2375     }
2376
2377     return stage;
2378 }
2379
2380 HRESULT WINAPI
2381 GL_IDirect3DDeviceImpl_7_3T_SetTexture(LPDIRECT3DDEVICE7 iface,
2382                                        DWORD dwStage,
2383                                        LPDIRECTDRAWSURFACE7 lpTexture2)
2384 {
2385     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2386
2387     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwStage, lpTexture2);
2388
2389     if (((GL_extensions.max_texture_units == 0) && (dwStage > 0)) ||
2390         ((GL_extensions.max_texture_units != 0) && (dwStage >= GL_extensions.max_texture_units))) {
2391         if (lpTexture2 != NULL) {
2392             WARN(" setting a texture to a non-supported texture stage !\n");
2393         }
2394         return DD_OK;
2395     }
2396
2397     if (This->current_texture[dwStage] != NULL) {
2398         IDirectDrawSurface7_Release(ICOM_INTERFACE(This->current_texture[dwStage], IDirectDrawSurface7));
2399     }
2400
2401     if (lpTexture2 == NULL) {
2402         This->current_texture[dwStage] = NULL;
2403     } else {
2404         IDirectDrawSurfaceImpl *tex_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, lpTexture2);
2405         IDirectDrawSurface7_AddRef(ICOM_INTERFACE(tex_impl, IDirectDrawSurface7));
2406         This->current_texture[dwStage] = tex_impl;
2407     }
2408
2409     return DD_OK;
2410 }
2411
2412 static HRESULT WINAPI
2413 GL_IDirect3DDeviceImpl_7_GetCaps(LPDIRECT3DDEVICE7 iface,
2414                                  LPD3DDEVICEDESC7 lpD3DHELDevDesc)
2415 {
2416     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2417     TRACE("(%p/%p)->(%p)\n", This, iface, lpD3DHELDevDesc);
2418
2419     fill_opengl_caps_7(lpD3DHELDevDesc);
2420
2421     TRACE(" returning caps : no dump function yet.\n");
2422
2423     return DD_OK;
2424 }
2425
2426 HRESULT WINAPI
2427 GL_IDirect3DDeviceImpl_7_SetMaterial(LPDIRECT3DDEVICE7 iface,
2428                                      LPD3DMATERIAL7 lpMat)
2429 {
2430     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2431     TRACE("(%p/%p)->(%p)\n", This, iface, lpMat);
2432
2433     if (TRACE_ON(ddraw)) {
2434         TRACE(" material is :\n");
2435         dump_D3DMATERIAL7(lpMat);
2436     }
2437
2438     This->current_material = *lpMat;
2439
2440     ENTER_GL();
2441     glMaterialfv(GL_FRONT_AND_BACK,
2442                  GL_DIFFUSE,
2443                  (float *) &(This->current_material.u.diffuse));
2444     glMaterialfv(GL_FRONT_AND_BACK,
2445                  GL_AMBIENT,
2446                  (float *) &(This->current_material.u1.ambient));
2447     glMaterialfv(GL_FRONT_AND_BACK,
2448                  GL_SPECULAR,
2449                  (float *) &(This->current_material.u2.specular));
2450     glMaterialfv(GL_FRONT_AND_BACK,
2451                  GL_EMISSION,
2452                  (float *) &(This->current_material.u3.emissive));
2453     glMaterialf(GL_FRONT_AND_BACK,
2454                 GL_SHININESS,
2455                 This->current_material.u4.power); /* Not sure about this... */
2456     LEAVE_GL();
2457
2458     return DD_OK;
2459 }
2460
2461 static LPD3DLIGHT7 get_light(IDirect3DDeviceImpl *This, DWORD dwLightIndex)
2462 {
2463     if (dwLightIndex >= This->num_set_lights)
2464     {
2465         /* Extend, or allocate the light parameters array. */
2466         DWORD newlightnum = dwLightIndex + 1;
2467         LPD3DLIGHT7 newarrayptr = NULL;
2468
2469         if (This->light_parameters)
2470             newarrayptr = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2471                 This->light_parameters, newlightnum * sizeof(D3DLIGHT7));
2472         else
2473             newarrayptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2474                 newlightnum * sizeof(D3DLIGHT7));
2475
2476         if (!newarrayptr)
2477             return NULL;
2478
2479         This->light_parameters = newarrayptr;
2480         This->num_set_lights = newlightnum;
2481     }
2482
2483     return &This->light_parameters[dwLightIndex];
2484 }
2485
2486 HRESULT WINAPI
2487 GL_IDirect3DDeviceImpl_7_SetLight(LPDIRECT3DDEVICE7 iface,
2488                                   DWORD dwLightIndex,
2489                                   LPD3DLIGHT7 lpLight)
2490 {
2491     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2492     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
2493     LPD3DLIGHT7 lpdestlight = get_light( This, dwLightIndex );
2494
2495     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwLightIndex, lpLight);
2496
2497     if (TRACE_ON(ddraw)) {
2498         TRACE(" setting light :\n");
2499         dump_D3DLIGHT7(lpLight);
2500     }
2501
2502     /* DirectX7 documentation states that this function can return
2503        DDERR_OUTOFMEMORY, so we do just that in case of an allocation
2504        error (which is the only reason why get_light() can fail). */
2505     if( !lpdestlight )
2506         return DDERR_OUTOFMEMORY;
2507
2508     *lpdestlight = *lpLight;
2509
2510     /* Some checks to print out nice warnings :-) */
2511     switch (lpLight->dltType) {
2512         case D3DLIGHT_DIRECTIONAL:
2513         case D3DLIGHT_POINT:
2514             /* These are handled properly... */
2515             break;
2516
2517         case D3DLIGHT_SPOT:
2518             if ((lpLight->dvTheta != 0.0) ||
2519                 (lpLight->dvTheta != lpLight->dvPhi)) {
2520                 ERR("dvTheta not fully supported yet !\n");
2521             }
2522             break;
2523
2524         default:
2525             ERR("Light type not handled yet : %08x !\n", lpLight->dltType);
2526     }
2527
2528     /* This will force the Light setting on next drawing of primitives */
2529     glThis->transform_state = GL_TRANSFORM_NONE;
2530
2531     return DD_OK;
2532 }
2533
2534 HRESULT WINAPI
2535 GL_IDirect3DDeviceImpl_7_LightEnable(LPDIRECT3DDEVICE7 iface,
2536                                      DWORD dwLightIndex,
2537                                      BOOL bEnable)
2538 {
2539     int lightslot = -1, i;
2540     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2541     LPD3DLIGHT7 lpdestlight = get_light(This, dwLightIndex);
2542
2543     TRACE("(%p/%p)->(%08lx,%d)\n", This, iface, dwLightIndex, bEnable);
2544
2545     /* The DirectX doc isn't as explicit as for SetLight as whether we can
2546        return this from this function, but it doesn't state otherwise. */
2547     if (!lpdestlight)
2548         return DDERR_OUTOFMEMORY;
2549
2550     /* If this light hasn't been set, initialise it with default values. */
2551     if (lpdestlight->dltType == 0)
2552     {
2553         TRACE("setting default light parameters\n");
2554
2555         /* We always use HEAP_ZERO_MEMORY when allocating the light_parameters
2556            array, so we only have to setup anything that shoud not be zero. */
2557         lpdestlight->dltType = D3DLIGHT_DIRECTIONAL;
2558         lpdestlight->dcvDiffuse.u1.r = 1.f;
2559         lpdestlight->dcvDiffuse.u2.g = 1.f;
2560         lpdestlight->dcvDiffuse.u3.b = 1.f;
2561         lpdestlight->dvDirection.u3.z = 1.f;
2562     }
2563
2564     /* Look for this light in the active lights array. */
2565     for (i = 0; i < This->max_active_lights; i++)
2566         if (This->active_lights[i] == dwLightIndex)
2567         {
2568             lightslot = i;
2569             break;
2570         }
2571
2572     /* If we didn't find it, let's find the first available slot, if any. */
2573     if (lightslot == -1)
2574         for (i = 0; i < This->max_active_lights; i++)
2575             if (This->active_lights[i] == ~0)
2576             {
2577                 lightslot = i;
2578                 break;
2579             }
2580
2581     ENTER_GL();
2582     if (bEnable) {
2583         if (lightslot == -1)
2584         {
2585             /* This means that the app is trying to enable more lights than
2586                the maximum possible indicated in the caps.
2587
2588                Windows actually let you do this, and disable one of the
2589                previously enabled lights to let you enable this one.
2590
2591                It's not documented and I'm not sure how windows pick which light
2592                to disable to make room for this one. */
2593             FIXME("Enabling more light than the maximum is not supported yet.");
2594             return D3D_OK;
2595         }
2596
2597         glEnable(GL_LIGHT0 + lightslot);
2598
2599
2600         if (This->active_lights[lightslot] == ~0)
2601         {
2602             /* This light gets active... Need to update its parameters to GL before the next drawing */
2603             IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
2604
2605             This->active_lights[lightslot] = dwLightIndex;
2606             glThis->transform_state = GL_TRANSFORM_NONE;
2607         }
2608     } else {
2609         glDisable(GL_LIGHT0 + lightslot);
2610         This->active_lights[lightslot] = ~0;
2611     }
2612
2613     LEAVE_GL();
2614     return DD_OK;
2615 }
2616
2617 HRESULT  WINAPI
2618 GL_IDirect3DDeviceImpl_7_SetClipPlane(LPDIRECT3DDEVICE7 iface, DWORD dwIndex, CONST D3DVALUE* pPlaneEquation)
2619 {
2620     IDirect3DDeviceImpl *This = (IDirect3DDeviceImpl *)iface;
2621     IDirect3DDeviceGLImpl* glThis = (IDirect3DDeviceGLImpl*) This;
2622
2623     TRACE("(%p)->(%ld,%p)\n", This, dwIndex, pPlaneEquation);
2624
2625     if (dwIndex >= This->max_clipping_planes) {
2626         return DDERR_INVALIDPARAMS;
2627     }
2628
2629     TRACE(" clip plane %ld : %f %f %f %f\n", dwIndex, pPlaneEquation[0], pPlaneEquation[1], pPlaneEquation[2], pPlaneEquation[3] );
2630
2631     memcpy(This->clipping_planes[dwIndex].plane, pPlaneEquation, sizeof(D3DVALUE[4]));
2632
2633     /* This is to force the reset of the transformation matrices on the next drawing.
2634      * This is needed to use the correct matrices for the various clipping planes.
2635      */
2636     glThis->transform_state = GL_TRANSFORM_NONE;
2637
2638     return D3D_OK;
2639 }
2640
2641 static HRESULT WINAPI
2642 GL_IDirect3DDeviceImpl_7_SetViewport(LPDIRECT3DDEVICE7 iface,
2643                                      LPD3DVIEWPORT7 lpData)
2644 {
2645     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2646     TRACE("(%p/%p)->(%p)\n", This, iface, lpData);
2647
2648     if (TRACE_ON(ddraw)) {
2649         TRACE(" viewport is :\n");
2650         TRACE("    - dwX = %ld   dwY = %ld\n",
2651               lpData->dwX, lpData->dwY);
2652         TRACE("    - dwWidth = %ld   dwHeight = %ld\n",
2653               lpData->dwWidth, lpData->dwHeight);
2654         TRACE("    - dvMinZ = %f   dvMaxZ = %f\n",
2655               lpData->dvMinZ, lpData->dvMaxZ);
2656     }
2657     ENTER_GL();
2658
2659     /* Set the viewport */
2660     if ((lpData->dvMinZ != This->active_viewport.dvMinZ) ||
2661         (lpData->dvMaxZ != This->active_viewport.dvMaxZ)) {
2662         glDepthRange(lpData->dvMinZ, lpData->dvMaxZ);
2663     }
2664     if ((lpData->dwX != This->active_viewport.dwX) ||
2665         (lpData->dwY != This->active_viewport.dwY) ||
2666         (lpData->dwWidth != This->active_viewport.dwWidth) ||
2667         (lpData->dwHeight != This->active_viewport.dwHeight)) {
2668         glViewport(lpData->dwX,
2669                    This->surface->surface_desc.dwHeight - (lpData->dwHeight + lpData->dwY),
2670                    lpData->dwWidth, lpData->dwHeight);
2671     }
2672
2673     LEAVE_GL();
2674
2675     This->active_viewport = *lpData;
2676
2677     return DD_OK;
2678 }
2679
2680 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2681 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice7.fun))
2682 #else
2683 # define XCAST(fun)     (void*)
2684 #endif
2685
2686 static const IDirect3DDevice7Vtbl VTABLE_IDirect3DDevice7 =
2687 {
2688     XCAST(QueryInterface) Main_IDirect3DDeviceImpl_7_3T_2T_1T_QueryInterface,
2689     XCAST(AddRef) Main_IDirect3DDeviceImpl_7_3T_2T_1T_AddRef,
2690     XCAST(Release) GL_IDirect3DDeviceImpl_7_3T_2T_1T_Release,
2691     XCAST(GetCaps) GL_IDirect3DDeviceImpl_7_GetCaps,
2692     XCAST(EnumTextureFormats) GL_IDirect3DDeviceImpl_7_3T_EnumTextureFormats,
2693     XCAST(BeginScene) Main_IDirect3DDeviceImpl_7_3T_2T_1T_BeginScene,
2694     XCAST(EndScene) Main_IDirect3DDeviceImpl_7_3T_2T_1T_EndScene,
2695     XCAST(GetDirect3D) Main_IDirect3DDeviceImpl_7_3T_2T_1T_GetDirect3D,
2696     XCAST(SetRenderTarget) Main_IDirect3DDeviceImpl_7_3T_2T_SetRenderTarget,
2697     XCAST(GetRenderTarget) Main_IDirect3DDeviceImpl_7_3T_2T_GetRenderTarget,
2698     XCAST(Clear) Main_IDirect3DDeviceImpl_7_Clear,
2699     XCAST(SetTransform) Main_IDirect3DDeviceImpl_7_3T_2T_SetTransform,
2700     XCAST(GetTransform) Main_IDirect3DDeviceImpl_7_3T_2T_GetTransform,
2701     XCAST(SetViewport) GL_IDirect3DDeviceImpl_7_SetViewport,
2702     XCAST(MultiplyTransform) Main_IDirect3DDeviceImpl_7_3T_2T_MultiplyTransform,
2703     XCAST(GetViewport) Main_IDirect3DDeviceImpl_7_GetViewport,
2704     XCAST(SetMaterial) GL_IDirect3DDeviceImpl_7_SetMaterial,
2705     XCAST(GetMaterial) Main_IDirect3DDeviceImpl_7_GetMaterial,
2706     XCAST(SetLight) GL_IDirect3DDeviceImpl_7_SetLight,
2707     XCAST(GetLight) Main_IDirect3DDeviceImpl_7_GetLight,
2708     XCAST(SetRenderState) GL_IDirect3DDeviceImpl_7_3T_2T_SetRenderState,
2709     XCAST(GetRenderState) GL_IDirect3DDeviceImpl_7_3T_2T_GetRenderState,
2710     XCAST(BeginStateBlock) Main_IDirect3DDeviceImpl_7_BeginStateBlock,
2711     XCAST(EndStateBlock) Main_IDirect3DDeviceImpl_7_EndStateBlock,
2712     XCAST(PreLoad) Main_IDirect3DDeviceImpl_7_PreLoad,
2713     XCAST(DrawPrimitive) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitive,
2714     XCAST(DrawIndexedPrimitive) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitive,
2715     XCAST(SetClipStatus) Main_IDirect3DDeviceImpl_7_3T_2T_SetClipStatus,
2716     XCAST(GetClipStatus) Main_IDirect3DDeviceImpl_7_3T_2T_GetClipStatus,
2717     XCAST(DrawPrimitiveStrided) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveStrided,
2718     XCAST(DrawIndexedPrimitiveStrided) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveStrided,
2719     XCAST(DrawPrimitiveVB) GL_IDirect3DDeviceImpl_7_3T_DrawPrimitiveVB,
2720     XCAST(DrawIndexedPrimitiveVB) GL_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB,
2721     XCAST(ComputeSphereVisibility) Main_IDirect3DDeviceImpl_7_3T_ComputeSphereVisibility,
2722     XCAST(GetTexture) Main_IDirect3DDeviceImpl_7_3T_GetTexture,
2723     XCAST(SetTexture) GL_IDirect3DDeviceImpl_7_3T_SetTexture,
2724     XCAST(GetTextureStageState) Main_IDirect3DDeviceImpl_7_3T_GetTextureStageState,
2725     XCAST(SetTextureStageState) GL_IDirect3DDeviceImpl_7_3T_SetTextureStageState,
2726     XCAST(ValidateDevice) Main_IDirect3DDeviceImpl_7_3T_ValidateDevice,
2727     XCAST(ApplyStateBlock) Main_IDirect3DDeviceImpl_7_ApplyStateBlock,
2728     XCAST(CaptureStateBlock) Main_IDirect3DDeviceImpl_7_CaptureStateBlock,
2729     XCAST(DeleteStateBlock) Main_IDirect3DDeviceImpl_7_DeleteStateBlock,
2730     XCAST(CreateStateBlock) Main_IDirect3DDeviceImpl_7_CreateStateBlock,
2731     XCAST(Load) Main_IDirect3DDeviceImpl_7_Load,
2732     XCAST(LightEnable) GL_IDirect3DDeviceImpl_7_LightEnable,
2733     XCAST(GetLightEnable) Main_IDirect3DDeviceImpl_7_GetLightEnable,
2734     XCAST(SetClipPlane) GL_IDirect3DDeviceImpl_7_SetClipPlane,
2735     XCAST(GetClipPlane) Main_IDirect3DDeviceImpl_7_GetClipPlane,
2736     XCAST(GetInfo) Main_IDirect3DDeviceImpl_7_GetInfo,
2737 };
2738
2739 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2740 #undef XCAST
2741 #endif
2742
2743
2744 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2745 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice3.fun))
2746 #else
2747 # define XCAST(fun)     (void*)
2748 #endif
2749
2750 static const IDirect3DDevice3Vtbl VTABLE_IDirect3DDevice3 =
2751 {
2752     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_3_QueryInterface,
2753     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_3_AddRef,
2754     XCAST(Release) Thunk_IDirect3DDeviceImpl_3_Release,
2755     XCAST(GetCaps) GL_IDirect3DDeviceImpl_3_2T_1T_GetCaps,
2756     XCAST(GetStats) Main_IDirect3DDeviceImpl_3_2T_1T_GetStats,
2757     XCAST(AddViewport) Main_IDirect3DDeviceImpl_3_2T_1T_AddViewport,
2758     XCAST(DeleteViewport) Main_IDirect3DDeviceImpl_3_2T_1T_DeleteViewport,
2759     XCAST(NextViewport) Main_IDirect3DDeviceImpl_3_2T_1T_NextViewport,
2760     XCAST(EnumTextureFormats) Thunk_IDirect3DDeviceImpl_3_EnumTextureFormats,
2761     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_3_BeginScene,
2762     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_3_EndScene,
2763     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_3_GetDirect3D,
2764     XCAST(SetCurrentViewport) Main_IDirect3DDeviceImpl_3_2T_SetCurrentViewport,
2765     XCAST(GetCurrentViewport) Main_IDirect3DDeviceImpl_3_2T_GetCurrentViewport,
2766     XCAST(SetRenderTarget) Thunk_IDirect3DDeviceImpl_3_SetRenderTarget,
2767     XCAST(GetRenderTarget) Thunk_IDirect3DDeviceImpl_3_GetRenderTarget,
2768     XCAST(Begin) Main_IDirect3DDeviceImpl_3_Begin,
2769     XCAST(BeginIndexed) Main_IDirect3DDeviceImpl_3_BeginIndexed,
2770     XCAST(Vertex) Main_IDirect3DDeviceImpl_3_2T_Vertex,
2771     XCAST(Index) Main_IDirect3DDeviceImpl_3_2T_Index,
2772     XCAST(End) Main_IDirect3DDeviceImpl_3_2T_End,
2773     XCAST(GetRenderState) Thunk_IDirect3DDeviceImpl_3_GetRenderState,
2774     XCAST(SetRenderState) Thunk_IDirect3DDeviceImpl_3_SetRenderState,
2775     XCAST(GetLightState) GL_IDirect3DDeviceImpl_3_2T_GetLightState,
2776     XCAST(SetLightState) GL_IDirect3DDeviceImpl_3_2T_SetLightState,
2777     XCAST(SetTransform) Thunk_IDirect3DDeviceImpl_3_SetTransform,
2778     XCAST(GetTransform) Thunk_IDirect3DDeviceImpl_3_GetTransform,
2779     XCAST(MultiplyTransform) Thunk_IDirect3DDeviceImpl_3_MultiplyTransform,
2780     XCAST(DrawPrimitive) Thunk_IDirect3DDeviceImpl_3_DrawPrimitive,
2781     XCAST(DrawIndexedPrimitive) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitive,
2782     XCAST(SetClipStatus) Thunk_IDirect3DDeviceImpl_3_SetClipStatus,
2783     XCAST(GetClipStatus) Thunk_IDirect3DDeviceImpl_3_GetClipStatus,
2784     XCAST(DrawPrimitiveStrided) Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveStrided,
2785     XCAST(DrawIndexedPrimitiveStrided) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveStrided,
2786     XCAST(DrawPrimitiveVB) Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveVB,
2787     XCAST(DrawIndexedPrimitiveVB) Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveVB,
2788     XCAST(ComputeSphereVisibility) Thunk_IDirect3DDeviceImpl_3_ComputeSphereVisibility,
2789     XCAST(GetTexture) Thunk_IDirect3DDeviceImpl_3_GetTexture,
2790     XCAST(SetTexture) Thunk_IDirect3DDeviceImpl_3_SetTexture,
2791     XCAST(GetTextureStageState) Thunk_IDirect3DDeviceImpl_3_GetTextureStageState,
2792     XCAST(SetTextureStageState) Thunk_IDirect3DDeviceImpl_3_SetTextureStageState,
2793     XCAST(ValidateDevice) Thunk_IDirect3DDeviceImpl_3_ValidateDevice,
2794 };
2795
2796 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2797 #undef XCAST
2798 #endif
2799
2800
2801 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2802 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice2.fun))
2803 #else
2804 # define XCAST(fun)     (void*)
2805 #endif
2806
2807 static const IDirect3DDevice2Vtbl VTABLE_IDirect3DDevice2 =
2808 {
2809     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_2_QueryInterface,
2810     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_2_AddRef,
2811     XCAST(Release) Thunk_IDirect3DDeviceImpl_2_Release,
2812     XCAST(GetCaps) Thunk_IDirect3DDeviceImpl_2_GetCaps,
2813     XCAST(SwapTextureHandles) Main_IDirect3DDeviceImpl_2_1T_SwapTextureHandles,
2814     XCAST(GetStats) Thunk_IDirect3DDeviceImpl_2_GetStats,
2815     XCAST(AddViewport) Thunk_IDirect3DDeviceImpl_2_AddViewport,
2816     XCAST(DeleteViewport) Thunk_IDirect3DDeviceImpl_2_DeleteViewport,
2817     XCAST(NextViewport) Thunk_IDirect3DDeviceImpl_2_NextViewport,
2818     XCAST(EnumTextureFormats) GL_IDirect3DDeviceImpl_2_1T_EnumTextureFormats,
2819     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_2_BeginScene,
2820     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_2_EndScene,
2821     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_2_GetDirect3D,
2822     XCAST(SetCurrentViewport) Thunk_IDirect3DDeviceImpl_2_SetCurrentViewport,
2823     XCAST(GetCurrentViewport) Thunk_IDirect3DDeviceImpl_2_GetCurrentViewport,
2824     XCAST(SetRenderTarget) Thunk_IDirect3DDeviceImpl_2_SetRenderTarget,
2825     XCAST(GetRenderTarget) Thunk_IDirect3DDeviceImpl_2_GetRenderTarget,
2826     XCAST(Begin) Main_IDirect3DDeviceImpl_2_Begin,
2827     XCAST(BeginIndexed) Main_IDirect3DDeviceImpl_2_BeginIndexed,
2828     XCAST(Vertex) Thunk_IDirect3DDeviceImpl_2_Vertex,
2829     XCAST(Index) Thunk_IDirect3DDeviceImpl_2_Index,
2830     XCAST(End) Thunk_IDirect3DDeviceImpl_2_End,
2831     XCAST(GetRenderState) Thunk_IDirect3DDeviceImpl_2_GetRenderState,
2832     XCAST(SetRenderState) Thunk_IDirect3DDeviceImpl_2_SetRenderState,
2833     XCAST(GetLightState) Thunk_IDirect3DDeviceImpl_2_GetLightState,
2834     XCAST(SetLightState) Thunk_IDirect3DDeviceImpl_2_SetLightState,
2835     XCAST(SetTransform) Thunk_IDirect3DDeviceImpl_2_SetTransform,
2836     XCAST(GetTransform) Thunk_IDirect3DDeviceImpl_2_GetTransform,
2837     XCAST(MultiplyTransform) Thunk_IDirect3DDeviceImpl_2_MultiplyTransform,
2838     XCAST(DrawPrimitive) GL_IDirect3DDeviceImpl_2_DrawPrimitive,
2839     XCAST(DrawIndexedPrimitive) GL_IDirect3DDeviceImpl_2_DrawIndexedPrimitive,
2840     XCAST(SetClipStatus) Thunk_IDirect3DDeviceImpl_2_SetClipStatus,
2841     XCAST(GetClipStatus) Thunk_IDirect3DDeviceImpl_2_GetClipStatus,
2842 };
2843
2844 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2845 #undef XCAST
2846 #endif
2847
2848
2849 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2850 # define XCAST(fun)     (typeof(VTABLE_IDirect3DDevice.fun))
2851 #else
2852 # define XCAST(fun)     (void*)
2853 #endif
2854
2855 static const IDirect3DDeviceVtbl VTABLE_IDirect3DDevice =
2856 {
2857     XCAST(QueryInterface) Thunk_IDirect3DDeviceImpl_1_QueryInterface,
2858     XCAST(AddRef) Thunk_IDirect3DDeviceImpl_1_AddRef,
2859     XCAST(Release) Thunk_IDirect3DDeviceImpl_1_Release,
2860     XCAST(Initialize) Main_IDirect3DDeviceImpl_1_Initialize,
2861     XCAST(GetCaps) Thunk_IDirect3DDeviceImpl_1_GetCaps,
2862     XCAST(SwapTextureHandles) Thunk_IDirect3DDeviceImpl_1_SwapTextureHandles,
2863     XCAST(CreateExecuteBuffer) GL_IDirect3DDeviceImpl_1_CreateExecuteBuffer,
2864     XCAST(GetStats) Thunk_IDirect3DDeviceImpl_1_GetStats,
2865     XCAST(Execute) Main_IDirect3DDeviceImpl_1_Execute,
2866     XCAST(AddViewport) Thunk_IDirect3DDeviceImpl_1_AddViewport,
2867     XCAST(DeleteViewport) Thunk_IDirect3DDeviceImpl_1_DeleteViewport,
2868     XCAST(NextViewport) Thunk_IDirect3DDeviceImpl_1_NextViewport,
2869     XCAST(Pick) Main_IDirect3DDeviceImpl_1_Pick,
2870     XCAST(GetPickRecords) Main_IDirect3DDeviceImpl_1_GetPickRecords,
2871     XCAST(EnumTextureFormats) Thunk_IDirect3DDeviceImpl_1_EnumTextureFormats,
2872     XCAST(CreateMatrix) Main_IDirect3DDeviceImpl_1_CreateMatrix,
2873     XCAST(SetMatrix) Main_IDirect3DDeviceImpl_1_SetMatrix,
2874     XCAST(GetMatrix) Main_IDirect3DDeviceImpl_1_GetMatrix,
2875     XCAST(DeleteMatrix) Main_IDirect3DDeviceImpl_1_DeleteMatrix,
2876     XCAST(BeginScene) Thunk_IDirect3DDeviceImpl_1_BeginScene,
2877     XCAST(EndScene) Thunk_IDirect3DDeviceImpl_1_EndScene,
2878     XCAST(GetDirect3D) Thunk_IDirect3DDeviceImpl_1_GetDirect3D,
2879 };
2880
2881 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
2882 #undef XCAST
2883 #endif
2884
2885 static HRESULT d3ddevice_clear(IDirect3DDeviceImpl *This,
2886                                WINE_GL_BUFFER_TYPE buffer_type,
2887                                DWORD dwCount,
2888                                LPD3DRECT lpRects,
2889                                DWORD dwFlags,
2890                                DWORD dwColor,
2891                                D3DVALUE dvZ,
2892                                DWORD dwStencil)
2893 {
2894     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
2895     GLbitfield bitfield = 0;
2896     D3DRECT rect;
2897     unsigned int i;
2898
2899     TRACE("(%p)->(%08lx,%p,%08lx,%08lx,%f,%08lx)\n", This, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil);
2900     if (TRACE_ON(ddraw)) {
2901         if (dwCount > 0) {
2902             unsigned int i;
2903             TRACE(" rectangles :\n");
2904             for (i = 0; i < dwCount; i++) {
2905                 TRACE("  - %ld x %ld     %ld x %ld\n", lpRects[i].u1.x1, lpRects[i].u2.y1, lpRects[i].u3.x2, lpRects[i].u4.y2);
2906             }
2907         }
2908     }
2909
2910     if (dwCount == 0) {
2911         dwCount = 1;
2912         rect.u1.x1 = 0;
2913         rect.u2.y1 = 0;
2914         rect.u3.x2 = This->surface->surface_desc.dwWidth;
2915         rect.u4.y2 = This->surface->surface_desc.dwHeight;
2916         lpRects = &rect;
2917     }
2918
2919     /* Clears the screen */
2920     ENTER_GL();
2921
2922     if (dwFlags & D3DCLEAR_TARGET) {
2923         if (glThis->state[buffer_type] == SURFACE_MEMORY_DIRTY) {
2924             /* TODO: optimize here the case where Clear changes all the screen... */
2925             This->flush_to_framebuffer(This, &(glThis->lock_rect[buffer_type]), glThis->lock_surf[buffer_type]);
2926         }
2927         glThis->state[buffer_type] = SURFACE_GL;
2928     }
2929
2930     if (dwFlags & D3DCLEAR_ZBUFFER) {
2931         bitfield |= GL_DEPTH_BUFFER_BIT;
2932         if (glThis->depth_mask == FALSE) {
2933             glDepthMask(GL_TRUE); /* Enables Z writing to be sure to delete also the Z buffer */
2934         }
2935         if (dvZ != glThis->prev_clear_Z) {
2936             glClearDepth(dvZ);
2937             glThis->prev_clear_Z = dvZ;
2938         }
2939         TRACE(" depth value : %f\n", dvZ);
2940     }
2941     if (dwFlags & D3DCLEAR_STENCIL) {
2942         bitfield |= GL_STENCIL_BUFFER_BIT;
2943         if (dwStencil != glThis->prev_clear_stencil) {
2944             glClearStencil(dwStencil);
2945             glThis->prev_clear_stencil = dwStencil;
2946         }
2947         TRACE(" stencil value : %ld\n", dwStencil);
2948     }
2949     if (dwFlags & D3DCLEAR_TARGET) {
2950         bitfield |= GL_COLOR_BUFFER_BIT;
2951         if (dwColor != glThis->prev_clear_color) {
2952             glClearColor(((dwColor >> 16) & 0xFF) / 255.0,
2953                          ((dwColor >>  8) & 0xFF) / 255.0,
2954                          ((dwColor >>  0) & 0xFF) / 255.0,
2955                          ((dwColor >> 24) & 0xFF) / 255.0);
2956             glThis->prev_clear_color = dwColor;
2957         }
2958         TRACE(" color value (ARGB) : %08lx\n", dwColor);
2959     }
2960
2961     glEnable(GL_SCISSOR_TEST);
2962     for (i = 0; i < dwCount; i++) {
2963         glScissor(lpRects[i].u1.x1, This->surface->surface_desc.dwHeight - lpRects[i].u4.y2,
2964                   lpRects[i].u3.x2 - lpRects[i].u1.x1, lpRects[i].u4.y2 - lpRects[i].u2.y1);
2965         glClear(bitfield);
2966     }
2967     glDisable(GL_SCISSOR_TEST);
2968
2969     if (dwFlags & D3DCLEAR_ZBUFFER) {
2970         if (glThis->depth_mask == FALSE) glDepthMask(GL_FALSE);
2971     }
2972
2973     LEAVE_GL();
2974
2975     return DD_OK;
2976 }
2977
2978 static HRESULT d3ddevice_clear_back(IDirect3DDeviceImpl *This,
2979                                     DWORD dwCount,
2980                                     LPD3DRECT lpRects,
2981                                     DWORD dwFlags,
2982                                     DWORD dwColor,
2983                                     D3DVALUE dvZ,
2984                                     DWORD dwStencil)
2985 {
2986     return d3ddevice_clear(This, WINE_GL_BUFFER_BACK, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil);
2987 }
2988
2989 static HRESULT
2990 setup_rect_and_surface_for_blt(IDirectDrawSurfaceImpl *This,
2991                                WINE_GL_BUFFER_TYPE *buffer_type_p, D3DRECT *rect)
2992 {
2993     IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice;
2994     WINE_GL_BUFFER_TYPE buffer_type;
2995
2996     /* First check if we BLT to the backbuffer... */
2997     if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) != 0) {
2998         buffer_type = WINE_GL_BUFFER_BACK;
2999     } else if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
3000         buffer_type = WINE_GL_BUFFER_FRONT;
3001     } else {
3002         ERR("Only BLT override to front or back-buffer is supported for now !\n");
3003         return DDERR_INVALIDPARAMS;
3004     }
3005
3006     if ((gl_d3d_dev->state[buffer_type] == SURFACE_MEMORY_DIRTY) &&
3007         (rect->u1.x1 >= gl_d3d_dev->lock_rect[buffer_type].left) &&
3008         (rect->u2.y1 >= gl_d3d_dev->lock_rect[buffer_type].top) &&
3009         (rect->u3.x2 <= gl_d3d_dev->lock_rect[buffer_type].right) &&
3010         (rect->u4.y2 <= gl_d3d_dev->lock_rect[buffer_type].bottom)) {
3011         /* If the memory zone is already dirty, use the standard 'in memory' blit operations and not
3012          * GL to do it.
3013          */
3014         return DDERR_INVALIDPARAMS;
3015     }
3016     *buffer_type_p = buffer_type;
3017
3018     return DD_OK;
3019 }
3020
3021 HRESULT
3022 d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst,
3023               LPDIRECTDRAWSURFACE7 src, LPRECT rsrc,
3024               DWORD dwFlags, LPDDBLTFX lpbltfx)
3025 {
3026     WINE_GL_BUFFER_TYPE buffer_type;
3027     D3DRECT rect;
3028
3029     if (rdst) {
3030         rect.u1.x1 = rdst->left;
3031         rect.u2.y1 = rdst->top;
3032         rect.u3.x2 = rdst->right;
3033         rect.u4.y2 = rdst->bottom;
3034     } else {
3035         rect.u1.x1 = 0;
3036         rect.u2.y1 = 0;
3037         rect.u3.x2 = This->surface_desc.dwWidth;
3038         rect.u4.y2 = This->surface_desc.dwHeight;
3039     }
3040
3041     if (setup_rect_and_surface_for_blt(This, &buffer_type, &rect) != DD_OK) return DDERR_INVALIDPARAMS;
3042
3043     if (dwFlags & DDBLT_COLORFILL) {
3044         /* This is easy to handle for the D3D Device... */
3045         DWORD color;
3046         GLint prev_draw;
3047
3048         /* The color as given in the Blt function is in the format of the frame-buffer...
3049          * 'clear' expect it in ARGB format => we need to do some conversion :-)
3050          */
3051         if (This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
3052             if (This->palette) {
3053                 color = ((0xFF000000) |
3054                          (This->palette->palents[lpbltfx->u5.dwFillColor].peRed << 16) |
3055                          (This->palette->palents[lpbltfx->u5.dwFillColor].peGreen << 8) |
3056                          (This->palette->palents[lpbltfx->u5.dwFillColor].peBlue));
3057             } else {
3058                 color = 0xFF000000;
3059             }
3060         } else if ((This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_RGB) &&
3061                    (((This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) == 0) ||
3062                     (This->surface_desc.u4.ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x00000000))) {
3063             if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 16) &&
3064                 (This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask == 0xF800) &&
3065                 (This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask == 0x07E0) &&
3066                 (This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask == 0x001F)) {
3067                 if (lpbltfx->u5.dwFillColor == 0xFFFF) {
3068                     color = 0xFFFFFFFF;
3069                 } else {
3070                     color = ((0xFF000000) |
3071                              ((lpbltfx->u5.dwFillColor & 0xF800) << 8) |
3072                              ((lpbltfx->u5.dwFillColor & 0x07E0) << 5) |
3073                              ((lpbltfx->u5.dwFillColor & 0x001F) << 3));
3074                 }
3075             } else if (((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 32) ||
3076                         (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 24)) &&
3077                        (This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask == 0x00FF0000) &&
3078                        (This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask == 0x0000FF00) &&
3079                        (This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask == 0x000000FF)) {
3080                 color = 0xFF000000 | lpbltfx->u5.dwFillColor;
3081             } else {
3082                 ERR("Wrong surface type for BLT override (unknown RGB format) !\n");
3083                 return DDERR_INVALIDPARAMS;
3084             }
3085         } else {
3086             ERR("Wrong surface type for BLT override !\n");
3087             return DDERR_INVALIDPARAMS;
3088         }
3089
3090         TRACE(" executing D3D Device override.\n");
3091
3092         ENTER_GL();
3093
3094         glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
3095         if (buffer_type == WINE_GL_BUFFER_FRONT)
3096             glDrawBuffer(GL_FRONT);
3097         else
3098             glDrawBuffer(GL_BACK);
3099
3100         d3ddevice_clear(This->d3ddevice, buffer_type, 1, &rect, D3DCLEAR_TARGET, color, 0.0, 0x00000000);
3101
3102         if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) ||
3103             ((buffer_type == WINE_GL_BUFFER_BACK)  && (prev_draw == GL_FRONT)))
3104             glDrawBuffer(prev_draw);
3105
3106         LEAVE_GL();
3107
3108         return DD_OK;
3109     } else if ((dwFlags & (~(DDBLT_KEYSRC|DDBLT_WAIT|DDBLT_ASYNC))) == 0) {
3110         /* Normal blit without any special case... */
3111         if (src != NULL) {
3112             /* And which has a SRC surface */
3113             IDirectDrawSurfaceImpl *src_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src);
3114
3115             if ((src_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE) &&
3116                 (src_impl->d3ddevice == This->d3ddevice) &&
3117                 ((dwFlags & DDBLT_KEYSRC) == 0)) {
3118                 /* Both are 3D devices and using the same GL device and the Blt is without color-keying */
3119                 D3DRECT src_rect;
3120                 int width, height;
3121                 GLint prev_draw;
3122                 WINE_GL_BUFFER_TYPE src_buffer_type;
3123                 IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice;
3124                 BOOLEAN initial;
3125                 DWORD opt_bitmap;
3126                 int x, y;
3127
3128                 if (rsrc) {
3129                     src_rect.u1.x1 = rsrc->left;
3130                     src_rect.u2.y1 = rsrc->top;
3131                     src_rect.u3.x2 = rsrc->right;
3132                     src_rect.u4.y2 = rsrc->bottom;
3133                 } else {
3134                     src_rect.u1.x1 = 0;
3135                     src_rect.u2.y1 = 0;
3136                     src_rect.u3.x2 = src_impl->surface_desc.dwWidth;
3137                     src_rect.u4.y2 = src_impl->surface_desc.dwHeight;
3138                 }
3139
3140                 width = src_rect.u3.x2 - src_rect.u1.x1;
3141                 height = src_rect.u4.y2 - src_rect.u2.y1;
3142
3143                 if ((width != (rect.u3.x2 - rect.u1.x1)) ||
3144                     (height != (rect.u4.y2 - rect.u2.y1))) {
3145                     FIXME(" buffer to buffer copy not supported with stretching yet !\n");
3146                     return DDERR_INVALIDPARAMS;
3147                 }
3148
3149                 /* First check if we BLT from the backbuffer... */
3150                 if ((src_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) != 0) {
3151                     src_buffer_type = WINE_GL_BUFFER_BACK;
3152                 } else if ((src_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
3153                     src_buffer_type = WINE_GL_BUFFER_FRONT;
3154                 } else {
3155                     ERR("Unexpected case in direct buffer to buffer copy !\n");
3156                     return DDERR_INVALIDPARAMS;
3157                 }
3158
3159                 TRACE(" using direct buffer to buffer copy.\n");
3160
3161                 ENTER_GL();
3162
3163                 opt_bitmap = d3ddevice_set_state_for_flush(This->d3ddevice, (LPCRECT) &rect, FALSE, &initial);
3164
3165                 if (upload_surface_to_tex_memory_init(This, 0, &gl_d3d_dev->current_internal_format,
3166                                                       initial, FALSE, UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) {
3167                     ERR(" unsupported pixel format at direct buffer to buffer copy.\n");
3168                     LEAVE_GL();
3169                     return DDERR_INVALIDPARAMS;
3170                 }
3171
3172                 glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
3173                 if (buffer_type == WINE_GL_BUFFER_FRONT)
3174                     glDrawBuffer(GL_FRONT);
3175                 else
3176                     glDrawBuffer(GL_BACK);
3177
3178                 if (src_buffer_type == WINE_GL_BUFFER_FRONT)
3179                     glReadBuffer(GL_FRONT);
3180                 else
3181                     glReadBuffer(GL_BACK);
3182
3183                 /* Now the serious stuff happens. Basically, we copy from the source buffer to the texture memory.
3184                    And directly re-draws this on the destination buffer. */
3185                 for (y = 0; y < height; y += UNLOCK_TEX_SIZE) {
3186                     int get_height;
3187
3188                     if ((src_rect.u2.y1 + y + UNLOCK_TEX_SIZE) > src_impl->surface_desc.dwHeight)
3189                         get_height = src_impl->surface_desc.dwHeight - (src_rect.u2.y1 + y);
3190                     else
3191                         get_height = UNLOCK_TEX_SIZE;
3192
3193                     for (x = 0; x < width; x += UNLOCK_TEX_SIZE) {
3194                         int get_width;
3195
3196                         if ((src_rect.u1.x1 + x + UNLOCK_TEX_SIZE) > src_impl->surface_desc.dwWidth)
3197                             get_width = src_impl->surface_desc.dwWidth - (src_rect.u1.x1 + x);
3198                         else
3199                             get_width = UNLOCK_TEX_SIZE;
3200
3201                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
3202                                             0, UNLOCK_TEX_SIZE - get_height,
3203                                             src_rect.u1.x1 + x, src_impl->surface_desc.dwHeight - (src_rect.u2.y1 + y + get_height),
3204                                             get_width, get_height);
3205
3206                         glBegin(GL_QUADS);
3207                         glTexCoord2f(0.0, 0.0);
3208                         glVertex3d(rect.u1.x1 + x,
3209                                    rect.u2.y1 + y + UNLOCK_TEX_SIZE,
3210                                    0.5);
3211                         glTexCoord2f(1.0, 0.0);
3212                         glVertex3d(rect.u1.x1 + x + UNLOCK_TEX_SIZE,
3213                                    rect.u2.y1 + y + UNLOCK_TEX_SIZE,
3214                                    0.5);
3215                         glTexCoord2f(1.0, 1.0);
3216                         glVertex3d(rect.u1.x1 + x + UNLOCK_TEX_SIZE,
3217                                    rect.u2.y1 + y,
3218                                    0.5);
3219                         glTexCoord2f(0.0, 1.0);
3220                         glVertex3d(rect.u1.x1 + x,
3221                                    rect.u2.y1 + y,
3222                                    0.5);
3223                         glEnd();
3224                     }
3225                 }
3226
3227                 upload_surface_to_tex_memory_release();
3228                 d3ddevice_restore_state_after_flush(This->d3ddevice, opt_bitmap, FALSE);
3229
3230                 if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) ||
3231                     ((buffer_type == WINE_GL_BUFFER_BACK)  && (prev_draw == GL_FRONT)))
3232                     glDrawBuffer(prev_draw);
3233
3234                 LEAVE_GL();
3235
3236                 return DD_OK;
3237             } else {
3238                 /* This is the normal 'with source' Blit. Use the texture engine to do the Blt for us
3239                    (this prevents calling glReadPixels) */
3240                 D3DRECT src_rect;
3241                 int width, height;
3242                 GLint prev_draw;
3243                 IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice;
3244                 BOOLEAN initial;
3245                 DWORD opt_bitmap;
3246                 int x, y;
3247                 double x_stretch, y_stretch;
3248
3249                 if (rsrc) {
3250                     src_rect.u1.x1 = rsrc->left;
3251                     src_rect.u2.y1 = rsrc->top;
3252                     src_rect.u3.x2 = rsrc->right;
3253                     src_rect.u4.y2 = rsrc->bottom;
3254                 } else {
3255                     src_rect.u1.x1 = 0;
3256                     src_rect.u2.y1 = 0;
3257                     src_rect.u3.x2 = src_impl->surface_desc.dwWidth;
3258                     src_rect.u4.y2 = src_impl->surface_desc.dwHeight;
3259                 }
3260
3261                 width = src_rect.u3.x2 - src_rect.u1.x1;
3262                 height = src_rect.u4.y2 - src_rect.u2.y1;
3263
3264                 x_stretch = (double) (rect.u3.x2 - rect.u1.x1) / (double) width;
3265                 y_stretch = (double) (rect.u4.y2 - rect.u2.y1) / (double) height;
3266
3267                 TRACE(" using memory to buffer Blt override.\n");
3268
3269                 ENTER_GL();
3270
3271                 opt_bitmap = d3ddevice_set_state_for_flush(This->d3ddevice, (LPCRECT) &rect, ((dwFlags & DDBLT_KEYSRC) != 0), &initial);
3272
3273                 if (upload_surface_to_tex_memory_init(src_impl, 0, &gl_d3d_dev->current_internal_format,
3274                                                       initial, ((dwFlags & DDBLT_KEYSRC) != 0), UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) {
3275                     ERR(" unsupported pixel format at memory to buffer Blt override.\n");
3276                     LEAVE_GL();
3277                     return DDERR_INVALIDPARAMS;
3278                 }
3279
3280                 glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
3281                 if (buffer_type == WINE_GL_BUFFER_FRONT)
3282                     glDrawBuffer(GL_FRONT);
3283                 else
3284                     glDrawBuffer(GL_BACK);
3285
3286                 /* Now the serious stuff happens. This is basically the same code as for the memory
3287                    flush to frame buffer ... with stretching and different rectangles added :-) */
3288                 for (y = 0; y < height; y += UNLOCK_TEX_SIZE) {
3289                     RECT flush_rect;
3290
3291                     flush_rect.top    = src_rect.u2.y1 + y;
3292                     flush_rect.bottom = ((src_rect.u2.y1 + y + UNLOCK_TEX_SIZE > src_rect.u4.y2) ?
3293                                          src_rect.u4.y2 :
3294                                          (src_rect.u2.y1 + y + UNLOCK_TEX_SIZE));
3295
3296                     for (x = 0; x < width; x += UNLOCK_TEX_SIZE) {
3297                         flush_rect.left  = src_rect.u1.x1 + x;
3298                         flush_rect.right = ((src_rect.u1.x1 + x + UNLOCK_TEX_SIZE > src_rect.u3.x2) ?
3299                                             src_rect.u3.x2 :
3300                                             (src_rect.u1.x1 + x + UNLOCK_TEX_SIZE));
3301
3302                         upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr));
3303
3304                         glBegin(GL_QUADS);
3305                         glTexCoord2f(0.0, 0.0);
3306                         glVertex3d(rect.u1.x1 + (x * x_stretch),
3307                                    rect.u2.y1 + (y * y_stretch),
3308                                    0.5);
3309                         glTexCoord2f(1.0, 0.0);
3310                         glVertex3d(rect.u1.x1 + ((x + UNLOCK_TEX_SIZE) * x_stretch),
3311                                    rect.u2.y1 + (y * y_stretch),
3312                                    0.5);
3313                         glTexCoord2f(1.0, 1.0);
3314                         glVertex3d(rect.u1.x1 + ((x + UNLOCK_TEX_SIZE) * x_stretch),
3315                                    rect.u2.y1 + ((y + UNLOCK_TEX_SIZE) * y_stretch),
3316                                    0.5);
3317                         glTexCoord2f(0.0, 1.0);
3318                         glVertex3d(rect.u1.x1 + (x * x_stretch),
3319                                    rect.u2.y1 + ((y + UNLOCK_TEX_SIZE) * y_stretch),
3320                                    0.5);
3321                         glEnd();
3322                     }
3323                 }
3324
3325                 upload_surface_to_tex_memory_release();
3326                 d3ddevice_restore_state_after_flush(This->d3ddevice, opt_bitmap, ((dwFlags & DDBLT_KEYSRC) != 0));
3327
3328                 if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) ||
3329                     ((buffer_type == WINE_GL_BUFFER_BACK)  && (prev_draw == GL_FRONT)))
3330                     glDrawBuffer(prev_draw);
3331
3332                 LEAVE_GL();
3333
3334                 return DD_OK;
3335             }
3336         }
3337     }
3338     return DDERR_INVALIDPARAMS;
3339 }
3340
3341 HRESULT
3342 d3ddevice_bltfast(IDirectDrawSurfaceImpl *This, DWORD dstx,
3343                   DWORD dsty, LPDIRECTDRAWSURFACE7 src,
3344                   LPRECT rsrc, DWORD trans)
3345 {
3346     RECT rsrc2;
3347     RECT rdst;
3348     IDirectDrawSurfaceImpl *src_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src);
3349     IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice;
3350     WINE_GL_BUFFER_TYPE buffer_type;
3351     GLint prev_draw;
3352     DWORD opt_bitmap;
3353     BOOLEAN initial;
3354     int width, height, x, y;
3355
3356     /* Cannot support DSTCOLORKEY blitting... */
3357     if ((trans & DDBLTFAST_DESTCOLORKEY) != 0) return DDERR_INVALIDPARAMS;
3358
3359     if (rsrc == NULL) {
3360         WARN("rsrc is NULL - getting the whole surface !!\n");
3361         rsrc = &rsrc2;
3362         rsrc->left = rsrc->top = 0;
3363         rsrc->right = src_impl->surface_desc.dwWidth;
3364         rsrc->bottom = src_impl->surface_desc.dwHeight;
3365     } else {
3366         rsrc2 = *rsrc;
3367         rsrc = &rsrc2;
3368     }
3369
3370     rdst.left = dstx;
3371     rdst.top = dsty;
3372     rdst.right = dstx + (rsrc->right - rsrc->left);
3373     if (rdst.right > This->surface_desc.dwWidth) {
3374         rsrc->right -= (This->surface_desc.dwWidth - rdst.right);
3375         rdst.right = This->surface_desc.dwWidth;
3376     }
3377     rdst.bottom = dsty + (rsrc->bottom - rsrc->top);
3378     if (rdst.bottom > This->surface_desc.dwHeight) {
3379         rsrc->bottom -= (This->surface_desc.dwHeight - rdst.bottom);
3380         rdst.bottom = This->surface_desc.dwHeight;
3381     }
3382
3383     width = rsrc->right - rsrc->left;
3384     height = rsrc->bottom - rsrc->top;
3385
3386     if (setup_rect_and_surface_for_blt(This, &buffer_type, (D3DRECT *) &rdst) != DD_OK) return DDERR_INVALIDPARAMS;
3387
3388     TRACE(" using BltFast memory to frame buffer override.\n");
3389
3390     ENTER_GL();
3391
3392     opt_bitmap = d3ddevice_set_state_for_flush(This->d3ddevice, &rdst, (trans & DDBLTFAST_SRCCOLORKEY) != 0, &initial);
3393
3394     if (upload_surface_to_tex_memory_init(src_impl, 0, &gl_d3d_dev->current_internal_format,
3395                                           initial, (trans & DDBLTFAST_SRCCOLORKEY) != 0,
3396                                           UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) {
3397         ERR(" unsupported pixel format at memory to buffer Blt override.\n");
3398         LEAVE_GL();
3399         return DDERR_INVALIDPARAMS;
3400     }
3401
3402     glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
3403     if (buffer_type == WINE_GL_BUFFER_FRONT)
3404         glDrawBuffer(GL_FRONT);
3405     else
3406         glDrawBuffer(GL_BACK);
3407
3408     /* Now the serious stuff happens. This is basically the same code that for the memory
3409        flush to frame buffer but with different rectangles for source and destination :-) */
3410     for (y = 0; y < height; y += UNLOCK_TEX_SIZE) {
3411         RECT flush_rect;
3412
3413         flush_rect.top    = rsrc->top + y;
3414         flush_rect.bottom = ((rsrc->top + y + UNLOCK_TEX_SIZE > rsrc->bottom) ?
3415                              rsrc->bottom :
3416                              (rsrc->top + y + UNLOCK_TEX_SIZE));
3417
3418         for (x = 0; x < width; x += UNLOCK_TEX_SIZE) {
3419             flush_rect.left  = rsrc->left + x;
3420             flush_rect.right = ((rsrc->left + x + UNLOCK_TEX_SIZE > rsrc->right) ?
3421                                 rsrc->right :
3422                                 (rsrc->left + x + UNLOCK_TEX_SIZE));
3423
3424             upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr));
3425
3426             glBegin(GL_QUADS);
3427             glTexCoord2f(0.0, 0.0);
3428             glVertex3d(rdst.left + x,
3429                        rdst.top + y,
3430                        0.5);
3431             glTexCoord2f(1.0, 0.0);
3432             glVertex3d(rdst.left + (x + UNLOCK_TEX_SIZE),
3433                        rdst.top + y,
3434                        0.5);
3435             glTexCoord2f(1.0, 1.0);
3436             glVertex3d(rdst.left + (x + UNLOCK_TEX_SIZE),
3437                        rdst.top + (y + UNLOCK_TEX_SIZE),
3438                        0.5);
3439             glTexCoord2f(0.0, 1.0);
3440             glVertex3d(rdst.left + x,
3441                        rdst.top + (y + UNLOCK_TEX_SIZE),
3442                        0.5);
3443             glEnd();
3444         }
3445     }
3446
3447     upload_surface_to_tex_memory_release();
3448     d3ddevice_restore_state_after_flush(This->d3ddevice, opt_bitmap, (trans & DDBLTFAST_SRCCOLORKEY) != 0);
3449
3450     if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) ||
3451         ((buffer_type == WINE_GL_BUFFER_BACK)  && (prev_draw == GL_FRONT)))
3452         glDrawBuffer(prev_draw);
3453
3454     LEAVE_GL();
3455
3456     return DD_OK;
3457 }
3458
3459 void
3460 d3ddevice_set_ortho(IDirect3DDeviceImpl *This)
3461 {
3462     GLfloat height, width;
3463     GLfloat trans_mat[16];
3464
3465     TRACE("(%p)\n", This);
3466
3467     width = This->surface->surface_desc.dwWidth;
3468     height = This->surface->surface_desc.dwHeight;
3469
3470     /* The X axis is straighforward.. For the Y axis, we need to convert 'D3D' screen coordinates
3471      * to OpenGL screen coordinates (ie the upper left corner is not the same).
3472      */
3473     trans_mat[ 0] = 2.0 / width;  trans_mat[ 4] = 0.0;           trans_mat[ 8] = 0.0;    trans_mat[12] = -1.0;
3474     trans_mat[ 1] = 0.0;          trans_mat[ 5] = -2.0 / height; trans_mat[ 9] = 0.0;    trans_mat[13] =  1.0;
3475 #if 0
3476     /* It has been checked that in Messiah, which mixes XYZ and XYZRHZ vertex format in the same scene,
3477      * that the Z coordinate needs to be given to GL unchanged.
3478      */
3479     trans_mat[ 2] = 0.0;          trans_mat[ 6] = 0.0;           trans_mat[10] = 2.0;    trans_mat[14] = -1.0;
3480 #endif
3481     trans_mat[ 2] = 0.0;          trans_mat[ 6] = 0.0;           trans_mat[10] = 1.0;    trans_mat[14] =  0.0;
3482     trans_mat[ 3] = 0.0;          trans_mat[ 7] = 0.0;           trans_mat[11] = 0.0;    trans_mat[15] =  1.0;
3483
3484     ENTER_GL();
3485     glMatrixMode(GL_MODELVIEW);
3486     glLoadIdentity();
3487     /* See the OpenGL Red Book for an explanation of the following translation (in the OpenGL
3488        Correctness Tips section).
3489
3490        Basically, from what I understood, if the game does not filter the font texture,
3491        as the 'real' pixel will lie at the middle of the two texels, OpenGL may choose the wrong
3492        one and we will have strange artifacts (as the rounding and stuff may give different results
3493        for different pixels, ie sometimes take the left pixel, sometimes the right).
3494     */
3495     glTranslatef(0.375, 0.375, 0);
3496     glMatrixMode(GL_PROJECTION);
3497     glLoadMatrixf(trans_mat);
3498     LEAVE_GL();
3499 }
3500
3501 void
3502 d3ddevice_set_matrices(IDirect3DDeviceImpl *This, DWORD matrices,
3503                        D3DMATRIX *world_mat, D3DMATRIX *view_mat, D3DMATRIX *proj_mat)
3504 {
3505     TRACE("(%p,%08lx,%p,%p,%p)\n", This, matrices, world_mat, view_mat, proj_mat);
3506
3507     ENTER_GL();
3508     if ((matrices & (VIEWMAT_CHANGED|WORLDMAT_CHANGED)) != 0) {
3509         glMatrixMode(GL_MODELVIEW);
3510         glLoadMatrixf((float *) view_mat);
3511
3512         /* Now also re-loads all the Lights and Clipping Planes using the new matrices */
3513         if (This->state_block.render_state[D3DRENDERSTATE_CLIPPING - 1] != FALSE) {
3514             GLint i;
3515             DWORD runner;
3516             for (i = 0, runner = 0x00000001; i < This->max_clipping_planes; i++, runner <<= 1) {
3517                 if (runner & This->state_block.render_state[D3DRENDERSTATE_CLIPPLANEENABLE - 1]) {
3518                     GLdouble plane[4];
3519
3520                     plane[0] = This->clipping_planes[i].plane[0];
3521                     plane[1] = This->clipping_planes[i].plane[1];
3522                     plane[2] = This->clipping_planes[i].plane[2];
3523                     plane[3] = This->clipping_planes[i].plane[3];
3524
3525                     glClipPlane( GL_CLIP_PLANE0 + i, (const GLdouble*) (&plane) );
3526                 }
3527             }
3528         }
3529         if (This->state_block.render_state[D3DRENDERSTATE_LIGHTING - 1] != FALSE) {
3530             GLint i;
3531
3532             for (i = 0; i < This->max_active_lights; i++ )
3533             {
3534                 DWORD dwLightIndex = This->active_lights[i];
3535                 if (dwLightIndex != ~0)
3536                 {
3537                     LPD3DLIGHT7 pLight = &This->light_parameters[dwLightIndex];
3538                     switch (pLight->dltType)
3539                     {
3540                         case D3DLIGHT_DIRECTIONAL: {
3541                             float direction[4];
3542                             float cut_off = 180.0;
3543
3544                             glLightfv(GL_LIGHT0 + i, GL_AMBIENT,  (float *) &pLight->dcvAmbient);
3545                             glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,  (float *) &pLight->dcvDiffuse);
3546                             glLightfv(GL_LIGHT0 + i, GL_SPECULAR, (float *) &pLight->dcvSpecular);
3547                             glLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &cut_off);
3548
3549                             direction[0] = pLight->dvDirection.u1.x;
3550                             direction[1] = pLight->dvDirection.u2.y;
3551                             direction[2] = pLight->dvDirection.u3.z;
3552                             direction[3] = 0.0;
3553                             glLightfv(GL_LIGHT0 + i, GL_POSITION, (float *) direction);
3554                         } break;
3555
3556                         case D3DLIGHT_POINT: {
3557                             float position[4];
3558                             float cut_off = 180.0;
3559
3560                             glLightfv(GL_LIGHT0 + i, GL_AMBIENT,  (float *) &pLight->dcvAmbient);
3561                             glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,  (float *) &pLight->dcvDiffuse);
3562                             glLightfv(GL_LIGHT0 + i, GL_SPECULAR, (float *) &pLight->dcvSpecular);
3563                             position[0] = pLight->dvPosition.u1.x;
3564                             position[1] = pLight->dvPosition.u2.y;
3565                             position[2] = pLight->dvPosition.u3.z;
3566                             position[3] = 1.0;
3567                             glLightfv(GL_LIGHT0 + i, GL_POSITION, (float *) position);
3568                             glLightfv(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, &pLight->dvAttenuation0);
3569                             glLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &pLight->dvAttenuation1);
3570                             glLightfv(GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, &pLight->dvAttenuation2);
3571                             glLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &cut_off);
3572                         } break;
3573
3574                         case D3DLIGHT_SPOT: {
3575                             float direction[4];
3576                             float position[4];
3577                             float cut_off = 90.0 * (This->light_parameters[i].dvPhi / M_PI);
3578
3579                             glLightfv(GL_LIGHT0 + i, GL_AMBIENT,  (float *) &pLight->dcvAmbient);
3580                             glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,  (float *) &pLight->dcvDiffuse);
3581                             glLightfv(GL_LIGHT0 + i, GL_SPECULAR, (float *) &pLight->dcvSpecular);
3582
3583                             direction[0] = pLight->dvDirection.u1.x;
3584                             direction[1] = pLight->dvDirection.u2.y;
3585                             direction[2] = pLight->dvDirection.u3.z;
3586                             direction[3] = 0.0;
3587                             glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, (float *) direction);
3588                             position[0] = pLight->dvPosition.u1.x;
3589                             position[1] = pLight->dvPosition.u2.y;
3590                             position[2] = pLight->dvPosition.u3.z;
3591                             position[3] = 1.0;
3592                             glLightfv(GL_LIGHT0 + i, GL_POSITION, (float *) position);
3593                             glLightfv(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, &pLight->dvAttenuation0);
3594                             glLightfv(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, &pLight->dvAttenuation1);
3595                             glLightfv(GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, &pLight->dvAttenuation2);
3596                             glLightfv(GL_LIGHT0 + i, GL_SPOT_CUTOFF, &cut_off);
3597                             glLightfv(GL_LIGHT0 + i, GL_SPOT_EXPONENT, &pLight->dvFalloff);
3598                         } break;
3599
3600                         default:
3601                             /* No warning here as it's already done at light setting */
3602                             break;
3603                     }
3604                 }
3605             }
3606         }
3607
3608         glMultMatrixf((float *) world_mat);
3609     }
3610     if ((matrices & PROJMAT_CHANGED) != 0) {
3611         glMatrixMode(GL_PROJECTION);
3612         glLoadMatrixf((float *) proj_mat);
3613     }
3614     LEAVE_GL();
3615 }
3616
3617 void
3618 d3ddevice_matrices_updated(IDirect3DDeviceImpl *This, DWORD matrices)
3619 {
3620     IDirect3DDeviceGLImpl *glThis = (IDirect3DDeviceGLImpl *) This;
3621     DWORD tex_mat, tex_stage;
3622
3623     TRACE("(%p,%08lx)\n", This, matrices);
3624
3625     if (matrices & (VIEWMAT_CHANGED|WORLDMAT_CHANGED|PROJMAT_CHANGED)) {
3626         if (glThis->transform_state == GL_TRANSFORM_NORMAL) {
3627             /* This will force an update of the transform state at the next drawing. */
3628             glThis->transform_state = GL_TRANSFORM_NONE;
3629         }
3630     }
3631     if (matrices & (TEXMAT0_CHANGED|TEXMAT1_CHANGED|TEXMAT2_CHANGED|TEXMAT3_CHANGED|
3632                     TEXMAT4_CHANGED|TEXMAT5_CHANGED|TEXMAT6_CHANGED|TEXMAT7_CHANGED))
3633     {
3634         ENTER_GL();
3635         for (tex_mat = TEXMAT0_CHANGED, tex_stage = 0; tex_mat <= TEXMAT7_CHANGED; tex_mat <<= 1, tex_stage++) {
3636             GLenum unit = GL_TEXTURE0_WINE + tex_stage;
3637             if (matrices & tex_mat) {
3638                 if (This->state_block.texture_stage_state[tex_stage][D3DTSS_TEXTURETRANSFORMFLAGS - 1] != D3DTTFF_DISABLE) {
3639                     int is_identity = (memcmp(This->tex_mat[tex_stage], id_mat, 16 * sizeof(D3DVALUE)) != 0);
3640
3641                     if (This->tex_mat_is_identity[tex_stage] != is_identity) {
3642                         if (glThis->current_active_tex_unit != unit) {
3643                             GL_extensions.glActiveTexture(unit);
3644                             glThis->current_active_tex_unit = unit;
3645                         }
3646                         glMatrixMode(GL_TEXTURE);
3647                         glLoadMatrixf((float *) This->tex_mat[tex_stage]);
3648                     }
3649                     This->tex_mat_is_identity[tex_stage] = is_identity;
3650                 } else {
3651                     if (This->tex_mat_is_identity[tex_stage] == FALSE) {
3652                         if (glThis->current_active_tex_unit != unit) {
3653                             GL_extensions.glActiveTexture(unit);
3654                             glThis->current_active_tex_unit = unit;
3655                         }
3656                         glMatrixMode(GL_TEXTURE);
3657                         glLoadIdentity();
3658                         This->tex_mat_is_identity[tex_stage] = TRUE;
3659                     }
3660                 }
3661             }
3662         }
3663         LEAVE_GL();
3664     }
3665 }
3666
3667 /* TODO for both these functions :
3668     - change / restore OpenGL parameters for pictures transfers in case they are ever modified
3669       by other OpenGL code in D3D
3670     - handle the case where no 'Begin / EndScene' was done between two locks
3671     - handle the rectangles in the unlock too
3672     - handle pitch correctly...
3673 */
3674 static void d3ddevice_lock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect, DWORD dwFlags)
3675 {
3676     IDirect3DDeviceImpl *d3d_dev = This->d3ddevice;
3677     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
3678     WINE_GL_BUFFER_TYPE buffer_type;
3679     RECT loc_rect;
3680
3681     if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
3682         buffer_type = WINE_GL_BUFFER_FRONT;
3683         if ((gl_d3d_dev->state[WINE_GL_BUFFER_FRONT] != SURFACE_GL) &&
3684             (gl_d3d_dev->lock_surf[WINE_GL_BUFFER_FRONT] != This)) {
3685             ERR("Change of front buffer.. Expect graphic corruptions !\n");
3686         }
3687         gl_d3d_dev->lock_surf[WINE_GL_BUFFER_FRONT] = This;
3688     } else if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) == (DDSCAPS_BACKBUFFER)) {
3689         buffer_type = WINE_GL_BUFFER_BACK;
3690         if ((gl_d3d_dev->state[WINE_GL_BUFFER_BACK] != SURFACE_GL) &&
3691             (gl_d3d_dev->lock_surf[WINE_GL_BUFFER_BACK] != This)) {
3692             ERR("Change of back buffer.. Expect graphic corruptions !\n");
3693         }
3694         gl_d3d_dev->lock_surf[WINE_GL_BUFFER_BACK] = This;
3695     } else {
3696         ERR("Wrong surface type for locking !\n");
3697         return;
3698     }
3699
3700     if (pRect == NULL) {
3701         loc_rect.top = 0;
3702         loc_rect.left = 0;
3703         loc_rect.bottom = This->surface_desc.dwHeight;
3704         loc_rect.right = This->surface_desc.dwWidth;
3705         pRect = &loc_rect;
3706     }
3707
3708     /* Try to acquire the device critical section */
3709     EnterCriticalSection(&(d3d_dev->crit));
3710
3711     if (gl_d3d_dev->lock_rect_valid[buffer_type]) {
3712         ERR("Two consecutive locks on %s buffer... Expect problems !\n",
3713             (buffer_type == WINE_GL_BUFFER_BACK ? "back" : "front"));
3714     }
3715     gl_d3d_dev->lock_rect_valid[buffer_type] = TRUE;
3716
3717     if (gl_d3d_dev->state[buffer_type] != SURFACE_GL) {
3718         /* Check if the new rectangle is in the previous one or not.
3719            If it is not, flush first the previous locks on screen.
3720         */
3721         if ((pRect->top    < gl_d3d_dev->lock_rect[buffer_type].top) ||
3722             (pRect->left   < gl_d3d_dev->lock_rect[buffer_type].left) ||
3723             (pRect->right  > gl_d3d_dev->lock_rect[buffer_type].right) ||
3724             (pRect->bottom > gl_d3d_dev->lock_rect[buffer_type].bottom)) {
3725             if (gl_d3d_dev->state[buffer_type] == SURFACE_MEMORY_DIRTY) {
3726                 TRACE(" flushing back to %s buffer as new rect : (%ldx%ld) - (%ldx%ld) not included in old rect : (%ldx%ld) - (%ldx%ld)\n",
3727                       (buffer_type == WINE_GL_BUFFER_BACK ? "back" : "front"),
3728                       pRect->left, pRect->top, pRect->right, pRect->bottom,
3729                       gl_d3d_dev->lock_rect[buffer_type].left, gl_d3d_dev->lock_rect[buffer_type].top,
3730                       gl_d3d_dev->lock_rect[buffer_type].right, gl_d3d_dev->lock_rect[buffer_type].bottom);
3731                 d3d_dev->flush_to_framebuffer(d3d_dev, &(gl_d3d_dev->lock_rect[buffer_type]), gl_d3d_dev->lock_surf[buffer_type]);
3732             }
3733             gl_d3d_dev->state[buffer_type] = SURFACE_GL;
3734             gl_d3d_dev->lock_rect[buffer_type] = *pRect;
3735         }
3736         /* In the other case, do not upgrade the locking rectangle as it's no need... */
3737     } else {
3738         gl_d3d_dev->lock_rect[buffer_type] = *pRect;
3739     }
3740
3741     if (gl_d3d_dev->state[buffer_type] == SURFACE_GL) {
3742         /* If the surface is already in memory, no need to do anything here... */
3743         GLenum buffer_format;
3744         GLenum buffer_color;
3745         int y;
3746         char *dst;
3747
3748         TRACE(" copying %s buffer to main memory with rectangle (%ldx%ld) - (%ldx%ld).\n", (buffer_type == WINE_GL_BUFFER_BACK ? "back" : "front"),
3749               pRect->left, pRect->top, pRect->right, pRect->bottom);
3750
3751         /* Note that here we cannot do 'optmizations' about the WriteOnly flag... Indeed, a game
3752            may only write to the device... But when we will blit it back to the screen, we need
3753            also to blit correctly the parts the application did not overwrite... */
3754
3755         if (((This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_RGB) != 0) &&
3756             (((This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) == 0) ||
3757              (This->surface_desc.u4.ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x00000000))) {
3758             if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 16) &&
3759                 (This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask == 0xF800) &&
3760                 (This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask == 0x07E0) &&
3761                 (This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask == 0x001F)) {
3762                 buffer_format = GL_UNSIGNED_SHORT_5_6_5;
3763                 buffer_color = GL_RGB;
3764             } else if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 24) &&
3765                        (This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask == 0xFF0000) &&
3766                        (This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask == 0x00FF00) &&
3767                        (This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask == 0x0000FF)) {
3768                 buffer_format = GL_UNSIGNED_BYTE;
3769                 buffer_color = GL_RGB;
3770             } else if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount == 32) &&
3771                        (This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask == 0x00FF0000) &&
3772                        (This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask == 0x0000FF00) &&
3773                        (This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask == 0x000000FF)) {
3774                 buffer_format = GL_UNSIGNED_INT_8_8_8_8_REV;
3775                 buffer_color = GL_BGRA;
3776             } else {
3777                 ERR(" unsupported pixel format at device locking.\n");
3778                 return;
3779             }
3780         } else {
3781             ERR(" unsupported pixel format at device locking - alpha on frame buffer.\n");
3782             return;
3783         }
3784
3785         ENTER_GL();
3786
3787         if (buffer_type == WINE_GL_BUFFER_FRONT)
3788             /* Application wants to lock the front buffer */
3789             glReadBuffer(GL_FRONT);
3790         else
3791             /* Application wants to lock the back buffer */
3792             glReadBuffer(GL_BACK);
3793
3794         dst = ((char *)This->surface_desc.lpSurface) +
3795           (pRect->top * This->surface_desc.u1.lPitch) + (pRect->left * GET_BPP(This->surface_desc));
3796
3797         if (This->surface_desc.u1.lPitch != (GET_BPP(This->surface_desc) * This->surface_desc.dwWidth)) {
3798             /* Slow-path in case of 'odd' surfaces. This could be fixed using some GL options, but I
3799              * could not be bothered considering the rare cases where it may be useful :-)
3800              */
3801             for (y = (This->surface_desc.dwHeight - pRect->top - 1);
3802                  y >= ((int) This->surface_desc.dwHeight - (int) pRect->bottom);
3803                  y--) {
3804                 glReadPixels(pRect->left, y,
3805                              pRect->right - pRect->left, 1,
3806                              buffer_color, buffer_format, dst);
3807                 dst += This->surface_desc.u1.lPitch;
3808             }
3809         } else {
3810             /* Faster path for surface copy. Note that I can use static variables here as I am
3811              * protected by the OpenGL critical section so this function won't be called by
3812              * two threads at the same time.
3813              */
3814             static char *buffer = NULL;
3815             static int buffer_width = 0;
3816             char *dst2 = dst + ((pRect->bottom - pRect->top) - 1) * This->surface_desc.u1.lPitch;
3817             int current_width = (pRect->right - pRect->left) * GET_BPP(This->surface_desc);
3818
3819             glReadPixels(pRect->left, ((int) This->surface_desc.dwHeight - (int) pRect->bottom),
3820                          pRect->right - pRect->left, pRect->bottom - pRect->top,
3821                          buffer_color, buffer_format, dst);
3822
3823             if (current_width > buffer_width) {
3824                 if (buffer != NULL) HeapFree(GetProcessHeap(), 0, buffer);
3825                 buffer_width = current_width;
3826                 buffer = HeapAlloc(GetProcessHeap(), 0, buffer_width);
3827             }
3828             for (y = 0; y < ((pRect->bottom - pRect->top) / 2); y++) {
3829                 memcpy(buffer, dst, current_width);
3830                 memcpy(dst, dst2, current_width);
3831                 memcpy(dst2, buffer, current_width);
3832                 dst  += This->surface_desc.u1.lPitch;
3833                 dst2 -= This->surface_desc.u1.lPitch;
3834             }
3835         }
3836
3837         gl_d3d_dev->state[buffer_type] = SURFACE_MEMORY;
3838
3839 #if 0
3840         /* I keep this code here as it's very useful to debug :-) */
3841         {
3842             static int flush_count = 0;
3843             char buf[128];
3844             FILE *f;
3845
3846             if ((++flush_count % 50) == 0) {
3847                 sprintf(buf, "lock_%06d.pnm", flush_count);
3848                 f = fopen(buf, "wb");
3849                 DDRAW_dump_surface_to_disk(This, f);
3850             }
3851         }
3852 #endif
3853
3854         LEAVE_GL();
3855     }
3856 }
3857
3858 static void d3ddevice_flush_to_frame_buffer(IDirect3DDeviceImpl *d3d_dev, LPCRECT pRect, IDirectDrawSurfaceImpl *surf) {
3859     RECT loc_rect;
3860     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
3861     int x, y;
3862     BOOLEAN initial;
3863     DWORD opt_bitmap;
3864
3865     /* Note : no need here to lock the 'device critical section' as we are already protected by
3866        the GL critical section. */
3867
3868     if (pRect == NULL) {
3869         loc_rect.top = 0;
3870         loc_rect.left = 0;
3871         loc_rect.bottom = d3d_dev->surface->surface_desc.dwHeight;
3872         loc_rect.right = d3d_dev->surface->surface_desc.dwWidth;
3873         pRect = &loc_rect;
3874     }
3875
3876     TRACE(" flushing memory back to screen memory (%ld,%ld) x (%ld,%ld).\n", pRect->top, pRect->left, pRect->right, pRect->bottom);
3877
3878     opt_bitmap = d3ddevice_set_state_for_flush(d3d_dev, pRect, FALSE, &initial);
3879
3880     if (upload_surface_to_tex_memory_init(surf, 0, &gl_d3d_dev->current_internal_format,
3881                                           initial, FALSE, UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) {
3882         ERR(" unsupported pixel format at frame buffer flush.\n");
3883         return;
3884     }
3885
3886     for (y = pRect->top; y < pRect->bottom; y += UNLOCK_TEX_SIZE) {
3887         RECT flush_rect;
3888
3889         flush_rect.top = y;
3890         flush_rect.bottom = (y + UNLOCK_TEX_SIZE > pRect->bottom) ? pRect->bottom : (y + UNLOCK_TEX_SIZE);
3891
3892         for (x = pRect->left; x < pRect->right; x += UNLOCK_TEX_SIZE) {
3893             /* First, upload the texture... */
3894             flush_rect.left = x;
3895             flush_rect.right = (x + UNLOCK_TEX_SIZE > pRect->right)  ? pRect->right  : (x + UNLOCK_TEX_SIZE);
3896
3897             upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr));
3898
3899             glBegin(GL_QUADS);
3900             glTexCoord2f(0.0, 0.0);
3901             glVertex3d(x, y, 0.5);
3902             glTexCoord2f(1.0, 0.0);
3903             glVertex3d(x + UNLOCK_TEX_SIZE, y, 0.5);
3904             glTexCoord2f(1.0, 1.0);
3905             glVertex3d(x + UNLOCK_TEX_SIZE, y + UNLOCK_TEX_SIZE, 0.5);
3906             glTexCoord2f(0.0, 1.0);
3907             glVertex3d(x, y + UNLOCK_TEX_SIZE, 0.5);
3908             glEnd();
3909         }
3910     }
3911
3912     upload_surface_to_tex_memory_release();
3913     d3ddevice_restore_state_after_flush(d3d_dev, opt_bitmap, FALSE);
3914
3915 #if 0
3916     /* I keep this code here as it's very useful to debug :-) */
3917     {
3918         static int flush_count = 0;
3919         char buf[128];
3920         FILE *f;
3921
3922         if ((++flush_count % 50) == 0) {
3923             sprintf(buf, "flush_%06d.pnm", flush_count);
3924             f = fopen(buf, "wb");
3925             DDRAW_dump_surface_to_disk(surf, f);
3926         }
3927     }
3928 #endif
3929 }
3930
3931 static void d3ddevice_unlock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect)
3932 {
3933     WINE_GL_BUFFER_TYPE buffer_type;
3934     IDirect3DDeviceImpl *d3d_dev = This->d3ddevice;
3935     IDirect3DDeviceGLImpl* gl_d3d_dev = (IDirect3DDeviceGLImpl*) d3d_dev;
3936
3937     if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER|DDSCAPS_PRIMARYSURFACE)) != 0) {
3938         buffer_type = WINE_GL_BUFFER_FRONT;
3939     } else if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) == (DDSCAPS_BACKBUFFER)) {
3940         buffer_type = WINE_GL_BUFFER_BACK;
3941     } else {
3942         ERR("Wrong surface type for locking !\n");
3943         return;
3944     }
3945
3946     if (gl_d3d_dev->lock_rect_valid[buffer_type] == FALSE) {
3947         ERR("Unlock without prior lock on %s buffer... Expect problems !\n",
3948             (buffer_type == WINE_GL_BUFFER_BACK ? "back" : "front"));
3949     }
3950     gl_d3d_dev->lock_rect_valid[buffer_type] = FALSE;
3951
3952     /* First, check if we need to do anything. For the backbuffer, flushing is done at the next 3D activity. */
3953     if ((This->lastlocktype & DDLOCK_READONLY) == 0) {
3954         if (buffer_type == WINE_GL_BUFFER_FRONT) {
3955             GLint prev_draw;
3956
3957             TRACE(" flushing front buffer immediately on screen.\n");
3958
3959             ENTER_GL();
3960             glGetIntegerv(GL_DRAW_BUFFER, &prev_draw);
3961             glDrawBuffer(GL_FRONT);
3962             /* Note: we do not use the application provided lock rectangle but our own stored at
3963                      lock time. This is because in old D3D versions, the 'lock' parameter did not
3964                      exist.
3965             */
3966             d3d_dev->flush_to_framebuffer(d3d_dev, &(gl_d3d_dev->lock_rect[WINE_GL_BUFFER_FRONT]), gl_d3d_dev->lock_surf[WINE_GL_BUFFER_FRONT]);
3967             glDrawBuffer(prev_draw);
3968             LEAVE_GL();
3969         } else {
3970             gl_d3d_dev->state[WINE_GL_BUFFER_BACK] = SURFACE_MEMORY_DIRTY;
3971         }
3972     }
3973
3974     /* And 'frees' the device critical section */
3975     LeaveCriticalSection(&(d3d_dev->crit));
3976 }
3977
3978 static void
3979 apply_texture_state(IDirect3DDeviceImpl *This)
3980 {
3981     int stage, state;
3982
3983     /* Initialize texture stages states */
3984     for (stage = 0; stage < MAX_TEXTURES; stage++) {
3985        for (state = 0; state < HIGHEST_TEXTURE_STAGE_STATE; state += 1) {
3986            if (This->state_block.set_flags.texture_stage_state[stage][state]) {
3987                IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7),
3988                                                      stage, state + 1, This->state_block.texture_stage_state[stage][state]);
3989            }
3990        }
3991     }
3992 }
3993
3994 HRESULT
3995 d3ddevice_create(IDirect3DDeviceImpl **obj, IDirectDrawImpl *d3d, IDirectDrawSurfaceImpl *surface, int version)
3996 {
3997     IDirect3DDeviceImpl *object;
3998     IDirect3DDeviceGLImpl *gl_object;
3999     IDirectDrawSurfaceImpl *surf;
4000     HDC device_context;
4001     XVisualInfo *vis;
4002     int num;
4003     int tex_num;
4004     XVisualInfo template;
4005     GLenum buffer = GL_FRONT;
4006     int light;
4007
4008     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDeviceGLImpl));
4009     if (object == NULL) return DDERR_OUTOFMEMORY;
4010
4011     gl_object = (IDirect3DDeviceGLImpl *) object;
4012
4013     object->ref = 1;
4014     object->d3d = d3d;
4015     object->surface = surface;
4016     object->set_context = set_context;
4017     object->clear = d3ddevice_clear_back;
4018     object->set_matrices = d3ddevice_set_matrices;
4019     object->matrices_updated = d3ddevice_matrices_updated;
4020     object->flush_to_framebuffer = d3ddevice_flush_to_frame_buffer;
4021     object->version = version;
4022
4023     TRACE(" creating OpenGL device for surface = %p, d3d = %p\n", surface, d3d);
4024
4025     InitializeCriticalSection(&(object->crit));
4026
4027     TRACE(" device critical section : %p\n", &(object->crit));
4028
4029     device_context = GetDC(surface->ddraw_owner->window);
4030     gl_object->display = get_display(device_context);
4031     gl_object->drawable = get_drawable(device_context);
4032     ReleaseDC(surface->ddraw_owner->window,device_context);
4033
4034     ENTER_GL();
4035     template.visualid = (VisualID)GetPropA( GetDesktopWindow(), "__wine_x11_visual_id" );
4036     vis = XGetVisualInfo(gl_object->display, VisualIDMask, &template, &num);
4037     if (vis == NULL) {
4038         HeapFree(GetProcessHeap(), 0, object);
4039         ERR("No visual found !\n");
4040         LEAVE_GL();
4041         return DDERR_INVALIDPARAMS;
4042     } else {
4043         TRACE(" visual found\n");
4044     }
4045
4046     gl_object->gl_context = glXCreateContext(gl_object->display, vis,
4047                                              NULL, GL_TRUE);
4048
4049     if (gl_object->gl_context == NULL) {
4050         HeapFree(GetProcessHeap(), 0, object);
4051         ERR("Error in context creation !\n");
4052         LEAVE_GL();
4053         return DDERR_INVALIDPARAMS;
4054     } else {
4055         TRACE(" context created (%p)\n", gl_object->gl_context);
4056     }
4057
4058     /* Look for the front buffer and override its surface's Flip method (if in double buffering) */
4059     for (surf = surface; surf != NULL; surf = surf->surface_owner) {
4060         if ((surf->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) == (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER)) {
4061             surf->aux_ctx  = (LPVOID) object;
4062             surf->aux_data = (LPVOID) gl_object->drawable;
4063             surf->aux_flip = opengl_flip;
4064             buffer =  GL_BACK;
4065             break;
4066         }
4067     }
4068     /* We are not doing any double buffering.. Then force OpenGL to draw on the front buffer */
4069     if (surf == NULL) {
4070         TRACE(" no double buffering : drawing on the front buffer\n");
4071         buffer = GL_FRONT;
4072     }
4073
4074     for (surf = surface; surf != NULL; surf = surf->surface_owner) {
4075         IDirectDrawSurfaceImpl *surf2;
4076         for (surf2 = surf; surf2->prev_attached != NULL; surf2 = surf2->prev_attached) ;
4077         for (; surf2 != NULL; surf2 = surf2->next_attached) {
4078             TRACE(" checking surface %p :", surf2);
4079             if (((surf2->surface_desc.ddsCaps.dwCaps & (DDSCAPS_3DDEVICE)) == (DDSCAPS_3DDEVICE)) &&
4080                 ((surf2->surface_desc.ddsCaps.dwCaps & (DDSCAPS_ZBUFFER)) != (DDSCAPS_ZBUFFER))) {
4081                 /* Override the Lock / Unlock function for all these surfaces */
4082                 surf2->lock_update_prev = surf2->lock_update;
4083                 surf2->lock_update = d3ddevice_lock_update;
4084                 surf2->unlock_update_prev = surf2->unlock_update;
4085                 surf2->unlock_update = d3ddevice_unlock_update;
4086                 /* And install also the blt / bltfast overrides */
4087                 surf2->aux_blt = d3ddevice_blt;
4088                 surf2->aux_bltfast = d3ddevice_bltfast;
4089
4090                 TRACE(" overriding direct surface access.\n");
4091             } else {
4092                 TRACE(" no override.\n");
4093             }
4094             surf2->d3ddevice = object;
4095         }
4096     }
4097
4098     /* Set the various light parameters */
4099     object->num_set_lights = 0;
4100     object->max_active_lights = opengl_device_caps.dwMaxActiveLights;
4101     object->light_parameters = NULL;
4102     object->active_lights = HeapAlloc(GetProcessHeap(), 0,
4103         object->max_active_lights * sizeof(object->active_lights[0]));
4104     /* Fill the active light array with ~0, which is used to indicate an
4105        invalid light index. We don't use 0, because it's a valid light index. */
4106     for (light=0; light < object->max_active_lights; light++)
4107         object->active_lights[light] = ~0;
4108
4109
4110     /* Allocate memory for the matrices */
4111     object->world_mat = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
4112     object->view_mat  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
4113     object->proj_mat  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
4114     memcpy(object->world_mat, id_mat, 16 * sizeof(float));
4115     memcpy(object->view_mat , id_mat, 16 * sizeof(float));
4116     memcpy(object->proj_mat , id_mat, 16 * sizeof(float));
4117     for (tex_num = 0; tex_num < MAX_TEXTURES; tex_num++) {
4118         object->tex_mat[tex_num] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 16 * sizeof(float));
4119         memcpy(object->tex_mat[tex_num], id_mat, 16 * sizeof(float));
4120         object->tex_mat_is_identity[tex_num] = TRUE;
4121     }
4122
4123     /* Initialisation */
4124     TRACE(" setting current context\n");
4125     object->set_context(object);
4126     TRACE(" current context set\n");
4127
4128     /* allocate the clipping planes */
4129     object->max_clipping_planes = opengl_device_caps.wMaxUserClipPlanes;
4130     object->clipping_planes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->max_clipping_planes * sizeof(d3d7clippingplane));
4131
4132     glHint(GL_FOG_HINT,GL_NICEST);
4133
4134     /* Initialize the various GL contexts to be in sync with what we store locally */
4135     glClearDepth(0.0);
4136     glClearStencil(0);
4137     glClearColor(0.0, 0.0, 0.0, 0.0);
4138     glDepthMask(GL_TRUE);
4139     gl_object->depth_mask = TRUE;
4140     glEnable(GL_DEPTH_TEST);
4141     gl_object->depth_test = TRUE;
4142     glDisable(GL_ALPHA_TEST);
4143     glDisable(GL_STENCIL_TEST);
4144     glDisable(GL_CULL_FACE);
4145     glDisable(GL_LIGHTING);
4146     glDisable(GL_BLEND);
4147     glDisable(GL_FOG);
4148     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
4149     gl_object->current_tex_env = GL_REPLACE;
4150     gl_object->current_active_tex_unit = GL_TEXTURE0_WINE;
4151     if (GL_extensions.glActiveTexture != NULL) {
4152         GL_extensions.glActiveTexture(GL_TEXTURE0_WINE);
4153     }
4154     gl_object->current_alpha_test_ref = 0.0;
4155     gl_object->current_alpha_test_func = GL_ALWAYS;
4156     glAlphaFunc(GL_ALWAYS, 0.0);
4157
4158     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
4159     glDrawBuffer(buffer);
4160     glReadBuffer(buffer);
4161     /* glDisable(GL_DEPTH_TEST); Need here to check for the presence of a ZBuffer and to reenable it when the ZBuffer is attached */
4162     LEAVE_GL();
4163
4164     gl_object->state[WINE_GL_BUFFER_BACK] = SURFACE_GL;
4165     gl_object->state[WINE_GL_BUFFER_FRONT] = SURFACE_GL;
4166
4167     /* fill_device_capabilities(d3d->ddraw); */
4168
4169     ICOM_INIT_INTERFACE(object, IDirect3DDevice,  VTABLE_IDirect3DDevice);
4170     ICOM_INIT_INTERFACE(object, IDirect3DDevice2, VTABLE_IDirect3DDevice2);
4171     ICOM_INIT_INTERFACE(object, IDirect3DDevice3, VTABLE_IDirect3DDevice3);
4172     ICOM_INIT_INTERFACE(object, IDirect3DDevice7, VTABLE_IDirect3DDevice7);
4173
4174     *obj = object;
4175
4176     TRACE(" creating implementation at %p.\n", *obj);
4177
4178     /* And finally warn D3D that this device is now present */
4179     object->d3d->d3d_added_device(object->d3d, object);
4180
4181     InitDefaultStateBlock(&object->state_block, object->version);
4182     /* Apply default render state and texture stage state values */
4183     apply_render_state(object, &object->state_block);
4184     apply_texture_state(object);
4185
4186     /* And fill the fog table with the default fog value */
4187     build_fog_table(gl_object->fog_table, object->state_block.render_state[D3DRENDERSTATE_FOGCOLOR - 1]);
4188
4189     return DD_OK;
4190 }
4191
4192 static void fill_opengl_primcaps(D3DPRIMCAPS *pc)
4193 {
4194     pc->dwSize = sizeof(*pc);
4195     pc->dwMiscCaps = D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLCCW | D3DPMISCCAPS_CULLCW |
4196       D3DPMISCCAPS_LINEPATTERNREP | D3DPMISCCAPS_MASKPLANES | D3DPMISCCAPS_MASKZ;
4197     pc->dwRasterCaps = D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_FOGTABLE |
4198       D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL |
4199           D3DPRASTERCAPS_ZFOG;
4200     if (GL_extensions.mipmap_lodbias) {
4201         pc->dwRasterCaps |= D3DPRASTERCAPS_MIPMAPLODBIAS;
4202     }
4203     pc->dwZCmpCaps = D3DPCMPCAPS_ALWAYS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_GREATEREQUAL |
4204       D3DPCMPCAPS_LESS | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_NEVER | D3DPCMPCAPS_NOTEQUAL;
4205     pc->dwSrcBlendCaps  = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_DESTCOLOR | D3DPBLENDCAPS_INVDESTCOLOR |
4206       D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_SRCALPHASAT |
4207         D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA;
4208     pc->dwDestBlendCaps = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | D3DPBLENDCAPS_INVSRCCOLOR |
4209       D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_SRCALPHASAT |
4210         D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA;
4211     pc->dwAlphaCmpCaps  = D3DPCMPCAPS_ALWAYS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_GREATEREQUAL |
4212       D3DPCMPCAPS_LESS | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_NEVER | D3DPCMPCAPS_NOTEQUAL;
4213     pc->dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDRGB |
4214       D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDRGB;
4215     pc->dwTextureCaps = D3DPTEXTURECAPS_ALPHA | D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_PERSPECTIVE |
4216       D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_TRANSPARENCY;
4217     pc->dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_LINEARMIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST |
4218       D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_MIPNEAREST | D3DPTFILTERCAPS_NEAREST | D3DPTFILTERCAPS_MAGFLINEAR |
4219           D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MIPFLINEAR |
4220               D3DPTFILTERCAPS_MIPFPOINT;
4221     pc->dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL | D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
4222       D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA | D3DPTBLENDCAPS_MODULATEMASK;
4223     pc->dwTextureAddressCaps = D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_CLAMP | D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_INDEPENDENTUV;
4224     if (GL_extensions.mirrored_repeat) {
4225         pc->dwTextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
4226     }
4227     pc->dwStippleWidth = 32;
4228     pc->dwStippleHeight = 32;
4229 }
4230
4231 static void fill_caps(void)
4232 {
4233     GLint max_clip_planes;
4234     GLint depth_bits;
4235
4236     /* Fill first all the fields with default values which will be overriden later on with
4237        correct ones from the GL code
4238     */
4239     opengl_device_caps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_EXECUTESYSTEMMEMORY |
4240       D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_TEXTURESYSTEMMEMORY |
4241       D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4242       /* D3D 7 capabilities */
4243       D3DDEVCAPS_DRAWPRIMITIVES2 /*| D3DDEVCAPS_HWTRANSFORMANDLIGHT*/ | D3DDEVCAPS_HWRASTERIZATION | D3DDEVCAPS_DRAWPRIMITIVES2EX;
4244     fill_opengl_primcaps(&(opengl_device_caps.dpcLineCaps));
4245     fill_opengl_primcaps(&(opengl_device_caps.dpcTriCaps));
4246     opengl_device_caps.dwDeviceRenderBitDepth  = DDBD_16|DDBD_24|DDBD_32;
4247     opengl_device_caps.dwMinTextureWidth  = 1;
4248     opengl_device_caps.dwMinTextureHeight = 1;
4249     opengl_device_caps.dwMaxTextureWidth  = 1024;
4250     opengl_device_caps.dwMaxTextureHeight = 1024;
4251     opengl_device_caps.dwMaxTextureRepeat = 16;
4252     opengl_device_caps.dwMaxTextureAspectRatio = 1024;
4253     opengl_device_caps.dwMaxAnisotropy = 0;
4254     opengl_device_caps.dvGuardBandLeft = 0.0;
4255     opengl_device_caps.dvGuardBandRight = 0.0;
4256     opengl_device_caps.dvGuardBandTop = 0.0;
4257     opengl_device_caps.dvGuardBandBottom = 0.0;
4258     opengl_device_caps.dvExtentsAdjust = 0.0;
4259     opengl_device_caps.dwStencilCaps = D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_INVERT | D3DSTENCILCAPS_KEEP |
4260       D3DSTENCILCAPS_REPLACE | D3DSTENCILCAPS_ZERO;
4261     opengl_device_caps.dwTextureOpCaps = D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 | D3DTEXOPCAPS_MODULATE4X |
4262         D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED2X | D3DTEXOPCAPS_ADDSIGNED |
4263             D3DTEXOPCAPS_BLENDDIFFUSEALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHA | D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDCURRENTALPHA;
4264     if (GL_extensions.max_texture_units != 0) {
4265         opengl_device_caps.wMaxTextureBlendStages = GL_extensions.max_texture_units;
4266         opengl_device_caps.wMaxSimultaneousTextures = GL_extensions.max_texture_units;
4267         opengl_device_caps.dwFVFCaps = D3DFVFCAPS_DONOTSTRIPELEMENTS | GL_extensions.max_texture_units;
4268     } else {
4269         opengl_device_caps.wMaxTextureBlendStages = 1;
4270         opengl_device_caps.wMaxSimultaneousTextures = 1;
4271         opengl_device_caps.dwFVFCaps = D3DFVFCAPS_DONOTSTRIPELEMENTS | 1;
4272     }
4273     opengl_device_caps.dwMaxActiveLights = 16;
4274     opengl_device_caps.dvMaxVertexW = 100000000.0; /* No idea exactly what to put here... */
4275     opengl_device_caps.deviceGUID = IID_IDirect3DTnLHalDevice;
4276     opengl_device_caps.wMaxUserClipPlanes = 1;
4277     opengl_device_caps.wMaxVertexBlendMatrices = 0;
4278     opengl_device_caps.dwVertexProcessingCaps = D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG |
4279         D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER;
4280     opengl_device_caps.dwReserved1 = 0;
4281     opengl_device_caps.dwReserved2 = 0;
4282     opengl_device_caps.dwReserved3 = 0;
4283     opengl_device_caps.dwReserved4 = 0;
4284
4285     /* And now some GL overrides :-) */
4286     glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *) &opengl_device_caps.dwMaxTextureWidth);
4287     opengl_device_caps.dwMaxTextureHeight = opengl_device_caps.dwMaxTextureWidth;
4288     opengl_device_caps.dwMaxTextureAspectRatio = opengl_device_caps.dwMaxTextureWidth;
4289     TRACE(": max texture size = %ld\n", opengl_device_caps.dwMaxTextureWidth);
4290
4291     glGetIntegerv(GL_MAX_LIGHTS, (GLint *) &opengl_device_caps.dwMaxActiveLights);
4292     TRACE(": max active lights = %ld\n", opengl_device_caps.dwMaxActiveLights);
4293
4294     glGetIntegerv(GL_MAX_CLIP_PLANES, &max_clip_planes);
4295     opengl_device_caps.wMaxUserClipPlanes = max_clip_planes;
4296     TRACE(": max clipping planes = %d\n", opengl_device_caps.wMaxUserClipPlanes);
4297
4298     glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
4299     TRACE(": Z bits = %d\n", depth_bits);
4300     switch (depth_bits) {
4301         case 16: opengl_device_caps.dwDeviceZBufferBitDepth = DDBD_16; break;
4302         case 24: opengl_device_caps.dwDeviceZBufferBitDepth = DDBD_16|DDBD_24; break;
4303         case 32:
4304         default: opengl_device_caps.dwDeviceZBufferBitDepth = DDBD_16|DDBD_24|DDBD_32; break;
4305     }
4306 }
4307
4308 BOOL
4309 d3ddevice_init_at_startup(void *gl_handle)
4310 {
4311     XVisualInfo template;
4312     XVisualInfo *vis;
4313     HDC device_context;
4314     Display *display;
4315     Visual *visual;
4316     Drawable drawable = (Drawable) GetPropA(GetDesktopWindow(), "__wine_x11_whole_window");
4317     XWindowAttributes win_attr;
4318     GLXContext gl_context;
4319     int num;
4320     const char *glExtensions;
4321     const char *glVersion;
4322     const char *glXExtensions = NULL;
4323     const void *(*pglXGetProcAddressARB)(const GLubyte *) = NULL;
4324     int major, minor, patch, num_parsed;
4325
4326     TRACE("Initializing GL...\n");
4327
4328     if (!drawable)
4329     {
4330         WARN("x11drv not loaded - D3D support disabled!\n");
4331         return FALSE;
4332     }
4333
4334     /* Get a default rendering context to have the 'caps' function query some info from GL */
4335     device_context = GetDC(0);
4336     display = get_display(device_context);
4337     ReleaseDC(0, device_context);
4338
4339     ENTER_GL();
4340     if (XGetWindowAttributes(display, drawable, &win_attr)) {
4341         visual = win_attr.visual;
4342     } else {
4343         visual = DefaultVisual(display, DefaultScreen(display));
4344     }
4345     template.visualid = XVisualIDFromVisual(visual);
4346     vis = XGetVisualInfo(display, VisualIDMask, &template, &num);
4347     if (vis == NULL) {
4348         LEAVE_GL();
4349         WARN("Error creating visual info for capabilities initialization - D3D support disabled !\n");
4350         return FALSE;
4351     }
4352     gl_context = glXCreateContext(display, vis, NULL, GL_TRUE);
4353     XFree(vis);
4354
4355     if (gl_context == NULL) {
4356         LEAVE_GL();
4357         WARN("Error creating default context for capabilities initialization - D3D support disabled !\n");
4358         return FALSE;
4359     }
4360     if (glXMakeCurrent(display, drawable, gl_context) == False) {
4361         glXDestroyContext(display, gl_context);
4362         LEAVE_GL();
4363         WARN("Error setting default context as current for capabilities initialization - D3D support disabled !\n");
4364         return FALSE;
4365     }
4366
4367     /* Then, query all extensions */
4368     glXExtensions = glXQueryExtensionsString(display, DefaultScreen(display)); /* Note: not used right now but will for PBuffers */
4369     glExtensions = (const char *) glGetString(GL_EXTENSIONS);
4370     glVersion = (const char *) glGetString(GL_VERSION);
4371     if (gl_handle != NULL) {
4372         pglXGetProcAddressARB = wine_dlsym(gl_handle, "glXGetProcAddressARB", NULL, 0);
4373     }
4374
4375     /* Parse the GL version string */
4376     num_parsed = sscanf(glVersion, "%d.%d.%d", &major, &minor, &patch);
4377     if (num_parsed == 1) {
4378         minor = 0;
4379         patch = 0;
4380     } else if (num_parsed == 2) {
4381         patch = 0;
4382     }
4383     TRACE("GL version %d.%d.%d\n", major, minor, patch);
4384
4385     /* And starts to fill the extension context properly */
4386     memset(&GL_extensions, 0, sizeof(GL_extensions));
4387     TRACE("GL supports following extensions used by Wine :\n");
4388
4389     /* Mirrored Repeat extension :
4390         - GL_ARB_texture_mirrored_repeat
4391         - GL_IBM_texture_mirrored_repeat
4392         - GL >= 1.4
4393     */
4394     if ((strstr(glExtensions, "GL_ARB_texture_mirrored_repeat")) ||
4395         (strstr(glExtensions, "GL_IBM_texture_mirrored_repeat")) ||
4396         (major > 1) ||
4397         ((major == 1) && (minor >= 4))) {
4398         TRACE(" - mirrored repeat\n");
4399         GL_extensions.mirrored_repeat = TRUE;
4400     }
4401
4402     /* Texture LOD Bias :
4403         - GL_EXT_texture_lod_bias
4404     */
4405     if (strstr(glExtensions, "GL_EXT_texture_lod_bias")) {
4406         TRACE(" - texture lod bias\n");
4407         GL_extensions.mipmap_lodbias = TRUE;
4408     }
4409
4410     /* For all subsequent extensions, we need glXGetProcAddress */
4411     if (pglXGetProcAddressARB != NULL) {
4412         /* Multi-texturing :
4413             - GL_ARB_multitexture
4414             - GL >= 1.2.1
4415         */
4416         if ((strstr(glExtensions, "GL_ARB_multitexture")) ||
4417             (major > 1) ||
4418             ((major == 1) && (minor > 2)) ||
4419             ((major == 1) && (minor == 2) && (patch >= 1))) {
4420             glGetIntegerv(GL_MAX_TEXTURE_UNITS_WINE, &(GL_extensions.max_texture_units));
4421             TRACE(" - multi-texturing (%d stages)\n", GL_extensions.max_texture_units);
4422             /* We query the ARB version to be the most portable we can... */
4423             GL_extensions.glActiveTexture = pglXGetProcAddressARB( (const GLubyte *) "glActiveTextureARB");
4424             GL_extensions.glMultiTexCoord[0] = pglXGetProcAddressARB( (const GLubyte *) "glMultiTexCoord1fvARB");
4425             GL_extensions.glMultiTexCoord[1] = pglXGetProcAddressARB( (const GLubyte *) "glMultiTexCoord2fvARB");
4426             GL_extensions.glMultiTexCoord[2] = pglXGetProcAddressARB( (const GLubyte *) "glMultiTexCoord3fvARB");
4427             GL_extensions.glMultiTexCoord[3] = pglXGetProcAddressARB( (const GLubyte *) "glMultiTexCoord4fvARB");
4428             GL_extensions.glClientActiveTexture = pglXGetProcAddressARB( (const GLubyte *) "glClientActiveTextureARB");
4429         } else {
4430             GL_extensions.max_texture_units = 0;
4431         }
4432
4433         if (strstr(glExtensions, "GL_EXT_texture_compression_s3tc")) {
4434             TRACE(" - S3TC compression supported\n");
4435             GL_extensions.s3tc_compressed_texture = TRUE;
4436             GL_extensions.glCompressedTexImage2D = pglXGetProcAddressARB( (const GLubyte *) "glCompressedTexImage2DARB");
4437             GL_extensions.glCompressedTexSubImage2D = pglXGetProcAddressARB( (const GLubyte *) "glCompressedTexSubImage2DARB");
4438         }
4439     }
4440
4441     /* Fill the D3D capabilities according to what GL tells us... */
4442     fill_caps();
4443
4444     /* And frees this now-useless context */
4445     glXMakeCurrent(display, None, NULL);
4446     glXDestroyContext(display, gl_context);
4447     LEAVE_GL();
4448
4449     return TRUE;
4450 }