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
 330     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
 331
 332     wined3d_mutex_lock();
 333     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 334     {
 335         wined3d_mutex_unlock();
 336         return D3DERR_INVALIDCALL;
 337     }
 338
 339     *surface = wined3d_resource_get_parent(sub_resource);
 340     IDirect3DSurface9_AddRef(*surface);
 341     wined3d_mutex_unlock();
 342
 343     return D3D_OK;
 344 }
 345
 346 static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface,
 347         UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
 348 {
 349     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 350     struct wined3d_resource *sub_resource;
 351     HRESULT hr;
 352
 353     TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
 354             iface, level, locked_rect, rect, flags);
 355
 356     wined3d_mutex_lock();
 357     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 358         hr = D3DERR_INVALIDCALL;
 359     else
 360         hr = IDirect3DSurface9_LockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource),
 361                 locked_rect, rect, flags);
 362     wined3d_mutex_unlock();
 363
 364     return hr;
 365 }
 366
 367 static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT level)
 368 {
 369     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 370     struct wined3d_resource *sub_resource;
 371     HRESULT hr;
 372
 373     TRACE("iface %p, level %u.\n", iface, level);
 374
 375     wined3d_mutex_lock();
 376     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 377         hr = D3DERR_INVALIDCALL;
 378     else
 379         hr = IDirect3DSurface9_UnlockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource));
 380     wined3d_mutex_unlock();
 381
 382     return hr;
 383 }
 384
 385 static HRESULT WINAPI d3d9_texture_2d_AddDirtyRect(IDirect3DTexture9 *iface, const RECT *dirty_rect)
 386 {
 387     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 388     HRESULT hr;
 389
 390     TRACE("iface %p, dirty_rect %s.\n",
 391             iface, wine_dbgstr_rect(dirty_rect));
 392
 393     wined3d_mutex_lock();
 394     if (!dirty_rect)
 395         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL);
 396     else
 397     {
 398         struct wined3d_box dirty_region;
 399
 400         dirty_region.left = dirty_rect->left;
 401         dirty_region.top = dirty_rect->top;
 402         dirty_region.right = dirty_rect->right;
 403         dirty_region.bottom = dirty_rect->bottom;
 404         dirty_region.front = 0;
 405         dirty_region.back = 1;
 406         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region);
 407     }
 408     wined3d_mutex_unlock();
 409
 410     return hr;
 411 }
 412
 413 static const IDirect3DTexture9Vtbl d3d9_texture_2d_vtbl =
 414 {
 415     /* IUnknown */
 416     d3d9_texture_2d_QueryInterface,
 417     d3d9_texture_2d_AddRef,
 418     d3d9_texture_2d_Release,
 419      /* IDirect3DResource9 */
 420     d3d9_texture_2d_GetDevice,
 421     d3d9_texture_2d_SetPrivateData,
 422     d3d9_texture_2d_GetPrivateData,
 423     d3d9_texture_2d_FreePrivateData,
 424     d3d9_texture_2d_SetPriority,
 425     d3d9_texture_2d_GetPriority,
 426     d3d9_texture_2d_PreLoad,
 427     d3d9_texture_2d_GetType,
 428     /* IDirect3dBaseTexture9 */
 429     d3d9_texture_2d_SetLOD,
 430     d3d9_texture_2d_GetLOD,
 431     d3d9_texture_2d_GetLevelCount,
 432     d3d9_texture_2d_SetAutoGenFilterType,
 433     d3d9_texture_2d_GetAutoGenFilterType,
 434     d3d9_texture_2d_GenerateMipSubLevels,
 435     /* IDirect3DTexture9 */
 436     d3d9_texture_2d_GetLevelDesc,
 437     d3d9_texture_2d_GetSurfaceLevel,
 438     d3d9_texture_2d_LockRect,
 439     d3d9_texture_2d_UnlockRect,
 440     d3d9_texture_2d_AddDirtyRect,
 441 };
 442
 443 static HRESULT WINAPI d3d9_texture_cube_QueryInterface(IDirect3DCubeTexture9 *iface, REFIID riid, void **out)
 444 {
 445     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 446
 447     if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)
 448             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 449             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 450             || IsEqualGUID(riid, &IID_IUnknown))
 451     {
 452         IDirect3DCubeTexture9_AddRef(iface);
 453         *out = iface;
 454         return S_OK;
 455     }
 456
 457     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 458
 459     *out = NULL;
 460     return E_NOINTERFACE;
 461 }
 462
 463 static ULONG WINAPI d3d9_texture_cube_AddRef(IDirect3DCubeTexture9 *iface)
 464 {
 465     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 466     ULONG ref = InterlockedIncrement(&texture->refcount);
 467
 468     TRACE("%p increasing refcount to %u.\n", iface, ref);
 469
 470     if (ref == 1)
 471     {
 472         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 473         wined3d_mutex_lock();
 474         wined3d_texture_incref(texture->wined3d_texture);
 475         wined3d_mutex_unlock();
 476     }
 477
 478     return ref;
 479 }
 480
 481 static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface)
 482 {
 483     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 484     ULONG ref = InterlockedDecrement(&texture->refcount);
 485
 486     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 487
 488     if (!ref)
 489     {
 490         IDirect3DDevice9Ex *parent_device = texture->parent_device;
 491
 492         TRACE("Releasing child %p.\n", texture->wined3d_texture);
 493
 494         wined3d_mutex_lock();
 495         wined3d_texture_decref(texture->wined3d_texture);
 496         wined3d_mutex_unlock();
 497
 498         /* Release the device last, as it may cause the device to be destroyed. */
 499         IDirect3DDevice9Ex_Release(parent_device);
 500     }
 501     return ref;
 502 }
 503
 504 static HRESULT WINAPI d3d9_texture_cube_GetDevice(IDirect3DCubeTexture9 *iface, IDirect3DDevice9 **device)
 505 {
 506     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 507
 508     TRACE("iface %p, device %p.\n", iface, device);
 509
 510     *device = (IDirect3DDevice9 *)texture->parent_device;
 511     IDirect3DDevice9_AddRef(*device);
 512
 513     TRACE("Returning device %p.\n", *device);
 514
 515     return D3D_OK;
 516 }
 517
 518 static HRESULT WINAPI d3d9_texture_cube_SetPrivateData(IDirect3DCubeTexture9 *iface,
 519         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 520 {
 521     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 522     struct wined3d_resource *resource;
 523     HRESULT hr;
 524
 525     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 526             iface, debugstr_guid(guid), data, data_size, flags);
 527
 528     wined3d_mutex_lock();
 529     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 530     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 531     wined3d_mutex_unlock();
 532
 533     return hr;
 534 }
 535
 536 static HRESULT WINAPI d3d9_texture_cube_GetPrivateData(IDirect3DCubeTexture9 *iface,
 537         REFGUID guid, void *data, DWORD *data_size)
 538 {
 539     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 540     struct wined3d_resource *resource;
 541     HRESULT hr;
 542
 543     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 544             iface, debugstr_guid(guid), data, data_size);
 545
 546     wined3d_mutex_lock();
 547     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 548     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 549     wined3d_mutex_unlock();
 550
 551     return hr;
 552 }
 553
 554 static HRESULT WINAPI d3d9_texture_cube_FreePrivateData(IDirect3DCubeTexture9 *iface, REFGUID guid)
 555 {
 556     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 557     struct wined3d_resource *resource;
 558     HRESULT hr;
 559
 560     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 561
 562     wined3d_mutex_lock();
 563     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 564     hr = wined3d_resource_free_private_data(resource, guid);
 565     wined3d_mutex_unlock();
 566
 567     return hr;
 568 }
 569
 570 static DWORD WINAPI d3d9_texture_cube_SetPriority(IDirect3DCubeTexture9 *iface, DWORD priority)
 571 {
 572     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 573     DWORD ret;
 574
 575     TRACE("iface %p, priority %u.\n", iface, priority);
 576
 577     wined3d_mutex_lock();
 578     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 579     wined3d_mutex_unlock();
 580
 581     return ret;
 582 }
 583
 584 static DWORD WINAPI d3d9_texture_cube_GetPriority(IDirect3DCubeTexture9 *iface)
 585 {
 586     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 587     DWORD ret;
 588
 589     TRACE("iface %p.\n", iface);
 590
 591     wined3d_mutex_lock();
 592     ret = wined3d_texture_get_priority(texture->wined3d_texture);
 593     wined3d_mutex_unlock();
 594
 595     return ret;
 596 }
 597
 598 static void WINAPI d3d9_texture_cube_PreLoad(IDirect3DCubeTexture9 *iface)
 599 {
 600     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 601
 602     TRACE("iface %p.\n", iface);
 603
 604     wined3d_mutex_lock();
 605     wined3d_texture_preload(texture->wined3d_texture);
 606     wined3d_mutex_unlock();
 607 }
 608
 609 static D3DRESOURCETYPE WINAPI d3d9_texture_cube_GetType(IDirect3DCubeTexture9 *iface)
 610 {
 611     TRACE("iface %p.\n", iface);
 612
 613     return D3DRTYPE_CUBETEXTURE;
 614 }
 615
 616 static DWORD WINAPI d3d9_texture_cube_SetLOD(IDirect3DCubeTexture9 *iface, DWORD lod)
 617 {
 618     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 619     DWORD ret;
 620
 621     TRACE("iface %p, lod %u.\n", iface, lod);
 622
 623     wined3d_mutex_lock();
 624     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 625     wined3d_mutex_unlock();
 626
 627     return ret;
 628 }
 629
 630 static DWORD WINAPI d3d9_texture_cube_GetLOD(IDirect3DCubeTexture9 *iface)
 631 {
 632     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 633     DWORD ret;
 634
 635     TRACE("iface %p.\n", iface);
 636
 637     wined3d_mutex_lock();
 638     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 639     wined3d_mutex_unlock();
 640
 641     return ret;
 642 }
 643
 644 static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface)
 645 {
 646     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 647     DWORD ret;
 648
 649     TRACE("iface %p.\n", iface);
 650
 651     wined3d_mutex_lock();
 652     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 653     wined3d_mutex_unlock();
 654
 655     return ret;
 656 }
 657
 658 static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTexture9 *iface,
 659         D3DTEXTUREFILTERTYPE filter_type)
 660 {
 661     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 662     HRESULT hr;
 663
 664     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
 665
 666     wined3d_mutex_lock();
 667     hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
 668             (enum wined3d_texture_filter_type)filter_type);
 669     wined3d_mutex_unlock();
 670
 671     return hr;
 672 }
 673
 674 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_cube_GetAutoGenFilterType(IDirect3DCubeTexture9 *iface)
 675 {
 676     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 677     D3DTEXTUREFILTERTYPE ret;
 678
 679     TRACE("iface %p.\n", iface);
 680
 681     wined3d_mutex_lock();
 682     ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
 683     wined3d_mutex_unlock();
 684
 685     return ret;
 686 }
 687
 688 static void WINAPI d3d9_texture_cube_GenerateMipSubLevels(IDirect3DCubeTexture9 *iface)
 689 {
 690     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 691
 692     TRACE("iface %p.\n", iface);
 693
 694     wined3d_mutex_lock();
 695     wined3d_texture_generate_mipmaps(texture->wined3d_texture);
 696     wined3d_mutex_unlock();
 697 }
 698
 699 static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
 700 {
 701     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 702     struct wined3d_resource *sub_resource;
 703     HRESULT hr = D3D_OK;
 704
 705     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 706
 707     wined3d_mutex_lock();
 708     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 709         hr = D3DERR_INVALIDCALL;
 710     else
 711     {
 712         struct wined3d_resource_desc wined3d_desc;
 713
 714         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 715         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 716         desc->Type = wined3d_desc.resource_type;
 717         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 718         desc->Pool = wined3d_desc.pool;
 719         desc->MultiSampleType = wined3d_desc.multisample_type;
 720         desc->MultiSampleQuality = wined3d_desc.multisample_quality;
 721         desc->Width = wined3d_desc.width;
 722         desc->Height = wined3d_desc.height;
 723     }
 724     wined3d_mutex_unlock();
 725
 726     return hr;
 727 }
 728
 729 static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9 *iface,
 730         D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface9 **surface)
 731 {
 732     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 733     struct wined3d_resource *sub_resource;
 734     UINT sub_resource_idx;
 735
 736     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
 737
 738     wined3d_mutex_lock();
 739     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 740     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 741     {
 742         wined3d_mutex_unlock();
 743         return D3DERR_INVALIDCALL;
 744     }
 745
 746     *surface = wined3d_resource_get_parent(sub_resource);
 747     IDirect3DSurface9_AddRef(*surface);
 748     wined3d_mutex_unlock();
 749
 750     return D3D_OK;
 751 }
 752
 753 static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface,
 754         D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
 755         DWORD flags)
 756 {
 757     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 758     struct wined3d_resource *sub_resource;
 759     UINT sub_resource_idx;
 760     HRESULT hr;
 761
 762     TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
 763             iface, face, level, locked_rect, rect, flags);
 764
 765     wined3d_mutex_lock();
 766     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 767     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 768         hr = D3DERR_INVALIDCALL;
 769     else
 770         hr = IDirect3DSurface9_LockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource),
 771                 locked_rect, rect, flags);
 772     wined3d_mutex_unlock();
 773
 774     return hr;
 775 }
 776
 777 static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface,
 778         D3DCUBEMAP_FACES face, UINT level)
 779 {
 780     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 781     struct wined3d_resource *sub_resource;
 782     UINT sub_resource_idx;
 783     HRESULT hr;
 784
 785     TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
 786
 787     wined3d_mutex_lock();
 788     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 789     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 790         hr = D3DERR_INVALIDCALL;
 791     else
 792         hr = IDirect3DSurface9_UnlockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource));
 793     wined3d_mutex_unlock();
 794
 795     return hr;
 796 }
 797
 798 static HRESULT  WINAPI d3d9_texture_cube_AddDirtyRect(IDirect3DCubeTexture9 *iface,
 799         D3DCUBEMAP_FACES face, const RECT *dirty_rect)
 800 {
 801     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 802     HRESULT hr;
 803
 804     TRACE("iface %p, face %#x, dirty_rect %s.\n",
 805             iface, face, wine_dbgstr_rect(dirty_rect));
 806
 807     wined3d_mutex_lock();
 808     if (!dirty_rect)
 809         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
 810     else
 811     {
 812         struct wined3d_box dirty_region;
 813
 814         dirty_region.left = dirty_rect->left;
 815         dirty_region.top = dirty_rect->top;
 816         dirty_region.right = dirty_rect->right;
 817         dirty_region.bottom = dirty_rect->bottom;
 818         dirty_region.front = 0;
 819         dirty_region.back = 1;
 820         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
 821     }
 822     wined3d_mutex_unlock();
 823
 824     return hr;
 825 }
 826
 827 static const IDirect3DCubeTexture9Vtbl d3d9_texture_cube_vtbl =
 828 {
 829     /* IUnknown */
 830     d3d9_texture_cube_QueryInterface,
 831     d3d9_texture_cube_AddRef,
 832     d3d9_texture_cube_Release,
 833     /* IDirect3DResource9 */
 834     d3d9_texture_cube_GetDevice,
 835     d3d9_texture_cube_SetPrivateData,
 836     d3d9_texture_cube_GetPrivateData,
 837     d3d9_texture_cube_FreePrivateData,
 838     d3d9_texture_cube_SetPriority,
 839     d3d9_texture_cube_GetPriority,
 840     d3d9_texture_cube_PreLoad,
 841     d3d9_texture_cube_GetType,
 842     /* IDirect3DBaseTexture9 */
 843     d3d9_texture_cube_SetLOD,
 844     d3d9_texture_cube_GetLOD,
 845     d3d9_texture_cube_GetLevelCount,
 846     d3d9_texture_cube_SetAutoGenFilterType,
 847     d3d9_texture_cube_GetAutoGenFilterType,
 848     d3d9_texture_cube_GenerateMipSubLevels,
 849     /* IDirect3DCubeTexture9 */
 850     d3d9_texture_cube_GetLevelDesc,
 851     d3d9_texture_cube_GetCubeMapSurface,
 852     d3d9_texture_cube_LockRect,
 853     d3d9_texture_cube_UnlockRect,
 854     d3d9_texture_cube_AddDirtyRect,
 855 };
 856
 857 static HRESULT WINAPI d3d9_texture_3d_QueryInterface(IDirect3DVolumeTexture9 *iface, REFIID riid, void **out)
 858 {
 859     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 860
 861     if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)
 862             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 863             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 864             || IsEqualGUID(riid, &IID_IUnknown))
 865     {
 866         IDirect3DVolumeTexture9_AddRef(iface);
 867         *out = iface;
 868         return S_OK;
 869     }
 870
 871     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 872
 873     *out = NULL;
 874     return E_NOINTERFACE;
 875 }
 876
 877 static ULONG WINAPI d3d9_texture_3d_AddRef(IDirect3DVolumeTexture9 *iface)
 878 {
 879     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 880     ULONG ref = InterlockedIncrement(&texture->refcount);
 881
 882     TRACE("%p increasing refcount to %u.\n", iface, ref);
 883
 884     if (ref == 1)
 885     {
 886         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 887         wined3d_mutex_lock();
 888         wined3d_texture_incref(texture->wined3d_texture);
 889         wined3d_mutex_unlock();
 890     }
 891
 892     return ref;
 893 }
 894
 895 static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface)
 896 {
 897     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 898     ULONG ref = InterlockedDecrement(&texture->refcount);
 899
 900     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 901
 902     if (!ref)
 903     {
 904         IDirect3DDevice9Ex *parent_device = texture->parent_device;
 905
 906         wined3d_mutex_lock();
 907         wined3d_texture_decref(texture->wined3d_texture);
 908         wined3d_mutex_unlock();
 909
 910         /* Release the device last, as it may cause the device to be destroyed. */
 911         IDirect3DDevice9Ex_Release(parent_device);
 912     }
 913     return ref;
 914 }
 915
 916 static HRESULT WINAPI d3d9_texture_3d_GetDevice(IDirect3DVolumeTexture9 *iface, IDirect3DDevice9 **device)
 917 {
 918     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 919
 920     TRACE("iface %p, device %p.\n", iface, device);
 921
 922     *device = (IDirect3DDevice9 *)texture->parent_device;
 923     IDirect3DDevice9_AddRef(*device);
 924
 925     TRACE("Returning device %p.\n", *device);
 926
 927     return D3D_OK;
 928 }
 929
 930 static HRESULT WINAPI d3d9_texture_3d_SetPrivateData(IDirect3DVolumeTexture9 *iface,
 931         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 932 {
 933     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 934     struct wined3d_resource *resource;
 935     HRESULT hr;
 936
 937     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 938             iface, debugstr_guid(guid), data, data_size, flags);
 939
 940     wined3d_mutex_lock();
 941     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 942     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 943     wined3d_mutex_unlock();
 944
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI d3d9_texture_3d_GetPrivateData(IDirect3DVolumeTexture9 *iface,
 949         REFGUID guid, void *data, DWORD *data_size)
 950 {
 951     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 952     struct wined3d_resource *resource;
 953     HRESULT hr;
 954
 955     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 956             iface, debugstr_guid(guid), data, data_size);
 957
 958     wined3d_mutex_lock();
 959     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 960     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 961     wined3d_mutex_unlock();
 962
 963     return hr;
 964 }
 965
 966 static HRESULT WINAPI d3d9_texture_3d_FreePrivateData(IDirect3DVolumeTexture9 *iface, REFGUID guid)
 967 {
 968     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 969     struct wined3d_resource *resource;
 970     HRESULT hr;
 971
 972     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 973
 974     wined3d_mutex_lock();
 975     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 976     hr = wined3d_resource_free_private_data(resource, guid);
 977     wined3d_mutex_unlock();
 978
 979     return hr;
 980 }
 981
 982 static DWORD WINAPI d3d9_texture_3d_SetPriority(IDirect3DVolumeTexture9 *iface, DWORD priority)
 983 {
 984     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 985     DWORD ret;
 986
 987     TRACE("iface %p, priority %u.\n", iface, priority);
 988
 989     wined3d_mutex_lock();
 990     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 991     wined3d_mutex_unlock();
 992
 993     return ret;
 994 }
 995
 996 static DWORD WINAPI d3d9_texture_3d_GetPriority(IDirect3DVolumeTexture9 *iface)
 997 {
 998     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 999     DWORD ret;
1000
1001     TRACE("iface %p.\n", iface);
1002
1003     wined3d_mutex_lock();
1004     ret = wined3d_texture_get_priority(texture->wined3d_texture);
1005     wined3d_mutex_unlock();
1006
1007     return ret;
1008 }
1009
1010 static void WINAPI d3d9_texture_3d_PreLoad(IDirect3DVolumeTexture9 *iface)
1011 {
1012     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1013
1014     TRACE("iface %p.\n", iface);
1015
1016     wined3d_mutex_lock();
1017     wined3d_texture_preload(texture->wined3d_texture);
1018     wined3d_mutex_unlock();
1019 }
1020
1021 static D3DRESOURCETYPE WINAPI d3d9_texture_3d_GetType(IDirect3DVolumeTexture9 *iface)
1022 {
1023     TRACE("iface %p.\n", iface);
1024
1025     return D3DRTYPE_VOLUMETEXTURE;
1026 }
1027
1028 static DWORD WINAPI d3d9_texture_3d_SetLOD(IDirect3DVolumeTexture9 *iface, DWORD lod)
1029 {
1030     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1031     DWORD ret;
1032
1033     TRACE("iface %p, lod %u.\n", iface, lod);
1034
1035     wined3d_mutex_lock();
1036     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
1037     wined3d_mutex_unlock();
1038
1039     return ret;
1040 }
1041
1042 static DWORD WINAPI d3d9_texture_3d_GetLOD(IDirect3DVolumeTexture9 *iface)
1043 {
1044     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1045     DWORD ret;
1046
1047     TRACE("iface %p.\n", iface);
1048
1049     wined3d_mutex_lock();
1050     ret = wined3d_texture_get_lod(texture->wined3d_texture);
1051     wined3d_mutex_unlock();
1052
1053     return ret;
1054 }
1055
1056 static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface)
1057 {
1058     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1059     DWORD ret;
1060
1061     TRACE("iface %p.\n", iface);
1062
1063     wined3d_mutex_lock();
1064     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
1065     wined3d_mutex_unlock();
1066
1067     return ret;
1068 }
1069
1070 static HRESULT WINAPI d3d9_texture_3d_SetAutoGenFilterType(IDirect3DVolumeTexture9 *iface,
1071         D3DTEXTUREFILTERTYPE filter_type)
1072 {
1073     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1074     HRESULT hr;
1075
1076     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
1077
1078     wined3d_mutex_lock();
1079     hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
1080             (enum wined3d_texture_filter_type)filter_type);
1081     wined3d_mutex_unlock();
1082
1083     return hr;
1084 }
1085
1086 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_3d_GetAutoGenFilterType(IDirect3DVolumeTexture9 *iface)
1087 {
1088     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1089     D3DTEXTUREFILTERTYPE filter_type;
1090
1091     TRACE("iface %p.\n", iface);
1092
1093     wined3d_mutex_lock();
1094     filter_type = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
1095     wined3d_mutex_unlock();
1096
1097     return filter_type;
1098 }
1099
1100 static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface)
1101 {
1102     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1103
1104     TRACE("iface %p.\n", iface);
1105
1106     wined3d_mutex_lock();
1107     wined3d_texture_generate_mipmaps(texture->wined3d_texture);
1108     wined3d_mutex_unlock();
1109 }
1110
1111 static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *iface, UINT level, D3DVOLUME_DESC *desc)
1112 {
1113     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1114     struct wined3d_resource *sub_resource;
1115     HRESULT hr = D3D_OK;
1116
1117     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
1118
1119     wined3d_mutex_lock();
1120     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1121         hr = D3DERR_INVALIDCALL;
1122     else
1123     {
1124         struct wined3d_resource_desc wined3d_desc;
1125
1126         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
1127         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
1128         desc->Type = wined3d_desc.resource_type;
1129         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
1130         desc->Pool = wined3d_desc.pool;
1131         desc->Width = wined3d_desc.width;
1132         desc->Height = wined3d_desc.height;
1133         desc->Depth = wined3d_desc.depth;
1134     }
1135     wined3d_mutex_unlock();
1136
1137     return hr;
1138 }
1139
1140 static HRESULT WINAPI d3d9_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture9 *iface,
1141         UINT level, IDirect3DVolume9 **volume)
1142 {
1143     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1144     struct wined3d_resource *sub_resource;
1145
1146     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
1147
1148     wined3d_mutex_lock();
1149     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1150     {
1151         wined3d_mutex_unlock();
1152         return D3DERR_INVALIDCALL;
1153     }
1154
1155     *volume = wined3d_resource_get_parent(sub_resource);
1156     IDirect3DVolume9_AddRef(*volume);
1157     wined3d_mutex_unlock();
1158
1159     return D3D_OK;
1160 }
1161
1162 static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface,
1163         UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
1164 {
1165     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1166     struct wined3d_resource *sub_resource;
1167     HRESULT hr;
1168
1169     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
1170             iface, level, locked_box, box, flags);
1171
1172     wined3d_mutex_lock();
1173     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1174         hr = D3DERR_INVALIDCALL;
1175     else
1176         hr = IDirect3DVolume9_LockBox((IDirect3DVolume9 *)wined3d_resource_get_parent(sub_resource),
1177                 locked_box, box, flags);
1178     wined3d_mutex_unlock();
1179
1180     return hr;
1181 }
1182
1183 static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
1184 {
1185     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1186     struct wined3d_resource *sub_resource;
1187     HRESULT hr;
1188
1189     TRACE("iface %p, level %u.\n", iface, level);
1190
1191     wined3d_mutex_lock();
1192     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1193         hr = D3DERR_INVALIDCALL;
1194     else
1195         hr = IDirect3DVolume9_UnlockBox((IDirect3DVolume9 *)wined3d_resource_get_parent(sub_resource));
1196     wined3d_mutex_unlock();
1197
1198     return hr;
1199 }
1200
1201 static HRESULT WINAPI d3d9_texture_3d_AddDirtyBox(IDirect3DVolumeTexture9 *iface, const D3DBOX *dirty_box)
1202 {
1203     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1204     HRESULT hr;
1205
1206     TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
1207
1208     wined3d_mutex_lock();
1209     hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
1210     wined3d_mutex_unlock();
1211
1212     return hr;
1213 }
1214
1215
1216 static const IDirect3DVolumeTexture9Vtbl d3d9_texture_3d_vtbl =
1217 {
1218     /* IUnknown */
1219     d3d9_texture_3d_QueryInterface,
1220     d3d9_texture_3d_AddRef,
1221     d3d9_texture_3d_Release,
1222     /* IDirect3DResource9 */
1223     d3d9_texture_3d_GetDevice,
1224     d3d9_texture_3d_SetPrivateData,
1225     d3d9_texture_3d_GetPrivateData,
1226     d3d9_texture_3d_FreePrivateData,
1227     d3d9_texture_3d_SetPriority,
1228     d3d9_texture_3d_GetPriority,
1229     d3d9_texture_3d_PreLoad,
1230     d3d9_texture_3d_GetType,
1231     /* IDirect3DBaseTexture9 */
1232     d3d9_texture_3d_SetLOD,
1233     d3d9_texture_3d_GetLOD,
1234     d3d9_texture_3d_GetLevelCount,
1235     d3d9_texture_3d_SetAutoGenFilterType,
1236     d3d9_texture_3d_GetAutoGenFilterType,
1237     d3d9_texture_3d_GenerateMipSubLevels,
1238     /* IDirect3DVolumeTexture9 */
1239     d3d9_texture_3d_GetLevelDesc,
1240     d3d9_texture_3d_GetVolumeLevel,
1241     d3d9_texture_3d_LockBox,
1242     d3d9_texture_3d_UnlockBox,
1243     d3d9_texture_3d_AddDirtyBox,
1244 };
1245
1246 struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface)
1247 {
1248     if (!iface)
1249         return NULL;
1250     assert(iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl
1251             || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl
1252             || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl);
1253     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
1254 }
1255
1256 static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent)
1257 {
1258     HeapFree(GetProcessHeap(), 0, parent);
1259 }
1260
1261 static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops =
1262 {
1263     d3d9_texture_wined3d_object_destroyed,
1264 };
1265
1266 HRESULT texture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1267         UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1268 {
1269     HRESULT hr;
1270
1271     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
1272     texture->refcount = 1;
1273
1274     wined3d_mutex_lock();
1275     hr = wined3d_texture_create_2d(device->wined3d_device, width, height, levels,
1276             usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool,
1277             texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1278     wined3d_mutex_unlock();
1279     if (FAILED(hr))
1280     {
1281         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1282         return hr;
1283     }
1284
1285     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1286     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1287
1288     return D3D_OK;
1289 }
1290
1291 HRESULT cubetexture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1292         UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1293 {
1294     HRESULT hr;
1295
1296     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
1297     texture->refcount = 1;
1298
1299     wined3d_mutex_lock();
1300     hr = wined3d_texture_create_cube(device->wined3d_device, edge_length,
1301             levels, usage, wined3dformat_from_d3dformat(format), pool, texture,
1302             &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1303     wined3d_mutex_unlock();
1304     if (FAILED(hr))
1305     {
1306         WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
1307         return hr;
1308     }
1309
1310     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1311     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1312
1313     return D3D_OK;
1314 }
1315
1316 HRESULT volumetexture_init(struct d3d9_texture *texture, IDirect3DDevice9Impl *device,
1317         UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1318 {
1319     HRESULT hr;
1320
1321     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
1322     texture->refcount = 1;
1323
1324     wined3d_mutex_lock();
1325     hr = wined3d_texture_create_3d(device->wined3d_device, width, height, depth, levels,
1326             usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool, texture,
1327             &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1328     wined3d_mutex_unlock();
1329     if (FAILED(hr))
1330     {
1331         WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
1332         return hr;
1333     }
1334
1335     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1336     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1337
1338     return D3D_OK;
1339 }