| /* |
| * Direct3D 11 |
| * |
| * Copyright 2008 Henri Verbeet for CodeWeavers |
| * Copyright 2013 Austin English |
| * |
| * 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 D3D11_INIT_GUID |
| #include "d3d11_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(d3d11); |
| |
| static const char *debug_d3d_driver_type(D3D_DRIVER_TYPE driver_type) |
| { |
| switch (driver_type) |
| { |
| #define D3D11_TO_STR(x) case x: return #x |
| D3D11_TO_STR(D3D_DRIVER_TYPE_UNKNOWN); |
| D3D11_TO_STR(D3D_DRIVER_TYPE_HARDWARE); |
| D3D11_TO_STR(D3D_DRIVER_TYPE_REFERENCE); |
| D3D11_TO_STR(D3D_DRIVER_TYPE_NULL); |
| D3D11_TO_STR(D3D_DRIVER_TYPE_SOFTWARE); |
| D3D11_TO_STR(D3D_DRIVER_TYPE_WARP); |
| #undef D3D11_TO_STR |
| default: |
| return wine_dbg_sprintf("Unrecognized D3D_DRIVER_TYPE %#x\n", driver_type); |
| } |
| } |
| |
| static HRESULT WINAPI layer_init(enum dxgi_device_layer_id id, DWORD *count, DWORD *values) |
| { |
| TRACE("id %#x, count %p, values %p\n", id, count, values); |
| |
| if (id != DXGI_DEVICE_LAYER_D3D10_DEVICE) |
| { |
| WARN("Unknown layer id %#x\n", id); |
| return E_NOTIMPL; |
| } |
| |
| return S_OK; |
| } |
| |
| static UINT WINAPI layer_get_size(enum dxgi_device_layer_id id, struct layer_get_size_args *args, DWORD unknown0) |
| { |
| TRACE("id %#x, args %p, unknown0 %#x\n", id, args, unknown0); |
| |
| if (id != DXGI_DEVICE_LAYER_D3D10_DEVICE) |
| { |
| WARN("Unknown layer id %#x\n", id); |
| return 0; |
| } |
| |
| return sizeof(struct d3d_device); |
| } |
| |
| static HRESULT WINAPI layer_create(enum dxgi_device_layer_id id, void **layer_base, DWORD unknown0, |
| void *device_object, REFIID riid, void **device_layer) |
| { |
| struct d3d_device *object; |
| |
| TRACE("id %#x, layer_base %p, unknown0 %#x, device_object %p, riid %s, device_layer %p\n", |
| id, layer_base, unknown0, device_object, debugstr_guid(riid), device_layer); |
| |
| if (id != DXGI_DEVICE_LAYER_D3D10_DEVICE) |
| { |
| WARN("Unknown layer id %#x\n", id); |
| *device_layer = NULL; |
| return E_NOTIMPL; |
| } |
| |
| object = *layer_base; |
| d3d_device_init(object, device_object); |
| *device_layer = &object->IUnknown_inner; |
| |
| TRACE("Created d3d10 device at %p\n", object); |
| |
| return S_OK; |
| } |
| |
| static void WINAPI layer_set_feature_level(enum dxgi_device_layer_id id, void *device, |
| D3D_FEATURE_LEVEL feature_level) |
| { |
| struct d3d_device *d3d_device = device; |
| |
| TRACE("id %#x, device %p, feature_level %#x.\n", id, device, feature_level); |
| |
| if (id != DXGI_DEVICE_LAYER_D3D10_DEVICE) |
| { |
| WARN("Unknown layer id %#x.\n", id); |
| return; |
| } |
| |
| d3d_device->feature_level = feature_level; |
| } |
| |
| HRESULT WINAPI D3D11CoreRegisterLayers(void) |
| { |
| static const struct dxgi_device_layer layers[] = |
| { |
| {DXGI_DEVICE_LAYER_D3D10_DEVICE, layer_init, layer_get_size, layer_create, layer_set_feature_level}, |
| }; |
| |
| DXGID3D10RegisterLayers(layers, ARRAY_SIZE(layers)); |
| |
| return S_OK; |
| } |
| |
| HRESULT WINAPI D3D11CoreCreateDevice(IDXGIFactory *factory, IDXGIAdapter *adapter, UINT flags, |
| const D3D_FEATURE_LEVEL *feature_levels, UINT levels, ID3D11Device **device) |
| { |
| IUnknown *dxgi_device; |
| HMODULE d3d11; |
| HRESULT hr; |
| |
| TRACE("factory %p, adapter %p, flags %#x, feature_levels %p, levels %u, device %p.\n", |
| factory, adapter, flags, feature_levels, levels, device); |
| |
| d3d11 = GetModuleHandleA("d3d11.dll"); |
| hr = DXGID3D10CreateDevice(d3d11, factory, adapter, flags, feature_levels, levels, (void **)&dxgi_device); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create device, returning %#x.\n", hr); |
| return hr; |
| } |
| |
| hr = IUnknown_QueryInterface(dxgi_device, &IID_ID3D11Device, (void **)device); |
| IUnknown_Release(dxgi_device); |
| if (FAILED(hr)) |
| { |
| ERR("Failed to query ID3D11Device interface, returning E_FAIL.\n"); |
| return E_FAIL; |
| } |
| |
| return S_OK; |
| } |
| |
| HRESULT WINAPI D3D11CreateDevice(IDXGIAdapter *adapter, D3D_DRIVER_TYPE driver_type, HMODULE swrast, UINT flags, |
| const D3D_FEATURE_LEVEL *feature_levels, UINT levels, UINT sdk_version, ID3D11Device **device_out, |
| D3D_FEATURE_LEVEL *obtained_feature_level, ID3D11DeviceContext **immediate_context) |
| { |
| static const D3D_FEATURE_LEVEL default_feature_levels[] = |
| { |
| D3D_FEATURE_LEVEL_11_0, |
| D3D_FEATURE_LEVEL_10_1, |
| D3D_FEATURE_LEVEL_10_0, |
| D3D_FEATURE_LEVEL_9_3, |
| D3D_FEATURE_LEVEL_9_2, |
| D3D_FEATURE_LEVEL_9_1, |
| }; |
| IDXGIFactory *factory; |
| ID3D11Device *device; |
| HRESULT hr; |
| |
| TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, feature_levels %p, levels %u, sdk_version %u, " |
| "device %p, obtained_feature_level %p, immediate_context %p.\n", |
| adapter, debug_d3d_driver_type(driver_type), swrast, flags, feature_levels, levels, sdk_version, |
| device_out, obtained_feature_level, immediate_context); |
| |
| if (device_out) |
| *device_out = NULL; |
| if (obtained_feature_level) |
| *obtained_feature_level = 0; |
| if (immediate_context) |
| *immediate_context = NULL; |
| |
| if (adapter) |
| { |
| IDXGIAdapter_AddRef(adapter); |
| hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to get dxgi factory, returning %#x.\n", hr); |
| return hr; |
| } |
| } |
| else |
| { |
| hr = CreateDXGIFactory1(&IID_IDXGIFactory, (void **)&factory); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create dxgi factory, returning %#x.\n", hr); |
| return hr; |
| } |
| |
| switch(driver_type) |
| { |
| case D3D_DRIVER_TYPE_HARDWARE: |
| { |
| hr = IDXGIFactory_EnumAdapters(factory, 0, &adapter); |
| if (FAILED(hr)) |
| { |
| WARN("No adapters found, returning %#x.\n", hr); |
| IDXGIFactory_Release(factory); |
| return hr; |
| } |
| break; |
| } |
| |
| case D3D_DRIVER_TYPE_NULL: |
| FIXME("NULL device not implemented, falling back to refrast.\n"); |
| /* fall through, for now */ |
| case D3D_DRIVER_TYPE_REFERENCE: |
| { |
| HMODULE refrast = LoadLibraryA("d3d11ref.dll"); |
| if (!refrast) |
| { |
| WARN("Failed to load refrast, returning E_FAIL.\n"); |
| IDXGIFactory_Release(factory); |
| return E_FAIL; |
| } |
| hr = IDXGIFactory_CreateSoftwareAdapter(factory, refrast, &adapter); |
| FreeLibrary(refrast); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create a software adapter, returning %#x.\n", hr); |
| IDXGIFactory_Release(factory); |
| return hr; |
| } |
| break; |
| } |
| |
| case D3D_DRIVER_TYPE_SOFTWARE: |
| { |
| if (!swrast) |
| { |
| WARN("Software device requested, but NULL swrast passed, returning E_FAIL.\n"); |
| IDXGIFactory_Release(factory); |
| return E_FAIL; |
| } |
| hr = IDXGIFactory_CreateSoftwareAdapter(factory, swrast, &adapter); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create a software adapter, returning %#x.\n", hr); |
| IDXGIFactory_Release(factory); |
| return hr; |
| } |
| break; |
| } |
| |
| default: |
| FIXME("Unhandled driver type %#x.\n", driver_type); |
| IDXGIFactory_Release(factory); |
| return E_FAIL; |
| } |
| } |
| |
| if (!feature_levels) |
| { |
| feature_levels = default_feature_levels; |
| levels = ARRAY_SIZE(default_feature_levels); |
| } |
| hr = D3D11CoreCreateDevice(factory, adapter, flags, feature_levels, levels, &device); |
| IDXGIAdapter_Release(adapter); |
| IDXGIFactory_Release(factory); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create a device, returning %#x.\n", hr); |
| return hr; |
| } |
| |
| TRACE("Created ID3D11Device %p.\n", device); |
| |
| if (obtained_feature_level) |
| *obtained_feature_level = ID3D11Device_GetFeatureLevel(device); |
| |
| if (immediate_context) |
| ID3D11Device_GetImmediateContext(device, immediate_context); |
| |
| if (device_out) |
| *device_out = device; |
| else |
| ID3D11Device_Release(device); |
| |
| return (device_out || immediate_context) ? S_OK : S_FALSE; |
| } |
| |
| HRESULT WINAPI D3D11CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D_DRIVER_TYPE driver_type, |
| HMODULE swrast, UINT flags, const D3D_FEATURE_LEVEL *feature_levels, UINT levels, |
| UINT sdk_version, const DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, |
| ID3D11Device **device_out, D3D_FEATURE_LEVEL *obtained_feature_level, ID3D11DeviceContext **immediate_context) |
| { |
| DXGI_SWAP_CHAIN_DESC desc; |
| IDXGIDevice *dxgi_device; |
| IDXGIFactory *factory; |
| ID3D11Device *device; |
| HRESULT hr; |
| |
| TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, feature_levels %p, levels %u, sdk_version %u, " |
| "swapchain_desc %p, swapchain %p, device %p, obtained_feature_level %p, immediate_context %p.\n", |
| adapter, debug_d3d_driver_type(driver_type), swrast, flags, feature_levels, levels, sdk_version, |
| swapchain_desc, swapchain, device_out, obtained_feature_level, immediate_context); |
| |
| if (swapchain) |
| *swapchain = NULL; |
| if (device_out) |
| *device_out = NULL; |
| |
| if (FAILED(hr = D3D11CreateDevice(adapter, driver_type, swrast, flags, feature_levels, levels, sdk_version, |
| &device, obtained_feature_level, immediate_context))) |
| { |
| WARN("Failed to create a device, returning %#x.\n", hr); |
| return hr; |
| } |
| |
| if (swapchain) |
| { |
| if (FAILED(hr = ID3D11Device_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgi_device))) |
| { |
| ERR("Failed to get a dxgi device from the d3d11 device, returning %#x.\n", hr); |
| goto cleanup; |
| } |
| |
| hr = IDXGIDevice_GetAdapter(dxgi_device, &adapter); |
| IDXGIDevice_Release(dxgi_device); |
| if (FAILED(hr)) |
| { |
| ERR("Failed to get the device adapter, returning %#x.\n", hr); |
| goto cleanup; |
| } |
| |
| hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory); |
| IDXGIAdapter_Release(adapter); |
| if (FAILED(hr)) |
| { |
| ERR("Failed to get the adapter factory, returning %#x.\n", hr); |
| goto cleanup; |
| } |
| |
| desc = *swapchain_desc; |
| hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)device, &desc, swapchain); |
| IDXGIFactory_Release(factory); |
| if (FAILED(hr)) |
| { |
| WARN("Failed to create a swapchain, returning %#x.\n", hr); |
| goto cleanup; |
| } |
| |
| TRACE("Created IDXGISwapChain %p.\n", *swapchain); |
| } |
| |
| if (device_out) |
| *device_out = device; |
| else |
| ID3D11Device_Release(device); |
| |
| return (swapchain || device_out || immediate_context) ? S_OK : S_FALSE; |
| |
| cleanup: |
| ID3D11Device_Release(device); |
| if (obtained_feature_level) |
| *obtained_feature_level = 0; |
| if (immediate_context) |
| { |
| ID3D11DeviceContext_Release(*immediate_context); |
| *immediate_context = NULL; |
| } |
| |
| return hr; |
| } |