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 /* ID3D11Texture2D methods */
  29
  30 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_QueryInterface(ID3D11Texture2D *iface, REFIID riid, void **object)
  31 {
  32     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  33
  34     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  35
  36     if (IsEqualGUID(riid, &IID_ID3D11Texture2D)
  37             || IsEqualGUID(riid, &IID_ID3D11Resource)
  38             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
  39             || IsEqualGUID(riid, &IID_IUnknown))
  40     {
  41         *object = &texture->ID3D11Texture2D_iface;
  42         IUnknown_AddRef((IUnknown *)*object);
  43         return S_OK;
  44     }
  45     else if (IsEqualGUID(riid, &IID_ID3D10Texture2D)
  46             || IsEqualGUID(riid, &IID_ID3D10Resource)
  47             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
  48     {
  49         *object = &texture->ID3D10Texture2D_iface;
  50         IUnknown_AddRef((IUnknown *)*object);
  51         return S_OK;
  52     }
  53
  54     if (texture->dxgi_surface)
  55     {
  56         TRACE("Forwarding to dxgi surface.\n");
  57         return IUnknown_QueryInterface(texture->dxgi_surface, riid, object);
  58     }
  59
  60     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  61
  62     *object = NULL;
  63     return E_NOINTERFACE;
  64 }
  65
  66 static ULONG STDMETHODCALLTYPE d3d11_texture2d_AddRef(ID3D11Texture2D *iface)
  67 {
  68     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  69     ULONG refcount = InterlockedIncrement(&texture->refcount);
  70
  71     TRACE("%p increasing refcount to %u.\n", texture, refcount);
  72
  73     if (refcount == 1)
  74     {
  75         ID3D11Device_AddRef(texture->device);
  76         wined3d_mutex_lock();
  77         wined3d_texture_incref(texture->wined3d_texture);
  78         wined3d_mutex_unlock();
  79     }
  80
  81     return refcount;
  82 }
  83
  84 static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface)
  85 {
  86     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  87     ULONG refcount = InterlockedDecrement(&texture->refcount);
  88
  89     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
  90
  91     if (!refcount)
  92     {
  93         ID3D11Device *device = texture->device;
  94
  95         wined3d_mutex_lock();
  96         wined3d_texture_decref(texture->wined3d_texture);
  97         wined3d_mutex_unlock();
  98         /* Release the device last, it may cause the wined3d device to be
  99          * destroyed. */
 100         ID3D11Device_Release(device);
 101     }
 102
 103     return refcount;
 104 }
 105
 106 static void STDMETHODCALLTYPE d3d11_texture2d_GetDevice(ID3D11Texture2D *iface, ID3D11Device **device)
 107 {
 108     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 109
 110     TRACE("iface %p, device %p.\n", iface, device);
 111
 112     *device = texture->device;
 113     ID3D11Device_AddRef(*device);
 114 }
 115
 116 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_GetPrivateData(ID3D11Texture2D *iface,
 117         REFGUID guid, UINT *data_size, void *data)
 118 {
 119     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 120     IDXGISurface *dxgi_surface;
 121     HRESULT hr;
 122
 123     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 124
 125     if (texture->dxgi_surface
 126             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 127     {
 128         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 129         IDXGISurface_Release(dxgi_surface);
 130         return hr;
 131     }
 132
 133     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 134 }
 135
 136 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateData(ID3D11Texture2D *iface,
 137         REFGUID guid, UINT data_size, const void *data)
 138 {
 139     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 140     IDXGISurface *dxgi_surface;
 141     HRESULT hr;
 142
 143     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 144
 145     if (texture->dxgi_surface
 146             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 147     {
 148         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 149         IDXGISurface_Release(dxgi_surface);
 150         return hr;
 151     }
 152
 153     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 154 }
 155
 156 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateDataInterface(ID3D11Texture2D *iface,
 157         REFGUID guid, const IUnknown *data)
 158 {
 159     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 160     IDXGISurface *dxgi_surface;
 161     HRESULT hr;
 162
 163     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 164
 165     if (texture->dxgi_surface
 166             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 167     {
 168         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 169         IDXGISurface_Release(dxgi_surface);
 170         return hr;
 171     }
 172
 173     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 174 }
 175
 176 static void STDMETHODCALLTYPE d3d11_texture2d_GetType(ID3D11Texture2D *iface,
 177         D3D11_RESOURCE_DIMENSION *resource_dimension)
 178 {
 179     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 180
 181     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D;
 182 }
 183
 184 static void STDMETHODCALLTYPE d3d11_texture2d_SetEvictionPriority(ID3D11Texture2D *iface, UINT eviction_priority)
 185 {
 186     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 187 }
 188
 189 static UINT STDMETHODCALLTYPE d3d11_texture2d_GetEvictionPriority(ID3D11Texture2D *iface)
 190 {
 191     FIXME("iface %p stub!\n", iface);
 192
 193     return 0;
 194 }
 195
 196 static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc)
 197 {
 198     struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 199     struct wined3d_resource_desc wined3d_desc;
 200
 201     TRACE("iface %p, desc %p.\n", iface, desc);
 202
 203     *desc = texture->desc;
 204
 205     wined3d_mutex_lock();
 206     wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);
 207     wined3d_mutex_unlock();
 208
 209     /* FIXME: Resizing swapchain buffers can cause these to change. We'd like
 210      * to get everything from wined3d, but e.g. bind flags don't exist as such
 211      * there (yet). */
 212     desc->Width = wined3d_desc.width;
 213     desc->Height = wined3d_desc.height;
 214     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);
 215     desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE
 216         ? 1 : wined3d_desc.multisample_type;
 217     desc->SampleDesc.Quality = wined3d_desc.multisample_quality;
 218 }
 219
 220 static const struct ID3D11Texture2DVtbl d3d11_texture2d_vtbl =
 221 {
 222     /* IUnknown methods */
 223     d3d11_texture2d_QueryInterface,
 224     d3d11_texture2d_AddRef,
 225     d3d11_texture2d_Release,
 226     /* ID3D11DeviceChild methods */
 227     d3d11_texture2d_GetDevice,
 228     d3d11_texture2d_GetPrivateData,
 229     d3d11_texture2d_SetPrivateData,
 230     d3d11_texture2d_SetPrivateDataInterface,
 231     /* ID3D11Resource methods */
 232     d3d11_texture2d_GetType,
 233     d3d11_texture2d_SetEvictionPriority,
 234     d3d11_texture2d_GetEvictionPriority,
 235     /* ID3D11Texture2D methods */
 236     d3d11_texture2d_GetDesc,
 237 };
 238
 239 struct d3d_texture2d *unsafe_impl_from_ID3D11Texture2D(ID3D11Texture2D *iface)
 240 {
 241     if (!iface)
 242         return NULL;
 243     assert(iface->lpVtbl == &d3d11_texture2d_vtbl);
 244     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D11Texture2D_iface);
 245 }
 246
 247 /* IUnknown methods */
 248
 249 static inline struct d3d_texture2d *impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 250 {
 251     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 252 }
 253
 254 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_QueryInterface(ID3D10Texture2D *iface, REFIID riid, void **object)
 255 {
 256     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 257
 258     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 259
 260     return d3d11_texture2d_QueryInterface(&texture->ID3D11Texture2D_iface, riid, object);
 261 }
 262
 263 static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
 264 {
 265     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 266
 267     TRACE("iface %p.\n", iface);
 268
 269     return d3d11_texture2d_AddRef(&texture->ID3D11Texture2D_iface);
 270 }
 271
 272 static void STDMETHODCALLTYPE d3d_texture2d_wined3d_object_released(void *parent)
 273 {
 274     struct d3d_texture2d *texture = parent;
 275
 276     if (texture->dxgi_surface) IUnknown_Release(texture->dxgi_surface);
 277     wined3d_private_store_cleanup(&texture->private_store);
 278     heap_free(texture);
 279 }
 280
 281 static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
 282 {
 283     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 284
 285     TRACE("iface %p.\n", iface);
 286
 287     return d3d11_texture2d_Release(&texture->ID3D11Texture2D_iface);
 288 }
 289
 290 /* ID3D10DeviceChild methods */
 291
 292 static void STDMETHODCALLTYPE d3d10_texture2d_GetDevice(ID3D10Texture2D *iface, ID3D10Device **device)
 293 {
 294     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 295
 296     TRACE("iface %p, device %p.\n", iface, device);
 297
 298     ID3D11Device_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 299 }
 300
 301 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_GetPrivateData(ID3D10Texture2D *iface,
 302         REFGUID guid, UINT *data_size, void *data)
 303 {
 304     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 305
 306     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 307
 308     return d3d11_texture2d_GetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 309 }
 310
 311 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateData(ID3D10Texture2D *iface,
 312         REFGUID guid, UINT data_size, const void *data)
 313 {
 314     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 315
 316     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 317
 318     return d3d11_texture2d_SetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 319 }
 320
 321 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateDataInterface(ID3D10Texture2D *iface,
 322         REFGUID guid, const IUnknown *data)
 323 {
 324     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 325
 326     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 327
 328     return d3d11_texture2d_SetPrivateDataInterface(&texture->ID3D11Texture2D_iface, guid, data);
 329 }
 330
 331 /* ID3D10Resource methods */
 332
 333 static void STDMETHODCALLTYPE d3d10_texture2d_GetType(ID3D10Texture2D *iface,
 334         D3D10_RESOURCE_DIMENSION *resource_dimension)
 335 {
 336     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 337
 338     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE2D;
 339 }
 340
 341 static void STDMETHODCALLTYPE d3d10_texture2d_SetEvictionPriority(ID3D10Texture2D *iface, UINT eviction_priority)
 342 {
 343     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 344 }
 345
 346 static UINT STDMETHODCALLTYPE d3d10_texture2d_GetEvictionPriority(ID3D10Texture2D *iface)
 347 {
 348     FIXME("iface %p stub!\n", iface);
 349
 350     return 0;
 351 }
 352
 353 /* ID3D10Texture2D methods */
 354
 355 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,
 356         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture)
 357 {
 358     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 359     struct wined3d_map_desc wined3d_map_desc;
 360     HRESULT hr;
 361
 362     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 363             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 364
 365     if (map_flags)
 366         FIXME("Ignoring map_flags %#x.\n", map_flags);
 367
 368     wined3d_mutex_lock();
 369     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
 370             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))
 371     {
 372         mapped_texture->pData = wined3d_map_desc.data;
 373         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 374     }
 375     wined3d_mutex_unlock();
 376
 377     return hr;
 378 }
 379
 380 static void STDMETHODCALLTYPE d3d10_texture2d_Unmap(ID3D10Texture2D *iface, UINT sub_resource_idx)
 381 {
 382     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 383
 384     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 385
 386     wined3d_mutex_lock();
 387     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
 388     wined3d_mutex_unlock();
 389 }
 390
 391 static void STDMETHODCALLTYPE d3d10_texture2d_GetDesc(ID3D10Texture2D *iface, D3D10_TEXTURE2D_DESC *desc)
 392 {
 393     struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 394     D3D11_TEXTURE2D_DESC d3d11_desc;
 395
 396     TRACE("iface %p, desc %p\n", iface, desc);
 397
 398     d3d11_texture2d_GetDesc(&texture->ID3D11Texture2D_iface, &d3d11_desc);
 399
 400     desc->Width = d3d11_desc.Width;
 401     desc->Height = d3d11_desc.Height;
 402     desc->MipLevels = d3d11_desc.MipLevels;
 403     desc->ArraySize = d3d11_desc.ArraySize;
 404     desc->Format = d3d11_desc.Format;
 405     desc->SampleDesc = d3d11_desc.SampleDesc;
 406     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
 407     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
 408     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
 409     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
 410 }
 411
 412 static const struct ID3D10Texture2DVtbl d3d10_texture2d_vtbl =
 413 {
 414     /* IUnknown methods */
 415     d3d10_texture2d_QueryInterface,
 416     d3d10_texture2d_AddRef,
 417     d3d10_texture2d_Release,
 418     /* ID3D10DeviceChild methods */
 419     d3d10_texture2d_GetDevice,
 420     d3d10_texture2d_GetPrivateData,
 421     d3d10_texture2d_SetPrivateData,
 422     d3d10_texture2d_SetPrivateDataInterface,
 423     /* ID3D10Resource methods */
 424     d3d10_texture2d_GetType,
 425     d3d10_texture2d_SetEvictionPriority,
 426     d3d10_texture2d_GetEvictionPriority,
 427     /* ID3D10Texture2D methods */
 428     d3d10_texture2d_Map,
 429     d3d10_texture2d_Unmap,
 430     d3d10_texture2d_GetDesc,
 431 };
 432
 433 struct d3d_texture2d *unsafe_impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 434 {
 435     if (!iface)
 436         return NULL;
 437     assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
 438     return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
 439 }
 440
 441 static const struct wined3d_parent_ops d3d_texture2d_wined3d_parent_ops =
 442 {
 443     d3d_texture2d_wined3d_object_released,
 444 };
 445
 446 static BOOL is_gdi_compatible_texture(const D3D11_TEXTURE2D_DESC *desc)
 447 {
 448     if (!(desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM
 449             || desc->Format == DXGI_FORMAT_B8G8R8A8_TYPELESS
 450             || desc->Format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB))
 451         return FALSE;
 452
 453     if (desc->Usage != D3D11_USAGE_DEFAULT)
 454         return FALSE;
 455
 456     return TRUE;
 457 }
 458
 459 static BOOL validate_texture2d_desc(const D3D11_TEXTURE2D_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 460 {
 461     if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_TEXTURE2D,
 462             desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
 463         return FALSE;
 464
 465     if (desc->MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE
 466             && desc->ArraySize < 6)
 467     {
 468         WARN("Invalid array size %u for cube texture.\n", desc->ArraySize);
 469         return FALSE;
 470     }
 471
 472     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE
 473             && !is_gdi_compatible_texture(desc))
 474     {
 475         WARN("Incompatible description used to create GDI compatible texture.\n");
 476         return FALSE;
 477     }
 478
 479     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
 480             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
 481     {
 482         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET and "
 483                 "D3D11_BIND_SHADER_RESOURCE.\n");
 484         return FALSE;
 485     }
 486
 487     return TRUE;
 488 }
 489
 490 HRESULT d3d_texture2d_create(struct d3d_device *device, const D3D11_TEXTURE2D_DESC *desc,
 491         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture2d **out)
 492 {
 493     struct wined3d_resource_desc wined3d_desc;
 494     struct d3d_texture2d *texture;
 495     unsigned int levels;
 496     DWORD flags = 0;
 497     HRESULT hr;
 498
 499     if (!validate_texture2d_desc(desc, device->feature_level))
 500     {
 501         WARN("Failed to validate texture desc.\n");
 502         return E_INVALIDARG;
 503     }
 504
 505     if (!(texture = heap_alloc_zero(sizeof(*texture))))
 506         return E_OUTOFMEMORY;
 507
 508     texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
 509     texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
 510     texture->refcount = 1;
 511     wined3d_mutex_lock();
 512     wined3d_private_store_init(&texture->private_store);
 513     texture->desc = *desc;
 514
 515     if (desc->SampleDesc.Count > 1)
 516         FIXME("Multisampled textures not implemented.\n");
 517
 518     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
 519     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 520     wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
 521     wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
 522     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);
 523     wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU;
 524     wined3d_desc.width = desc->Width;
 525     wined3d_desc.height = desc->Height;
 526     wined3d_desc.depth = 1;
 527     wined3d_desc.size = 0;
 528
 529     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
 530
 531     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
 532         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 533     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
 534         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 535
 536     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 537             desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
 538             texture, &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
 539     {
 540         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 541         wined3d_private_store_cleanup(&texture->private_store);
 542         heap_free(texture);
 543         wined3d_mutex_unlock();
 544         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
 545             hr = E_INVALIDARG;
 546         return hr;
 547     }
 548     texture->desc.MipLevels = levels;
 549
 550     if (desc->MipLevels == 1 && desc->ArraySize == 1)
 551     {
 552         IWineDXGIDevice *wine_device;
 553
 554         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
 555                 (void **)&wine_device)))
 556         {
 557             ERR("Device should implement IWineDXGIDevice.\n");
 558             wined3d_texture_decref(texture->wined3d_texture);
 559             wined3d_mutex_unlock();
 560             return E_FAIL;
 561         }
 562
 563         hr = IWineDXGIDevice_create_surface(wine_device, texture->wined3d_texture, 0, NULL,
 564                 (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
 565         IWineDXGIDevice_Release(wine_device);
 566         if (FAILED(hr))
 567         {
 568             ERR("Failed to create DXGI surface, returning %#.x\n", hr);
 569             texture->dxgi_surface = NULL;
 570             wined3d_texture_decref(texture->wined3d_texture);
 571             wined3d_mutex_unlock();
 572             return hr;
 573         }
 574     }
 575     wined3d_mutex_unlock();
 576
 577     ID3D11Device_AddRef(texture->device = &device->ID3D11Device_iface);
 578
 579     TRACE("Created texture %p.\n", texture);
 580     *out = texture;
 581
 582     return S_OK;
 583 }
 584
 585 /* ID3D11Texture3D methods */
 586
 587 static inline struct d3d_texture3d *impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
 588 {
 589     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D11Texture3D_iface);
 590 }
 591
 592 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_QueryInterface(ID3D11Texture3D *iface, REFIID riid, void **object)
 593 {
 594     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 595
 596     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 597
 598     if (IsEqualGUID(riid, &IID_ID3D11Texture3D)
 599             || IsEqualGUID(riid, &IID_ID3D11Resource)
 600             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 601             || IsEqualGUID(riid, &IID_IUnknown))
 602     {
 603         IUnknown_AddRef(iface);
 604         *object = iface;
 605         return S_OK;
 606     }
 607     else if (IsEqualGUID(riid, &IID_ID3D10Texture3D)
 608             || IsEqualGUID(riid, &IID_ID3D10Resource)
 609             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 610     {
 611         IUnknown_AddRef(iface);
 612         *object = &texture->ID3D10Texture3D_iface;
 613         return S_OK;
 614     }
 615
 616     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 617
 618     *object = NULL;
 619     return E_NOINTERFACE;
 620 }
 621
 622 static ULONG STDMETHODCALLTYPE d3d11_texture3d_AddRef(ID3D11Texture3D *iface)
 623 {
 624     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 625     ULONG refcount = InterlockedIncrement(&texture->refcount);
 626
 627     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 628
 629     if (refcount == 1)
 630     {
 631         ID3D11Device_AddRef(texture->device);
 632         wined3d_mutex_lock();
 633         wined3d_texture_incref(texture->wined3d_texture);
 634         wined3d_mutex_unlock();
 635     }
 636
 637     return refcount;
 638 }
 639
 640 static void STDMETHODCALLTYPE d3d_texture3d_wined3d_object_released(void *parent)
 641 {
 642     struct d3d_texture3d *texture = parent;
 643
 644     wined3d_private_store_cleanup(&texture->private_store);
 645     heap_free(parent);
 646 }
 647
 648 static ULONG STDMETHODCALLTYPE d3d11_texture3d_Release(ID3D11Texture3D *iface)
 649 {
 650     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 651     ULONG refcount = InterlockedDecrement(&texture->refcount);
 652
 653     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 654
 655     if (!refcount)
 656     {
 657         ID3D11Device *device = texture->device;
 658
 659         wined3d_mutex_lock();
 660         wined3d_texture_decref(texture->wined3d_texture);
 661         wined3d_mutex_unlock();
 662         /* Release the device last, it may cause the wined3d device to be
 663          * destroyed. */
 664         ID3D11Device_Release(device);
 665     }
 666
 667     return refcount;
 668 }
 669
 670 static void STDMETHODCALLTYPE d3d11_texture3d_GetDevice(ID3D11Texture3D *iface, ID3D11Device **device)
 671 {
 672     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 673
 674     TRACE("iface %p, device %p.\n", iface, device);
 675
 676     *device = texture->device;
 677     ID3D11Device_AddRef(*device);
 678 }
 679
 680 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_GetPrivateData(ID3D11Texture3D *iface,
 681         REFGUID guid, UINT *data_size, void *data)
 682 {
 683     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 684
 685     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 686
 687     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 688 }
 689
 690 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateData(ID3D11Texture3D *iface,
 691         REFGUID guid, UINT data_size, const void *data)
 692 {
 693     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 694
 695     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 696
 697     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 698 }
 699
 700 static HRESULT STDMETHODCALLTYPE d3d11_texture3d_SetPrivateDataInterface(ID3D11Texture3D *iface,
 701         REFGUID guid, const IUnknown *data)
 702 {
 703     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 704
 705     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 706
 707     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 708 }
 709
 710 static void STDMETHODCALLTYPE d3d11_texture3d_GetType(ID3D11Texture3D *iface,
 711         D3D11_RESOURCE_DIMENSION *resource_dimension)
 712 {
 713     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 714
 715     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE3D;
 716 }
 717
 718 static void STDMETHODCALLTYPE d3d11_texture3d_SetEvictionPriority(ID3D11Texture3D *iface, UINT eviction_priority)
 719 {
 720     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 721 }
 722
 723 static UINT STDMETHODCALLTYPE d3d11_texture3d_GetEvictionPriority(ID3D11Texture3D *iface)
 724 {
 725     FIXME("iface %p stub!\n", iface);
 726
 727     return 0;
 728 }
 729
 730 static void STDMETHODCALLTYPE d3d11_texture3d_GetDesc(ID3D11Texture3D *iface, D3D11_TEXTURE3D_DESC *desc)
 731 {
 732     struct d3d_texture3d *texture = impl_from_ID3D11Texture3D(iface);
 733
 734     TRACE("iface %p, desc %p.\n", iface, desc);
 735
 736     *desc = texture->desc;
 737 }
 738
 739 static const struct ID3D11Texture3DVtbl d3d11_texture3d_vtbl =
 740 {
 741     /* IUnknown methods */
 742     d3d11_texture3d_QueryInterface,
 743     d3d11_texture3d_AddRef,
 744     d3d11_texture3d_Release,
 745     /* ID3D11DeviceChild methods */
 746     d3d11_texture3d_GetDevice,
 747     d3d11_texture3d_GetPrivateData,
 748     d3d11_texture3d_SetPrivateData,
 749     d3d11_texture3d_SetPrivateDataInterface,
 750     /* ID3D11Resource methods */
 751     d3d11_texture3d_GetType,
 752     d3d11_texture3d_SetEvictionPriority,
 753     d3d11_texture3d_GetEvictionPriority,
 754     /* ID3D11Texture3D methods */
 755     d3d11_texture3d_GetDesc,
 756 };
 757
 758 /* ID3D10Texture3D methods */
 759
 760 static inline struct d3d_texture3d *impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
 761 {
 762     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
 763 }
 764
 765 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_QueryInterface(ID3D10Texture3D *iface, REFIID riid, void **object)
 766 {
 767     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 768
 769     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 770
 771     return d3d11_texture3d_QueryInterface(&texture->ID3D11Texture3D_iface, riid, object);
 772 }
 773
 774 static ULONG STDMETHODCALLTYPE d3d10_texture3d_AddRef(ID3D10Texture3D *iface)
 775 {
 776     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 777
 778     TRACE("iface %p.\n", iface);
 779
 780     return d3d11_texture3d_AddRef(&texture->ID3D11Texture3D_iface);
 781 }
 782
 783 static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
 784 {
 785     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 786
 787     TRACE("iface %p.\n", iface);
 788
 789     return d3d11_texture3d_Release(&texture->ID3D11Texture3D_iface);
 790 }
 791
 792 static void STDMETHODCALLTYPE d3d10_texture3d_GetDevice(ID3D10Texture3D *iface, ID3D10Device **device)
 793 {
 794     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 795
 796     TRACE("iface %p, device %p.\n", iface, device);
 797
 798     ID3D11Device_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 799 }
 800
 801 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_GetPrivateData(ID3D10Texture3D *iface,
 802         REFGUID guid, UINT *data_size, void *data)
 803 {
 804     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 805
 806     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 807             iface, debugstr_guid(guid), data_size, data);
 808
 809     return d3d_get_private_data(&texture->private_store, guid, data_size, data);
 810 }
 811
 812 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateData(ID3D10Texture3D *iface,
 813         REFGUID guid, UINT data_size, const void *data)
 814 {
 815     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 816
 817     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 818             iface, debugstr_guid(guid), data_size, data);
 819
 820     return d3d_set_private_data(&texture->private_store, guid, data_size, data);
 821 }
 822
 823 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateDataInterface(ID3D10Texture3D *iface,
 824         REFGUID guid, const IUnknown *data)
 825 {
 826     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 827
 828     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 829
 830     return d3d_set_private_data_interface(&texture->private_store, guid, data);
 831 }
 832
 833 static void STDMETHODCALLTYPE d3d10_texture3d_GetType(ID3D10Texture3D *iface,
 834         D3D10_RESOURCE_DIMENSION *resource_dimension)
 835 {
 836     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 837
 838     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE3D;
 839 }
 840
 841 static void STDMETHODCALLTYPE d3d10_texture3d_SetEvictionPriority(ID3D10Texture3D *iface, UINT eviction_priority)
 842 {
 843     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 844 }
 845
 846 static UINT STDMETHODCALLTYPE d3d10_texture3d_GetEvictionPriority(ID3D10Texture3D *iface)
 847 {
 848     FIXME("iface %p stub!\n", iface);
 849
 850     return 0;
 851 }
 852
 853 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
 854         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
 855 {
 856     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 857     struct wined3d_map_desc wined3d_map_desc;
 858     HRESULT hr;
 859
 860     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 861             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 862
 863     if (map_flags)
 864         FIXME("Ignoring map_flags %#x.\n", map_flags);
 865
 866     wined3d_mutex_lock();
 867     if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
 868             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))
 869     {
 870         mapped_texture->pData = wined3d_map_desc.data;
 871         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 872         mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
 873     }
 874     wined3d_mutex_unlock();
 875
 876     return hr;
 877 }
 878
 879 static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx)
 880 {
 881     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 882
 883     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 884
 885     wined3d_mutex_lock();
 886     wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);
 887     wined3d_mutex_unlock();
 888 }
 889
 890 static void STDMETHODCALLTYPE d3d10_texture3d_GetDesc(ID3D10Texture3D *iface, D3D10_TEXTURE3D_DESC *desc)
 891 {
 892     struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 893     D3D11_TEXTURE3D_DESC d3d11_desc;
 894
 895     TRACE("iface %p, desc %p.\n", iface, desc);
 896
 897     d3d11_texture3d_GetDesc(&texture->ID3D11Texture3D_iface, &d3d11_desc);
 898
 899     desc->Width = d3d11_desc.Width;
 900     desc->Height = d3d11_desc.Height;
 901     desc->Depth = d3d11_desc.Depth;
 902     desc->MipLevels = d3d11_desc.MipLevels;
 903     desc->Format = d3d11_desc.Format;
 904     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc.Usage);
 905     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc.BindFlags);
 906     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc.CPUAccessFlags);
 907     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc.MiscFlags);
 908 }
 909
 910 static const struct ID3D10Texture3DVtbl d3d10_texture3d_vtbl =
 911 {
 912     /* IUnknown methods */
 913     d3d10_texture3d_QueryInterface,
 914     d3d10_texture3d_AddRef,
 915     d3d10_texture3d_Release,
 916     /* ID3D10DeviceChild methods */
 917     d3d10_texture3d_GetDevice,
 918     d3d10_texture3d_GetPrivateData,
 919     d3d10_texture3d_SetPrivateData,
 920     d3d10_texture3d_SetPrivateDataInterface,
 921     /* ID3D10Resource methods */
 922     d3d10_texture3d_GetType,
 923     d3d10_texture3d_SetEvictionPriority,
 924     d3d10_texture3d_GetEvictionPriority,
 925     /* ID3D10Texture3D methods */
 926     d3d10_texture3d_Map,
 927     d3d10_texture3d_Unmap,
 928     d3d10_texture3d_GetDesc,
 929 };
 930
 931 struct d3d_texture3d *unsafe_impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
 932 {
 933     if (!iface)
 934         return NULL;
 935     assert(iface->lpVtbl == &d3d10_texture3d_vtbl);
 936     return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
 937 }
 938
 939 struct d3d_texture3d *unsafe_impl_from_ID3D11Texture3D(ID3D11Texture3D *iface)
 940 {
 941     if (!iface)
 942         return NULL;
 943     assert(iface->lpVtbl == &d3d11_texture3d_vtbl);
 944     return impl_from_ID3D11Texture3D(iface);
 945 }
 946
 947 static const struct wined3d_parent_ops d3d_texture3d_wined3d_parent_ops =
 948 {
 949     d3d_texture3d_wined3d_object_released,
 950 };
 951
 952 static HRESULT d3d_texture3d_init(struct d3d_texture3d *texture, struct d3d_device *device,
 953         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data)
 954 {
 955     struct wined3d_resource_desc wined3d_desc;
 956     unsigned int levels;
 957     DWORD flags = 0;
 958     HRESULT hr;
 959
 960     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS
 961             && (~desc->BindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)))
 962     {
 963         WARN("D3D11_RESOURCE_MISC_GENERATE_MIPS used without D3D11_BIND_RENDER_TARGET "
 964                 "and D3D11_BIND_SHADER_RESOURCE.\n");
 965         return E_INVALIDARG;
 966     }
 967
 968     texture->ID3D11Texture3D_iface.lpVtbl = &d3d11_texture3d_vtbl;
 969     texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
 970     texture->refcount = 1;
 971     wined3d_mutex_lock();
 972     wined3d_private_store_init(&texture->private_store);
 973     texture->desc = *desc;
 974
 975     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
 976     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 977     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
 978     wined3d_desc.multisample_quality = 0;
 979     wined3d_desc.usage = wined3d_usage_from_d3d11(desc->BindFlags, desc->Usage);
 980     wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU;
 981     if (desc->Usage == D3D11_USAGE_STAGING)
 982         wined3d_desc.access |= WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP;
 983     wined3d_desc.width = desc->Width;
 984     wined3d_desc.height = desc->Height;
 985     wined3d_desc.depth = desc->Depth;
 986     wined3d_desc.size = 0;
 987
 988     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(max(desc->Width, desc->Height), desc->Depth)) + 1;
 989
 990     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
 991         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 992
 993     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 994             1, levels, flags, (struct wined3d_sub_resource_data *)data, texture,
 995             &d3d_texture3d_wined3d_parent_ops, &texture->wined3d_texture)))
 996     {
 997         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 998         wined3d_private_store_cleanup(&texture->private_store);
 999         wined3d_mutex_unlock();
1000         if (hr == WINED3DERR_INVALIDCALL)
1001             hr = E_INVALIDARG;
1002         return hr;
1003     }
1004     wined3d_mutex_unlock();
1005     texture->desc.MipLevels = levels;
1006
1007     texture->device = &device->ID3D11Device_iface;
1008     ID3D11Device_AddRef(texture->device);
1009
1010     return S_OK;
1011 }
1012
1013 HRESULT d3d_texture3d_create(struct d3d_device *device, const D3D11_TEXTURE3D_DESC *desc,
1014         const D3D11_SUBRESOURCE_DATA *data, struct d3d_texture3d **texture)
1015 {
1016     struct d3d_texture3d *object;
1017     HRESULT hr;
1018
1019     if (!(object = heap_alloc_zero(sizeof(*object))))
1020         return E_OUTOFMEMORY;
1021
1022     if (FAILED(hr = d3d_texture3d_init(object, device, desc, data)))
1023     {
1024         WARN("Failed to initialize texture, hr %#x.\n", hr);
1025         heap_free(object);
1026         return hr;
1027     }
1028
1029     TRACE("Created texture %p.\n", object);
1030     *texture = object;
1031
1032     return S_OK;
1033 }