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