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