dlls/d3d8/texture.c

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