dlls/d3d9/texture.c

   1 /*
   2  * Copyright 2002-2005 Jason Edmeades
   3  * Copyright 2002-2005 Raphael Junqueira
   4  * Copyright 2005 Oliver Stieber
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23 #include "d3d9_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
  26
  27 static inline struct d3d9_texture *impl_from_IDirect3DTexture9(IDirect3DTexture9 *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  30 }
  31
  32 static inline struct d3d9_texture *impl_from_IDirect3DCubeTexture9(IDirect3DCubeTexture9 *iface)
  33 {
  34     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  35 }
  36
  37 static inline struct d3d9_texture *impl_from_IDirect3DVolumeTexture9(IDirect3DVolumeTexture9 *iface)
  38 {
  39     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
  40 }
  41
  42 static void STDMETHODCALLTYPE srv_wined3d_object_destroyed(void *parent)
  43 {
  44     struct d3d9_texture *texture = parent;
  45
  46     texture->wined3d_srv = NULL;
  47 }
  48
  49 static const struct wined3d_parent_ops d3d9_srv_wined3d_parent_ops =
  50 {
  51     srv_wined3d_object_destroyed,
  52 };
  53
  54 /* wined3d critical section must be taken by the caller. */
  55 static struct wined3d_shader_resource_view *d3d9_texture_acquire_shader_resource_view(struct d3d9_texture *texture)
  56 {
  57     struct wined3d_sub_resource_desc sr_desc;
  58     struct wined3d_view_desc desc;
  59     HRESULT hr;
  60
  61     if (texture->wined3d_srv)
  62         return texture->wined3d_srv;
  63
  64     wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, 0, &sr_desc);
  65     desc.format_id = sr_desc.format;
  66     desc.flags = 0;
  67     desc.u.texture.level_idx = 0;
  68     desc.u.texture.level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
  69     desc.u.texture.layer_idx = 0;
  70     desc.u.texture.layer_count = sr_desc.usage & WINED3DUSAGE_LEGACY_CUBEMAP ? 6 : 1;
  71     if (FAILED(hr = wined3d_shader_resource_view_create(&desc,
  72             wined3d_texture_get_resource(texture->wined3d_texture), texture,
  73             &d3d9_srv_wined3d_parent_ops, &texture->wined3d_srv)))
  74     {
  75         ERR("Failed to create shader resource view, hr %#x.\n", hr);
  76         return NULL;
  77     }
  78
  79     return texture->wined3d_srv;
  80 }
  81
  82 static void d3d9_texture_cleanup(struct d3d9_texture *texture)
  83 {
  84     IDirect3DDevice9Ex *parent_device = texture->parent_device;
  85     struct d3d9_surface *surface;
  86
  87     wined3d_mutex_lock();
  88     if (texture->wined3d_srv)
  89         wined3d_shader_resource_view_decref(texture->wined3d_srv);
  90     LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry)
  91         wined3d_rendertarget_view_decref(surface->wined3d_rtv);
  92     wined3d_texture_decref(texture->wined3d_texture);
  93     wined3d_mutex_unlock();
  94
  95     /* Release the device last, as it may cause the device to be destroyed. */
  96     IDirect3DDevice9Ex_Release(parent_device);
  97 }
  98
  99 /* wined3d critical section must be taken by the caller. */
 100 void d3d9_texture_gen_auto_mipmap(struct d3d9_texture *texture)
 101 {
 102     if (!(texture->flags & D3D9_TEXTURE_MIPMAP_DIRTY))
 103         return;
 104     d3d9_texture_acquire_shader_resource_view(texture);
 105     wined3d_shader_resource_view_generate_mipmaps(texture->wined3d_srv);
 106     texture->flags &= ~D3D9_TEXTURE_MIPMAP_DIRTY;
 107 }
 108
 109 void d3d9_texture_flag_auto_gen_mipmap(struct d3d9_texture *texture)
 110 {
 111     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP)
 112         texture->flags |= D3D9_TEXTURE_MIPMAP_DIRTY;
 113 }
 114
 115 static HRESULT WINAPI d3d9_texture_2d_QueryInterface(IDirect3DTexture9 *iface, REFIID riid, void **out)
 116 {
 117     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 118
 119     if (IsEqualGUID(riid, &IID_IDirect3DTexture9)
 120             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 121             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 122             || IsEqualGUID(riid, &IID_IUnknown))
 123     {
 124         IDirect3DTexture9_AddRef(iface);
 125         *out = iface;
 126         return S_OK;
 127     }
 128
 129     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 130
 131     *out = NULL;
 132     return E_NOINTERFACE;
 133 }
 134
 135 static ULONG WINAPI d3d9_texture_2d_AddRef(IDirect3DTexture9 *iface)
 136 {
 137     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 138     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
 139
 140     TRACE("%p increasing refcount to %u.\n", iface, ref);
 141
 142     if (ref == 1)
 143     {
 144         struct d3d9_surface *surface;
 145
 146         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 147         wined3d_mutex_lock();
 148         LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry)
 149         {
 150             wined3d_rendertarget_view_incref(surface->wined3d_rtv);
 151         }
 152         wined3d_texture_incref(texture->wined3d_texture);
 153         wined3d_mutex_unlock();
 154     }
 155
 156     return ref;
 157 }
 158
 159 static ULONG WINAPI d3d9_texture_2d_Release(IDirect3DTexture9 *iface)
 160 {
 161     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 162     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
 163
 164     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 165
 166     if (!ref)
 167         d3d9_texture_cleanup(texture);
 168     return ref;
 169 }
 170
 171 static HRESULT WINAPI d3d9_texture_2d_GetDevice(IDirect3DTexture9 *iface, IDirect3DDevice9 **device)
 172 {
 173     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 174
 175     TRACE("iface %p, device %p.\n", iface, device);
 176
 177     *device = (IDirect3DDevice9 *)texture->parent_device;
 178     IDirect3DDevice9_AddRef(*device);
 179
 180     TRACE("Returning device %p.\n", *device);
 181
 182     return D3D_OK;
 183 }
 184
 185 static HRESULT WINAPI d3d9_texture_2d_SetPrivateData(IDirect3DTexture9 *iface,
 186         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 187 {
 188     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 189     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 190             iface, debugstr_guid(guid), data, data_size, flags);
 191
 192     return d3d9_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 193 }
 194
 195 static HRESULT WINAPI d3d9_texture_2d_GetPrivateData(IDirect3DTexture9 *iface,
 196         REFGUID guid, void *data, DWORD *data_size)
 197 {
 198     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 199     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 200             iface, debugstr_guid(guid), data, data_size);
 201
 202     return d3d9_resource_get_private_data(&texture->resource, guid, data, data_size);
 203 }
 204
 205 static HRESULT WINAPI d3d9_texture_2d_FreePrivateData(IDirect3DTexture9 *iface, REFGUID guid)
 206 {
 207     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 208     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 209
 210     return d3d9_resource_free_private_data(&texture->resource, guid);
 211 }
 212
 213 static DWORD WINAPI d3d9_texture_2d_SetPriority(IDirect3DTexture9 *iface, DWORD priority)
 214 {
 215     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 216     struct wined3d_resource *resource;
 217     DWORD ret;
 218
 219     TRACE("iface %p, priority %u.\n", iface, priority);
 220
 221     wined3d_mutex_lock();
 222     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 223     ret = wined3d_resource_set_priority(resource, priority);
 224     wined3d_mutex_unlock();
 225
 226     return ret;
 227 }
 228
 229 static DWORD WINAPI d3d9_texture_2d_GetPriority(IDirect3DTexture9 *iface)
 230 {
 231     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 232     const struct wined3d_resource *resource;
 233     DWORD ret;
 234
 235     TRACE("iface %p.\n", iface);
 236
 237     wined3d_mutex_lock();
 238     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 239     ret = wined3d_resource_get_priority(resource);
 240     wined3d_mutex_unlock();
 241
 242     return ret;
 243 }
 244
 245 static void WINAPI d3d9_texture_2d_PreLoad(IDirect3DTexture9 *iface)
 246 {
 247     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 248
 249     TRACE("iface %p.\n", iface);
 250
 251     wined3d_mutex_lock();
 252     wined3d_resource_preload(wined3d_texture_get_resource(texture->wined3d_texture));
 253     wined3d_mutex_unlock();
 254 }
 255
 256 static D3DRESOURCETYPE WINAPI d3d9_texture_2d_GetType(IDirect3DTexture9 *iface)
 257 {
 258     TRACE("iface %p.\n", iface);
 259
 260     return D3DRTYPE_TEXTURE;
 261 }
 262
 263 static DWORD WINAPI d3d9_texture_2d_SetLOD(IDirect3DTexture9 *iface, DWORD lod)
 264 {
 265     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 266     DWORD ret;
 267
 268     TRACE("iface %p, lod %u.\n", iface, lod);
 269
 270     wined3d_mutex_lock();
 271     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 272     wined3d_mutex_unlock();
 273
 274     return ret;
 275 }
 276
 277 static DWORD WINAPI d3d9_texture_2d_GetLOD(IDirect3DTexture9 *iface)
 278 {
 279     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 280     DWORD ret;
 281
 282     TRACE("iface %p.\n", iface);
 283
 284     wined3d_mutex_lock();
 285     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 286     wined3d_mutex_unlock();
 287
 288     return ret;
 289 }
 290
 291 static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface)
 292 {
 293     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 294     DWORD ret;
 295
 296     TRACE("iface %p.\n", iface);
 297
 298     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP)
 299         return 1;
 300
 301     wined3d_mutex_lock();
 302     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 303     wined3d_mutex_unlock();
 304
 305     return ret;
 306 }
 307
 308 static HRESULT WINAPI d3d9_texture_2d_SetAutoGenFilterType(IDirect3DTexture9 *iface, D3DTEXTUREFILTERTYPE filter_type)
 309 {
 310     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 311
 312     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
 313
 314     if (filter_type == D3DTEXF_NONE)
 315     {
 316         WARN("Invalid filter type D3DTEXF_NONE specified.\n");
 317         return D3DERR_INVALIDCALL;
 318     }
 319     if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP))
 320         WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
 321     else if (filter_type != D3DTEXF_LINEAR)
 322         FIXME("Unsupported filter type %u.\n", filter_type);
 323
 324     texture->autogen_filter_type = filter_type;
 325     return D3D_OK;
 326 }
 327
 328 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_2d_GetAutoGenFilterType(IDirect3DTexture9 *iface)
 329 {
 330     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 331
 332     TRACE("iface %p.\n", iface);
 333
 334     if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP))
 335         WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
 336
 337     return texture->autogen_filter_type;
 338 }
 339
 340 static void WINAPI d3d9_texture_2d_GenerateMipSubLevels(IDirect3DTexture9 *iface)
 341 {
 342     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 343
 344     TRACE("iface %p.\n", iface);
 345
 346     wined3d_mutex_lock();
 347     d3d9_texture_gen_auto_mipmap(texture);
 348     wined3d_mutex_unlock();
 349 }
 350
 351 static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
 352 {
 353     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 354     struct wined3d_sub_resource_desc wined3d_desc;
 355     HRESULT hr;
 356
 357     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 358
 359     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 360     {
 361         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 362         return D3DERR_INVALIDCALL;
 363     }
 364
 365     wined3d_mutex_lock();
 366     if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc)))
 367     {
 368         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 369         desc->Type = D3DRTYPE_SURFACE;
 370         desc->Usage = texture->usage;
 371         desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 372         desc->MultiSampleType = wined3d_desc.multisample_type;
 373         desc->MultiSampleQuality = wined3d_desc.multisample_quality;
 374         desc->Width = wined3d_desc.width;
 375         desc->Height = wined3d_desc.height;
 376     }
 377     wined3d_mutex_unlock();
 378
 379     return hr;
 380 }
 381
 382 static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface,
 383         UINT level, IDirect3DSurface9 **surface)
 384 {
 385     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 386     struct d3d9_surface *surface_impl;
 387
 388     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
 389
 390     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 391     {
 392         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 393         return D3DERR_INVALIDCALL;
 394     }
 395
 396     wined3d_mutex_lock();
 397     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 398     {
 399         wined3d_mutex_unlock();
 400         return D3DERR_INVALIDCALL;
 401     }
 402
 403     *surface = &surface_impl->IDirect3DSurface9_iface;
 404     IDirect3DSurface9_AddRef(*surface);
 405     wined3d_mutex_unlock();
 406
 407     return D3D_OK;
 408 }
 409
 410 static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface,
 411         UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
 412 {
 413     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 414     struct d3d9_surface *surface_impl;
 415     HRESULT hr;
 416
 417     TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
 418             iface, level, locked_rect, rect, flags);
 419
 420     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 421     {
 422         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 423         return D3DERR_INVALIDCALL;
 424     }
 425
 426     wined3d_mutex_lock();
 427     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 428         hr = D3DERR_INVALIDCALL;
 429     else
 430         hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
 431     wined3d_mutex_unlock();
 432
 433     return hr;
 434 }
 435
 436 static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT level)
 437 {
 438     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 439     struct d3d9_surface *surface_impl;
 440     HRESULT hr;
 441
 442     TRACE("iface %p, level %u.\n", iface, level);
 443
 444     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 445     {
 446         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 447         return D3DERR_INVALIDCALL;
 448     }
 449
 450     wined3d_mutex_lock();
 451     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
 452         hr = D3DERR_INVALIDCALL;
 453     else
 454         hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
 455     wined3d_mutex_unlock();
 456
 457     return hr;
 458 }
 459
 460 static HRESULT WINAPI d3d9_texture_2d_AddDirtyRect(IDirect3DTexture9 *iface, const RECT *dirty_rect)
 461 {
 462     struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
 463     HRESULT hr;
 464
 465     TRACE("iface %p, dirty_rect %s.\n",
 466             iface, wine_dbgstr_rect(dirty_rect));
 467
 468     wined3d_mutex_lock();
 469     if (!dirty_rect)
 470         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL);
 471     else
 472     {
 473         struct wined3d_box dirty_region;
 474
 475         wined3d_box_set(&dirty_region, dirty_rect->left, dirty_rect->top, dirty_rect->right, dirty_rect->bottom, 0, 1);
 476         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region);
 477     }
 478     wined3d_mutex_unlock();
 479
 480     return hr;
 481 }
 482
 483 static const IDirect3DTexture9Vtbl d3d9_texture_2d_vtbl =
 484 {
 485     /* IUnknown */
 486     d3d9_texture_2d_QueryInterface,
 487     d3d9_texture_2d_AddRef,
 488     d3d9_texture_2d_Release,
 489      /* IDirect3DResource9 */
 490     d3d9_texture_2d_GetDevice,
 491     d3d9_texture_2d_SetPrivateData,
 492     d3d9_texture_2d_GetPrivateData,
 493     d3d9_texture_2d_FreePrivateData,
 494     d3d9_texture_2d_SetPriority,
 495     d3d9_texture_2d_GetPriority,
 496     d3d9_texture_2d_PreLoad,
 497     d3d9_texture_2d_GetType,
 498     /* IDirect3dBaseTexture9 */
 499     d3d9_texture_2d_SetLOD,
 500     d3d9_texture_2d_GetLOD,
 501     d3d9_texture_2d_GetLevelCount,
 502     d3d9_texture_2d_SetAutoGenFilterType,
 503     d3d9_texture_2d_GetAutoGenFilterType,
 504     d3d9_texture_2d_GenerateMipSubLevels,
 505     /* IDirect3DTexture9 */
 506     d3d9_texture_2d_GetLevelDesc,
 507     d3d9_texture_2d_GetSurfaceLevel,
 508     d3d9_texture_2d_LockRect,
 509     d3d9_texture_2d_UnlockRect,
 510     d3d9_texture_2d_AddDirtyRect,
 511 };
 512
 513 static HRESULT WINAPI d3d9_texture_cube_QueryInterface(IDirect3DCubeTexture9 *iface, REFIID riid, void **out)
 514 {
 515     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 516
 517     if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)
 518             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 519             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 520             || IsEqualGUID(riid, &IID_IUnknown))
 521     {
 522         IDirect3DCubeTexture9_AddRef(iface);
 523         *out = iface;
 524         return S_OK;
 525     }
 526
 527     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 528
 529     *out = NULL;
 530     return E_NOINTERFACE;
 531 }
 532
 533 static ULONG WINAPI d3d9_texture_cube_AddRef(IDirect3DCubeTexture9 *iface)
 534 {
 535     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 536     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
 537
 538     TRACE("%p increasing refcount to %u.\n", iface, ref);
 539
 540     if (ref == 1)
 541     {
 542         struct d3d9_surface *surface;
 543
 544         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 545         wined3d_mutex_lock();
 546         LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry)
 547         {
 548             wined3d_rendertarget_view_decref(surface->wined3d_rtv);
 549         }
 550         wined3d_texture_incref(texture->wined3d_texture);
 551         wined3d_mutex_unlock();
 552     }
 553
 554     return ref;
 555 }
 556
 557 static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface)
 558 {
 559     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 560     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
 561
 562     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 563
 564     if (!ref)
 565         d3d9_texture_cleanup(texture);
 566     return ref;
 567 }
 568
 569 static HRESULT WINAPI d3d9_texture_cube_GetDevice(IDirect3DCubeTexture9 *iface, IDirect3DDevice9 **device)
 570 {
 571     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 572
 573     TRACE("iface %p, device %p.\n", iface, device);
 574
 575     *device = (IDirect3DDevice9 *)texture->parent_device;
 576     IDirect3DDevice9_AddRef(*device);
 577
 578     TRACE("Returning device %p.\n", *device);
 579
 580     return D3D_OK;
 581 }
 582
 583 static HRESULT WINAPI d3d9_texture_cube_SetPrivateData(IDirect3DCubeTexture9 *iface,
 584         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 585 {
 586     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 587     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 588             iface, debugstr_guid(guid), data, data_size, flags);
 589
 590     return d3d9_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
 591 }
 592
 593 static HRESULT WINAPI d3d9_texture_cube_GetPrivateData(IDirect3DCubeTexture9 *iface,
 594         REFGUID guid, void *data, DWORD *data_size)
 595 {
 596     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 597     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 598             iface, debugstr_guid(guid), data, data_size);
 599
 600     return d3d9_resource_get_private_data(&texture->resource, guid, data, data_size);
 601 }
 602
 603 static HRESULT WINAPI d3d9_texture_cube_FreePrivateData(IDirect3DCubeTexture9 *iface, REFGUID guid)
 604 {
 605     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 606     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 607
 608     return d3d9_resource_free_private_data(&texture->resource, guid);
 609 }
 610
 611 static DWORD WINAPI d3d9_texture_cube_SetPriority(IDirect3DCubeTexture9 *iface, DWORD priority)
 612 {
 613     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 614     struct wined3d_resource *resource;
 615     DWORD ret;
 616
 617     TRACE("iface %p, priority %u.\n", iface, priority);
 618
 619     wined3d_mutex_lock();
 620     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 621     ret = wined3d_resource_set_priority(resource, priority);
 622     wined3d_mutex_unlock();
 623
 624     return ret;
 625 }
 626
 627 static DWORD WINAPI d3d9_texture_cube_GetPriority(IDirect3DCubeTexture9 *iface)
 628 {
 629     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 630     const struct wined3d_resource *resource;
 631     DWORD ret;
 632
 633     TRACE("iface %p.\n", iface);
 634
 635     wined3d_mutex_lock();
 636     resource = wined3d_texture_get_resource(texture->wined3d_texture);
 637     ret = wined3d_resource_get_priority(resource);
 638     wined3d_mutex_unlock();
 639
 640     return ret;
 641 }
 642
 643 static void WINAPI d3d9_texture_cube_PreLoad(IDirect3DCubeTexture9 *iface)
 644 {
 645     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 646
 647     TRACE("iface %p.\n", iface);
 648
 649     wined3d_mutex_lock();
 650     wined3d_resource_preload(wined3d_texture_get_resource(texture->wined3d_texture));
 651     wined3d_mutex_unlock();
 652 }
 653
 654 static D3DRESOURCETYPE WINAPI d3d9_texture_cube_GetType(IDirect3DCubeTexture9 *iface)
 655 {
 656     TRACE("iface %p.\n", iface);
 657
 658     return D3DRTYPE_CUBETEXTURE;
 659 }
 660
 661 static DWORD WINAPI d3d9_texture_cube_SetLOD(IDirect3DCubeTexture9 *iface, DWORD lod)
 662 {
 663     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 664     DWORD ret;
 665
 666     TRACE("iface %p, lod %u.\n", iface, lod);
 667
 668     wined3d_mutex_lock();
 669     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
 670     wined3d_mutex_unlock();
 671
 672     return ret;
 673 }
 674
 675 static DWORD WINAPI d3d9_texture_cube_GetLOD(IDirect3DCubeTexture9 *iface)
 676 {
 677     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 678     DWORD ret;
 679
 680     TRACE("iface %p.\n", iface);
 681
 682     wined3d_mutex_lock();
 683     ret = wined3d_texture_get_lod(texture->wined3d_texture);
 684     wined3d_mutex_unlock();
 685
 686     return ret;
 687 }
 688
 689 static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface)
 690 {
 691     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 692     DWORD ret;
 693
 694     TRACE("iface %p.\n", iface);
 695
 696     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP)
 697         return 1;
 698
 699     wined3d_mutex_lock();
 700     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
 701     wined3d_mutex_unlock();
 702
 703     return ret;
 704 }
 705
 706 static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTexture9 *iface,
 707         D3DTEXTUREFILTERTYPE filter_type)
 708 {
 709     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 710
 711     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
 712
 713     if (filter_type == D3DTEXF_NONE)
 714     {
 715         WARN("Invalid filter type D3DTEXF_NONE specified.\n");
 716         return D3DERR_INVALIDCALL;
 717     }
 718     if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP))
 719         WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
 720     else if (filter_type != D3DTEXF_LINEAR)
 721         FIXME("Unsupported filter type %u.\n", filter_type);
 722
 723     texture->autogen_filter_type = filter_type;
 724     return D3D_OK;
 725 }
 726
 727 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_cube_GetAutoGenFilterType(IDirect3DCubeTexture9 *iface)
 728 {
 729     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 730
 731     TRACE("iface %p.\n", iface);
 732
 733     if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP))
 734         WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
 735
 736     return texture->autogen_filter_type;
 737 }
 738
 739 static void WINAPI d3d9_texture_cube_GenerateMipSubLevels(IDirect3DCubeTexture9 *iface)
 740 {
 741     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 742
 743     TRACE("iface %p.\n", iface);
 744
 745     wined3d_mutex_lock();
 746     d3d9_texture_gen_auto_mipmap(texture);
 747     wined3d_mutex_unlock();
 748 }
 749
 750 static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
 751 {
 752     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 753     struct wined3d_sub_resource_desc wined3d_desc;
 754     DWORD level_count;
 755     HRESULT hr;
 756
 757     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
 758
 759     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 760     {
 761         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 762         return D3DERR_INVALIDCALL;
 763     }
 764
 765     wined3d_mutex_lock();
 766     level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
 767     if (level >= level_count)
 768     {
 769         wined3d_mutex_unlock();
 770         return D3DERR_INVALIDCALL;
 771     }
 772
 773     if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc)))
 774     {
 775         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 776         desc->Type = D3DRTYPE_SURFACE;
 777         desc->Usage = texture->usage;
 778         desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 779         desc->MultiSampleType = wined3d_desc.multisample_type;
 780         desc->MultiSampleQuality = wined3d_desc.multisample_quality;
 781         desc->Width = wined3d_desc.width;
 782         desc->Height = wined3d_desc.height;
 783     }
 784     wined3d_mutex_unlock();
 785
 786     return hr;
 787 }
 788
 789 static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9 *iface,
 790         D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface9 **surface)
 791 {
 792     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 793     struct d3d9_surface *surface_impl;
 794     UINT sub_resource_idx;
 795     DWORD level_count;
 796
 797     TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
 798
 799     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 800     {
 801         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 802         return D3DERR_INVALIDCALL;
 803     }
 804
 805     wined3d_mutex_lock();
 806     level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
 807     if (level >= level_count)
 808     {
 809         wined3d_mutex_unlock();
 810         return D3DERR_INVALIDCALL;
 811     }
 812
 813     sub_resource_idx = level_count * face + level;
 814     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 815     {
 816         wined3d_mutex_unlock();
 817         return D3DERR_INVALIDCALL;
 818     }
 819
 820     *surface = &surface_impl->IDirect3DSurface9_iface;
 821     IDirect3DSurface9_AddRef(*surface);
 822     wined3d_mutex_unlock();
 823
 824     return D3D_OK;
 825 }
 826
 827 static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface,
 828         D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
 829         DWORD flags)
 830 {
 831     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 832     struct d3d9_surface *surface_impl;
 833     UINT sub_resource_idx;
 834     HRESULT hr;
 835
 836     TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
 837             iface, face, level, locked_rect, rect, flags);
 838
 839     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 840     {
 841         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 842         return D3DERR_INVALIDCALL;
 843     }
 844
 845     wined3d_mutex_lock();
 846     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 847     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 848         hr = D3DERR_INVALIDCALL;
 849     else
 850         hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
 851     wined3d_mutex_unlock();
 852
 853     return hr;
 854 }
 855
 856 static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface,
 857         D3DCUBEMAP_FACES face, UINT level)
 858 {
 859     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 860     struct d3d9_surface *surface_impl;
 861     UINT sub_resource_idx;
 862     HRESULT hr;
 863
 864     TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
 865
 866     if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level)
 867     {
 868         WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n");
 869         return D3DERR_INVALIDCALL;
 870     }
 871
 872     wined3d_mutex_lock();
 873     sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
 874     if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx)))
 875         hr = D3DERR_INVALIDCALL;
 876     else
 877         hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
 878     wined3d_mutex_unlock();
 879
 880     return hr;
 881 }
 882
 883 static HRESULT  WINAPI d3d9_texture_cube_AddDirtyRect(IDirect3DCubeTexture9 *iface,
 884         D3DCUBEMAP_FACES face, const RECT *dirty_rect)
 885 {
 886     struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
 887     HRESULT hr;
 888
 889     TRACE("iface %p, face %#x, dirty_rect %s.\n",
 890             iface, face, wine_dbgstr_rect(dirty_rect));
 891
 892     wined3d_mutex_lock();
 893     if (!dirty_rect)
 894         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
 895     else
 896     {
 897         struct wined3d_box dirty_region;
 898
 899         wined3d_box_set(&dirty_region, dirty_rect->left, dirty_rect->top, dirty_rect->right, dirty_rect->bottom, 0, 1);
 900         hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
 901     }
 902     wined3d_mutex_unlock();
 903
 904     return hr;
 905 }
 906
 907 static const IDirect3DCubeTexture9Vtbl d3d9_texture_cube_vtbl =
 908 {
 909     /* IUnknown */
 910     d3d9_texture_cube_QueryInterface,
 911     d3d9_texture_cube_AddRef,
 912     d3d9_texture_cube_Release,
 913     /* IDirect3DResource9 */
 914     d3d9_texture_cube_GetDevice,
 915     d3d9_texture_cube_SetPrivateData,
 916     d3d9_texture_cube_GetPrivateData,
 917     d3d9_texture_cube_FreePrivateData,
 918     d3d9_texture_cube_SetPriority,
 919     d3d9_texture_cube_GetPriority,
 920     d3d9_texture_cube_PreLoad,
 921     d3d9_texture_cube_GetType,
 922     /* IDirect3DBaseTexture9 */
 923     d3d9_texture_cube_SetLOD,
 924     d3d9_texture_cube_GetLOD,
 925     d3d9_texture_cube_GetLevelCount,
 926     d3d9_texture_cube_SetAutoGenFilterType,
 927     d3d9_texture_cube_GetAutoGenFilterType,
 928     d3d9_texture_cube_GenerateMipSubLevels,
 929     /* IDirect3DCubeTexture9 */
 930     d3d9_texture_cube_GetLevelDesc,
 931     d3d9_texture_cube_GetCubeMapSurface,
 932     d3d9_texture_cube_LockRect,
 933     d3d9_texture_cube_UnlockRect,
 934     d3d9_texture_cube_AddDirtyRect,
 935 };
 936
 937 static HRESULT WINAPI d3d9_texture_3d_QueryInterface(IDirect3DVolumeTexture9 *iface, REFIID riid, void **out)
 938 {
 939     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 940
 941     if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)
 942             || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
 943             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 944             || IsEqualGUID(riid, &IID_IUnknown))
 945     {
 946         IDirect3DVolumeTexture9_AddRef(iface);
 947         *out = iface;
 948         return S_OK;
 949     }
 950
 951     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 952
 953     *out = NULL;
 954     return E_NOINTERFACE;
 955 }
 956
 957 static ULONG WINAPI d3d9_texture_3d_AddRef(IDirect3DVolumeTexture9 *iface)
 958 {
 959     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 960     ULONG ref = InterlockedIncrement(&texture->resource.refcount);
 961
 962     TRACE("%p increasing refcount to %u.\n", iface, ref);
 963
 964     if (ref == 1)
 965     {
 966         IDirect3DDevice9Ex_AddRef(texture->parent_device);
 967         wined3d_mutex_lock();
 968         wined3d_texture_incref(texture->wined3d_texture);
 969         wined3d_mutex_unlock();
 970     }
 971
 972     return ref;
 973 }
 974
 975 static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface)
 976 {
 977     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 978     ULONG ref = InterlockedDecrement(&texture->resource.refcount);
 979
 980     TRACE("%p decreasing refcount to %u.\n", iface, ref);
 981
 982     if (!ref)
 983         d3d9_texture_cleanup(texture);
 984     return ref;
 985 }
 986
 987 static HRESULT WINAPI d3d9_texture_3d_GetDevice(IDirect3DVolumeTexture9 *iface, IDirect3DDevice9 **device)
 988 {
 989     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
 990
 991     TRACE("iface %p, device %p.\n", iface, device);
 992
 993     *device = (IDirect3DDevice9 *)texture->parent_device;
 994     IDirect3DDevice9_AddRef(*device);
 995
 996     TRACE("Returning device %p.\n", *device);
 997
 998     return D3D_OK;
 999 }
1000
1001 static HRESULT WINAPI d3d9_texture_3d_SetPrivateData(IDirect3DVolumeTexture9 *iface,
1002         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
1003 {
1004     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1005     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
1006             iface, debugstr_guid(guid), data, data_size, flags);
1007
1008     return d3d9_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
1009 }
1010
1011 static HRESULT WINAPI d3d9_texture_3d_GetPrivateData(IDirect3DVolumeTexture9 *iface,
1012         REFGUID guid, void *data, DWORD *data_size)
1013 {
1014     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1015     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
1016             iface, debugstr_guid(guid), data, data_size);
1017
1018     return d3d9_resource_get_private_data(&texture->resource, guid, data, data_size);
1019 }
1020
1021 static HRESULT WINAPI d3d9_texture_3d_FreePrivateData(IDirect3DVolumeTexture9 *iface, REFGUID guid)
1022 {
1023     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1024     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1025
1026     return d3d9_resource_free_private_data(&texture->resource, guid);
1027 }
1028
1029 static DWORD WINAPI d3d9_texture_3d_SetPriority(IDirect3DVolumeTexture9 *iface, DWORD priority)
1030 {
1031     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1032     struct wined3d_resource *resource;
1033     DWORD ret;
1034
1035     TRACE("iface %p, priority %u.\n", iface, priority);
1036
1037     wined3d_mutex_lock();
1038     resource = wined3d_texture_get_resource(texture->wined3d_texture);
1039     ret = wined3d_resource_set_priority(resource, priority);
1040     wined3d_mutex_unlock();
1041
1042     return ret;
1043 }
1044
1045 static DWORD WINAPI d3d9_texture_3d_GetPriority(IDirect3DVolumeTexture9 *iface)
1046 {
1047     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1048     const struct wined3d_resource *resource;
1049     DWORD ret;
1050
1051     TRACE("iface %p.\n", iface);
1052
1053     wined3d_mutex_lock();
1054     resource = wined3d_texture_get_resource(texture->wined3d_texture);
1055     ret = wined3d_resource_get_priority(resource);
1056     wined3d_mutex_unlock();
1057
1058     return ret;
1059 }
1060
1061 static void WINAPI d3d9_texture_3d_PreLoad(IDirect3DVolumeTexture9 *iface)
1062 {
1063     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1064
1065     TRACE("iface %p.\n", iface);
1066
1067     wined3d_mutex_lock();
1068     wined3d_resource_preload(wined3d_texture_get_resource(texture->wined3d_texture));
1069     wined3d_mutex_unlock();
1070 }
1071
1072 static D3DRESOURCETYPE WINAPI d3d9_texture_3d_GetType(IDirect3DVolumeTexture9 *iface)
1073 {
1074     TRACE("iface %p.\n", iface);
1075
1076     return D3DRTYPE_VOLUMETEXTURE;
1077 }
1078
1079 static DWORD WINAPI d3d9_texture_3d_SetLOD(IDirect3DVolumeTexture9 *iface, DWORD lod)
1080 {
1081     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1082     DWORD ret;
1083
1084     TRACE("iface %p, lod %u.\n", iface, lod);
1085
1086     wined3d_mutex_lock();
1087     ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
1088     wined3d_mutex_unlock();
1089
1090     return ret;
1091 }
1092
1093 static DWORD WINAPI d3d9_texture_3d_GetLOD(IDirect3DVolumeTexture9 *iface)
1094 {
1095     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1096     DWORD ret;
1097
1098     TRACE("iface %p.\n", iface);
1099
1100     wined3d_mutex_lock();
1101     ret = wined3d_texture_get_lod(texture->wined3d_texture);
1102     wined3d_mutex_unlock();
1103
1104     return ret;
1105 }
1106
1107 static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface)
1108 {
1109     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1110     DWORD ret;
1111
1112     TRACE("iface %p.\n", iface);
1113
1114     wined3d_mutex_lock();
1115     ret = wined3d_texture_get_level_count(texture->wined3d_texture);
1116     wined3d_mutex_unlock();
1117
1118     return ret;
1119 }
1120
1121 static HRESULT WINAPI d3d9_texture_3d_SetAutoGenFilterType(IDirect3DVolumeTexture9 *iface,
1122         D3DTEXTUREFILTERTYPE filter_type)
1123 {
1124     TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
1125
1126     return D3DERR_INVALIDCALL;
1127 }
1128
1129 static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_3d_GetAutoGenFilterType(IDirect3DVolumeTexture9 *iface)
1130 {
1131     TRACE("iface %p.\n", iface);
1132
1133     return D3DTEXF_NONE;
1134 }
1135
1136 static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface)
1137 {
1138     TRACE("iface %p.\n", iface);
1139 }
1140
1141 static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *iface, UINT level, D3DVOLUME_DESC *desc)
1142 {
1143     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1144     struct wined3d_sub_resource_desc wined3d_desc;
1145     HRESULT hr;
1146
1147     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
1148
1149     wined3d_mutex_lock();
1150     if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc)))
1151     {
1152         desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
1153         desc->Type = D3DRTYPE_VOLUME;
1154         desc->Usage = texture->usage;
1155         desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
1156         desc->Width = wined3d_desc.width;
1157         desc->Height = wined3d_desc.height;
1158         desc->Depth = wined3d_desc.depth;
1159     }
1160     wined3d_mutex_unlock();
1161
1162     return hr;
1163 }
1164
1165 static HRESULT WINAPI d3d9_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture9 *iface,
1166         UINT level, IDirect3DVolume9 **volume)
1167 {
1168     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1169     struct d3d9_volume *volume_impl;
1170
1171     TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
1172
1173     wined3d_mutex_lock();
1174     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
1175     {
1176         wined3d_mutex_unlock();
1177         return D3DERR_INVALIDCALL;
1178     }
1179
1180     *volume = &volume_impl->IDirect3DVolume9_iface;
1181     IDirect3DVolume9_AddRef(*volume);
1182     wined3d_mutex_unlock();
1183
1184     return D3D_OK;
1185 }
1186
1187 static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface,
1188         UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
1189 {
1190     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1191     struct d3d9_volume *volume_impl;
1192     HRESULT hr;
1193
1194     TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
1195             iface, level, locked_box, box, flags);
1196
1197     wined3d_mutex_lock();
1198     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
1199         hr = D3DERR_INVALIDCALL;
1200     else
1201         hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags);
1202     wined3d_mutex_unlock();
1203
1204     return hr;
1205 }
1206
1207 static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
1208 {
1209     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1210     struct d3d9_volume *volume_impl;
1211     HRESULT hr;
1212
1213     TRACE("iface %p, level %u.\n", iface, level);
1214
1215     wined3d_mutex_lock();
1216     if (!(volume_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level)))
1217         hr = D3DERR_INVALIDCALL;
1218     else
1219         hr = IDirect3DVolume9_UnlockBox(&volume_impl->IDirect3DVolume9_iface);
1220     wined3d_mutex_unlock();
1221
1222     return hr;
1223 }
1224
1225 static HRESULT WINAPI d3d9_texture_3d_AddDirtyBox(IDirect3DVolumeTexture9 *iface, const D3DBOX *dirty_box)
1226 {
1227     struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1228     HRESULT hr;
1229
1230     TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
1231
1232     wined3d_mutex_lock();
1233     hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
1234     wined3d_mutex_unlock();
1235
1236     return hr;
1237 }
1238
1239
1240 static const IDirect3DVolumeTexture9Vtbl d3d9_texture_3d_vtbl =
1241 {
1242     /* IUnknown */
1243     d3d9_texture_3d_QueryInterface,
1244     d3d9_texture_3d_AddRef,
1245     d3d9_texture_3d_Release,
1246     /* IDirect3DResource9 */
1247     d3d9_texture_3d_GetDevice,
1248     d3d9_texture_3d_SetPrivateData,
1249     d3d9_texture_3d_GetPrivateData,
1250     d3d9_texture_3d_FreePrivateData,
1251     d3d9_texture_3d_SetPriority,
1252     d3d9_texture_3d_GetPriority,
1253     d3d9_texture_3d_PreLoad,
1254     d3d9_texture_3d_GetType,
1255     /* IDirect3DBaseTexture9 */
1256     d3d9_texture_3d_SetLOD,
1257     d3d9_texture_3d_GetLOD,
1258     d3d9_texture_3d_GetLevelCount,
1259     d3d9_texture_3d_SetAutoGenFilterType,
1260     d3d9_texture_3d_GetAutoGenFilterType,
1261     d3d9_texture_3d_GenerateMipSubLevels,
1262     /* IDirect3DVolumeTexture9 */
1263     d3d9_texture_3d_GetLevelDesc,
1264     d3d9_texture_3d_GetVolumeLevel,
1265     d3d9_texture_3d_LockBox,
1266     d3d9_texture_3d_UnlockBox,
1267     d3d9_texture_3d_AddDirtyBox,
1268 };
1269
1270 struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface)
1271 {
1272     if (!iface)
1273         return NULL;
1274
1275     if (iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl
1276             && iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl
1277             && iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl)
1278     {
1279         WARN("%p is not a valid IDirect3DBaseTexture9 interface.\n", iface);
1280         return NULL;
1281     }
1282
1283     return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
1284 }
1285
1286 static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent)
1287 {
1288     struct d3d9_texture *texture = parent;
1289     d3d9_resource_cleanup(&texture->resource);
1290     heap_free(texture);
1291 }
1292
1293 static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops =
1294 {
1295     d3d9_texture_wined3d_object_destroyed,
1296 };
1297
1298 HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1299         UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1300 {
1301     struct wined3d_resource_desc desc;
1302     DWORD flags = 0;
1303     HRESULT hr;
1304
1305     if (pool == D3DPOOL_MANAGED && device->d3d_parent->extended)
1306     {
1307         WARN("Managed resources are not supported by d3d9ex devices.\n");
1308         return D3DERR_INVALIDCALL;
1309     }
1310
1311     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
1312     d3d9_resource_init(&texture->resource);
1313     list_init(&texture->rtv_list);
1314     texture->usage = usage;
1315
1316     desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1317     desc.format = wined3dformat_from_d3dformat(format);
1318     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1319     desc.multisample_quality = 0;
1320     desc.usage = wined3dusage_from_d3dusage(usage);
1321     if (pool == D3DPOOL_SCRATCH)
1322         desc.usage |= WINED3DUSAGE_SCRATCH;
1323     desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1324     desc.access = wined3daccess_from_d3dpool(pool, usage);
1325     desc.width = width;
1326     desc.height = height;
1327     desc.depth = 1;
1328     desc.size = 0;
1329
1330     if (is_gdi_compat_wined3dformat(desc.format))
1331         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
1332
1333     if (usage & D3DUSAGE_WRITEONLY)
1334     {
1335         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flags, returning D3DERR_INVALIDCALL.\n");
1336         return D3DERR_INVALIDCALL;
1337     }
1338     if (usage & D3DUSAGE_AUTOGENMIPMAP)
1339     {
1340         if (pool == D3DPOOL_SYSTEMMEM)
1341         {
1342             WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n");
1343             return D3DERR_INVALIDCALL;
1344         }
1345         if (levels && levels != 1)
1346         {
1347             WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels);
1348             return D3DERR_INVALIDCALL;
1349         }
1350         wined3d_mutex_lock();
1351         hr = wined3d_check_device_format(device->d3d_parent->wined3d, WINED3DADAPTER_DEFAULT,
1352                 WINED3D_DEVICE_TYPE_HAL, WINED3DFMT_B8G8R8A8_UNORM, WINED3DUSAGE_QUERY_GENMIPMAP,
1353                 WINED3D_BIND_SHADER_RESOURCE, WINED3D_RTYPE_TEXTURE_2D, wined3dformat_from_d3dformat(format));
1354         wined3d_mutex_unlock();
1355         if (hr == D3D_OK)
1356         {
1357             flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
1358             levels = 0;
1359         }
1360         else
1361         {
1362             WARN("D3DUSAGE_AUTOGENMIPMAP not supported on D3DFORMAT %#x, creating a texture "
1363                     "with a single level.\n", format);
1364             levels = 1;
1365         }
1366         texture->autogen_filter_type = D3DTEXF_LINEAR;
1367     }
1368     else
1369     {
1370         texture->autogen_filter_type = D3DTEXF_NONE;
1371     }
1372     if (!levels)
1373         levels = wined3d_log2i(max(width, height)) + 1;
1374
1375     wined3d_mutex_lock();
1376     hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, flags,
1377             NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1378     wined3d_mutex_unlock();
1379     if (FAILED(hr))
1380     {
1381         WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1382         return hr;
1383     }
1384
1385     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1386     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1387
1388     return D3D_OK;
1389 }
1390
1391 HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1392         UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1393 {
1394     struct wined3d_resource_desc desc;
1395     DWORD flags = 0;
1396     HRESULT hr;
1397
1398     if (pool == D3DPOOL_MANAGED && device->d3d_parent->extended)
1399     {
1400         WARN("Managed resources are not supported by d3d9ex devices.\n");
1401         return D3DERR_INVALIDCALL;
1402     }
1403
1404     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
1405     d3d9_resource_init(&texture->resource);
1406     list_init(&texture->rtv_list);
1407     texture->usage = usage;
1408
1409     desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1410     desc.format = wined3dformat_from_d3dformat(format);
1411     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1412     desc.multisample_quality = 0;
1413     desc.usage = wined3dusage_from_d3dusage(usage);
1414     desc.usage |= WINED3DUSAGE_LEGACY_CUBEMAP;
1415     if (pool == D3DPOOL_SCRATCH)
1416         desc.usage |= WINED3DUSAGE_SCRATCH;
1417     desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1418     desc.access = wined3daccess_from_d3dpool(pool, usage);
1419     desc.width = edge_length;
1420     desc.height = edge_length;
1421     desc.depth = 1;
1422     desc.size = 0;
1423
1424     if (is_gdi_compat_wined3dformat(desc.format))
1425         flags |= WINED3D_TEXTURE_CREATE_GET_DC;
1426
1427     if (usage & D3DUSAGE_WRITEONLY)
1428     {
1429         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flags, returning D3DERR_INVALIDCALL.\n");
1430         return D3DERR_INVALIDCALL;
1431     }
1432     if (usage & D3DUSAGE_AUTOGENMIPMAP)
1433     {
1434         if (pool == D3DPOOL_SYSTEMMEM)
1435         {
1436             WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n");
1437             return D3DERR_INVALIDCALL;
1438         }
1439         if (levels && levels != 1)
1440         {
1441             WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels);
1442             return D3DERR_INVALIDCALL;
1443         }
1444         flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
1445         texture->autogen_filter_type = D3DTEXF_LINEAR;
1446         levels = 0;
1447     }
1448     else
1449     {
1450         texture->autogen_filter_type = D3DTEXF_NONE;
1451     }
1452     if (!levels)
1453         levels = wined3d_log2i(edge_length) + 1;
1454
1455     wined3d_mutex_lock();
1456     hr = wined3d_texture_create(device->wined3d_device, &desc, 6, levels, flags,
1457             NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1458     wined3d_mutex_unlock();
1459     if (FAILED(hr))
1460     {
1461         WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
1462         return hr;
1463     }
1464
1465     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1466     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1467
1468     return D3D_OK;
1469 }
1470
1471 HRESULT volumetexture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1472         UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
1473 {
1474     struct wined3d_resource_desc desc;
1475     HRESULT hr;
1476
1477     if (pool == D3DPOOL_MANAGED && device->d3d_parent->extended)
1478     {
1479         WARN("Managed resources are not supported by d3d9ex devices.\n");
1480         return D3DERR_INVALIDCALL;
1481     }
1482
1483     /* In d3d9, 3D textures can't be used as rendertarget or depth/stencil buffer. */
1484     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
1485         return D3DERR_INVALIDCALL;
1486
1487     texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
1488     d3d9_resource_init(&texture->resource);
1489     list_init(&texture->rtv_list);
1490     texture->usage = usage;
1491
1492     desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
1493     desc.format = wined3dformat_from_d3dformat(format);
1494     desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1495     desc.multisample_quality = 0;
1496     desc.usage = wined3dusage_from_d3dusage(usage);
1497     if (pool == D3DPOOL_SCRATCH)
1498         desc.usage |= WINED3DUSAGE_SCRATCH;
1499     desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
1500     desc.access = wined3daccess_from_d3dpool(pool, usage);
1501     desc.width = width;
1502     desc.height = height;
1503     desc.depth = depth;
1504     desc.size = 0;
1505
1506     if (usage & D3DUSAGE_WRITEONLY)
1507     {
1508         WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flags, returning D3DERR_INVALIDCALL.\n");
1509         return D3DERR_INVALIDCALL;
1510     }
1511     if (usage & D3DUSAGE_AUTOGENMIPMAP)
1512     {
1513         WARN("D3DUSAGE_AUTOGENMIPMAP volume texture is not supported, returning D3DERR_INVALIDCALL.\n");
1514         return D3DERR_INVALIDCALL;
1515     }
1516     if (!levels)
1517         levels = wined3d_log2i(max(max(width, height), depth)) + 1;
1518
1519     wined3d_mutex_lock();
1520     hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, 0,
1521             NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
1522     wined3d_mutex_unlock();
1523     if (FAILED(hr))
1524     {
1525         WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
1526         return hr;
1527     }
1528
1529     texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1530     IDirect3DDevice9Ex_AddRef(texture->parent_device);
1531
1532     return D3D_OK;
1533 }