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