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