2 * Direct3D wine internal interface main
4 * Copyright 2002-2003 The wine-d3d team
5 * Copyright 2002-2003 Raphael Junqueira
6 * Copyright 2004 Jason Edmeades
7 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
8 * Copyright 2009 Henri Verbeet for CodeWeavers
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wine/port.h"
29 #include "wined3d_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
32 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
34 struct wined3d_wndproc
39 struct wined3d_device
*device
;
42 struct wined3d_wndproc_table
44 struct wined3d_wndproc
*entries
;
49 static struct wined3d_wndproc_table wndproc_table
;
51 static CRITICAL_SECTION wined3d_cs
;
52 static CRITICAL_SECTION_DEBUG wined3d_cs_debug
=
55 {&wined3d_cs_debug
.ProcessLocksList
,
56 &wined3d_cs_debug
.ProcessLocksList
},
57 0, 0, {(DWORD_PTR
)(__FILE__
": wined3d_cs")}
59 static CRITICAL_SECTION wined3d_cs
= {&wined3d_cs_debug
, -1, 0, 0, 0, 0};
61 static CRITICAL_SECTION wined3d_wndproc_cs
;
62 static CRITICAL_SECTION_DEBUG wined3d_wndproc_cs_debug
=
64 0, 0, &wined3d_wndproc_cs
,
65 {&wined3d_wndproc_cs_debug
.ProcessLocksList
,
66 &wined3d_wndproc_cs_debug
.ProcessLocksList
},
67 0, 0, {(DWORD_PTR
)(__FILE__
": wined3d_wndproc_cs")}
69 static CRITICAL_SECTION wined3d_wndproc_cs
= {&wined3d_wndproc_cs_debug
, -1, 0, 0, 0, 0};
71 /* When updating default value here, make sure to update winecfg as well,
72 * where appropriate. */
73 struct wined3d_settings wined3d_settings
=
75 TRUE
, /* Multithreaded CS by default. */
76 FALSE
, /* explicit_gl_version */
77 MAKEDWORD_VERSION(4, 4), /* Default to OpenGL 4.4 */
78 TRUE
, /* Use of GLSL enabled by default */
79 ORM_FBO
, /* Use FBOs to do offscreen rendering */
80 PCI_VENDOR_NONE
,/* PCI Vendor ID */
81 PCI_DEVICE_NONE
,/* PCI Device ID */
82 0, /* The default of memory is set in init_driver_info */
83 NULL
, /* No wine logo by default */
84 TRUE
, /* Prefer multisample textures to multisample renderbuffers. */
85 ~0u, /* Don't force a specific sample count by default. */
86 FALSE
, /* Don't range check relative addressing indices in float constants. */
87 ~0U, /* No VS shader model limit by default. */
88 ~0U, /* No HS shader model limit by default. */
89 ~0U, /* No DS shader model limit by default. */
90 ~0U, /* No GS shader model limit by default. */
91 ~0U, /* No PS shader model limit by default. */
92 ~0u, /* No CS shader model limit by default. */
93 FALSE
, /* 3D support enabled by default. */
96 struct wined3d
* CDECL
wined3d_create(DWORD flags
)
98 struct wined3d
*object
;
101 if (!(object
= heap_alloc_zero(FIELD_OFFSET(struct wined3d
, adapters
[1]))))
103 ERR("Failed to allocate wined3d object memory.\n");
107 if (wined3d_settings
.no_3d
)
108 flags
|= WINED3D_NO3D
;
110 hr
= wined3d_init(object
, flags
);
113 WARN("Failed to initialize wined3d object, hr %#x.\n", hr
);
118 TRACE("Created wined3d object %p.\n", object
);
123 static DWORD
get_config_key(HKEY defkey
, HKEY appkey
, const char *name
, char *buffer
, DWORD size
)
125 if (appkey
&& !RegQueryValueExA(appkey
, name
, 0, NULL
, (BYTE
*)buffer
, &size
)) return 0;
126 if (defkey
&& !RegQueryValueExA(defkey
, name
, 0, NULL
, (BYTE
*)buffer
, &size
)) return 0;
127 return ERROR_FILE_NOT_FOUND
;
130 static DWORD
get_config_key_dword(HKEY defkey
, HKEY appkey
, const char *name
, DWORD
*value
)
132 DWORD type
, data
, size
;
135 if (appkey
&& !RegQueryValueExA(appkey
, name
, 0, &type
, (BYTE
*)&data
, &size
) && type
== REG_DWORD
) goto success
;
137 if (defkey
&& !RegQueryValueExA(defkey
, name
, 0, &type
, (BYTE
*)&data
, &size
) && type
== REG_DWORD
) goto success
;
139 return ERROR_FILE_NOT_FOUND
;
146 static BOOL
wined3d_dll_init(HINSTANCE hInstDLL
)
148 DWORD wined3d_context_tls_idx
;
149 char buffer
[MAX_PATH
+10];
150 DWORD size
= sizeof(buffer
);
156 wined3d_context_tls_idx
= TlsAlloc();
157 if (wined3d_context_tls_idx
== TLS_OUT_OF_INDEXES
)
159 DWORD err
= GetLastError();
160 ERR("Failed to allocate context TLS index, err %#x.\n", err
);
163 context_set_tls_idx(wined3d_context_tls_idx
);
165 /* We need our own window class for a fake window which we use to retrieve GL capabilities */
166 /* We might need CS_OWNDC in the future if we notice strange things on Windows.
167 * Various articles/posts about OpenGL problems on Windows recommend this. */
168 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
169 wc
.lpfnWndProc
= DefWindowProcA
;
172 wc
.hInstance
= hInstDLL
;
173 wc
.hIcon
= LoadIconA(NULL
, (const char *)IDI_WINLOGO
);
174 wc
.hCursor
= LoadCursorA(NULL
, (const char *)IDC_ARROW
);
175 wc
.hbrBackground
= NULL
;
176 wc
.lpszMenuName
= NULL
;
177 wc
.lpszClassName
= WINED3D_OPENGL_WINDOW_CLASS_NAME
;
179 if (!RegisterClassA(&wc
))
181 ERR("Failed to register window class 'WineD3D_OpenGL'!\n");
182 if (!TlsFree(wined3d_context_tls_idx
))
184 DWORD err
= GetLastError();
185 ERR("Failed to free context TLS index, err %#x.\n", err
);
190 DisableThreadLibraryCalls(hInstDLL
);
192 /* @@ Wine registry key: HKCU\Software\Wine\Direct3D */
193 if ( RegOpenKeyA( HKEY_CURRENT_USER
, "Software\\Wine\\Direct3D", &hkey
) ) hkey
= 0;
195 len
= GetModuleFileNameA( 0, buffer
, MAX_PATH
);
196 if (len
&& len
< MAX_PATH
)
199 /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\Direct3D */
200 if (!RegOpenKeyA( HKEY_CURRENT_USER
, "Software\\Wine\\AppDefaults", &tmpkey
))
202 char *p
, *appname
= buffer
;
203 if ((p
= strrchr( appname
, '/' ))) appname
= p
+ 1;
204 if ((p
= strrchr( appname
, '\\' ))) appname
= p
+ 1;
205 strcat( appname
, "\\Direct3D" );
206 TRACE("appname = [%s]\n", appname
);
207 if (RegOpenKeyA( tmpkey
, appname
, &appkey
)) appkey
= 0;
208 RegCloseKey( tmpkey
);
214 if (!get_config_key_dword(hkey
, appkey
, "csmt", &wined3d_settings
.cs_multithreaded
))
215 ERR_(winediag
)("Setting multithreaded command stream to %#x.\n", wined3d_settings
.cs_multithreaded
);
216 if (!get_config_key_dword(hkey
, appkey
, "MaxVersionGL", &tmpvalue
))
218 ERR_(winediag
)("Setting maximum allowed wined3d GL version to %u.%u.\n",
219 tmpvalue
>> 16, tmpvalue
& 0xffff);
220 wined3d_settings
.explicit_gl_version
= TRUE
;
221 wined3d_settings
.max_gl_version
= tmpvalue
;
223 if ( !get_config_key( hkey
, appkey
, "UseGLSL", buffer
, size
) )
225 if (!strcmp(buffer
,"disabled"))
227 ERR_(winediag
)("The GLSL shader backend has been disabled. You get to keep all the pieces if it breaks.\n");
228 TRACE("Use of GL Shading Language disabled.\n");
229 wined3d_settings
.use_glsl
= FALSE
;
232 if (!get_config_key(hkey
, appkey
, "OffscreenRenderingMode", buffer
, size
)
233 && !strcmp(buffer
,"backbuffer"))
234 wined3d_settings
.offscreen_rendering_mode
= ORM_BACKBUFFER
;
235 if ( !get_config_key_dword( hkey
, appkey
, "VideoPciDeviceID", &tmpvalue
) )
237 int pci_device_id
= tmpvalue
;
239 /* A pci device id is 16-bit */
240 if(pci_device_id
> 0xffff)
242 ERR("Invalid value for VideoPciDeviceID. The value should be smaller or equal to 65535 or 0xffff\n");
246 TRACE("Using PCI Device ID %04x\n", pci_device_id
);
247 wined3d_settings
.pci_device_id
= pci_device_id
;
250 if ( !get_config_key_dword( hkey
, appkey
, "VideoPciVendorID", &tmpvalue
) )
252 int pci_vendor_id
= tmpvalue
;
254 /* A pci device id is 16-bit */
255 if(pci_vendor_id
> 0xffff)
257 ERR("Invalid value for VideoPciVendorID. The value should be smaller or equal to 65535 or 0xffff\n");
261 TRACE("Using PCI Vendor ID %04x\n", pci_vendor_id
);
262 wined3d_settings
.pci_vendor_id
= pci_vendor_id
;
265 if ( !get_config_key( hkey
, appkey
, "VideoMemorySize", buffer
, size
) )
267 int TmpVideoMemorySize
= atoi(buffer
);
268 if(TmpVideoMemorySize
> 0)
270 wined3d_settings
.emulated_textureram
= (UINT64
)TmpVideoMemorySize
*1024*1024;
271 TRACE("Use %iMiB = 0x%s bytes for emulated_textureram\n",
273 wine_dbgstr_longlong(wined3d_settings
.emulated_textureram
));
276 ERR("VideoMemorySize is %i but must be >0\n", TmpVideoMemorySize
);
278 if ( !get_config_key( hkey
, appkey
, "WineLogo", buffer
, size
) )
280 size_t len
= strlen(buffer
) + 1;
282 if (!(wined3d_settings
.logo
= heap_alloc(len
)))
283 ERR("Failed to allocate logo path memory.\n");
285 memcpy(wined3d_settings
.logo
, buffer
, len
);
287 if (!get_config_key_dword(hkey
, appkey
, "MultisampleTextures", &wined3d_settings
.multisample_textures
))
288 ERR_(winediag
)("Setting multisample textures to %#x.\n", wined3d_settings
.multisample_textures
);
289 if (!get_config_key_dword(hkey
, appkey
, "SampleCount", &wined3d_settings
.sample_count
))
290 ERR_(winediag
)("Forcing sample count to %u. This may not be compatible with all applications.\n",
291 wined3d_settings
.sample_count
);
292 if (!get_config_key(hkey
, appkey
, "CheckFloatConstants", buffer
, size
)
293 && !strcmp(buffer
, "enabled"))
295 TRACE("Checking relative addressing indices in float constants.\n");
296 wined3d_settings
.check_float_constants
= TRUE
;
298 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelVS", &wined3d_settings
.max_sm_vs
))
299 TRACE("Limiting VS shader model to %u.\n", wined3d_settings
.max_sm_vs
);
300 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelHS", &wined3d_settings
.max_sm_hs
))
301 TRACE("Limiting HS shader model to %u.\n", wined3d_settings
.max_sm_hs
);
302 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelDS", &wined3d_settings
.max_sm_ds
))
303 TRACE("Limiting DS shader model to %u.\n", wined3d_settings
.max_sm_ds
);
304 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelGS", &wined3d_settings
.max_sm_gs
))
305 TRACE("Limiting GS shader model to %u.\n", wined3d_settings
.max_sm_gs
);
306 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelPS", &wined3d_settings
.max_sm_ps
))
307 TRACE("Limiting PS shader model to %u.\n", wined3d_settings
.max_sm_ps
);
308 if (!get_config_key_dword(hkey
, appkey
, "MaxShaderModelCS", &wined3d_settings
.max_sm_cs
))
309 TRACE("Limiting CS shader model to %u.\n", wined3d_settings
.max_sm_cs
);
310 if (!get_config_key(hkey
, appkey
, "DirectDrawRenderer", buffer
, size
)
311 && !strcmp(buffer
, "gdi"))
313 TRACE("Disabling 3D support.\n");
314 wined3d_settings
.no_3d
= TRUE
;
318 if (appkey
) RegCloseKey( appkey
);
319 if (hkey
) RegCloseKey( hkey
);
324 static BOOL
wined3d_dll_destroy(HINSTANCE hInstDLL
)
326 DWORD wined3d_context_tls_idx
= context_get_tls_idx();
329 if (!TlsFree(wined3d_context_tls_idx
))
331 DWORD err
= GetLastError();
332 ERR("Failed to free context TLS index, err %#x.\n", err
);
335 for (i
= 0; i
< wndproc_table
.count
; ++i
)
337 /* Trying to unregister these would be futile. These entries can only
338 * exist if either we skipped them in wined3d_unregister_window() due
339 * to the application replacing the wndproc after the entry was
340 * registered, or if the application still has an active wined3d
341 * device. In the latter case the application has bigger problems than
343 WARN("Leftover wndproc table entry %p.\n", &wndproc_table
.entries
[i
]);
345 heap_free(wndproc_table
.entries
);
347 heap_free(wined3d_settings
.logo
);
348 UnregisterClassA(WINED3D_OPENGL_WINDOW_CLASS_NAME
, hInstDLL
);
350 DeleteCriticalSection(&wined3d_wndproc_cs
);
351 DeleteCriticalSection(&wined3d_cs
);
355 void WINAPI
wined3d_mutex_lock(void)
357 EnterCriticalSection(&wined3d_cs
);
360 void WINAPI
wined3d_mutex_unlock(void)
362 LeaveCriticalSection(&wined3d_cs
);
365 static void wined3d_wndproc_mutex_lock(void)
367 EnterCriticalSection(&wined3d_wndproc_cs
);
370 static void wined3d_wndproc_mutex_unlock(void)
372 LeaveCriticalSection(&wined3d_wndproc_cs
);
375 static struct wined3d_wndproc
*wined3d_find_wndproc(HWND window
)
379 for (i
= 0; i
< wndproc_table
.count
; ++i
)
381 if (wndproc_table
.entries
[i
].window
== window
)
383 return &wndproc_table
.entries
[i
];
390 static LRESULT CALLBACK
wined3d_wndproc(HWND window
, UINT message
, WPARAM wparam
, LPARAM lparam
)
392 struct wined3d_wndproc
*entry
;
393 struct wined3d_device
*device
;
397 wined3d_wndproc_mutex_lock();
398 entry
= wined3d_find_wndproc(window
);
402 wined3d_wndproc_mutex_unlock();
403 ERR("Window %p is not registered with wined3d.\n", window
);
404 return DefWindowProcW(window
, message
, wparam
, lparam
);
407 device
= entry
->device
;
408 unicode
= entry
->unicode
;
410 wined3d_wndproc_mutex_unlock();
413 return device_process_message(device
, window
, unicode
, message
, wparam
, lparam
, proc
);
415 return CallWindowProcW(proc
, window
, message
, wparam
, lparam
);
416 return CallWindowProcA(proc
, window
, message
, wparam
, lparam
);
419 BOOL
wined3d_register_window(HWND window
, struct wined3d_device
*device
)
421 struct wined3d_wndproc
*entry
;
423 wined3d_wndproc_mutex_lock();
425 if (wined3d_find_wndproc(window
))
427 wined3d_wndproc_mutex_unlock();
428 WARN("Window %p is already registered with wined3d.\n", window
);
432 if (!wined3d_array_reserve((void **)&wndproc_table
.entries
, &wndproc_table
.size
,
433 wndproc_table
.count
+ 1, sizeof(*entry
)))
435 wined3d_wndproc_mutex_unlock();
436 ERR("Failed to grow table.\n");
440 entry
= &wndproc_table
.entries
[wndproc_table
.count
++];
441 entry
->window
= window
;
442 entry
->unicode
= IsWindowUnicode(window
);
443 /* Set a window proc that matches the window. Some applications (e.g. NoX)
444 * replace the window proc after we've set ours, and expect to be able to
445 * call the previous one (ours) directly, without using CallWindowProc(). */
447 entry
->proc
= (WNDPROC
)SetWindowLongPtrW(window
, GWLP_WNDPROC
, (LONG_PTR
)wined3d_wndproc
);
449 entry
->proc
= (WNDPROC
)SetWindowLongPtrA(window
, GWLP_WNDPROC
, (LONG_PTR
)wined3d_wndproc
);
450 entry
->device
= device
;
452 wined3d_wndproc_mutex_unlock();
457 void wined3d_unregister_window(HWND window
)
459 struct wined3d_wndproc
*entry
, *last
;
462 wined3d_wndproc_mutex_lock();
464 if (!(entry
= wined3d_find_wndproc(window
)))
466 wined3d_wndproc_mutex_unlock();
467 ERR("Window %p is not registered with wined3d.\n", window
);
473 proc
= GetWindowLongPtrW(window
, GWLP_WNDPROC
);
474 if (proc
!= (LONG_PTR
)wined3d_wndproc
)
476 entry
->device
= NULL
;
477 wined3d_wndproc_mutex_unlock();
478 WARN("Not unregistering window %p, window proc %#lx doesn't match wined3d window proc %p.\n",
479 window
, proc
, wined3d_wndproc
);
483 SetWindowLongPtrW(window
, GWLP_WNDPROC
, (LONG_PTR
)entry
->proc
);
487 proc
= GetWindowLongPtrA(window
, GWLP_WNDPROC
);
488 if (proc
!= (LONG_PTR
)wined3d_wndproc
)
490 entry
->device
= NULL
;
491 wined3d_wndproc_mutex_unlock();
492 WARN("Not unregistering window %p, window proc %#lx doesn't match wined3d window proc %p.\n",
493 window
, proc
, wined3d_wndproc
);
497 SetWindowLongPtrA(window
, GWLP_WNDPROC
, (LONG_PTR
)entry
->proc
);
500 last
= &wndproc_table
.entries
[--wndproc_table
.count
];
501 if (entry
!= last
) *entry
= *last
;
503 wined3d_wndproc_mutex_unlock();
506 /* At process attach */
507 BOOL WINAPI
DllMain(HINSTANCE inst
, DWORD reason
, void *reserved
)
511 case DLL_PROCESS_ATTACH
:
512 return wined3d_dll_init(inst
);
514 case DLL_PROCESS_DETACH
:
516 return wined3d_dll_destroy(inst
);
519 case DLL_THREAD_DETACH
:
520 if (!context_set_current(NULL
))
522 ERR("Failed to clear current context.\n");