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