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