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