dlls/d3d8/buffer.c

   1 /*
   2  * Copyright 2005 Oliver Stieber
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "d3d8_private.h"
  20
  21 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
  22
  23 static inline struct d3d8_vertexbuffer *impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface)
  24 {
  25     return CONTAINING_RECORD(iface, struct d3d8_vertexbuffer, IDirect3DVertexBuffer8_iface);
  26 }
  27
  28 static HRESULT WINAPI d3d8_vertexbuffer_QueryInterface(IDirect3DVertexBuffer8 *iface, REFIID riid, void **object)
  29 {
  30     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  31
  32     if (IsEqualGUID(riid, &IID_IDirect3DVertexBuffer8)
  33             || IsEqualGUID(riid, &IID_IDirect3DResource8)
  34             || IsEqualGUID(riid, &IID_IUnknown))
  35     {
  36         IDirect3DVertexBuffer8_AddRef(iface);
  37         *object = iface;
  38         return S_OK;
  39     }
  40
  41     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  42
  43     *object = NULL;
  44     return E_NOINTERFACE;
  45 }
  46
  47 static ULONG WINAPI d3d8_vertexbuffer_AddRef(IDirect3DVertexBuffer8 *iface)
  48 {
  49     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  50     ULONG refcount = InterlockedIncrement(&buffer->resource.refcount);
  51
  52     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  53
  54     if (refcount == 1)
  55     {
  56         IDirect3DDevice8_AddRef(buffer->parent_device);
  57         if (buffer->draw_buffer)
  58             wined3d_buffer_incref(buffer->draw_buffer);
  59         else
  60             wined3d_buffer_incref(buffer->wined3d_buffer);
  61     }
  62
  63     return refcount;
  64 }
  65
  66 static ULONG WINAPI d3d8_vertexbuffer_Release(IDirect3DVertexBuffer8 *iface)
  67 {
  68     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  69     ULONG refcount = InterlockedDecrement(&buffer->resource.refcount);
  70
  71     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  72
  73     if (!refcount)
  74     {
  75         struct wined3d_buffer *draw_buffer = buffer->draw_buffer;
  76         IDirect3DDevice8 *device = buffer->parent_device;
  77
  78         if (draw_buffer)
  79             wined3d_buffer_decref(draw_buffer);
  80         else
  81             wined3d_buffer_decref(buffer->wined3d_buffer);
  82
  83         /* Release the device last, as it may cause the device to be destroyed. */
  84         IDirect3DDevice8_Release(device);
  85     }
  86
  87     return refcount;
  88 }
  89
  90 static HRESULT WINAPI d3d8_vertexbuffer_GetDevice(IDirect3DVertexBuffer8 *iface,
  91         IDirect3DDevice8 **device)
  92 {
  93     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  94
  95     TRACE("iface %p, device %p.\n", iface, device);
  96
  97     *device = buffer->parent_device;
  98     IDirect3DDevice8_AddRef(*device);
  99
 100     TRACE("Returning device %p.\n", *device);
 101
 102     return D3D_OK;
 103 }
 104
 105 static HRESULT WINAPI d3d8_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer8 *iface,
 106         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 107 {
 108     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 109     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 110             iface, debugstr_guid(guid), data, data_size, flags);
 111
 112     return d3d8_resource_set_private_data(&buffer->resource, guid, data, data_size, flags);
 113 }
 114
 115 static HRESULT WINAPI d3d8_vertexbuffer_GetPrivateData(IDirect3DVertexBuffer8 *iface,
 116         REFGUID guid, void *data, DWORD *data_size)
 117 {
 118     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 119     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 120             iface, debugstr_guid(guid), data, data_size);
 121
 122     return d3d8_resource_get_private_data(&buffer->resource, guid, data, data_size);
 123 }
 124
 125 static HRESULT WINAPI d3d8_vertexbuffer_FreePrivateData(IDirect3DVertexBuffer8 *iface, REFGUID guid)
 126 {
 127     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 128     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 129
 130     return d3d8_resource_free_private_data(&buffer->resource, guid);
 131 }
 132
 133 static DWORD WINAPI d3d8_vertexbuffer_SetPriority(IDirect3DVertexBuffer8 *iface, DWORD priority)
 134 {
 135     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 136     struct wined3d_resource *resource;
 137     DWORD previous;
 138
 139     TRACE("iface %p, priority %u.\n", iface, priority);
 140
 141     wined3d_mutex_lock();
 142     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 143     previous = wined3d_resource_set_priority(resource, priority);
 144     wined3d_mutex_unlock();
 145
 146     return previous;
 147 }
 148
 149 static DWORD WINAPI d3d8_vertexbuffer_GetPriority(IDirect3DVertexBuffer8 *iface)
 150 {
 151     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 152     const struct wined3d_resource *resource;
 153     DWORD priority;
 154
 155     TRACE("iface %p.\n", iface);
 156
 157     wined3d_mutex_lock();
 158     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 159     priority = wined3d_resource_get_priority(resource);
 160     wined3d_mutex_unlock();
 161
 162     return priority;
 163 }
 164
 165 static void WINAPI d3d8_vertexbuffer_PreLoad(IDirect3DVertexBuffer8 *iface)
 166 {
 167     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 168
 169     TRACE("iface %p.\n", iface);
 170
 171     wined3d_mutex_lock();
 172     wined3d_resource_preload(wined3d_buffer_get_resource(buffer->wined3d_buffer));
 173     wined3d_mutex_unlock();
 174 }
 175
 176 static D3DRESOURCETYPE WINAPI d3d8_vertexbuffer_GetType(IDirect3DVertexBuffer8 *iface)
 177 {
 178     TRACE("iface %p.\n", iface);
 179
 180     return D3DRTYPE_VERTEXBUFFER;
 181 }
 182
 183 static HRESULT WINAPI d3d8_vertexbuffer_Lock(IDirect3DVertexBuffer8 *iface, UINT offset, UINT size,
 184         BYTE **data, DWORD flags)
 185 {
 186     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 187     struct wined3d_resource *wined3d_resource;
 188     struct wined3d_map_desc wined3d_map_desc;
 189     struct wined3d_box wined3d_box = {0};
 190     HRESULT hr;
 191
 192     TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
 193             iface, offset, size, data, flags);
 194
 195     wined3d_box.left = offset;
 196     wined3d_box.right = offset + size;
 197     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 198     hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box,
 199             wined3dmapflags_from_d3dmapflags(flags, buffer->usage));
 200     *data = wined3d_map_desc.data;
 201
 202     return hr;
 203 }
 204
 205 static HRESULT WINAPI d3d8_vertexbuffer_Unlock(IDirect3DVertexBuffer8 *iface)
 206 {
 207     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 208
 209     TRACE("iface %p.\n", iface);
 210
 211     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 212
 213     return D3D_OK;
 214 }
 215
 216 static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface,
 217         D3DVERTEXBUFFER_DESC *desc)
 218 {
 219     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 220     struct wined3d_resource_desc wined3d_desc;
 221     struct wined3d_resource *wined3d_resource;
 222
 223     TRACE("iface %p, desc %p.\n", iface, desc);
 224
 225     wined3d_mutex_lock();
 226     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 227     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 228     wined3d_mutex_unlock();
 229
 230     desc->Format = D3DFMT_VERTEXDATA;
 231     desc->Type = D3DRTYPE_VERTEXBUFFER;
 232     desc->Usage = buffer->usage;
 233     desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 234     desc->Size = wined3d_desc.size;
 235     desc->FVF = buffer->fvf;
 236
 237     return D3D_OK;
 238 }
 239
 240 static const IDirect3DVertexBuffer8Vtbl Direct3DVertexBuffer8_Vtbl =
 241 {
 242     /* IUnknown */
 243     d3d8_vertexbuffer_QueryInterface,
 244     d3d8_vertexbuffer_AddRef,
 245     d3d8_vertexbuffer_Release,
 246     /* IDirect3DResource8 */
 247     d3d8_vertexbuffer_GetDevice,
 248     d3d8_vertexbuffer_SetPrivateData,
 249     d3d8_vertexbuffer_GetPrivateData,
 250     d3d8_vertexbuffer_FreePrivateData,
 251     d3d8_vertexbuffer_SetPriority,
 252     d3d8_vertexbuffer_GetPriority,
 253     d3d8_vertexbuffer_PreLoad,
 254     d3d8_vertexbuffer_GetType,
 255     /* IDirect3DVertexBuffer8 */
 256     d3d8_vertexbuffer_Lock,
 257     d3d8_vertexbuffer_Unlock,
 258     d3d8_vertexbuffer_GetDesc,
 259 };
 260
 261 static void STDMETHODCALLTYPE d3d8_vertexbuffer_wined3d_object_destroyed(void *parent)
 262 {
 263     struct d3d8_vertexbuffer *buffer = parent;
 264
 265     if (buffer->draw_buffer)
 266         wined3d_buffer_decref(buffer->wined3d_buffer);
 267     d3d8_resource_cleanup(&buffer->resource);
 268     heap_free(buffer);
 269 }
 270
 271 static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops =
 272 {
 273     d3d8_vertexbuffer_wined3d_object_destroyed,
 274 };
 275
 276 HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device,
 277         UINT size, DWORD usage, DWORD fvf, D3DPOOL pool)
 278 {
 279     const struct wined3d_parent_ops *parent_ops = &d3d8_null_wined3d_parent_ops;
 280     struct wined3d_buffer_desc desc;
 281     HRESULT hr;
 282
 283     if (pool == D3DPOOL_SCRATCH)
 284     {
 285         WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n");
 286         return D3DERR_INVALIDCALL;
 287     }
 288
 289     /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
 290     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
 291         return D3DERR_INVALIDCALL;
 292
 293     buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl;
 294     d3d8_resource_init(&buffer->resource);
 295     buffer->fvf = fvf;
 296     buffer->usage = usage;
 297
 298     desc.byte_width = size;
 299     desc.usage = usage & WINED3DUSAGE_MASK;
 300     desc.bind_flags = 0;
 301     desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
 302     /* Buffers are always readable. */
 303     if (pool != D3DPOOL_DEFAULT)
 304         desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
 305     desc.misc_flags = 0;
 306     desc.structure_byte_stride = 0;
 307
 308     if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
 309     {
 310         desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
 311         parent_ops = &d3d8_vertexbuffer_wined3d_parent_ops;
 312     }
 313
 314     wined3d_mutex_lock();
 315     hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, parent_ops, &buffer->wined3d_buffer);
 316     if (SUCCEEDED(hr) && !(desc.access & WINED3D_RESOURCE_ACCESS_GPU))
 317     {
 318         desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
 319         desc.access = WINED3D_RESOURCE_ACCESS_GPU;
 320         if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
 321                 &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->draw_buffer)))
 322             wined3d_buffer_decref(buffer->wined3d_buffer);
 323     }
 324     wined3d_mutex_unlock();
 325     if (FAILED(hr))
 326     {
 327         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 328         return hr;
 329     }
 330
 331     buffer->parent_device = &device->IDirect3DDevice8_iface;
 332     IDirect3DDevice8_AddRef(buffer->parent_device);
 333
 334     return D3D_OK;
 335 }
 336
 337 struct d3d8_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface)
 338 {
 339     if (!iface)
 340         return NULL;
 341     assert(iface->lpVtbl == &Direct3DVertexBuffer8_Vtbl);
 342
 343     return impl_from_IDirect3DVertexBuffer8(iface);
 344 }
 345
 346 static inline struct d3d8_indexbuffer *impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 347 {
 348     return CONTAINING_RECORD(iface, struct d3d8_indexbuffer, IDirect3DIndexBuffer8_iface);
 349 }
 350
 351 static HRESULT WINAPI d3d8_indexbuffer_QueryInterface(IDirect3DIndexBuffer8 *iface, REFIID riid, void **object)
 352 {
 353     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 354
 355     if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer8)
 356             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 357             || IsEqualGUID(riid, &IID_IUnknown))
 358     {
 359         IDirect3DIndexBuffer8_AddRef(iface);
 360         *object = iface;
 361         return S_OK;
 362     }
 363
 364     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 365
 366     *object = NULL;
 367     return E_NOINTERFACE;
 368 }
 369
 370 static ULONG WINAPI d3d8_indexbuffer_AddRef(IDirect3DIndexBuffer8 *iface)
 371 {
 372     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 373     ULONG refcount = InterlockedIncrement(&buffer->resource.refcount);
 374
 375     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 376
 377     if (refcount == 1)
 378     {
 379         IDirect3DDevice8_AddRef(buffer->parent_device);
 380         if (buffer->draw_buffer)
 381             wined3d_buffer_incref(buffer->draw_buffer);
 382         else
 383             wined3d_buffer_incref(buffer->wined3d_buffer);
 384     }
 385
 386     return refcount;
 387 }
 388
 389 static ULONG WINAPI d3d8_indexbuffer_Release(IDirect3DIndexBuffer8 *iface)
 390 {
 391     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 392     ULONG refcount = InterlockedDecrement(&buffer->resource.refcount);
 393
 394     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 395
 396     if (!refcount)
 397     {
 398         struct wined3d_buffer *draw_buffer = buffer->draw_buffer;
 399         IDirect3DDevice8 *device = buffer->parent_device;
 400
 401         if (draw_buffer)
 402             wined3d_buffer_decref(draw_buffer);
 403         else
 404             wined3d_buffer_decref(buffer->wined3d_buffer);
 405
 406         /* Release the device last, as it may cause the device to be destroyed. */
 407         IDirect3DDevice8_Release(device);
 408     }
 409
 410     return refcount;
 411 }
 412
 413 static HRESULT WINAPI d3d8_indexbuffer_GetDevice(IDirect3DIndexBuffer8 *iface,
 414         IDirect3DDevice8 **device)
 415 {
 416     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 417
 418     TRACE("iface %p, device %p.\n", iface, device);
 419
 420     *device = buffer->parent_device;
 421     IDirect3DDevice8_AddRef(*device);
 422
 423     TRACE("Returning device %p.\n", *device);
 424
 425     return D3D_OK;
 426 }
 427
 428 static HRESULT WINAPI d3d8_indexbuffer_SetPrivateData(IDirect3DIndexBuffer8 *iface,
 429         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 430 {
 431     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 432     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 433             iface, debugstr_guid(guid), data, data_size, flags);
 434
 435     return d3d8_resource_set_private_data(&buffer->resource, guid, data, data_size, flags);
 436 }
 437
 438 static HRESULT WINAPI d3d8_indexbuffer_GetPrivateData(IDirect3DIndexBuffer8 *iface,
 439         REFGUID guid, void *data, DWORD *data_size)
 440 {
 441     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 442     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 443             iface, debugstr_guid(guid), data, data_size);
 444
 445     return d3d8_resource_get_private_data(&buffer->resource, guid, data, data_size);
 446 }
 447
 448 static HRESULT WINAPI d3d8_indexbuffer_FreePrivateData(IDirect3DIndexBuffer8 *iface, REFGUID guid)
 449 {
 450     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 451     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 452
 453     return d3d8_resource_free_private_data(&buffer->resource, guid);
 454 }
 455
 456 static DWORD WINAPI d3d8_indexbuffer_SetPriority(IDirect3DIndexBuffer8 *iface, DWORD priority)
 457 {
 458     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 459     struct wined3d_resource *resource;
 460     DWORD previous;
 461
 462     TRACE("iface %p, priority %u.\n", iface, priority);
 463
 464     wined3d_mutex_lock();
 465     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 466     previous = wined3d_resource_set_priority(resource, priority);
 467     wined3d_mutex_unlock();
 468
 469     return previous;
 470 }
 471
 472 static DWORD WINAPI d3d8_indexbuffer_GetPriority(IDirect3DIndexBuffer8 *iface)
 473 {
 474     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 475     const struct wined3d_resource *resource;
 476     DWORD priority;
 477
 478     TRACE("iface %p.\n", iface);
 479
 480     wined3d_mutex_lock();
 481     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 482     priority = wined3d_resource_get_priority(resource);
 483     wined3d_mutex_unlock();
 484
 485     return priority;
 486 }
 487
 488 static void WINAPI d3d8_indexbuffer_PreLoad(IDirect3DIndexBuffer8 *iface)
 489 {
 490     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 491
 492     TRACE("iface %p.\n", iface);
 493
 494     wined3d_mutex_lock();
 495     wined3d_resource_preload(wined3d_buffer_get_resource(buffer->wined3d_buffer));
 496     wined3d_mutex_unlock();
 497 }
 498
 499 static D3DRESOURCETYPE WINAPI d3d8_indexbuffer_GetType(IDirect3DIndexBuffer8 *iface)
 500 {
 501     TRACE("iface %p.\n", iface);
 502
 503     return D3DRTYPE_INDEXBUFFER;
 504 }
 505
 506 static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size,
 507         BYTE **data, DWORD flags)
 508 {
 509     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 510     struct wined3d_resource *wined3d_resource;
 511     struct wined3d_map_desc wined3d_map_desc;
 512     struct wined3d_box wined3d_box = {0};
 513     HRESULT hr;
 514
 515     TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
 516             iface, offset, size, data, flags);
 517
 518     wined3d_box.left = offset;
 519     wined3d_box.right = offset + size;
 520     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 521     hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box,
 522             wined3dmapflags_from_d3dmapflags(flags, buffer->usage));
 523     *data = wined3d_map_desc.data;
 524
 525     return hr;
 526 }
 527
 528 static HRESULT WINAPI d3d8_indexbuffer_Unlock(IDirect3DIndexBuffer8 *iface)
 529 {
 530     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 531
 532     TRACE("iface %p.\n", iface);
 533
 534     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 535
 536     return D3D_OK;
 537 }
 538
 539 static HRESULT WINAPI d3d8_indexbuffer_GetDesc(IDirect3DIndexBuffer8 *iface,
 540         D3DINDEXBUFFER_DESC *desc)
 541 {
 542     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 543     struct wined3d_resource_desc wined3d_desc;
 544     struct wined3d_resource *wined3d_resource;
 545
 546     TRACE("iface %p, desc %p.\n", iface, desc);
 547
 548     wined3d_mutex_lock();
 549     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 550     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 551     wined3d_mutex_unlock();
 552
 553     desc->Format = d3dformat_from_wined3dformat(buffer->format);
 554     desc->Type = D3DRTYPE_INDEXBUFFER;
 555     desc->Usage = buffer->usage;
 556     desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 557     desc->Size = wined3d_desc.size;
 558
 559     return D3D_OK;
 560 }
 561
 562 static const IDirect3DIndexBuffer8Vtbl d3d8_indexbuffer_vtbl =
 563 {
 564     /* IUnknown */
 565     d3d8_indexbuffer_QueryInterface,
 566     d3d8_indexbuffer_AddRef,
 567     d3d8_indexbuffer_Release,
 568     /* IDirect3DResource8 */
 569     d3d8_indexbuffer_GetDevice,
 570     d3d8_indexbuffer_SetPrivateData,
 571     d3d8_indexbuffer_GetPrivateData,
 572     d3d8_indexbuffer_FreePrivateData,
 573     d3d8_indexbuffer_SetPriority,
 574     d3d8_indexbuffer_GetPriority,
 575     d3d8_indexbuffer_PreLoad,
 576     d3d8_indexbuffer_GetType,
 577     /* IDirect3DIndexBuffer8 */
 578     d3d8_indexbuffer_Lock,
 579     d3d8_indexbuffer_Unlock,
 580     d3d8_indexbuffer_GetDesc,
 581 };
 582
 583 static void STDMETHODCALLTYPE d3d8_indexbuffer_wined3d_object_destroyed(void *parent)
 584 {
 585     struct d3d8_indexbuffer *buffer = parent;
 586
 587     if (buffer->draw_buffer)
 588         wined3d_buffer_decref(buffer->wined3d_buffer);
 589     d3d8_resource_cleanup(&buffer->resource);
 590     heap_free(buffer);
 591 }
 592
 593 static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops =
 594 {
 595     d3d8_indexbuffer_wined3d_object_destroyed,
 596 };
 597
 598 HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device,
 599         UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
 600 {
 601     const struct wined3d_parent_ops *parent_ops = &d3d8_null_wined3d_parent_ops;
 602     struct wined3d_buffer_desc desc;
 603     HRESULT hr;
 604
 605     if (pool == D3DPOOL_SCRATCH)
 606         return D3DERR_INVALIDCALL;
 607
 608     /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
 609     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
 610         return D3DERR_INVALIDCALL;
 611
 612     desc.byte_width = size;
 613     desc.usage = (usage & WINED3DUSAGE_MASK) | WINED3DUSAGE_STATICDECL;
 614     desc.bind_flags = 0;
 615     desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
 616     /* Buffers are always readable. */
 617     if (pool != D3DPOOL_DEFAULT)
 618         desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
 619     desc.misc_flags = 0;
 620     desc.structure_byte_stride = 0;
 621
 622     if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
 623     {
 624         desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
 625         parent_ops = &d3d8_indexbuffer_wined3d_parent_ops;
 626     }
 627
 628     buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl;
 629     d3d8_resource_init(&buffer->resource);
 630     buffer->format = wined3dformat_from_d3dformat(format);
 631     buffer->usage = usage;
 632
 633     wined3d_mutex_lock();
 634     hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, parent_ops, &buffer->wined3d_buffer);
 635     if (SUCCEEDED(hr) && !(desc.access & WINED3D_RESOURCE_ACCESS_GPU))
 636     {
 637         desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
 638         desc.access = WINED3D_RESOURCE_ACCESS_GPU;
 639         if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
 640                 &d3d8_indexbuffer_wined3d_parent_ops, &buffer->draw_buffer)))
 641             wined3d_buffer_decref(buffer->wined3d_buffer);
 642     }
 643     wined3d_mutex_unlock();
 644     if (FAILED(hr))
 645     {
 646         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 647         return hr;
 648     }
 649
 650     buffer->parent_device = &device->IDirect3DDevice8_iface;
 651     IDirect3DDevice8_AddRef(buffer->parent_device);
 652
 653     return D3D_OK;
 654 }
 655
 656 struct d3d8_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 657 {
 658     if (!iface)
 659         return NULL;
 660     assert(iface->lpVtbl == &d3d8_indexbuffer_vtbl);
 661
 662     return impl_from_IDirect3DIndexBuffer8(iface);
 663 }