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