diff --git a/reactos/dll/directx/CMakeLists.txt b/reactos/dll/directx/CMakeLists.txt index b121b7cabc0..578e4f426c6 100644 --- a/reactos/dll/directx/CMakeLists.txt +++ b/reactos/dll/directx/CMakeLists.txt @@ -14,6 +14,7 @@ add_subdirectory(dplayx) add_subdirectory(dsound) #add_subdirectory(dsound_new) #disabled in trunk add_subdirectory(dxdiagn) +add_subdirectory(dxgi) #add_subdirectory(ksproxy) Not needed at the moment add_subdirectory(ksuser) add_subdirectory(msdmo) diff --git a/reactos/dll/directx/dxgi/CMakeLists.txt b/reactos/dll/directx/dxgi/CMakeLists.txt new file mode 100644 index 00000000000..10ce18f8bc6 --- /dev/null +++ b/reactos/dll/directx/dxgi/CMakeLists.txt @@ -0,0 +1,23 @@ + +add_definitions(-D__WINESRC__) +include_directories(BEFORE ${REACTOS_SOURCE_DIR}/include/reactos/wine) + +spec2def(dxgi.dll dxgi.spec ADD_IMPORTLIB) + +list(APPEND SOURCE + adapter.c + device.c + dxgi_main.c + factory.c + output.c + surface.c + swapchain.c + utils.c + ${CMAKE_CURRENT_BINARY_DIR}/dxgi.def) + +add_library(dxgi SHARED ${SOURCE} version.rc) +set_module_type(dxgi win32dll) +target_link_libraries(dxgi uuid dxgi_uuids wine) +add_importlibs(dxgi wined3d msvcrt kernel32 ntdll) +add_dependencies(dxgi wineheaders) +add_cd_file(TARGET dxgi DESTINATION reactos/system32 FOR all) diff --git a/reactos/dll/directx/dxgi/adapter.c b/reactos/dll/directx/dxgi/adapter.c new file mode 100644 index 00000000000..87d886b1995 --- /dev/null +++ b/reactos/dll/directx/dxgi/adapter.c @@ -0,0 +1,239 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static inline struct dxgi_adapter *impl_from_IWineDXGIAdapter(IWineDXGIAdapter *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_adapter, IWineDXGIAdapter_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_QueryInterface(IWineDXGIAdapter *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IDXGIAdapter) + || IsEqualGUID(riid, &IID_IWineDXGIAdapter)) + { + IUnknown_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_adapter_AddRef(IWineDXGIAdapter *iface) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + ULONG refcount = InterlockedIncrement(&This->refcount); + + TRACE("%p increasing refcount to %u\n", This, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_adapter_Release(IWineDXGIAdapter *iface) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + ULONG refcount = InterlockedDecrement(&This->refcount); + + TRACE("%p decreasing refcount to %u\n", This, refcount); + + if (!refcount) + { + IDXGIOutput_Release(This->output); + HeapFree(GetProcessHeap(), 0, This); + } + + return refcount; +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_SetPrivateData(IWineDXGIAdapter *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_SetPrivateDataInterface(IWineDXGIAdapter *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_GetPrivateData(IWineDXGIAdapter *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_GetParent(IWineDXGIAdapter *iface, REFIID riid, void **parent) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + + TRACE("iface %p, riid %s, parent %p\n", iface, debugstr_guid(riid), parent); + + return IWineDXGIFactory_QueryInterface(This->parent, riid, parent); +} + +/* IDXGIAdapter methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_EnumOutputs(IWineDXGIAdapter *iface, + UINT output_idx, IDXGIOutput **output) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + + TRACE("iface %p, output_idx %u, output %p.\n", iface, output_idx, output); + + if (output_idx > 0) + { + *output = NULL; + return DXGI_ERROR_NOT_FOUND; + } + + *output = This->output; + IDXGIOutput_AddRef(*output); + + TRACE("Returning output %p.\n", output); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_GetDesc(IWineDXGIAdapter *iface, DXGI_ADAPTER_DESC *desc) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + struct wined3d_adapter_identifier adapter_id; + char description[128]; + struct wined3d *wined3d; + HRESULT hr; + + TRACE("iface %p, desc %p.\n", iface, desc); + + if (!desc) return E_INVALIDARG; + + wined3d = IWineDXGIFactory_get_wined3d(This->parent); + adapter_id.driver_size = 0; + adapter_id.description = description; + adapter_id.description_size = sizeof(description); + adapter_id.device_name_size = 0; + + EnterCriticalSection(&dxgi_cs); + hr = wined3d_get_adapter_identifier(wined3d, This->ordinal, 0, &adapter_id); + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + + if (SUCCEEDED(hr)) + { + if (!MultiByteToWideChar(CP_ACP, 0, description, -1, desc->Description, 128)) + { + DWORD err = GetLastError(); + ERR("Failed to translate description %s (%#x).\n", debugstr_a(description), err); + hr = E_FAIL; + } + + desc->VendorId = adapter_id.vendor_id; + desc->DeviceId = adapter_id.device_id; + desc->SubSysId = adapter_id.subsystem_id; + desc->Revision = adapter_id.revision; + desc->DedicatedVideoMemory = adapter_id.video_memory; + desc->DedicatedSystemMemory = 0; /* FIXME */ + desc->SharedSystemMemory = 0; /* FIXME */ + memcpy(&desc->AdapterLuid, &adapter_id.adapter_luid, sizeof(desc->AdapterLuid)); + } + + return hr; +} + +static HRESULT STDMETHODCALLTYPE dxgi_adapter_CheckInterfaceSupport(IWineDXGIAdapter *iface, + REFGUID guid, LARGE_INTEGER *umd_version) +{ + FIXME("iface %p, guid %s, umd_version %p stub!\n", iface, debugstr_guid(guid), umd_version); + + return E_NOTIMPL; +} + +/* IWineDXGIAdapter methods */ + +static UINT STDMETHODCALLTYPE dxgi_adapter_get_ordinal(IWineDXGIAdapter *iface) +{ + struct dxgi_adapter *This = impl_from_IWineDXGIAdapter(iface); + + TRACE("iface %p, returning %u\n", iface, This->ordinal); + + return This->ordinal; +} + +static const struct IWineDXGIAdapterVtbl dxgi_adapter_vtbl = +{ + /* IUnknown methods */ + dxgi_adapter_QueryInterface, + dxgi_adapter_AddRef, + dxgi_adapter_Release, + /* IDXGIObject methods */ + dxgi_adapter_SetPrivateData, + dxgi_adapter_SetPrivateDataInterface, + dxgi_adapter_GetPrivateData, + dxgi_adapter_GetParent, + /* IDXGIAdapter methods */ + dxgi_adapter_EnumOutputs, + dxgi_adapter_GetDesc, + dxgi_adapter_CheckInterfaceSupport, + /* IWineDXGIAdapter methods */ + dxgi_adapter_get_ordinal, +}; + +HRESULT dxgi_adapter_init(struct dxgi_adapter *adapter, IWineDXGIFactory *parent, UINT ordinal) +{ + struct dxgi_output *output; + + adapter->IWineDXGIAdapter_iface.lpVtbl = &dxgi_adapter_vtbl; + adapter->parent = parent; + adapter->refcount = 1; + adapter->ordinal = ordinal; + + output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*output)); + if (!output) + { + return E_OUTOFMEMORY; + } + dxgi_output_init(output, adapter); + adapter->output = &output->IDXGIOutput_iface; + + return S_OK; +} diff --git a/reactos/dll/directx/dxgi/device.c b/reactos/dll/directx/dxgi/device.c new file mode 100644 index 00000000000..b8e6692c3d0 --- /dev/null +++ b/reactos/dll/directx/dxgi/device.c @@ -0,0 +1,429 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static inline struct dxgi_device *impl_from_IWineDXGIDevice(IWineDXGIDevice *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_device, IWineDXGIDevice_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_device_QueryInterface(IWineDXGIDevice *iface, REFIID riid, void **object) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + + TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IDXGIDevice) + || IsEqualGUID(riid, &IID_IWineDXGIDevice)) + { + IUnknown_AddRef(iface); + *object = iface; + return S_OK; + } + + if (This->child_layer) + { + TRACE("forwarding to child layer %p\n", This->child_layer); + return IUnknown_QueryInterface(This->child_layer, riid, object); + } + + WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_device_AddRef(IWineDXGIDevice *iface) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + ULONG refcount = InterlockedIncrement(&This->refcount); + + TRACE("%p increasing refcount to %u\n", This, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_device_Release(IWineDXGIDevice *iface) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + ULONG refcount = InterlockedDecrement(&This->refcount); + + TRACE("%p decreasing refcount to %u\n", This, refcount); + + if (!refcount) + { + if (This->child_layer) IUnknown_Release(This->child_layer); + EnterCriticalSection(&dxgi_cs); + wined3d_device_decref(This->wined3d_device); + LeaveCriticalSection(&dxgi_cs); + IWineDXGIFactory_Release(This->factory); + HeapFree(GetProcessHeap(), 0, This); + } + + return refcount; +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_device_SetPrivateData(IWineDXGIDevice *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_SetPrivateDataInterface(IWineDXGIDevice *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_GetPrivateData(IWineDXGIDevice *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_GetParent(IWineDXGIDevice *iface, REFIID riid, void **parent) +{ + IDXGIAdapter *adapter; + HRESULT hr; + + TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent); + + hr = IWineDXGIDevice_GetAdapter(iface, &adapter); + if (FAILED(hr)) + { + ERR("Failed to get adapter, hr %#x.\n", hr); + return hr; + } + + hr = IDXGIAdapter_QueryInterface(adapter, riid, parent); + IDXGIAdapter_Release(adapter); + + return hr; +} + +/* IDXGIDevice methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_device_GetAdapter(IWineDXGIDevice *iface, IDXGIAdapter **adapter) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + struct wined3d_device_creation_parameters create_parameters; + + TRACE("iface %p, adapter %p\n", iface, adapter); + + EnterCriticalSection(&dxgi_cs); + wined3d_device_get_creation_parameters(This->wined3d_device, &create_parameters); + LeaveCriticalSection(&dxgi_cs); + + return IWineDXGIFactory_EnumAdapters(This->factory, create_parameters.adapter_idx, adapter); +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_CreateSurface(IWineDXGIDevice *iface, + const DXGI_SURFACE_DESC *desc, UINT surface_count, DXGI_USAGE usage, + const DXGI_SHARED_RESOURCE *shared_resource, IDXGISurface **surface) +{ + struct wined3d_device_parent *device_parent; + IWineDXGIDeviceParent *dxgi_device_parent; + HRESULT hr; + UINT i; + UINT j; + + TRACE("iface %p, desc %p, surface_count %u, usage %#x, shared_resource %p, surface %p\n", + iface, desc, surface_count, usage, shared_resource, surface); + + hr = IWineDXGIDevice_QueryInterface(iface, &IID_IWineDXGIDeviceParent, (void **)&dxgi_device_parent); + if (FAILED(hr)) + { + ERR("Device should implement IWineD3DDeviceParent\n"); + return E_FAIL; + } + + device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent); + + FIXME("Implement DXGI<->wined3d usage conversion\n"); + + memset(surface, 0, surface_count * sizeof(*surface)); + for (i = 0; i < surface_count; ++i) + { + struct wined3d_surface *wined3d_surface; + IUnknown *parent; + + hr = device_parent->ops->create_swapchain_surface(device_parent, NULL, + desc->Width, desc->Height, wined3dformat_from_dxgi_format(desc->Format), usage, + desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE, + desc->SampleDesc.Quality, &wined3d_surface); + if (FAILED(hr)) + { + ERR("CreateSurface failed, returning %#x\n", hr); + goto fail; + } + + parent = wined3d_surface_get_parent(wined3d_surface); + hr = IUnknown_QueryInterface(parent, &IID_IDXGISurface, (void **)&surface[i]); + wined3d_surface_decref(wined3d_surface); + if (FAILED(hr)) + { + ERR("Surface should implement IDXGISurface\n"); + goto fail; + } + + TRACE("Created IDXGISurface %p (%u/%u)\n", surface[i], i + 1, surface_count); + } + IWineDXGIDeviceParent_Release(dxgi_device_parent); + + return S_OK; + +fail: + for (j = 0; j < i; ++j) + { + IDXGISurface_Release(surface[i]); + } + IWineDXGIDeviceParent_Release(dxgi_device_parent); + return hr; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_QueryResourceResidency(IWineDXGIDevice *iface, + IUnknown *const *resources, DXGI_RESIDENCY *residency, UINT resource_count) +{ + FIXME("iface %p, resources %p, residency %p, resource_count %u stub!\n", + iface, resources, residency, resource_count); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_SetGPUThreadPriority(IWineDXGIDevice *iface, INT priority) +{ + FIXME("iface %p, priority %d stub!\n", iface, priority); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_GetGPUThreadPriority(IWineDXGIDevice *iface, INT *priority) +{ + FIXME("iface %p, priority %p stub!\n", iface, priority); + + return E_NOTIMPL; +} + +/* IWineDXGIDevice methods */ + +static struct wined3d_device * STDMETHODCALLTYPE dxgi_device_get_wined3d_device(IWineDXGIDevice *iface) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + + TRACE("iface %p\n", iface); + + EnterCriticalSection(&dxgi_cs); + wined3d_device_incref(This->wined3d_device); + LeaveCriticalSection(&dxgi_cs); + return This->wined3d_device; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_create_surface(IWineDXGIDevice *iface, const DXGI_SURFACE_DESC *desc, + DXGI_USAGE usage, const DXGI_SHARED_RESOURCE *shared_resource, IUnknown *outer, void **surface) +{ + struct dxgi_surface *object; + HRESULT hr; + + FIXME("iface %p, desc %p, usage %#x, shared_resource %p, outer %p, surface %p partial stub!\n", + iface, desc, usage, shared_resource, outer, surface); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + ERR("Failed to allocate DXGI surface object memory\n"); + return E_OUTOFMEMORY; + } + + hr = dxgi_surface_init(object, (IDXGIDevice *)iface, outer); + if (FAILED(hr)) + { + WARN("Failed to initialize surface, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created IDXGISurface %p\n", object); + *surface = outer ? &object->IUnknown_iface : (IUnknown *)&object->IDXGISurface_iface; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_device_create_swapchain(IWineDXGIDevice *iface, + struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **wined3d_swapchain) +{ + struct dxgi_device *This = impl_from_IWineDXGIDevice(iface); + struct dxgi_swapchain *object; + HRESULT hr; + + TRACE("iface %p, desc %p, wined3d_swapchain %p.\n", + iface, desc, wined3d_swapchain); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + ERR("Failed to allocate DXGI swapchain object memory\n"); + return E_OUTOFMEMORY; + } + + hr = dxgi_swapchain_init(object, This, desc); + if (FAILED(hr)) + { + WARN("Failed to initialize swapchain, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created IDXGISwapChain %p\n", object); + *wined3d_swapchain = object->wined3d_swapchain; + + return S_OK; +} + +static const struct IWineDXGIDeviceVtbl dxgi_device_vtbl = +{ + /* IUnknown methods */ + dxgi_device_QueryInterface, + dxgi_device_AddRef, + dxgi_device_Release, + /* IDXGIObject methods */ + dxgi_device_SetPrivateData, + dxgi_device_SetPrivateDataInterface, + dxgi_device_GetPrivateData, + dxgi_device_GetParent, + /* IDXGIDevice methods */ + dxgi_device_GetAdapter, + dxgi_device_CreateSurface, + dxgi_device_QueryResourceResidency, + dxgi_device_SetGPUThreadPriority, + dxgi_device_GetGPUThreadPriority, + /* IWineDXGIAdapter methods */ + dxgi_device_get_wined3d_device, + dxgi_device_create_surface, + dxgi_device_create_swapchain, +}; + +HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *layer, + IDXGIFactory *factory, IDXGIAdapter *adapter) +{ + struct wined3d_device_parent *wined3d_device_parent; + IWineDXGIDeviceParent *dxgi_device_parent; + IWineDXGIAdapter *wine_adapter; + UINT adapter_ordinal; + struct wined3d *wined3d; + void *layer_base; + HRESULT hr; + WINED3DCAPS caps; + + device->IWineDXGIDevice_iface.lpVtbl = &dxgi_device_vtbl; + device->refcount = 1; + + layer_base = device + 1; + + hr = layer->create(layer->id, &layer_base, 0, + device, &IID_IUnknown, (void **)&device->child_layer); + if (FAILED(hr)) + { + WARN("Failed to create device, returning %#x.\n", hr); + goto fail; + } + + hr = IDXGIFactory_QueryInterface(factory, &IID_IWineDXGIFactory, (void **)&device->factory); + if (FAILED(hr)) + { + WARN("This is not the factory we're looking for, returning %#x.\n", hr); + goto fail; + } + wined3d = IWineDXGIFactory_get_wined3d(device->factory); + + hr = IDXGIAdapter_QueryInterface(adapter, &IID_IWineDXGIAdapter, (void **)&wine_adapter); + if (FAILED(hr)) + { + WARN("This is not the adapter we're looking for, returning %#x.\n", hr); + EnterCriticalSection(&dxgi_cs); + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + goto fail; + } + adapter_ordinal = IWineDXGIAdapter_get_ordinal(wine_adapter); + IWineDXGIAdapter_Release(wine_adapter); + + hr = IWineDXGIDevice_QueryInterface(&device->IWineDXGIDevice_iface, &IID_IWineDXGIDeviceParent, + (void **)&dxgi_device_parent); + if (FAILED(hr)) + { + ERR("DXGI device should implement IWineD3DDeviceParent.\n"); + goto fail; + } + + wined3d_device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent); + + FIXME("Ignoring adapter type.\n"); + + hr = wined3d_get_device_caps(wined3d, adapter_ordinal, WINED3D_DEVICE_TYPE_HAL, &caps); + if (FAILED(hr) || caps.VertexShaderVersion < 4 || caps.PixelShaderVersion < 4) + { + WARN("Direct3D 10 is not supported on this GPU with the current shader backend.\n"); + if (SUCCEEDED(hr)) + hr = E_FAIL; + goto fail; + } + + EnterCriticalSection(&dxgi_cs); + hr = wined3d_device_create(wined3d, adapter_ordinal, WINED3D_DEVICE_TYPE_HAL, NULL, 0, 4, + wined3d_device_parent, &device->wined3d_device); + IWineDXGIDeviceParent_Release(dxgi_device_parent); + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + if (FAILED(hr)) + { + WARN("Failed to create a wined3d device, returning %#x.\n", hr); + goto fail; + } + + return S_OK; + +fail: + if (device->wined3d_device) + { + EnterCriticalSection(&dxgi_cs); + wined3d_device_decref(device->wined3d_device); + LeaveCriticalSection(&dxgi_cs); + } + if (device->factory) IWineDXGIFactory_Release(device->factory); + if (device->child_layer) IUnknown_Release(device->child_layer); + return hr; +} diff --git a/reactos/dll/directx/dxgi/dxgi.spec b/reactos/dll/directx/dxgi/dxgi.spec new file mode 100644 index 00000000000..853d8e28d13 --- /dev/null +++ b/reactos/dll/directx/dxgi/dxgi.spec @@ -0,0 +1,3 @@ +@ stdcall CreateDXGIFactory(ptr ptr) +@ stdcall DXGID3D10CreateDevice(ptr ptr ptr long ptr ptr) +@ stdcall DXGID3D10RegisterLayers(ptr long) diff --git a/reactos/dll/directx/dxgi/dxgi_main.c b/reactos/dll/directx/dxgi/dxgi_main.c new file mode 100644 index 00000000000..c9d6f2e6845 --- /dev/null +++ b/reactos/dll/directx/dxgi/dxgi_main.c @@ -0,0 +1,272 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#define DXGI_INIT_GUID +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static CRITICAL_SECTION_DEBUG dxgi_cs_debug = +{ + 0, 0, &dxgi_cs, + {&dxgi_cs_debug.ProcessLocksList, + &dxgi_cs_debug.ProcessLocksList}, + 0, 0, {(DWORD_PTR)(__FILE__ ": dxgi_cs")} +}; +CRITICAL_SECTION dxgi_cs = {&dxgi_cs_debug, -1, 0, 0, 0, 0}; + +struct dxgi_main +{ + HMODULE d3d10core; + struct dxgi_device_layer *device_layers; + UINT layer_count; +}; +static struct dxgi_main dxgi_main; + +static void dxgi_main_cleanup(void) +{ + EnterCriticalSection(&dxgi_cs); + + HeapFree(GetProcessHeap(), 0, dxgi_main.device_layers); + dxgi_main.device_layers = NULL; + dxgi_main.layer_count = 0; + + FreeLibrary(dxgi_main.d3d10core); + dxgi_main.d3d10core = NULL; + + LeaveCriticalSection(&dxgi_cs); + DeleteCriticalSection(&dxgi_cs); +} + +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + TRACE("fdwReason %u\n", fdwReason); + + switch(fdwReason) + { + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hInstDLL); + break; + + case DLL_PROCESS_DETACH: + dxgi_main_cleanup(); + break; + } + + return TRUE; +} + +HRESULT WINAPI CreateDXGIFactory(REFIID riid, void **factory) +{ + struct dxgi_factory *object; + HRESULT hr; + + TRACE("riid %s, factory %p\n", debugstr_guid(riid), factory); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + ERR("Failed to allocate DXGI factory object memory\n"); + *factory = NULL; + return E_OUTOFMEMORY; + } + + hr = dxgi_factory_init(object); + if (FAILED(hr)) + { + WARN("Failed to initialize swapchain, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + *factory = NULL; + return hr; + } + + TRACE("Created IDXGIFactory %p\n", object); + + hr = IDXGIFactory_QueryInterface((IDXGIFactory *)object, riid, factory); + IDXGIFactory_Release((IDXGIFactory *)object); + + return hr; +} + +static BOOL get_layer(enum dxgi_device_layer_id id, struct dxgi_device_layer *layer) +{ + UINT i; + + EnterCriticalSection(&dxgi_cs); + + for (i = 0; i < dxgi_main.layer_count; ++i) + { + if (dxgi_main.device_layers[i].id == id) + { + *layer = dxgi_main.device_layers[i]; + LeaveCriticalSection(&dxgi_cs); + return TRUE; + } + } + + LeaveCriticalSection(&dxgi_cs); + return FALSE; +} + +static HRESULT register_d3d10core_layers(HMODULE d3d10core) +{ + EnterCriticalSection(&dxgi_cs); + + if (!dxgi_main.d3d10core) + { + HRESULT hr; + HRESULT (WINAPI *d3d10core_register_layers)(void); + HMODULE mod; + BOOL ret; + + ret = GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)d3d10core, &mod); + if (!ret) + { + LeaveCriticalSection(&dxgi_cs); + return E_FAIL; + } + + d3d10core_register_layers = (void *)GetProcAddress(mod, "D3D10CoreRegisterLayers"); + hr = d3d10core_register_layers(); + if (FAILED(hr)) + { + ERR("Failed to register d3d10core layers, returning %#x\n", hr); + LeaveCriticalSection(&dxgi_cs); + return hr; + } + + dxgi_main.d3d10core = mod; + } + + LeaveCriticalSection(&dxgi_cs); + + return S_OK; +} + +HRESULT WINAPI DXGID3D10CreateDevice(HMODULE d3d10core, IDXGIFactory *factory, IDXGIAdapter *adapter, + UINT flags, void *unknown0, void **device) +{ + struct layer_get_size_args get_size_args; + struct dxgi_device *dxgi_device; + struct dxgi_device_layer d3d10_layer; + UINT device_size; + DWORD count; + HRESULT hr; + + TRACE("d3d10core %p, factory %p, adapter %p, flags %#x, unknown0 %p, device %p.\n", + d3d10core, factory, adapter, flags, unknown0, device); + + hr = register_d3d10core_layers(d3d10core); + if (FAILED(hr)) + { + ERR("Failed to register d3d10core layers, returning %#x\n", hr); + return hr; + } + + if (!get_layer(DXGI_DEVICE_LAYER_D3D10_DEVICE, &d3d10_layer)) + { + ERR("Failed to get D3D10 device layer\n"); + return E_FAIL; + } + + count = 0; + hr = d3d10_layer.init(d3d10_layer.id, &count, NULL); + if (FAILED(hr)) + { + WARN("Failed to initialize D3D10 device layer\n"); + return E_FAIL; + } + + get_size_args.unknown0 = 0; + get_size_args.unknown1 = 0; + get_size_args.unknown2 = NULL; + get_size_args.unknown3 = NULL; + get_size_args.adapter = adapter; + get_size_args.interface_major = 10; + get_size_args.interface_minor = 1; + get_size_args.version_build = 4; + get_size_args.version_revision = 6000; + + device_size = d3d10_layer.get_size(d3d10_layer.id, &get_size_args, 0); + device_size += sizeof(*dxgi_device); + + dxgi_device = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, device_size); + if (!dxgi_device) + { + ERR("Failed to allocate device memory\n"); + return E_OUTOFMEMORY; + } + + hr = dxgi_device_init(dxgi_device, &d3d10_layer, factory, adapter); + if (FAILED(hr)) + { + WARN("Failed to initialize device, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, dxgi_device); + *device = NULL; + return hr; + } + + TRACE("Created device %p.\n", dxgi_device); + *device = dxgi_device; + + return S_OK; +} + +HRESULT WINAPI DXGID3D10RegisterLayers(const struct dxgi_device_layer *layers, UINT layer_count) +{ + UINT i; + struct dxgi_device_layer *new_layers; + + TRACE("layers %p, layer_count %u\n", layers, layer_count); + + EnterCriticalSection(&dxgi_cs); + + if (!dxgi_main.layer_count) + new_layers = HeapAlloc(GetProcessHeap(), 0, layer_count * sizeof(*new_layers)); + else + new_layers = HeapReAlloc(GetProcessHeap(), 0, dxgi_main.device_layers, + (dxgi_main.layer_count + layer_count) * sizeof(*new_layers)); + + if (!new_layers) + { + LeaveCriticalSection(&dxgi_cs); + ERR("Failed to allocate layer memory\n"); + return E_OUTOFMEMORY; + } + + for (i = 0; i < layer_count; ++i) + { + const struct dxgi_device_layer *layer = &layers[i]; + + TRACE("layer %d: id %#x, init %p, get_size %p, create %p\n", + i, layer->id, layer->init, layer->get_size, layer->create); + + new_layers[dxgi_main.layer_count + i] = *layer; + } + + dxgi_main.device_layers = new_layers; + dxgi_main.layer_count += layer_count; + + LeaveCriticalSection(&dxgi_cs); + + return S_OK; +} diff --git a/reactos/dll/directx/dxgi/dxgi_private.h b/reactos/dll/directx/dxgi/dxgi_private.h new file mode 100644 index 00000000000..565e448ae7d --- /dev/null +++ b/reactos/dll/directx/dxgi/dxgi_private.h @@ -0,0 +1,152 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + */ + +#ifndef __WINE_DXGI_PRIVATE_H +#define __WINE_DXGI_PRIVATE_H + +#define WIN32_NO_STATUS +#define _INC_WINDOWS +#define COM_NO_WINDOWS_H + +#include "wine/debug.h" + +#define COBJMACROS +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "objbase.h" +#include "winnls.h" + +#include "dxgi.h" +#ifdef DXGI_INIT_GUID +#include "initguid.h" +#endif +#include "wine/wined3d.h" +#include + +extern CRITICAL_SECTION dxgi_cs DECLSPEC_HIDDEN; + +/* Layered device */ +enum dxgi_device_layer_id +{ + DXGI_DEVICE_LAYER_DEBUG1 = 0x8, + DXGI_DEVICE_LAYER_THREAD_SAFE = 0x10, + DXGI_DEVICE_LAYER_DEBUG2 = 0x20, + DXGI_DEVICE_LAYER_SWITCH_TO_REF = 0x30, + DXGI_DEVICE_LAYER_D3D10_DEVICE = 0xffffffff, +}; + +struct layer_get_size_args +{ + DWORD unknown0; + DWORD unknown1; + DWORD *unknown2; + DWORD *unknown3; + IDXGIAdapter *adapter; + WORD interface_major; + WORD interface_minor; + WORD version_build; + WORD version_revision; +}; + +struct dxgi_device_layer +{ + enum dxgi_device_layer_id id; + HRESULT (WINAPI *init)(enum dxgi_device_layer_id id, DWORD *count, DWORD *values); + UINT (WINAPI *get_size)(enum dxgi_device_layer_id id, struct layer_get_size_args *args, DWORD unknown0); + HRESULT (WINAPI *create)(enum dxgi_device_layer_id id, void **layer_base, DWORD unknown0, + void *device_object, REFIID riid, void **device_layer); +}; + +/* TRACE helper functions */ +const char *debug_dxgi_format(DXGI_FORMAT format) DECLSPEC_HIDDEN; + +DXGI_FORMAT dxgi_format_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; +enum wined3d_format_id wined3dformat_from_dxgi_format(DXGI_FORMAT format) DECLSPEC_HIDDEN; + +/* IDXGIFactory */ +struct dxgi_factory +{ + IWineDXGIFactory IWineDXGIFactory_iface; + LONG refcount; + struct wined3d *wined3d; + UINT adapter_count; + IDXGIAdapter **adapters; +}; + +HRESULT dxgi_factory_init(struct dxgi_factory *factory) DECLSPEC_HIDDEN; + +/* IDXGIDevice */ +struct dxgi_device +{ + IWineDXGIDevice IWineDXGIDevice_iface; + IUnknown *child_layer; + LONG refcount; + struct wined3d_device *wined3d_device; + IWineDXGIFactory *factory; +}; + +HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *layer, + IDXGIFactory *factory, IDXGIAdapter *adapter) DECLSPEC_HIDDEN; + +/* IDXGIOutput */ +struct dxgi_output +{ + IDXGIOutput IDXGIOutput_iface; + LONG refcount; + struct dxgi_adapter *adapter; +}; + +void dxgi_output_init(struct dxgi_output *output, struct dxgi_adapter *adapter) DECLSPEC_HIDDEN; + +/* IDXGIAdapter */ +struct dxgi_adapter +{ + IWineDXGIAdapter IWineDXGIAdapter_iface; + IWineDXGIFactory *parent; + LONG refcount; + UINT ordinal; + IDXGIOutput *output; +}; + +HRESULT dxgi_adapter_init(struct dxgi_adapter *adapter, IWineDXGIFactory *parent, UINT ordinal) DECLSPEC_HIDDEN; + +/* IDXGISwapChain */ +struct dxgi_swapchain +{ + IDXGISwapChain IDXGISwapChain_iface; + LONG refcount; + struct wined3d_swapchain *wined3d_swapchain; +}; + +HRESULT dxgi_swapchain_init(struct dxgi_swapchain *swapchain, struct dxgi_device *device, + struct wined3d_swapchain_desc *desc) DECLSPEC_HIDDEN; + +/* IDXGISurface */ +struct dxgi_surface +{ + IDXGISurface IDXGISurface_iface; + IUnknown IUnknown_iface; + IUnknown *outer_unknown; + LONG refcount; + IDXGIDevice *device; +}; + +HRESULT dxgi_surface_init(struct dxgi_surface *surface, IDXGIDevice *device, IUnknown *outer) DECLSPEC_HIDDEN; + +#endif /* __WINE_DXGI_PRIVATE_H */ diff --git a/reactos/dll/directx/dxgi/factory.c b/reactos/dll/directx/dxgi/factory.c new file mode 100644 index 00000000000..72927c53639 --- /dev/null +++ b/reactos/dll/directx/dxgi/factory.c @@ -0,0 +1,370 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static inline struct dxgi_factory *impl_from_IWineDXGIFactory(IWineDXGIFactory *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_factory, IWineDXGIFactory_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_factory_QueryInterface(IWineDXGIFactory *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IDXGIFactory) + || IsEqualGUID(riid, &IID_IWineDXGIFactory)) + { + IUnknown_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_factory_AddRef(IWineDXGIFactory *iface) +{ + struct dxgi_factory *This = impl_from_IWineDXGIFactory(iface); + ULONG refcount = InterlockedIncrement(&This->refcount); + + TRACE("%p increasing refcount to %u\n", This, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_factory_Release(IWineDXGIFactory *iface) +{ + struct dxgi_factory *This = impl_from_IWineDXGIFactory(iface); + ULONG refcount = InterlockedDecrement(&This->refcount); + + TRACE("%p decreasing refcount to %u\n", This, refcount); + + if (!refcount) + { + UINT i; + + for (i = 0; i < This->adapter_count; ++i) + { + IDXGIAdapter_Release(This->adapters[i]); + } + HeapFree(GetProcessHeap(), 0, This->adapters); + + EnterCriticalSection(&dxgi_cs); + wined3d_decref(This->wined3d); + LeaveCriticalSection(&dxgi_cs); + HeapFree(GetProcessHeap(), 0, This); + } + + return refcount; +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_factory_SetPrivateData(IWineDXGIFactory *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_SetPrivateDataInterface(IWineDXGIFactory *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_GetPrivateData(IWineDXGIFactory *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_GetParent(IWineDXGIFactory *iface, REFIID riid, void **parent) +{ + WARN("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent); + + *parent = NULL; + + return E_NOINTERFACE; +} + +/* IDXGIFactory methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_factory_EnumAdapters(IWineDXGIFactory *iface, + UINT adapter_idx, IDXGIAdapter **adapter) +{ + struct dxgi_factory *This = impl_from_IWineDXGIFactory(iface); + + TRACE("iface %p, adapter_idx %u, adapter %p\n", iface, adapter_idx, adapter); + + if (!adapter) return DXGI_ERROR_INVALID_CALL; + + if (adapter_idx >= This->adapter_count) + { + *adapter = NULL; + return DXGI_ERROR_NOT_FOUND; + } + + *adapter = This->adapters[adapter_idx]; + IDXGIAdapter_AddRef(*adapter); + + TRACE("Returning adapter %p\n", *adapter); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_MakeWindowAssociation(IWineDXGIFactory *iface, HWND window, UINT flags) +{ + FIXME("iface %p, window %p, flags %#x stub!\n\n", iface, window, flags); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_GetWindowAssociation(IWineDXGIFactory *iface, HWND *window) +{ + FIXME("iface %p, window %p stub!\n", iface, window); + + return E_NOTIMPL; +} + +static UINT dxgi_rational_to_uint(const DXGI_RATIONAL *rational) +{ + if (rational->Denominator) + return rational->Numerator / rational->Denominator; + else + return rational->Numerator; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_CreateSwapChain(IWineDXGIFactory *iface, + IUnknown *device, DXGI_SWAP_CHAIN_DESC *desc, IDXGISwapChain **swapchain) +{ + struct wined3d_swapchain *wined3d_swapchain; + struct wined3d_swapchain_desc wined3d_desc; + struct wined3d_device *wined3d_device; + IWineDXGIDevice *dxgi_device; + UINT count; + HRESULT hr; + + FIXME("iface %p, device %p, desc %p, swapchain %p partial stub!\n", iface, device, desc, swapchain); + + hr = IUnknown_QueryInterface(device, &IID_IWineDXGIDevice, (void **)&dxgi_device); + if (FAILED(hr)) + { + ERR("This is not the device we're looking for\n"); + return hr; + } + + wined3d_device = IWineDXGIDevice_get_wined3d_device(dxgi_device); + IWineDXGIDevice_Release(dxgi_device); + + count = wined3d_device_get_swapchain_count(wined3d_device); + if (count) + { + FIXME("Only a single swapchain supported.\n"); + wined3d_device_decref(wined3d_device); + return E_FAIL; + } + + if (!desc->OutputWindow) + { + FIXME("No output window, should use factory output window\n"); + } + + FIXME("Ignoring SwapEffect and Flags\n"); + + wined3d_desc.backbuffer_width = desc->BufferDesc.Width; + wined3d_desc.backbuffer_height = desc->BufferDesc.Height; + wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(desc->BufferDesc.Format); + wined3d_desc.backbuffer_count = desc->BufferCount; + if (desc->SampleDesc.Count > 1) + { + wined3d_desc.multisample_type = desc->SampleDesc.Count; + wined3d_desc.multisample_quality = desc->SampleDesc.Quality; + } + else + { + wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + wined3d_desc.multisample_quality = 0; + } + wined3d_desc.swap_effect = WINED3D_SWAP_EFFECT_DISCARD; + wined3d_desc.device_window = desc->OutputWindow; + wined3d_desc.windowed = desc->Windowed; + wined3d_desc.enable_auto_depth_stencil = FALSE; + wined3d_desc.auto_depth_stencil_format = 0; + wined3d_desc.flags = 0; /* WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL? */ + wined3d_desc.refresh_rate = dxgi_rational_to_uint(&desc->BufferDesc.RefreshRate); + wined3d_desc.swap_interval = WINED3DPRESENT_INTERVAL_DEFAULT; + + hr = wined3d_device_init_3d(wined3d_device, &wined3d_desc); + if (FAILED(hr)) + { + WARN("Failed to initialize 3D, returning %#x\n", hr); + wined3d_device_decref(wined3d_device); + return hr; + } + + wined3d_swapchain = wined3d_device_get_swapchain(wined3d_device, 0); + wined3d_device_decref(wined3d_device); + if (!wined3d_swapchain) + { + WARN("Failed to get swapchain.\n"); + return E_FAIL; + } + + *swapchain = wined3d_swapchain_get_parent(wined3d_swapchain); + + /* FIXME? The swapchain is created with refcount 1 by the wined3d device, + * but the wined3d device can't hold a real reference. */ + + TRACE("Created IDXGISwapChain %p\n", *swapchain); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_factory_CreateSoftwareAdapter(IWineDXGIFactory *iface, + HMODULE swrast, IDXGIAdapter **adapter) +{ + FIXME("iface %p, swrast %p, adapter %p stub!\n", iface, swrast, adapter); + + return E_NOTIMPL; +} + +/* IWineDXGIFactory methods */ + +static struct wined3d * STDMETHODCALLTYPE dxgi_factory_get_wined3d(IWineDXGIFactory *iface) +{ + struct dxgi_factory *This = impl_from_IWineDXGIFactory(iface); + + TRACE("iface %p\n", iface); + + EnterCriticalSection(&dxgi_cs); + wined3d_incref(This->wined3d); + LeaveCriticalSection(&dxgi_cs); + return This->wined3d; +} + +static const struct IWineDXGIFactoryVtbl dxgi_factory_vtbl = +{ + /* IUnknown methods */ + dxgi_factory_QueryInterface, + dxgi_factory_AddRef, + dxgi_factory_Release, + /* IDXGIObject methods */ + dxgi_factory_SetPrivateData, + dxgi_factory_SetPrivateDataInterface, + dxgi_factory_GetPrivateData, + dxgi_factory_GetParent, + /* IDXGIFactory methods */ + dxgi_factory_EnumAdapters, + dxgi_factory_MakeWindowAssociation, + dxgi_factory_GetWindowAssociation, + dxgi_factory_CreateSwapChain, + dxgi_factory_CreateSoftwareAdapter, + /* IWineDXGIFactory methods */ + dxgi_factory_get_wined3d, +}; + +HRESULT dxgi_factory_init(struct dxgi_factory *factory) +{ + HRESULT hr; + UINT i; + + factory->IWineDXGIFactory_iface.lpVtbl = &dxgi_factory_vtbl; + factory->refcount = 1; + + EnterCriticalSection(&dxgi_cs); + factory->wined3d = wined3d_create(10, 0); + if (!factory->wined3d) + { + LeaveCriticalSection(&dxgi_cs); + return DXGI_ERROR_UNSUPPORTED; + } + + factory->adapter_count = wined3d_get_adapter_count(factory->wined3d); + LeaveCriticalSection(&dxgi_cs); + factory->adapters = HeapAlloc(GetProcessHeap(), 0, factory->adapter_count * sizeof(*factory->adapters)); + if (!factory->adapters) + { + ERR("Failed to allocate DXGI adapter array memory.\n"); + hr = E_OUTOFMEMORY; + goto fail; + } + + for (i = 0; i < factory->adapter_count; ++i) + { + struct dxgi_adapter *adapter = HeapAlloc(GetProcessHeap(), 0, sizeof(*adapter)); + if (!adapter) + { + UINT j; + + ERR("Failed to allocate DXGI adapter memory.\n"); + + for (j = 0; j < i; ++j) + { + IDXGIAdapter_Release(factory->adapters[j]); + } + hr = E_OUTOFMEMORY; + goto fail; + } + + hr = dxgi_adapter_init(adapter, &factory->IWineDXGIFactory_iface, i); + if (FAILED(hr)) + { + UINT j; + + ERR("Failed to initialize adapter, hr %#x.\n", hr); + + HeapFree(GetProcessHeap(), 0, adapter); + for (j = 0; j < i; ++j) + { + IDXGIAdapter_Release(factory->adapters[j]); + } + goto fail; + } + + factory->adapters[i] = (IDXGIAdapter *)adapter; + } + + return S_OK; + +fail: + HeapFree(GetProcessHeap(), 0, factory->adapters); + EnterCriticalSection(&dxgi_cs); + wined3d_decref(factory->wined3d); + LeaveCriticalSection(&dxgi_cs); + return hr; +} diff --git a/reactos/dll/directx/dxgi/output.c b/reactos/dll/directx/dxgi/output.c new file mode 100644 index 00000000000..4cdd06b2480 --- /dev/null +++ b/reactos/dll/directx/dxgi/output.c @@ -0,0 +1,292 @@ +/* + * Copyright 2009 Henri Verbeet for CodeWeavers + * + * 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 + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static inline struct dxgi_output *impl_from_IDXGIOutput(IDXGIOutput *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_output, IDXGIOutput_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_output_QueryInterface(IDXGIOutput *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IDXGIOutput) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IUnknown_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_output_AddRef(IDXGIOutput *iface) +{ + struct dxgi_output *This = impl_from_IDXGIOutput(iface); + ULONG refcount = InterlockedIncrement(&This->refcount); + + TRACE("%p increasing refcount to %u.\n", This, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_output_Release(IDXGIOutput *iface) +{ + struct dxgi_output *This = impl_from_IDXGIOutput(iface); + ULONG refcount = InterlockedDecrement(&This->refcount); + + TRACE("%p decreasing refcount to %u.\n", This, refcount); + + if (!refcount) + { + HeapFree(GetProcessHeap(), 0, This); + } + + return refcount; +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_output_SetPrivateData(IDXGIOutput *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_SetPrivateDataInterface(IDXGIOutput *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetPrivateData(IDXGIOutput *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetParent(IDXGIOutput *iface, + REFIID riid, void **parent) +{ + struct dxgi_output *This = impl_from_IDXGIOutput(iface); + + TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent); + + return IDXGIAdapter_QueryInterface((IDXGIAdapter *)This->adapter, riid, parent); +} + +/* IDXGIOutput methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetDesc(IDXGIOutput *iface, DXGI_OUTPUT_DESC *desc) +{ + FIXME("iface %p, desc %p stub!\n", iface, desc); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetDisplayModeList(IDXGIOutput *iface, + DXGI_FORMAT format, UINT flags, UINT *mode_count, DXGI_MODE_DESC *desc) +{ + struct dxgi_output *This = impl_from_IDXGIOutput(iface); + enum wined3d_format_id wined3d_format; + struct wined3d *wined3d; + UINT i; + UINT max_count; + + FIXME("iface %p, format %s, flags %#x, mode_count %p, desc %p partial stub!\n", + iface, debug_dxgi_format(format), flags, mode_count, desc); + + if (!mode_count) + { + return S_OK; + } + + if (format == DXGI_FORMAT_UNKNOWN) + { + *mode_count = 0; + return S_OK; + } + + wined3d = IWineDXGIFactory_get_wined3d(This->adapter->parent); + wined3d_format = wined3dformat_from_dxgi_format(format); + + EnterCriticalSection(&dxgi_cs); + max_count = wined3d_get_adapter_mode_count(wined3d, This->adapter->ordinal, + wined3d_format, WINED3D_SCANLINE_ORDERING_UNKNOWN); + + if (!desc) + { + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + *mode_count = max_count; + return S_OK; + } + + *mode_count = min(*mode_count,max_count); + + for (i = 0; i < *mode_count; ++i) + { + struct wined3d_display_mode mode; + HRESULT hr; + + hr = wined3d_enum_adapter_modes(wined3d, This->adapter->ordinal, wined3d_format, + WINED3D_SCANLINE_ORDERING_UNKNOWN, i, &mode); + if (FAILED(hr)) + { + WARN("EnumAdapterModes failed, hr %#x.\n", hr); + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + return hr; + } + + desc[i].Width = mode.width; + desc[i].Height = mode.height; + desc[i].RefreshRate.Numerator = mode.refresh_rate; + desc[i].RefreshRate.Denominator = 1; + desc[i].Format = format; + desc[i].ScanlineOrdering = mode.scanline_ordering; + desc[i].Scaling = DXGI_MODE_SCALING_UNSPECIFIED; /* FIXME */ + } + wined3d_decref(wined3d); + LeaveCriticalSection(&dxgi_cs); + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_FindClosestMatchingMode(IDXGIOutput *iface, + const DXGI_MODE_DESC *mode, DXGI_MODE_DESC *closest_match, IUnknown *device) +{ + FIXME("iface %p, mode %p, closest_match %p, device %p stub!\n", iface, mode, closest_match, device); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_WaitForVBlank(IDXGIOutput *iface) +{ + FIXME("iface %p stub!\n", iface); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_TakeOwnership(IDXGIOutput *iface, IUnknown *device, BOOL exclusive) +{ + FIXME("iface %p, device %p, exclusive %d stub!\n", iface, device, exclusive); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE dxgi_output_ReleaseOwnership(IDXGIOutput *iface) +{ + FIXME("iface %p stub!\n", iface); +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetGammaControlCapabilities(IDXGIOutput *iface, + DXGI_GAMMA_CONTROL_CAPABILITIES *gamma_caps) +{ + FIXME("iface %p, gamma_caps %p stub!\n", iface, gamma_caps); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_SetGammaControl(IDXGIOutput *iface, + const DXGI_GAMMA_CONTROL *gamma_control) +{ + FIXME("iface %p, gamma_control %p stub!\n", iface, gamma_control); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetGammaControl(IDXGIOutput *iface, DXGI_GAMMA_CONTROL *gamma_control) +{ + FIXME("iface %p, gamma_control %p stub!\n", iface, gamma_control); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_SetDisplaySurface(IDXGIOutput *iface, IDXGISurface *surface) +{ + FIXME("iface %p, surface %p stub!\n", iface, surface); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetDisplaySurfaceData(IDXGIOutput *iface, IDXGISurface *surface) +{ + FIXME("iface %p, surface %p stub!\n", iface, surface); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_output_GetFrameStatistics(IDXGIOutput *iface, DXGI_FRAME_STATISTICS *stats) +{ + FIXME("iface %p, stats %p stub!\n", iface, stats); + + return E_NOTIMPL; +} + +static const struct IDXGIOutputVtbl dxgi_output_vtbl = +{ + dxgi_output_QueryInterface, + dxgi_output_AddRef, + dxgi_output_Release, + /* IDXGIObject methods */ + dxgi_output_SetPrivateData, + dxgi_output_SetPrivateDataInterface, + dxgi_output_GetPrivateData, + dxgi_output_GetParent, + /* IDXGIOutput methods */ + dxgi_output_GetDesc, + dxgi_output_GetDisplayModeList, + dxgi_output_FindClosestMatchingMode, + dxgi_output_WaitForVBlank, + dxgi_output_TakeOwnership, + dxgi_output_ReleaseOwnership, + dxgi_output_GetGammaControlCapabilities, + dxgi_output_SetGammaControl, + dxgi_output_GetGammaControl, + dxgi_output_SetDisplaySurface, + dxgi_output_GetDisplaySurfaceData, + dxgi_output_GetFrameStatistics, +}; + +void dxgi_output_init(struct dxgi_output *output, struct dxgi_adapter *adapter) +{ + output->IDXGIOutput_iface.lpVtbl = &dxgi_output_vtbl; + output->refcount = 1; + output->adapter = adapter; +} diff --git a/reactos/dll/directx/dxgi/surface.c b/reactos/dll/directx/dxgi/surface.c new file mode 100644 index 00000000000..f7fa93176ce --- /dev/null +++ b/reactos/dll/directx/dxgi/surface.c @@ -0,0 +1,216 @@ +/* + * Copyright 2009 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +/* Inner IUnknown methods */ + +static inline struct dxgi_surface *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_surface, IUnknown_iface); +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out) +{ + struct dxgi_surface *surface = impl_from_IUnknown(iface); + + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDXGISurface) + || IsEqualGUID(riid, &IID_IDXGIDeviceSubObject) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDXGISurface_AddRef(&surface->IDXGISurface_iface); + *out = &surface->IDXGISurface_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_surface_inner_AddRef(IUnknown *iface) +{ + struct dxgi_surface *surface = impl_from_IUnknown(iface); + ULONG refcount = InterlockedIncrement(&surface->refcount); + + TRACE("%p increasing refcount to %u.\n", surface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_surface_inner_Release(IUnknown *iface) +{ + struct dxgi_surface *surface = impl_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&surface->refcount); + + TRACE("%p decreasing refcount to %u.\n", surface, refcount); + + if (!refcount) + { + IDXGIDevice_Release(surface->device); + HeapFree(GetProcessHeap(), 0, surface); + } + + return refcount; +} + +static inline struct dxgi_surface *impl_from_IDXGISurface(IDXGISurface *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_surface, IDXGISurface_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_surface_QueryInterface(IDXGISurface *iface, REFIID riid, + void **object) +{ + struct dxgi_surface *This = impl_from_IDXGISurface(iface); + TRACE("Forwarding to outer IUnknown\n"); + return IUnknown_QueryInterface(This->outer_unknown, riid, object); +} + +static ULONG STDMETHODCALLTYPE dxgi_surface_AddRef(IDXGISurface *iface) +{ + struct dxgi_surface *This = impl_from_IDXGISurface(iface); + TRACE("Forwarding to outer IUnknown\n"); + return IUnknown_AddRef(This->outer_unknown); +} + +static ULONG STDMETHODCALLTYPE dxgi_surface_Release(IDXGISurface *iface) +{ + struct dxgi_surface *This = impl_from_IDXGISurface(iface); + TRACE("Forwarding to outer IUnknown\n"); + return IUnknown_Release(This->outer_unknown); +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_surface_SetPrivateData(IDXGISurface *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_SetPrivateDataInterface(IDXGISurface *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_GetPrivateData(IDXGISurface *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_GetParent(IDXGISurface *iface, REFIID riid, void **parent) +{ + struct dxgi_surface *This = impl_from_IDXGISurface(iface); + + TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent); + + return IDXGIDevice_QueryInterface(This->device, riid, parent); +} + +/* IDXGIDeviceSubObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_surface_GetDevice(IDXGISurface *iface, REFIID riid, void **device) +{ + struct dxgi_surface *This = impl_from_IDXGISurface(iface); + + TRACE("iface %p, riid %s, device %p.\n", iface, debugstr_guid(riid), device); + + return IDXGIDevice_QueryInterface(This->device, riid, device); +} + +/* IDXGISurface methods */ +static HRESULT STDMETHODCALLTYPE dxgi_surface_GetDesc(IDXGISurface *iface, DXGI_SURFACE_DESC *desc) +{ + FIXME("iface %p, desc %p stub!\n", iface, desc); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_Map(IDXGISurface *iface, DXGI_MAPPED_RECT *mapped_rect, UINT flags) +{ + FIXME("iface %p, mapped_rect %p, flags %#x stub!\n", iface, mapped_rect, flags); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_surface_Unmap(IDXGISurface *iface) +{ + FIXME("iface %p stub!\n", iface); + + return E_NOTIMPL; +} + +static const struct IDXGISurfaceVtbl dxgi_surface_vtbl = +{ + /* IUnknown methods */ + dxgi_surface_QueryInterface, + dxgi_surface_AddRef, + dxgi_surface_Release, + /* IDXGIObject methods */ + dxgi_surface_SetPrivateData, + dxgi_surface_SetPrivateDataInterface, + dxgi_surface_GetPrivateData, + dxgi_surface_GetParent, + /* IDXGIDeviceSubObject methods */ + dxgi_surface_GetDevice, + /* IDXGISurface methods */ + dxgi_surface_GetDesc, + dxgi_surface_Map, + dxgi_surface_Unmap, +}; + +static const struct IUnknownVtbl dxgi_surface_inner_unknown_vtbl = +{ + /* IUnknown methods */ + dxgi_surface_inner_QueryInterface, + dxgi_surface_inner_AddRef, + dxgi_surface_inner_Release, +}; + +HRESULT dxgi_surface_init(struct dxgi_surface *surface, IDXGIDevice *device, IUnknown *outer) +{ + surface->IDXGISurface_iface.lpVtbl = &dxgi_surface_vtbl; + surface->IUnknown_iface.lpVtbl = &dxgi_surface_inner_unknown_vtbl; + surface->refcount = 1; + surface->outer_unknown = outer ? outer : &surface->IUnknown_iface; + surface->device = device; + IDXGIDevice_AddRef(device); + + return S_OK; +} diff --git a/reactos/dll/directx/dxgi/swapchain.c b/reactos/dll/directx/dxgi/swapchain.c new file mode 100644 index 00000000000..0c27007eda7 --- /dev/null +++ b/reactos/dll/directx/dxgi/swapchain.c @@ -0,0 +1,315 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +static inline struct dxgi_swapchain *impl_from_IDXGISwapChain(IDXGISwapChain *iface) +{ + return CONTAINING_RECORD(iface, struct dxgi_swapchain, IDXGISwapChain_iface); +} + +/* IUnknown methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_QueryInterface(IDXGISwapChain *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDXGIObject) + || IsEqualGUID(riid, &IID_IDXGIDeviceSubObject) + || IsEqualGUID(riid, &IID_IDXGISwapChain)) + { + IUnknown_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE dxgi_swapchain_AddRef(IDXGISwapChain *iface) +{ + struct dxgi_swapchain *This = impl_from_IDXGISwapChain(iface); + ULONG refcount = InterlockedIncrement(&This->refcount); + + TRACE("%p increasing refcount to %u\n", This, refcount); + + if (refcount == 1) + wined3d_swapchain_incref(This->wined3d_swapchain); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE dxgi_swapchain_Release(IDXGISwapChain *iface) +{ + struct dxgi_swapchain *This = impl_from_IDXGISwapChain(iface); + ULONG refcount = InterlockedDecrement(&This->refcount); + + TRACE("%p decreasing refcount to %u\n", This, refcount); + + if (!refcount) + { + struct wined3d_device *wined3d_device; + HRESULT hr; + + FIXME("Only a single swapchain is supported\n"); + + wined3d_device = wined3d_swapchain_get_device(This->wined3d_swapchain); + hr = wined3d_device_uninit_3d(wined3d_device); + if (FAILED(hr)) + { + ERR("Uninit3D failed, hr %#x\n", hr); + } + } + + return refcount; +} + +/* IDXGIObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetPrivateData(IDXGISwapChain *iface, + REFGUID guid, UINT data_size, const void *data) +{ + FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetPrivateDataInterface(IDXGISwapChain *iface, + REFGUID guid, const IUnknown *object) +{ + FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetPrivateData(IDXGISwapChain *iface, + REFGUID guid, UINT *data_size, void *data) +{ + FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetParent(IDXGISwapChain *iface, REFIID riid, void **parent) +{ + FIXME("iface %p, riid %s, parent %p stub!\n", iface, debugstr_guid(riid), parent); + + return E_NOTIMPL; +} + +/* IDXGIDeviceSubObject methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetDevice(IDXGISwapChain *iface, REFIID riid, void **device) +{ + FIXME("iface %p, riid %s, device %p stub!\n", iface, debugstr_guid(riid), device); + + return E_NOTIMPL; +} + +/* IDXGISwapChain methods */ + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_Present(IDXGISwapChain *iface, UINT sync_interval, UINT flags) +{ + struct dxgi_swapchain *This = impl_from_IDXGISwapChain(iface); + + TRACE("iface %p, sync_interval %u, flags %#x\n", iface, sync_interval, flags); + + if (sync_interval) FIXME("Unimplemented sync interval %u\n", sync_interval); + if (flags) FIXME("Unimplemented flags %#x\n", flags); + + return wined3d_swapchain_present(This->wined3d_swapchain, NULL, NULL, NULL, NULL, 0); +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetBuffer(IDXGISwapChain *iface, + UINT buffer_idx, REFIID riid, void **surface) +{ + struct dxgi_swapchain *This = impl_from_IDXGISwapChain(iface); + struct wined3d_surface *backbuffer; + IUnknown *parent; + HRESULT hr; + + TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n", + iface, buffer_idx, debugstr_guid(riid), surface); + + EnterCriticalSection(&dxgi_cs); + + if (!(backbuffer = wined3d_swapchain_get_back_buffer(This->wined3d_swapchain, + buffer_idx, WINED3D_BACKBUFFER_TYPE_MONO))) + { + LeaveCriticalSection(&dxgi_cs); + return DXGI_ERROR_INVALID_CALL; + } + + parent = wined3d_surface_get_parent(backbuffer); + hr = IUnknown_QueryInterface(parent, riid, surface); + LeaveCriticalSection(&dxgi_cs); + + return hr; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetFullscreenState(IDXGISwapChain *iface, + BOOL fullscreen, IDXGIOutput *target) +{ + FIXME("iface %p, fullscreen %u, target %p stub!\n", iface, fullscreen, target); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetFullscreenState(IDXGISwapChain *iface, + BOOL *fullscreen, IDXGIOutput **target) +{ + FIXME("iface %p, fullscreen %p, target %p stub!\n", iface, fullscreen, target); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetDesc(IDXGISwapChain *iface, DXGI_SWAP_CHAIN_DESC *desc) +{ + struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain(iface); + struct wined3d_swapchain_desc wined3d_desc; + + FIXME("iface %p, desc %p partial stub!\n", iface, desc); + + if (desc == NULL) + return E_INVALIDARG; + + EnterCriticalSection(&dxgi_cs); + wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc); + LeaveCriticalSection(&dxgi_cs); + + FIXME("Ignoring ScanlineOrdering, Scaling, SwapEffect and Flags\n"); + + desc->BufferDesc.Width = wined3d_desc.backbuffer_width; + desc->BufferDesc.Height = wined3d_desc.backbuffer_height; + desc->BufferDesc.RefreshRate.Numerator = wined3d_desc.refresh_rate; + desc->BufferDesc.RefreshRate.Denominator = 1; + desc->BufferDesc.Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format); + desc->BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + desc->BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + desc->SampleDesc.Count = wined3d_desc.multisample_type; + desc->SampleDesc.Quality = wined3d_desc.multisample_quality; + desc->BufferCount = wined3d_desc.backbuffer_count; + desc->OutputWindow = wined3d_desc.device_window; + desc->Windowed = wined3d_desc.windowed; + desc->SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + desc->Flags = 0; + + return S_OK; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeBuffers(IDXGISwapChain *iface, + UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags) +{ + FIXME("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x stub!\n", + iface, buffer_count, width, height, debug_dxgi_format(format), flags); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeTarget(IDXGISwapChain *iface, + const DXGI_MODE_DESC *target_mode_desc) +{ + FIXME("iface %p, target_mode_desc %p stub!\n", iface, target_mode_desc); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetContainingOutput(IDXGISwapChain *iface, IDXGIOutput **output) +{ + FIXME("iface %p, output %p stub!\n", iface, output); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetFrameStatistics(IDXGISwapChain *iface, DXGI_FRAME_STATISTICS *stats) +{ + FIXME("iface %p, stats %p stub!\n", iface, stats); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetLastPresentCount(IDXGISwapChain *iface, UINT *last_present_count) +{ + FIXME("iface %p, last_present_count %p stub!\n", iface, last_present_count); + + return E_NOTIMPL; +} + +static const struct IDXGISwapChainVtbl dxgi_swapchain_vtbl = +{ + /* IUnknown methods */ + dxgi_swapchain_QueryInterface, + dxgi_swapchain_AddRef, + dxgi_swapchain_Release, + /* IDXGIObject methods */ + dxgi_swapchain_SetPrivateData, + dxgi_swapchain_SetPrivateDataInterface, + dxgi_swapchain_GetPrivateData, + dxgi_swapchain_GetParent, + /* IDXGIDeviceSubObject methods */ + dxgi_swapchain_GetDevice, + /* IDXGISwapChain methods */ + dxgi_swapchain_Present, + dxgi_swapchain_GetBuffer, + dxgi_swapchain_SetFullscreenState, + dxgi_swapchain_GetFullscreenState, + dxgi_swapchain_GetDesc, + dxgi_swapchain_ResizeBuffers, + dxgi_swapchain_ResizeTarget, + dxgi_swapchain_GetContainingOutput, + dxgi_swapchain_GetFrameStatistics, + dxgi_swapchain_GetLastPresentCount, +}; + +static void STDMETHODCALLTYPE dxgi_swapchain_wined3d_object_released(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops dxgi_swapchain_wined3d_parent_ops = +{ + dxgi_swapchain_wined3d_object_released, +}; + +HRESULT dxgi_swapchain_init(struct dxgi_swapchain *swapchain, struct dxgi_device *device, + struct wined3d_swapchain_desc *desc) +{ + HRESULT hr; + + swapchain->IDXGISwapChain_iface.lpVtbl = &dxgi_swapchain_vtbl; + swapchain->refcount = 1; + + if (FAILED(hr = wined3d_swapchain_create(device->wined3d_device, desc, swapchain, + &dxgi_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain))) + { + WARN("Failed to create wined3d swapchain, hr %#x.\n", hr); + return hr; + } + + return S_OK; +} diff --git a/reactos/dll/directx/dxgi/utils.c b/reactos/dll/directx/dxgi/utils.c new file mode 100644 index 00000000000..979c9721e66 --- /dev/null +++ b/reactos/dll/directx/dxgi/utils.c @@ -0,0 +1,326 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + * + */ + +#include "config.h" +#include "wine/port.h" + +#include "dxgi_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dxgi); + +#define WINE_DXGI_TO_STR(x) case x: return #x + +const char *debug_dxgi_format(DXGI_FORMAT format) +{ + switch(format) + { + WINE_DXGI_TO_STR(DXGI_FORMAT_UNKNOWN); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32A32_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32A32_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32A32_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32A32_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32B32_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16B16A16_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G32_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32G8X24_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_D32_FLOAT_S8X24_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R10G10B10A2_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R10G10B10A2_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R10G10B10A2_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R11G11B10_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8B8A8_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16G16_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_D32_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R32_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R24G8_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_D24_UNORM_S8_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R24_UNORM_X8_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_X24_TYPELESS_G8_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_FLOAT); + WINE_DXGI_TO_STR(DXGI_FORMAT_D16_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R16_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8_UINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8_SINT); + WINE_DXGI_TO_STR(DXGI_FORMAT_A8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R1_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_R9G9B9E5_SHAREDEXP); + WINE_DXGI_TO_STR(DXGI_FORMAT_R8G8_B8G8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_G8R8_G8B8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC1_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC1_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC1_UNORM_SRGB); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC2_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC2_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC2_UNORM_SRGB); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC3_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC3_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC3_UNORM_SRGB); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC4_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC4_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC4_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC5_TYPELESS); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC5_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_BC5_SNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_B5G6R5_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_B5G5R5A1_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_B8G8R8A8_UNORM); + WINE_DXGI_TO_STR(DXGI_FORMAT_B8G8R8X8_UNORM); + default: + FIXME("Unrecognized DXGI_FORMAT %#x\n", format); + return "unrecognized"; + } +} + +#undef WINE_DXGI_TO_STR + +DXGI_FORMAT dxgi_format_from_wined3dformat(enum wined3d_format_id format) +{ + switch(format) + { + case WINED3DFMT_UNKNOWN: return DXGI_FORMAT_UNKNOWN; + case WINED3DFMT_R32G32B32A32_TYPELESS: return DXGI_FORMAT_R32G32B32A32_TYPELESS; + case WINED3DFMT_R32G32B32A32_FLOAT: return DXGI_FORMAT_R32G32B32A32_FLOAT; + case WINED3DFMT_R32G32B32A32_UINT: return DXGI_FORMAT_R32G32B32A32_UINT; + case WINED3DFMT_R32G32B32A32_SINT: return DXGI_FORMAT_R32G32B32A32_SINT; + case WINED3DFMT_R32G32B32_TYPELESS: return DXGI_FORMAT_R32G32B32_TYPELESS; + case WINED3DFMT_R32G32B32_FLOAT: return DXGI_FORMAT_R32G32B32_FLOAT; + case WINED3DFMT_R32G32B32_UINT: return DXGI_FORMAT_R32G32B32_UINT; + case WINED3DFMT_R32G32B32_SINT: return DXGI_FORMAT_R32G32B32_SINT; + case WINED3DFMT_R16G16B16A16_TYPELESS: return DXGI_FORMAT_R16G16B16A16_TYPELESS; + case WINED3DFMT_R16G16B16A16_FLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT; + case WINED3DFMT_R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM; + case WINED3DFMT_R16G16B16A16_UINT: return DXGI_FORMAT_R16G16B16A16_UINT; + case WINED3DFMT_R16G16B16A16_SNORM: return DXGI_FORMAT_R16G16B16A16_SNORM; + case WINED3DFMT_R16G16B16A16_SINT: return DXGI_FORMAT_R16G16B16A16_SINT; + case WINED3DFMT_R32G32_TYPELESS: return DXGI_FORMAT_R32G32_TYPELESS; + case WINED3DFMT_R32G32_FLOAT: return DXGI_FORMAT_R32G32_FLOAT; + case WINED3DFMT_R32G32_UINT: return DXGI_FORMAT_R32G32_UINT; + case WINED3DFMT_R32G32_SINT: return DXGI_FORMAT_R32G32_SINT; + case WINED3DFMT_R32G8X24_TYPELESS: return DXGI_FORMAT_R32G8X24_TYPELESS; + case WINED3DFMT_D32_FLOAT_S8X24_UINT: return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; + case WINED3DFMT_R32_FLOAT_X8X24_TYPELESS: return DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; + case WINED3DFMT_X32_TYPELESS_G8X24_UINT: return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; + case WINED3DFMT_R10G10B10A2_TYPELESS: return DXGI_FORMAT_R10G10B10A2_TYPELESS; + case WINED3DFMT_R10G10B10A2_UNORM: return DXGI_FORMAT_R10G10B10A2_UNORM; + case WINED3DFMT_R10G10B10A2_UINT: return DXGI_FORMAT_R10G10B10A2_UINT; + case WINED3DFMT_R11G11B10_FLOAT: return DXGI_FORMAT_R11G11B10_FLOAT; + case WINED3DFMT_R8G8B8A8_TYPELESS: return DXGI_FORMAT_R8G8B8A8_TYPELESS; + case WINED3DFMT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case WINED3DFMT_R8G8B8A8_UNORM_SRGB: return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + case WINED3DFMT_R8G8B8A8_UINT: return DXGI_FORMAT_R8G8B8A8_UINT; + case WINED3DFMT_R8G8B8A8_SNORM: return DXGI_FORMAT_R8G8B8A8_SNORM; + case WINED3DFMT_R8G8B8A8_SINT: return DXGI_FORMAT_R8G8B8A8_SINT; + case WINED3DFMT_R16G16_TYPELESS: return DXGI_FORMAT_R16G16_TYPELESS; + case WINED3DFMT_R16G16_FLOAT: return DXGI_FORMAT_R16G16_FLOAT; + case WINED3DFMT_R16G16_UNORM: return DXGI_FORMAT_R16G16_UNORM; + case WINED3DFMT_R16G16_UINT: return DXGI_FORMAT_R16G16_UINT; + case WINED3DFMT_R16G16_SNORM: return DXGI_FORMAT_R16G16_SNORM; + case WINED3DFMT_R16G16_SINT: return DXGI_FORMAT_R16G16_SINT; + case WINED3DFMT_R32_TYPELESS: return DXGI_FORMAT_R32_TYPELESS; + case WINED3DFMT_D32_FLOAT: return DXGI_FORMAT_D32_FLOAT; + case WINED3DFMT_R32_FLOAT: return DXGI_FORMAT_R32_FLOAT; + case WINED3DFMT_R32_UINT: return DXGI_FORMAT_R32_UINT; + case WINED3DFMT_R32_SINT: return DXGI_FORMAT_R32_SINT; + case WINED3DFMT_R24G8_TYPELESS: return DXGI_FORMAT_R24G8_TYPELESS; + case WINED3DFMT_D24_UNORM_S8_UINT: return DXGI_FORMAT_D24_UNORM_S8_UINT; + case WINED3DFMT_R24_UNORM_X8_TYPELESS: return DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + case WINED3DFMT_X24_TYPELESS_G8_UINT: return DXGI_FORMAT_X24_TYPELESS_G8_UINT; + case WINED3DFMT_R8G8_TYPELESS: return DXGI_FORMAT_R8G8_TYPELESS; + case WINED3DFMT_R8G8_UNORM: return DXGI_FORMAT_R8G8_UNORM; + case WINED3DFMT_R8G8_UINT: return DXGI_FORMAT_R8G8_UINT; + case WINED3DFMT_R8G8_SNORM: return DXGI_FORMAT_R8G8_SNORM; + case WINED3DFMT_R8G8_SINT: return DXGI_FORMAT_R8G8_SINT; + case WINED3DFMT_R16_TYPELESS: return DXGI_FORMAT_R16_TYPELESS; + case WINED3DFMT_R16_FLOAT: return DXGI_FORMAT_R16_FLOAT; + case WINED3DFMT_D16_UNORM: return DXGI_FORMAT_D16_UNORM; + case WINED3DFMT_R16_UNORM: return DXGI_FORMAT_R16_UNORM; + case WINED3DFMT_R16_UINT: return DXGI_FORMAT_R16_UINT; + case WINED3DFMT_R16_SNORM: return DXGI_FORMAT_R16_SNORM; + case WINED3DFMT_R16_SINT: return DXGI_FORMAT_R16_SINT; + case WINED3DFMT_R8_TYPELESS: return DXGI_FORMAT_R8_TYPELESS; + case WINED3DFMT_R8_UNORM: return DXGI_FORMAT_R8_UNORM; + case WINED3DFMT_R8_UINT: return DXGI_FORMAT_R8_UINT; + case WINED3DFMT_R8_SNORM: return DXGI_FORMAT_R8_SNORM; + case WINED3DFMT_R8_SINT: return DXGI_FORMAT_R8_SINT; + case WINED3DFMT_A8_UNORM: return DXGI_FORMAT_A8_UNORM; + case WINED3DFMT_R1_UNORM: return DXGI_FORMAT_R1_UNORM; + case WINED3DFMT_R9G9B9E5_SHAREDEXP: return DXGI_FORMAT_R9G9B9E5_SHAREDEXP; + case WINED3DFMT_R8G8_B8G8_UNORM: return DXGI_FORMAT_R8G8_B8G8_UNORM; + case WINED3DFMT_G8R8_G8B8_UNORM: return DXGI_FORMAT_G8R8_G8B8_UNORM; + case WINED3DFMT_BC1_TYPELESS: return DXGI_FORMAT_BC1_TYPELESS; + case WINED3DFMT_BC1_UNORM: return DXGI_FORMAT_BC1_UNORM; + case WINED3DFMT_BC1_UNORM_SRGB: return DXGI_FORMAT_BC1_UNORM_SRGB; + case WINED3DFMT_BC2_TYPELESS: return DXGI_FORMAT_BC2_TYPELESS; + case WINED3DFMT_BC2_UNORM: return DXGI_FORMAT_BC2_UNORM; + case WINED3DFMT_BC2_UNORM_SRGB: return DXGI_FORMAT_BC2_UNORM_SRGB; + case WINED3DFMT_BC3_TYPELESS: return DXGI_FORMAT_BC3_TYPELESS; + case WINED3DFMT_BC3_UNORM: return DXGI_FORMAT_BC3_UNORM; + case WINED3DFMT_BC3_UNORM_SRGB: return DXGI_FORMAT_BC3_UNORM_SRGB; + case WINED3DFMT_BC4_TYPELESS: return DXGI_FORMAT_BC4_TYPELESS; + case WINED3DFMT_BC4_UNORM: return DXGI_FORMAT_BC4_UNORM; + case WINED3DFMT_BC4_SNORM: return DXGI_FORMAT_BC4_SNORM; + case WINED3DFMT_BC5_TYPELESS: return DXGI_FORMAT_BC5_TYPELESS; + case WINED3DFMT_BC5_UNORM: return DXGI_FORMAT_BC5_UNORM; + case WINED3DFMT_BC5_SNORM: return DXGI_FORMAT_BC5_SNORM; + case WINED3DFMT_B5G6R5_UNORM: return DXGI_FORMAT_B5G6R5_UNORM; + case WINED3DFMT_B5G5R5A1_UNORM: return DXGI_FORMAT_B5G5R5A1_UNORM; + case WINED3DFMT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM; + case WINED3DFMT_B8G8R8X8_UNORM: return DXGI_FORMAT_B8G8R8X8_UNORM; + default: + FIXME("Unhandled wined3d format %#x.\n", format); + return DXGI_FORMAT_UNKNOWN; + } +} + +enum wined3d_format_id wined3dformat_from_dxgi_format(DXGI_FORMAT format) +{ + switch(format) + { + case DXGI_FORMAT_UNKNOWN: return WINED3DFMT_UNKNOWN; + case DXGI_FORMAT_R32G32B32A32_TYPELESS: return WINED3DFMT_R32G32B32A32_TYPELESS; + case DXGI_FORMAT_R32G32B32A32_FLOAT: return WINED3DFMT_R32G32B32A32_FLOAT; + case DXGI_FORMAT_R32G32B32A32_UINT: return WINED3DFMT_R32G32B32A32_UINT; + case DXGI_FORMAT_R32G32B32A32_SINT: return WINED3DFMT_R32G32B32A32_SINT; + case DXGI_FORMAT_R32G32B32_TYPELESS: return WINED3DFMT_R32G32B32_TYPELESS; + case DXGI_FORMAT_R32G32B32_FLOAT: return WINED3DFMT_R32G32B32_FLOAT; + case DXGI_FORMAT_R32G32B32_UINT: return WINED3DFMT_R32G32B32_UINT; + case DXGI_FORMAT_R32G32B32_SINT: return WINED3DFMT_R32G32B32_SINT; + case DXGI_FORMAT_R16G16B16A16_TYPELESS: return WINED3DFMT_R16G16B16A16_TYPELESS; + case DXGI_FORMAT_R16G16B16A16_FLOAT: return WINED3DFMT_R16G16B16A16_FLOAT; + case DXGI_FORMAT_R16G16B16A16_UNORM: return WINED3DFMT_R16G16B16A16_UNORM; + case DXGI_FORMAT_R16G16B16A16_UINT: return WINED3DFMT_R16G16B16A16_UINT; + case DXGI_FORMAT_R16G16B16A16_SNORM: return WINED3DFMT_R16G16B16A16_SNORM; + case DXGI_FORMAT_R16G16B16A16_SINT: return WINED3DFMT_R16G16B16A16_SINT; + case DXGI_FORMAT_R32G32_TYPELESS: return WINED3DFMT_R32G32_TYPELESS; + case DXGI_FORMAT_R32G32_FLOAT: return WINED3DFMT_R32G32_FLOAT; + case DXGI_FORMAT_R32G32_UINT: return WINED3DFMT_R32G32_UINT; + case DXGI_FORMAT_R32G32_SINT: return WINED3DFMT_R32G32_SINT; + case DXGI_FORMAT_R32G8X24_TYPELESS: return WINED3DFMT_R32G8X24_TYPELESS; + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: return WINED3DFMT_D32_FLOAT_S8X24_UINT; + case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: return WINED3DFMT_R32_FLOAT_X8X24_TYPELESS; + case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: return WINED3DFMT_X32_TYPELESS_G8X24_UINT; + case DXGI_FORMAT_R10G10B10A2_TYPELESS: return WINED3DFMT_R10G10B10A2_TYPELESS; + case DXGI_FORMAT_R10G10B10A2_UNORM: return WINED3DFMT_R10G10B10A2_UNORM; + case DXGI_FORMAT_R10G10B10A2_UINT: return WINED3DFMT_R10G10B10A2_UINT; + case DXGI_FORMAT_R11G11B10_FLOAT: return WINED3DFMT_R11G11B10_FLOAT; + case DXGI_FORMAT_R8G8B8A8_TYPELESS: return WINED3DFMT_R8G8B8A8_TYPELESS; + case DXGI_FORMAT_R8G8B8A8_UNORM: return WINED3DFMT_R8G8B8A8_UNORM; + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: return WINED3DFMT_R8G8B8A8_UNORM_SRGB; + case DXGI_FORMAT_R8G8B8A8_UINT: return WINED3DFMT_R8G8B8A8_UINT; + case DXGI_FORMAT_R8G8B8A8_SNORM: return WINED3DFMT_R8G8B8A8_SNORM; + case DXGI_FORMAT_R8G8B8A8_SINT: return WINED3DFMT_R8G8B8A8_SINT; + case DXGI_FORMAT_R16G16_TYPELESS: return WINED3DFMT_R16G16_TYPELESS; + case DXGI_FORMAT_R16G16_FLOAT: return WINED3DFMT_R16G16_FLOAT; + case DXGI_FORMAT_R16G16_UNORM: return WINED3DFMT_R16G16_UNORM; + case DXGI_FORMAT_R16G16_UINT: return WINED3DFMT_R16G16_UINT; + case DXGI_FORMAT_R16G16_SNORM: return WINED3DFMT_R16G16_SNORM; + case DXGI_FORMAT_R16G16_SINT: return WINED3DFMT_R16G16_SINT; + case DXGI_FORMAT_R32_TYPELESS: return WINED3DFMT_R32_TYPELESS; + case DXGI_FORMAT_D32_FLOAT: return WINED3DFMT_D32_FLOAT; + case DXGI_FORMAT_R32_FLOAT: return WINED3DFMT_R32_FLOAT; + case DXGI_FORMAT_R32_UINT: return WINED3DFMT_R32_UINT; + case DXGI_FORMAT_R32_SINT: return WINED3DFMT_R32_SINT; + case DXGI_FORMAT_R24G8_TYPELESS: return WINED3DFMT_R24G8_TYPELESS; + case DXGI_FORMAT_D24_UNORM_S8_UINT: return WINED3DFMT_D24_UNORM_S8_UINT; + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: return WINED3DFMT_R24_UNORM_X8_TYPELESS; + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: return WINED3DFMT_X24_TYPELESS_G8_UINT; + case DXGI_FORMAT_R8G8_TYPELESS: return WINED3DFMT_R8G8_TYPELESS; + case DXGI_FORMAT_R8G8_UNORM: return WINED3DFMT_R8G8_UNORM; + case DXGI_FORMAT_R8G8_UINT: return WINED3DFMT_R8G8_UINT; + case DXGI_FORMAT_R8G8_SNORM: return WINED3DFMT_R8G8_SNORM; + case DXGI_FORMAT_R8G8_SINT: return WINED3DFMT_R8G8_SINT; + case DXGI_FORMAT_R16_TYPELESS: return WINED3DFMT_R16_TYPELESS; + case DXGI_FORMAT_R16_FLOAT: return WINED3DFMT_R16_FLOAT; + case DXGI_FORMAT_D16_UNORM: return WINED3DFMT_D16_UNORM; + case DXGI_FORMAT_R16_UNORM: return WINED3DFMT_R16_UNORM; + case DXGI_FORMAT_R16_UINT: return WINED3DFMT_R16_UINT; + case DXGI_FORMAT_R16_SNORM: return WINED3DFMT_R16_SNORM; + case DXGI_FORMAT_R16_SINT: return WINED3DFMT_R16_SINT; + case DXGI_FORMAT_R8_TYPELESS: return WINED3DFMT_R8_TYPELESS; + case DXGI_FORMAT_R8_UNORM: return WINED3DFMT_R8_UNORM; + case DXGI_FORMAT_R8_UINT: return WINED3DFMT_R8_UINT; + case DXGI_FORMAT_R8_SNORM: return WINED3DFMT_R8_SNORM; + case DXGI_FORMAT_R8_SINT: return WINED3DFMT_R8_SINT; + case DXGI_FORMAT_A8_UNORM: return WINED3DFMT_A8_UNORM; + case DXGI_FORMAT_R1_UNORM: return WINED3DFMT_R1_UNORM; + case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: return WINED3DFMT_R9G9B9E5_SHAREDEXP; + case DXGI_FORMAT_R8G8_B8G8_UNORM: return WINED3DFMT_R8G8_B8G8_UNORM; + case DXGI_FORMAT_G8R8_G8B8_UNORM: return WINED3DFMT_G8R8_G8B8_UNORM; + case DXGI_FORMAT_BC1_TYPELESS: return WINED3DFMT_BC1_TYPELESS; + case DXGI_FORMAT_BC1_UNORM: return WINED3DFMT_BC1_UNORM; + case DXGI_FORMAT_BC1_UNORM_SRGB: return WINED3DFMT_BC1_UNORM_SRGB; + case DXGI_FORMAT_BC2_TYPELESS: return WINED3DFMT_BC2_TYPELESS; + case DXGI_FORMAT_BC2_UNORM: return WINED3DFMT_BC2_UNORM; + case DXGI_FORMAT_BC2_UNORM_SRGB: return WINED3DFMT_BC2_UNORM_SRGB; + case DXGI_FORMAT_BC3_TYPELESS: return WINED3DFMT_BC3_TYPELESS; + case DXGI_FORMAT_BC3_UNORM: return WINED3DFMT_BC3_UNORM; + case DXGI_FORMAT_BC3_UNORM_SRGB: return WINED3DFMT_BC3_UNORM_SRGB; + case DXGI_FORMAT_BC4_TYPELESS: return WINED3DFMT_BC4_TYPELESS; + case DXGI_FORMAT_BC4_UNORM: return WINED3DFMT_BC4_UNORM; + case DXGI_FORMAT_BC4_SNORM: return WINED3DFMT_BC4_SNORM; + case DXGI_FORMAT_BC5_TYPELESS: return WINED3DFMT_BC5_TYPELESS; + case DXGI_FORMAT_BC5_UNORM: return WINED3DFMT_BC5_UNORM; + case DXGI_FORMAT_BC5_SNORM: return WINED3DFMT_BC5_SNORM; + case DXGI_FORMAT_B5G6R5_UNORM: return WINED3DFMT_B5G6R5_UNORM; + case DXGI_FORMAT_B5G5R5A1_UNORM: return WINED3DFMT_B5G5R5A1_UNORM; + case DXGI_FORMAT_B8G8R8A8_UNORM: return WINED3DFMT_B8G8R8A8_UNORM; + case DXGI_FORMAT_B8G8R8X8_UNORM: return WINED3DFMT_B8G8R8X8_UNORM; + default: + FIXME("Unhandled DXGI_FORMAT %#x\n", format); + return WINED3DFMT_UNKNOWN; + } +} diff --git a/reactos/dll/directx/dxgi/version.rc b/reactos/dll/directx/dxgi/version.rc new file mode 100644 index 00000000000..bd51eb8c55b --- /dev/null +++ b/reactos/dll/directx/dxgi/version.rc @@ -0,0 +1,26 @@ +/* + * Copyright 2008 Henri Verbeet for CodeWeavers + * + * 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 + */ + +#define WINE_FILEDESCRIPTION_STR "Wine DXGI" +#define WINE_FILENAME_STR "dxgi.dll" +#define WINE_FILEVERSION 6,0,6000,16386 +#define WINE_FILEVERSION_STR "6.0.6000.16386" +#define WINE_PRODUCTVERSION 6,0,6000,16386 +#define WINE_PRODUCTVERSION_STR "6.0.6000.16386" + +#include "wine/wine_common_ver.rc" diff --git a/reactos/include/psdk/CMakeLists.txt b/reactos/include/psdk/CMakeLists.txt index feae9deecef..c62b3245ee1 100644 --- a/reactos/include/psdk/CMakeLists.txt +++ b/reactos/include/psdk/CMakeLists.txt @@ -38,6 +38,7 @@ list(APPEND SOURCE docobj.idl docobjectservice.idl downloadmgr.idl + dxgi.idl # dyngraph.idl exdisp.idl fusion.idl @@ -129,6 +130,7 @@ add_idl_headers(psdk ${SOURCE}) add_typelib(stdole2.idl) add_custom_target(stdole2 DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/stdole2.tlb) +add_iid_library(dxgi_uuids dxgi.idl) add_iid_library(wuguid wuapi.idl) add_iid_library(xml_uuids msxml2.idl) diff --git a/reactos/include/psdk/dxgi.idl b/reactos/include/psdk/dxgi.idl new file mode 100644 index 00000000000..d87a72c97de --- /dev/null +++ b/reactos/include/psdk/dxgi.idl @@ -0,0 +1,446 @@ +/* + * Copyright 2007 Andras Kovacs + * + * 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 + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgitype.h"; + +const UINT _FACDXGI = 0x87a; + +cpp_quote("#define MAKE_DXGI_STATUS(x) MAKE_HRESULT(0, _FACDXGI, x)") +cpp_quote("#define DXGI_STATUS_OCCLUDED MAKE_DXGI_STATUS(1)") +cpp_quote("#define DXGI_STATUS_CLIPPED MAKE_DXGI_STATUS(2)") +cpp_quote("#define DXGI_STATUS_NO_REDIRECTION MAKE_DXGI_STATUS(4)") +cpp_quote("#define DXGI_STATUS_NO_DESKTOP_ACCESS MAKE_DXGI_STATUS(5)") +cpp_quote("#define DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE MAKE_DXGI_STATUS(6)") +cpp_quote("#define DXGI_STATUS_MODE_CHANGED MAKE_DXGI_STATUS(7)") +cpp_quote("#define DXGI_STATUS_MODE_CHANGE_IN_PROGRESS MAKE_DXGI_STATUS(8)") + +cpp_quote("#define MAKE_DXGI_HRESULT(x) MAKE_HRESULT(1, _FACDXGI, x)") +cpp_quote("#define DXGI_ERROR_INVALID_CALL MAKE_DXGI_HRESULT(1)") +cpp_quote("#define DXGI_ERROR_NOT_FOUND MAKE_DXGI_HRESULT(2)") +cpp_quote("#define DXGI_ERROR_MORE_DATA MAKE_DXGI_HRESULT(3)") +cpp_quote("#define DXGI_ERROR_UNSUPPORTED MAKE_DXGI_HRESULT(4)") +cpp_quote("#define DXGI_ERROR_DEVICE_REMOVED MAKE_DXGI_HRESULT(5)") +cpp_quote("#define DXGI_ERROR_DEVICE_HUNG MAKE_DXGI_HRESULT(6)") +cpp_quote("#define DXGI_ERROR_DEVICE_RESET MAKE_DXGI_HRESULT(7)") +cpp_quote("#define DXGI_ERROR_WAS_STILL_DRAWING MAKE_DXGI_HRESULT(10)") +cpp_quote("#define DXGI_ERROR_FRAME_STATISTICS_DISJOINT MAKE_DXGI_HRESULT(11)") +cpp_quote("#define DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE MAKE_DXGI_HRESULT(12)") +cpp_quote("#define DXGI_ERROR_DRIVER_INTERNAL_ERROR MAKE_DXGI_HRESULT(32)") +cpp_quote("#define DXGI_ERROR_NONEXCLUSIVE MAKE_DXGI_HRESULT(33)") +cpp_quote("#define DXGI_ERROR_NOT_CURRENTLY_AVAILABLE MAKE_DXGI_HRESULT(34)") + +cpp_quote("#if 0") +typedef HANDLE HMONITOR; +typedef struct _LUID { + DWORD LowPart; + LONG HighPart; +} LUID, *PLUID; +cpp_quote("#endif") + +typedef UINT DXGI_USAGE; +const DXGI_USAGE DXGI_USAGE_SHADER_INPUT = 0x10L; +const DXGI_USAGE DXGI_USAGE_RENDER_TARGET_OUTPUT = 0x20L; +const DXGI_USAGE DXGI_USAGE_BACK_BUFFER = 0x40L; +const DXGI_USAGE DXGI_USAGE_SHARED = 0x80L; +const DXGI_USAGE DXGI_USAGE_READ_ONLY = 0x100L; + +const UINT DXGI_ENUM_MODES_INTERLACED = 1; +const UINT DXGI_ENUM_MODES_SCALING = 2; + +typedef enum DXGI_SWAP_EFFECT { + DXGI_SWAP_EFFECT_DISCARD = 0, + DXGI_SWAP_EFFECT_SEQUENTIAL = 1, +} DXGI_SWAP_EFFECT; + +typedef enum DXGI_RESIDENCY { + DXGI_RESIDENCY_FULLY_RESIDENT = 1, + DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY = 2, + DXGI_RESIDENCY_EVICTED_TO_DISK = 3, +} DXGI_RESIDENCY; + +typedef struct DXGI_SURFACE_DESC { + UINT Width; + UINT Height; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; +} DXGI_SURFACE_DESC; + +typedef struct DXGI_MAPPED_RECT { + INT Pitch; + BYTE *pBits; +} DXGI_MAPPED_RECT; + +typedef struct DXGI_OUTPUT_DESC { + WCHAR DeviceName[32]; + RECT DesktopCoordinates; + BOOL AttachedToDesktop; + DXGI_MODE_ROTATION Rotation; + HMONITOR Monitor; +} DXGI_OUTPUT_DESC; + +typedef struct DXGI_FRAME_STATISTICS { + UINT PresentCount; + UINT PresentRefreshCount; + UINT SyncRefreshCount; + LARGE_INTEGER SyncQPCTime; + LARGE_INTEGER SyncGPUTime; +} DXGI_FRAME_STATISTICS; + +typedef struct DXGI_ADAPTER_DESC { + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; +} DXGI_ADAPTER_DESC; + +typedef enum DXGI_SWAP_CHAIN_FLAG { + DXGI_SWAP_CHAIN_FLAG_NONPREROTATED = 1, + DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH = 2, + DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE = 4 +} DXGI_SWAP_CHAIN_FLAG; + +typedef struct DXGI_SWAP_CHAIN_DESC { + DXGI_MODE_DESC BufferDesc; + DXGI_SAMPLE_DESC SampleDesc; + DXGI_USAGE BufferUsage; + UINT BufferCount; + HWND OutputWindow; + BOOL Windowed; + DXGI_SWAP_EFFECT SwapEffect; + UINT Flags; +} DXGI_SWAP_CHAIN_DESC; + +typedef struct DXGI_SHARED_RESOURCE { + HANDLE Handle; +} DXGI_SHARED_RESOURCE; + +[ + object, + local, + uuid(aec22fb8-76f3-4639-9be0-28eb43a67a2e) +] +interface IDXGIObject : IUnknown +{ + HRESULT SetPrivateData( + [in] REFGUID guid, + [in] UINT data_size, + [in] const void *data + ); + HRESULT SetPrivateDataInterface( + [in] REFGUID guid, + [in] const IUnknown *object + ); + HRESULT GetPrivateData( + [in] REFGUID guid, + [in, out] UINT *data_size, + [out] void *data + ); + HRESULT GetParent( + [in] REFIID riid, + [out] void **parent + ); +} + +[ + object, + local, + uuid(3d3e0379-f9de-4d58-bb6c-18d62992f1a6) +] +interface IDXGIDeviceSubObject : IDXGIObject +{ + HRESULT GetDevice( + [in] REFIID riid, + [out] void **device + ); +} + +[ + object, + uuid(035f3ab4-482e-4e50-b41f-8a7f8bd8960b), + local, + pointer_default(unique) +] +interface IDXGIResource : IDXGIDeviceSubObject +{ + HRESULT GetSharedHandle([out] HANDLE *pSharedHandle); + HRESULT GetUsage([out] DXGI_USAGE *pUsage); + HRESULT SetEvictionPriority([in] UINT EvictionPriority); + HRESULT GetEvictionPriority([out, retval] UINT *pEvictionPriority); +} + +[ + object, + uuid(9d8e1289-d7b3-465f-8126-250e349af85d), + local, + pointer_default(unique) +] +interface IDXGIKeyedMutex : IDXGIDeviceSubObject +{ + HRESULT AcquireSync([in] UINT64 Key, [in] DWORD dwMilliseconds); + HRESULT ReleaseSync([in] UINT64 Key); +} + +[ + object, + local, + uuid(cafcb56c-6ac3-4889-bf47-9e23bbd260ec) +] +interface IDXGISurface : IDXGIDeviceSubObject +{ + HRESULT GetDesc( + [out] DXGI_SURFACE_DESC *desc + ); + HRESULT Map( + [out] DXGI_MAPPED_RECT *mapped_rect, + [in] UINT flags + ); + HRESULT Unmap( + ); +} + +[ + object, + local, + uuid(ae02eedb-c735-4690-8d52-5a8dc20213aa) +] +interface IDXGIOutput : IDXGIObject +{ + HRESULT GetDesc( + [out] DXGI_OUTPUT_DESC *desc + ); + HRESULT GetDisplayModeList( + [in] DXGI_FORMAT format, + [in] UINT flags, + [in, out] UINT *mode_count, + [out] DXGI_MODE_DESC *desc + ); + HRESULT FindClosestMatchingMode( + [in] const DXGI_MODE_DESC *mode, + [out] DXGI_MODE_DESC *closest_match, + [in] IUnknown *device + ); + HRESULT WaitForVBlank( + ); + HRESULT TakeOwnership( + [in] IUnknown *device, + [in] BOOL exclusive + ); + void ReleaseOwnership( + ); + HRESULT GetGammaControlCapabilities( + [out] DXGI_GAMMA_CONTROL_CAPABILITIES *gamma_caps + ); + HRESULT SetGammaControl( + [in] const DXGI_GAMMA_CONTROL *gamma_control + ); + HRESULT GetGammaControl( + [out] DXGI_GAMMA_CONTROL *gamma_control + ); + HRESULT SetDisplaySurface( + [in] IDXGISurface *surface + ); + HRESULT GetDisplaySurfaceData( + [in] IDXGISurface *surface + ); + HRESULT GetFrameStatistics( + [out] DXGI_FRAME_STATISTICS *stats + ); +} + +[ + object, + local, + uuid(2411e7e1-12ac-4ccf-bd14-9798e8534dc0) +] +interface IDXGIAdapter : IDXGIObject +{ + HRESULT EnumOutputs( + [in] UINT output_idx, + [in, out] IDXGIOutput **output + ); + HRESULT GetDesc( + [out] DXGI_ADAPTER_DESC *desc + ); + HRESULT CheckInterfaceSupport( + [in] REFGUID guid, + [out] LARGE_INTEGER *umd_version + ); +} + +[ + object, + local, + uuid(310d36a0-d2e7-4c0a-aa04-6a9d23b8886a) +] +interface IDXGISwapChain : IDXGIDeviceSubObject +{ + HRESULT Present( + [in] UINT sync_interval, + [in] UINT flags + ); + HRESULT GetBuffer( + [in] UINT buffer_idx, + [in] REFIID riid, + [in, out] void **surface + ); + HRESULT SetFullscreenState( + [in] BOOL fullscreen, + [in] IDXGIOutput *target + ); + HRESULT GetFullscreenState( + [out] BOOL *fullscreen, + [out] IDXGIOutput **target + ); + HRESULT GetDesc( + [out] DXGI_SWAP_CHAIN_DESC *desc + ); + HRESULT ResizeBuffers( + [in] UINT buffer_count, + [in] UINT width, + [in] UINT height, + [in] DXGI_FORMAT format, + [in] UINT flags + ); + HRESULT ResizeTarget( + [in] const DXGI_MODE_DESC *target_mode_desc + ); + HRESULT GetContainingOutput( + [out] IDXGIOutput **output + ); + HRESULT GetFrameStatistics( + [out] DXGI_FRAME_STATISTICS *stats + ); + HRESULT GetLastPresentCount( + [out] UINT *last_present_count + ); +} + +cpp_quote("#define DXGI_MWA_NO_WINDOW_CHANGES 0x1") +cpp_quote("#define DXGI_MWA_NO_ALT_ENTER 0x2") +cpp_quote("#define DXGI_MWA_NO_PRINT_SCREEN 0x4") +cpp_quote("#define DXGI_MWA_VALID 0x7") + +[ + object, + local, + uuid(7b7166ec-21c7-44ae-b21a-c9ae321ae369) +] +interface IDXGIFactory : IDXGIObject +{ + HRESULT EnumAdapters( + [in] UINT adapter_idx, + [out] IDXGIAdapter **adapter + ); + HRESULT MakeWindowAssociation( + [in] HWND window, + [in] UINT flags + ); + HRESULT GetWindowAssociation( + [in] HWND *window + ); + HRESULT CreateSwapChain( + [in] IUnknown *device, + [in] DXGI_SWAP_CHAIN_DESC *desc, + [out] IDXGISwapChain **swapchain + ); + HRESULT CreateSoftwareAdapter( + [in] HMODULE swrast, + [out] IDXGIAdapter **adapter + ); +} + +[local] HRESULT __stdcall CreateDXGIFactory(REFIID riid, void **factory); + +[ + object, + local, + uuid(54ec77fa-1377-44e6-8c32-88fd5f44c84c) +] +interface IDXGIDevice : IDXGIObject +{ + HRESULT GetAdapter( + [out] IDXGIAdapter **adapter + ); + HRESULT CreateSurface( + [in] const DXGI_SURFACE_DESC *desc, + [in] UINT surface_count, + [in] DXGI_USAGE usage, + [in] const DXGI_SHARED_RESOURCE *shared_resource, + [out] IDXGISurface **surface + ); + HRESULT QueryResourceResidency( + [in] IUnknown *const *resources, + [out] DXGI_RESIDENCY *residency, + [in] UINT resource_count + ); + HRESULT SetGPUThreadPriority( + [in] INT priority + ); + HRESULT GetGPUThreadPriority( + [out] INT *priority + ); +} + +typedef enum DXGI_ADAPTER_FLAG { + DXGI_ADAPTER_FLAG_NONE = 0, + DXGI_ADAPTER_FLAG_REMOTE = 1, + DXGI_ADAPTER_FLAG_FORCE_DWORD = 0xFFFFFFFF +} DXGI_ADAPTER_FLAG; + +typedef struct DXGI_ADAPTER_DESC1 { + WCHAR Description[128]; + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + SIZE_T DedicatedVideoMemory; + SIZE_T DedicatedSystemMemory; + SIZE_T SharedSystemMemory; + LUID AdapterLuid; + UINT Flags; +} DXGI_ADAPTER_DESC1; + +[ + object, + uuid(29038f61-3839-4626-91fd-086879011a05), + local, + pointer_default(unique) +] +interface IDXGIAdapter1 : IDXGIAdapter +{ + HRESULT GetDesc1([out] DXGI_ADAPTER_DESC1 *pDesc); +} + +[ + object, + uuid(770aae78-f26f-4dba-a829-253c83d1b387), + local, + pointer_default(unique) + ] +interface IDXGIFactory1 : IDXGIFactory +{ + HRESULT EnumAdapters1([in] UINT Adapter, [out] IDXGIAdapter1 **ppAdapter); + BOOL IsCurrent(); +} diff --git a/reactos/include/psdk/dxgiformat.h b/reactos/include/psdk/dxgiformat.h new file mode 100644 index 00000000000..5c7ad62140c --- /dev/null +++ b/reactos/include/psdk/dxgiformat.h @@ -0,0 +1,117 @@ +/* + * Copyright 2007 Andras Kovacs + * + * 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 + */ + +#ifndef __dxgiformat_h__ +#define __dxgiformat_h__ + +#define DXGI_FORMAT_DEFINED 1 + +typedef enum DXGI_FORMAT { + DXGI_FORMAT_UNKNOWN = 0, + DXGI_FORMAT_R32G32B32A32_TYPELESS = 1, + DXGI_FORMAT_R32G32B32A32_FLOAT = 2, + DXGI_FORMAT_R32G32B32A32_UINT = 3, + DXGI_FORMAT_R32G32B32A32_SINT = 4, + DXGI_FORMAT_R32G32B32_TYPELESS = 5, + DXGI_FORMAT_R32G32B32_FLOAT = 6, + DXGI_FORMAT_R32G32B32_UINT = 7, + DXGI_FORMAT_R32G32B32_SINT = 8, + DXGI_FORMAT_R16G16B16A16_TYPELESS = 9, + DXGI_FORMAT_R16G16B16A16_FLOAT = 10, + DXGI_FORMAT_R16G16B16A16_UNORM = 11, + DXGI_FORMAT_R16G16B16A16_UINT = 12, + DXGI_FORMAT_R16G16B16A16_SNORM = 13, + DXGI_FORMAT_R16G16B16A16_SINT = 14, + DXGI_FORMAT_R32G32_TYPELESS = 15, + DXGI_FORMAT_R32G32_FLOAT = 16, + DXGI_FORMAT_R32G32_UINT = 17, + DXGI_FORMAT_R32G32_SINT = 18, + DXGI_FORMAT_R32G8X24_TYPELESS = 19, + DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS= 21, + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22, + DXGI_FORMAT_R10G10B10A2_TYPELESS = 23, + DXGI_FORMAT_R10G10B10A2_UNORM = 24, + DXGI_FORMAT_R10G10B10A2_UINT = 25, + DXGI_FORMAT_R11G11B10_FLOAT = 26, + DXGI_FORMAT_R8G8B8A8_TYPELESS = 27, + DXGI_FORMAT_R8G8B8A8_UNORM = 28, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29, + DXGI_FORMAT_R8G8B8A8_UINT = 30, + DXGI_FORMAT_R8G8B8A8_SNORM = 31, + DXGI_FORMAT_R8G8B8A8_SINT = 32, + DXGI_FORMAT_R16G16_TYPELESS = 33, + DXGI_FORMAT_R16G16_FLOAT = 34, + DXGI_FORMAT_R16G16_UNORM = 35, + DXGI_FORMAT_R16G16_UINT = 36, + DXGI_FORMAT_R16G16_SNORM = 37, + DXGI_FORMAT_R16G16_SINT = 38, + DXGI_FORMAT_R32_TYPELESS = 39, + DXGI_FORMAT_D32_FLOAT = 40, + DXGI_FORMAT_R32_FLOAT = 41, + DXGI_FORMAT_R32_UINT = 42, + DXGI_FORMAT_R32_SINT = 43, + DXGI_FORMAT_R24G8_TYPELESS = 44, + DXGI_FORMAT_D24_UNORM_S8_UINT = 45, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46, + DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47, + DXGI_FORMAT_R8G8_TYPELESS = 48, + DXGI_FORMAT_R8G8_UNORM = 49, + DXGI_FORMAT_R8G8_UINT = 50, + DXGI_FORMAT_R8G8_SNORM = 51, + DXGI_FORMAT_R8G8_SINT = 52, + DXGI_FORMAT_R16_TYPELESS = 53, + DXGI_FORMAT_R16_FLOAT = 54, + DXGI_FORMAT_D16_UNORM = 55, + DXGI_FORMAT_R16_UNORM = 56, + DXGI_FORMAT_R16_UINT = 57, + DXGI_FORMAT_R16_SNORM = 58, + DXGI_FORMAT_R16_SINT = 59, + DXGI_FORMAT_R8_TYPELESS = 60, + DXGI_FORMAT_R8_UNORM = 61, + DXGI_FORMAT_R8_UINT = 62, + DXGI_FORMAT_R8_SNORM = 63, + DXGI_FORMAT_R8_SINT = 64, + DXGI_FORMAT_A8_UNORM = 65, + DXGI_FORMAT_R1_UNORM = 66, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67, + DXGI_FORMAT_R8G8_B8G8_UNORM = 68, + DXGI_FORMAT_G8R8_G8B8_UNORM = 69, + DXGI_FORMAT_BC1_TYPELESS = 70, + DXGI_FORMAT_BC1_UNORM = 71, + DXGI_FORMAT_BC1_UNORM_SRGB = 72, + DXGI_FORMAT_BC2_TYPELESS = 73, + DXGI_FORMAT_BC2_UNORM = 74, + DXGI_FORMAT_BC2_UNORM_SRGB = 75, + DXGI_FORMAT_BC3_TYPELESS = 76, + DXGI_FORMAT_BC3_UNORM = 77, + DXGI_FORMAT_BC3_UNORM_SRGB = 78, + DXGI_FORMAT_BC4_TYPELESS = 79, + DXGI_FORMAT_BC4_UNORM = 80, + DXGI_FORMAT_BC4_SNORM = 81, + DXGI_FORMAT_BC5_TYPELESS = 82, + DXGI_FORMAT_BC5_UNORM = 83, + DXGI_FORMAT_BC5_SNORM = 84, + DXGI_FORMAT_B5G6R5_UNORM = 85, + DXGI_FORMAT_B5G5R5A1_UNORM = 86, + DXGI_FORMAT_B8G8R8A8_UNORM = 87, + DXGI_FORMAT_B8G8R8X8_UNORM = 88, + DXGI_FORMAT_FORCE_UINT = 0xffffffff +} DXGI_FORMAT; + +#endif diff --git a/reactos/include/psdk/dxgitype.h b/reactos/include/psdk/dxgitype.h new file mode 100644 index 00000000000..e89e055c153 --- /dev/null +++ b/reactos/include/psdk/dxgitype.h @@ -0,0 +1,84 @@ +/* + * Copyright 2007 Andras Kovacs + * + * 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 + */ + +#ifndef __dxgitype_h__ +#define __dxgitype_h__ + +#include "dxgiformat.h" + +typedef struct DXGI_SAMPLE_DESC { + UINT Count; + UINT Quality; +} DXGI_SAMPLE_DESC; + +typedef enum DXGI_MODE_ROTATION { + DXGI_MODE_ROTATION_UNSPECIFIED = 0, + DXGI_MODE_ROTATION_IDENTITY = 1, + DXGI_MODE_ROTATION_ROTATE90 = 2, + DXGI_MODE_ROTATION_ROTATE180 = 3, + DXGI_MODE_ROTATION_ROTATE270 = 4, +} DXGI_MODE_ROTATION; + +typedef enum DXGI_MODE_SCANLINE_ORDER { + DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED = 0, + DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE = 1, + DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST = 2, + DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST = 3, +} DXGI_MODE_SCANLINE_ORDER; + +typedef enum DXGI_MODE_SCALING { + DXGI_MODE_SCALING_UNSPECIFIED = 0, + DXGI_MODE_SCALING_CENTERED = 1, + DXGI_MODE_SCALING_STRETCHED = 2, +} DXGI_MODE_SCALING; + +typedef struct DXGI_RATIONAL { + UINT Numerator; + UINT Denominator; +} DXGI_RATIONAL; + +typedef struct DXGI_MODE_DESC { + UINT Width; + UINT Height; + DXGI_RATIONAL RefreshRate; + DXGI_FORMAT Format; + DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; + DXGI_MODE_SCALING Scaling; +} DXGI_MODE_DESC; + +typedef struct DXGI_GAMMA_CONTROL_CAPABILITIES { + BOOL ScaleAndOffsetSupported; + float MaxConvertedValue; + float MinConvertedValue; + UINT NumGammaControlPoints; + float ControlPointPositions[1025]; +} DXGI_GAMMA_CONTROL_CAPABILITIES; + +typedef struct DXGI_RGB { + float Red; + float Green; + float Blue; +} DXGI_RGB; + +typedef struct DXGI_GAMMA_CONTROL { + DXGI_RGB Scale; + DXGI_RGB Offset; + DXGI_RGB GammaCurve[1025]; +} DXGI_GAMMA_CONTROL; + +#endif diff --git a/reactos/include/reactos/wine/CMakeLists.txt b/reactos/include/reactos/wine/CMakeLists.txt index 228da16f35f..9b39c88cdb9 100644 --- a/reactos/include/reactos/wine/CMakeLists.txt +++ b/reactos/include/reactos/wine/CMakeLists.txt @@ -1,4 +1,3 @@ -add_idl_headers(wineheaders itss.idl) - +add_idl_headers(wineheaders itss.idl winedxgi.idl) add_iid_library(itss_guid itss.idl) diff --git a/reactos/include/reactos/wine/winedxgi.idl b/reactos/include/reactos/wine/winedxgi.idl new file mode 100644 index 00000000000..363030a0018 --- /dev/null +++ b/reactos/include/reactos/wine/winedxgi.idl @@ -0,0 +1,70 @@ +/* + * Copyright 2008-2009 Henri Verbeet for CodeWeavers + * + * 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 + */ + +import "dxgi.idl"; + +[ + object, + local, + uuid(a07ad9ab-fb01-4574-8bfb-0a70a7373f04) +] +interface IWineDXGIFactory : IDXGIFactory +{ + struct wined3d *get_wined3d(); +} + +[ + object, + local, + uuid(ab1de34c-2963-4ffd-8493-40f580e510e5) +] +interface IWineDXGIAdapter : IDXGIAdapter +{ + UINT get_ordinal(); +} + +[ + object, + local, + uuid(3e1ff30b-c951-48c3-b010-0fb49f3dca71) +] +interface IWineDXGIDevice : IDXGIDevice +{ + struct wined3d_device *get_wined3d_device(); + HRESULT create_surface( + [in] const DXGI_SURFACE_DESC *desc, + [in] DXGI_USAGE usage, + [in] const DXGI_SHARED_RESOURCE *shared_resource, + [in] IUnknown *outer, + [out] void **surface + ); + HRESULT create_swapchain( + [in] struct wined3d_swapchain_desc *desc, + [out] struct wined3d_swapchain **wined3d_swapchain + ); +} + +[ + object, + local, + uuid(f2b918f3-603f-430a-9ccd-55872b6e85df) +] +interface IWineDXGIDeviceParent : IUnknown +{ + struct wined3d_device_parent *get_wined3d_device_parent(); +} diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE index 3a35d92aeef..bb221015655 100644 --- a/reactos/media/doc/README.WINE +++ b/reactos/media/doc/README.WINE @@ -35,6 +35,7 @@ reactos/dll/directx/dplay # Synced to Wine-1.5.26 reactos/dll/directx/dplayx # Synced to Wine-1.5.26 reactos/dll/directx/dsound # Synced to Wine-1.5.26 reactos/dll/directx/dxdiagn # Synced to Wine-0_9_5 +reactos/dll/directx/dxgi # Synced to Wine-1.5.26 reactos/dll/directx/msdmo # Autosync reactos/dll/directx/qedit # Autosync reactos/dll/directx/quartz # Synced to Wine-1.5.26