dlls/d3d11/texture.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  * Copyright 2015 Józef Kucia for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #include "d3d11_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  24
  25 /* ID3D11Texture1D methods */
  26
  27 static inline struct d3d_texture1d *impl_from_ID3D11Texture1D(ID3D11Texture1D *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D11Texture1D_iface);
  30 }
  31
  32 static HRESULT STDMETHODCALLTYPE d3d11_texture1d_QueryInterface(ID3D11Texture1D *iface, REFIID iid, void **out)
  33 {
  34     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
  35
  36     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  37
  38     if (IsEqualGUID(iid, &IID_ID3D11Texture1D)
  39             || IsEqualGUID(iid, &IID_ID3D11Resource)
  40             || IsEqualGUID(iid, &IID_ID3D11DeviceChild)
  41             || IsEqualGUID(iid, &IID_IUnknown))
  42     {
  43         *out = iface;
  44         IUnknown_AddRef(iface);
  45         return S_OK;
  46     }
  47
  48     if (IsEqualGUID(iid, &IID_ID3D10Texture1D)
  49             || IsEqualGUID(iid, &IID_ID3D10Resource)
  50             || IsEqualGUID(iid, &IID_ID3D10DeviceChild))
  51     {
  52         *out = &texture->ID3D10Texture1D_iface;
  53         IUnknown_AddRef((IUnknown *)*out);
  54         return S_OK;
  55     }
  56
  57     if (texture->dxgi_surface)
  58     {
  59         TRACE("Forwarding to dxgi surface.\n");
  60         return IUnknown_QueryInterface(texture->dxgi_surface, iid, out);
  61     }
  62
  63     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  64
  65     *out = NULL;
  66     return E_NOINTERFACE;
  67 }
  68
  69 static ULONG STDMETHODCALLTYPE d3d11_texture1d_AddRef(ID3D11Texture1D *iface)
  70 {
  71     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
  72     ULONG refcount = InterlockedIncrement(&texture->refcount);
  73
  74     TRACE("%p increasing refcount to %u.\n", texture, refcount);
  75
  76     if (refcount == 1)
  77     {
  78         ID3D11Device2_AddRef(texture->device);
  79         wined3d_mutex_lock();
  80         wined3d_texture_incref(texture->wined3d_texture);
  81         wined3d_mutex_unlock();
  82     }
  83
  84     return refcount;
  85 }
  86
  87 static ULONG STDMETHODCALLTYPE d3d11_texture1d_Release(ID3D11Texture1D *iface)
  88 {
  89     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
  90     ULONG refcount = InterlockedDecrement(&texture->refcount);
  91
  92     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
  93
  94     if (!refcount)
  95     {
  96         ID3D11Device2 *device = texture->device;
  97
  98         wined3d_mutex_lock();
  99         wined3d_texture_decref(texture->wined3d_texture);
 100         wined3d_mutex_unlock();
 101         /* Release the device last, it may cause the wined3d device to be
 102          * destroyed. */
 103         ID3D11Device2_Release(device);
 104     }
 105
 106     return refcount;
 107 }
 108
 109 static void STDMETHODCALLTYPE d3d11_texture1d_GetDevice(ID3D11Texture1D *iface, ID3D11Device **device)
 110 {
 111     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
 112
 113     TRACE("iface %p, device %p.\n", iface, device);
 114
 115     *device = (ID3D11Device *)texture->device;
 116     ID3D11Device_AddRef(*device);
 117 }
 118
 119 static HRESULT STDMETHODCALLTYPE d3d11_texture1d_GetPrivateData(ID3D11Texture1D *iface,
 120         REFGUID guid, UINT *data_size, void *data)
 121 {
 122     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
 123     IDXGISurface *dxgi_surface;
 124     HRESULT hr;
 125
 126     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 127
 128     if (texture->dxgi_surface
 129             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 130     {
 131         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 132         IDXGISurface_Release(dxgi_surface);
 133         return hr;
 134     }
 135
 136     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 137 }
 138
 139 static HRESULT STDMETHODCALLTYPE d3d11_texture1d_SetPrivateData(ID3D11Texture1D *iface,
 140         REFGUID guid, UINT data_size, const void *data)
 141 {
 142     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
 143     IDXGISurface *dxgi_surface;
 144     HRESULT hr;
 145
 146     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 147
 148     if (texture->dxgi_surface
 149             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 150     {
 151         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 152         IDXGISurface_Release(dxgi_surface);
 153         return hr;
 154     }
 155
 156     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 157 }
 158
 159 static HRESULT STDMETHODCALLTYPE d3d11_texture1d_SetPrivateDataInterface(ID3D11Texture1D *iface,
 160         REFGUID guid, const IUnknown *data)
 161 {
 162     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
 163     IDXGISurface *dxgi_surface;
 164     HRESULT hr;
 165
 166     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 167
 168     if (texture->dxgi_surface
 169             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 170     {
 171         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 172         IDXGISurface_Release(dxgi_surface);
 173         return hr;
 174     }
 175
 176     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 177 }
 178
 179 static void STDMETHODCALLTYPE d3d11_texture1d_GetType(ID3D11Texture1D *iface,
 180         D3D11_RESOURCE_DIMENSION *resource_dimension)
 181 {
 182     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 183
 184     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE1D;
 185 }
 186
 187 static void STDMETHODCALLTYPE d3d11_texture1d_SetEvictionPriority(ID3D11Texture1D *iface, UINT eviction_priority)
 188 {
 189     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 190 }
 191
 192 static UINT STDMETHODCALLTYPE d3d11_texture1d_GetEvictionPriority(ID3D11Texture1D *iface)
 193 {
 194     FIXME("iface %p stub!\n", iface);
 195
 196     return 0;
 197 }
 198
 199 static void STDMETHODCALLTYPE d3d11_texture1d_GetDesc(ID3D11Texture1D *iface, D3D11_TEXTURE1D_DESC *desc)
 200 {
 201     struct d3d_texture1d *texture = impl_from_ID3D11Texture1D(iface);
 202
 203     TRACE("iface %p, desc %p.\n", iface, desc);
 204
 205     *desc = texture->desc;
 206 }
 207
 208 static const struct ID3D11Texture1DVtbl d3d11_texture1d_vtbl =
 209 {
 210     /* IUnknown methods */
 211     d3d11_texture1d_QueryInterface,
 212     d3d11_texture1d_AddRef,
 213     d3d11_texture1d_Release,
 214     /* ID3D11DeviceChild methods */
 215     d3d11_texture1d_GetDevice,
 216     d3d11_texture1d_GetPrivateData,
 217     d3d11_texture1d_SetPrivateData,
 218     d3d11_texture1d_SetPrivateDataInterface,
 219     /* ID3D11Resource methods */
 220     d3d11_texture1d_GetType,
 221     d3d11_texture1d_SetEvictionPriority,
 222     d3d11_texture1d_GetEvictionPriority,
 223     /* ID3D11Texture1D methods */
 224     d3d11_texture1d_GetDesc,
 225 };
 226
 227 struct d3d_texture1d *unsafe_impl_from_ID3D11Texture1D(ID3D11Texture1D *iface)
 228 {
 229     if (!iface)
 230         return NULL;
 231     assert(iface->lpVtbl == &d3d11_texture1d_vtbl);
 232     return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D11Texture1D_iface);
 233 }
 234
 235 static inline struct d3d_texture1d *impl_from_ID3D10Texture1D(ID3D10Texture1D *iface)
 236 {
 237     return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D10Texture1D_iface);
 238 }
 239
 240 /* IUnknown methods */
 241
 242 static HRESULT STDMETHODCALLTYPE d3d10_texture1d_QueryInterface(ID3D10Texture1D *iface, REFIID iid, void **out)
 243 {
 244     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 245
 246     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 247
 248     return d3d11_texture1d_QueryInterface(&texture->ID3D11Texture1D_iface, iid, out);
 249 }
 250
 251 static ULONG STDMETHODCALLTYPE d3d10_texture1d_AddRef(ID3D10Texture1D *iface)
 252 {
 253     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 254
 255     TRACE("iface %p.\n", iface);
 256
 257     return d3d11_texture1d_AddRef(&texture->ID3D11Texture1D_iface);
 258 }
 259
 260 static void STDMETHODCALLTYPE d3d_texture1d_wined3d_object_released(void *parent)
 261 {
 262     struct d3d_texture1d *texture = parent;
 263
 264     if (texture->dxgi_surface)
 265         IUnknown_Release(texture->dxgi_surface);
 266     wined3d_private_store_cleanup(&texture->private_store);
 267     heap_free(texture);
 268 }
 269
 270 static ULONG STDMETHODCALLTYPE d3d10_texture1d_Release(ID3D10Texture1D *iface)
 271 {
 272     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 273
 274     TRACE("iface %p.\n", iface);
 275
 276     return d3d11_texture1d_Release(&texture->ID3D11Texture1D_iface);
 277 }
 278
 279 /* ID3D10DeviceChild methods */
 280
 281 static void STDMETHODCALLTYPE d3d10_texture1d_GetDevice(ID3D10Texture1D *iface, ID3D10Device **device)
 282 {
 283     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 284
 285     TRACE("iface %p, device %p.\n", iface, device);
 286
 287     ID3D11Device2_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 288 }
 289
 290 static HRESULT STDMETHODCALLTYPE d3d10_texture1d_GetPrivateData(ID3D10Texture1D *iface,
 291         REFGUID guid, UINT *data_size, void *data)
 292 {
 293     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 294
 295     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 296
 297     return d3d11_texture1d_GetPrivateData(&texture->ID3D11Texture1D_iface, guid, data_size, data);
 298 }
 299
 300 static HRESULT STDMETHODCALLTYPE d3d10_texture1d_SetPrivateData(ID3D10Texture1D *iface,
 301         REFGUID guid, UINT data_size, const void *data)
 302 {
 303     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 304
 305     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 306
 307     return d3d11_texture1d_SetPrivateData(&texture->ID3D11Texture1D_iface, guid, data_size, data);
 308 }
 309
 310 static HRESULT STDMETHODCALLTYPE d3d10_texture1d_SetPrivateDataInterface(ID3D10Texture1D *iface,
 311         REFGUID guid, const IUnknown *data)
 312 {
 313     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 314
 315     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 316
 317     return d3d11_texture1d_SetPrivateDataInterface(&texture->ID3D11Texture1D_iface, guid, data);
 318 }
 319
 320 /* ID3D10Resource methods */
 321
 322 static void STDMETHODCALLTYPE d3d10_texture1d_GetType(ID3D10Texture1D *iface,
 323         D3D10_RESOURCE_DIMENSION *resource_dimension)
 324 {
 325     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 326
 327     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE1D;
 328 }
 329
 330 static void STDMETHODCALLTYPE d3d10_texture1d_SetEvictionPriority(ID3D10Texture1D *iface, UINT eviction_priority)
 331 {
 332     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 333 }
 334
 335 static UINT STDMETHODCALLTYPE d3d10_texture1d_GetEvictionPriority(ID3D10Texture1D *iface)
 336 {
 337     FIXME("iface %p stub!\n", iface);
 338
 339     return 0;
 340 }
 341
 342 /* ID3D10Texture1D methods */
 343
 344 static HRESULT STDMETHODCALLTYPE d3d10_texture1d_Map(ID3D10Texture1D *iface, UINT sub_resource_idx,
 345         D3D10_MAP map_type, UINT map_flags, void **data)
 346 {
 347     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 348     struct wined3d_map_desc wined3d_map_desc;
 349     HRESULT hr;
 350
 351     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, data %p.\n",
 352             iface, sub_resource_idx, map_type, map_flags, data);
 353
 354     if (map_flags)
 355         FIXME("Ignoring map_flags %#x.\n", map_flags);
 356
 357     wined3d_mutex_lock();
 358     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
 359             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 360     {
 361         *data = wined3d_map_desc.data;
 362     }
 363     wined3d_mutex_unlock();
 364
 365     return hr;
 366 }
 367
 368 static void STDMETHODCALLTYPE d3d10_texture1d_Unmap(ID3D10Texture1D *iface, UINT sub_resource_idx)
 369 {
 370     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 371
 372     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 373
 374     wined3d_mutex_lock();
 375     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
 376     wined3d_mutex_unlock();
 377 }
 378
 379 static void STDMETHODCALLTYPE d3d10_texture1d_GetDesc(ID3D10Texture1D *iface, D3D10_TEXTURE1D_DESC *desc)
 380 {
 381     struct d3d_texture1d *texture = impl_from_ID3D10Texture1D(iface);
 382     D3D11_TEXTURE1D_DESC d3d11_desc;
 383
 384     TRACE("iface %p, desc %p.\n", iface, desc);
 385
 386     d3d11_texture1d_GetDesc(&texture->ID3D11Texture1D_iface, &d3d11_desc);
 387
 388     desc->Width = d3d11_desc.Width;
 389     desc->MipLevels = d3d11_desc.MipLevels;
 390     desc->ArraySize = d3d11_desc.ArraySize;
 391     desc->Format = d3d11_desc.Format;
 392     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
 393     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
 394     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
 395     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
 396 }
 397
 398 static const struct ID3D10Texture1DVtbl d3d10_texture1d_vtbl =
 399 {
 400     /* IUnknown methods */
 401     d3d10_texture1d_QueryInterface,
 402     d3d10_texture1d_AddRef,
 403     d3d10_texture1d_Release,
 404     /* ID3D10DeviceChild methods */
 405     d3d10_texture1d_GetDevice,
 406     d3d10_texture1d_GetPrivateData,
 407     d3d10_texture1d_SetPrivateData,
 408     d3d10_texture1d_SetPrivateDataInterface,
 409     /* ID3D10Resource methods */
 410     d3d10_texture1d_GetType,
 411     d3d10_texture1d_SetEvictionPriority,
 412     d3d10_texture1d_GetEvictionPriority,
 413     /* ID3D10Texture1D methods */
 414     d3d10_texture1d_Map,
 415     d3d10_texture1d_Unmap,
 416     d3d10_texture1d_GetDesc,
 417 };
 418
 419 struct d3d_texture1d *unsafe_impl_from_ID3D10Texture1D(ID3D10Texture1D *iface)
 420 {
 421     if (!iface)
 422         return NULL;
 423     assert(iface->lpVtbl == &d3d10_texture1d_vtbl);
 424     return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D10Texture1D_iface);
 425 }
 426
 427 static const struct wined3d_parent_ops d3d_texture1d_wined3d_parent_ops =
 428 {
 429     d3d_texture1d_wined3d_object_released,
 430 };
 431
 432 HRESULT d3d_texture1d_create(struct d3d_device *device, const D3D11_TEXTURE1D_DESC *desc,
 433         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture1d **out)
 434 {
 435     struct wined3d_resource_desc wined3d_desc;
 436     struct d3d_texture1d *texture;
 437     unsigned int levels;
 438     DWORD flags = 0;
 439     HRESULT hr;
 440
 441     if (!(texture = heap_alloc_zero(sizeof(*texture))))
 442         return E_OUTOFMEMORY;
 443
 444     texture->ID3D11Texture1D_iface.lpVtbl = &d3d11_texture1d_vtbl;
 445     texture->ID3D10Texture1D_iface.lpVtbl = &d3d10_texture1d_vtbl;
 446     texture->refcount = 1;
 447     wined3d_private_store_init(&texture->private_store);
 448     texture->desc = *desc;
 449     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(desc->Width) + 1;
 450     texture->desc.MipLevels = levels;
 451
 452     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_1D;
 453     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 454     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
 455     wined3d_desc.multisample_quality = 0;
 456     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->Usage);
 457     wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(desc->BindFlags, desc->MiscFlags);
 458     wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
 459             desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
 460     wined3d_desc.width = desc->Width;
 461     wined3d_desc.height = 1;
 462     wined3d_desc.depth = 1;
 463     wined3d_desc.size = 0;
 464
 465     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
 466         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 467     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
 468         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 469
 470     wined3d_mutex_lock();
 471     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 472             desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
 473             texture, &d3d_texture1d_wined3d_parent_ops, &texture->wined3d_texture)))
 474     {
 475         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 476         wined3d_private_store_cleanup(&texture->private_store);
 477         heap_free(texture);
 478         wined3d_mutex_unlock();
 479         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
 480             hr = E_INVALIDARG;
 481         return hr;
 482     }
 483
 484     if (desc->MipLevels == 1 && desc->ArraySize == 1)
 485     {
 486         IWineDXGIDevice *wine_device;
 487
 488         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
 489                 (void **)&wine_device)))
 490         {
 491             ERR("Device should implement IWineDXGIDevice.\n");
 492             wined3d_texture_decref(texture->wined3d_texture);
 493             wined3d_mutex_unlock();
 494             return E_FAIL;
 495         }
 496
 497         hr = IWineDXGIDevice_create_surface(wine_device, texture->wined3d_texture, 0, NULL,
 498                 (IUnknown *)&texture->ID3D10Texture1D_iface, (void **)&texture->dxgi_surface);
 499         IWineDXGIDevice_Release(wine_device);
 500         if (FAILED(hr))
 501         {
 502             ERR("Failed to create DXGI surface, returning %#.x\n", hr);
 503             texture->dxgi_surface = NULL;
 504             wined3d_texture_decref(texture->wined3d_texture);
 505             wined3d_mutex_unlock();
 506             return hr;
 507         }
 508     }
 509     wined3d_mutex_unlock();
 510
 511     ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
 512
 513     TRACE("Created texture %p.\n", texture);
 514     *out = texture;
 515
 516     return S_OK;
 517 }
 518
 519 /* ID3D11Texture2D methods */
 520
 521 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_QueryInterface(ID3D11Texture2D *iface, REFIID riid, void **object)
 522 {
 523     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 524
 525     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 526
 527     if (IsEqualGUID(riid, &IID_ID3D11Texture2D)
 528             || IsEqualGUID(riid, &IID_ID3D11Resource)
 529             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 530             || IsEqualGUID(riid, &IID_IUnknown))
 531     {
 532         *object = &texture->ID3D11Texture2D_iface;
 533         IUnknown_AddRef((IUnknown *)*object);
 534         return S_OK;
 535     }
 536     else if (IsEqualGUID(riid, &IID_ID3D10Texture2D)
 537             || IsEqualGUID(riid, &IID_ID3D10Resource)
 538             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 539     {
 540         *object = &texture->ID3D10Texture2D_iface;
 541         IUnknown_AddRef((IUnknown *)*object);
 542         return S_OK;
 543     }
 544
 545     if (texture->dxgi_surface)
 546     {
 547         TRACE("Forwarding to dxgi surface.\n");
 548         return IUnknown_QueryInterface(texture->dxgi_surface, riid, object);
 549     }
 550
 551     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 552
 553     *object = NULL;
 554     return E_NOINTERFACE;
 555 }
 556
 557 static ULONG STDMETHODCALLTYPE d3d11_texture2d_AddRef(ID3D11Texture2D *iface)
 558 {
 559     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 560     ULONG refcount = InterlockedIncrement(&texture->refcount);
 561
 562     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 563
 564     if (refcount == 1)
 565     {
 566         ID3D11Device2_AddRef(texture->device);
 567         wined3d_mutex_lock();
 568         wined3d_texture_incref(texture->wined3d_texture);
 569         wined3d_mutex_unlock();
 570     }
 571
 572     return refcount;
 573 }
 574
 575 static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface)
 576 {
 577     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 578     ULONG refcount = InterlockedDecrement(&texture->refcount);
 579
 580     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 581
 582     if (!refcount)
 583     {
 584         ID3D11Device2 *device = texture->device;
 585
 586         wined3d_mutex_lock();
 587         wined3d_texture_decref(texture->wined3d_texture);
 588         wined3d_mutex_unlock();
 589         /* Release the device last, it may cause the wined3d device to be
 590          * destroyed. */
 591         ID3D11Device2_Release(device);
 592     }
 593
 594     return refcount;
 595 }
 596
 597 static void STDMETHODCALLTYPE d3d11_texture2d_GetDevice(ID3D11Texture2D *iface, ID3D11Device **device)
 598 {
 599     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 600
 601     TRACE("iface %p, device %p.\n", iface, device);
 602
 603     *device = (ID3D11Device *)texture->device;
 604     ID3D11Device_AddRef(*device);
 605 }
 606
 607 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_GetPrivateData(ID3D11Texture2D *iface,
 608         REFGUID guid, UINT *data_size, void *data)
 609 {
 610     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 611     IDXGISurface *dxgi_surface;
 612     HRESULT hr;
 613
 614     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 615
 616     if (texture->dxgi_surface
 617             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 618     {
 619         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 620         IDXGISurface_Release(dxgi_surface);
 621         return hr;
 622     }
 623
 624     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 625 }
 626
 627 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateData(ID3D11Texture2D *iface,
 628         REFGUID guid, UINT data_size, const void *data)
 629 {
 630     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 631     IDXGISurface *dxgi_surface;
 632     HRESULT hr;
 633
 634     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 635
 636     if (texture->dxgi_surface
 637             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 638     {
 639         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 640         IDXGISurface_Release(dxgi_surface);
 641         return hr;
 642     }
 643
 644     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 645 }
 646
 647 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateDataInterface(ID3D11Texture2D *iface,
 648         REFGUID guid, const IUnknown *data)
 649 {
 650     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 651     IDXGISurface *dxgi_surface;
 652     HRESULT hr;
 653
 654     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 655
 656     if (texture->dxgi_surface
 657             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 658     {
 659         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 660         IDXGISurface_Release(dxgi_surface);
 661         return hr;
 662     }
 663
 664     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 665 }
 666
 667 static void STDMETHODCALLTYPE d3d11_texture2d_GetType(ID3D11Texture2D *iface,
 668         D3D11_RESOURCE_DIMENSION *resource_dimension)
 669 {
 670     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 671
 672     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D;
 673 }
 674
 675 static void STDMETHODCALLTYPE d3d11_texture2d_SetEvictionPriority(ID3D11Texture2D *iface, UINT eviction_priority)
 676 {
 677     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 678 }
 679
 680 static UINT STDMETHODCALLTYPE d3d11_texture2d_GetEvictionPriority(ID3D11Texture2D *iface)
 681 {
 682     FIXME("iface %p stub!\n", iface);
 683
 684     return 0;
 685 }
 686
 687 static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc)
 688 {
 689     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 690     struct wined3d_resource_desc wined3d_desc;
 691
 692     TRACE("iface %p, desc %p.\n", iface, desc);
 693
 694     *desc = texture->desc;
 695
 696     wined3d_mutex_lock();
 697     wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);
 698     wined3d_mutex_unlock();
 699
 700     /* FIXME: Resizing swapchain buffers can cause these to change. We'd like
 701      * to get everything from wined3d, but e.g. bind flags don't exist as such
 702      * there (yet). */
 703     desc->Width = wined3d_desc.width;
 704     desc->Height = wined3d_desc.height;
 705     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);
 706     desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE
 707         ? 1 : wined3d_desc.multisample_type;
 708     desc->SampleDesc.Quality = wined3d_desc.multisample_quality;
 709 }
 710
 711 static const struct ID3D11Texture2DVtbl d3d11_texture2d_vtbl =
 712 {
 713     /* IUnknown methods */
 714     d3d11_texture2d_QueryInterface,
 715     d3d11_texture2d_AddRef,
 716     d3d11_texture2d_Release,
 717     /* ID3D11DeviceChild methods */
 718     d3d11_texture2d_GetDevice,
 719     d3d11_texture2d_GetPrivateData,
 720     d3d11_texture2d_SetPrivateData,
 721     d3d11_texture2d_SetPrivateDataInterface,
 722     /* ID3D11Resource methods */
 723     d3d11_texture2d_GetType,
 724     d3d11_texture2d_SetEvictionPriority,
 725     d3d11_texture2d_GetEvictionPriority,
 726     /* ID3D11Texture2D methods */
 727     d3d11_texture2d_GetDesc,
 728 };
 729
 730 struct d3d_texture2d *unsafe_impl_from_ID3D11Texture2D(ID3D11Texture2D *iface)
 731 {
 732     if (!iface)
 733         return NULL;
 734     assert(iface->lpVtbl == &d3d11_texture2d_vtbl);
 735     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D11Texture2D_iface);
 736 }
 737
 738 /* IUnknown methods */
 739
 740 static inline struct d3d_texture2d *impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 741 {
 742     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 743 }
 744
 745 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_QueryInterface(ID3D10Texture2D *iface, REFIID riid, void **object)
 746 {
 747     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 748
 749     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 750
 751     return d3d11_texture2d_QueryInterface(&texture->ID3D11Texture2D_iface, riid, object);
 752 }
 753
 754 static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
 755 {
 756     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 757
 758     TRACE("iface %p.\n", iface);
 759
 760     return d3d11_texture2d_AddRef(&texture->ID3D11Texture2D_iface);
 761 }
 762
 763 static void STDMETHODCALLTYPE d3d_texture2d_wined3d_object_released(void *parent)
 764 {
 765     struct d3d_texture2d *texture = parent;
 766
 767     if (texture->dxgi_surface) IUnknown_Release(texture->dxgi_surface);
 768     wined3d_private_store_cleanup(&texture->private_store);
 769     heap_free(texture);
 770 }
 771
 772 static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
 773 {
 774     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 775
 776     TRACE("iface %p.\n", iface);
 777
 778     return d3d11_texture2d_Release(&texture->ID3D11Texture2D_iface);
 779 }
 780
 781 /* ID3D10DeviceChild methods */
 782
 783 static void STDMETHODCALLTYPE d3d10_texture2d_GetDevice(ID3D10Texture2D *iface, ID3D10Device **device)
 784 {
 785     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 786
 787     TRACE("iface %p, device %p.\n", iface, device);
 788
 789     ID3D11Device2_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 790 }
 791
 792 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_GetPrivateData(ID3D10Texture2D *iface,
 793         REFGUID guid, UINT *data_size, void *data)
 794 {
 795     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 796
 797     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 798
 799     return d3d11_texture2d_GetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 800 }
 801
 802 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateData(ID3D10Texture2D *iface,
 803         REFGUID guid, UINT data_size, const void *data)
 804 {
 805     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 806
 807     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 808
 809     return d3d11_texture2d_SetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 810 }
 811
 812 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateDataInterface(ID3D10Texture2D *iface,
 813         REFGUID guid, const IUnknown *data)
 814 {
 815     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 816
 817     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 818
 819     return d3d11_texture2d_SetPrivateDataInterface(&texture->ID3D11Texture2D_iface, guid, data);
 820 }
 821
 822 /* ID3D10Resource methods */
 823
 824 static void STDMETHODCALLTYPE d3d10_texture2d_GetType(ID3D10Texture2D *iface,
 825         D3D10_RESOURCE_DIMENSION *resource_dimension)
 826 {
 827     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 828
 829     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE2D;
 830 }
 831
 832 static void STDMETHODCALLTYPE d3d10_texture2d_SetEvictionPriority(ID3D10Texture2D *iface, UINT eviction_priority)
 833 {
 834     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 835 }
 836
 837 static UINT STDMETHODCALLTYPE d3d10_texture2d_GetEvictionPriority(ID3D10Texture2D *iface)
 838 {
 839     FIXME("iface %p stub!\n", iface);
 840
 841     return 0;
 842 }
 843
 844 /* ID3D10Texture2D methods */
 845
 846 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,
 847         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture)
 848 {
 849     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 850     struct wined3d_map_desc wined3d_map_desc;
 851     HRESULT hr;
 852
 853     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 854             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 855
 856     if (map_flags)
 857         FIXME("Ignoring map_flags %#x.\n", map_flags);
 858
 859     wined3d_mutex_lock();
 860     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
 861             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 862     {
 863         mapped_texture->pData = wined3d_map_desc.data;
 864         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 865     }
 866     wined3d_mutex_unlock();
 867
 868     return hr;
 869 }
 870
 871 static void STDMETHODCALLTYPE d3d10_texture2d_Unmap(ID3D10Texture2D *iface, UINT sub_resource_idx)
 872 {
 873     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 874
 875     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 876
 877     wined3d_mutex_lock();
 878     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
 879     wined3d_mutex_unlock();
 880 }
 881
 882 static void STDMETHODCALLTYPE d3d10_texture2d_GetDesc(ID3D10Texture2D *iface, D3D10_TEXTURE2D_DESC *desc)
 883 {
 884     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 885     D3D11_TEXTURE2D_DESC d3d11_desc;
 886
 887     TRACE("iface %p, desc %p\n", iface, desc);
 888
 889     d3d11_texture2d_GetDesc(&texture->ID3D11Texture2D_iface, &d3d11_desc);
 890
 891     desc->Width = d3d11_desc.Width;
 892     desc->Height = d3d11_desc.Height;
 893     desc->MipLevels = d3d11_desc.MipLevels;
 894     desc->ArraySize = d3d11_desc.ArraySize;
 895     desc->Format = d3d11_desc.Format;
 896     desc->SampleDesc = d3d11_desc.SampleDesc;
 897     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
 898     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
 899     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
 900     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
 901 }
 902
 903 static const struct ID3D10Texture2DVtbl d3d10_texture2d_vtbl =
 904 {
 905     /* IUnknown methods */
 906     d3d10_texture2d_QueryInterface,
 907     d3d10_texture2d_AddRef,
 908     d3d10_texture2d_Release,
 909     /* ID3D10DeviceChild methods */
 910     d3d10_texture2d_GetDevice,
 911     d3d10_texture2d_GetPrivateData,
 912     d3d10_texture2d_SetPrivateData,
 913     d3d10_texture2d_SetPrivateDataInterface,
 914     /* ID3D10Resource methods */
 915     d3d10_texture2d_GetType,
 916     d3d10_texture2d_SetEvictionPriority,
 917     d3d10_texture2d_GetEvictionPriority,
 918     /* ID3D10Texture2D methods */
 919     d3d10_texture2d_Map,
 920     d3d10_texture2d_Unmap,
 921     d3d10_texture2d_GetDesc,
 922 };
 923
 924 struct d3d_texture2d *unsafe_impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 925 {
 926     if (!iface)
 927         return NULL;
 928     assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
 929     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 930 }
 931
 932 static const struct wined3d_parent_ops d3d_texture2d_wined3d_parent_ops =
 933 {
 934     d3d_texture2d_wined3d_object_released,
 935 };
 936
 937 static BOOL is_gdi_compatible_texture(const D3D11_TEXTURE2D_DESC *desc)
 938 {
 939     if (!(desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM
 940             || desc->Format == DXGI_FORMAT_B8G8R8A8_TYPELESS
 941             || desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB))
 942         return FALSE;
 943
 944     if (desc->Usage != D3D11_USAGE_DEFAULT)
 945         return FALSE;
 946
 947     return TRUE;
 948 }
 949
 950 static BOOL validate_texture2d_desc(const D3D11_TEXTURE2D_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 951 {
 952     if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_TEXTURE2D,
 953             desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
 954         return FALSE;
 955
 956     if (desc->MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE
 957             && desc->ArraySize < 6)
 958     {
 959         WARN("Invalid array size %u for cube texture.\n", desc->ArraySize);
 960         return FALSE;
 961     }
 962
 963     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE
 964             && !is_gdi_compatible_texture(desc))
 965     {
 966         WARN("Incompatible description used to create GDI compatible texture.\n");
 967         return FALSE;
 968     }
 969
 970     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
 971             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
 972     {
 973         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET and "
 974                 "D3D11_BIND_SHADER_RESOURCE.\n");
 975         return FALSE;
 976     }
 977
 978     return TRUE;
 979 }
 980
 981 HRESULT d3d_texture2d_create(struct d3d_device *device, const D3D11_TEXTURE2D_DESC *desc,
 982         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture2d **out)
 983 {
 984     struct wined3d_resource_desc wined3d_desc;
 985     struct d3d_texture2d *texture;
 986     unsigned int levels;
 987     DWORD flags = 0;
 988     HRESULT hr;
 989
 990     if (!validate_texture2d_desc(desc, device->state->feature_level))
 991     {
 992         WARN("Failed to validate texture desc.\n");
 993         return E_INVALIDARG;
 994     }
 995
 996     if (!(texture = heap_alloc_zero(sizeof(*texture))))
 997         return E_OUTOFMEMORY;
 998
 999     texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
1000     texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
1001     texture->refcount = 1;
1002     wined3d_mutex_lock();
1003     wined3d_private_store_init(&texture->private_store);
1004     texture->desc = *desc;
1005
1006     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1007     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
1008     wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
1009     wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
1010     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->Usage);
1011     wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(desc->BindFlags, desc->MiscFlags);
1012     wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
1013             desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
1014     wined3d_desc.width = desc->Width;
1015     wined3d_desc.height = desc->Height;
1016     wined3d_desc.depth = 1;
1017     wined3d_desc.size = 0;
1018
1019     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
1020
1021     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
1022         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
1023     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
1024         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
1025
1026     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
1027             desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
1028             texture, &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
1029     {
1030         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1031         wined3d_private_store_cleanup(&texture->private_store);
1032         heap_free(texture);
1033         wined3d_mutex_unlock();
1034         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
1035             hr = E_INVALIDARG;
1036         return hr;
1037     }
1038     texture->desc.MipLevels = levels;
1039
1040     if (desc->MipLevels == 1 && desc->ArraySize == 1)
1041     {
1042         IWineDXGIDevice *wine_device;
1043
1044         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
1045                 (void **)&wine_device)))
1046         {
1047             ERR("Device should implement IWineDXGIDevice.\n");
1048             wined3d_texture_decref(texture->wined3d_texture);
1049             wined3d_mutex_unlock();
1050             return E_FAIL;
1051         }
1052
1053         hr = IWineDXGIDevice_create_surface(wine_device, texture->wined3d_texture, 0, NULL,
1054                 (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
1055         IWineDXGIDevice_Release(wine_device);
1056         if (FAILED(hr))
1057         {
1058             ERR("Failed to create DXGI surface, returning %#.x\n", hr);
1059             texture->dxgi_surface = NULL;
1060             wined3d_texture_decref(texture->wined3d_texture);
1061             wined3d_mutex_unlock();
1062             return hr;
1063         }
1064     }
1065     wined3d_mutex_unlock();
1066
1067     ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
1068
1069     TRACE("Created texture %p.\n", texture);
1070     *out = texture;
1071
1072     return S_OK;
1073 }
1074
1075 /* ID3D11Texture3D methods */
1076
1077 static inline struct d3d_texture3d *impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
1078 {
1079     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D11Texture3D_iface);
1080 }
1081
1082 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_QueryInterface(ID3D11Texture3D *iface, REFIID riid, void **object)
1083 {
1084     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1085
1086     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1087
1088     if (IsEqualGUID(riid, &IID_ID3D11Texture3D)
1089             || IsEqualGUID(riid, &IID_ID3D11Resource)
1090             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1091             || IsEqualGUID(riid, &IID_IUnknown))
1092     {
1093         IUnknown_AddRef(iface);
1094         *object = iface;
1095         return S_OK;
1096     }
1097     else if (IsEqualGUID(riid, &IID_ID3D10Texture3D)
1098             || IsEqualGUID(riid, &IID_ID3D10Resource)
1099             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1100     {
1101         IUnknown_AddRef(iface);
1102         *object = &texture->ID3D10Texture3D_iface;
1103         return S_OK;
1104     }
1105
1106     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1107
1108     *object = NULL;
1109     return E_NOINTERFACE;
1110 }
1111
1112 static ULONG STDMETHODCALLTYPE d3d11_texture3d_AddRef(ID3D11Texture3D *iface)
1113 {
1114     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1115     ULONG refcount = InterlockedIncrement(&texture->refcount);
1116
1117     TRACE("%p increasing refcount to %u.\n", texture, refcount);
1118
1119     if (refcount == 1)
1120     {
1121         ID3D11Device2_AddRef(texture->device);
1122         wined3d_mutex_lock();
1123         wined3d_texture_incref(texture->wined3d_texture);
1124         wined3d_mutex_unlock();
1125     }
1126
1127     return refcount;
1128 }
1129
1130 static void STDMETHODCALLTYPE d3d_texture3d_wined3d_object_released(void *parent)
1131 {
1132     struct d3d_texture3d *texture = parent;
1133
1134     wined3d_private_store_cleanup(&texture->private_store);
1135     heap_free(parent);
1136 }
1137
1138 static ULONG STDMETHODCALLTYPE d3d11_texture3d_Release(ID3D11Texture3D *iface)
1139 {
1140     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1141     ULONG refcount = InterlockedDecrement(&texture->refcount);
1142
1143     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
1144
1145     if (!refcount)
1146     {
1147         ID3D11Device2 *device = texture->device;
1148
1149         wined3d_mutex_lock();
1150         wined3d_texture_decref(texture->wined3d_texture);
1151         wined3d_mutex_unlock();
1152         /* Release the device last, it may cause the wined3d device to be
1153          * destroyed. */
1154         ID3D11Device2_Release(device);
1155     }
1156
1157     return refcount;
1158 }
1159
1160 static void STDMETHODCALLTYPE d3d11_texture3d_GetDevice(ID3D11Texture3D *iface, ID3D11Device **device)
1161 {
1162     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1163
1164     TRACE("iface %p, device %p.\n", iface, device);
1165
1166     *device = (ID3D11Device *)texture->device;
1167     ID3D11Device_AddRef(*device);
1168 }
1169
1170 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_GetPrivateData(ID3D11Texture3D *iface,
1171         REFGUID guid, UINT *data_size, void *data)
1172 {
1173     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1174
1175     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1176
1177     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
1178 }
1179
1180 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateData(ID3D11Texture3D *iface,
1181         REFGUID guid, UINT data_size, const void *data)
1182 {
1183     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1184
1185     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1186
1187     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
1188 }
1189
1190 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateDataInterface(ID3D11Texture3D *iface,
1191         REFGUID guid, const IUnknown *data)
1192 {
1193     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1194
1195     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1196
1197     return d3d_set_private_data_interface(&texture->private_store, guid, data);
1198 }
1199
1200 static void STDMETHODCALLTYPE d3d11_texture3d_GetType(ID3D11Texture3D *iface,
1201         D3D11_RESOURCE_DIMENSION *resource_dimension)
1202 {
1203     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
1204
1205     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE3D;
1206 }
1207
1208 static void STDMETHODCALLTYPE d3d11_texture3d_SetEvictionPriority(ID3D11Texture3D *iface, UINT eviction_priority)
1209 {
1210     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
1211 }
1212
1213 static UINT STDMETHODCALLTYPE d3d11_texture3d_GetEvictionPriority(ID3D11Texture3D *iface)
1214 {
1215     FIXME("iface %p stub!\n", iface);
1216
1217     return 0;
1218 }
1219
1220 static void STDMETHODCALLTYPE d3d11_texture3d_GetDesc(ID3D11Texture3D *iface, D3D11_TEXTURE3D_DESC *desc)
1221 {
1222     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1223
1224     TRACE("iface %p, desc %p.\n", iface, desc);
1225
1226     *desc = texture->desc;
1227 }
1228
1229 static const struct ID3D11Texture3DVtbl d3d11_texture3d_vtbl =
1230 {
1231     /* IUnknown methods */
1232     d3d11_texture3d_QueryInterface,
1233     d3d11_texture3d_AddRef,
1234     d3d11_texture3d_Release,
1235     /* ID3D11DeviceChild methods */
1236     d3d11_texture3d_GetDevice,
1237     d3d11_texture3d_GetPrivateData,
1238     d3d11_texture3d_SetPrivateData,
1239     d3d11_texture3d_SetPrivateDataInterface,
1240     /* ID3D11Resource methods */
1241     d3d11_texture3d_GetType,
1242     d3d11_texture3d_SetEvictionPriority,
1243     d3d11_texture3d_GetEvictionPriority,
1244     /* ID3D11Texture3D methods */
1245     d3d11_texture3d_GetDesc,
1246 };
1247
1248 /* ID3D10Texture3D methods */
1249
1250 static inline struct d3d_texture3d *impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
1251 {
1252     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
1253 }
1254
1255 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_QueryInterface(ID3D10Texture3D *iface, REFIID riid, void **object)
1256 {
1257     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1258
1259     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1260
1261     return d3d11_texture3d_QueryInterface(&texture->ID3D11Texture3D_iface, riid, object);
1262 }
1263
1264 static ULONG STDMETHODCALLTYPE d3d10_texture3d_AddRef(ID3D10Texture3D *iface)
1265 {
1266     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1267
1268     TRACE("iface %p.\n", iface);
1269
1270     return d3d11_texture3d_AddRef(&texture->ID3D11Texture3D_iface);
1271 }
1272
1273 static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
1274 {
1275     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1276
1277     TRACE("iface %p.\n", iface);
1278
1279     return d3d11_texture3d_Release(&texture->ID3D11Texture3D_iface);
1280 }
1281
1282 static void STDMETHODCALLTYPE d3d10_texture3d_GetDevice(ID3D10Texture3D *iface, ID3D10Device **device)
1283 {
1284     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1285
1286     TRACE("iface %p, device %p.\n", iface, device);
1287
1288     ID3D11Device2_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
1289 }
1290
1291 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_GetPrivateData(ID3D10Texture3D *iface,
1292         REFGUID guid, UINT *data_size, void *data)
1293 {
1294     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1295
1296     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1297             iface, debugstr_guid(guid), data_size, data);
1298
1299     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
1300 }
1301
1302 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateData(ID3D10Texture3D *iface,
1303         REFGUID guid, UINT data_size, const void *data)
1304 {
1305     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1306
1307     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1308             iface, debugstr_guid(guid), data_size, data);
1309
1310     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
1311 }
1312
1313 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateDataInterface(ID3D10Texture3D *iface,
1314         REFGUID guid, const IUnknown *data)
1315 {
1316     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1317
1318     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1319
1320     return d3d_set_private_data_interface(&texture->private_store, guid, data);
1321 }
1322
1323 static void STDMETHODCALLTYPE d3d10_texture3d_GetType(ID3D10Texture3D *iface,
1324         D3D10_RESOURCE_DIMENSION *resource_dimension)
1325 {
1326     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
1327
1328     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE3D;
1329 }
1330
1331 static void STDMETHODCALLTYPE d3d10_texture3d_SetEvictionPriority(ID3D10Texture3D *iface, UINT eviction_priority)
1332 {
1333     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
1334 }
1335
1336 static UINT STDMETHODCALLTYPE d3d10_texture3d_GetEvictionPriority(ID3D10Texture3D *iface)
1337 {
1338     FIXME("iface %p stub!\n", iface);
1339
1340     return 0;
1341 }
1342
1343 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
1344         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
1345 {
1346     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1347     struct wined3d_map_desc wined3d_map_desc;
1348     HRESULT hr;
1349
1350     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
1351             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
1352
1353     if (map_flags)
1354         FIXME("Ignoring map_flags %#x.\n", map_flags);
1355
1356     wined3d_mutex_lock();
1357     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
1358             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
1359     {
1360         mapped_texture->pData = wined3d_map_desc.data;
1361         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
1362         mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
1363     }
1364     wined3d_mutex_unlock();
1365
1366     return hr;
1367 }
1368
1369 static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx)
1370 {
1371     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1372
1373     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
1374
1375     wined3d_mutex_lock();
1376     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
1377     wined3d_mutex_unlock();
1378 }
1379
1380 static void STDMETHODCALLTYPE d3d10_texture3d_GetDesc(ID3D10Texture3D *iface, D3D10_TEXTURE3D_DESC *desc)
1381 {
1382     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1383     D3D11_TEXTURE3D_DESC d3d11_desc;
1384
1385     TRACE("iface %p, desc %p.\n", iface, desc);
1386
1387     d3d11_texture3d_GetDesc(&texture->ID3D11Texture3D_iface, &d3d11_desc);
1388
1389     desc->Width = d3d11_desc.Width;
1390     desc->Height = d3d11_desc.Height;
1391     desc->Depth = d3d11_desc.Depth;
1392     desc->MipLevels = d3d11_desc.MipLevels;
1393     desc->Format = d3d11_desc.Format;
1394     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
1395     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
1396     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
1397     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
1398 }
1399
1400 static const struct ID3D10Texture3DVtbl d3d10_texture3d_vtbl =
1401 {
1402     /* IUnknown methods */
1403     d3d10_texture3d_QueryInterface,
1404     d3d10_texture3d_AddRef,
1405     d3d10_texture3d_Release,
1406     /* ID3D10DeviceChild methods */
1407     d3d10_texture3d_GetDevice,
1408     d3d10_texture3d_GetPrivateData,
1409     d3d10_texture3d_SetPrivateData,
1410     d3d10_texture3d_SetPrivateDataInterface,
1411     /* ID3D10Resource methods */
1412     d3d10_texture3d_GetType,
1413     d3d10_texture3d_SetEvictionPriority,
1414     d3d10_texture3d_GetEvictionPriority,
1415     /* ID3D10Texture3D methods */
1416     d3d10_texture3d_Map,
1417     d3d10_texture3d_Unmap,
1418     d3d10_texture3d_GetDesc,
1419 };
1420
1421 struct d3d_texture3d *unsafe_impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
1422 {
1423     if (!iface)
1424         return NULL;
1425     assert(iface->lpVtbl == &d3d10_texture3d_vtbl);
1426     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
1427 }
1428
1429 struct d3d_texture3d *unsafe_impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
1430 {
1431     if (!iface)
1432         return NULL;
1433     assert(iface->lpVtbl == &d3d11_texture3d_vtbl);
1434     return impl_from_ID3D11Texture3D(iface);
1435 }
1436
1437 static const struct wined3d_parent_ops d3d_texture3d_wined3d_parent_ops =
1438 {
1439     d3d_texture3d_wined3d_object_released,
1440 };
1441
1442 static HRESULT d3d_texture3d_init(struct d3d_texture3d *texture, struct d3d_device *device,
1443         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data)
1444 {
1445     struct wined3d_resource_desc wined3d_desc;
1446     unsigned int levels;
1447     DWORD flags = 0;
1448     HRESULT hr;
1449
1450     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
1451             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
1452     {
1453         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET "
1454                 "and D3D11_BIND_SHADER_RESOURCE.\n");
1455         return E_INVALIDARG;
1456     }
1457
1458     texture->ID3D11Texture3D_iface.lpVtbl = &d3d11_texture3d_vtbl;
1459     texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
1460     texture->refcount = 1;
1461     wined3d_mutex_lock();
1462     wined3d_private_store_init(&texture->private_store);
1463     texture->desc = *desc;
1464
1465     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
1466     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
1467     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1468     wined3d_desc.multisample_quality = 0;
1469     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->Usage);
1470     wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(desc->BindFlags, desc->MiscFlags);
1471     wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
1472             desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
1473     wined3d_desc.width = desc->Width;
1474     wined3d_desc.height = desc->Height;
1475     wined3d_desc.depth = desc->Depth;
1476     wined3d_desc.size = 0;
1477
1478     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(max(desc->Width, desc->Height), desc->Depth)) + 1;
1479
1480     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
1481         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
1482
1483     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
1484             1, levels, flags, (struct wined3d_sub_resource_data *)data, texture,
1485             &d3d_texture3d_wined3d_parent_ops, &texture->wined3d_texture)))
1486     {
1487         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1488         wined3d_private_store_cleanup(&texture->private_store);
1489         wined3d_mutex_unlock();
1490         if (hr == WINED3DERR_INVALIDCALL)
1491             hr = E_INVALIDARG;
1492         return hr;
1493     }
1494     wined3d_mutex_unlock();
1495     texture->desc.MipLevels = levels;
1496
1497     ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
1498
1499     return S_OK;
1500 }
1501
1502 HRESULT d3d_texture3d_create(struct d3d_device *device, const D3D11_TEXTURE3D_DESC *desc,
1503         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture3d **texture)
1504 {
1505     struct d3d_texture3d *object;
1506     HRESULT hr;
1507
1508     if (!(object = heap_alloc_zero(sizeof(*object))))
1509         return E_OUTOFMEMORY;
1510
1511     if (FAILED(hr = d3d_texture3d_init(object, device, desc, data)))
1512     {
1513         WARN("Failed to initialize texture, hr %#x.\n", hr);
1514         heap_free(object);
1515         return hr;
1516     }
1517
1518     TRACE("Created texture %p.\n", object);
1519     *texture = object;
1520
1521     return S_OK;
1522 }