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

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