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