git.oblomov.eu Git - wine/blob - dlls/d3d10/d3d10_main.c

   1 /*
   2  * Direct3D 10
   3  *
   4  * Copyright 2007 Andras Kovacs
   5  * Copyright 2009 Henri Verbeet for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include "d3d10_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
  29
  30 /* At process attach */
  31 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
  32 {
  33     TRACE("fdwReason=%d\n", fdwReason);
  34     switch(fdwReason)
  35     {
  36     case DLL_PROCESS_ATTACH:
  37         DisableThreadLibraryCalls( hInstDLL );
  38         break;
  39     }
  40     return TRUE;
  41 }
  42
  43 HRESULT WINAPI D3D10CreateDevice(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type,
  44         HMODULE swrast, UINT flags, UINT sdk_version, ID3D10Device **device)
  45 {
  46     IDXGIFactory *factory;
  47     HRESULT hr;
  48
  49     TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, sdk_version %d, device %p\n",
  50             adapter, debug_d3d10_driver_type(driver_type), swrast, flags, sdk_version, device);
  51
  52     if (adapter)
  53     {
  54         IDXGIAdapter_AddRef(adapter);
  55         hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory);
  56         if (FAILED(hr))
  57         {
  58             WARN("Failed to get dxgi factory, returning %#x\n", hr);
  59             return hr;
  60         }
  61     }
  62     else
  63     {
  64         hr = CreateDXGIFactory(&IID_IDXGIFactory, (void **)&factory);
  65         if (FAILED(hr))
  66         {
  67             WARN("Failed to create dxgi factory, returning %#x\n", hr);
  68             return hr;
  69         }
  70
  71         switch(driver_type)
  72         {
  73             case D3D10_DRIVER_TYPE_HARDWARE:
  74             {
  75                 hr = IDXGIFactory_EnumAdapters(factory, 0, &adapter);
  76                 if (FAILED(hr))
  77                 {
  78                     WARN("No adapters found, returning %#x\n", hr);
  79                     IDXGIFactory_Release(factory);
  80                     return hr;
  81                 }
  82                 break;
  83             }
  84
  85             case D3D10_DRIVER_TYPE_NULL:
  86                 FIXME("NULL device not implemented, falling back to refrast\n");
  87                 /* fall through, for now */
  88             case D3D10_DRIVER_TYPE_REFERENCE:
  89             {
  90                 HMODULE refrast = LoadLibraryA("d3d10ref.dll");
  91                 if (!refrast)
  92                 {
  93                     WARN("Failed to load refrast, returning E_FAIL\n");
  94                     IDXGIFactory_Release(factory);
  95                     return E_FAIL;
  96                 }
  97                 hr = IDXGIFactory_CreateSoftwareAdapter(factory, refrast, &adapter);
  98                 FreeLibrary(refrast);
  99                 if (FAILED(hr))
 100                 {
 101                     WARN("Failed to create a software adapter, returning %#x\n", hr);
 102                     IDXGIFactory_Release(factory);
 103                     return hr;
 104                 }
 105                 break;
 106             }
 107
 108             case D3D10_DRIVER_TYPE_SOFTWARE:
 109             {
 110                 if (!swrast)
 111                 {
 112                     WARN("Software device requested, but NULL swrast passed, returning E_FAIL\n");
 113                     IDXGIFactory_Release(factory);
 114                     return E_FAIL;
 115                 }
 116                 hr = IDXGIFactory_CreateSoftwareAdapter(factory, swrast, &adapter);
 117                 if (FAILED(hr))
 118                 {
 119                     WARN("Failed to create a software adapter, returning %#x\n", hr);
 120                     IDXGIFactory_Release(factory);
 121                     return hr;
 122                 }
 123                 break;
 124             }
 125         }
 126     }
 127
 128     hr = D3D10CoreCreateDevice(factory, adapter, flags, NULL, device);
 129     IDXGIAdapter_Release(adapter);
 130     IDXGIFactory_Release(factory);
 131     if (FAILED(hr))
 132     {
 133         WARN("Failed to create a device, returning %#x\n", hr);
 134         return hr;
 135     }
 136
 137     TRACE("Created ID3D10Device %p\n", *device);
 138
 139     return hr;
 140 }
 141
 142 HRESULT WINAPI D3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type,
 143         HMODULE swrast, UINT flags, UINT sdk_version, DXGI_SWAP_CHAIN_DESC *swapchain_desc,
 144         IDXGISwapChain **swapchain, ID3D10Device **device)
 145 {
 146     IDXGIDevice *dxgi_device;
 147     IDXGIFactory *factory;
 148     HRESULT hr;
 149
 150     TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, sdk_version %d,\n"
 151             "\tswapchain_desc %p, swapchain %p, device %p\n",
 152             adapter, debug_d3d10_driver_type(driver_type), swrast, flags, sdk_version,
 153             swapchain_desc, swapchain, device);
 154
 155     hr = D3D10CreateDevice(adapter, driver_type, swrast, flags, sdk_version, device);
 156     if (FAILED(hr))
 157     {
 158         WARN("Failed to create a device, returning %#x\n", hr);
 159         *device = NULL;
 160         return hr;
 161     }
 162
 163     TRACE("Created ID3D10Device %p\n", *device);
 164
 165     hr = ID3D10Device_QueryInterface(*device, &IID_IDXGIDevice, (void **)&dxgi_device);
 166     if (FAILED(hr))
 167     {
 168         ERR("Failed to get a dxgi device from the d3d10 device, returning %#x\n", hr);
 169         ID3D10Device_Release(*device);
 170         *device = NULL;
 171         return hr;
 172     }
 173
 174     hr = IDXGIDevice_GetAdapter(dxgi_device, &adapter);
 175     IDXGIDevice_Release(dxgi_device);
 176     if (FAILED(hr))
 177     {
 178         ERR("Failed to get the device adapter, returning %#x\n", hr);
 179         ID3D10Device_Release(*device);
 180         *device = NULL;
 181         return hr;
 182     }
 183
 184     hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory);
 185     IDXGIAdapter_Release(adapter);
 186     if (FAILED(hr))
 187     {
 188         ERR("Failed to get the adapter factory, returning %#x\n", hr);
 189         ID3D10Device_Release(*device);
 190         *device = NULL;
 191         return hr;
 192     }
 193
 194     hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)*device, swapchain_desc, swapchain);
 195     IDXGIFactory_Release(factory);
 196     if (FAILED(hr))
 197     {
 198         ID3D10Device_Release(*device);
 199         *device = NULL;
 200
 201         WARN("Failed to create a swapchain, returning %#x\n", hr);
 202         return hr;
 203     }
 204
 205     TRACE("Created IDXGISwapChain %p\n", *swapchain);
 206
 207     return S_OK;
 208 }
 209
 210 HRESULT WINAPI D3D10CreateEffectFromMemory(void *data, SIZE_T data_size, UINT flags,
 211         ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3D10Effect **effect)
 212 {
 213     struct d3d10_effect *object;
 214     HRESULT hr;
 215
 216     FIXME("data %p, data_size %lu, flags %#x, device %p, effect_pool %p, effect %p stub!\n",
 217             data, data_size, flags, device, effect_pool, effect);
 218
 219     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 220     if (!object)
 221     {
 222         ERR("Failed to allocate D3D10 effect object memory\n");
 223         return E_OUTOFMEMORY;
 224     }
 225
 226     object->ID3D10Effect_iface.lpVtbl = &d3d10_effect_vtbl;
 227     object->refcount = 1;
 228     ID3D10Device_AddRef(device);
 229     object->device = device;
 230
 231     hr = d3d10_effect_parse(object, data, data_size);
 232     if (FAILED(hr))
 233     {
 234         ERR("Failed to parse effect\n");
 235         IUnknown_Release(&object->ID3D10Effect_iface);
 236         return hr;
 237     }
 238
 239     *effect = &object->ID3D10Effect_iface;
 240
 241     TRACE("Created ID3D10Effect %p\n", object);
 242
 243     return S_OK;
 244 }
 245
 246 HRESULT WINAPI D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const char *filename,
 247         const D3D10_SHADER_MACRO *defines, ID3D10Include *include, UINT hlsl_flags, UINT fx_flags,
 248         ID3D10Blob **effect, ID3D10Blob **errors)
 249 {
 250     FIXME("data %p, data_size %lu, filename %s, defines %p, include %p,"
 251             " hlsl_flags %#x, fx_flags %#x, effect %p, errors %p stub!\n",
 252             data, data_size, wine_dbgstr_a(filename), defines, include,
 253             hlsl_flags, fx_flags, effect, errors);
 254
 255     if (effect)
 256         *effect = NULL;
 257     if (errors)
 258         *errors = NULL;
 259
 260     return E_NOTIMPL;
 261 }
 262
 263
 264 LPCSTR WINAPI D3D10GetVertexShaderProfile(ID3D10Device *device)
 265 {
 266     FIXME("device %p stub!\n", device);
 267
 268     return "vs_4_0";
 269 }
 270
 271 LPCSTR WINAPI D3D10GetGeometryShaderProfile(ID3D10Device *device)
 272 {
 273     FIXME("device %p stub!\n", device);
 274
 275     return "gs_4_0";
 276 }
 277
 278 LPCSTR WINAPI D3D10GetPixelShaderProfile(ID3D10Device *device)
 279 {
 280     FIXME("device %p stub!\n", device);
 281
 282     return "ps_4_0";
 283 }
 284
 285 HRESULT WINAPI D3D10ReflectShader(const void *data, SIZE_T data_size, ID3D10ShaderReflection **reflector)
 286 {
 287     struct d3d10_shader_reflection *object;
 288
 289     FIXME("data %p, data_size %lu, reflector %p stub!\n", data, data_size, reflector);
 290
 291     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 292     if (!object)
 293     {
 294         ERR("Failed to allocate D3D10 shader reflection object memory\n");
 295         return E_OUTOFMEMORY;
 296     }
 297
 298     object->ID3D10ShaderReflection_iface.lpVtbl = &d3d10_shader_reflection_vtbl;
 299     object->refcount = 1;
 300
 301     *reflector = &object->ID3D10ShaderReflection_iface;
 302
 303     TRACE("Created ID3D10ShaderReflection %p\n", object);
 304
 305     return S_OK;
 306 }