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