zontreck/wine
1
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine.git synced 2024-11-19 17:06:04 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'd3d9' into 'master'

Browse source 
d3d9: Implement Direct3DCreate9On12().

See merge request wine/wine!4915
This commit is contained in:
Mohamad Al-Jaf 2024-11-19 22:26:40 +00:00
commit 5f7ef9c304
8 changed files with 406 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
dlls/d3d9/d3d9.spec
View file

@ -12,3 +12,4 @@
@ stdcall DebugSetMute()
@ stdcall Direct3DCreate9(long)
@ stdcall Direct3DCreate9Ex(long ptr)
@ stdcall Direct3DCreate9On12(long ptr long)

28
dlls/d3d9/d3d9_main.c
View file

@ -41,7 +41,7 @@ IDirect3D9 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate9(UINT sdk_version)
if (!(object = calloc(1, sizeof(*object))))
return NULL;
if (!d3d9_init(object, FALSE))
if (!d3d9_init(object, FALSE, FALSE))
{
WARN("Failed to initialize d3d9.\n");
free(object);
@ -62,7 +62,7 @@ HRESULT WINAPI DECLSPEC_HOTPATCH Direct3DCreate9Ex(UINT sdk_version, IDirect3D9E
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
if (!d3d9_init(object, TRUE))
if (!d3d9_init(object, TRUE, FALSE))
{
WARN("Failed to initialize d3d9.\n");
free(object);
@ -75,6 +75,30 @@ HRESULT WINAPI DECLSPEC_HOTPATCH Direct3DCreate9Ex(UINT sdk_version, IDirect3D9E
return D3D_OK;
}
IDirect3D9 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate9On12(UINT sdk_version, D3D9ON12_ARGS *d3d9on12_args, UINT override_entries)
{
struct d3d9 *object;
BOOL d3d9on12 = TRUE;
TRACE("sdk_version %#x, d3d9on12_args %p, override_entries %#x.\n", sdk_version, d3d9on12_args, override_entries);
if (!(object = calloc(1, sizeof(*object))))
return NULL;
if (!d3d9on12_args || !d3d9on12_args->Enable9On12 || !override_entries)
d3d9on12 = FALSE;
if (!d3d9_init(object, TRUE, d3d9on12))
{
WARN("Failed to initialize d3d9.\n");
free(object);
return NULL;
}
TRACE("Created d3d9 object %p.\n", object);
return (IDirect3D9 *)&object->IDirect3D9Ex_iface;
}
/* The callback is called on any error encountered during validation, including
* improper IDirect3DShaderValidator9 method calls.
* - "file" and "line" are passed through directly from Instruction(). "line"

5
dlls/d3d9/d3d9_private.h
View file

@ -34,6 +34,7 @@
#include "wine/debug.h"
#include "d3d9.h"
#include "d3d9on12.h"
#include "wine/wined3d.h"
#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 256
@ -65,11 +66,12 @@ struct d3d9
struct wined3d_output **wined3d_outputs;
unsigned int wined3d_output_count;
BOOL extended;
BOOL d3d9on12;
};
void d3d9_caps_from_wined3dcaps(const struct d3d9 *d3d9, unsigned int adapter_ordinal,
D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps);
BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended);
BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended, BOOL d3d9on12);
struct fvf_declaration
{
@ -87,6 +89,7 @@ enum d3d9_device_state
struct d3d9_device
{
IDirect3DDevice9Ex IDirect3DDevice9Ex_iface;
IDirect3DDevice9On12 IDirect3DDevice9On12_iface;
struct wined3d_device_parent device_parent;
LONG refcount;
struct wined3d_device *wined3d_device;

72
dlls/d3d9/device.c
View file

@ -593,6 +593,61 @@ static void device_reset_viewport_state(struct d3d9_device *device)
wined3d_stateblock_set_scissor_rect(device->state, &rect);
}
static inline struct d3d9_device *impl_from_IDirect3DDevice9On12(IDirect3DDevice9On12 *iface)
{
return CONTAINING_RECORD(iface, struct d3d9_device, IDirect3DDevice9On12_iface);
}
static HRESULT WINAPI d3d9on12_QueryInterface(IDirect3DDevice9On12 *iface, REFIID iid, void **out)
{
return IDirect3DDevice9Ex_QueryInterface(iface, iid, out);
}
static ULONG WINAPI d3d9on12_AddRef(IDirect3DDevice9On12 *iface)
{
return IDirect3DDevice9Ex_AddRef(iface);
}
static ULONG WINAPI d3d9on12_Release(IDirect3DDevice9On12 *iface)
{
return IDirect3DDevice9Ex_Release(iface);
}
static HRESULT WINAPI d3d9on12_GetD3D12Device(IDirect3DDevice9On12 *iface, REFIID iid, void **out)
{
FIXME("iface %p, iid %s, out %p stub!\n", iface, debugstr_guid(iid), out);
if (!out)
return E_INVALIDARG;
*out = NULL;
return E_NOINTERFACE;
}
static HRESULT WINAPI d3d9on12_UnwrapUnderlyingResource(IDirect3DDevice9On12 *iface, IDirect3DResource9 *resource, ID3D12CommandQueue *queue, REFIID iid, void **out)
{
FIXME("iface %p, resource %p, queue %p, iid %s, out %p stub!\n", iface, resource, queue, debugstr_guid(iid), out);
return E_NOTIMPL;
}
static HRESULT WINAPI d3d9on12_ReturnUnderlyingResource(IDirect3DDevice9On12 *iface, IDirect3DResource9 *resource, UINT num_sync, UINT64 *signal_values, ID3D12Fence **fences)
{
FIXME("iface %p, resource %p, num_sync %#x, signal_values %p, fences %p stub!\n", iface, resource, num_sync, signal_values, fences);
return E_NOTIMPL;
}
static const struct IDirect3DDevice9On12Vtbl d3d9on12_vtbl =
{
/* IUnknown */
d3d9on12_QueryInterface,
d3d9on12_AddRef,
d3d9on12_Release,
/* IDirect3DDevice9On12 */
d3d9on12_GetD3D12Device,
d3d9on12_UnwrapUnderlyingResource,
d3d9on12_ReturnUnderlyingResource
};
static HRESULT WINAPI d3d9_device_QueryInterface(IDirect3DDevice9Ex *iface, REFIID riid, void **out)
{
TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
@ -623,6 +678,22 @@ static HRESULT WINAPI d3d9_device_QueryInterface(IDirect3DDevice9Ex *iface, REFI
return S_OK;
}
if (IsEqualGUID(riid, &IID_IDirect3DDevice9On12))
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
if (!device->d3d_parent->d3d9on12)
{
WARN("IDirect3D9 instance wasn't created with D3D9On12 enabled, returning E_NOINTERFACE.\n");
*out = NULL;
return E_NOINTERFACE;
}
IDirect3DDevice9Ex_AddRef(iface);
*out = &device->IDirect3DDevice9On12_iface;
return S_OK;
}
WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
*out = NULL;
@ -4668,6 +4739,7 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine
FIXME("Ignoring display mode.\n");
device->IDirect3DDevice9Ex_iface.lpVtbl = &d3d9_device_vtbl;
device->IDirect3DDevice9On12_iface.lpVtbl = &d3d9on12_vtbl;
device->device_parent.ops = &d3d9_wined3d_device_parent_ops;
device->adapter_ordinal = adapter;
device->refcount = 1;

3
dlls/d3d9/directx.c
View file

@ -683,7 +683,7 @@ static const struct IDirect3D9ExVtbl d3d9_vtbl =
d3d9_GetAdapterLUID,
};
BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended)
BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended, BOOL d3d9on12)
{
DWORD flags = WINED3D_PRESENT_CONVERSION | WINED3D_HANDLE_RESTORE | WINED3D_PIXEL_CENTER_INTEGER
| WINED3D_SRGB_READ_WRITE_CONTROL | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR
@ -736,6 +736,7 @@ BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended)
wined3d_mutex_unlock();
d3d9->extended = extended;
d3d9->d3d9on12 = d3d9on12;
return TRUE;
}

249
dlls/d3d9/tests/device.c
View file

@ -25,6 +25,19 @@
#define COBJMACROS
#include <d3d9.h>
#include "utils.h"
#include <initguid.h>
#include <d3d9on12.h>
#include <dxgi1_4.h>
static HMODULE d3d9_handle = 0;
static HMODULE d3d12_handle = 0;
static HMODULE dxgi_handle = 0;
static IDirect3D9 * (WINAPI *pDirect3DCreate9On12)(UINT sdk_version, D3D9ON12_ARGS *override_list, UINT override_entries);
static HRESULT (WINAPI *pCreateDXGIFactory2)(UINT flags, REFIID iid, void **factory);
static HRESULT (WINAPI *pD3D12CreateDevice)(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level, REFIID iid, void **device);
DEFINE_GUID(IID_IDeadbeef, 0xdeadbeef, 0xdead, 0xbeef, 0xde, 0xad, 0xbe, 0xee, 0xee, 0xee, 0xee, 0xef);
struct vec3
{
@ -15035,6 +15048,241 @@ static void test_window_position(void)
IDirect3D9_Release(d3d);
}
static BOOL init_d3d9on12_modules(void)
{
d3d9_handle = LoadLibraryA("d3d9.dll");
if (!d3d9_handle)
{
skip("Could not load d3d9.dll\n");
return FALSE;
}
dxgi_handle = LoadLibraryA("dxgi.dll");
if (!dxgi_handle)
{
skip("Could not load dxgi.dll\n");
return FALSE;
}
d3d12_handle = LoadLibraryA("d3d12.dll");
if (!d3d12_handle)
{
skip("Could not load d3d12.dll\n");
return FALSE;
}
pDirect3DCreate9On12 = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9On12");
if (!pDirect3DCreate9On12)
{
win_skip("Direct3DCreate9On12 is not supported, skipping d3d9on12 tests\n");
return FALSE;
}
pCreateDXGIFactory2 = (void *)GetProcAddress(dxgi_handle, "CreateDXGIFactory2");
if (!pCreateDXGIFactory2)
{
win_skip("CreateDXGIFactory2 is not supported, skipping d3d9on12 tests\n");
return FALSE;
}
pD3D12CreateDevice = (void *)GetProcAddress(d3d12_handle, "D3D12CreateDevice");
if (!pD3D12CreateDevice)
{
win_skip("D3D12CreateDevice is not supported, skipping d3d9on12 tests\n");
return FALSE;
}
return TRUE;
}
#define create_d3d9on12_device(out_d3d9, window, override_list, override_entries, out_device) \
create_d3d9on12_device_(__LINE__, out_d3d9, window, override_list, override_entries, out_device)
static HRESULT create_d3d9on12_device_(unsigned int line, IDirect3D9 **out_d3d9, HWND window, D3D9ON12_ARGS *override_list,
UINT override_entries, IDirect3DDevice9 **out_device)
{
IDirect3DDevice9On12 *d3d9on12 = (void *)0xdeadbeef;
IDirect3DDevice9 *device = (void *)0xdeadbeef;
IDirect3D9 *d3d9 = (void *)0xdeadbeef;
D3DPRESENT_PARAMETERS present_parameters;
HRESULT hr;
memset(&present_parameters, 0, sizeof(present_parameters));
present_parameters.Windowed = TRUE;
present_parameters.hDeviceWindow = window;
present_parameters.SwapEffect = D3DSWAPEFFECT_COPY;
present_parameters.BackBufferWidth = 640;
present_parameters.BackBufferHeight = 480;
present_parameters.EnableAutoDepthStencil = FALSE;
present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
SetLastError(0xdeadbeef);
d3d9 = pDirect3DCreate9On12(D3D_SDK_VERSION, override_list, override_entries);
ok_(__FILE__, line)(d3d9 != NULL, "got NULL d3d9 object\n");
hr = IDirect3D9_QueryInterface(d3d9, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok_(__FILE__, line)(hr == E_NOINTERFACE, "Got hr %#lx.\n", hr);
ok_(__FILE__, line)(d3d9on12 == NULL, "QueryInterface returned interface %p, expected NULL\n", d3d9on12);
hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow,
D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device);
*out_d3d9 = d3d9;
*out_device = device;
return hr;
}
static void test_d3d9on12(void)
{
IDirect3DDevice9On12 *d3d9on12_2 = (void *)0xdeadbeef;
IDirect3DDevice9On12 *d3d9on12 = (void *)0xdeadbeef;
IDirect3DDevice9 *device = (void *)0xdeadbeef;
IDirect3D9 *d3d9 = (void *)0xdeadbeef;
IDXGIAdapter *adapter = (void *)0xdeadbeef;
IDXGIFactory4 *factory = (void *)0xdeadbeef;
ID3D12Device *d3d12device = (void *)0xdeadbeef;
ID3D12Device *d3d12device_2 = (void *)0xdeadbeef;
D3D9ON12_ARGS override_list;
ULONG ref;
HRESULT hr;
HWND window = create_window();
if (!init_d3d9on12_modules())
{
win_skip("Failed to load d3d9on12 modules, skipping d3d9on12 tests.\n");
DestroyWindow(window);
return;
}
SetLastError(0xdeadbeef);
d3d9 = pDirect3DCreate9On12(D3D_SDK_VERSION, NULL, 0);
ok(d3d9 != NULL, "got NULL d3d9 object\n");
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
hr = create_d3d9on12_device(&d3d9, window, &override_list, 0, &device);
if (FAILED(hr))
{
win_skip("Failed to create a regular Direct3DDevice9, skipping d3d9on12 tests\n");
goto out;
}
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == E_NOINTERFACE, "Got hr %#lx.\n", hr);
ok(d3d9on12 == NULL, "QueryInterface returned interface %p, expected NULL\n", d3d9on12);
IDirect3DDevice9_Release(device);
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
override_list.Enable9On12 = TRUE;
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 0, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == E_NOINTERFACE, "Got hr %#lx.\n", hr);
ok(d3d9on12 == NULL, "QueryInterface returned interface %p, expected NULL\n", d3d9on12);
ref = IDirect3DDevice9_Release(device);
ok(ref == 0, "Got refcount %lu.\n", ref);
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 1, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == E_NOINTERFACE, "Got hr %#lx.\n", hr);
ok(d3d9on12 == NULL, "QueryInterface returned interface %p, expected NULL\n", d3d9on12);
ref = IDirect3DDevice9_Release(device);
ok(ref == 0, "Got refcount %lu.\n", ref);
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
override_list.Enable9On12 = TRUE;
override_list.NodeMask = 0xdeadbeef;
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 1, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9On12_QueryInterface(d3d9on12, &IID_IDirect3DDevice9On12, (void **)&d3d9on12_2);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
ref = IDirect3DDevice9On12_Release(d3d9on12_2);
todo_wine
ok(ref == 1, "Got refcount %lu.\n", ref);
ref = IDirect3DDevice9On12_Release(d3d9on12);
todo_wine
ok(ref == 0, "Got refcount %lu.\n", ref);
ref = IDirect3DDevice9_Release(device);
ok(ref == 0, "Got refcount %lu.\n", ref);
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
override_list.Enable9On12 = TRUE;
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 1, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9On12_GetD3D12Device(d3d9on12, NULL, NULL);
ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9On12_GetD3D12Device(d3d9on12, &IID_IDeadbeef, NULL);
ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
IDirect3DDevice9On12_Release(d3d9on12);
IDirect3DDevice9_Release(device);
IDirect3D9_Release(d3d9);
memset(&override_list, 0, sizeof(override_list));
override_list.Enable9On12 = TRUE;
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 0xdeadbeef, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
ref = IDirect3DDevice9On12_Release(d3d9on12);
todo_wine
ok(ref == 0, "Got refcount %lu.\n", ref);
ref = IDirect3DDevice9_Release(device);
ok(ref == 0, "Got refcount %lu.\n", ref);
IDirect3D9_Release(d3d9);
hr = pCreateDXGIFactory2(0, &IID_IDXGIFactory4, (void **)&factory);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDXGIFactory4_EnumAdapters(factory, 0, &adapter);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
IDXGIFactory4_Release(factory);
hr = pD3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&d3d12device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
IDXGIAdapter_Release(adapter);
memset(&override_list, 0, sizeof(override_list));
override_list.Enable9On12 = TRUE;
override_list.pD3D12Device = (IUnknown *)d3d12device;
d3d9on12 = (void *)0xdeadbeef;
hr = create_d3d9on12_device(&d3d9, window, &override_list, 1, &device);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9On12, (void **)&d3d9on12);
ok(hr == S_OK, "Got hr %#lx.\n", hr);
hr = IDirect3DDevice9On12_GetD3D12Device(d3d9on12, &IID_ID3D12Device, (void **)&d3d12device_2);
todo_wine
ok(hr == S_OK, "Got hr %#lx.\n", hr);
todo_wine
ok(override_list.pD3D12Device == (IUnknown *)d3d12device_2, "GetD3D12Device returned device %p, expected %p\n", d3d12device_2, override_list.pD3D12Device);
d3d12device_2 = (void *)0xdeadbeef;
hr = IDirect3DDevice9On12_GetD3D12Device(d3d9on12, &IID_IDeadbeef, (void **)&d3d12device_2);
ok(hr == E_NOINTERFACE, "Got hr %#lx.\n", hr);
ok(d3d12device_2 == NULL, "GetD3D12Device returned device %p, expected NULL\n", d3d12device_2);
ref = ID3D12Device_Release(d3d12device);
todo_wine
ok(ref == 28, "Got refcount %lu.\n", ref);
ref = IDirect3DDevice9On12_Release(d3d9on12);
todo_wine
ok(ref == 0, "Got refcount %lu.\n", ref);
ref = IDirect3DDevice9_Release(device);
ok(ref == 0, "Got refcount %lu.\n", ref);
out:
IDirect3D9_Release(d3d9);
DestroyWindow(window);
}
START_TEST(device)
{
HMODULE d3d9_handle = GetModuleHandleA("d3d9.dll");
@ -15171,6 +15419,7 @@ START_TEST(device)
test_creation_parameters();
test_cursor_clipping();
test_window_position();
test_d3d9on12();
UnregisterClassA("d3d9_test_wc", GetModuleHandleA(NULL));
}

1
include/Makefile.in
View file

@ -139,6 +139,7 @@ SOURCES = \
d3d8types.h \
d3d9.h \
d3d9caps.h \
d3d9on12.idl \
d3d9types.h \
d3dcaps.h \
d3dcommon.idl \

51
include/d3d9on12.idl Normal file
View file

@ -0,0 +1,51 @@
/*
* Copyright (C) 2024 Mohamad Al-Jaf
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
cpp_quote("#include <d3d9.h>")
import "d3d12.idl";
interface IDirect3D9;
interface IDirect3DResource9;
#define MAX_D3D9ON12_QUEUES 2
typedef struct D3D9ON12_ARGS
{
BOOL Enable9On12;
IUnknown *pD3D12Device;
IUnknown *ppD3D12Queues[MAX_D3D9ON12_QUEUES];
UINT NumQueues;
UINT NodeMask;
} D3D9ON12_ARGS;
typedef IDirect3D9 * (__stdcall *PFN_Direct3DCreate9On12)(UINT sdk_version, D3D9ON12_ARGS *override_list, UINT override_entries);
IDirect3D9 * __stdcall Direct3DCreate9On12(UINT,D3D9ON12_ARGS *,UINT);
typedef struct IDirect3DDevice9On12 *LPDIRECT3DDEVICE9ON12, *PDIRECT3DDEVICE9ON12;
[
local,
object,
uuid(e7fda234-b589-4049-940d-8878977531c8)
]
interface IDirect3DDevice9On12 : IUnknown
{
HRESULT GetD3D12Device(REFIID riid, void **out);
HRESULT UnwrapUnderlyingResource(IDirect3DResource9 *resource, ID3D12CommandQueue *queue, REFIID riid, void **out);
HRESULT ReturnUnderlyingResource(IDirect3DResource9 *resource, UINT num_sync, UINT64 *signal_values, ID3D12Fence **fences);
}