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->BindFlags, desc->Usage);
 460     wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
 461             desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
 462     wined3d_desc.width = desc->Width;
 463     wined3d_desc.height = 1;
 464     wined3d_desc.depth = 1;
 465     wined3d_desc.size = 0;
 466
 467     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
 468         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 469     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
 470         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 471
 472     wined3d_mutex_lock();
 473     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 474             desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
 475             texture, &d3d_texture1d_wined3d_parent_ops, &texture->wined3d_texture)))
 476     {
 477         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 478         wined3d_private_store_cleanup(&texture->private_store);
 479         heap_free(texture);
 480         wined3d_mutex_unlock();
 481         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
 482             hr = E_INVALIDARG;
 483         return hr;
 484     }
 485
 486     if (desc->MipLevels == 1 && desc->ArraySize == 1)
 487     {
 488         IWineDXGIDevice *wine_device;
 489
 490         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
 491                 (void **)&wine_device)))
 492         {
 493             ERR("Device should implement IWineDXGIDevice.\n");
 494             wined3d_texture_decref(texture->wined3d_texture);
 495             wined3d_mutex_unlock();
 496             return E_FAIL;
 497         }
 498
 499         hr = IWineDXGIDevice_create_surface(wine_device, texture->wined3d_texture, 0, NULL,
 500                 (IUnknown *)&texture->ID3D10Texture1D_iface, (void **)&texture->dxgi_surface);
 501         IWineDXGIDevice_Release(wine_device);
 502         if (FAILED(hr))
 503         {
 504             ERR("Failed to create DXGI surface, returning %#.x\n", hr);
 505             texture->dxgi_surface = NULL;
 506             wined3d_texture_decref(texture->wined3d_texture);
 507             wined3d_mutex_unlock();
 508             return hr;
 509         }
 510     }
 511     wined3d_mutex_unlock();
 512
 513     ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
 514
 515     TRACE("Created texture %p.\n", texture);
 516     *out = texture;
 517
 518     return S_OK;
 519 }
 520
 521 /* ID3D11Texture2D methods */
 522
 523 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_QueryInterface(ID3D11Texture2D *iface, REFIID riid, void **object)
 524 {
 525     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 526
 527     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 528
 529     if (IsEqualGUID(riid, &IID_ID3D11Texture2D)
 530             || IsEqualGUID(riid, &IID_ID3D11Resource)
 531             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 532             || IsEqualGUID(riid, &IID_IUnknown))
 533     {
 534         *object = &texture->ID3D11Texture2D_iface;
 535         IUnknown_AddRef((IUnknown *)*object);
 536         return S_OK;
 537     }
 538     else if (IsEqualGUID(riid, &IID_ID3D10Texture2D)
 539             || IsEqualGUID(riid, &IID_ID3D10Resource)
 540             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 541     {
 542         *object = &texture->ID3D10Texture2D_iface;
 543         IUnknown_AddRef((IUnknown *)*object);
 544         return S_OK;
 545     }
 546
 547     if (texture->dxgi_surface)
 548     {
 549         TRACE("Forwarding to dxgi surface.\n");
 550         return IUnknown_QueryInterface(texture->dxgi_surface, riid, object);
 551     }
 552
 553     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 554
 555     *object = NULL;
 556     return E_NOINTERFACE;
 557 }
 558
 559 static ULONG STDMETHODCALLTYPE d3d11_texture2d_AddRef(ID3D11Texture2D *iface)
 560 {
 561     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 562     ULONG refcount = InterlockedIncrement(&texture->refcount);
 563
 564     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 565
 566     if (refcount == 1)
 567     {
 568         ID3D11Device2_AddRef(texture->device);
 569         wined3d_mutex_lock();
 570         wined3d_texture_incref(texture->wined3d_texture);
 571         wined3d_mutex_unlock();
 572     }
 573
 574     return refcount;
 575 }
 576
 577 static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface)
 578 {
 579     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 580     ULONG refcount = InterlockedDecrement(&texture->refcount);
 581
 582     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 583
 584     if (!refcount)
 585     {
 586         ID3D11Device2 *device = texture->device;
 587
 588         wined3d_mutex_lock();
 589         wined3d_texture_decref(texture->wined3d_texture);
 590         wined3d_mutex_unlock();
 591         /* Release the device last, it may cause the wined3d device to be
 592          * destroyed. */
 593         ID3D11Device2_Release(device);
 594     }
 595
 596     return refcount;
 597 }
 598
 599 static void STDMETHODCALLTYPE d3d11_texture2d_GetDevice(ID3D11Texture2D *iface, ID3D11Device **device)
 600 {
 601     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 602
 603     TRACE("iface %p, device %p.\n", iface, device);
 604
 605     *device = (ID3D11Device *)texture->device;
 606     ID3D11Device_AddRef(*device);
 607 }
 608
 609 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_GetPrivateData(ID3D11Texture2D *iface,
 610         REFGUID guid, UINT *data_size, void *data)
 611 {
 612     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 613     IDXGISurface *dxgi_surface;
 614     HRESULT hr;
 615
 616     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 617
 618     if (texture->dxgi_surface
 619             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 620     {
 621         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 622         IDXGISurface_Release(dxgi_surface);
 623         return hr;
 624     }
 625
 626     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 627 }
 628
 629 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateData(ID3D11Texture2D *iface,
 630         REFGUID guid, UINT data_size, const void *data)
 631 {
 632     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 633     IDXGISurface *dxgi_surface;
 634     HRESULT hr;
 635
 636     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 637
 638     if (texture->dxgi_surface
 639             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 640     {
 641         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 642         IDXGISurface_Release(dxgi_surface);
 643         return hr;
 644     }
 645
 646     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 647 }
 648
 649 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateDataInterface(ID3D11Texture2D *iface,
 650         REFGUID guid, const IUnknown *data)
 651 {
 652     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 653     IDXGISurface *dxgi_surface;
 654     HRESULT hr;
 655
 656     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 657
 658     if (texture->dxgi_surface
 659             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 660     {
 661         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 662         IDXGISurface_Release(dxgi_surface);
 663         return hr;
 664     }
 665
 666     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 667 }
 668
 669 static void STDMETHODCALLTYPE d3d11_texture2d_GetType(ID3D11Texture2D *iface,
 670         D3D11_RESOURCE_DIMENSION *resource_dimension)
 671 {
 672     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 673
 674     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D;
 675 }
 676
 677 static void STDMETHODCALLTYPE d3d11_texture2d_SetEvictionPriority(ID3D11Texture2D *iface, UINT eviction_priority)
 678 {
 679     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 680 }
 681
 682 static UINT STDMETHODCALLTYPE d3d11_texture2d_GetEvictionPriority(ID3D11Texture2D *iface)
 683 {
 684     FIXME("iface %p stub!\n", iface);
 685
 686     return 0;
 687 }
 688
 689 static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc)
 690 {
 691     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 692     struct wined3d_resource_desc wined3d_desc;
 693
 694     TRACE("iface %p, desc %p.\n", iface, desc);
 695
 696     *desc = texture->desc;
 697
 698     wined3d_mutex_lock();
 699     wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);
 700     wined3d_mutex_unlock();
 701
 702     /* FIXME: Resizing swapchain buffers can cause these to change. We'd like
 703      * to get everything from wined3d, but e.g. bind flags don't exist as such
 704      * there (yet). */
 705     desc->Width = wined3d_desc.width;
 706     desc->Height = wined3d_desc.height;
 707     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);
 708     desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE
 709         ? 1 : wined3d_desc.multisample_type;
 710     desc->SampleDesc.Quality = wined3d_desc.multisample_quality;
 711 }
 712
 713 static const struct ID3D11Texture2DVtbl d3d11_texture2d_vtbl =
 714 {
 715     /* IUnknown methods */
 716     d3d11_texture2d_QueryInterface,
 717     d3d11_texture2d_AddRef,
 718     d3d11_texture2d_Release,
 719     /* ID3D11DeviceChild methods */
 720     d3d11_texture2d_GetDevice,
 721     d3d11_texture2d_GetPrivateData,
 722     d3d11_texture2d_SetPrivateData,
 723     d3d11_texture2d_SetPrivateDataInterface,
 724     /* ID3D11Resource methods */
 725     d3d11_texture2d_GetType,
 726     d3d11_texture2d_SetEvictionPriority,
 727     d3d11_texture2d_GetEvictionPriority,
 728     /* ID3D11Texture2D methods */
 729     d3d11_texture2d_GetDesc,
 730 };
 731
 732 struct d3d_texture2d *unsafe_impl_from_ID3D11Texture2D(ID3D11Texture2D *iface)
 733 {
 734     if (!iface)
 735         return NULL;
 736     assert(iface->lpVtbl == &d3d11_texture2d_vtbl);
 737     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D11Texture2D_iface);
 738 }
 739
 740 /* IUnknown methods */
 741
 742 static inline struct d3d_texture2d *impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 743 {
 744     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 745 }
 746
 747 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_QueryInterface(ID3D10Texture2D *iface, REFIID riid, void **object)
 748 {
 749     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 750
 751     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 752
 753     return d3d11_texture2d_QueryInterface(&texture->ID3D11Texture2D_iface, riid, object);
 754 }
 755
 756 static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
 757 {
 758     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 759
 760     TRACE("iface %p.\n", iface);
 761
 762     return d3d11_texture2d_AddRef(&texture->ID3D11Texture2D_iface);
 763 }
 764
 765 static void STDMETHODCALLTYPE d3d_texture2d_wined3d_object_released(void *parent)
 766 {
 767     struct d3d_texture2d *texture = parent;
 768
 769     if (texture->dxgi_surface) IUnknown_Release(texture->dxgi_surface);
 770     wined3d_private_store_cleanup(&texture->private_store);
 771     heap_free(texture);
 772 }
 773
 774 static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
 775 {
 776     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 777
 778     TRACE("iface %p.\n", iface);
 779
 780     return d3d11_texture2d_Release(&texture->ID3D11Texture2D_iface);
 781 }
 782
 783 /* ID3D10DeviceChild methods */
 784
 785 static void STDMETHODCALLTYPE d3d10_texture2d_GetDevice(ID3D10Texture2D *iface, ID3D10Device **device)
 786 {
 787     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 788
 789     TRACE("iface %p, device %p.\n", iface, device);
 790
 791     ID3D11Device2_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 792 }
 793
 794 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_GetPrivateData(ID3D10Texture2D *iface,
 795         REFGUID guid, UINT *data_size, void *data)
 796 {
 797     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 798
 799     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 800
 801     return d3d11_texture2d_GetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 802 }
 803
 804 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateData(ID3D10Texture2D *iface,
 805         REFGUID guid, UINT data_size, const void *data)
 806 {
 807     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 808
 809     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 810
 811     return d3d11_texture2d_SetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 812 }
 813
 814 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateDataInterface(ID3D10Texture2D *iface,
 815         REFGUID guid, const IUnknown *data)
 816 {
 817     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 818
 819     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 820
 821     return d3d11_texture2d_SetPrivateDataInterface(&texture->ID3D11Texture2D_iface, guid, data);
 822 }
 823
 824 /* ID3D10Resource methods */
 825
 826 static void STDMETHODCALLTYPE d3d10_texture2d_GetType(ID3D10Texture2D *iface,
 827         D3D10_RESOURCE_DIMENSION *resource_dimension)
 828 {
 829     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 830
 831     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE2D;
 832 }
 833
 834 static void STDMETHODCALLTYPE d3d10_texture2d_SetEvictionPriority(ID3D10Texture2D *iface, UINT eviction_priority)
 835 {
 836     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 837 }
 838
 839 static UINT STDMETHODCALLTYPE d3d10_texture2d_GetEvictionPriority(ID3D10Texture2D *iface)
 840 {
 841     FIXME("iface %p stub!\n", iface);
 842
 843     return 0;
 844 }
 845
 846 /* ID3D10Texture2D methods */
 847
 848 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,
 849         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture)
 850 {
 851     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 852     struct wined3d_map_desc wined3d_map_desc;
 853     HRESULT hr;
 854
 855     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 856             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 857
 858     if (map_flags)
 859         FIXME("Ignoring map_flags %#x.\n", map_flags);
 860
 861     wined3d_mutex_lock();
 862     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
 863             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))
 864     {
 865         mapped_texture->pData = wined3d_map_desc.data;
 866         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 867     }
 868     wined3d_mutex_unlock();
 869
 870     return hr;
 871 }
 872
 873 static void STDMETHODCALLTYPE d3d10_texture2d_Unmap(ID3D10Texture2D *iface, UINT sub_resource_idx)
 874 {
 875     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 876
 877     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 878
 879     wined3d_mutex_lock();
 880     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
 881     wined3d_mutex_unlock();
 882 }
 883
 884 static void STDMETHODCALLTYPE d3d10_texture2d_GetDesc(ID3D10Texture2D *iface, D3D10_TEXTURE2D_DESC *desc)
 885 {
 886     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 887     D3D11_TEXTURE2D_DESC d3d11_desc;
 888
 889     TRACE("iface %p, desc %p\n", iface, desc);
 890
 891     d3d11_texture2d_GetDesc(&texture->ID3D11Texture2D_iface, &d3d11_desc);
 892
 893     desc->Width = d3d11_desc.Width;
 894     desc->Height = d3d11_desc.Height;
 895     desc->MipLevels = d3d11_desc.MipLevels;
 896     desc->ArraySize = d3d11_desc.ArraySize;
 897     desc->Format = d3d11_desc.Format;
 898     desc->SampleDesc = d3d11_desc.SampleDesc;
 899     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
 900     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
 901     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
 902     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
 903 }
 904
 905 static const struct ID3D10Texture2DVtbl d3d10_texture2d_vtbl =
 906 {
 907     /* IUnknown methods */
 908     d3d10_texture2d_QueryInterface,
 909     d3d10_texture2d_AddRef,
 910     d3d10_texture2d_Release,
 911     /* ID3D10DeviceChild methods */
 912     d3d10_texture2d_GetDevice,
 913     d3d10_texture2d_GetPrivateData,
 914     d3d10_texture2d_SetPrivateData,
 915     d3d10_texture2d_SetPrivateDataInterface,
 916     /* ID3D10Resource methods */
 917     d3d10_texture2d_GetType,
 918     d3d10_texture2d_SetEvictionPriority,
 919     d3d10_texture2d_GetEvictionPriority,
 920     /* ID3D10Texture2D methods */
 921     d3d10_texture2d_Map,
 922     d3d10_texture2d_Unmap,
 923     d3d10_texture2d_GetDesc,
 924 };
 925
 926 struct d3d_texture2d *unsafe_impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 927 {
 928     if (!iface)
 929         return NULL;
 930     assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
 931     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 932 }
 933
 934 static const struct wined3d_parent_ops d3d_texture2d_wined3d_parent_ops =
 935 {
 936     d3d_texture2d_wined3d_object_released,
 937 };
 938
 939 static BOOL is_gdi_compatible_texture(const D3D11_TEXTURE2D_DESC *desc)
 940 {
 941     if (!(desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM
 942             || desc->Format == DXGI_FORMAT_B8G8R8A8_TYPELESS
 943             || desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB))
 944         return FALSE;
 945
 946     if (desc->Usage != D3D11_USAGE_DEFAULT)
 947         return FALSE;
 948
 949     return TRUE;
 950 }
 951
 952 static BOOL validate_texture2d_desc(const D3D11_TEXTURE2D_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 953 {
 954     if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_TEXTURE2D,
 955             desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
 956         return FALSE;
 957
 958     if (desc->MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE
 959             && desc->ArraySize < 6)
 960     {
 961         WARN("Invalid array size %u for cube texture.\n", desc->ArraySize);
 962         return FALSE;
 963     }
 964
 965     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE
 966             && !is_gdi_compatible_texture(desc))
 967     {
 968         WARN("Incompatible description used to create GDI compatible texture.\n");
 969         return FALSE;
 970     }
 971
 972     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
 973             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
 974     {
 975         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET and "
 976                 "D3D11_BIND_SHADER_RESOURCE.\n");
 977         return FALSE;
 978     }
 979
 980     return TRUE;
 981 }
 982
 983 HRESULT d3d_texture2d_create(struct d3d_device *device, const D3D11_TEXTURE2D_DESC *desc,
 984         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture2d **out)
 985 {
 986     struct wined3d_resource_desc wined3d_desc;
 987     struct d3d_texture2d *texture;
 988     unsigned int levels;
 989     DWORD flags = 0;
 990     HRESULT hr;
 991
 992     if (!validate_texture2d_desc(desc, device->feature_level))
 993     {
 994         WARN("Failed to validate texture desc.\n");
 995         return E_INVALIDARG;
 996     }
 997
 998     if (!(texture = heap_alloc_zero(sizeof(*texture))))
 999         return E_OUTOFMEMORY;
1000
1001     texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
1002     texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
1003     texture->refcount = 1;
1004     wined3d_mutex_lock();
1005     wined3d_private_store_init(&texture->private_store);
1006     texture->desc = *desc;
1007
1008     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1009     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
1010     wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
1011     wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
1012     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);
1013     wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
1014             desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
1015     wined3d_desc.width = desc->Width;
1016     wined3d_desc.height = desc->Height;
1017     wined3d_desc.depth = 1;
1018     wined3d_desc.size = 0;
1019
1020     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
1021
1022     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
1023         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
1024     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
1025         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
1026
1027     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
1028             desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
1029             texture, &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
1030     {
1031         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1032         wined3d_private_store_cleanup(&texture->private_store);
1033         heap_free(texture);
1034         wined3d_mutex_unlock();
1035         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
1036             hr = E_INVALIDARG;
1037         return hr;
1038     }
1039     texture->desc.MipLevels = levels;
1040
1041     if (desc->MipLevels == 1 && desc->ArraySize == 1)
1042     {
1043         IWineDXGIDevice *wine_device;
1044
1045         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
1046                 (void **)&wine_device)))
1047         {
1048             ERR("Device should implement IWineDXGIDevice.\n");
1049             wined3d_texture_decref(texture->wined3d_texture);
1050             wined3d_mutex_unlock();
1051             return E_FAIL;
1052         }
1053
1054         hr = IWineDXGIDevice_create_surface(wine_device, texture->wined3d_texture, 0, NULL,
1055                 (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
1056         IWineDXGIDevice_Release(wine_device);
1057         if (FAILED(hr))
1058         {
1059             ERR("Failed to create DXGI surface, returning %#.x\n", hr);
1060             texture->dxgi_surface = NULL;
1061             wined3d_texture_decref(texture->wined3d_texture);
1062             wined3d_mutex_unlock();
1063             return hr;
1064         }
1065     }
1066     wined3d_mutex_unlock();
1067
1068     ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
1069
1070     TRACE("Created texture %p.\n", texture);
1071     *out = texture;
1072
1073     return S_OK;
1074 }
1075
1076 /* ID3D11Texture3D methods */
1077
1078 static inline struct d3d_texture3d *impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
1079 {
1080     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D11Texture3D_iface);
1081 }
1082
1083 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_QueryInterface(ID3D11Texture3D *iface, REFIID riid, void **object)
1084 {
1085     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1086
1087     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1088
1089     if (IsEqualGUID(riid, &IID_ID3D11Texture3D)
1090             || IsEqualGUID(riid, &IID_ID3D11Resource)
1091             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1092             || IsEqualGUID(riid, &IID_IUnknown))
1093     {
1094         IUnknown_AddRef(iface);
1095         *object = iface;
1096         return S_OK;
1097     }
1098     else if (IsEqualGUID(riid, &IID_ID3D10Texture3D)
1099             || IsEqualGUID(riid, &IID_ID3D10Resource)
1100             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1101     {
1102         IUnknown_AddRef(iface);
1103         *object = &texture->ID3D10Texture3D_iface;
1104         return S_OK;
1105     }
1106
1107     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1108
1109     *object = NULL;
1110     return E_NOINTERFACE;
1111 }
1112
1113 static ULONG STDMETHODCALLTYPE d3d11_texture3d_AddRef(ID3D11Texture3D *iface)
1114 {
1115     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1116     ULONG refcount = InterlockedIncrement(&texture->refcount);
1117
1118     TRACE("%p increasing refcount to %u.\n", texture, refcount);
1119
1120     if (refcount == 1)
1121     {
1122         ID3D11Device2_AddRef(texture->device);
1123         wined3d_mutex_lock();
1124         wined3d_texture_incref(texture->wined3d_texture);
1125         wined3d_mutex_unlock();
1126     }
1127
1128     return refcount;
1129 }
1130
1131 static void STDMETHODCALLTYPE d3d_texture3d_wined3d_object_released(void *parent)
1132 {
1133     struct d3d_texture3d *texture = parent;
1134
1135     wined3d_private_store_cleanup(&texture->private_store);
1136     heap_free(parent);
1137 }
1138
1139 static ULONG STDMETHODCALLTYPE d3d11_texture3d_Release(ID3D11Texture3D *iface)
1140 {
1141     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1142     ULONG refcount = InterlockedDecrement(&texture->refcount);
1143
1144     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
1145
1146     if (!refcount)
1147     {
1148         ID3D11Device2 *device = texture->device;
1149
1150         wined3d_mutex_lock();
1151         wined3d_texture_decref(texture->wined3d_texture);
1152         wined3d_mutex_unlock();
1153         /* Release the device last, it may cause the wined3d device to be
1154          * destroyed. */
1155         ID3D11Device2_Release(device);
1156     }
1157
1158     return refcount;
1159 }
1160
1161 static void STDMETHODCALLTYPE d3d11_texture3d_GetDevice(ID3D11Texture3D *iface, ID3D11Device **device)
1162 {
1163     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1164
1165     TRACE("iface %p, device %p.\n", iface, device);
1166
1167     *device = (ID3D11Device *)texture->device;
1168     ID3D11Device_AddRef(*device);
1169 }
1170
1171 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_GetPrivateData(ID3D11Texture3D *iface,
1172         REFGUID guid, UINT *data_size, void *data)
1173 {
1174     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1175
1176     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1177
1178     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
1179 }
1180
1181 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateData(ID3D11Texture3D *iface,
1182         REFGUID guid, UINT data_size, const void *data)
1183 {
1184     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1185
1186     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1187
1188     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
1189 }
1190
1191 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateDataInterface(ID3D11Texture3D *iface,
1192         REFGUID guid, const IUnknown *data)
1193 {
1194     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1195
1196     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1197
1198     return d3d_set_private_data_interface(&texture->private_store, guid, data);
1199 }
1200
1201 static void STDMETHODCALLTYPE d3d11_texture3d_GetType(ID3D11Texture3D *iface,
1202         D3D11_RESOURCE_DIMENSION *resource_dimension)
1203 {
1204     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
1205
1206     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE3D;
1207 }
1208
1209 static void STDMETHODCALLTYPE d3d11_texture3d_SetEvictionPriority(ID3D11Texture3D *iface, UINT eviction_priority)
1210 {
1211     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
1212 }
1213
1214 static UINT STDMETHODCALLTYPE d3d11_texture3d_GetEvictionPriority(ID3D11Texture3D *iface)
1215 {
1216     FIXME("iface %p stub!\n", iface);
1217
1218     return 0;
1219 }
1220
1221 static void STDMETHODCALLTYPE d3d11_texture3d_GetDesc(ID3D11Texture3D *iface, D3D11_TEXTURE3D_DESC *desc)
1222 {
1223     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
1224
1225     TRACE("iface %p, desc %p.\n", iface, desc);
1226
1227     *desc = texture->desc;
1228 }
1229
1230 static const struct ID3D11Texture3DVtbl d3d11_texture3d_vtbl =
1231 {
1232     /* IUnknown methods */
1233     d3d11_texture3d_QueryInterface,
1234     d3d11_texture3d_AddRef,
1235     d3d11_texture3d_Release,
1236     /* ID3D11DeviceChild methods */
1237     d3d11_texture3d_GetDevice,
1238     d3d11_texture3d_GetPrivateData,
1239     d3d11_texture3d_SetPrivateData,
1240     d3d11_texture3d_SetPrivateDataInterface,
1241     /* ID3D11Resource methods */
1242     d3d11_texture3d_GetType,
1243     d3d11_texture3d_SetEvictionPriority,
1244     d3d11_texture3d_GetEvictionPriority,
1245     /* ID3D11Texture3D methods */
1246     d3d11_texture3d_GetDesc,
1247 };
1248
1249 /* ID3D10Texture3D methods */
1250
1251 static inline struct d3d_texture3d *impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
1252 {
1253     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
1254 }
1255
1256 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_QueryInterface(ID3D10Texture3D *iface, REFIID riid, void **object)
1257 {
1258     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1259
1260     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1261
1262     return d3d11_texture3d_QueryInterface(&texture->ID3D11Texture3D_iface, riid, object);
1263 }
1264
1265 static ULONG STDMETHODCALLTYPE d3d10_texture3d_AddRef(ID3D10Texture3D *iface)
1266 {
1267     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1268
1269     TRACE("iface %p.\n", iface);
1270
1271     return d3d11_texture3d_AddRef(&texture->ID3D11Texture3D_iface);
1272 }
1273
1274 static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
1275 {
1276     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1277
1278     TRACE("iface %p.\n", iface);
1279
1280     return d3d11_texture3d_Release(&texture->ID3D11Texture3D_iface);
1281 }
1282
1283 static void STDMETHODCALLTYPE d3d10_texture3d_GetDevice(ID3D10Texture3D *iface, ID3D10Device **device)
1284 {
1285     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1286
1287     TRACE("iface %p, device %p.\n", iface, device);
1288
1289     ID3D11Device2_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
1290 }
1291
1292 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_GetPrivateData(ID3D10Texture3D *iface,
1293         REFGUID guid, UINT *data_size, void *data)
1294 {
1295     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1296
1297     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1298             iface, debugstr_guid(guid), data_size, data);
1299
1300     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
1301 }
1302
1303 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateData(ID3D10Texture3D *iface,
1304         REFGUID guid, UINT data_size, const void *data)
1305 {
1306     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1307
1308     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1309             iface, debugstr_guid(guid), data_size, data);
1310
1311     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
1312 }
1313
1314 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateDataInterface(ID3D10Texture3D *iface,
1315         REFGUID guid, const IUnknown *data)
1316 {
1317     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1318
1319     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1320
1321     return d3d_set_private_data_interface(&texture->private_store, guid, data);
1322 }
1323
1324 static void STDMETHODCALLTYPE d3d10_texture3d_GetType(ID3D10Texture3D *iface,
1325         D3D10_RESOURCE_DIMENSION *resource_dimension)
1326 {
1327     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
1328
1329     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE3D;
1330 }
1331
1332 static void STDMETHODCALLTYPE d3d10_texture3d_SetEvictionPriority(ID3D10Texture3D *iface, UINT eviction_priority)
1333 {
1334     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
1335 }
1336
1337 static UINT STDMETHODCALLTYPE d3d10_texture3d_GetEvictionPriority(ID3D10Texture3D *iface)
1338 {
1339     FIXME("iface %p stub!\n", iface);
1340
1341     return 0;
1342 }
1343
1344 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
1345         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
1346 {
1347     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1348     struct wined3d_map_desc wined3d_map_desc;
1349     HRESULT hr;
1350
1351     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
1352             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
1353
1354     if (map_flags)
1355         FIXME("Ignoring map_flags %#x.\n", map_flags);
1356
1357     wined3d_mutex_lock();
1358     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
1359             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))
1360     {
1361         mapped_texture->pData = wined3d_map_desc.data;
1362         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
1363         mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
1364     }
1365     wined3d_mutex_unlock();
1366
1367     return hr;
1368 }
1369
1370 static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx)
1371 {
1372     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1373
1374     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
1375
1376     wined3d_mutex_lock();
1377     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
1378     wined3d_mutex_unlock();
1379 }
1380
1381 static void STDMETHODCALLTYPE d3d10_texture3d_GetDesc(ID3D10Texture3D *iface, D3D10_TEXTURE3D_DESC *desc)
1382 {
1383     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
1384     D3D11_TEXTURE3D_DESC d3d11_desc;
1385
1386     TRACE("iface %p, desc %p.\n", iface, desc);
1387
1388     d3d11_texture3d_GetDesc(&texture->ID3D11Texture3D_iface, &d3d11_desc);
1389
1390     desc->Width = d3d11_desc.Width;
1391     desc->Height = d3d11_desc.Height;
1392     desc->Depth = d3d11_desc.Depth;
1393     desc->MipLevels = d3d11_desc.MipLevels;
1394     desc->Format = d3d11_desc.Format;
1395     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
1396     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
1397     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
1398     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
1399 }
1400
1401 static const struct ID3D10Texture3DVtbl d3d10_texture3d_vtbl =
1402 {
1403     /* IUnknown methods */
1404     d3d10_texture3d_QueryInterface,
1405     d3d10_texture3d_AddRef,
1406     d3d10_texture3d_Release,
1407     /* ID3D10DeviceChild methods */
1408     d3d10_texture3d_GetDevice,
1409     d3d10_texture3d_GetPrivateData,
1410     d3d10_texture3d_SetPrivateData,
1411     d3d10_texture3d_SetPrivateDataInterface,
1412     /* ID3D10Resource methods */
1413     d3d10_texture3d_GetType,
1414     d3d10_texture3d_SetEvictionPriority,
1415     d3d10_texture3d_GetEvictionPriority,
1416     /* ID3D10Texture3D methods */
1417     d3d10_texture3d_Map,
1418     d3d10_texture3d_Unmap,
1419     d3d10_texture3d_GetDesc,
1420 };
1421
1422 struct d3d_texture3d *unsafe_impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
1423 {
1424     if (!iface)
1425         return NULL;
1426     assert(iface->lpVtbl == &d3d10_texture3d_vtbl);
1427     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
1428 }
1429
1430 struct d3d_texture3d *unsafe_impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
1431 {
1432     if (!iface)
1433         return NULL;
1434     assert(iface->lpVtbl == &d3d11_texture3d_vtbl);
1435     return impl_from_ID3D11Texture3D(iface);
1436 }
1437
1438 static const struct wined3d_parent_ops d3d_texture3d_wined3d_parent_ops =
1439 {
1440     d3d_texture3d_wined3d_object_released,
1441 };
1442
1443 static HRESULT d3d_texture3d_init(struct d3d_texture3d *texture, struct d3d_device *device,
1444         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data)
1445 {
1446     struct wined3d_resource_desc wined3d_desc;
1447     unsigned int levels;
1448     DWORD flags = 0;
1449     HRESULT hr;
1450
1451     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
1452             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
1453     {
1454         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET "
1455                 "and D3D11_BIND_SHADER_RESOURCE.\n");
1456         return E_INVALIDARG;
1457     }
1458
1459     texture->ID3D11Texture3D_iface.lpVtbl = &d3d11_texture3d_vtbl;
1460     texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
1461     texture->refcount = 1;
1462     wined3d_mutex_lock();
1463     wined3d_private_store_init(&texture->private_store);
1464     texture->desc = *desc;
1465
1466     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
1467     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
1468     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1469     wined3d_desc.multisample_quality = 0;
1470     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);
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 }