dlls/d3d11/texture.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "d3d11_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  26
  27 static inline struct d3d10_texture2d *impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct d3d10_texture2d, ID3D10Texture2D_iface);
  30 }
  31
  32 /* IUnknown methods */
  33
  34 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_QueryInterface(ID3D10Texture2D *iface, REFIID riid, void **object)
  35 {
  36     struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
  37
  38     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
  39
  40     if (IsEqualGUID(riid, &IID_ID3D10Texture2D)
  41             || IsEqualGUID(riid, &IID_ID3D10Resource)
  42             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
  43             || IsEqualGUID(riid, &IID_IUnknown))
  44     {
  45         IUnknown_AddRef(iface);
  46         *object = iface;
  47         return S_OK;
  48     }
  49
  50     if (This->dxgi_surface)
  51     {
  52         TRACE("Forwarding to dxgi surface\n");
  53         return IUnknown_QueryInterface(This->dxgi_surface, riid, object);
  54     }
  55
  56     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  57
  58     *object = NULL;
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
  63 {
  64     struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
  65     ULONG refcount = InterlockedIncrement(&This->refcount);
  66
  67     TRACE("%p increasing refcount to %u\n", This, refcount);
  68
  69     if (refcount == 1)
  70     {
  71         ID3D10Device1_AddRef(This->device);
  72         wined3d_mutex_lock();
  73         wined3d_texture_incref(This->wined3d_texture);
  74         wined3d_mutex_unlock();
  75     }
  76
  77     return refcount;
  78 }
  79
  80 static void STDMETHODCALLTYPE d3d10_texture2d_wined3d_object_released(void *parent)
  81 {
  82     struct d3d10_texture2d *This = parent;
  83
  84     if (This->dxgi_surface) IUnknown_Release(This->dxgi_surface);
  85     wined3d_private_store_cleanup(&This->private_store);
  86     HeapFree(GetProcessHeap(), 0, This);
  87 }
  88
  89 static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
  90 {
  91     struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
  92     ULONG refcount = InterlockedDecrement(&This->refcount);
  93
  94     TRACE("%p decreasing refcount to %u\n", This, refcount);
  95
  96     if (!refcount)
  97     {
  98         ID3D10Device1 *device = This->device;
  99
 100         wined3d_mutex_lock();
 101         wined3d_texture_decref(This->wined3d_texture);
 102         wined3d_mutex_unlock();
 103         /* Release the device last, it may cause the wined3d device to be
 104          * destroyed. */
 105         ID3D10Device1_Release(device);
 106     }
 107
 108     return refcount;
 109 }
 110
 111 /* ID3D10DeviceChild methods */
 112
 113 static void STDMETHODCALLTYPE d3d10_texture2d_GetDevice(ID3D10Texture2D *iface, ID3D10Device **device)
 114 {
 115     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 116
 117     TRACE("iface %p, device %p.\n", iface, device);
 118
 119     *device = (ID3D10Device *)texture->device;
 120     ID3D10Device_AddRef(*device);
 121 }
 122
 123 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_GetPrivateData(ID3D10Texture2D *iface,
 124         REFGUID guid, UINT *data_size, void *data)
 125 {
 126     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 127     IDXGISurface *dxgi_surface;
 128     HRESULT hr;
 129
 130     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 131             iface, debugstr_guid(guid), data_size, data);
 132
 133     if (texture->dxgi_surface
 134             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 135     {
 136         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 137         IDXGISurface_Release(dxgi_surface);
 138         return hr;
 139     }
 140
 141     return d3d10_get_private_data(&texture->private_store, guid, data_size, data);
 142 }
 143
 144 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateData(ID3D10Texture2D *iface,
 145         REFGUID guid, UINT data_size, const void *data)
 146 {
 147     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 148     IDXGISurface *dxgi_surface;
 149     HRESULT hr;
 150
 151     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 152             iface, debugstr_guid(guid), data_size, data);
 153
 154     if (texture->dxgi_surface
 155             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 156     {
 157         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 158         IDXGISurface_Release(dxgi_surface);
 159         return hr;
 160     }
 161
 162     return d3d10_set_private_data(&texture->private_store, guid, data_size, data);
 163 }
 164
 165 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateDataInterface(ID3D10Texture2D *iface,
 166         REFGUID guid, const IUnknown *data)
 167 {
 168     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 169     IDXGISurface *dxgi_surface;
 170     HRESULT hr;
 171
 172     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 173
 174     if (texture->dxgi_surface
 175             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 176     {
 177         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 178         IDXGISurface_Release(dxgi_surface);
 179         return hr;
 180     }
 181
 182     return d3d10_set_private_data_interface(&texture->private_store, guid, data);
 183 }
 184
 185 /* ID3D10Resource methods */
 186
 187 static void STDMETHODCALLTYPE d3d10_texture2d_GetType(ID3D10Texture2D *iface,
 188         D3D10_RESOURCE_DIMENSION *resource_dimension)
 189 {
 190     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 191
 192     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE2D;
 193 }
 194
 195 static void STDMETHODCALLTYPE d3d10_texture2d_SetEvictionPriority(ID3D10Texture2D *iface, UINT eviction_priority)
 196 {
 197     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 198 }
 199
 200 static UINT STDMETHODCALLTYPE d3d10_texture2d_GetEvictionPriority(ID3D10Texture2D *iface)
 201 {
 202     FIXME("iface %p stub!\n", iface);
 203
 204     return 0;
 205 }
 206
 207 /* ID3D10Texture2D methods */
 208
 209 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,
 210         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture)
 211 {
 212     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 213     struct wined3d_map_desc wined3d_map_desc;
 214     struct wined3d_resource *sub_resource;
 215     HRESULT hr;
 216
 217     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 218             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 219
 220     if (map_flags)
 221         FIXME("Ignoring map_flags %#x.\n", map_flags);
 222
 223     wined3d_mutex_lock();
 224     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 225         hr = E_INVALIDARG;
 226     else if (SUCCEEDED(hr = wined3d_surface_map(wined3d_surface_from_resource(sub_resource),
 227             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 228     {
 229         mapped_texture->pData = wined3d_map_desc.data;
 230         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 231     }
 232     wined3d_mutex_unlock();
 233
 234     return hr;
 235 }
 236
 237 static void STDMETHODCALLTYPE d3d10_texture2d_Unmap(ID3D10Texture2D *iface, UINT sub_resource_idx)
 238 {
 239     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 240     struct wined3d_resource *sub_resource;
 241
 242     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 243
 244     wined3d_mutex_lock();
 245     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 246     {
 247         wined3d_mutex_unlock();
 248         return;
 249     }
 250
 251     wined3d_surface_unmap(wined3d_surface_from_resource(sub_resource));
 252     wined3d_mutex_unlock();
 253 }
 254
 255 static void STDMETHODCALLTYPE d3d10_texture2d_GetDesc(ID3D10Texture2D *iface, D3D10_TEXTURE2D_DESC *desc)
 256 {
 257     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 258     struct wined3d_resource_desc wined3d_desc;
 259
 260     TRACE("iface %p, desc %p\n", iface, desc);
 261
 262     *desc = texture->desc;
 263
 264     wined3d_mutex_lock();
 265     wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);
 266     wined3d_mutex_unlock();
 267
 268     /* FIXME: Resizing swapchain buffers can cause these to change. We'd like
 269      * to get everything from wined3d, but e.g. bind flags don't exist as such
 270      * there (yet). */
 271     desc->Width = wined3d_desc.width;
 272     desc->Height = wined3d_desc.height;
 273     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);
 274     desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE
 275             ? 1 : wined3d_desc.multisample_type;
 276     desc->SampleDesc.Quality = wined3d_desc.multisample_quality;
 277 }
 278
 279 static const struct ID3D10Texture2DVtbl d3d10_texture2d_vtbl =
 280 {
 281     /* IUnknown methods */
 282     d3d10_texture2d_QueryInterface,
 283     d3d10_texture2d_AddRef,
 284     d3d10_texture2d_Release,
 285     /* ID3D10DeviceChild methods */
 286     d3d10_texture2d_GetDevice,
 287     d3d10_texture2d_GetPrivateData,
 288     d3d10_texture2d_SetPrivateData,
 289     d3d10_texture2d_SetPrivateDataInterface,
 290     /* ID3D10Resource methods */
 291     d3d10_texture2d_GetType,
 292     d3d10_texture2d_SetEvictionPriority,
 293     d3d10_texture2d_GetEvictionPriority,
 294     /* ID3D10Texture2D methods */
 295     d3d10_texture2d_Map,
 296     d3d10_texture2d_Unmap,
 297     d3d10_texture2d_GetDesc,
 298 };
 299
 300 struct d3d10_texture2d *unsafe_impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 301 {
 302     if (!iface)
 303         return NULL;
 304     assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
 305     return CONTAINING_RECORD(iface, struct d3d10_texture2d, ID3D10Texture2D_iface);
 306 }
 307
 308 static const struct wined3d_parent_ops d3d10_texture2d_wined3d_parent_ops =
 309 {
 310     d3d10_texture2d_wined3d_object_released,
 311 };
 312
 313 HRESULT d3d10_texture2d_init(struct d3d10_texture2d *texture, struct d3d10_device *device,
 314         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data)
 315 {
 316     struct wined3d_resource_desc wined3d_desc;
 317     unsigned int levels;
 318     HRESULT hr;
 319
 320     texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
 321     texture->refcount = 1;
 322     wined3d_mutex_lock();
 323     wined3d_private_store_init(&texture->private_store);
 324     texture->desc = *desc;
 325
 326     if (desc->ArraySize != 1)
 327         FIXME("Array textures not implemented.\n");
 328     if (desc->SampleDesc.Count > 1)
 329         FIXME("Multisampled textures not implemented.\n");
 330
 331     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
 332     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 333     wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
 334     wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
 335     wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
 336     wined3d_desc.pool = WINED3D_POOL_DEFAULT;
 337     wined3d_desc.width = desc->Width;
 338     wined3d_desc.height = desc->Height;
 339     wined3d_desc.depth = 1;
 340     wined3d_desc.size = 0;
 341
 342     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
 343
 344     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 345             levels, 0, (struct wined3d_sub_resource_data *)data, texture,
 346             &d3d10_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
 347     {
 348         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 349         wined3d_private_store_cleanup(&texture->private_store);
 350         wined3d_mutex_unlock();
 351         return hr;
 352     }
 353     texture->desc.MipLevels = levels;
 354
 355     if (desc->MipLevels == 1 && desc->ArraySize == 1)
 356     {
 357         IWineDXGIDevice *wine_device;
 358
 359         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
 360                 (void **)&wine_device)))
 361         {
 362             ERR("Device should implement IWineDXGIDevice.\n");
 363             wined3d_texture_decref(texture->wined3d_texture);
 364             wined3d_mutex_unlock();
 365             return E_FAIL;
 366         }
 367
 368         hr = IWineDXGIDevice_create_surface(wine_device, wined3d_texture_get_resource(texture->wined3d_texture),
 369                 0, NULL, (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
 370         IWineDXGIDevice_Release(wine_device);
 371         if (FAILED(hr))
 372         {
 373             ERR("Failed to create DXGI surface, returning %#x\n", hr);
 374             texture->dxgi_surface = NULL;
 375             wined3d_texture_decref(texture->wined3d_texture);
 376             wined3d_mutex_unlock();
 377             return hr;
 378         }
 379     }
 380     wined3d_mutex_unlock();
 381
 382     texture->device = &device->ID3D10Device1_iface;
 383     ID3D10Device1_AddRef(texture->device);
 384
 385     return S_OK;
 386 }
 387
 388 static inline struct d3d10_texture3d *impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
 389 {
 390     return CONTAINING_RECORD(iface, struct d3d10_texture3d, ID3D10Texture3D_iface);
 391 }
 392
 393 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_QueryInterface(ID3D10Texture3D *iface, REFIID riid, void **object)
 394 {
 395     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 396
 397     if (IsEqualGUID(riid, &IID_ID3D10Texture3D)
 398             || IsEqualGUID(riid, &IID_ID3D10Resource)
 399             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 400             || IsEqualGUID(riid, &IID_IUnknown))
 401     {
 402         IUnknown_AddRef(iface);
 403         *object = iface;
 404         return S_OK;
 405     }
 406
 407     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 408
 409     *object = NULL;
 410     return E_NOINTERFACE;
 411 }
 412
 413 static ULONG STDMETHODCALLTYPE d3d10_texture3d_AddRef(ID3D10Texture3D *iface)
 414 {
 415     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 416     ULONG refcount = InterlockedIncrement(&texture->refcount);
 417
 418     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 419
 420     if (refcount == 1)
 421     {
 422         ID3D10Device1_AddRef(texture->device);
 423         wined3d_mutex_lock();
 424         wined3d_texture_incref(texture->wined3d_texture);
 425         wined3d_mutex_unlock();
 426     }
 427
 428     return refcount;
 429 }
 430
 431 static void STDMETHODCALLTYPE d3d10_texture3d_wined3d_object_released(void *parent)
 432 {
 433     struct d3d10_texture3d *texture = parent;
 434
 435     wined3d_private_store_cleanup(&texture->private_store);
 436     HeapFree(GetProcessHeap(), 0, parent);
 437 }
 438
 439 static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
 440 {
 441     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 442     ULONG refcount = InterlockedDecrement(&texture->refcount);
 443
 444     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 445
 446     if (!refcount)
 447     {
 448         ID3D10Device1 *device = texture->device;
 449
 450         wined3d_mutex_lock();
 451         wined3d_texture_decref(texture->wined3d_texture);
 452         wined3d_mutex_unlock();
 453         /* Release the device last, it may cause the wined3d device to be
 454          * destroyed. */
 455         ID3D10Device1_Release(device);
 456     }
 457
 458     return refcount;
 459 }
 460
 461 static void STDMETHODCALLTYPE d3d10_texture3d_GetDevice(ID3D10Texture3D *iface, ID3D10Device **device)
 462 {
 463     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 464
 465     TRACE("iface %p, device %p.\n", iface, device);
 466
 467     *device = (ID3D10Device *)texture->device;
 468     ID3D10Device_AddRef(*device);
 469 }
 470
 471 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_GetPrivateData(ID3D10Texture3D *iface,
 472         REFGUID guid, UINT *data_size, void *data)
 473 {
 474     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 475
 476     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 477             iface, debugstr_guid(guid), data_size, data);
 478
 479     return d3d10_get_private_data(&texture->private_store, guid, data_size, data);
 480 }
 481
 482 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateData(ID3D10Texture3D *iface,
 483         REFGUID guid, UINT data_size, const void *data)
 484 {
 485     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 486
 487     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 488             iface, debugstr_guid(guid), data_size, data);
 489
 490     return d3d10_set_private_data(&texture->private_store, guid, data_size, data);
 491 }
 492
 493 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateDataInterface(ID3D10Texture3D *iface,
 494         REFGUID guid, const IUnknown *data)
 495 {
 496     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 497
 498     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 499
 500     return d3d10_set_private_data_interface(&texture->private_store, guid, data);
 501 }
 502
 503 static void STDMETHODCALLTYPE d3d10_texture3d_GetType(ID3D10Texture3D *iface,
 504         D3D10_RESOURCE_DIMENSION *resource_dimension)
 505 {
 506     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 507
 508     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE3D;
 509 }
 510
 511 static void STDMETHODCALLTYPE d3d10_texture3d_SetEvictionPriority(ID3D10Texture3D *iface, UINT eviction_priority)
 512 {
 513     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 514 }
 515
 516 static UINT STDMETHODCALLTYPE d3d10_texture3d_GetEvictionPriority(ID3D10Texture3D *iface)
 517 {
 518     FIXME("iface %p stub!\n", iface);
 519
 520     return 0;
 521 }
 522
 523 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
 524         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
 525 {
 526     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 527     struct wined3d_map_desc wined3d_map_desc;
 528     struct wined3d_resource *sub_resource;
 529     HRESULT hr;
 530
 531     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 532             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 533
 534     if (map_flags)
 535         FIXME("Ignoring map_flags %#x.\n", map_flags);
 536
 537     wined3d_mutex_lock();
 538     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 539         hr = E_INVALIDARG;
 540     else if (SUCCEEDED(hr = wined3d_volume_map(wined3d_volume_from_resource(sub_resource),
 541             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 542     {
 543         mapped_texture->pData = wined3d_map_desc.data;
 544         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 545         mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
 546     }
 547     wined3d_mutex_unlock();
 548
 549     return hr;
 550 }
 551
 552 static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx)
 553 {
 554     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 555     struct wined3d_resource *sub_resource;
 556
 557     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 558
 559     wined3d_mutex_lock();
 560     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 561     {
 562         wined3d_mutex_unlock();
 563         return;
 564     }
 565
 566     wined3d_volume_unmap(wined3d_volume_from_resource(sub_resource));
 567     wined3d_mutex_unlock();
 568 }
 569
 570 static void STDMETHODCALLTYPE d3d10_texture3d_GetDesc(ID3D10Texture3D *iface, D3D10_TEXTURE3D_DESC *desc)
 571 {
 572     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 573
 574     TRACE("iface %p, desc %p.\n", iface, desc);
 575
 576     *desc = texture->desc;
 577 }
 578
 579 static const struct ID3D10Texture3DVtbl d3d10_texture3d_vtbl =
 580 {
 581     /* IUnknown methods */
 582     d3d10_texture3d_QueryInterface,
 583     d3d10_texture3d_AddRef,
 584     d3d10_texture3d_Release,
 585     /* ID3D10DeviceChild methods */
 586     d3d10_texture3d_GetDevice,
 587     d3d10_texture3d_GetPrivateData,
 588     d3d10_texture3d_SetPrivateData,
 589     d3d10_texture3d_SetPrivateDataInterface,
 590     /* ID3D10Resource methods */
 591     d3d10_texture3d_GetType,
 592     d3d10_texture3d_SetEvictionPriority,
 593     d3d10_texture3d_GetEvictionPriority,
 594     /* ID3D10Texture3D methods */
 595     d3d10_texture3d_Map,
 596     d3d10_texture3d_Unmap,
 597     d3d10_texture3d_GetDesc,
 598 };
 599
 600 static const struct wined3d_parent_ops d3d10_texture3d_wined3d_parent_ops =
 601 {
 602     d3d10_texture3d_wined3d_object_released,
 603 };
 604
 605 HRESULT d3d10_texture3d_init(struct d3d10_texture3d *texture, struct d3d10_device *device,
 606         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data)
 607 {
 608     struct wined3d_resource_desc wined3d_desc;
 609     unsigned int levels;
 610     HRESULT hr;
 611
 612     texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
 613     texture->refcount = 1;
 614     wined3d_mutex_lock();
 615     wined3d_private_store_init(&texture->private_store);
 616     texture->desc = *desc;
 617
 618     wined3d_desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE;
 619     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 620     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
 621     wined3d_desc.multisample_quality = 0;
 622     wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
 623     wined3d_desc.pool = WINED3D_POOL_DEFAULT;
 624     wined3d_desc.width = desc->Width;
 625     wined3d_desc.height = desc->Height;
 626     wined3d_desc.depth = desc->Depth;
 627     wined3d_desc.size = 0;
 628
 629     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(max(desc->Width, desc->Height), desc->Depth)) + 1;
 630
 631     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 632             levels, 0, (struct wined3d_sub_resource_data *)data, texture,
 633             &d3d10_texture3d_wined3d_parent_ops, &texture->wined3d_texture)))
 634     {
 635         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 636         wined3d_private_store_cleanup(&texture->private_store);
 637         wined3d_mutex_unlock();
 638         return hr;
 639     }
 640     wined3d_mutex_unlock();
 641     texture->desc.MipLevels = levels;
 642
 643     texture->device = &device->ID3D10Device1_iface;
 644     ID3D10Device1_AddRef(texture->device);
 645
 646     return S_OK;
 647 }