VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/directx.c@ 46525

Last change on this file since 46525 was 46521, checked in by vboxsync, 11 years ago

wine/new: export
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.9 KB
Line 
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
38WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
39
40static inline struct d3d8 *impl_from_IDirect3D8(IDirect3D8 *iface)
41{
42 return CONTAINING_RECORD(iface, struct d3d8, IDirect3D8_iface);
43}
44
45static HRESULT WINAPI d3d8_QueryInterface(IDirect3D8 *iface, REFIID riid, void **out)
46{
47 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
48
49 if (IsEqualGUID(riid, &IID_IDirect3D8)
50 || IsEqualGUID(riid, &IID_IUnknown))
51 {
52 IDirect3D8_AddRef(iface);
53 *out = iface;
54 return S_OK;
55 }
56
57 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
58
59 *out = NULL;
60 return E_NOINTERFACE;
61}
62
63static ULONG WINAPI d3d8_AddRef(IDirect3D8 *iface)
64{
65 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
66 ULONG refcount = InterlockedIncrement(&d3d8->refcount);
67
68 TRACE("%p increasing refcount to %u.\n", iface, refcount);
69
70 return refcount;
71}
72
73static ULONG WINAPI d3d8_Release(IDirect3D8 *iface)
74{
75 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
76 ULONG refcount = InterlockedDecrement(&d3d8->refcount);
77
78 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
79
80 if (!refcount)
81 {
82 wined3d_mutex_lock();
83 wined3d_decref(d3d8->wined3d);
84 wined3d_mutex_unlock();
85
86 HeapFree(GetProcessHeap(), 0, d3d8);
87 }
88
89 return refcount;
90}
91
92static HRESULT WINAPI d3d8_RegisterSoftwareDevice(IDirect3D8 *iface, void *init_function)
93{
94 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
95 HRESULT hr;
96
97 TRACE("iface %p, init_function %p.\n", iface, init_function);
98
99 wined3d_mutex_lock();
100 hr = wined3d_register_software_device(d3d8->wined3d, init_function);
101 wined3d_mutex_unlock();
102
103 return hr;
104}
105
106static UINT WINAPI d3d8_GetAdapterCount(IDirect3D8 *iface)
107{
108 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
109 HRESULT hr;
110
111 TRACE("iface %p.\n", iface);
112
113 wined3d_mutex_lock();
114 hr = wined3d_get_adapter_count(d3d8->wined3d);
115 wined3d_mutex_unlock();
116
117 return hr;
118}
119
120static HRESULT WINAPI d3d8_GetAdapterIdentifier(IDirect3D8 *iface, UINT adapter,
121 DWORD flags, D3DADAPTER_IDENTIFIER8 *identifier)
122{
123 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
124 struct wined3d_adapter_identifier adapter_id;
125 HRESULT hr;
126
127 TRACE("iface %p, adapter %u, flags %#x, identifier %p.\n",
128 iface, adapter, flags, identifier);
129
130 adapter_id.driver = identifier->Driver;
131 adapter_id.driver_size = sizeof(identifier->Driver);
132 adapter_id.description = identifier->Description;
133 adapter_id.description_size = sizeof(identifier->Description);
134 adapter_id.device_name = NULL; /* d3d9 only */
135 adapter_id.device_name_size = 0; /* d3d9 only */
136
137 wined3d_mutex_lock();
138 hr = wined3d_get_adapter_identifier(d3d8->wined3d, adapter, flags, &adapter_id);
139 wined3d_mutex_unlock();
140
141 identifier->DriverVersion = adapter_id.driver_version;
142 identifier->VendorId = adapter_id.vendor_id;
143 identifier->DeviceId = adapter_id.device_id;
144 identifier->SubSysId = adapter_id.subsystem_id;
145 identifier->Revision = adapter_id.revision;
146 memcpy(&identifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(identifier->DeviceIdentifier));
147 identifier->WHQLLevel = adapter_id.whql_level;
148
149 return hr;
150}
151
152static UINT WINAPI d3d8_GetAdapterModeCount(IDirect3D8 *iface, UINT adapter)
153{
154 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
155 HRESULT hr;
156
157 TRACE("iface %p, adapter %u.\n", iface, adapter);
158
159 wined3d_mutex_lock();
160 hr = wined3d_get_adapter_mode_count(d3d8->wined3d, adapter,
161 WINED3DFMT_UNKNOWN, WINED3D_SCANLINE_ORDERING_UNKNOWN);
162 wined3d_mutex_unlock();
163
164 return hr;
165}
166
167static HRESULT WINAPI d3d8_EnumAdapterModes(IDirect3D8 *iface, UINT adapter, UINT mode_idx, D3DDISPLAYMODE *mode)
168{
169 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
170 struct wined3d_display_mode wined3d_mode;
171 HRESULT hr;
172
173 TRACE("iface %p, adapter %u, mode_idx %u, mode %p.\n",
174 iface, adapter, mode_idx, mode);
175
176 wined3d_mutex_lock();
177 hr = wined3d_enum_adapter_modes(d3d8->wined3d, adapter, WINED3DFMT_UNKNOWN,
178 WINED3D_SCANLINE_ORDERING_UNKNOWN, mode_idx, &wined3d_mode);
179 wined3d_mutex_unlock();
180
181 if (SUCCEEDED(hr))
182 {
183 mode->Width = wined3d_mode.width;
184 mode->Height = wined3d_mode.height;
185 mode->RefreshRate = wined3d_mode.refresh_rate;
186 mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id);
187 }
188
189 return hr;
190}
191
192static HRESULT WINAPI d3d8_GetAdapterDisplayMode(IDirect3D8 *iface, UINT adapter, D3DDISPLAYMODE *mode)
193{
194 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
195 struct wined3d_display_mode wined3d_mode;
196 HRESULT hr;
197
198 TRACE("iface %p, adapter %u, mode %p.\n",
199 iface, adapter, mode);
200
201 wined3d_mutex_lock();
202 hr = wined3d_get_adapter_display_mode(d3d8->wined3d, adapter, &wined3d_mode, NULL);
203 wined3d_mutex_unlock();
204
205 if (SUCCEEDED(hr))
206 {
207 mode->Width = wined3d_mode.width;
208 mode->Height = wined3d_mode.height;
209 mode->RefreshRate = wined3d_mode.refresh_rate;
210 mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id);
211 }
212
213 return hr;
214}
215
216static HRESULT WINAPI d3d8_CheckDeviceType(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type,
217 D3DFORMAT display_format, D3DFORMAT backbuffer_format, BOOL windowed)
218{
219 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
220 HRESULT hr;
221
222 TRACE("iface %p, adapter %u, device_type %#x, display_format %#x, backbuffer_format %#x, windowed %#x.\n",
223 iface, adapter, device_type, display_format, backbuffer_format, windowed);
224
225 wined3d_mutex_lock();
226 hr = wined3d_check_device_type(d3d8->wined3d, adapter, device_type, wined3dformat_from_d3dformat(display_format),
227 wined3dformat_from_d3dformat(backbuffer_format), windowed);
228 wined3d_mutex_unlock();
229
230 return hr;
231}
232
233static HRESULT WINAPI d3d8_CheckDeviceFormat(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type,
234 D3DFORMAT adapter_format, DWORD usage, D3DRESOURCETYPE resource_type, D3DFORMAT format)
235{
236 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
237 enum wined3d_resource_type wined3d_rtype;
238 HRESULT hr;
239
240 TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n",
241 iface, adapter, device_type, adapter_format, usage, resource_type, format);
242
243 switch (resource_type)
244 {
245 case D3DRTYPE_VERTEXBUFFER:
246 case D3DRTYPE_INDEXBUFFER:
247 wined3d_rtype = WINED3D_RTYPE_BUFFER;
248 break;
249
250 default:
251 wined3d_rtype = resource_type;
252 break;
253 }
254
255 wined3d_mutex_lock();
256 hr = wined3d_check_device_format(d3d8->wined3d, adapter, device_type, wined3dformat_from_d3dformat(adapter_format),
257 usage, wined3d_rtype, wined3dformat_from_d3dformat(format));
258 wined3d_mutex_unlock();
259
260 return hr;
261}
262
263static HRESULT WINAPI d3d8_CheckDeviceMultiSampleType(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type,
264 D3DFORMAT format, BOOL windowed, D3DMULTISAMPLE_TYPE multisample_type)
265{
266 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
267 HRESULT hr;
268
269 TRACE("iface %p, adapter %u, device_type %#x, format %#x, windowed %#x, multisample_type %#x.\n",
270 iface, adapter, device_type, format, windowed, multisample_type);
271
272 wined3d_mutex_lock();
273 hr = wined3d_check_device_multisample_type(d3d8->wined3d, adapter, device_type,
274 wined3dformat_from_d3dformat(format), windowed,
275 (enum wined3d_multisample_type)multisample_type, NULL);
276 wined3d_mutex_unlock();
277
278 return hr;
279}
280
281static HRESULT WINAPI d3d8_CheckDepthStencilMatch(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type,
282 D3DFORMAT adapter_format, D3DFORMAT rt_format, D3DFORMAT ds_format)
283{
284 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
285 HRESULT hr;
286
287 TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, rt_format %#x, ds_format %#x.\n",
288 iface, adapter, device_type, adapter_format, rt_format, ds_format);
289
290 wined3d_mutex_lock();
291 hr = wined3d_check_depth_stencil_match(d3d8->wined3d, adapter, device_type,
292 wined3dformat_from_d3dformat(adapter_format), wined3dformat_from_d3dformat(rt_format),
293 wined3dformat_from_d3dformat(ds_format));
294 wined3d_mutex_unlock();
295
296 return hr;
297}
298
299void fixup_caps(WINED3DCAPS *caps)
300{
301 /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
302 if (caps->PixelShaderVersion)
303 caps->PixelShaderVersion = D3DPS_VERSION(1,4);
304 else
305 caps->PixelShaderVersion = D3DPS_VERSION(0,0);
306 if (caps->VertexShaderVersion)
307 caps->VertexShaderVersion = D3DVS_VERSION(1,1);
308 else
309 caps->VertexShaderVersion = D3DVS_VERSION(0,0);
310 caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
311
312 caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
313}
314
315static HRESULT WINAPI d3d8_GetDeviceCaps(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, D3DCAPS8 *caps)
316{
317 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
318 WINED3DCAPS *wined3d_caps;
319 HRESULT hr;
320
321 TRACE("iface %p, adapter %u, device_type %#x, caps %p.\n", iface, adapter, device_type, caps);
322
323 if (!caps)
324 return D3DERR_INVALIDCALL;
325
326 if (!(wined3d_caps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wined3d_caps))))
327 return D3DERR_INVALIDCALL;
328
329 wined3d_mutex_lock();
330 hr = wined3d_get_device_caps(d3d8->wined3d, adapter, device_type, wined3d_caps);
331 wined3d_mutex_unlock();
332
333 fixup_caps(wined3d_caps);
334 WINECAPSTOD3D8CAPS(caps, wined3d_caps)
335 HeapFree(GetProcessHeap(), 0, wined3d_caps);
336
337 return hr;
338}
339
340static HMONITOR WINAPI d3d8_GetAdapterMonitor(IDirect3D8 *iface, UINT adapter)
341{
342 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
343 HMONITOR ret;
344
345 TRACE("iface %p, adapter %u.\n", iface, adapter);
346
347 wined3d_mutex_lock();
348 ret = wined3d_get_adapter_monitor(d3d8->wined3d, adapter);
349 wined3d_mutex_unlock();
350
351 return ret;
352}
353
354static HRESULT WINAPI d3d8_CreateDevice(IDirect3D8 *iface, UINT adapter,
355 D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters,
356 IDirect3DDevice8 **device)
357{
358 struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
359 struct d3d8_device *object;
360 HRESULT hr;
361
362 TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, device %p.\n",
363 iface, adapter, device_type, focus_window, flags, parameters, device);
364
365 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
366 if (!object)
367 return E_OUTOFMEMORY;
368
369 hr = device_init(object, d3d8, d3d8->wined3d, adapter, device_type, focus_window, flags, parameters);
370 if (FAILED(hr))
371 {
372 WARN("Failed to initialize device, hr %#x.\n", hr);
373 HeapFree(GetProcessHeap(), 0, object);
374 return hr;
375 }
376
377 TRACE("Created device %p.\n", object);
378 *device = &object->IDirect3DDevice8_iface;
379
380 return D3D_OK;
381}
382
383static const struct IDirect3D8Vtbl d3d8_vtbl =
384{
385 /* IUnknown */
386 d3d8_QueryInterface,
387 d3d8_AddRef,
388 d3d8_Release,
389 /* IDirect3D8 */
390 d3d8_RegisterSoftwareDevice,
391 d3d8_GetAdapterCount,
392 d3d8_GetAdapterIdentifier,
393 d3d8_GetAdapterModeCount,
394 d3d8_EnumAdapterModes,
395 d3d8_GetAdapterDisplayMode,
396 d3d8_CheckDeviceType,
397 d3d8_CheckDeviceFormat,
398 d3d8_CheckDeviceMultiSampleType,
399 d3d8_CheckDepthStencilMatch,
400 d3d8_GetDeviceCaps,
401 d3d8_GetAdapterMonitor,
402 d3d8_CreateDevice,
403};
404
405BOOL d3d8_init(struct d3d8 *d3d8)
406{
407 DWORD flags = WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING;
408
409 d3d8->IDirect3D8_iface.lpVtbl = &d3d8_vtbl;
410 d3d8->refcount = 1;
411
412 wined3d_mutex_lock();
413 d3d8->wined3d = wined3d_create(8, flags);
414 wined3d_mutex_unlock();
415 if (!d3d8->wined3d)
416 return FALSE;
417
418 return TRUE;
419}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette