dlls/d3d9/texture.c

   1 /*
   2  * Copyright 2002-2005 Jason Edmeades
   3  * Copyright 2002-2005 Raphael Junqueira
   4  * Copyright 2005 Oliver Stieber
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "d3d9_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
  25
  26 static inline struct d3d9_texture *impl_from_IDirect3DTexture9(IDirect3DTexture9 *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  29 }
  30
  31 static inline struct d3d9_texture *impl_from_IDirect3DCubeTexture9(IDirect3DCubeTexture9 *iface)
  32 {
  33     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  34 }
  35
  36 static inline struct d3d9_texture *impl_from_IDirect3DVolumeTexture9(IDirect3DVolumeTexture9 *iface)
  37 {
  38     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  39 }
  40
  41 static HRESULT WINAPI d3d9_texture_2d_QueryInterface(IDirect3DTexture9 *iface, REFIID riid, void **out)
  42 {
  43     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  44
  45     if (IsEqualGUID(riid, &IID_IDirect3DTexture9)
  46             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
  47             || IsEqualGUID(riid, &IID_IDirect3DResource9)
  48             || IsEqualGUID(riid, &IID_IUnknown))
  49     {
  50         IDirect3DTexture9_AddRef(iface);
  51         *out = iface;
  52         return S_OK;
  53     }
  54
  55     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  56
  57     *out = NULL;
  58     return E_NOINTERFACE;
  59 }
  60
  61 static ULONG WINAPI d3d9_texture_2d_AddRef(IDirect3DTexture9 *iface)
  62 {
  63     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
  64     ULONG ref = InterlockedIncrement(&texture->refcount);
  65
  66     TRACE("%p increasing refcount to %u.\n", iface, ref);
  67
  68     if (ref == 1)
  69     {
  70         IDirect3DDevice9Ex_AddRef(texture->parent_device);
  71         wined3d_mutex_lock();
  72         wined3d_texture_incref(texture->wined3d_texture);
  73         wined3d_mutex_unlock();
  74     }
  75
  76     return ref;
  77 }
  78
  79 static ULONG WINAPI d3d9_texture_2d_Release(IDirect3DTexture9 *iface)
  80 {
  81     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
  82     ULONG ref = InterlockedDecrement(&texture->refcount);
  83
  84     TRACE("%p decreasing refcount to %u.\n", iface, ref);
  85
  86     if (!ref)
  87     {
  88         IDirect3DDevice9Ex *parent_device = texture->parent_device;
  89
  90         wined3d_mutex_lock();
  91         wined3d_texture_decref(texture->wined3d_texture);
  92         wined3d_mutex_unlock();
  93
  94         /* Release the device last, as it may cause the device to be destroyed. */
  95         IDirect3DDevice9Ex_Release(parent_device);
  96     }
  97     return ref;
  98 }
  99
 100 static HRESULT WINAPI d3d9_texture_2d_GetDevice(IDirect3DTexture9 *iface, IDirect3DDevice9 **device)
 101 {
 102     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 103
 104     TRACE("iface %p, device %p.\n", iface, device);
 105
 106     *device = (IDirect3DDevice9 *)texture->parent_device;
 107     IDirect3DDevice9_AddRef(*device);
 108
 109     TRACE("Returning device %p.\n", *device);
 110
 111     return D3D_OK;
 112 }
 113
 114 static HRESULT WINAPI d3d9_texture_2d_SetPrivateData(IDirect3DTexture9 *iface,
 115         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 116 {
 117     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 118     struct wined3d_resource *resource;
 119     HRESULT hr;
 120
 121     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 122             iface, debugstr_guid(guid), data, data_size, flags);
 123
 124     wined3d_mutex_lock();
 125     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 126     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 127     wined3d_mutex_unlock();
 128
 129     return hr;
 130 }
 131
 132 static HRESULT WINAPI d3d9_texture_2d_GetPrivateData(IDirect3DTexture9 *iface,
 133         REFGUID guid, void *data, DWORD *data_size)
 134 {
 135     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 136     struct wined3d_resource *resource;
 137     HRESULT hr;
 138
 139     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 140             iface, debugstr_guid(guid), data, data_size);
 141
 142     wined3d_mutex_lock();
 143     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 144     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 145     wined3d_mutex_unlock();
 146
 147     return hr;
 148 }
 149
 150 static HRESULT WINAPI d3d9_texture_2d_FreePrivateData(IDirect3DTexture9 *iface, REFGUID guid)
 151 {
 152     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 153     struct wined3d_resource *resource;
 154     HRESULT hr;
 155
 156     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 157
 158     wined3d_mutex_lock();
 159     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 160     hr = wined3d_resource_free_private_data(resource, guid);
 161     wined3d_mutex_unlock();
 162
 163     return hr;
 164 }
 165
 166 static DWORD WINAPI d3d9_texture_2d_SetPriority(IDirect3DTexture9 *iface, DWORD priority)
 167 {
 168     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 169     DWORD ret;
 170
 171     TRACE("iface %p, priority %u.\n", iface, priority);
 172
 173     wined3d_mutex_lock();
 174     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 175     wined3d_mutex_unlock();
 176
 177     return ret;
 178 }
 179
 180 static DWORD WINAPI d3d9_texture_2d_GetPriority(IDirect3DTexture9 *iface)
 181 {
 182     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 183     DWORD ret;
 184
 185     TRACE("iface %p.\n", iface);
 186
 187     wined3d_mutex_lock();
 188     ret = wined3d_texture_get_priority(texture->wined3d_texture);
 189     wined3d_mutex_unlock();
 190
 191     return ret;
 192 }
 193
 194 static void WINAPI d3d9_texture_2d_PreLoad(IDirect3DTexture9 *iface)
 195 {
 196     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 197
 198     TRACE("iface %p.\n", iface);
 199
 200     wined3d_mutex_lock();
 201     wined3d_texture_preload(texture->wined3d_texture);
 202     wined3d_mutex_unlock();
 203 }
 204
 205 static D3DRESOURCETYPE WINAPI d3d9_texture_2d_GetType(IDirect3DTexture9 *iface)
 206 {
 207     TRACE("iface %p.\n", iface);
 208
 209     return D3DRTYPE_TEXTURE;
 210 }
 211
 212 static DWORD WINAPI d3d9_texture_2d_SetLOD(IDirect3DTexture9 *iface, DWORD lod)
 213 {
 214     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 215     DWORD ret;
 216
 217     TRACE("iface %p, lod %u.\n", iface, lod);
 218
 219     wined3d_mutex_lock();
 220     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 221     wined3d_mutex_unlock();
 222
 223     return ret;
 224 }
 225
 226 static DWORD WINAPI d3d9_texture_2d_GetLOD(IDirect3DTexture9 *iface)
 227 {
 228     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 229     DWORD ret;
 230
 231     TRACE("iface %p.\n", iface);
 232
 233     wined3d_mutex_lock();
 234     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 235     wined3d_mutex_unlock();
 236
 237     return ret;
 238 }
 239
 240 static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface)
 241 {
 242     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 243     DWORD ret;
 244
 245     TRACE("iface %p.\n", iface);
 246
 247     wined3d_mutex_lock();
 248     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 249     wined3d_mutex_unlock();
 250
 251     return ret;
 252 }
 253
 254 static HRESULT WINAPI d3d9_texture_2d_SetAutoGenFilterType(IDirect3DTexture9 *iface, D3DTEXTUREFILTERTYPE filter_type)
 255 {
 256     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 257     HRESULT hr;
 258
 259     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
 260
 261     wined3d_mutex_lock();
 262     hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
 263             (enum wined3d_texture_filter_type)filter_type);
 264     wined3d_mutex_unlock();
 265
 266     return hr;
 267 }
 268
 269 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_2d_GetAutoGenFilterType(IDirect3DTexture9 *iface)
 270 {
 271     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 272     D3DTEXTUREFILTERTYPE ret;
 273
 274     TRACE("iface %p.\n", iface);
 275
 276     wined3d_mutex_lock();
 277     ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
 278     wined3d_mutex_unlock();
 279
 280     return ret;
 281 }
 282
 283 static void WINAPI d3d9_texture_2d_GenerateMipSubLevels(IDirect3DTexture9 *iface)
 284 {
 285     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 286
 287     TRACE("iface %p.\n", iface);
 288
 289     wined3d_mutex_lock();
 290     wined3d_texture_generate_mipmaps(texture->wined3d_texture);
 291     wined3d_mutex_unlock();
 292 }
 293
 294 static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
 295 {
 296     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 297     struct wined3d_resource *sub_resource;
 298     HRESULT hr = D3D_OK;
 299
 300     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 301
 302     wined3d_mutex_lock();
 303     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 304         hr = D3DERR_INVALIDCALL;
 305     else
 306     {
 307         struct wined3d_resource_desc wined3d_desc;
 308
 309         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 310         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 311         desc->Type = wined3d_desc.resource_type;
 312         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 313         desc->Pool = wined3d_desc.pool;
 314         desc->MultiSampleType = wined3d_desc.multisample_type;
 315         desc->MultiSampleQuality = wined3d_desc.multisample_quality;
 316         desc->Width = wined3d_desc.width;
 317         desc->Height = wined3d_desc.height;
 318     }
 319     wined3d_mutex_unlock();
 320
 321     return hr;
 322 }
 323
 324 static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface,
 325         UINT level, IDirect3DSurface9 **surface)
 326 {
 327     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 328     struct wined3d_resource *sub_resource;
 329     IDirect3DSurface9Impl *surface_impl;
 330
 331     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
 332
 333     wined3d_mutex_lock();
 334     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 335     {
 336         wined3d_mutex_unlock();
 337         return D3DERR_INVALIDCALL;
 338     }
 339
 340     surface_impl = wined3d_resource_get_parent(sub_resource);
 341     *surface = &surface_impl->IDirect3DSurface9_iface;
 342     IDirect3DSurface9_AddRef(*surface);
 343     wined3d_mutex_unlock();
 344
 345     return D3D_OK;
 346 }
 347
 348 static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface,
 349         UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
 350 {
 351     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 352     struct wined3d_resource *sub_resource;
 353     IDirect3DSurface9Impl *surface_impl;
 354     HRESULT hr;
 355
 356     TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
 357             iface, level, locked_rect, rect, flags);
 358
 359     wined3d_mutex_lock();
 360     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 361         hr = D3DERR_INVALIDCALL;
 362     else
 363     {
 364         surface_impl = wined3d_resource_get_parent(sub_resource);
 365         hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
 366     }
 367     wined3d_mutex_unlock();
 368
 369     return hr;
 370 }
 371
 372 static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT level)
 373 {
 374     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 375     struct wined3d_resource *sub_resource;
 376     IDirect3DSurface9Impl *surface_impl;
 377     HRESULT hr;
 378
 379     TRACE("iface %p, level %u.\n", iface, level);
 380
 381     wined3d_mutex_lock();
 382     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 383         hr = D3DERR_INVALIDCALL;
 384     else
 385     {
 386         surface_impl = wined3d_resource_get_parent(sub_resource);
 387         hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
 388     }
 389     wined3d_mutex_unlock();
 390
 391     return hr;
 392 }
 393
 394 static HRESULT WINAPI d3d9_texture_2d_AddDirtyRect(IDirect3DTexture9 *iface, const RECT *dirty_rect)
 395 {
 396     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 397     HRESULT hr;
 398
 399     TRACE("iface %p, dirty_rect %s.\n",
 400             iface, wine_dbgstr_rect(dirty_rect));
 401
 402     wined3d_mutex_lock();
 403     if (!dirty_rect)
 404         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL);
 405     else
 406     {
 407         struct wined3d_box dirty_region;
 408
 409         dirty_region.left = dirty_rect->left;
 410         dirty_region.top = dirty_rect->top;
 411         dirty_region.right = dirty_rect->right;
 412         dirty_region.bottom = dirty_rect->bottom;
 413         dirty_region.front = 0;
 414         dirty_region.back = 1;
 415         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region);
 416     }
 417     wined3d_mutex_unlock();
 418
 419     return hr;
 420 }
 421
 422 static const IDirect3DTexture9Vtbl d3d9_texture_2d_vtbl =
 423 {
 424     /* IUnknown */
 425     d3d9_texture_2d_QueryInterface,
 426     d3d9_texture_2d_AddRef,
 427     d3d9_texture_2d_Release,
 428      /* IDirect3DResource9 */
 429     d3d9_texture_2d_GetDevice,
 430     d3d9_texture_2d_SetPrivateData,
 431     d3d9_texture_2d_GetPrivateData,
 432     d3d9_texture_2d_FreePrivateData,
 433     d3d9_texture_2d_SetPriority,
 434     d3d9_texture_2d_GetPriority,
 435     d3d9_texture_2d_PreLoad,
 436     d3d9_texture_2d_GetType,
 437     /* IDirect3dBaseTexture9 */
 438     d3d9_texture_2d_SetLOD,
 439     d3d9_texture_2d_GetLOD,
 440     d3d9_texture_2d_GetLevelCount,
 441     d3d9_texture_2d_SetAutoGenFilterType,
 442     d3d9_texture_2d_GetAutoGenFilterType,
 443     d3d9_texture_2d_GenerateMipSubLevels,
 444     /* IDirect3DTexture9 */
 445     d3d9_texture_2d_GetLevelDesc,
 446     d3d9_texture_2d_GetSurfaceLevel,
 447     d3d9_texture_2d_LockRect,
 448     d3d9_texture_2d_UnlockRect,
 449     d3d9_texture_2d_AddDirtyRect,
 450 };
 451
 452 static HRESULT WINAPI d3d9_texture_cube_QueryInterface(IDirect3DCubeTexture9 *iface, REFIID riid, void **out)
 453 {
 454     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 455
 456     if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)
 457             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 458             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 459             || IsEqualGUID(riid, &IID_IUnknown))
 460     {
 461         IDirect3DCubeTexture9_AddRef(iface);
 462         *out = iface;
 463         return S_OK;
 464     }
 465
 466     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 467
 468     *out = NULL;
 469     return E_NOINTERFACE;
 470 }
 471
 472 static ULONG WINAPI d3d9_texture_cube_AddRef(IDirect3DCubeTexture9 *iface)
 473 {
 474     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 475     ULONG ref = InterlockedIncrement(&texture->refcount);
 476
 477     TRACE("%p increasing refcount to %u.\n", iface, ref);
 478
 479     if (ref == 1)
 480     {
 481         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 482         wined3d_mutex_lock();
 483         wined3d_texture_incref(texture->wined3d_texture);
 484         wined3d_mutex_unlock();
 485     }
 486
 487     return ref;
 488 }
 489
 490 static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface)
 491 {
 492     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 493     ULONG ref = InterlockedDecrement(&texture->refcount);
 494
 495     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 496
 497     if (!ref)
 498     {
 499         IDirect3DDevice9Ex *parent_device = texture->parent_device;
 500
 501         TRACE("Releasing child %p.\n", texture->wined3d_texture);
 502
 503         wined3d_mutex_lock();
 504         wined3d_texture_decref(texture->wined3d_texture);
 505         wined3d_mutex_unlock();
 506
 507         /* Release the device last, as it may cause the device to be destroyed. */
 508         IDirect3DDevice9Ex_Release(parent_device);
 509     }
 510     return ref;
 511 }
 512
 513 static HRESULT WINAPI d3d9_texture_cube_GetDevice(IDirect3DCubeTexture9 *iface, IDirect3DDevice9 **device)
 514 {
 515     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 516
 517     TRACE("iface %p, device %p.\n", iface, device);
 518
 519     *device = (IDirect3DDevice9 *)texture->parent_device;
 520     IDirect3DDevice9_AddRef(*device);
 521
 522     TRACE("Returning device %p.\n", *device);
 523
 524     return D3D_OK;
 525 }
 526
 527 static HRESULT WINAPI d3d9_texture_cube_SetPrivateData(IDirect3DCubeTexture9 *iface,
 528         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 529 {
 530     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 531     struct wined3d_resource *resource;
 532     HRESULT hr;
 533
 534     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 535             iface, debugstr_guid(guid), data, data_size, flags);
 536
 537     wined3d_mutex_lock();
 538     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 539     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 540     wined3d_mutex_unlock();
 541
 542     return hr;
 543 }
 544
 545 static HRESULT WINAPI d3d9_texture_cube_GetPrivateData(IDirect3DCubeTexture9 *iface,
 546         REFGUID guid, void *data, DWORD *data_size)
 547 {
 548     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 549     struct wined3d_resource *resource;
 550     HRESULT hr;
 551
 552     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 553             iface, debugstr_guid(guid), data, data_size);
 554
 555     wined3d_mutex_lock();
 556     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 557     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 558     wined3d_mutex_unlock();
 559
 560     return hr;
 561 }
 562
 563 static HRESULT WINAPI d3d9_texture_cube_FreePrivateData(IDirect3DCubeTexture9 *iface, REFGUID guid)
 564 {
 565     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 566     struct wined3d_resource *resource;
 567     HRESULT hr;
 568
 569     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 570
 571     wined3d_mutex_lock();
 572     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 573     hr = wined3d_resource_free_private_data(resource, guid);
 574     wined3d_mutex_unlock();
 575
 576     return hr;
 577 }
 578
 579 static DWORD WINAPI d3d9_texture_cube_SetPriority(IDirect3DCubeTexture9 *iface, DWORD priority)
 580 {
 581     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 582     DWORD ret;
 583
 584     TRACE("iface %p, priority %u.\n", iface, priority);
 585
 586     wined3d_mutex_lock();
 587     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 588     wined3d_mutex_unlock();
 589
 590     return ret;
 591 }
 592
 593 static DWORD WINAPI d3d9_texture_cube_GetPriority(IDirect3DCubeTexture9 *iface)
 594 {
 595     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 596     DWORD ret;
 597
 598     TRACE("iface %p.\n", iface);
 599
 600     wined3d_mutex_lock();
 601     ret = wined3d_texture_get_priority(texture->wined3d_texture);
 602     wined3d_mutex_unlock();
 603
 604     return ret;
 605 }
 606
 607 static void WINAPI d3d9_texture_cube_PreLoad(IDirect3DCubeTexture9 *iface)
 608 {
 609     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 610
 611     TRACE("iface %p.\n", iface);
 612
 613     wined3d_mutex_lock();
 614     wined3d_texture_preload(texture->wined3d_texture);
 615     wined3d_mutex_unlock();
 616 }
 617
 618 static D3DRESOURCETYPE WINAPI d3d9_texture_cube_GetType(IDirect3DCubeTexture9 *iface)
 619 {
 620     TRACE("iface %p.\n", iface);
 621
 622     return D3DRTYPE_CUBETEXTURE;
 623 }
 624
 625 static DWORD WINAPI d3d9_texture_cube_SetLOD(IDirect3DCubeTexture9 *iface, DWORD lod)
 626 {
 627     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 628     DWORD ret;
 629
 630     TRACE("iface %p, lod %u.\n", iface, lod);
 631
 632     wined3d_mutex_lock();
 633     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 634     wined3d_mutex_unlock();
 635
 636     return ret;
 637 }
 638
 639 static DWORD WINAPI d3d9_texture_cube_GetLOD(IDirect3DCubeTexture9 *iface)
 640 {
 641     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 642     DWORD ret;
 643
 644     TRACE("iface %p.\n", iface);
 645
 646     wined3d_mutex_lock();
 647     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 648     wined3d_mutex_unlock();
 649
 650     return ret;
 651 }
 652
 653 static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface)
 654 {
 655     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 656     DWORD ret;
 657
 658     TRACE("iface %p.\n", iface);
 659
 660     wined3d_mutex_lock();
 661     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 662     wined3d_mutex_unlock();
 663
 664     return ret;
 665 }
 666
 667 static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTexture9 *iface,
 668         D3DTEXTUREFILTERTYPE filter_type)
 669 {
 670     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 671     HRESULT hr;
 672
 673     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
 674
 675     wined3d_mutex_lock();
 676     hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
 677             (enum wined3d_texture_filter_type)filter_type);
 678     wined3d_mutex_unlock();
 679
 680     return hr;
 681 }
 682
 683 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_cube_GetAutoGenFilterType(IDirect3DCubeTexture9 *iface)
 684 {
 685     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 686     D3DTEXTUREFILTERTYPE ret;
 687
 688     TRACE("iface %p.\n", iface);
 689
 690     wined3d_mutex_lock();
 691     ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
 692     wined3d_mutex_unlock();
 693
 694     return ret;
 695 }
 696
 697 static void WINAPI d3d9_texture_cube_GenerateMipSubLevels(IDirect3DCubeTexture9 *iface)
 698 {
 699     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 700
 701     TRACE("iface %p.\n", iface);
 702
 703     wined3d_mutex_lock();
 704     wined3d_texture_generate_mipmaps(texture->wined3d_texture);
 705     wined3d_mutex_unlock();
 706 }
 707
 708 static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
 709 {
 710     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 711     struct wined3d_resource *sub_resource;
 712     HRESULT hr = D3D_OK;
 713     DWORD level_count;
 714
 715     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 716
 717     wined3d_mutex_lock();
 718     level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
 719     if (level >= level_count)
 720     {
 721         wined3d_mutex_unlock();
 722         return D3DERR_INVALIDCALL;
 723     }
 724
 725     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 726         hr = D3DERR_INVALIDCALL;
 727     else
 728     {
 729         struct wined3d_resource_desc wined3d_desc;
 730
 731         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 732         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 733         desc->Type = wined3d_desc.resource_type;
 734         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 735         desc->Pool = wined3d_desc.pool;
 736         desc->MultiSampleType = wined3d_desc.multisample_type;
 737         desc->MultiSampleQuality = wined3d_desc.multisample_quality;
 738         desc->Width = wined3d_desc.width;
 739         desc->Height = wined3d_desc.height;
 740     }
 741     wined3d_mutex_unlock();
 742
 743     return hr;
 744 }
 745
 746 static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9 *iface,
 747         D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface9 **surface)
 748 {
 749     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 750     struct wined3d_resource *sub_resource;
 751     IDirect3DSurface9Impl *surface_impl;
 752     UINT sub_resource_idx;
 753
 754     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
 755
 756     wined3d_mutex_lock();
 757     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 758     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 759     {
 760         wined3d_mutex_unlock();
 761         return D3DERR_INVALIDCALL;
 762     }
 763
 764     surface_impl = wined3d_resource_get_parent(sub_resource);
 765     *surface = &surface_impl->IDirect3DSurface9_iface;
 766     IDirect3DSurface9_AddRef(*surface);
 767     wined3d_mutex_unlock();
 768
 769     return D3D_OK;
 770 }
 771
 772 static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface,
 773         D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
 774         DWORD flags)
 775 {
 776     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 777     struct wined3d_resource *sub_resource;
 778     IDirect3DSurface9Impl *surface_impl;
 779     UINT sub_resource_idx;
 780     HRESULT hr;
 781
 782     TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
 783             iface, face, level, locked_rect, rect, flags);
 784
 785     wined3d_mutex_lock();
 786     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 787     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 788         hr = D3DERR_INVALIDCALL;
 789     else
 790     {
 791         surface_impl = wined3d_resource_get_parent(sub_resource);
 792         hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
 793     }
 794     wined3d_mutex_unlock();
 795
 796     return hr;
 797 }
 798
 799 static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface,
 800         D3DCUBEMAP_FACES face, UINT level)
 801 {
 802     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 803     struct wined3d_resource *sub_resource;
 804     IDirect3DSurface9Impl *surface_impl;
 805     UINT sub_resource_idx;
 806     HRESULT hr;
 807
 808     TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
 809
 810     wined3d_mutex_lock();
 811     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 812     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 813         hr = D3DERR_INVALIDCALL;
 814     else
 815     {
 816         surface_impl = wined3d_resource_get_parent(sub_resource);
 817         hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
 818     }
 819     wined3d_mutex_unlock();
 820
 821     return hr;
 822 }
 823
 824 static HRESULT  WINAPI d3d9_texture_cube_AddDirtyRect(IDirect3DCubeTexture9 *iface,
 825         D3DCUBEMAP_FACES face, const RECT *dirty_rect)
 826 {
 827     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 828     HRESULT hr;
 829
 830     TRACE("iface %p, face %#x, dirty_rect %s.\n",
 831             iface, face, wine_dbgstr_rect(dirty_rect));
 832
 833     wined3d_mutex_lock();
 834     if (!dirty_rect)
 835         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
 836     else
 837     {
 838         struct wined3d_box dirty_region;
 839
 840         dirty_region.left = dirty_rect->left;
 841         dirty_region.top = dirty_rect->top;
 842         dirty_region.right = dirty_rect->right;
 843         dirty_region.bottom = dirty_rect->bottom;
 844         dirty_region.front = 0;
 845         dirty_region.back = 1;
 846         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
 847     }
 848     wined3d_mutex_unlock();
 849
 850     return hr;
 851 }
 852
 853 static const IDirect3DCubeTexture9Vtbl d3d9_texture_cube_vtbl =
 854 {
 855     /* IUnknown */
 856     d3d9_texture_cube_QueryInterface,
 857     d3d9_texture_cube_AddRef,
 858     d3d9_texture_cube_Release,
 859     /* IDirect3DResource9 */
 860     d3d9_texture_cube_GetDevice,
 861     d3d9_texture_cube_SetPrivateData,
 862     d3d9_texture_cube_GetPrivateData,
 863     d3d9_texture_cube_FreePrivateData,
 864     d3d9_texture_cube_SetPriority,
 865     d3d9_texture_cube_GetPriority,
 866     d3d9_texture_cube_PreLoad,
 867     d3d9_texture_cube_GetType,
 868     /* IDirect3DBaseTexture9 */
 869     d3d9_texture_cube_SetLOD,
 870     d3d9_texture_cube_GetLOD,
 871     d3d9_texture_cube_GetLevelCount,
 872     d3d9_texture_cube_SetAutoGenFilterType,
 873     d3d9_texture_cube_GetAutoGenFilterType,
 874     d3d9_texture_cube_GenerateMipSubLevels,
 875     /* IDirect3DCubeTexture9 */
 876     d3d9_texture_cube_GetLevelDesc,
 877     d3d9_texture_cube_GetCubeMapSurface,
 878     d3d9_texture_cube_LockRect,
 879     d3d9_texture_cube_UnlockRect,
 880     d3d9_texture_cube_AddDirtyRect,
 881 };
 882
 883 static HRESULT WINAPI d3d9_texture_3d_QueryInterface(IDirect3DVolumeTexture9 *iface, REFIID riid, void **out)
 884 {
 885     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 886
 887     if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)
 888             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 889             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 890             || IsEqualGUID(riid, &IID_IUnknown))
 891     {
 892         IDirect3DVolumeTexture9_AddRef(iface);
 893         *out = iface;
 894         return S_OK;
 895     }
 896
 897     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 898
 899     *out = NULL;
 900     return E_NOINTERFACE;
 901 }
 902
 903 static ULONG WINAPI d3d9_texture_3d_AddRef(IDirect3DVolumeTexture9 *iface)
 904 {
 905     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 906     ULONG ref = InterlockedIncrement(&texture->refcount);
 907
 908     TRACE("%p increasing refcount to %u.\n", iface, ref);
 909
 910     if (ref == 1)
 911     {
 912         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 913         wined3d_mutex_lock();
 914         wined3d_texture_incref(texture->wined3d_texture);
 915         wined3d_mutex_unlock();
 916     }
 917
 918     return ref;
 919 }
 920
 921 static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface)
 922 {
 923     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 924     ULONG ref = InterlockedDecrement(&texture->refcount);
 925
 926     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 927
 928     if (!ref)
 929     {
 930         IDirect3DDevice9Ex *parent_device = texture->parent_device;
 931
 932         wined3d_mutex_lock();
 933         wined3d_texture_decref(texture->wined3d_texture);
 934         wined3d_mutex_unlock();
 935
 936         /* Release the device last, as it may cause the device to be destroyed. */
 937         IDirect3DDevice9Ex_Release(parent_device);
 938     }
 939     return ref;
 940 }
 941
 942 static HRESULT WINAPI d3d9_texture_3d_GetDevice(IDirect3DVolumeTexture9 *iface, IDirect3DDevice9 **device)
 943 {
 944     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 945
 946     TRACE("iface %p, device %p.\n", iface, device);
 947
 948     *device = (IDirect3DDevice9 *)texture->parent_device;
 949     IDirect3DDevice9_AddRef(*device);
 950
 951     TRACE("Returning device %p.\n", *device);
 952
 953     return D3D_OK;
 954 }
 955
 956 static HRESULT WINAPI d3d9_texture_3d_SetPrivateData(IDirect3DVolumeTexture9 *iface,
 957         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 958 {
 959     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 960     struct wined3d_resource *resource;
 961     HRESULT hr;
 962
 963     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 964             iface, debugstr_guid(guid), data, data_size, flags);
 965
 966     wined3d_mutex_lock();
 967     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 968     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 969     wined3d_mutex_unlock();
 970
 971     return hr;
 972 }
 973
 974 static HRESULT WINAPI d3d9_texture_3d_GetPrivateData(IDirect3DVolumeTexture9 *iface,
 975         REFGUID guid, void *data, DWORD *data_size)
 976 {
 977     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 978     struct wined3d_resource *resource;
 979     HRESULT hr;
 980
 981     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 982             iface, debugstr_guid(guid), data, data_size);
 983
 984     wined3d_mutex_lock();
 985     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 986     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 987     wined3d_mutex_unlock();
 988
 989     return hr;
 990 }
 991
 992 static HRESULT WINAPI d3d9_texture_3d_FreePrivateData(IDirect3DVolumeTexture9 *iface, REFGUID guid)
 993 {
 994     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 995     struct wined3d_resource *resource;
 996     HRESULT hr;
 997
 998     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 999
1000     wined3d_mutex_lock();
1001     resource = wined3d_texture_get_resource(texture->wined3d_texture);
1002     hr = wined3d_resource_free_private_data(resource, guid);
1003     wined3d_mutex_unlock();
1004
1005     return hr;
1006 }
1007
1008 static DWORD WINAPI d3d9_texture_3d_SetPriority(IDirect3DVolumeTexture9 *iface, DWORD priority)
1009 {
1010     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1011     DWORD ret;
1012
1013     TRACE("iface %p, priority %u.\n", iface, priority);
1014
1015     wined3d_mutex_lock();
1016     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
1017     wined3d_mutex_unlock();
1018
1019     return ret;
1020 }
1021
1022 static DWORD WINAPI d3d9_texture_3d_GetPriority(IDirect3DVolumeTexture9 *iface)
1023 {
1024     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1025     DWORD ret;
1026
1027     TRACE("iface %p.\n", iface);
1028
1029     wined3d_mutex_lock();
1030     ret = wined3d_texture_get_priority(texture->wined3d_texture);
1031     wined3d_mutex_unlock();
1032
1033     return ret;
1034 }
1035
1036 static void WINAPI d3d9_texture_3d_PreLoad(IDirect3DVolumeTexture9 *iface)
1037 {
1038     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1039
1040     TRACE("iface %p.\n", iface);
1041
1042     wined3d_mutex_lock();
1043     wined3d_texture_preload(texture->wined3d_texture);
1044     wined3d_mutex_unlock();
1045 }
1046
1047 static D3DRESOURCETYPE WINAPI d3d9_texture_3d_GetType(IDirect3DVolumeTexture9 *iface)
1048 {
1049     TRACE("iface %p.\n", iface);
1050
1051     return D3DRTYPE_VOLUMETEXTURE;
1052 }
1053
1054 static DWORD WINAPI d3d9_texture_3d_SetLOD(IDirect3DVolumeTexture9 *iface, DWORD lod)
1055 {
1056     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1057     DWORD ret;
1058
1059     TRACE("iface %p, lod %u.\n", iface, lod);
1060
1061     wined3d_mutex_lock();
1062     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
1063     wined3d_mutex_unlock();
1064
1065     return ret;
1066 }
1067
1068 static DWORD WINAPI d3d9_texture_3d_GetLOD(IDirect3DVolumeTexture9 *iface)
1069 {
1070     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1071     DWORD ret;
1072
1073     TRACE("iface %p.\n", iface);
1074
1075     wined3d_mutex_lock();
1076     ret = wined3d_texture_get_lod(texture->wined3d_texture);
1077     wined3d_mutex_unlock();
1078
1079     return ret;
1080 }
1081
1082 static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface)
1083 {
1084     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1085     DWORD ret;
1086
1087     TRACE("iface %p.\n", iface);
1088
1089     wined3d_mutex_lock();
1090     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
1091     wined3d_mutex_unlock();
1092
1093     return ret;
1094 }
1095
1096 static HRESULT WINAPI d3d9_texture_3d_SetAutoGenFilterType(IDirect3DVolumeTexture9 *iface,
1097         D3DTEXTUREFILTERTYPE filter_type)
1098 {
1099     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1100     HRESULT hr;
1101
1102     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
1103
1104     wined3d_mutex_lock();
1105     hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
1106             (enum wined3d_texture_filter_type)filter_type);
1107     wined3d_mutex_unlock();
1108
1109     return hr;
1110 }
1111
1112 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_3d_GetAutoGenFilterType(IDirect3DVolumeTexture9 *iface)
1113 {
1114     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1115     D3DTEXTUREFILTERTYPE filter_type;
1116
1117     TRACE("iface %p.\n", iface);
1118
1119     wined3d_mutex_lock();
1120     filter_type = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
1121     wined3d_mutex_unlock();
1122
1123     return filter_type;
1124 }
1125
1126 static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface)
1127 {
1128     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1129
1130     TRACE("iface %p.\n", iface);
1131
1132     wined3d_mutex_lock();
1133     wined3d_texture_generate_mipmaps(texture->wined3d_texture);
1134     wined3d_mutex_unlock();
1135 }
1136
1137 static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *iface, UINT level, D3DVOLUME_DESC *desc)
1138 {
1139     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1140     struct wined3d_resource *sub_resource;
1141     HRESULT hr = D3D_OK;
1142
1143     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
1144
1145     wined3d_mutex_lock();
1146     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1147         hr = D3DERR_INVALIDCALL;
1148     else
1149     {
1150         struct wined3d_resource_desc wined3d_desc;
1151
1152         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
1153         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
1154         desc->Type = wined3d_desc.resource_type;
1155         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
1156         desc->Pool = wined3d_desc.pool;
1157         desc->Width = wined3d_desc.width;
1158         desc->Height = wined3d_desc.height;
1159         desc->Depth = wined3d_desc.depth;
1160     }
1161     wined3d_mutex_unlock();
1162
1163     return hr;
1164 }
1165
1166 static HRESULT WINAPI d3d9_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture9 *iface,
1167         UINT level, IDirect3DVolume9 **volume)
1168 {
1169     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1170     struct wined3d_resource *sub_resource;
1171     IDirect3DVolume9Impl *volume_impl;
1172
1173     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
1174
1175     wined3d_mutex_lock();
1176     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1177     {
1178         wined3d_mutex_unlock();
1179         return D3DERR_INVALIDCALL;
1180     }
1181
1182     volume_impl = wined3d_resource_get_parent(sub_resource);
1183     *volume = &volume_impl->IDirect3DVolume9_iface;
1184     IDirect3DVolume9_AddRef(*volume);
1185     wined3d_mutex_unlock();
1186
1187     return D3D_OK;
1188 }
1189
1190 static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface,
1191         UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
1192 {
1193     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1194     struct wined3d_resource *sub_resource;
1195     IDirect3DVolume9Impl *volume_impl;
1196     HRESULT hr;
1197
1198     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
1199             iface, level, locked_box, box, flags);
1200
1201     wined3d_mutex_lock();
1202     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1203         hr = D3DERR_INVALIDCALL;
1204     else
1205     {
1206         volume_impl = wined3d_resource_get_parent(sub_resource);
1207         hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags);
1208     }
1209     wined3d_mutex_unlock();
1210
1211     return hr;
1212 }
1213
1214 static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
1215 {
1216     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1217     struct wined3d_resource *sub_resource;
1218     IDirect3DVolume9Impl *volume_impl;
1219     HRESULT hr;
1220
1221     TRACE("iface %p, level %u.\n", iface, level);
1222
1223     wined3d_mutex_lock();
1224     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1225         hr = D3DERR_INVALIDCALL;
1226     else
1227     {
1228         volume_impl = wined3d_resource_get_parent(sub_resource);
1229         hr = IDirect3DVolume9_UnlockBox(&volume_impl->IDirect3DVolume9_iface);
1230     }
1231     wined3d_mutex_unlock();
1232
1233     return hr;
1234 }
1235
1236 static HRESULT WINAPI d3d9_texture_3d_AddDirtyBox(IDirect3DVolumeTexture9 *iface, const D3DBOX *dirty_box)
1237 {
1238     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1239     HRESULT hr;
1240
1241     TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
1242
1243     wined3d_mutex_lock();
1244     hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
1245     wined3d_mutex_unlock();
1246
1247     return hr;
1248 }
1249
1250
1251 static const IDirect3DVolumeTexture9Vtbl d3d9_texture_3d_vtbl =
1252 {
1253     /* IUnknown */
1254     d3d9_texture_3d_QueryInterface,
1255     d3d9_texture_3d_AddRef,
1256     d3d9_texture_3d_Release,
1257     /* IDirect3DResource9 */
1258     d3d9_texture_3d_GetDevice,
1259     d3d9_texture_3d_SetPrivateData,
1260     d3d9_texture_3d_GetPrivateData,
1261     d3d9_texture_3d_FreePrivateData,
1262     d3d9_texture_3d_SetPriority,
1263     d3d9_texture_3d_GetPriority,
1264     d3d9_texture_3d_PreLoad,
1265     d3d9_texture_3d_GetType,
1266     /* IDirect3DBaseTexture9 */
1267     d3d9_texture_3d_SetLOD,
1268     d3d9_texture_3d_GetLOD,
1269     d3d9_texture_3d_GetLevelCount,
1270     d3d9_texture_3d_SetAutoGenFilterType,
1271     d3d9_texture_3d_GetAutoGenFilterType,
1272     d3d9_texture_3d_GenerateMipSubLevels,
1273     /* IDirect3DVolumeTexture9 */
1274     d3d9_texture_3d_GetLevelDesc,
1275     d3d9_texture_3d_GetVolumeLevel,
1276     d3d9_texture_3d_LockBox,
1277     d3d9_texture_3d_UnlockBox,
1278     d3d9_texture_3d_AddDirtyBox,
1279 };
1280
1281 struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface)
1282 {
1283     if (!iface)
1284         return NULL;
1285     assert(iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl
1286             || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl
1287             || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl);
1288     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
1289 }
1290
1291 static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent)
1292 {
1293     HeapFree(GetProcessHeap(), 0, parent);
1294 }
1295
1296 static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops =
1297 {
1298     d3d9_texture_wined3d_object_destroyed,
1299 };
1300
1301 HRESULT texture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1302         UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1303 {
1304     HRESULT hr;
1305
1306     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
1307     texture->refcount = 1;
1308
1309     wined3d_mutex_lock();
1310     hr = wined3d_texture_create_2d(device->wined3d_device, width, height, levels,
1311             usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool,
1312             texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1313     wined3d_mutex_unlock();
1314     if (FAILED(hr))
1315     {
1316         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1317         return hr;
1318     }
1319
1320     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1321     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1322
1323     return D3D_OK;
1324 }
1325
1326 HRESULT cubetexture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1327         UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1328 {
1329     HRESULT hr;
1330
1331     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
1332     texture->refcount = 1;
1333
1334     wined3d_mutex_lock();
1335     hr = wined3d_texture_create_cube(device->wined3d_device, edge_length,
1336             levels, usage, wined3dformat_from_d3dformat(format), pool, texture,
1337             &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1338     wined3d_mutex_unlock();
1339     if (FAILED(hr))
1340     {
1341         WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
1342         return hr;
1343     }
1344
1345     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1346     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1347
1348     return D3D_OK;
1349 }
1350
1351 HRESULT volumetexture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1352         UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1353 {
1354     HRESULT hr;
1355
1356     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
1357     texture->refcount = 1;
1358
1359     wined3d_mutex_lock();
1360     hr = wined3d_texture_create_3d(device->wined3d_device, width, height, depth, levels,
1361             usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool, texture,
1362             &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1363     wined3d_mutex_unlock();
1364     if (FAILED(hr))
1365     {
1366         WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
1367         return hr;
1368     }
1369
1370     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1371     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1372
1373     return D3D_OK;
1374 }