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