?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix gcc 4.0 warnings.
[wine/multimedia.git] / dlls / d3d8 / directx.c
blob363e7735f2980d41811ca054b92dcc7c566dff26
1 /*
2 * IDirect3D8 implementation
3 *
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
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
25 #include <stdarg.h>
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
35
36 #include "d3d8_private.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
39 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
40
41 /* x11drv GDI escapes */
42 #define X11DRV_ESCAPE 6789
43 enum x11drv_escape_codes
44 {
45 X11DRV_GET_DISPLAY, /* get X11 display for a DC */
46 X11DRV_GET_DRAWABLE, /* get current drawable for a DC */
47 X11DRV_GET_FONT, /* get current X font for a DC */
48 };
49
50 #define NUM_FORMATS 7
51 static const D3DFORMAT device_formats[NUM_FORMATS] = {
52 D3DFMT_P8,
53 D3DFMT_R3G3B2,
54 D3DFMT_R5G6B5,
55 D3DFMT_X1R5G5B5,
56 D3DFMT_X4R4G4B4,
57 D3DFMT_R8G8B8,
58 D3DFMT_X8R8G8B8
59 };
60
61 static void IDirect3D8Impl_FillGLCaps(LPDIRECT3D8 iface, Display* display);
62
63
64 /* retrieve the X display to use on a given DC */
65 inline static Display *get_display( HDC hdc )
66 {
67 Display *display;
68 enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
69
70 if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
71 sizeof(display), (LPSTR)&display )) display = NULL;
72 return display;
73 }
74
75 /* IDirect3D IUnknown parts follow: */
76 HRESULT WINAPI IDirect3D8Impl_QueryInterface(LPDIRECT3D8 iface,REFIID riid,LPVOID *ppobj)
77 {
78 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
79
80 if (IsEqualGUID(riid, &IID_IUnknown)
81 || IsEqualGUID(riid, &IID_IDirect3D8)) {
82 IDirect3D8Impl_AddRef(iface);
83 *ppobj = This;
84 return D3D_OK;
85 }
86
87 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
88 return E_NOINTERFACE;
89 }
90
91 ULONG WINAPI IDirect3D8Impl_AddRef(LPDIRECT3D8 iface) {
92 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
93 ULONG ref = InterlockedIncrement(&This->ref);
94
95 TRACE("(%p) : AddRef from %ld\n", This, ref - 1);
96
97 return ref;
98 }
99
100 ULONG WINAPI IDirect3D8Impl_Release(LPDIRECT3D8 iface) {
101 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
102 ULONG ref = InterlockedDecrement(&This->ref);
103
104 TRACE("(%p) : ReleaseRef to %ld\n", This, ref);
105
106 if (ref == 0) {
107 IWineD3D_Release(This->WineD3D);
108 HeapFree(GetProcessHeap(), 0, This);
109 }
110 return ref;
111 }
112
113 /* IDirect3D Interface follow: */
114 HRESULT WINAPI IDirect3D8Impl_RegisterSoftwareDevice (LPDIRECT3D8 iface, void* pInitializeFunction) {
115 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
116 return IWineD3D_RegisterSoftwareDevice(This->WineD3D, pInitializeFunction);
117 }
118
119 UINT WINAPI IDirect3D8Impl_GetAdapterCount (LPDIRECT3D8 iface) {
120 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
121 return IWineD3D_GetAdapterCount(This->WineD3D);
122 }
123
124 HRESULT WINAPI IDirect3D8Impl_GetAdapterIdentifier (LPDIRECT3D8 iface,
125 UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) {
126 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
127 WINED3DADAPTER_IDENTIFIER adapter_id;
128
129 /* dx8 and dx9 have different structures to be filled in, with incompatible
130 layouts so pass in pointers to the places to be filled via an internal
131 structure */
132 adapter_id.Driver = pIdentifier->Driver;
133 adapter_id.Description = pIdentifier->Description;
134 adapter_id.DeviceName = NULL;
135 adapter_id.DriverVersion = &pIdentifier->DriverVersion;
136 adapter_id.VendorId = &pIdentifier->VendorId;
137 adapter_id.DeviceId = &pIdentifier->DeviceId;
138 adapter_id.SubSysId = &pIdentifier->SubSysId;
139 adapter_id.Revision = &pIdentifier->Revision;
140 adapter_id.DeviceIdentifier = &pIdentifier->DeviceIdentifier;
141 adapter_id.WHQLLevel = &pIdentifier->WHQLLevel;
142
143 return IWineD3D_GetAdapterIdentifier(This->WineD3D, Adapter, Flags, &adapter_id);
144 }
145
146 UINT WINAPI IDirect3D8Impl_GetAdapterModeCount (LPDIRECT3D8 iface,UINT Adapter) {
147 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
148 return IWineD3D_GetAdapterModeCount(This->WineD3D, Adapter, D3DFMT_UNKNOWN);
149 }
150
151 HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes (LPDIRECT3D8 iface, UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode) {
152 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
153 return IWineD3D_EnumAdapterModes(This->WineD3D, Adapter, D3DFMT_UNKNOWN, Mode, pMode);
154 }
155
156 HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode (LPDIRECT3D8 iface, UINT Adapter, D3DDISPLAYMODE* pMode) {
157 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
158 return IWineD3D_GetAdapterDisplayMode(This->WineD3D, Adapter, pMode);
159 }
160
161 HRESULT WINAPI IDirect3D8Impl_CheckDeviceType (LPDIRECT3D8 iface,
162 UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat,
163 D3DFORMAT BackBufferFormat, BOOL Windowed) {
164 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
165 return IWineD3D_CheckDeviceType(This->WineD3D, Adapter, CheckType, DisplayFormat,
166 BackBufferFormat, Windowed);
167 }
168
169 HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat (LPDIRECT3D8 iface,
170 UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
171 DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
172 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
173 return IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, AdapterFormat,
174 Usage, RType, CheckFormat);
175 }
176
177 HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType(LPDIRECT3D8 iface,
178 UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat,
179 BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) {
180 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
181 return IWineD3D_CheckDeviceMultiSampleType(This->WineD3D, Adapter, DeviceType, SurfaceFormat,
182 Windowed, MultiSampleType, NULL);
183 }
184
185 HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch(LPDIRECT3D8 iface,
186 UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
187 D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) {
188 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
189 return IWineD3D_CheckDepthStencilMatch(This->WineD3D, Adapter, DeviceType, AdapterFormat,
190 RenderTargetFormat, DepthStencilFormat);
191 }
192
193 HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) {
194 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
195 HRESULT hrc = D3D_OK;
196 WINED3DCAPS *pWineCaps;
197
198 TRACE("(%p) Relay %d %u %p \n", This, Adapter, DeviceType, pCaps);
199
200 if(NULL == pCaps){
201 return D3DERR_INVALIDCALL;
202 }
203 pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
204 if(pWineCaps == NULL){
205 return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
206 }
207 D3D8CAPSTOWINECAPS(pCaps, pWineCaps)
208 hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
209 HeapFree(GetProcessHeap(), 0, pWineCaps);
210 TRACE("(%p) returning %p\n", This, pCaps);
211 return hrc;
212 }
213
214 HMONITOR WINAPI IDirect3D8Impl_GetAdapterMonitor(LPDIRECT3D8 iface, UINT Adapter) {
215 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
216 return IWineD3D_GetAdapterMonitor(This->WineD3D, Adapter);
217 }
218
219 static void IDirect3D8Impl_FillGLCaps(LPDIRECT3D8 iface, Display* display) {
220 const char *GL_Extensions = NULL;
221 const char *GLX_Extensions = NULL;
222 GLint gl_max;
223 const char* gl_string = NULL;
224 const char* gl_string_cursor = NULL;
225 Bool test = 0;
226 int major, minor;
227 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
228
229 if (This->gl_info.bIsFilled) return;
230 This->gl_info.bIsFilled = 1;
231
232 TRACE_(d3d_caps)("(%p, %p)\n", This, display);
233
234 if (NULL != display) {
235 test = glXQueryVersion(display, &major, &minor);
236 This->gl_info.glx_version = ((major & 0x0000FFFF) << 16) | (minor & 0x0000FFFF);
237 gl_string = glXGetClientString(display, GLX_VENDOR);
238 } else {
239 gl_string = (const char*) glGetString(GL_VENDOR);
240 }
241
242 if (strstr(gl_string, "NVIDIA")) {
243 This->gl_info.gl_vendor = VENDOR_NVIDIA;
244 } else if (strstr(gl_string, "ATI")) {
245 This->gl_info.gl_vendor = VENDOR_ATI;
246 } else {
247 This->gl_info.gl_vendor = VENDOR_WINE;
248 }
249
250 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), This->gl_info.gl_vendor);
251
252 gl_string = (const char*) glGetString(GL_VERSION);
253 switch (This->gl_info.gl_vendor) {
254 case VENDOR_NVIDIA:
255 gl_string_cursor = strstr(gl_string, "NVIDIA");
256 gl_string_cursor = strstr(gl_string_cursor, " ");
257 while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
258 if (*gl_string_cursor) {
259 char tmp[16];
260 int cursor = 0;
261
262 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
263 tmp[cursor++] = *gl_string_cursor;
264 ++gl_string_cursor;
265 }
266 tmp[cursor] = 0;
267 major = atoi(tmp);
268
269 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
270 ++gl_string_cursor;
271
272 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
273 tmp[cursor++] = *gl_string_cursor;
274 ++gl_string_cursor;
275 }
276 tmp[cursor] = 0;
277 minor = atoi(tmp);
278 break;
279 }
280 case VENDOR_ATI:
281 major = minor = 0;
282 gl_string_cursor = strchr(gl_string, '-');
283 if (gl_string_cursor) {
284 int error = 0;
285 gl_string_cursor++;
286
287 /* Check if version number is of the form x.y.z */
288 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
289 error = 1;
290 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
291 error = 1;
292 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
293 error = 1;
294 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
295 error = 1;
296 /* Mark version number as malformed */
297 if (error)
298 gl_string_cursor = 0;
299 }
300 if (!gl_string_cursor)
301 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
302 else {
303 major = *gl_string_cursor - '0';
304 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
305 }
306 break;
307 default:
308 major = 0;
309 minor = 9;
310 }
311 This->gl_info.gl_driver_version = MAKEDWORD_VERSION(major, minor);
312
313 FIXME_(d3d_caps)("found GL_VERSION (%s)->(0x%08lx)\n", debugstr_a(gl_string), This->gl_info.gl_driver_version);
314
315 gl_string = (const char*) glGetString(GL_RENDERER);
316 strcpy(This->gl_info.gl_renderer, gl_string);
317
318 switch (This->gl_info.gl_vendor) {
319 case VENDOR_NVIDIA:
320 if (strstr(This->gl_info.gl_renderer, "GeForce4 Ti")) {
321 This->gl_info.gl_card = CARD_NVIDIA_GEFORCE4_TI4600;
322 } else if (strstr(This->gl_info.gl_renderer, "GeForceFX")) {
323 This->gl_info.gl_card = CARD_NVIDIA_GEFORCEFX_5900ULTRA;
324 } else {
325 This->gl_info.gl_card = CARD_NVIDIA_GEFORCE4_TI4600;
326 }
327 break;
328 case VENDOR_ATI:
329 if (strstr(This->gl_info.gl_renderer, "RADEON 9800 PRO")) {
330 This->gl_info.gl_card = CARD_ATI_RADEON_9800PRO;
331 } else if (strstr(This->gl_info.gl_renderer, "RADEON 9700 PRO")) {
332 This->gl_info.gl_card = CARD_ATI_RADEON_9700PRO;
333 } else {
334 This->gl_info.gl_card = CARD_ATI_RADEON_8500;
335 }
336 break;
337 default:
338 This->gl_info.gl_card = CARD_WINE;
339 break;
340 }
341
342 FIXME_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(This->gl_info.gl_renderer), This->gl_info.gl_card);
343
344 /*
345 * Initialize openGL extension related variables
346 * with Default values
347 */
348 memset(&This->gl_info.supported, 0, sizeof(This->gl_info.supported));
349 This->gl_info.max_textures = 1;
350 This->gl_info.ps_arb_version = PS_VERSION_NOT_SUPPORTED;
351 This->gl_info.vs_arb_version = VS_VERSION_NOT_SUPPORTED;
352 This->gl_info.vs_nv_version = VS_VERSION_NOT_SUPPORTED;
353 This->gl_info.vs_ati_version = VS_VERSION_NOT_SUPPORTED;
354
355 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = NULL;
356 GL_EXT_FUNCS_GEN;
357 #undef USE_GL_FUNC
358
359 /* Retrieve opengl defaults */
360 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
361 This->gl_info.max_clipplanes = min(MAX_CLIPPLANES, gl_max);
362 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
363
364 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
365 This->gl_info.max_lights = gl_max;
366 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
367
368 /* Parse the gl supported features, in theory enabling parts of our code appropriately */
369 GL_Extensions = (const char*) glGetString(GL_EXTENSIONS);
370 TRACE_(d3d_caps)("GL_Extensions reported:\n");
371
372 if (NULL == GL_Extensions) {
373 ERR(" GL_Extensions returns NULL\n");
374 } else {
375 while (*GL_Extensions != 0x00) {
376 const char *Start = GL_Extensions;
377 char ThisExtn[256];
378
379 memset(ThisExtn, 0x00, sizeof(ThisExtn));
380 while (*GL_Extensions != ' ' && *GL_Extensions != 0x00) {
381 GL_Extensions++;
382 }
383 memcpy(ThisExtn, Start, (GL_Extensions - Start));
384 TRACE_(d3d_caps)("- %s\n", ThisExtn);
385
386 /**
387 * ARB
388 */
389 if (strcmp(ThisExtn, "GL_ARB_fragment_program") == 0) {
390 This->gl_info.ps_arb_version = PS_VERSION_11;
391 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - version=%02x\n", This->gl_info.ps_arb_version);
392 This->gl_info.supported[ARB_FRAGMENT_PROGRAM] = TRUE;
393 } else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
394 TRACE_(d3d_caps)(" FOUND: ARB Multisample support\n");
395 This->gl_info.supported[ARB_MULTISAMPLE] = TRUE;
396 } else if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
397 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
398 TRACE_(d3d_caps)(" FOUND: ARB Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%u\n", gl_max);
399 This->gl_info.supported[ARB_MULTITEXTURE] = TRUE;
400 This->gl_info.max_textures = min(8, gl_max);
401 } else if (strcmp(ThisExtn, "GL_ARB_texture_cube_map") == 0) {
402 TRACE_(d3d_caps)(" FOUND: ARB Texture Cube Map support\n");
403 This->gl_info.supported[ARB_TEXTURE_CUBE_MAP] = TRUE;
404 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
405 This->gl_info.supported[NV_TEXGEN_REFLECTION] = TRUE;
406 } else if (strcmp(ThisExtn, "GL_ARB_texture_compression") == 0) {
407 TRACE_(d3d_caps)(" FOUND: ARB Texture Compression support\n");
408 This->gl_info.supported[ARB_TEXTURE_COMPRESSION] = TRUE;
409 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_add") == 0) {
410 TRACE_(d3d_caps)(" FOUND: ARB Texture Env Add support\n");
411 This->gl_info.supported[ARB_TEXTURE_ENV_ADD] = TRUE;
412 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_combine") == 0) {
413 TRACE_(d3d_caps)(" FOUND: ARB Texture Env combine support\n");
414 This->gl_info.supported[ARB_TEXTURE_ENV_COMBINE] = TRUE;
415 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_dot3") == 0) {
416 TRACE_(d3d_caps)(" FOUND: ARB Dot3 support\n");
417 This->gl_info.supported[ARB_TEXTURE_ENV_DOT3] = TRUE;
418 } else if (strcmp(ThisExtn, "GL_ARB_texture_border_clamp") == 0) {
419 TRACE_(d3d_caps)(" FOUND: ARB Texture border clamp support\n");
420 This->gl_info.supported[ARB_TEXTURE_BORDER_CLAMP] = TRUE;
421 } else if (strcmp(ThisExtn, "GL_ARB_texture_mirrored_repeat") == 0) {
422 TRACE_(d3d_caps)(" FOUND: ARB Texture mirrored repeat support\n");
423 This->gl_info.supported[ARB_TEXTURE_MIRRORED_REPEAT] = TRUE;
424 } else if (strstr(ThisExtn, "GL_ARB_vertex_program")) {
425 This->gl_info.vs_arb_version = VS_VERSION_11;
426 TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - version=%02x\n", This->gl_info.vs_arb_version);
427 This->gl_info.supported[ARB_VERTEX_PROGRAM] = TRUE;
428
429 /**
430 * EXT
431 */
432 } else if (strcmp(ThisExtn, "GL_EXT_fog_coord") == 0) {
433 TRACE_(d3d_caps)(" FOUND: EXT Fog coord support\n");
434 This->gl_info.supported[EXT_FOG_COORD] = TRUE;
435 } else if (strcmp(ThisExtn, "GL_EXT_paletted_texture") == 0) { /* handle paletted texture extensions */
436 TRACE_(d3d_caps)(" FOUND: EXT Paletted texture support\n");
437 This->gl_info.supported[EXT_PALETTED_TEXTURE] = TRUE;
438 } else if (strcmp(ThisExtn, "GL_EXT_point_parameters") == 0) {
439 TRACE_(d3d_caps)(" FOUND: EXT Point parameters support\n");
440 This->gl_info.supported[EXT_POINT_PARAMETERS] = TRUE;
441 } else if (strcmp(ThisExtn, "GL_EXT_secondary_color") == 0) {
442 TRACE_(d3d_caps)(" FOUND: EXT Secondary coord support\n");
443 This->gl_info.supported[EXT_SECONDARY_COLOR] = TRUE;
444 } else if (strcmp(ThisExtn, "GL_EXT_stencil_wrap") == 0) {
445 TRACE_(d3d_caps)(" FOUND: EXT Stencil wrap support\n");
446 This->gl_info.supported[EXT_STENCIL_WRAP] = TRUE;
447 } else if (strcmp(ThisExtn, "GL_EXT_texture_compression_s3tc") == 0) {
448 TRACE_(d3d_caps)(" FOUND: EXT Texture S3TC compression support\n");
449 This->gl_info.supported[EXT_TEXTURE_COMPRESSION_S3TC] = TRUE;
450 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_add") == 0) {
451 TRACE_(d3d_caps)(" FOUND: EXT Texture Env Add support\n");
452 This->gl_info.supported[EXT_TEXTURE_ENV_ADD] = TRUE;
453 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_combine") == 0) {
454 TRACE_(d3d_caps)(" FOUND: EXT Texture Env combine support\n");
455 This->gl_info.supported[EXT_TEXTURE_ENV_COMBINE] = TRUE;
456 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_dot3") == 0) {
457 TRACE_(d3d_caps)(" FOUND: EXT Dot3 support\n");
458 This->gl_info.supported[EXT_TEXTURE_ENV_DOT3] = TRUE;
459 } else if (strcmp(ThisExtn, "GL_EXT_texture_filter_anisotropic") == 0) {
460 TRACE_(d3d_caps)(" FOUND: EXT Texture Anisotropic filter support\n");
461 This->gl_info.supported[EXT_TEXTURE_FILTER_ANISOTROPIC] = TRUE;
462 } else if (strcmp(ThisExtn, "GL_EXT_texture_lod") == 0) {
463 TRACE_(d3d_caps)(" FOUND: EXT Texture LOD support\n");
464 This->gl_info.supported[EXT_TEXTURE_LOD] = TRUE;
465 } else if (strcmp(ThisExtn, "GL_EXT_texture_lod_bias") == 0) {
466 TRACE_(d3d_caps)(" FOUND: EXT Texture LOD bias support\n");
467 This->gl_info.supported[EXT_TEXTURE_LOD_BIAS] = TRUE;
468 } else if (strcmp(ThisExtn, "GL_EXT_vertex_weighting") == 0) {
469 TRACE_(d3d_caps)(" FOUND: EXT Vertex weighting support\n");
470 This->gl_info.supported[EXT_VERTEX_WEIGHTING] = TRUE;
471
472 /**
473 * NVIDIA
474 */
475 } else if (strstr(ThisExtn, "GL_NV_fog_distance")) {
476 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Fog Distance support\n");
477 This->gl_info.supported[NV_FOG_DISTANCE] = TRUE;
478 } else if (strstr(ThisExtn, "GL_NV_fragment_program")) {
479 This->gl_info.ps_nv_version = PS_VERSION_11;
480 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Pixel Shader support - version=%02x\n", This->gl_info.ps_nv_version);
481 } else if (strcmp(ThisExtn, "GL_NV_register_combiners") == 0) {
482 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (1) support\n");
483 This->gl_info.supported[NV_REGISTER_COMBINERS] = TRUE;
484 } else if (strcmp(ThisExtn, "GL_NV_register_combiners2") == 0) {
485 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (2) support\n");
486 This->gl_info.supported[NV_REGISTER_COMBINERS2] = TRUE;
487 } else if (strcmp(ThisExtn, "GL_NV_texgen_reflection") == 0) {
488 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Gen Reflection support\n");
489 This->gl_info.supported[NV_TEXGEN_REFLECTION] = TRUE;
490 } else if (strcmp(ThisExtn, "GL_NV_texture_env_combine4") == 0) {
491 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Env combine (4) support\n");
492 This->gl_info.supported[NV_TEXTURE_ENV_COMBINE4] = TRUE;
493 } else if (strcmp(ThisExtn, "GL_NV_texture_shader") == 0) {
494 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (1) support\n");
495 This->gl_info.supported[NV_TEXTURE_SHADER] = TRUE;
496 } else if (strcmp(ThisExtn, "GL_NV_texture_shader2") == 0) {
497 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (2) support\n");
498 This->gl_info.supported[NV_TEXTURE_SHADER2] = TRUE;
499 } else if (strcmp(ThisExtn, "GL_NV_texture_shader3") == 0) {
500 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (3) support\n");
501 This->gl_info.supported[NV_TEXTURE_SHADER3] = TRUE;
502 } else if (strstr(ThisExtn, "GL_NV_vertex_program")) {
503 This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program1_1")) ? VS_VERSION_11 : VS_VERSION_10);
504 This->gl_info.vs_nv_version = max(This->gl_info.vs_nv_version, (0 == strcmp(ThisExtn, "GL_NV_vertex_program2")) ? VS_VERSION_20 : VS_VERSION_10);
505 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Vertex Shader support - version=%02x\n", This->gl_info.vs_nv_version);
506 This->gl_info.supported[NV_VERTEX_PROGRAM] = TRUE;
507
508 /**
509 * ATI
510 */
511 /** TODO */
512 } else if (strcmp(ThisExtn, "GL_ATI_texture_env_combine3") == 0) {
513 TRACE_(d3d_caps)(" FOUND: ATI Texture Env combine (3) support\n");
514 This->gl_info.supported[ATI_TEXTURE_ENV_COMBINE3] = TRUE;
515 } else if (strcmp(ThisExtn, "GL_ATI_texture_mirror_once") == 0) {
516 TRACE_(d3d_caps)(" FOUND: ATI Texture Mirror Once support\n");
517 This->gl_info.supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE;
518 } else if (strcmp(ThisExtn, "GL_EXT_vertex_shader") == 0) {
519 This->gl_info.vs_ati_version = VS_VERSION_11;
520 TRACE_(d3d_caps)(" FOUND: ATI (EXT) Vertex Shader support - version=%02x\n", This->gl_info.vs_ati_version);
521 This->gl_info.supported[EXT_VERTEX_SHADER] = TRUE;
522 }
523
524
525 if (*GL_Extensions == ' ') GL_Extensions++;
526 }
527 }
528
529 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = (type) glXGetProcAddressARB( (const GLubyte *) #pfn);
530 GL_EXT_FUNCS_GEN;
531 #undef USE_GL_FUNC
532
533 if (display != NULL) {
534 GLX_Extensions = glXQueryExtensionsString(display, DefaultScreen(display));
535 TRACE_(d3d_caps)("GLX_Extensions reported:\n");
536
537 if (NULL == GLX_Extensions) {
538 ERR(" GLX_Extensions returns NULL\n");
539 } else {
540 while (*GLX_Extensions != 0x00) {
541 const char *Start = GLX_Extensions;
542 char ThisExtn[256];
543
544 memset(ThisExtn, 0x00, sizeof(ThisExtn));
545 while (*GLX_Extensions != ' ' && *GLX_Extensions != 0x00) {
546 GLX_Extensions++;
547 }
548 memcpy(ThisExtn, Start, (GLX_Extensions - Start));
549 TRACE_(d3d_caps)("- %s\n", ThisExtn);
550 if (*GLX_Extensions == ' ') GLX_Extensions++;
551 }
552 }
553 }
554
555 #define USE_GL_FUNC(type, pfn) This->gl_info.pfn = (type) glXGetProcAddressARB( (const GLubyte *) #pfn);
556 GLX_EXT_FUNCS_GEN;
557 #undef USE_GL_FUNC
558
559 /* Only save the values obtained when a display is provided */
560 if (display != NULL) This->isGLInfoValid = TRUE;
561
562 }
563
564 /* Internal function called back during the CreateDevice to create a render target */
565 HRESULT WINAPI D3D8CB_CreateRenderTarget(IUnknown *device, UINT Width, UINT Height,
566 WINED3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample,
567 DWORD MultisampleQuality, BOOL Lockable,
568 IWineD3DSurface** ppSurface, HANDLE* pSharedHandle) {
569 HRESULT res = D3D_OK;
570 IDirect3DSurface8Impl *d3dSurface = NULL;
571
572 /* Note - Throw away MultisampleQuality and SharedHandle - only relevant for d3d9 */
573 res = IDirect3DDevice8_CreateRenderTarget((IDirect3DDevice8 *)device, Width, Height,
574 (D3DFORMAT)Format, MultiSample, Lockable,
575 (IDirect3DSurface8 **)&d3dSurface);
576 if (res == D3D_OK) {
577 *ppSurface = d3dSurface->wineD3DSurface;
578 }
579 return res;
580 }
581
582 /* Callback for creating the inplicite swapchain when the device is created */
583 HRESULT WINAPI D3D8CB_CreateAdditionalSwapChain(IUnknown *device,
584 WINED3DPRESENT_PARAMETERS* pPresentationParameters,
585 IWineD3DSwapChain ** ppSwapChain){
586 HRESULT res = D3D_OK;
587 IDirect3DSwapChain8Impl *d3dSwapChain = NULL;
588 /* We have to pass the presentation parameters back and forth */
589 D3DPRESENT_PARAMETERS localParameters;
590 localParameters.BackBufferWidth = *(pPresentationParameters->BackBufferWidth);
591 localParameters.BackBufferHeight = *(pPresentationParameters->BackBufferHeight);
592 localParameters.BackBufferFormat = *(pPresentationParameters->BackBufferFormat);
593 localParameters.BackBufferCount = *(pPresentationParameters->BackBufferCount);
594 localParameters.MultiSampleType = *(pPresentationParameters->MultiSampleType);
595 /* d3d9 only */
596 /* localParameters.MultiSampleQuality = *(pPresentationParameters->MultiSampleQuality); */
597 localParameters.SwapEffect = *(pPresentationParameters->SwapEffect);
598 localParameters.hDeviceWindow = *(pPresentationParameters->hDeviceWindow);
599 localParameters.Windowed = *(pPresentationParameters->Windowed);
600 localParameters.EnableAutoDepthStencil = *(pPresentationParameters->EnableAutoDepthStencil);
601 localParameters.AutoDepthStencilFormat = *(pPresentationParameters->AutoDepthStencilFormat);
602 localParameters.Flags = *(pPresentationParameters->Flags);
603 localParameters.FullScreen_RefreshRateInHz = *(pPresentationParameters->FullScreen_RefreshRateInHz);
604 /* not in d3d8 */
605 /* localParameters.PresentationInterval = *(pPresentationParameters->PresentationInterval); */
606
607 TRACE("(%p) rellaying\n", device);
608 /*copy the presentation parameters*/
609 res = IDirect3DDevice8_CreateAdditionalSwapChain((IDirect3DDevice8 *)device, &localParameters, (IDirect3DSwapChain8 **)&d3dSwapChain);
610
611 if (res == D3D_OK){
612 *ppSwapChain = d3dSwapChain->wineD3DSwapChain;
613 } else {
614 FIXME("failed to create additional swap chain\n");
615 *ppSwapChain = NULL;
616 }
617 /* Copy back the presentation parameters */
618 TRACE("(%p) setting up return parameters\n", device);
619 *pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
620 *pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
621 *pPresentationParameters->BackBufferFormat = localParameters.BackBufferFormat;
622 *pPresentationParameters->BackBufferCount = localParameters.BackBufferCount;
623 *pPresentationParameters->MultiSampleType = localParameters.MultiSampleType;
624 /* *pPresentationParameters->MultiSampleQuality leave alone in case wined3d set something internally */
625 *pPresentationParameters->SwapEffect = localParameters.SwapEffect;
626 *pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow;
627 *pPresentationParameters->Windowed = localParameters.Windowed;
628 *pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil;
629 *pPresentationParameters->AutoDepthStencilFormat = localParameters.AutoDepthStencilFormat;
630 *pPresentationParameters->Flags = localParameters.Flags;
631 *pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz;
632 /* *pPresentationParameters->PresentationInterval leave alone in case wined3d set something internally */
633
634 return res;
635 }
636
637 HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface,
638 UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
639 DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters,
640 IDirect3DDevice8** ppReturnedDeviceInterface) {
641 IDirect3DDevice8Impl *object;
642 HWND whichHWND;
643 int num;
644 XVisualInfo template;
645 HDC hDc;
646 WINED3DPRESENT_PARAMETERS localParameters;
647
648 IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
649 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %lx, PresParms: %p, RetDevInt: %p)\n", This, Adapter, DeviceType,
650 hFocusWindow, BehaviourFlags, pPresentationParameters, ppReturnedDeviceInterface);
651
652 if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) {
653 return D3DERR_INVALIDCALL;
654 }
655
656 /* Allocate the storage for the device */
657 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDevice8Impl));
658 if (NULL == object) {
659 return D3DERR_OUTOFVIDEOMEMORY;
660 }
661 object->lpVtbl = &Direct3DDevice8_Vtbl;
662 object->ref = 1;
663 object->direct3d8 = This;
664 /** The device AddRef the direct3d8 Interface else crash in propers clients codes */
665 IDirect3D8_AddRef((LPDIRECT3D8) object->direct3d8);
666
667 /* Allocate an associated WineD3DDevice object */
668 localParameters.BackBufferWidth = &pPresentationParameters->BackBufferWidth;
669 localParameters.BackBufferHeight = &pPresentationParameters->BackBufferHeight;
670 localParameters.BackBufferFormat = &pPresentationParameters->BackBufferFormat;
671 localParameters.BackBufferCount = &pPresentationParameters->BackBufferCount;
672 localParameters.MultiSampleType = &pPresentationParameters->MultiSampleType;
673 localParameters.MultiSampleQuality = NULL; /* New at dx9 */
674 localParameters.SwapEffect = &pPresentationParameters->SwapEffect;
675 localParameters.hDeviceWindow = &pPresentationParameters->hDeviceWindow;
676 localParameters.Windowed = &pPresentationParameters->Windowed;
677 localParameters.EnableAutoDepthStencil = &pPresentationParameters->EnableAutoDepthStencil;
678 localParameters.AutoDepthStencilFormat = &pPresentationParameters->AutoDepthStencilFormat;
679 localParameters.Flags = &pPresentationParameters->Flags;
680 localParameters.FullScreen_RefreshRateInHz = &pPresentationParameters->FullScreen_RefreshRateInHz;
681 localParameters.PresentationInterval = &pPresentationParameters->FullScreen_PresentationInterval; /* Renamed in dx9 */
682 IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &localParameters, &object->WineD3DDevice, (IUnknown *)object, D3D8CB_CreateAdditionalSwapChain);
683
684 /** use StateBlock Factory here, for creating the startup stateBlock */
685 object->StateBlock = NULL;
686 IDirect3DDeviceImpl_CreateStateBlock(object, D3DSBT_ALL, NULL);
687 object->UpdateStateBlock = object->StateBlock;
688
689 /* Save the creation parameters */
690 object->CreateParms.AdapterOrdinal = Adapter;
691 object->CreateParms.DeviceType = DeviceType;
692 object->CreateParms.hFocusWindow = hFocusWindow;
693 object->CreateParms.BehaviorFlags = BehaviourFlags;
694
695 *ppReturnedDeviceInterface = (LPDIRECT3DDEVICE8) object;
696
697 /* Initialize settings */
698 object->PresentParms.BackBufferCount = 1; /* Opengl only supports one? */
699 object->adapterNo = Adapter;
700 object->devType = DeviceType;
701
702 /* Initialize openGl - Note the visual is chosen as the window is created and the glcontext cannot
703 use different properties after that point in time. FIXME: How to handle when requested format
704 doesn't match actual visual? Cannot choose one here - code removed as it ONLY works if the one
705 it chooses is identical to the one already being used! */
706 /* FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat */
707
708 /* Which hwnd are we using? */
709 whichHWND = pPresentationParameters->hDeviceWindow;
710 if (!whichHWND) {
711 whichHWND = hFocusWindow;
712 }
713 object->win_handle = whichHWND;
714 object->win = (Window)GetPropA( whichHWND, "__wine_x11_whole_window" );
715
716 hDc = GetDC(whichHWND);
717 object->display = get_display(hDc);
718
719 TRACE("(%p)->(DepthStencil:(%u,%s), BackBufferFormat:(%u,%s))\n", This,
720 pPresentationParameters->AutoDepthStencilFormat, debug_d3dformat(pPresentationParameters->AutoDepthStencilFormat),
721 pPresentationParameters->BackBufferFormat, debug_d3dformat(pPresentationParameters->BackBufferFormat));
722
723 ENTER_GL();
724
725 /* Create a context based off the properties of the existing visual */
726 template.visualid = (VisualID)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id");
727 object->visInfo = XGetVisualInfo(object->display, VisualIDMask, &template, &num);
728 if (NULL == object->visInfo) {
729 ERR("cannot really get XVisual\n");
730 LEAVE_GL();
731 return D3DERR_NOTAVAILABLE;
732 }
733 object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE);
734 if (NULL == object->glCtx) {
735 ERR("cannot create glxContext\n");
736 LEAVE_GL();
737 return D3DERR_NOTAVAILABLE;
738 }
739 LEAVE_GL();
740
741 ReleaseDC(whichHWND, hDc);
742
743 if (object->glCtx == NULL) {
744 ERR("Error in context creation !\n");
745 return D3DERR_INVALIDCALL;
746 } else {
747 TRACE("Context created (HWND=%p, glContext=%p, Window=%ld, VisInfo=%p)\n",
748 whichHWND, object->glCtx, object->win, object->visInfo);
749 }
750
751 /* If not windowed, need to go fullscreen, and resize the HWND to the appropriate */
752 /* dimensions */
753 if (!pPresentationParameters->Windowed) {
754 #if 1
755 DEVMODEW devmode;
756 HDC hdc;
757 int bpp = 0;
758 memset(&devmode, 0, sizeof(DEVMODEW));
759 devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
760 MultiByteToWideChar(CP_ACP, 0, "Gamers CG", -1, devmode.dmDeviceName, CCHDEVICENAME);
761 hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
762 bpp = GetDeviceCaps(hdc, BITSPIXEL);
763 DeleteDC(hdc);
764 devmode.dmBitsPerPel = (bpp >= 24) ? 32 : bpp;/*Stupid XVidMode cannot change bpp D3DFmtGetBpp(object, pPresentationParameters->BackBufferFormat);*/
765 devmode.dmPelsWidth = pPresentationParameters->BackBufferWidth;
766 devmode.dmPelsHeight = pPresentationParameters->BackBufferHeight;
767 ChangeDisplaySettingsExW(devmode.dmDeviceName, &devmode, object->win_handle, CDS_FULLSCREEN, NULL);
768 #else
769 FIXME("Requested full screen support not implemented, expect windowed operation\n");
770 #endif
771
772 /* Make popup window */
773 SetWindowLongA(whichHWND, GWL_STYLE, WS_POPUP);
774 SetWindowPos(object->win_handle, HWND_TOP, 0, 0,
775 pPresentationParameters->BackBufferWidth,
776 pPresentationParameters->BackBufferHeight, SWP_SHOWWINDOW | SWP_FRAMECHANGED);
777 }
778
779 TRACE("Creating back buffer\n");
780 /* MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero,
781 then the corresponding dimension of the client area of the hDeviceWindow
782 (or the focus window, if hDeviceWindow is NULL) is taken. */
783 if (pPresentationParameters->Windowed && ((pPresentationParameters->BackBufferWidth == 0) ||
784 (pPresentationParameters->BackBufferHeight == 0))) {
785 RECT Rect;
786
787 GetClientRect(whichHWND, &Rect);
788
789 if (pPresentationParameters->BackBufferWidth == 0) {
790 pPresentationParameters->BackBufferWidth = Rect.right;
791 TRACE("Updating width to %d\n", pPresentationParameters->BackBufferWidth);
792 }
793 if (pPresentationParameters->BackBufferHeight == 0) {
794 pPresentationParameters->BackBufferHeight = Rect.bottom;
795 TRACE("Updating height to %d\n", pPresentationParameters->BackBufferHeight);
796 }
797 }
798
799 /* Save the presentation parms now filled in correctly */
800 memcpy(&object->PresentParms, pPresentationParameters, sizeof(D3DPRESENT_PARAMETERS));
801
802
803 IDirect3DDevice8Impl_CreateRenderTarget((LPDIRECT3DDEVICE8) object,
804 pPresentationParameters->BackBufferWidth,
805 pPresentationParameters->BackBufferHeight,
806 pPresentationParameters->BackBufferFormat,
807 pPresentationParameters->MultiSampleType,
808 TRUE,
809 (LPDIRECT3DSURFACE8*) &object->frontBuffer);
810
811 IDirect3DDevice8Impl_CreateRenderTarget((LPDIRECT3DDEVICE8) object,
812 pPresentationParameters->BackBufferWidth,
813 pPresentationParameters->BackBufferHeight,
814 pPresentationParameters->BackBufferFormat,
815 pPresentationParameters->MultiSampleType,
816 TRUE,
817 (LPDIRECT3DSURFACE8*) &object->backBuffer);
818
819 if (pPresentationParameters->EnableAutoDepthStencil) {
820 IDirect3DDevice8Impl_CreateDepthStencilSurface((LPDIRECT3DDEVICE8) object,
821 pPresentationParameters->BackBufferWidth,
822 pPresentationParameters->BackBufferHeight,
823 pPresentationParameters->AutoDepthStencilFormat,
824 D3DMULTISAMPLE_NONE,
825 (LPDIRECT3DSURFACE8*) &object->depthStencilBuffer);
826 } else {
827 object->depthStencilBuffer = NULL;
828 }
829 TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil @ %p\n",object->frontBuffer, object->backBuffer, object->depthStencilBuffer);
830
831 /* init the default renderTarget management */
832 object->drawable = object->win;
833 object->render_ctx = object->glCtx;
834 object->renderTarget = object->backBuffer;
835 IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) object->renderTarget);
836 object->stencilBufferTarget = object->depthStencilBuffer;
837 if (NULL != object->stencilBufferTarget) {
838 IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) object->stencilBufferTarget);
839 }
840
841 ENTER_GL();
842
843 if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) {
844 ERR("Error in setting current context (context %p drawable %ld)!\n", object->glCtx, object->win);
845 }
846 checkGLcall("glXMakeCurrent");
847
848 /* Clear the screen */
849 glClearColor(1.0, 0.0, 0.0, 0.0);
850 checkGLcall("glClearColor");
851 glColor3f(1.0, 1.0, 1.0);
852 checkGLcall("glColor3f");
853
854 glEnable(GL_LIGHTING);
855 checkGLcall("glEnable");
856
857 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
858 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
859
860 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
861 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
862
863 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
864 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
865
866 /*
867 * Initialize openGL extension related variables
868 * with Default values
869 */
870 IDirect3D8Impl_FillGLCaps(iface, object->display);
871
872 /* Setup all the devices defaults */
873 IDirect3DDeviceImpl_InitStartupStateBlock(object);
874
875 LEAVE_GL();
876
877 { /* Set a default viewport */
878 D3DVIEWPORT8 vp;
879 vp.X = 0;
880 vp.Y = 0;
881 vp.Width = pPresentationParameters->BackBufferWidth;
882 vp.Height = pPresentationParameters->BackBufferHeight;
883 vp.MinZ = 0.0f;
884 vp.MaxZ = 1.0f;
885 IDirect3DDevice8Impl_SetViewport((LPDIRECT3DDEVICE8) object, &vp);
886 }
887
888 /* Initialize the current view state */
889 object->modelview_valid = 1;
890 object->proj_valid = 0;
891 object->view_ident = 1;
892 object->last_was_rhw = 0;
893 glGetIntegerv(GL_MAX_LIGHTS, &object->maxConcurrentLights);
894 TRACE("(%p,%d) All defaults now set up, leaving CreateDevice with %p\n", This, Adapter, object);
895
896 /* Clear the screen */
897 IDirect3DDevice8Impl_Clear((LPDIRECT3DDEVICE8) object, 0, NULL, D3DCLEAR_STENCIL|D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET, 0x00, 1.0, 0);
898
899 return D3D_OK;
900 }
901
902 const IDirect3D8Vtbl Direct3D8_Vtbl =
903 {
904 IDirect3D8Impl_QueryInterface,
905 IDirect3D8Impl_AddRef,
906 IDirect3D8Impl_Release,
907 IDirect3D8Impl_RegisterSoftwareDevice,
908 IDirect3D8Impl_GetAdapterCount,
909 IDirect3D8Impl_GetAdapterIdentifier,
910 IDirect3D8Impl_GetAdapterModeCount,
911 IDirect3D8Impl_EnumAdapterModes,
912 IDirect3D8Impl_GetAdapterDisplayMode,
913 IDirect3D8Impl_CheckDeviceType,
914 IDirect3D8Impl_CheckDeviceFormat,
915 IDirect3D8Impl_CheckDeviceMultiSampleType,
916 IDirect3D8Impl_CheckDepthStencilMatch,
917 IDirect3D8Impl_GetDeviceCaps,
918 IDirect3D8Impl_GetAdapterMonitor,
919 IDirect3D8Impl_CreateDevice
920 };
Maarten's multimedia branch