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