dlls/d3d8/texture.c

   1 /*
   2  * Copyright 2005 Oliver Stieber
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "d3d8_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
  23
  24 static inline struct d3d8_texture *impl_from_IDirect3DTexture8(IDirect3DTexture8 *iface)
  25 {
  26     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  27 }
  28
  29 static inline struct d3d8_texture *impl_from_IDirect3DCubeTexture8(IDirect3DCubeTexture8 *iface)
  30 {
  31     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  32 }
  33
  34 static inline struct d3d8_texture *impl_from_IDirect3DVolumeTexture8(IDirect3DVolumeTexture8 *iface)
  35 {
  36     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  37 }
  38
  39 static HRESULT WINAPI d3d8_texture_2d_QueryInterface(IDirect3DTexture8 *iface, REFIID riid, void **out)
  40 {
  41     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  42
  43     if (IsEqualGUID(riid, &IID_IDirect3DTexture8)
  44             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8)
  45             || IsEqualGUID(riid, &IID_IDirect3DResource8)
  46             || IsEqualGUID(riid, &IID_IUnknown))
  47     {
  48         IDirect3DTexture8_AddRef(iface);
  49         *out = iface;
  50         return S_OK;
  51     }
  52
  53     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  54
  55     *out = NULL;
  56     return E_NOINTERFACE;
  57 }
  58
  59 static ULONG WINAPI d3d8_texture_2d_AddRef(IDirect3DTexture8 *iface)
  60 {
  61     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
  62     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
  63
  64     TRACE("%p increasing refcount to %u.\n", iface, ref);
  65
  66     if (ref == 1)
  67     {
  68         IDirect3DDevice8_AddRef(texture->parent_device);
  69         wined3d_mutex_lock();
  70         wined3d_texture_incref(texture->wined3d_texture);
  71         wined3d_mutex_unlock();
  72     }
  73
  74     return ref;
  75 }
  76
  77 static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface)
  78 {
  79     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
  80     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
  81
  82     TRACE("%p decreasing refcount to %u.\n", iface, ref);
  83
  84     if (!ref)
  85     {
  86         IDirect3DDevice8 *parent_device = texture->parent_device;
  87
  88         wined3d_mutex_lock();
  89         wined3d_texture_decref(texture->wined3d_texture);
  90         wined3d_mutex_unlock();
  91
  92         /* Release the device last, as it may cause the device to be destroyed. */
  93         IDirect3DDevice8_Release(parent_device);
  94     }
  95     return ref;
  96 }
  97
  98 static HRESULT WINAPI d3d8_texture_2d_GetDevice(IDirect3DTexture8 *iface, IDirect3DDevice8 **device)
  99 {
 100     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 101
 102     TRACE("iface %p, device %p.\n", iface, device);
 103
 104     *device = texture->parent_device;
 105     IDirect3DDevice8_AddRef(*device);
 106
 107     TRACE("Returning device %p.\n", *device);
 108
 109     return D3D_OK;
 110 }
 111
 112 static HRESULT WINAPI d3d8_texture_2d_SetPrivateData(IDirect3DTexture8 *iface,
 113         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 114 {
 115     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 116     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 117             iface, debugstr_guid(guid), data, data_size, flags);
 118
 119     return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 120 }
 121
 122 static HRESULT WINAPI d3d8_texture_2d_GetPrivateData(IDirect3DTexture8 *iface,
 123         REFGUID guid, void *data, DWORD *data_size)
 124 {
 125     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 126     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 127             iface, debugstr_guid(guid), data, data_size);
 128
 129     return d3d8_resource_get_private_data(&texture->resource, guid, data, data_size);
 130 }
 131
 132 static HRESULT WINAPI d3d8_texture_2d_FreePrivateData(IDirect3DTexture8 *iface, REFGUID guid)
 133 {
 134     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 135     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 136
 137     return d3d8_resource_free_private_data(&texture->resource, guid);
 138 }
 139
 140 static DWORD WINAPI d3d8_texture_2d_SetPriority(IDirect3DTexture8 *iface, DWORD priority)
 141 {
 142     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 143     DWORD ret;
 144
 145     TRACE("iface %p, priority %u.\n", iface, priority);
 146
 147     wined3d_mutex_lock();
 148     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 149     wined3d_mutex_unlock();
 150
 151     return ret;
 152 }
 153
 154 static DWORD WINAPI d3d8_texture_2d_GetPriority(IDirect3DTexture8 *iface)
 155 {
 156     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 157     DWORD ret;
 158
 159     TRACE("iface %p.\n", iface);
 160
 161     wined3d_mutex_lock();
 162     ret = wined3d_texture_get_priority(texture->wined3d_texture);
 163     wined3d_mutex_unlock();
 164
 165     return ret;
 166 }
 167
 168 static void WINAPI d3d8_texture_2d_PreLoad(IDirect3DTexture8 *iface)
 169 {
 170     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 171
 172     TRACE("iface %p.\n", iface);
 173
 174     wined3d_mutex_lock();
 175     wined3d_texture_preload(texture->wined3d_texture);
 176     wined3d_mutex_unlock();
 177 }
 178
 179 static D3DRESOURCETYPE WINAPI d3d8_texture_2d_GetType(IDirect3DTexture8 *iface)
 180 {
 181     TRACE("iface %p.\n", iface);
 182
 183     return D3DRTYPE_TEXTURE;
 184 }
 185
 186 static DWORD WINAPI d3d8_texture_2d_SetLOD(IDirect3DTexture8 *iface, DWORD lod)
 187 {
 188     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 189     DWORD ret;
 190
 191     TRACE("iface %p, lod %u.\n", iface, lod);
 192
 193     wined3d_mutex_lock();
 194     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 195     wined3d_mutex_unlock();
 196
 197     return ret;
 198 }
 199
 200 static DWORD WINAPI d3d8_texture_2d_GetLOD(IDirect3DTexture8 *iface)
 201 {
 202     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 203     DWORD ret;
 204
 205     TRACE("iface %p.\n", iface);
 206
 207     wined3d_mutex_lock();
 208     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 209     wined3d_mutex_unlock();
 210
 211     return ret;
 212 }
 213
 214 static DWORD WINAPI d3d8_texture_2d_GetLevelCount(IDirect3DTexture8 *iface)
 215 {
 216     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 217     DWORD ret;
 218
 219     TRACE("iface %p.\n", iface);
 220
 221     wined3d_mutex_lock();
 222     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 223     wined3d_mutex_unlock();
 224
 225     return ret;
 226 }
 227
 228 static HRESULT WINAPI d3d8_texture_2d_GetLevelDesc(IDirect3DTexture8 *iface, UINT level, D3DSURFACE_DESC *desc)
 229 {
 230     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 231     struct wined3d_resource *sub_resource;
 232     HRESULT hr = D3D_OK;
 233
 234     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 235
 236     wined3d_mutex_lock();
 237     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 238         hr = D3DERR_INVALIDCALL;
 239     else
 240     {
 241         struct wined3d_resource_desc wined3d_desc;
 242
 243         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 244         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 245         desc->Type = wined3d_desc.resource_type;
 246         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 247         desc->Pool = wined3d_desc.pool;
 248         desc->Size = wined3d_desc.size;
 249         desc->MultiSampleType = wined3d_desc.multisample_type;
 250         desc->Width = wined3d_desc.width;
 251         desc->Height = wined3d_desc.height;
 252     }
 253     wined3d_mutex_unlock();
 254
 255     return hr;
 256 }
 257
 258 static HRESULT WINAPI d3d8_texture_2d_GetSurfaceLevel(IDirect3DTexture8 *iface,
 259         UINT level, IDirect3DSurface8 **surface)
 260 {
 261     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 262     struct wined3d_resource *sub_resource;
 263     struct d3d8_surface *surface_impl;
 264
 265     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
 266
 267     wined3d_mutex_lock();
 268     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 269     {
 270         wined3d_mutex_unlock();
 271         return D3DERR_INVALIDCALL;
 272     }
 273
 274     surface_impl = wined3d_resource_get_parent(sub_resource);
 275     *surface = &surface_impl->IDirect3DSurface8_iface;
 276     IDirect3DSurface8_AddRef(*surface);
 277     wined3d_mutex_unlock();
 278
 279     return D3D_OK;
 280 }
 281
 282 static HRESULT WINAPI d3d8_texture_2d_LockRect(IDirect3DTexture8 *iface, UINT level,
 283         D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
 284 {
 285     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 286     struct wined3d_resource *sub_resource;
 287     struct d3d8_surface *surface_impl;
 288     HRESULT hr;
 289
 290     TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
 291             iface, level, locked_rect, rect, flags);
 292
 293     wined3d_mutex_lock();
 294     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 295         hr = D3DERR_INVALIDCALL;
 296     else
 297     {
 298         surface_impl = wined3d_resource_get_parent(sub_resource);
 299         hr = IDirect3DSurface8_LockRect(&surface_impl->IDirect3DSurface8_iface, locked_rect, rect, flags);
 300     }
 301     wined3d_mutex_unlock();
 302
 303     return hr;
 304 }
 305
 306 static HRESULT WINAPI d3d8_texture_2d_UnlockRect(IDirect3DTexture8 *iface, UINT level)
 307 {
 308     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 309     struct wined3d_resource *sub_resource;
 310     struct d3d8_surface *surface_impl;
 311     HRESULT hr;
 312
 313     TRACE("iface %p, level %u.\n", iface, level);
 314
 315     wined3d_mutex_lock();
 316     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 317         hr = D3DERR_INVALIDCALL;
 318     else
 319     {
 320         surface_impl = wined3d_resource_get_parent(sub_resource);
 321         hr = IDirect3DSurface8_UnlockRect(&surface_impl->IDirect3DSurface8_iface);
 322     }
 323     wined3d_mutex_unlock();
 324
 325     return hr;
 326 }
 327
 328 static HRESULT WINAPI d3d8_texture_2d_AddDirtyRect(IDirect3DTexture8 *iface, const RECT *dirty_rect)
 329 {
 330     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 331     HRESULT hr;
 332
 333     TRACE("iface %p, dirty_rect %s.\n",
 334             iface, wine_dbgstr_rect(dirty_rect));
 335
 336     wined3d_mutex_lock();
 337     if (!dirty_rect)
 338         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL);
 339     else
 340     {
 341         struct wined3d_box dirty_region;
 342
 343         dirty_region.left = dirty_rect->left;
 344         dirty_region.top = dirty_rect->top;
 345         dirty_region.right = dirty_rect->right;
 346         dirty_region.bottom = dirty_rect->bottom;
 347         dirty_region.front = 0;
 348         dirty_region.back = 1;
 349         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region);
 350     }
 351     wined3d_mutex_unlock();
 352
 353     return hr;
 354 }
 355
 356 static const IDirect3DTexture8Vtbl Direct3DTexture8_Vtbl =
 357 {
 358     /* IUnknown */
 359     d3d8_texture_2d_QueryInterface,
 360     d3d8_texture_2d_AddRef,
 361     d3d8_texture_2d_Release,
 362     /* IDirect3DResource8 */
 363     d3d8_texture_2d_GetDevice,
 364     d3d8_texture_2d_SetPrivateData,
 365     d3d8_texture_2d_GetPrivateData,
 366     d3d8_texture_2d_FreePrivateData,
 367     d3d8_texture_2d_SetPriority,
 368     d3d8_texture_2d_GetPriority,
 369     d3d8_texture_2d_PreLoad,
 370     d3d8_texture_2d_GetType,
 371     /* IDirect3dBaseTexture8 */
 372     d3d8_texture_2d_SetLOD,
 373     d3d8_texture_2d_GetLOD,
 374     d3d8_texture_2d_GetLevelCount,
 375     /* IDirect3DTexture8 */
 376     d3d8_texture_2d_GetLevelDesc,
 377     d3d8_texture_2d_GetSurfaceLevel,
 378     d3d8_texture_2d_LockRect,
 379     d3d8_texture_2d_UnlockRect,
 380     d3d8_texture_2d_AddDirtyRect,
 381 };
 382
 383 static HRESULT WINAPI d3d8_texture_cube_QueryInterface(IDirect3DCubeTexture8 *iface, REFIID riid, void **out)
 384 {
 385     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 386
 387     if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture8)
 388             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8)
 389             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 390             || IsEqualGUID(riid, &IID_IUnknown))
 391     {
 392         IDirect3DCubeTexture8_AddRef(iface);
 393         *out = iface;
 394         return S_OK;
 395     }
 396
 397     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 398
 399     *out = NULL;
 400     return E_NOINTERFACE;
 401 }
 402
 403 static ULONG WINAPI d3d8_texture_cube_AddRef(IDirect3DCubeTexture8 *iface)
 404 {
 405     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 406     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
 407
 408     TRACE("%p increasing refcount to %u.\n", iface, ref);
 409
 410     if (ref == 1)
 411     {
 412         IDirect3DDevice8_AddRef(texture->parent_device);
 413         wined3d_mutex_lock();
 414         wined3d_texture_incref(texture->wined3d_texture);
 415         wined3d_mutex_unlock();
 416     }
 417
 418     return ref;
 419 }
 420
 421 static ULONG WINAPI d3d8_texture_cube_Release(IDirect3DCubeTexture8 *iface)
 422 {
 423     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 424     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
 425
 426     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 427
 428     if (!ref)
 429     {
 430         IDirect3DDevice8 *parent_device = texture->parent_device;
 431
 432         TRACE("Releasing child %p.\n", texture->wined3d_texture);
 433
 434         wined3d_mutex_lock();
 435         wined3d_texture_decref(texture->wined3d_texture);
 436         wined3d_mutex_unlock();
 437
 438         /* Release the device last, as it may cause the device to be destroyed. */
 439         IDirect3DDevice8_Release(parent_device);
 440     }
 441     return ref;
 442 }
 443
 444 static HRESULT WINAPI d3d8_texture_cube_GetDevice(IDirect3DCubeTexture8 *iface, IDirect3DDevice8 **device)
 445 {
 446     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 447
 448     TRACE("iface %p, device %p.\n", iface, device);
 449
 450     *device = texture->parent_device;
 451     IDirect3DDevice8_AddRef(*device);
 452
 453     TRACE("Returning device %p.\n", *device);
 454
 455     return D3D_OK;
 456 }
 457
 458 static HRESULT WINAPI d3d8_texture_cube_SetPrivateData(IDirect3DCubeTexture8 *iface,
 459         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 460 {
 461     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 462     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 463             iface, debugstr_guid(guid), data, data_size, flags);
 464
 465     return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 466 }
 467
 468 static HRESULT WINAPI d3d8_texture_cube_GetPrivateData(IDirect3DCubeTexture8 *iface,
 469         REFGUID guid, void *data, DWORD *data_size)
 470 {
 471     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 472     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 473             iface, debugstr_guid(guid), data, data_size);
 474
 475     return d3d8_resource_get_private_data(&texture->resource, guid, data, data_size);
 476 }
 477
 478 static HRESULT WINAPI d3d8_texture_cube_FreePrivateData(IDirect3DCubeTexture8 *iface, REFGUID guid)
 479 {
 480     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 481     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 482
 483     return d3d8_resource_free_private_data(&texture->resource, guid);
 484 }
 485
 486 static DWORD WINAPI d3d8_texture_cube_SetPriority(IDirect3DCubeTexture8 *iface, DWORD priority)
 487 {
 488     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 489     DWORD ret;
 490
 491     TRACE("iface %p, priority %u.\n", iface, priority);
 492
 493     wined3d_mutex_lock();
 494     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 495     wined3d_mutex_unlock();
 496
 497     return ret;
 498 }
 499
 500 static DWORD WINAPI d3d8_texture_cube_GetPriority(IDirect3DCubeTexture8 *iface)
 501 {
 502     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 503     DWORD ret;
 504
 505     TRACE("iface %p.\n", iface);
 506
 507     wined3d_mutex_lock();
 508     ret =  wined3d_texture_get_priority(texture->wined3d_texture);
 509     wined3d_mutex_unlock();
 510
 511     return ret;
 512 }
 513
 514 static void WINAPI d3d8_texture_cube_PreLoad(IDirect3DCubeTexture8 *iface)
 515 {
 516     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 517
 518     TRACE("iface %p.\n", iface);
 519
 520     wined3d_mutex_lock();
 521     wined3d_texture_preload(texture->wined3d_texture);
 522     wined3d_mutex_unlock();
 523 }
 524
 525 static D3DRESOURCETYPE WINAPI d3d8_texture_cube_GetType(IDirect3DCubeTexture8 *iface)
 526 {
 527     TRACE("iface %p.\n", iface);
 528
 529     return D3DRTYPE_CUBETEXTURE;
 530 }
 531
 532 static DWORD WINAPI d3d8_texture_cube_SetLOD(IDirect3DCubeTexture8 *iface, DWORD lod)
 533 {
 534     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 535     DWORD ret;
 536
 537     TRACE("iface %p, lod %u.\n", iface, lod);
 538
 539     wined3d_mutex_lock();
 540     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 541     wined3d_mutex_unlock();
 542
 543     return ret;
 544 }
 545
 546 static DWORD WINAPI d3d8_texture_cube_GetLOD(IDirect3DCubeTexture8 *iface)
 547 {
 548     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 549     DWORD ret;
 550
 551     TRACE("iface %p.\n", iface);
 552
 553     wined3d_mutex_lock();
 554     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 555     wined3d_mutex_unlock();
 556
 557     return ret;
 558 }
 559
 560 static DWORD WINAPI d3d8_texture_cube_GetLevelCount(IDirect3DCubeTexture8 *iface)
 561 {
 562     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 563     DWORD ret;
 564
 565     TRACE("iface %p.\n", iface);
 566
 567     wined3d_mutex_lock();
 568     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 569     wined3d_mutex_unlock();
 570
 571     return ret;
 572 }
 573
 574 static HRESULT WINAPI d3d8_texture_cube_GetLevelDesc(IDirect3DCubeTexture8 *iface, UINT level, D3DSURFACE_DESC *desc)
 575 {
 576     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 577     struct wined3d_resource *sub_resource;
 578     HRESULT hr = D3D_OK;
 579
 580     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 581
 582     wined3d_mutex_lock();
 583     if (level >= wined3d_texture_get_level_count(texture->wined3d_texture))
 584     {
 585         wined3d_mutex_unlock();
 586         return D3DERR_INVALIDCALL;
 587     }
 588
 589     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 590         hr = D3DERR_INVALIDCALL;
 591     else
 592     {
 593         struct wined3d_resource_desc wined3d_desc;
 594
 595         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 596         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 597         desc->Type = wined3d_desc.resource_type;
 598         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 599         desc->Pool = wined3d_desc.pool;
 600         desc->Size = wined3d_desc.size;
 601         desc->MultiSampleType = wined3d_desc.multisample_type;
 602         desc->Width = wined3d_desc.width;
 603         desc->Height = wined3d_desc.height;
 604     }
 605     wined3d_mutex_unlock();
 606
 607     return hr;
 608 }
 609
 610 static HRESULT WINAPI d3d8_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture8 *iface,
 611         D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface8 **surface)
 612 {
 613     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 614     struct wined3d_resource *sub_resource;
 615     struct d3d8_surface *surface_impl;
 616     UINT sub_resource_idx;
 617     DWORD level_count;
 618
 619     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
 620
 621     wined3d_mutex_lock();
 622     level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
 623     if (level >= level_count)
 624     {
 625         wined3d_mutex_unlock();
 626         return D3DERR_INVALIDCALL;
 627     }
 628
 629     sub_resource_idx = level_count * face + level;
 630     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 631     {
 632         wined3d_mutex_unlock();
 633         return D3DERR_INVALIDCALL;
 634     }
 635
 636     surface_impl = wined3d_resource_get_parent(sub_resource);
 637     *surface = &surface_impl->IDirect3DSurface8_iface;
 638     IDirect3DSurface8_AddRef(*surface);
 639     wined3d_mutex_unlock();
 640
 641     return D3D_OK;
 642 }
 643
 644 static HRESULT WINAPI d3d8_texture_cube_LockRect(IDirect3DCubeTexture8 *iface,
 645         D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
 646         DWORD flags)
 647 {
 648     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 649     struct wined3d_resource *sub_resource;
 650     struct d3d8_surface *surface_impl;
 651     UINT sub_resource_idx;
 652     HRESULT hr;
 653
 654     TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
 655             iface, face, level, locked_rect, rect, flags);
 656
 657     wined3d_mutex_lock();
 658     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 659     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 660         hr = D3DERR_INVALIDCALL;
 661     else
 662     {
 663         surface_impl = wined3d_resource_get_parent(sub_resource);
 664         hr = IDirect3DSurface8_LockRect(&surface_impl->IDirect3DSurface8_iface, locked_rect, rect, flags);
 665     }
 666     wined3d_mutex_unlock();
 667
 668     return hr;
 669 }
 670
 671 static HRESULT WINAPI d3d8_texture_cube_UnlockRect(IDirect3DCubeTexture8 *iface,
 672         D3DCUBEMAP_FACES face, UINT level)
 673 {
 674     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 675     struct wined3d_resource *sub_resource;
 676     struct d3d8_surface *surface_impl;
 677     UINT sub_resource_idx;
 678     HRESULT hr;
 679
 680     TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
 681
 682     wined3d_mutex_lock();
 683     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 684     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
 685         hr = D3DERR_INVALIDCALL;
 686     else
 687     {
 688         surface_impl = wined3d_resource_get_parent(sub_resource);
 689         hr = IDirect3DSurface8_UnlockRect(&surface_impl->IDirect3DSurface8_iface);
 690     }
 691     wined3d_mutex_unlock();
 692
 693     return hr;
 694 }
 695
 696 static HRESULT WINAPI d3d8_texture_cube_AddDirtyRect(IDirect3DCubeTexture8 *iface,
 697         D3DCUBEMAP_FACES face, const RECT *dirty_rect)
 698 {
 699     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 700     HRESULT hr;
 701
 702     TRACE("iface %p, face %#x, dirty_rect %s.\n",
 703             iface, face, wine_dbgstr_rect(dirty_rect));
 704
 705     wined3d_mutex_lock();
 706     if (!dirty_rect)
 707         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
 708     else
 709     {
 710         struct wined3d_box dirty_region;
 711
 712         dirty_region.left = dirty_rect->left;
 713         dirty_region.top = dirty_rect->top;
 714         dirty_region.right = dirty_rect->right;
 715         dirty_region.bottom = dirty_rect->bottom;
 716         dirty_region.front = 0;
 717         dirty_region.back = 1;
 718         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
 719     }
 720     wined3d_mutex_unlock();
 721
 722     return hr;
 723 }
 724
 725 static const IDirect3DCubeTexture8Vtbl Direct3DCubeTexture8_Vtbl =
 726 {
 727     /* IUnknown */
 728     d3d8_texture_cube_QueryInterface,
 729     d3d8_texture_cube_AddRef,
 730     d3d8_texture_cube_Release,
 731     /* IDirect3DResource8 */
 732     d3d8_texture_cube_GetDevice,
 733     d3d8_texture_cube_SetPrivateData,
 734     d3d8_texture_cube_GetPrivateData,
 735     d3d8_texture_cube_FreePrivateData,
 736     d3d8_texture_cube_SetPriority,
 737     d3d8_texture_cube_GetPriority,
 738     d3d8_texture_cube_PreLoad,
 739     d3d8_texture_cube_GetType,
 740     /* IDirect3DBaseTexture8 */
 741     d3d8_texture_cube_SetLOD,
 742     d3d8_texture_cube_GetLOD,
 743     d3d8_texture_cube_GetLevelCount,
 744     /* IDirect3DCubeTexture8 */
 745     d3d8_texture_cube_GetLevelDesc,
 746     d3d8_texture_cube_GetCubeMapSurface,
 747     d3d8_texture_cube_LockRect,
 748     d3d8_texture_cube_UnlockRect,
 749     d3d8_texture_cube_AddDirtyRect,
 750 };
 751
 752 static HRESULT WINAPI d3d8_texture_3d_QueryInterface(IDirect3DVolumeTexture8 *iface, REFIID riid, void **out)
 753 {
 754     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 755
 756     if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture8)
 757             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8)
 758             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 759             || IsEqualGUID(riid, &IID_IUnknown))
 760     {
 761         IDirect3DVolumeTexture8_AddRef(iface);
 762         *out = iface;
 763         return S_OK;
 764     }
 765
 766     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 767
 768     *out = NULL;
 769     return E_NOINTERFACE;
 770 }
 771
 772 static ULONG WINAPI d3d8_texture_3d_AddRef(IDirect3DVolumeTexture8 *iface)
 773 {
 774     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 775     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
 776
 777     TRACE("%p increasing refcount to %u.\n", iface, ref);
 778
 779     if (ref == 1)
 780     {
 781         IDirect3DDevice8_AddRef(texture->parent_device);
 782         wined3d_mutex_lock();
 783         wined3d_texture_incref(texture->wined3d_texture);
 784         wined3d_mutex_unlock();
 785     }
 786
 787     return ref;
 788 }
 789
 790 static ULONG WINAPI d3d8_texture_3d_Release(IDirect3DVolumeTexture8 *iface)
 791 {
 792     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 793     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
 794
 795     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 796
 797     if (!ref)
 798     {
 799         IDirect3DDevice8 *parent_device = texture->parent_device;
 800
 801         wined3d_mutex_lock();
 802         wined3d_texture_decref(texture->wined3d_texture);
 803         wined3d_mutex_unlock();
 804
 805         /* Release the device last, as it may cause the device to be destroyed. */
 806         IDirect3DDevice8_Release(parent_device);
 807     }
 808     return ref;
 809 }
 810
 811 static HRESULT WINAPI d3d8_texture_3d_GetDevice(IDirect3DVolumeTexture8 *iface, IDirect3DDevice8 **device)
 812 {
 813     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 814
 815     TRACE("iface %p, device %p.\n", iface, device);
 816
 817     *device = texture->parent_device;
 818     IDirect3DDevice8_AddRef(*device);
 819
 820     TRACE("Returning device %p.\n", *device);
 821
 822     return D3D_OK;
 823 }
 824
 825 static HRESULT WINAPI d3d8_texture_3d_SetPrivateData(IDirect3DVolumeTexture8 *iface,
 826         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 827 {
 828     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 829     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 830             iface, debugstr_guid(guid), data, data_size, flags);
 831
 832     return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 833 }
 834
 835 static HRESULT WINAPI d3d8_texture_3d_GetPrivateData(IDirect3DVolumeTexture8 *iface,
 836         REFGUID guid, void *data, DWORD *data_size)
 837 {
 838     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 839     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 840             iface, debugstr_guid(guid), data, data_size);
 841
 842     return d3d8_resource_get_private_data(&texture->resource, guid, data, data_size);
 843 }
 844
 845 static HRESULT WINAPI d3d8_texture_3d_FreePrivateData(IDirect3DVolumeTexture8 *iface, REFGUID guid)
 846 {
 847     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 848     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 849
 850     return d3d8_resource_free_private_data(&texture->resource, guid);
 851 }
 852
 853 static DWORD WINAPI d3d8_texture_3d_SetPriority(IDirect3DVolumeTexture8 *iface, DWORD priority)
 854 {
 855     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 856     DWORD ret;
 857
 858     TRACE("iface %p, priority %u.\n", iface, priority);
 859
 860     wined3d_mutex_lock();
 861     ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
 862     wined3d_mutex_unlock();
 863
 864     return ret;
 865 }
 866
 867 static DWORD WINAPI d3d8_texture_3d_GetPriority(IDirect3DVolumeTexture8 *iface)
 868 {
 869     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 870     DWORD ret;
 871
 872     TRACE("iface %p.\n", iface);
 873
 874     wined3d_mutex_lock();
 875     ret = wined3d_texture_get_priority(texture->wined3d_texture);
 876     wined3d_mutex_unlock();
 877
 878     return ret;
 879 }
 880
 881 static void WINAPI d3d8_texture_3d_PreLoad(IDirect3DVolumeTexture8 *iface)
 882 {
 883     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 884
 885     TRACE("iface %p.\n", iface);
 886
 887     wined3d_mutex_lock();
 888     wined3d_texture_preload(texture->wined3d_texture);
 889     wined3d_mutex_unlock();
 890 }
 891
 892 static D3DRESOURCETYPE WINAPI d3d8_texture_3d_GetType(IDirect3DVolumeTexture8 *iface)
 893 {
 894     TRACE("iface %p.\n", iface);
 895
 896     return D3DRTYPE_VOLUMETEXTURE;
 897 }
 898
 899 static DWORD WINAPI d3d8_texture_3d_SetLOD(IDirect3DVolumeTexture8 *iface, DWORD lod)
 900 {
 901     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 902     DWORD ret;
 903
 904     TRACE("iface %p, lod %u.\n", iface, lod);
 905
 906     wined3d_mutex_lock();
 907     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 908     wined3d_mutex_unlock();
 909
 910     return ret;
 911 }
 912
 913 static DWORD WINAPI d3d8_texture_3d_GetLOD(IDirect3DVolumeTexture8 *iface)
 914 {
 915     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 916     DWORD ret;
 917
 918     TRACE("iface %p.\n", iface);
 919
 920     wined3d_mutex_lock();
 921     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 922     wined3d_mutex_unlock();
 923
 924     return ret;
 925 }
 926
 927 static DWORD WINAPI d3d8_texture_3d_GetLevelCount(IDirect3DVolumeTexture8 *iface)
 928 {
 929     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 930     DWORD ret;
 931
 932     TRACE("iface %p.\n", iface);
 933
 934     wined3d_mutex_lock();
 935     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 936     wined3d_mutex_unlock();
 937
 938     return ret;
 939 }
 940
 941 static HRESULT WINAPI d3d8_texture_3d_GetLevelDesc(IDirect3DVolumeTexture8 *iface, UINT level, D3DVOLUME_DESC *desc)
 942 {
 943     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 944     struct wined3d_resource *sub_resource;
 945     HRESULT hr = D3D_OK;
 946
 947     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 948
 949     wined3d_mutex_lock();
 950     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 951         hr = D3DERR_INVALIDCALL;
 952     else
 953     {
 954         struct wined3d_resource_desc wined3d_desc;
 955
 956         wined3d_resource_get_desc(sub_resource, &wined3d_desc);
 957         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 958         desc->Type = wined3d_desc.resource_type;
 959         desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 960         desc->Pool = wined3d_desc.pool;
 961         desc->Size = wined3d_desc.size;
 962         desc->Width = wined3d_desc.width;
 963         desc->Height = wined3d_desc.height;
 964         desc->Depth = wined3d_desc.depth;
 965     }
 966     wined3d_mutex_unlock();
 967
 968     return hr;
 969 }
 970
 971 static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *iface,
 972         UINT level, IDirect3DVolume8 **volume)
 973 {
 974     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 975     struct wined3d_resource *sub_resource;
 976     struct d3d8_volume *volume_impl;
 977
 978     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
 979
 980     wined3d_mutex_lock();
 981     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
 982     {
 983         wined3d_mutex_unlock();
 984         return D3DERR_INVALIDCALL;
 985     }
 986
 987     volume_impl = wined3d_resource_get_parent(sub_resource);
 988     *volume = &volume_impl->IDirect3DVolume8_iface;
 989     IDirect3DVolume8_AddRef(*volume);
 990     wined3d_mutex_unlock();
 991
 992     return D3D_OK;
 993 }
 994
 995 static HRESULT WINAPI d3d8_texture_3d_LockBox(IDirect3DVolumeTexture8 *iface,
 996         UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
 997 {
 998     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 999     struct wined3d_resource *sub_resource;
1000     struct d3d8_volume *volume_impl;
1001     HRESULT hr;
1002
1003     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
1004             iface, level, locked_box, box, flags);
1005
1006     wined3d_mutex_lock();
1007     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1008         hr = D3DERR_INVALIDCALL;
1009     else
1010     {
1011         volume_impl = wined3d_resource_get_parent(sub_resource);
1012         hr = IDirect3DVolume8_LockBox(&volume_impl->IDirect3DVolume8_iface, locked_box, box, flags);
1013     }
1014     wined3d_mutex_unlock();
1015
1016     return hr;
1017 }
1018
1019 static HRESULT WINAPI d3d8_texture_3d_UnlockBox(IDirect3DVolumeTexture8 *iface, UINT level)
1020 {
1021     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
1022     struct wined3d_resource *sub_resource;
1023     struct d3d8_volume *volume_impl;
1024     HRESULT hr;
1025
1026     TRACE("iface %p, level %u.\n", iface, level);
1027
1028     wined3d_mutex_lock();
1029     if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1030         hr = D3DERR_INVALIDCALL;
1031     else
1032     {
1033         volume_impl = wined3d_resource_get_parent(sub_resource);
1034         hr = IDirect3DVolume8_UnlockBox(&volume_impl->IDirect3DVolume8_iface);
1035     }
1036     wined3d_mutex_unlock();
1037
1038     return hr;
1039 }
1040
1041 static HRESULT WINAPI d3d8_texture_3d_AddDirtyBox(IDirect3DVolumeTexture8 *iface, const D3DBOX *dirty_box)
1042 {
1043     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
1044     HRESULT hr;
1045
1046     TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
1047
1048     wined3d_mutex_lock();
1049     hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
1050     wined3d_mutex_unlock();
1051
1052     return hr;
1053 }
1054
1055 static const IDirect3DVolumeTexture8Vtbl Direct3DVolumeTexture8_Vtbl =
1056 {
1057     /* IUnknown */
1058     d3d8_texture_3d_QueryInterface,
1059     d3d8_texture_3d_AddRef,
1060     d3d8_texture_3d_Release,
1061     /* IDirect3DResource8 */
1062     d3d8_texture_3d_GetDevice,
1063     d3d8_texture_3d_SetPrivateData,
1064     d3d8_texture_3d_GetPrivateData,
1065     d3d8_texture_3d_FreePrivateData,
1066     d3d8_texture_3d_SetPriority,
1067     d3d8_texture_3d_GetPriority,
1068     d3d8_texture_3d_PreLoad,
1069     d3d8_texture_3d_GetType,
1070     /* IDirect3DBaseTexture8 */
1071     d3d8_texture_3d_SetLOD,
1072     d3d8_texture_3d_GetLOD,
1073     d3d8_texture_3d_GetLevelCount,
1074     /* IDirect3DVolumeTexture8 */
1075     d3d8_texture_3d_GetLevelDesc,
1076     d3d8_texture_3d_GetVolumeLevel,
1077     d3d8_texture_3d_LockBox,
1078     d3d8_texture_3d_UnlockBox,
1079     d3d8_texture_3d_AddDirtyBox
1080 };
1081
1082 struct d3d8_texture *unsafe_impl_from_IDirect3DBaseTexture8(IDirect3DBaseTexture8 *iface)
1083 {
1084     if (!iface)
1085         return NULL;
1086
1087     /* SetTexture() in particular doesn't do a lot of validation on the pointer
1088      * that gets passed in, and passing an invalid pointer works as long as the
1089      * application doesn't try to actually render anything with it, so we print
1090      * a WARN and return NULL instead of having the usual assert() here.
1091      * One application affected by this is Fishdom 2. */
1092     if (iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl
1093             && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl
1094             && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl)
1095     {
1096         WARN("%p is not a valid IDirect3DBaseTexture8 interface.\n", iface);
1097         return NULL;
1098     }
1099
1100     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
1101 }
1102
1103 static void STDMETHODCALLTYPE d3d8_texture_wined3d_object_destroyed(void *parent)
1104 {
1105     struct d3d8_texture *texture = parent;
1106     d3d8_resource_cleanup(&texture->resource);
1107     HeapFree(GetProcessHeap(), 0, texture);
1108 }
1109
1110 static const struct wined3d_parent_ops d3d8_texture_wined3d_parent_ops =
1111 {
1112     d3d8_texture_wined3d_object_destroyed,
1113 };
1114
1115 HRESULT texture_init(struct d3d8_texture *texture, struct d3d8_device *device,
1116         UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1117 {
1118     struct wined3d_resource_desc desc;
1119     DWORD surface_flags = 0;
1120     HRESULT hr;
1121
1122     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl;
1123     d3d8_resource_init(&texture->resource);
1124
1125     desc.resource_type = WINED3D_RTYPE_TEXTURE;
1126     desc.format = wined3dformat_from_d3dformat(format);
1127     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1128     desc.multisample_quality = 0;
1129     desc.usage = usage & WINED3DUSAGE_MASK;
1130     desc.usage |= WINED3DUSAGE_TEXTURE;
1131     desc.pool = pool;
1132     desc.width = width;
1133     desc.height = height;
1134     desc.depth = 1;
1135     desc.size = 0;
1136
1137     if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
1138         surface_flags |= WINED3D_SURFACE_MAPPABLE;
1139
1140     wined3d_mutex_lock();
1141     hr = wined3d_texture_create(device->wined3d_device, &desc, levels, surface_flags,
1142             texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture);
1143     wined3d_mutex_unlock();
1144     if (FAILED(hr))
1145     {
1146         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1147         return hr;
1148     }
1149
1150     texture->parent_device = &device->IDirect3DDevice8_iface;
1151     IDirect3DDevice8_AddRef(texture->parent_device);
1152
1153     return D3D_OK;
1154 }
1155
1156 HRESULT cubetexture_init(struct d3d8_texture *texture, struct d3d8_device *device,
1157         UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1158 {
1159     struct wined3d_resource_desc desc;
1160     DWORD surface_flags = 0;
1161     HRESULT hr;
1162
1163     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl;
1164     d3d8_resource_init(&texture->resource);
1165
1166     desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE;
1167     desc.format = wined3dformat_from_d3dformat(format);
1168     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1169     desc.multisample_quality = 0;
1170     desc.usage = usage & WINED3DUSAGE_MASK;
1171     desc.usage |= WINED3DUSAGE_TEXTURE;
1172     desc.pool = pool;
1173     desc.width = edge_length;
1174     desc.height = edge_length;
1175     desc.depth = 1;
1176     desc.size = 0;
1177
1178     if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
1179         surface_flags |= WINED3D_SURFACE_MAPPABLE;
1180
1181     wined3d_mutex_lock();
1182     hr = wined3d_texture_create(device->wined3d_device, &desc, levels, surface_flags,
1183             texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture);
1184     wined3d_mutex_unlock();
1185     if (FAILED(hr))
1186     {
1187         WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
1188         return hr;
1189     }
1190
1191     texture->parent_device = &device->IDirect3DDevice8_iface;
1192     IDirect3DDevice8_AddRef(texture->parent_device);
1193
1194     return D3D_OK;
1195 }
1196
1197 HRESULT volumetexture_init(struct d3d8_texture *texture, struct d3d8_device *device,
1198         UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1199 {
1200     struct wined3d_resource_desc desc;
1201     HRESULT hr;
1202
1203     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl;
1204     d3d8_resource_init(&texture->resource);
1205
1206     desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE;
1207     desc.format = wined3dformat_from_d3dformat(format);
1208     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1209     desc.multisample_quality = 0;
1210     desc.usage = usage & WINED3DUSAGE_MASK;
1211     desc.usage |= WINED3DUSAGE_TEXTURE;
1212     desc.pool = pool;
1213     desc.width = width;
1214     desc.height = height;
1215     desc.depth = depth;
1216     desc.size = 0;
1217
1218     wined3d_mutex_lock();
1219     hr = wined3d_texture_create(device->wined3d_device, &desc, levels, 0,
1220             texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture);
1221     wined3d_mutex_unlock();
1222     if (FAILED(hr))
1223     {
1224         WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
1225         return hr;
1226     }
1227
1228     texture->parent_device = &device->IDirect3DDevice8_iface;
1229     IDirect3DDevice8_AddRef(texture->parent_device);
1230
1231     return D3D_OK;
1232 }