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 /* ID3D11Texture2D methods */
  28
  29 static inline struct d3d10_texture2d *impl_from_ID3D11Texture2D(ID3D11Texture2D *iface)
  30 {
  31     return CONTAINING_RECORD(iface, struct d3d10_texture2d, ID3D11Texture2D_iface);
  32 }
  33
  34 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_QueryInterface(ID3D11Texture2D *iface, REFIID riid, void **object)
  35 {
  36     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  37
  38     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  39
  40     if (IsEqualGUID(riid, &IID_ID3D11Texture2D)
  41             || IsEqualGUID(riid, &IID_ID3D11Resource)
  42             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
  43             || IsEqualGUID(riid, &IID_IUnknown))
  44     {
  45         *object = &texture->ID3D11Texture2D_iface;
  46         IUnknown_AddRef((IUnknown *)*object);
  47         return S_OK;
  48     }
  49     else if (IsEqualGUID(riid, &IID_ID3D10Texture2D)
  50             || IsEqualGUID(riid, &IID_ID3D10Resource)
  51             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
  52     {
  53         *object = &texture->ID3D10Texture2D_iface;
  54         IUnknown_AddRef((IUnknown *)*object);
  55         return S_OK;
  56     }
  57
  58     if (texture->dxgi_surface)
  59     {
  60         TRACE("Forwarding to dxgi surface.\n");
  61         return IUnknown_QueryInterface(texture->dxgi_surface, riid, object);
  62     }
  63
  64     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  65
  66     *object = NULL;
  67     return E_NOINTERFACE;
  68 }
  69
  70 static ULONG STDMETHODCALLTYPE d3d11_texture2d_AddRef(ID3D11Texture2D *iface)
  71 {
  72     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  73     ULONG refcount = InterlockedIncrement(&texture->refcount);
  74
  75     TRACE("%p increasing refcount to %u.\n", texture, refcount);
  76
  77     if (refcount == 1)
  78     {
  79         ID3D11Device_AddRef(texture->device);
  80         wined3d_mutex_lock();
  81         wined3d_texture_incref(texture->wined3d_texture);
  82         wined3d_mutex_unlock();
  83     }
  84
  85     return refcount;
  86 }
  87
  88 static ULONG STDMETHODCALLTYPE d3d11_texture2d_Release(ID3D11Texture2D *iface)
  89 {
  90     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
  91     ULONG refcount = InterlockedDecrement(&texture->refcount);
  92
  93     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
  94
  95     if (!refcount)
  96     {
  97         ID3D11Device *device = texture->device;
  98
  99         wined3d_mutex_lock();
 100         wined3d_texture_decref(texture->wined3d_texture);
 101         wined3d_mutex_unlock();
 102         /* Release the device last, it may cause the wined3d device to be
 103          * destroyed. */
 104         ID3D11Device_Release(device);
 105     }
 106
 107     return refcount;
 108 }
 109
 110 static void STDMETHODCALLTYPE d3d11_texture2d_GetDevice(ID3D11Texture2D *iface, ID3D11Device **device)
 111 {
 112     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 113
 114     TRACE("iface %p, device %p.\n", iface, device);
 115
 116     *device = texture->device;
 117     ID3D11Device_AddRef(*device);
 118 }
 119
 120 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_GetPrivateData(ID3D11Texture2D *iface,
 121         REFGUID guid, UINT *data_size, void *data)
 122 {
 123     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 124     IDXGISurface *dxgi_surface;
 125     HRESULT hr;
 126
 127     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 128
 129     if (texture->dxgi_surface
 130             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 131     {
 132         hr = IDXGISurface_GetPrivateData(dxgi_surface, guid, data_size, data);
 133         IDXGISurface_Release(dxgi_surface);
 134         return hr;
 135     }
 136
 137     return d3d10_get_private_data(&texture->private_store, guid, data_size, data);
 138 }
 139
 140 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateData(ID3D11Texture2D *iface,
 141         REFGUID guid, UINT data_size, const void *data)
 142 {
 143     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 144     IDXGISurface *dxgi_surface;
 145     HRESULT hr;
 146
 147     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 148
 149     if (texture->dxgi_surface
 150             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 151     {
 152         hr = IDXGISurface_SetPrivateData(dxgi_surface, guid, data_size, data);
 153         IDXGISurface_Release(dxgi_surface);
 154         return hr;
 155     }
 156
 157     return d3d10_set_private_data(&texture->private_store, guid, data_size, data);
 158 }
 159
 160 static HRESULT STDMETHODCALLTYPE d3d11_texture2d_SetPrivateDataInterface(ID3D11Texture2D *iface,
 161         REFGUID guid, const IUnknown *data)
 162 {
 163     struct d3d10_texture2d *texture = impl_from_ID3D11Texture2D(iface);
 164     IDXGISurface *dxgi_surface;
 165     HRESULT hr;
 166
 167     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 168
 169     if (texture->dxgi_surface
 170             && SUCCEEDED(IUnknown_QueryInterface(texture->dxgi_surface, &IID_IDXGISurface, (void **)&dxgi_surface)))
 171     {
 172         hr = IDXGISurface_SetPrivateDataInterface(dxgi_surface, guid, data);
 173         IDXGISurface_Release(dxgi_surface);
 174         return hr;
 175     }
 176
 177     return d3d10_set_private_data_interface(&texture->private_store, guid, data);
 178 }
 179
 180 static void STDMETHODCALLTYPE d3d11_texture2d_GetType(ID3D11Texture2D *iface,
 181         D3D11_RESOURCE_DIMENSION *resource_dimension)
 182 {
 183     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 184
 185     *resource_dimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D;
 186 }
 187
 188 static void STDMETHODCALLTYPE d3d11_texture2d_SetEvictionPriority(ID3D11Texture2D *iface, UINT eviction_priority)
 189 {
 190     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 191 }
 192
 193 static UINT STDMETHODCALLTYPE d3d11_texture2d_GetEvictionPriority(ID3D11Texture2D *iface)
 194 {
 195     FIXME("iface %p stub!\n", iface);
 196
 197     return 0;
 198 }
 199
 200 static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc)
 201 {
 202     FIXME("iface %p, desc %p stub!\n", iface, desc);
 203 }
 204
 205 static const struct ID3D11Texture2DVtbl d3d11_texture2d_vtbl =
 206 {
 207     /* IUnknown methods */
 208     d3d11_texture2d_QueryInterface,
 209     d3d11_texture2d_AddRef,
 210     d3d11_texture2d_Release,
 211     /* ID3D11DeviceChild methods */
 212     d3d11_texture2d_GetDevice,
 213     d3d11_texture2d_GetPrivateData,
 214     d3d11_texture2d_SetPrivateData,
 215     d3d11_texture2d_SetPrivateDataInterface,
 216     /* ID3D11Resource methods */
 217     d3d11_texture2d_GetType,
 218     d3d11_texture2d_SetEvictionPriority,
 219     d3d11_texture2d_GetEvictionPriority,
 220     /* ID3D11Texture2D methods */
 221     d3d11_texture2d_GetDesc,
 222 };
 223
 224 /* IUnknown methods */
 225
 226 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_QueryInterface(ID3D10Texture2D *iface, REFIID riid, void **object)
 227 {
 228     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 229
 230     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 231
 232     return d3d11_texture2d_QueryInterface(&texture->ID3D11Texture2D_iface, riid, object);
 233 }
 234
 235 static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
 236 {
 237     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 238
 239     TRACE("iface %p.\n", iface);
 240
 241     return d3d11_texture2d_AddRef(&texture->ID3D11Texture2D_iface);
 242 }
 243
 244 static void STDMETHODCALLTYPE d3d10_texture2d_wined3d_object_released(void *parent)
 245 {
 246     struct d3d10_texture2d *This = parent;
 247
 248     if (This->dxgi_surface) IUnknown_Release(This->dxgi_surface);
 249     wined3d_private_store_cleanup(&This->private_store);
 250     HeapFree(GetProcessHeap(), 0, This);
 251 }
 252
 253 static ULONG STDMETHODCALLTYPE d3d10_texture2d_Release(ID3D10Texture2D *iface)
 254 {
 255     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 256
 257     TRACE("iface %p.\n", iface);
 258
 259     return d3d11_texture2d_Release(&texture->ID3D11Texture2D_iface);
 260 }
 261
 262 /* ID3D10DeviceChild methods */
 263
 264 static void STDMETHODCALLTYPE d3d10_texture2d_GetDevice(ID3D10Texture2D *iface, ID3D10Device **device)
 265 {
 266     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 267
 268     TRACE("iface %p, device %p.\n", iface, device);
 269
 270     ID3D11Device_QueryInterface(texture->device, &IID_ID3D10Device, (void **)device);
 271 }
 272
 273 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_GetPrivateData(ID3D10Texture2D *iface,
 274         REFGUID guid, UINT *data_size, void *data)
 275 {
 276     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 277
 278     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 279
 280     return d3d11_texture2d_GetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 281 }
 282
 283 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateData(ID3D10Texture2D *iface,
 284         REFGUID guid, UINT data_size, const void *data)
 285 {
 286     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 287
 288     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 289
 290     return d3d11_texture2d_SetPrivateData(&texture->ID3D11Texture2D_iface, guid, data_size, data);
 291 }
 292
 293 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_SetPrivateDataInterface(ID3D10Texture2D *iface,
 294         REFGUID guid, const IUnknown *data)
 295 {
 296     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 297
 298     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 299
 300     return d3d11_texture2d_SetPrivateDataInterface(&texture->ID3D11Texture2D_iface, guid, data);
 301 }
 302
 303 /* ID3D10Resource methods */
 304
 305 static void STDMETHODCALLTYPE d3d10_texture2d_GetType(ID3D10Texture2D *iface,
 306         D3D10_RESOURCE_DIMENSION *resource_dimension)
 307 {
 308     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 309
 310     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE2D;
 311 }
 312
 313 static void STDMETHODCALLTYPE d3d10_texture2d_SetEvictionPriority(ID3D10Texture2D *iface, UINT eviction_priority)
 314 {
 315     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 316 }
 317
 318 static UINT STDMETHODCALLTYPE d3d10_texture2d_GetEvictionPriority(ID3D10Texture2D *iface)
 319 {
 320     FIXME("iface %p stub!\n", iface);
 321
 322     return 0;
 323 }
 324
 325 /* ID3D10Texture2D methods */
 326
 327 static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx,
 328         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture)
 329 {
 330     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 331     struct wined3d_map_desc wined3d_map_desc;
 332     struct wined3d_resource *sub_resource;
 333     HRESULT hr;
 334
 335     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 336             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 337
 338     if (map_flags)
 339         FIXME("Ignoring map_flags %#x.\n", map_flags);
 340
 341     wined3d_mutex_lock();
 342     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 343         hr = E_INVALIDARG;
 344     else if (SUCCEEDED(hr = wined3d_surface_map(wined3d_surface_from_resource(sub_resource),
 345             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 346     {
 347         mapped_texture->pData = wined3d_map_desc.data;
 348         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 349     }
 350     wined3d_mutex_unlock();
 351
 352     return hr;
 353 }
 354
 355 static void STDMETHODCALLTYPE d3d10_texture2d_Unmap(ID3D10Texture2D *iface, UINT sub_resource_idx)
 356 {
 357     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 358     struct wined3d_resource *sub_resource;
 359
 360     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 361
 362     wined3d_mutex_lock();
 363     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 364     {
 365         wined3d_mutex_unlock();
 366         return;
 367     }
 368
 369     wined3d_surface_unmap(wined3d_surface_from_resource(sub_resource));
 370     wined3d_mutex_unlock();
 371 }
 372
 373 static void STDMETHODCALLTYPE d3d10_texture2d_GetDesc(ID3D10Texture2D *iface, D3D10_TEXTURE2D_DESC *desc)
 374 {
 375     struct d3d10_texture2d *texture = impl_from_ID3D10Texture2D(iface);
 376     struct wined3d_resource_desc wined3d_desc;
 377
 378     TRACE("iface %p, desc %p\n", iface, desc);
 379
 380     *desc = texture->desc;
 381
 382     wined3d_mutex_lock();
 383     wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc);
 384     wined3d_mutex_unlock();
 385
 386     /* FIXME: Resizing swapchain buffers can cause these to change. We'd like
 387      * to get everything from wined3d, but e.g. bind flags don't exist as such
 388      * there (yet). */
 389     desc->Width = wined3d_desc.width;
 390     desc->Height = wined3d_desc.height;
 391     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format);
 392     desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE
 393             ? 1 : wined3d_desc.multisample_type;
 394     desc->SampleDesc.Quality = wined3d_desc.multisample_quality;
 395 }
 396
 397 static const struct ID3D10Texture2DVtbl d3d10_texture2d_vtbl =
 398 {
 399     /* IUnknown methods */
 400     d3d10_texture2d_QueryInterface,
 401     d3d10_texture2d_AddRef,
 402     d3d10_texture2d_Release,
 403     /* ID3D10DeviceChild methods */
 404     d3d10_texture2d_GetDevice,
 405     d3d10_texture2d_GetPrivateData,
 406     d3d10_texture2d_SetPrivateData,
 407     d3d10_texture2d_SetPrivateDataInterface,
 408     /* ID3D10Resource methods */
 409     d3d10_texture2d_GetType,
 410     d3d10_texture2d_SetEvictionPriority,
 411     d3d10_texture2d_GetEvictionPriority,
 412     /* ID3D10Texture2D methods */
 413     d3d10_texture2d_Map,
 414     d3d10_texture2d_Unmap,
 415     d3d10_texture2d_GetDesc,
 416 };
 417
 418 struct d3d10_texture2d *unsafe_impl_from_ID3D10Texture2D(ID3D10Texture2D *iface)
 419 {
 420     if (!iface)
 421         return NULL;
 422     assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
 423     return CONTAINING_RECORD(iface, struct d3d10_texture2d, ID3D10Texture2D_iface);
 424 }
 425
 426 static const struct wined3d_parent_ops d3d10_texture2d_wined3d_parent_ops =
 427 {
 428     d3d10_texture2d_wined3d_object_released,
 429 };
 430
 431 HRESULT d3d10_texture2d_init(struct d3d10_texture2d *texture, struct d3d_device *device,
 432         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data)
 433 {
 434     struct wined3d_resource_desc wined3d_desc;
 435     unsigned int levels;
 436     HRESULT hr;
 437
 438     texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
 439     texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
 440     texture->refcount = 1;
 441     wined3d_mutex_lock();
 442     wined3d_private_store_init(&texture->private_store);
 443     texture->desc = *desc;
 444
 445     if (desc->ArraySize != 1)
 446         FIXME("Array textures not implemented.\n");
 447     if (desc->SampleDesc.Count > 1)
 448         FIXME("Multisampled textures not implemented.\n");
 449
 450     wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
 451     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 452     wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
 453     wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
 454     wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
 455     wined3d_desc.pool = WINED3D_POOL_DEFAULT;
 456     wined3d_desc.width = desc->Width;
 457     wined3d_desc.height = desc->Height;
 458     wined3d_desc.depth = 1;
 459     wined3d_desc.size = 0;
 460
 461     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
 462
 463     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 464             levels, 0, (struct wined3d_sub_resource_data *)data, texture,
 465             &d3d10_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
 466     {
 467         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 468         wined3d_private_store_cleanup(&texture->private_store);
 469         wined3d_mutex_unlock();
 470         return hr;
 471     }
 472     texture->desc.MipLevels = levels;
 473
 474     if (desc->MipLevels == 1 && desc->ArraySize == 1)
 475     {
 476         IWineDXGIDevice *wine_device;
 477
 478         if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
 479                 (void **)&wine_device)))
 480         {
 481             ERR("Device should implement IWineDXGIDevice.\n");
 482             wined3d_texture_decref(texture->wined3d_texture);
 483             wined3d_mutex_unlock();
 484             return E_FAIL;
 485         }
 486
 487         hr = IWineDXGIDevice_create_surface(wine_device, wined3d_texture_get_resource(texture->wined3d_texture),
 488                 0, NULL, (IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
 489         IWineDXGIDevice_Release(wine_device);
 490         if (FAILED(hr))
 491         {
 492             ERR("Failed to create DXGI surface, returning %#x\n", hr);
 493             texture->dxgi_surface = NULL;
 494             wined3d_texture_decref(texture->wined3d_texture);
 495             wined3d_mutex_unlock();
 496             return hr;
 497         }
 498     }
 499     wined3d_mutex_unlock();
 500
 501     texture->device = &device->ID3D11Device_iface;
 502     ID3D11Device_AddRef(texture->device);
 503
 504     return S_OK;
 505 }
 506
 507 static inline struct d3d10_texture3d *impl_from_ID3D10Texture3D(ID3D10Texture3D *iface)
 508 {
 509     return CONTAINING_RECORD(iface, struct d3d10_texture3d, ID3D10Texture3D_iface);
 510 }
 511
 512 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_QueryInterface(ID3D10Texture3D *iface, REFIID riid, void **object)
 513 {
 514     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 515
 516     if (IsEqualGUID(riid, &IID_ID3D10Texture3D)
 517             || IsEqualGUID(riid, &IID_ID3D10Resource)
 518             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 519             || IsEqualGUID(riid, &IID_IUnknown))
 520     {
 521         IUnknown_AddRef(iface);
 522         *object = iface;
 523         return S_OK;
 524     }
 525
 526     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 527
 528     *object = NULL;
 529     return E_NOINTERFACE;
 530 }
 531
 532 static ULONG STDMETHODCALLTYPE d3d10_texture3d_AddRef(ID3D10Texture3D *iface)
 533 {
 534     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 535     ULONG refcount = InterlockedIncrement(&texture->refcount);
 536
 537     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 538
 539     if (refcount == 1)
 540     {
 541         ID3D10Device1_AddRef(texture->device);
 542         wined3d_mutex_lock();
 543         wined3d_texture_incref(texture->wined3d_texture);
 544         wined3d_mutex_unlock();
 545     }
 546
 547     return refcount;
 548 }
 549
 550 static void STDMETHODCALLTYPE d3d10_texture3d_wined3d_object_released(void *parent)
 551 {
 552     struct d3d10_texture3d *texture = parent;
 553
 554     wined3d_private_store_cleanup(&texture->private_store);
 555     HeapFree(GetProcessHeap(), 0, parent);
 556 }
 557
 558 static ULONG STDMETHODCALLTYPE d3d10_texture3d_Release(ID3D10Texture3D *iface)
 559 {
 560     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 561     ULONG refcount = InterlockedDecrement(&texture->refcount);
 562
 563     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 564
 565     if (!refcount)
 566     {
 567         ID3D10Device1 *device = texture->device;
 568
 569         wined3d_mutex_lock();
 570         wined3d_texture_decref(texture->wined3d_texture);
 571         wined3d_mutex_unlock();
 572         /* Release the device last, it may cause the wined3d device to be
 573          * destroyed. */
 574         ID3D10Device1_Release(device);
 575     }
 576
 577     return refcount;
 578 }
 579
 580 static void STDMETHODCALLTYPE d3d10_texture3d_GetDevice(ID3D10Texture3D *iface, ID3D10Device **device)
 581 {
 582     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 583
 584     TRACE("iface %p, device %p.\n", iface, device);
 585
 586     *device = (ID3D10Device *)texture->device;
 587     ID3D10Device_AddRef(*device);
 588 }
 589
 590 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_GetPrivateData(ID3D10Texture3D *iface,
 591         REFGUID guid, UINT *data_size, void *data)
 592 {
 593     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 594
 595     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 596             iface, debugstr_guid(guid), data_size, data);
 597
 598     return d3d10_get_private_data(&texture->private_store, guid, data_size, data);
 599 }
 600
 601 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateData(ID3D10Texture3D *iface,
 602         REFGUID guid, UINT data_size, const void *data)
 603 {
 604     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 605
 606     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 607             iface, debugstr_guid(guid), data_size, data);
 608
 609     return d3d10_set_private_data(&texture->private_store, guid, data_size, data);
 610 }
 611
 612 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_SetPrivateDataInterface(ID3D10Texture3D *iface,
 613         REFGUID guid, const IUnknown *data)
 614 {
 615     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 616
 617     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 618
 619     return d3d10_set_private_data_interface(&texture->private_store, guid, data);
 620 }
 621
 622 static void STDMETHODCALLTYPE d3d10_texture3d_GetType(ID3D10Texture3D *iface,
 623         D3D10_RESOURCE_DIMENSION *resource_dimension)
 624 {
 625     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 626
 627     *resource_dimension = D3D10_RESOURCE_DIMENSION_TEXTURE3D;
 628 }
 629
 630 static void STDMETHODCALLTYPE d3d10_texture3d_SetEvictionPriority(ID3D10Texture3D *iface, UINT eviction_priority)
 631 {
 632     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 633 }
 634
 635 static UINT STDMETHODCALLTYPE d3d10_texture3d_GetEvictionPriority(ID3D10Texture3D *iface)
 636 {
 637     FIXME("iface %p stub!\n", iface);
 638
 639     return 0;
 640 }
 641
 642 static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
 643         D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
 644 {
 645     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 646     struct wined3d_map_desc wined3d_map_desc;
 647     struct wined3d_resource *sub_resource;
 648     HRESULT hr;
 649
 650     TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
 651             iface, sub_resource_idx, map_type, map_flags, mapped_texture);
 652
 653     if (map_flags)
 654         FIXME("Ignoring map_flags %#x.\n", map_flags);
 655
 656     wined3d_mutex_lock();
 657     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 658         hr = E_INVALIDARG;
 659     else if (SUCCEEDED(hr = wined3d_volume_map(wined3d_volume_from_resource(sub_resource),
 660             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type))))
 661     {
 662         mapped_texture->pData = wined3d_map_desc.data;
 663         mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
 664         mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
 665     }
 666     wined3d_mutex_unlock();
 667
 668     return hr;
 669 }
 670
 671 static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx)
 672 {
 673     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 674     struct wined3d_resource *sub_resource;
 675
 676     TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx);
 677
 678     wined3d_mutex_lock();
 679     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 680     {
 681         wined3d_mutex_unlock();
 682         return;
 683     }
 684
 685     wined3d_volume_unmap(wined3d_volume_from_resource(sub_resource));
 686     wined3d_mutex_unlock();
 687 }
 688
 689 static void STDMETHODCALLTYPE d3d10_texture3d_GetDesc(ID3D10Texture3D *iface, D3D10_TEXTURE3D_DESC *desc)
 690 {
 691     struct d3d10_texture3d *texture = impl_from_ID3D10Texture3D(iface);
 692
 693     TRACE("iface %p, desc %p.\n", iface, desc);
 694
 695     *desc = texture->desc;
 696 }
 697
 698 static const struct ID3D10Texture3DVtbl d3d10_texture3d_vtbl =
 699 {
 700     /* IUnknown methods */
 701     d3d10_texture3d_QueryInterface,
 702     d3d10_texture3d_AddRef,
 703     d3d10_texture3d_Release,
 704     /* ID3D10DeviceChild methods */
 705     d3d10_texture3d_GetDevice,
 706     d3d10_texture3d_GetPrivateData,
 707     d3d10_texture3d_SetPrivateData,
 708     d3d10_texture3d_SetPrivateDataInterface,
 709     /* ID3D10Resource methods */
 710     d3d10_texture3d_GetType,
 711     d3d10_texture3d_SetEvictionPriority,
 712     d3d10_texture3d_GetEvictionPriority,
 713     /* ID3D10Texture3D methods */
 714     d3d10_texture3d_Map,
 715     d3d10_texture3d_Unmap,
 716     d3d10_texture3d_GetDesc,
 717 };
 718
 719 static const struct wined3d_parent_ops d3d10_texture3d_wined3d_parent_ops =
 720 {
 721     d3d10_texture3d_wined3d_object_released,
 722 };
 723
 724 HRESULT d3d10_texture3d_init(struct d3d10_texture3d *texture, struct d3d_device *device,
 725         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data)
 726 {
 727     struct wined3d_resource_desc wined3d_desc;
 728     unsigned int levels;
 729     HRESULT hr;
 730
 731     texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
 732     texture->refcount = 1;
 733     wined3d_mutex_lock();
 734     wined3d_private_store_init(&texture->private_store);
 735     texture->desc = *desc;
 736
 737     wined3d_desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE;
 738     wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
 739     wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
 740     wined3d_desc.multisample_quality = 0;
 741     wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
 742     wined3d_desc.pool = WINED3D_POOL_DEFAULT;
 743     wined3d_desc.width = desc->Width;
 744     wined3d_desc.height = desc->Height;
 745     wined3d_desc.depth = desc->Depth;
 746     wined3d_desc.size = 0;
 747
 748     levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(max(desc->Width, desc->Height), desc->Depth)) + 1;
 749
 750     if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
 751             levels, 0, (struct wined3d_sub_resource_data *)data, texture,
 752             &d3d10_texture3d_wined3d_parent_ops, &texture->wined3d_texture)))
 753     {
 754         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
 755         wined3d_private_store_cleanup(&texture->private_store);
 756         wined3d_mutex_unlock();
 757         return hr;
 758     }
 759     wined3d_mutex_unlock();
 760     texture->desc.MipLevels = levels;
 761
 762     texture->device = &device->ID3D10Device1_iface;
 763     ID3D10Device1_AddRef(texture->device);
 764
 765     return S_OK;
 766 }