dlls/d3d10_1/d3d10_1_main.c

   1 /*
   2  * Copyright 2014 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "wine/debug.h"
  21
  22 #define COBJMACROS
  23 #include "d3d10_1.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
  26
  27 HRESULT WINAPI D3D10CoreCreateDevice(IDXGIFactory *factory, IDXGIAdapter *adapter,
  28         unsigned int flags, D3D_FEATURE_LEVEL feature_level, ID3D10Device **device);
  29
  30 #define WINE_D3D10_TO_STR(x) case x: return #x
  31
  32 static const char *debug_d3d10_driver_type(D3D10_DRIVER_TYPE driver_type)
  33 {
  34     switch (driver_type)
  35     {
  36         WINE_D3D10_TO_STR(D3D10_DRIVER_TYPE_HARDWARE);
  37         WINE_D3D10_TO_STR(D3D10_DRIVER_TYPE_REFERENCE);
  38         WINE_D3D10_TO_STR(D3D10_DRIVER_TYPE_NULL);
  39         WINE_D3D10_TO_STR(D3D10_DRIVER_TYPE_SOFTWARE);
  40         WINE_D3D10_TO_STR(D3D10_DRIVER_TYPE_WARP);
  41         default:
  42             FIXME("Unrecognized D3D10_DRIVER_TYPE %#x.\n", driver_type);
  43             return "unrecognized";
  44     }
  45 }
  46
  47 static const char *debug_d3d10_feature_level(D3D10_FEATURE_LEVEL1 feature_level)
  48 {
  49     switch (feature_level)
  50     {
  51         WINE_D3D10_TO_STR(D3D10_FEATURE_LEVEL_10_0);
  52         WINE_D3D10_TO_STR(D3D10_FEATURE_LEVEL_10_1);
  53         WINE_D3D10_TO_STR(D3D10_FEATURE_LEVEL_9_1);
  54         WINE_D3D10_TO_STR(D3D10_FEATURE_LEVEL_9_2);
  55         WINE_D3D10_TO_STR(D3D10_FEATURE_LEVEL_9_3);
  56         default:
  57             FIXME("Unrecognized D3D10_FEATURE_LEVEL1 %#x.\n", feature_level);
  58             return "unrecognized";
  59     }
  60 }
  61
  62 #undef WINE_D3D10_TO_STR
  63
  64 static HRESULT d3d10_create_device1(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, HMODULE swrast,
  65         UINT flags, D3D10_FEATURE_LEVEL1 hw_level, UINT sdk_version, ID3D10Device1 **device)
  66 {
  67     IDXGIFactory *factory;
  68     HRESULT hr;
  69
  70     TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, hw_level %s, sdk_version %d, device %p.\n",
  71             adapter, debug_d3d10_driver_type(driver_type), swrast, flags,
  72             debug_d3d10_feature_level(hw_level), sdk_version, device);
  73
  74     if (!device)
  75         return E_INVALIDARG;
  76
  77     *device = NULL;
  78
  79     if (!hw_level)
  80         return E_INVALIDARG;
  81
  82     if (adapter)
  83     {
  84         IDXGIAdapter_AddRef(adapter);
  85         if (FAILED(hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory)))
  86         {
  87             WARN("Failed to get dxgi factory, hr %#x.\n", hr);
  88             return hr;
  89         }
  90     }
  91     else
  92     {
  93         if (FAILED(hr = CreateDXGIFactory(&IID_IDXGIFactory, (void **)&factory)))
  94         {
  95             WARN("Failed to create dxgi factory, hr %#x.\n", hr);
  96             return hr;
  97         }
  98
  99         switch (driver_type)
 100         {
 101             case D3D10_DRIVER_TYPE_WARP:
 102                 FIXME("WARP driver not implemented, falling back to hardware.\n");
 103             case D3D10_DRIVER_TYPE_HARDWARE:
 104             {
 105                 if (FAILED(hr = IDXGIFactory_EnumAdapters(factory, 0, &adapter)))
 106                 {
 107                     WARN("No adapters found, hr %#x.\n", hr);
 108                     IDXGIFactory_Release(factory);
 109                     return hr;
 110                 }
 111                 break;
 112             }
 113
 114             case D3D10_DRIVER_TYPE_NULL:
 115                 FIXME("NULL device not implemented, falling back to refrast.\n");
 116                 /* Fall through, for now. */
 117             case D3D10_DRIVER_TYPE_REFERENCE:
 118             {
 119                 HMODULE refrast;
 120
 121                 if (!(refrast = LoadLibraryA("d3d10ref.dll")))
 122                 {
 123                     WARN("Failed to load refrast, returning E_FAIL.\n");
 124                     IDXGIFactory_Release(factory);
 125                     return E_FAIL;
 126                 }
 127                 hr = IDXGIFactory_CreateSoftwareAdapter(factory, refrast, &adapter);
 128                 FreeLibrary(refrast);
 129                 if (FAILED(hr))
 130                 {
 131                     WARN("Failed to create a software adapter, hr %#x.\n", hr);
 132                     IDXGIFactory_Release(factory);
 133                     return hr;
 134                 }
 135                 break;
 136             }
 137
 138             case D3D10_DRIVER_TYPE_SOFTWARE:
 139             {
 140                 if (!swrast)
 141                 {
 142                     WARN("Software device requested, but NULL swrast passed, returning E_FAIL.\n");
 143                     IDXGIFactory_Release(factory);
 144                     return E_FAIL;
 145                 }
 146                 if (FAILED(hr = IDXGIFactory_CreateSoftwareAdapter(factory, swrast, &adapter)))
 147                 {
 148                     WARN("Failed to create a software adapter, hr %#x.\n", hr);
 149                     IDXGIFactory_Release(factory);
 150                     return hr;
 151                 }
 152                 break;
 153             }
 154
 155             default:
 156                 FIXME("Unhandled driver type %#x.\n", driver_type);
 157                 IDXGIFactory_Release(factory);
 158                 return E_FAIL;
 159         }
 160     }
 161
 162     hr = D3D10CoreCreateDevice(factory, adapter, flags, hw_level, (ID3D10Device **)device);
 163     IDXGIAdapter_Release(adapter);
 164     IDXGIFactory_Release(factory);
 165     if (FAILED(hr))
 166     {
 167         WARN("Failed to create a device, hr %#x.\n", hr);
 168         return hr;
 169     }
 170
 171     TRACE("Created device %p.\n", *device);
 172
 173     return hr;
 174 }
 175
 176 HRESULT WINAPI D3D10CreateDevice1(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, HMODULE swrast,
 177         UINT flags, D3D10_FEATURE_LEVEL1 hw_level, UINT sdk_version, ID3D10Device1 **device)
 178 {
 179     return d3d10_create_device1(adapter, driver_type, swrast, flags, hw_level, sdk_version, device);
 180 }
 181
 182 HRESULT WINAPI D3D10CreateDeviceAndSwapChain1(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type,
 183         HMODULE swrast, UINT flags, D3D10_FEATURE_LEVEL1 feature_level, UINT sdk_version,
 184         DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D10Device1 **device)
 185 {
 186     IDXGIDevice *dxgi_device;
 187     IDXGIFactory *factory;
 188     HRESULT hr;
 189
 190     TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, "
 191             "feature_level %s, sdk_version %d, swapchain_desc %p, swapchain %p, device %p.\n",
 192             adapter, debug_d3d10_driver_type(driver_type), swrast, flags,
 193             debug_d3d10_feature_level(feature_level), sdk_version, swapchain_desc, swapchain, device);
 194
 195     if (swapchain)
 196         *swapchain = NULL;
 197
 198     if (!device)
 199         return E_INVALIDARG;
 200
 201     /* Avoid forwarding to D3D10CreateDevice1(), since it breaks applications
 202      * hooking these entry-points. */
 203     if (FAILED(hr = d3d10_create_device1(adapter, driver_type, swrast, flags, feature_level, sdk_version, device)))
 204     {
 205         WARN("Failed to create a device, returning %#x.\n", hr);
 206         *device = NULL;
 207         return hr;
 208     }
 209
 210     if (swapchain)
 211     {
 212         if (FAILED(hr = ID3D10Device1_QueryInterface(*device, &IID_IDXGIDevice, (void **)&dxgi_device)))
 213         {
 214             ERR("Failed to get a dxgi device from the d3d10 device, returning %#x.\n", hr);
 215             goto cleanup;
 216         }
 217
 218         hr = IDXGIDevice_GetAdapter(dxgi_device, &adapter);
 219         IDXGIDevice_Release(dxgi_device);
 220         if (FAILED(hr))
 221         {
 222             ERR("Failed to get the device adapter, returning %#x.\n", hr);
 223             goto cleanup;
 224         }
 225
 226         hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory);
 227         IDXGIAdapter_Release(adapter);
 228         if (FAILED(hr))
 229         {
 230             ERR("Failed to get the adapter factory, returning %#x.\n", hr);
 231             goto cleanup;
 232         }
 233
 234         hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)*device, swapchain_desc, swapchain);
 235         IDXGIFactory_Release(factory);
 236         if (FAILED(hr))
 237         {
 238             WARN("Failed to create a swapchain, returning %#x.\n", hr);
 239             goto cleanup;
 240         }
 241
 242         TRACE("Created IDXGISwapChain %p.\n", *swapchain);
 243     }
 244
 245     return S_OK;
 246
 247 cleanup:
 248     ID3D10Device1_Release(*device);
 249     *device = NULL;
 250     return hr;
 251 }