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);
  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;
  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     struct d3d8_device *device = impl_from_IDirect3DDevice8(texture->parent_device);
  74
  75     wined3d_mutex_lock();
  76     if (texture->draw_texture)
  77         wined3d_device_update_texture(device->wined3d_device, texture->wined3d_texture, texture->draw_texture);
  78     else
  79         wined3d_resource_preload(wined3d_texture_get_resource(texture->wined3d_texture));
  80     wined3d_mutex_unlock();
  81 }
  82
  83 static inline struct d3d8_texture *impl_from_IDirect3DTexture8(IDirect3DTexture8 *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  86 }
  87
  88 static inline struct d3d8_texture *impl_from_IDirect3DCubeTexture8(IDirect3DCubeTexture8 *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  91 }
  92
  93 static inline struct d3d8_texture *impl_from_IDirect3DVolumeTexture8(IDirect3DVolumeTexture8 *iface)
  94 {
  95     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
  96 }
  97
  98 static HRESULT WINAPI d3d8_texture_2d_QueryInterface(IDirect3DTexture8 *iface, REFIID riid, void **out)
  99 {
 100     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 101
 102     if (IsEqualGUID(riid, &IID_IDirect3DTexture8)
 103             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8)
 104             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 105             || IsEqualGUID(riid, &IID_IUnknown))
 106     {
 107         IDirect3DTexture8_AddRef(iface);
 108         *out = iface;
 109         return S_OK;
 110     }
 111
 112     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 113
 114     *out = NULL;
 115     return E_NOINTERFACE;
 116 }
 117
 118 static ULONG WINAPI d3d8_texture_2d_AddRef(IDirect3DTexture8 *iface)
 119 {
 120     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 121
 122     return d3d8_texture_incref(texture);
 123 }
 124
 125 static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface)
 126 {
 127     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 128
 129     return d3d8_texture_decref(texture);
 130 }
 131
 132 static HRESULT WINAPI d3d8_texture_2d_GetDevice(IDirect3DTexture8 *iface, IDirect3DDevice8 **device)
 133 {
 134     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 135
 136     TRACE("iface %p, device %p.\n", iface, device);
 137
 138     *device = texture->parent_device;
 139     IDirect3DDevice8_AddRef(*device);
 140
 141     TRACE("Returning device %p.\n", *device);
 142
 143     return D3D_OK;
 144 }
 145
 146 static HRESULT WINAPI d3d8_texture_2d_SetPrivateData(IDirect3DTexture8 *iface,
 147         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 148 {
 149     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 150     TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
 151             iface, debugstr_guid(guid), data, data_size, flags);
 152
 153     return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 154 }
 155
 156 static HRESULT WINAPI d3d8_texture_2d_GetPrivateData(IDirect3DTexture8 *iface,
 157         REFGUID guid, void *data, DWORD *data_size)
 158 {
 159     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 160     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 161             iface, debugstr_guid(guid), data, data_size);
 162
 163     return d3d8_resource_get_private_data(&texture->resource, guid, data, data_size);
 164 }
 165
 166 static HRESULT WINAPI d3d8_texture_2d_FreePrivateData(IDirect3DTexture8 *iface, REFGUID guid)
 167 {
 168     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 169     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 170
 171     return d3d8_resource_free_private_data(&texture->resource, guid);
 172 }
 173
 174 static DWORD WINAPI d3d8_texture_2d_SetPriority(IDirect3DTexture8 *iface, DWORD priority)
 175 {
 176     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 177     struct wined3d_resource *resource;
 178     DWORD ret;
 179
 180     TRACE("iface %p, priority %lu.\n", iface, priority);
 181
 182     wined3d_mutex_lock();
 183     resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
 184     ret = wined3d_resource_set_priority(resource, priority);
 185     wined3d_mutex_unlock();
 186
 187     return ret;
 188 }
 189
 190 static DWORD WINAPI d3d8_texture_2d_GetPriority(IDirect3DTexture8 *iface)
 191 {
 192     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 193     const struct wined3d_resource *resource;
 194     DWORD ret;
 195
 196     TRACE("iface %p.\n", iface);
 197
 198     wined3d_mutex_lock();
 199     resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
 200     ret = wined3d_resource_get_priority(resource);
 201     wined3d_mutex_unlock();
 202
 203     return ret;
 204 }
 205
 206 static void WINAPI d3d8_texture_2d_PreLoad(IDirect3DTexture8 *iface)
 207 {
 208     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 209
 210     TRACE("iface %p.\n", iface);
 211
 212     d3d8_texture_preload(texture);
 213 }
 214
 215 static D3DRESOURCETYPE WINAPI d3d8_texture_2d_GetType(IDirect3DTexture8 *iface)
 216 {
 217     TRACE("iface %p.\n", iface);
 218
 219     return D3DRTYPE_TEXTURE;
 220 }
 221
 222 static DWORD WINAPI d3d8_texture_2d_SetLOD(IDirect3DTexture8 *iface, DWORD lod)
 223 {
 224     struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
 225     DWORD ret;
 226
 227     TRACE("iface %p, lod %lu.\n", iface, lod);
 228
 229     wined3d_mutex_lock();
 230     ret = wined3d_texture_set_lod(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;
 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_texture_set_lod(d3d8_texture_get_draw_texture(texture), lod);
 532     wined3d_mutex_unlock();
 533
 534     return ret;
 535 }
 536
 537 static DWORD WINAPI d3d8_texture_cube_GetLOD(IDirect3DCubeTexture8 *iface)
 538 {
 539     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 540     DWORD ret;
 541
 542     TRACE("iface %p.\n", iface);
 543
 544     wined3d_mutex_lock();
 545     ret = wined3d_texture_get_lod(d3d8_texture_get_draw_texture(texture));
 546     wined3d_mutex_unlock();
 547
 548     return ret;
 549 }
 550
 551 static DWORD WINAPI d3d8_texture_cube_GetLevelCount(IDirect3DCubeTexture8 *iface)
 552 {
 553     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 554     DWORD ret;
 555
 556     TRACE("iface %p.\n", iface);
 557
 558     wined3d_mutex_lock();
 559     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 560     wined3d_mutex_unlock();
 561
 562     return ret;
 563 }
 564
 565 static HRESULT WINAPI d3d8_texture_cube_GetLevelDesc(IDirect3DCubeTexture8 *iface, UINT level, D3DSURFACE_DESC *desc)
 566 {
 567     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 568     struct wined3d_sub_resource_desc wined3d_desc;
 569     HRESULT hr;
 570
 571     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 572
 573     wined3d_mutex_lock();
 574     if (level >= wined3d_texture_get_level_count(texture->wined3d_texture))
 575     {
 576         wined3d_mutex_unlock();
 577         return D3DERR_INVALIDCALL;
 578     }
 579
 580     if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc)))
 581     {
 582         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 583         desc->Type = D3DRTYPE_SURFACE;
 584         desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage, wined3d_desc.bind_flags);
 585         desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 586         desc->Size = wined3d_desc.size;
 587         desc->MultiSampleType = d3dmultisample_type_from_wined3d(wined3d_desc.multisample_type);
 588         desc->Width = wined3d_desc.width;
 589         desc->Height = wined3d_desc.height;
 590     }
 591     wined3d_mutex_unlock();
 592
 593     return hr;
 594 }
 595
 596 static HRESULT WINAPI d3d8_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture8 *iface,
 597         D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface8 **surface)
 598 {
 599     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 600     struct d3d8_surface *surface_impl;
 601     UINT sub_resource_idx;
 602     DWORD level_count;
 603
 604     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
 605
 606     wined3d_mutex_lock();
 607     level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
 608     if (level >= level_count)
 609     {
 610         wined3d_mutex_unlock();
 611         return D3DERR_INVALIDCALL;
 612     }
 613
 614     sub_resource_idx = level_count * face + level;
 615     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 616     {
 617         wined3d_mutex_unlock();
 618         return D3DERR_INVALIDCALL;
 619     }
 620
 621     *surface = &surface_impl->IDirect3DSurface8_iface;
 622     IDirect3DSurface8_AddRef(*surface);
 623     wined3d_mutex_unlock();
 624
 625     return D3D_OK;
 626 }
 627
 628 static HRESULT WINAPI d3d8_texture_cube_LockRect(IDirect3DCubeTexture8 *iface,
 629         D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
 630         DWORD flags)
 631 {
 632     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 633     struct d3d8_surface *surface_impl;
 634     UINT sub_resource_idx;
 635     HRESULT hr;
 636
 637     TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#lx.\n",
 638             iface, face, level, locked_rect, rect, flags);
 639
 640     wined3d_mutex_lock();
 641     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 642     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 643         hr = D3DERR_INVALIDCALL;
 644     else
 645         hr = IDirect3DSurface8_LockRect(&surface_impl->IDirect3DSurface8_iface, locked_rect, rect, flags);
 646     wined3d_mutex_unlock();
 647
 648     return hr;
 649 }
 650
 651 static HRESULT WINAPI d3d8_texture_cube_UnlockRect(IDirect3DCubeTexture8 *iface,
 652         D3DCUBEMAP_FACES face, UINT level)
 653 {
 654     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 655     struct d3d8_surface *surface_impl;
 656     UINT sub_resource_idx;
 657     HRESULT hr;
 658
 659     TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
 660
 661     wined3d_mutex_lock();
 662     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 663     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 664         hr = D3DERR_INVALIDCALL;
 665     else
 666         hr = IDirect3DSurface8_UnlockRect(&surface_impl->IDirect3DSurface8_iface);
 667     wined3d_mutex_unlock();
 668
 669     return hr;
 670 }
 671
 672 static HRESULT WINAPI d3d8_texture_cube_AddDirtyRect(IDirect3DCubeTexture8 *iface,
 673         D3DCUBEMAP_FACES face, const RECT *dirty_rect)
 674 {
 675     struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
 676     HRESULT hr;
 677
 678     TRACE("iface %p, face %#x, dirty_rect %s.\n",
 679             iface, face, wine_dbgstr_rect(dirty_rect));
 680
 681     wined3d_mutex_lock();
 682     if (!dirty_rect)
 683         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
 684     else
 685     {
 686         struct wined3d_box dirty_region;
 687
 688         wined3d_box_set(&dirty_region, dirty_rect->left, dirty_rect->top, dirty_rect->right, dirty_rect->bottom, 0, 1);
 689         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
 690     }
 691     wined3d_mutex_unlock();
 692
 693     return hr;
 694 }
 695
 696 static const IDirect3DCubeTexture8Vtbl Direct3DCubeTexture8_Vtbl =
 697 {
 698     /* IUnknown */
 699     d3d8_texture_cube_QueryInterface,
 700     d3d8_texture_cube_AddRef,
 701     d3d8_texture_cube_Release,
 702     /* IDirect3DResource8 */
 703     d3d8_texture_cube_GetDevice,
 704     d3d8_texture_cube_SetPrivateData,
 705     d3d8_texture_cube_GetPrivateData,
 706     d3d8_texture_cube_FreePrivateData,
 707     d3d8_texture_cube_SetPriority,
 708     d3d8_texture_cube_GetPriority,
 709     d3d8_texture_cube_PreLoad,
 710     d3d8_texture_cube_GetType,
 711     /* IDirect3DBaseTexture8 */
 712     d3d8_texture_cube_SetLOD,
 713     d3d8_texture_cube_GetLOD,
 714     d3d8_texture_cube_GetLevelCount,
 715     /* IDirect3DCubeTexture8 */
 716     d3d8_texture_cube_GetLevelDesc,
 717     d3d8_texture_cube_GetCubeMapSurface,
 718     d3d8_texture_cube_LockRect,
 719     d3d8_texture_cube_UnlockRect,
 720     d3d8_texture_cube_AddDirtyRect,
 721 };
 722
 723 static HRESULT WINAPI d3d8_texture_3d_QueryInterface(IDirect3DVolumeTexture8 *iface, REFIID riid, void **out)
 724 {
 725     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 726
 727     if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture8)
 728             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8)
 729             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 730             || IsEqualGUID(riid, &IID_IUnknown))
 731     {
 732         IDirect3DVolumeTexture8_AddRef(iface);
 733         *out = iface;
 734         return S_OK;
 735     }
 736
 737     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 738
 739     *out = NULL;
 740     return E_NOINTERFACE;
 741 }
 742
 743 static ULONG WINAPI d3d8_texture_3d_AddRef(IDirect3DVolumeTexture8 *iface)
 744 {
 745     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 746
 747     return d3d8_texture_incref(texture);
 748 }
 749
 750 static ULONG WINAPI d3d8_texture_3d_Release(IDirect3DVolumeTexture8 *iface)
 751 {
 752     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 753
 754     return d3d8_texture_decref(texture);
 755 }
 756
 757 static HRESULT WINAPI d3d8_texture_3d_GetDevice(IDirect3DVolumeTexture8 *iface, IDirect3DDevice8 **device)
 758 {
 759     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 760
 761     TRACE("iface %p, device %p.\n", iface, device);
 762
 763     *device = texture->parent_device;
 764     IDirect3DDevice8_AddRef(*device);
 765
 766     TRACE("Returning device %p.\n", *device);
 767
 768     return D3D_OK;
 769 }
 770
 771 static HRESULT WINAPI d3d8_texture_3d_SetPrivateData(IDirect3DVolumeTexture8 *iface,
 772         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 773 {
 774     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 775     TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
 776             iface, debugstr_guid(guid), data, data_size, flags);
 777
 778     return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 779 }
 780
 781 static HRESULT WINAPI d3d8_texture_3d_GetPrivateData(IDirect3DVolumeTexture8 *iface,
 782         REFGUID guid, void *data, DWORD *data_size)
 783 {
 784     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 785     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 786             iface, debugstr_guid(guid), data, data_size);
 787
 788     return d3d8_resource_get_private_data(&texture->resource, guid, data, data_size);
 789 }
 790
 791 static HRESULT WINAPI d3d8_texture_3d_FreePrivateData(IDirect3DVolumeTexture8 *iface, REFGUID guid)
 792 {
 793     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 794     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 795
 796     return d3d8_resource_free_private_data(&texture->resource, guid);
 797 }
 798
 799 static DWORD WINAPI d3d8_texture_3d_SetPriority(IDirect3DVolumeTexture8 *iface, DWORD priority)
 800 {
 801     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 802     struct wined3d_resource *resource;
 803     DWORD ret;
 804
 805     TRACE("iface %p, priority %lu.\n", iface, priority);
 806
 807     wined3d_mutex_lock();
 808     resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
 809     ret = wined3d_resource_set_priority(resource, priority);
 810     wined3d_mutex_unlock();
 811
 812     return ret;
 813 }
 814
 815 static DWORD WINAPI d3d8_texture_3d_GetPriority(IDirect3DVolumeTexture8 *iface)
 816 {
 817     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 818     const struct wined3d_resource *resource;
 819     DWORD ret;
 820
 821     TRACE("iface %p.\n", iface);
 822
 823     wined3d_mutex_lock();
 824     resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
 825     ret = wined3d_resource_get_priority(resource);
 826     wined3d_mutex_unlock();
 827
 828     return ret;
 829 }
 830
 831 static void WINAPI d3d8_texture_3d_PreLoad(IDirect3DVolumeTexture8 *iface)
 832 {
 833     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 834
 835     TRACE("iface %p.\n", iface);
 836
 837     d3d8_texture_preload(texture);
 838 }
 839
 840 static D3DRESOURCETYPE WINAPI d3d8_texture_3d_GetType(IDirect3DVolumeTexture8 *iface)
 841 {
 842     TRACE("iface %p.\n", iface);
 843
 844     return D3DRTYPE_VOLUMETEXTURE;
 845 }
 846
 847 static DWORD WINAPI d3d8_texture_3d_SetLOD(IDirect3DVolumeTexture8 *iface, DWORD lod)
 848 {
 849     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 850     DWORD ret;
 851
 852     TRACE("iface %p, lod %lu.\n", iface, lod);
 853
 854     wined3d_mutex_lock();
 855     ret = wined3d_texture_set_lod(d3d8_texture_get_draw_texture(texture), lod);
 856     wined3d_mutex_unlock();
 857
 858     return ret;
 859 }
 860
 861 static DWORD WINAPI d3d8_texture_3d_GetLOD(IDirect3DVolumeTexture8 *iface)
 862 {
 863     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 864     DWORD ret;
 865
 866     TRACE("iface %p.\n", iface);
 867
 868     wined3d_mutex_lock();
 869     ret = wined3d_texture_get_lod(d3d8_texture_get_draw_texture(texture));
 870     wined3d_mutex_unlock();
 871
 872     return ret;
 873 }
 874
 875 static DWORD WINAPI d3d8_texture_3d_GetLevelCount(IDirect3DVolumeTexture8 *iface)
 876 {
 877     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 878     DWORD ret;
 879
 880     TRACE("iface %p.\n", iface);
 881
 882     wined3d_mutex_lock();
 883     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 884     wined3d_mutex_unlock();
 885
 886     return ret;
 887 }
 888
 889 static HRESULT WINAPI d3d8_texture_3d_GetLevelDesc(IDirect3DVolumeTexture8 *iface, UINT level, D3DVOLUME_DESC *desc)
 890 {
 891     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 892     struct wined3d_sub_resource_desc wined3d_desc;
 893     HRESULT hr;
 894
 895     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 896
 897     wined3d_mutex_lock();
 898     if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc)))
 899     {
 900         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 901         desc->Type = D3DRTYPE_VOLUME;
 902         desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage, wined3d_desc.bind_flags);
 903         desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 904         desc->Size = wined3d_desc.size;
 905         desc->Width = wined3d_desc.width;
 906         desc->Height = wined3d_desc.height;
 907         desc->Depth = wined3d_desc.depth;
 908     }
 909     wined3d_mutex_unlock();
 910
 911     return hr;
 912 }
 913
 914 static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *iface,
 915         UINT level, IDirect3DVolume8 **volume)
 916 {
 917     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 918     struct d3d8_volume *volume_impl;
 919
 920     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
 921
 922     wined3d_mutex_lock();
 923     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 924     {
 925         wined3d_mutex_unlock();
 926         return D3DERR_INVALIDCALL;
 927     }
 928
 929     *volume = &volume_impl->IDirect3DVolume8_iface;
 930     IDirect3DVolume8_AddRef(*volume);
 931     wined3d_mutex_unlock();
 932
 933     return D3D_OK;
 934 }
 935
 936 static HRESULT WINAPI d3d8_texture_3d_LockBox(IDirect3DVolumeTexture8 *iface,
 937         UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
 938 {
 939     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 940     struct d3d8_volume *volume_impl;
 941     HRESULT hr;
 942
 943     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#lx.\n",
 944             iface, level, locked_box, box, flags);
 945
 946     wined3d_mutex_lock();
 947     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 948         hr = D3DERR_INVALIDCALL;
 949     else
 950         hr = IDirect3DVolume8_LockBox(&volume_impl->IDirect3DVolume8_iface, locked_box, box, flags);
 951     wined3d_mutex_unlock();
 952
 953     return hr;
 954 }
 955
 956 static HRESULT WINAPI d3d8_texture_3d_UnlockBox(IDirect3DVolumeTexture8 *iface, UINT level)
 957 {
 958     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 959     struct d3d8_volume *volume_impl;
 960     HRESULT hr;
 961
 962     TRACE("iface %p, level %u.\n", iface, level);
 963
 964     wined3d_mutex_lock();
 965     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 966         hr = D3DERR_INVALIDCALL;
 967     else
 968         hr = IDirect3DVolume8_UnlockBox(&volume_impl->IDirect3DVolume8_iface);
 969     wined3d_mutex_unlock();
 970
 971     return hr;
 972 }
 973
 974 static HRESULT WINAPI d3d8_texture_3d_AddDirtyBox(IDirect3DVolumeTexture8 *iface, const D3DBOX *dirty_box)
 975 {
 976     struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
 977     HRESULT hr;
 978
 979     TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
 980
 981     wined3d_mutex_lock();
 982     hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
 983     wined3d_mutex_unlock();
 984
 985     return hr;
 986 }
 987
 988 static const IDirect3DVolumeTexture8Vtbl Direct3DVolumeTexture8_Vtbl =
 989 {
 990     /* IUnknown */
 991     d3d8_texture_3d_QueryInterface,
 992     d3d8_texture_3d_AddRef,
 993     d3d8_texture_3d_Release,
 994     /* IDirect3DResource8 */
 995     d3d8_texture_3d_GetDevice,
 996     d3d8_texture_3d_SetPrivateData,
 997     d3d8_texture_3d_GetPrivateData,
 998     d3d8_texture_3d_FreePrivateData,
 999     d3d8_texture_3d_SetPriority,
1000     d3d8_texture_3d_GetPriority,
1001     d3d8_texture_3d_PreLoad,
1002     d3d8_texture_3d_GetType,
1003     /* IDirect3DBaseTexture8 */
1004     d3d8_texture_3d_SetLOD,
1005     d3d8_texture_3d_GetLOD,
1006     d3d8_texture_3d_GetLevelCount,
1007     /* IDirect3DVolumeTexture8 */
1008     d3d8_texture_3d_GetLevelDesc,
1009     d3d8_texture_3d_GetVolumeLevel,
1010     d3d8_texture_3d_LockBox,
1011     d3d8_texture_3d_UnlockBox,
1012     d3d8_texture_3d_AddDirtyBox
1013 };
1014
1015 struct d3d8_texture *unsafe_impl_from_IDirect3DBaseTexture8(IDirect3DBaseTexture8 *iface)
1016 {
1017     if (!iface)
1018         return NULL;
1019
1020     /* SetTexture() in particular doesn't do a lot of validation on the pointer
1021      * that gets passed in, and passing an invalid pointer works as long as the
1022      * application doesn't try to actually render anything with it, so we print
1023      * a WARN and return NULL instead of having the usual assert() here.
1024      * One application affected by this is Fishdom 2. */
1025     if (iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl
1026             && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl
1027             && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl)
1028     {
1029         WARN("%p is not a valid IDirect3DBaseTexture8 interface.\n", iface);
1030         return NULL;
1031     }
1032
1033     return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
1034 }
1035
1036 static void STDMETHODCALLTYPE d3d8_texture_wined3d_object_destroyed(void *parent)
1037 {
1038     struct d3d8_texture *texture = parent;
1039
1040     /* If the texture was managed, release the sysmem copy now. */
1041     if (texture->draw_texture)
1042         wined3d_texture_decref(texture->wined3d_texture);
1043     d3d8_resource_cleanup(&texture->resource);
1044     heap_free(texture);
1045 }
1046
1047 static const struct wined3d_parent_ops d3d8_texture_wined3d_parent_ops =
1048 {
1049     d3d8_texture_wined3d_object_destroyed,
1050 };
1051
1052 static HRESULT d3d8_texture_init(struct d3d8_texture *texture, struct d3d8_device *device,
1053         const struct wined3d_resource_desc *desc, D3DPOOL pool, unsigned int layer_count, unsigned int level_count)
1054 {
1055     unsigned int flags = 0;
1056     HRESULT hr;
1057
1058     d3d8_resource_init(&texture->resource);
1059     list_init(&texture->rtv_list);
1060
1061     if (!level_count)
1062         level_count = wined3d_log2i(max(max(desc->width, desc->height), desc->depth)) + 1;
1063
1064     if (pool == D3DPOOL_SYSTEMMEM || pool == D3DPOOL_MANAGED)
1065         flags |= WINED3D_TEXTURE_CREATE_RECORD_DIRTY_REGIONS;
1066
1067     wined3d_mutex_lock();
1068
1069     if (pool == D3DPOOL_MANAGED)
1070     {
1071         struct wined3d_resource_desc managed_desc = *desc;
1072
1073         managed_desc.access = WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
1074         managed_desc.bind_flags = 0;
1075         if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &managed_desc, layer_count, level_count, flags,
1076                 NULL, texture, &d3d8_null_wined3d_parent_ops, &texture->wined3d_texture)))
1077         {
1078             wined3d_mutex_unlock();
1079             WARN("Failed to create sysmem texture, hr %#lx.\n", hr);
1080             return hr;
1081         }
1082
1083         managed_desc.access = WINED3D_RESOURCE_ACCESS_GPU;
1084         managed_desc.bind_flags = desc->bind_flags;
1085         if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &managed_desc, layer_count, level_count, 0,
1086                 NULL, texture, &d3d8_texture_wined3d_parent_ops, &texture->draw_texture)))
1087         {
1088             wined3d_texture_decref(texture->wined3d_texture);
1089             wined3d_mutex_unlock();
1090             WARN("Failed to create draw texture, hr %#lx.\n", hr);
1091             return hr;
1092         }
1093     }
1094     else
1095     {
1096         if (FAILED(hr = wined3d_texture_create(device->wined3d_device, desc, layer_count, level_count, flags,
1097                 NULL, texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture)))
1098         {
1099             wined3d_mutex_unlock();
1100             WARN("Failed to create wined3d texture, hr %#lx.\n", hr);
1101             return hr;
1102         }
1103     }
1104     wined3d_mutex_unlock();
1105
1106     texture->parent_device = &device->IDirect3DDevice8_iface;
1107     IDirect3DDevice8_AddRef(texture->parent_device);
1108
1109     return D3D_OK;
1110 }
1111
1112 HRESULT d3d8_texture_2d_init(struct d3d8_texture *texture, struct d3d8_device *device, unsigned int width,
1113         unsigned int height, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1114 {
1115     struct wined3d_resource_desc desc;
1116
1117     desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1118     desc.format = wined3dformat_from_d3dformat(format);
1119     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1120     desc.multisample_quality = 0;
1121     desc.usage = wined3d_usage_from_d3d(pool, usage);
1122     desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1123     desc.access = wined3daccess_from_d3dpool(pool, usage);
1124     desc.width = width;
1125     desc.height = height;
1126     desc.depth = 1;
1127     desc.size = 0;
1128
1129     if (usage & D3DUSAGE_WRITEONLY)
1130     {
1131         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flag, returning D3DERR_INVALIDCALL.\n");
1132         return D3DERR_INVALIDCALL;
1133     }
1134
1135     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl;
1136     return d3d8_texture_init(texture, device, &desc, pool, 1, level_count);
1137 }
1138
1139 HRESULT d3d8_texture_cube_init(struct d3d8_texture *texture, struct d3d8_device *device,
1140         unsigned int edge_length, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1141 {
1142     struct wined3d_resource_desc desc;
1143
1144     desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1145     desc.format = wined3dformat_from_d3dformat(format);
1146     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1147     desc.multisample_quality = 0;
1148     desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_LEGACY_CUBEMAP;
1149     desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1150     desc.access = wined3daccess_from_d3dpool(pool, usage);
1151     desc.width = edge_length;
1152     desc.height = edge_length;
1153     desc.depth = 1;
1154     desc.size = 0;
1155
1156     if (usage & D3DUSAGE_WRITEONLY)
1157     {
1158         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flag, returning D3DERR_INVALIDCALL.\n");
1159         return D3DERR_INVALIDCALL;
1160     }
1161
1162     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl;
1163     return d3d8_texture_init(texture, device, &desc, pool, 6, level_count);
1164 }
1165
1166 HRESULT d3d8_texture_3d_init(struct d3d8_texture *texture, struct d3d8_device *device, unsigned int width,
1167         unsigned int height, unsigned int depth, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1168 {
1169     struct wined3d_resource_desc desc;
1170
1171     /* In d3d8, 3D textures can't be used as rendertarget or depth/stencil buffer. */
1172     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
1173         return D3DERR_INVALIDCALL;
1174
1175     desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
1176     desc.format = wined3dformat_from_d3dformat(format);
1177     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1178     desc.multisample_quality = 0;
1179     desc.usage = wined3d_usage_from_d3d(pool, usage);
1180     desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1181     desc.access = wined3daccess_from_d3dpool(pool, usage);
1182     desc.width = width;
1183     desc.height = height;
1184     desc.depth = depth;
1185     desc.size = 0;
1186
1187     if (usage & D3DUSAGE_WRITEONLY)
1188     {
1189         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flags, returning D3DERR_INVALIDCALL.\n");
1190         return D3DERR_INVALIDCALL;
1191     }
1192
1193     texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl;
1194     return d3d8_texture_init(texture, device, &desc, pool, 1, level_count);
1195 }