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