dlls/d3d8/texture.c

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