reactos/dll/directx/wine/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 static inline struct d3d8_vertexbuffer *impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface)
  22 {
  23     return CONTAINING_RECORD(iface, struct d3d8_vertexbuffer, IDirect3DVertexBuffer8_iface);
  24 }
  25
  26 static HRESULT WINAPI d3d8_vertexbuffer_QueryInterface(IDirect3DVertexBuffer8 *iface, REFIID riid, void **object)
  27 {
  28     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  29
  30     if (IsEqualGUID(riid, &IID_IDirect3DVertexBuffer8)
  31             || IsEqualGUID(riid, &IID_IDirect3DResource8)
  32             || IsEqualGUID(riid, &IID_IUnknown))
  33     {
  34         IDirect3DVertexBuffer8_AddRef(iface);
  35         *object = iface;
  36         return S_OK;
  37     }
  38
  39     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  40
  41     *object = NULL;
  42     return E_NOINTERFACE;
  43 }
  44
  45 static ULONG WINAPI d3d8_vertexbuffer_AddRef(IDirect3DVertexBuffer8 *iface)
  46 {
  47     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  48     ULONG refcount = InterlockedIncrement(&buffer->refcount);
  49
  50     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  51
  52     if (refcount == 1)
  53     {
  54         IDirect3DDevice8_AddRef(buffer->parent_device);
  55         wined3d_mutex_lock();
  56         wined3d_buffer_incref(buffer->wined3d_buffer);
  57         wined3d_mutex_unlock();
  58     }
  59
  60     return refcount;
  61 }
  62
  63 static ULONG WINAPI d3d8_vertexbuffer_Release(IDirect3DVertexBuffer8 *iface)
  64 {
  65     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  66     ULONG refcount = InterlockedDecrement(&buffer->refcount);
  67
  68     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  69
  70     if (!refcount)
  71     {
  72         IDirect3DDevice8 *device = buffer->parent_device;
  73
  74         wined3d_mutex_lock();
  75         wined3d_buffer_decref(buffer->wined3d_buffer);
  76         wined3d_mutex_unlock();
  77
  78         /* Release the device last, as it may cause the device to be destroyed. */
  79         IDirect3DDevice8_Release(device);
  80     }
  81
  82     return refcount;
  83 }
  84
  85 static HRESULT WINAPI d3d8_vertexbuffer_GetDevice(IDirect3DVertexBuffer8 *iface,
  86         IDirect3DDevice8 **device)
  87 {
  88     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
  89
  90     TRACE("iface %p, device %p.\n", iface, device);
  91
  92     *device = buffer->parent_device;
  93     IDirect3DDevice8_AddRef(*device);
  94
  95     TRACE("Returning device %p.\n", *device);
  96
  97     return D3D_OK;
  98 }
  99
 100 static HRESULT WINAPI d3d8_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer8 *iface,
 101         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 102 {
 103     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 104     struct wined3d_resource *resource;
 105     HRESULT hr;
 106
 107     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 108             iface, debugstr_guid(guid), data, data_size, flags);
 109
 110     wined3d_mutex_lock();
 111     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 112     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 113     wined3d_mutex_unlock();
 114
 115     return hr;
 116 }
 117
 118 static HRESULT WINAPI d3d8_vertexbuffer_GetPrivateData(IDirect3DVertexBuffer8 *iface,
 119         REFGUID guid, void *data, DWORD *data_size)
 120 {
 121     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 122     struct wined3d_resource *resource;
 123     HRESULT hr;
 124
 125     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 126             iface, debugstr_guid(guid), data, data_size);
 127
 128     wined3d_mutex_lock();
 129     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 130     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 131     wined3d_mutex_unlock();
 132
 133     return hr;
 134 }
 135
 136 static HRESULT WINAPI d3d8_vertexbuffer_FreePrivateData(IDirect3DVertexBuffer8 *iface, REFGUID guid)
 137 {
 138     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 139     struct wined3d_resource *resource;
 140     HRESULT hr;
 141
 142     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 143
 144     wined3d_mutex_lock();
 145     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 146     hr = wined3d_resource_free_private_data(resource, guid);
 147     wined3d_mutex_unlock();
 148
 149     return hr;
 150 }
 151
 152 static DWORD WINAPI d3d8_vertexbuffer_SetPriority(IDirect3DVertexBuffer8 *iface, DWORD priority)
 153 {
 154     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 155     DWORD previous;
 156
 157     TRACE("iface %p, priority %u.\n", iface, priority);
 158
 159     wined3d_mutex_lock();
 160     previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority);
 161     wined3d_mutex_unlock();
 162
 163     return previous;
 164 }
 165
 166 static DWORD WINAPI d3d8_vertexbuffer_GetPriority(IDirect3DVertexBuffer8 *iface)
 167 {
 168     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 169     DWORD priority;
 170
 171     TRACE("iface %p.\n", iface);
 172
 173     wined3d_mutex_lock();
 174     priority = wined3d_buffer_get_priority(buffer->wined3d_buffer);
 175     wined3d_mutex_unlock();
 176
 177     return priority;
 178 }
 179
 180 static void WINAPI d3d8_vertexbuffer_PreLoad(IDirect3DVertexBuffer8 *iface)
 181 {
 182     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 183
 184     TRACE("iface %p.\n", iface);
 185
 186     wined3d_mutex_lock();
 187     wined3d_buffer_preload(buffer->wined3d_buffer);
 188     wined3d_mutex_unlock();
 189 }
 190
 191 static D3DRESOURCETYPE WINAPI d3d8_vertexbuffer_GetType(IDirect3DVertexBuffer8 *iface)
 192 {
 193     TRACE("iface %p.\n", iface);
 194
 195     return D3DRTYPE_VERTEXBUFFER;
 196 }
 197
 198 static HRESULT WINAPI d3d8_vertexbuffer_Lock(IDirect3DVertexBuffer8 *iface, UINT offset, UINT size,
 199         BYTE **data, DWORD flags)
 200 {
 201     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 202     HRESULT hr;
 203
 204     TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
 205             iface, offset, size, data, flags);
 206
 207     wined3d_mutex_lock();
 208     hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, data, flags);
 209     wined3d_mutex_unlock();
 210
 211     return hr;
 212 }
 213
 214 static HRESULT WINAPI d3d8_vertexbuffer_Unlock(IDirect3DVertexBuffer8 *iface)
 215 {
 216     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 217
 218     TRACE("iface %p.\n", iface);
 219
 220     wined3d_mutex_lock();
 221     wined3d_buffer_unmap(buffer->wined3d_buffer);
 222     wined3d_mutex_unlock();
 223
 224     return D3D_OK;
 225 }
 226
 227 static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface,
 228         D3DVERTEXBUFFER_DESC *desc)
 229 {
 230     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 231     struct wined3d_resource_desc wined3d_desc;
 232     struct wined3d_resource *wined3d_resource;
 233
 234     TRACE("iface %p, desc %p.\n", iface, desc);
 235
 236     wined3d_mutex_lock();
 237     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 238     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 239     wined3d_mutex_unlock();
 240
 241     desc->Type = D3DRTYPE_VERTEXBUFFER;
 242     desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 243     desc->Pool = wined3d_desc.pool;
 244     desc->Size = wined3d_desc.size;
 245     desc->FVF = buffer->fvf;
 246     desc->Format = D3DFMT_VERTEXDATA;
 247
 248     return D3D_OK;
 249 }
 250
 251 static const IDirect3DVertexBuffer8Vtbl Direct3DVertexBuffer8_Vtbl =
 252 {
 253     /* IUnknown */
 254     d3d8_vertexbuffer_QueryInterface,
 255     d3d8_vertexbuffer_AddRef,
 256     d3d8_vertexbuffer_Release,
 257     /* IDirect3DResource8 */
 258     d3d8_vertexbuffer_GetDevice,
 259     d3d8_vertexbuffer_SetPrivateData,
 260     d3d8_vertexbuffer_GetPrivateData,
 261     d3d8_vertexbuffer_FreePrivateData,
 262     d3d8_vertexbuffer_SetPriority,
 263     d3d8_vertexbuffer_GetPriority,
 264     d3d8_vertexbuffer_PreLoad,
 265     d3d8_vertexbuffer_GetType,
 266     /* IDirect3DVertexBuffer8 */
 267     d3d8_vertexbuffer_Lock,
 268     d3d8_vertexbuffer_Unlock,
 269     d3d8_vertexbuffer_GetDesc,
 270 };
 271
 272 static void STDMETHODCALLTYPE d3d8_vertexbuffer_wined3d_object_destroyed(void *parent)
 273 {
 274     HeapFree(GetProcessHeap(), 0, parent);
 275 }
 276
 277 static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops =
 278 {
 279     d3d8_vertexbuffer_wined3d_object_destroyed,
 280 };
 281
 282 HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device,
 283         UINT size, DWORD usage, DWORD fvf, D3DPOOL pool)
 284 {
 285     HRESULT hr;
 286
 287     buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl;
 288     buffer->refcount = 1;
 289     buffer->fvf = fvf;
 290
 291     wined3d_mutex_lock();
 292     hr = wined3d_buffer_create_vb(device->wined3d_device, size, usage & WINED3DUSAGE_MASK,
 293             (enum wined3d_pool)pool, buffer, &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
 294     wined3d_mutex_unlock();
 295     if (FAILED(hr))
 296     {
 297         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 298         return hr;
 299     }
 300
 301     buffer->parent_device = &device->IDirect3DDevice8_iface;
 302     IDirect3DDevice8_AddRef(buffer->parent_device);
 303
 304     return D3D_OK;
 305 }
 306
 307 struct d3d8_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface)
 308 {
 309     if (!iface)
 310         return NULL;
 311     assert(iface->lpVtbl == &Direct3DVertexBuffer8_Vtbl);
 312
 313     return impl_from_IDirect3DVertexBuffer8(iface);
 314 }
 315
 316 static inline struct d3d8_indexbuffer *impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 317 {
 318     return CONTAINING_RECORD(iface, struct d3d8_indexbuffer, IDirect3DIndexBuffer8_iface);
 319 }
 320
 321 static HRESULT WINAPI d3d8_indexbuffer_QueryInterface(IDirect3DIndexBuffer8 *iface, REFIID riid, void **object)
 322 {
 323     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 324
 325     if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer8)
 326             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 327             || IsEqualGUID(riid, &IID_IUnknown))
 328     {
 329         IDirect3DIndexBuffer8_AddRef(iface);
 330         *object = iface;
 331         return S_OK;
 332     }
 333
 334     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 335
 336     *object = NULL;
 337     return E_NOINTERFACE;
 338 }
 339
 340 static ULONG WINAPI d3d8_indexbuffer_AddRef(IDirect3DIndexBuffer8 *iface)
 341 {
 342     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 343     ULONG refcount = InterlockedIncrement(&buffer->refcount);
 344
 345     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 346
 347     if (refcount == 1)
 348     {
 349         IDirect3DDevice8_AddRef(buffer->parent_device);
 350         wined3d_mutex_lock();
 351         wined3d_buffer_incref(buffer->wined3d_buffer);
 352         wined3d_mutex_unlock();
 353     }
 354
 355     return refcount;
 356 }
 357
 358 static ULONG WINAPI d3d8_indexbuffer_Release(IDirect3DIndexBuffer8 *iface)
 359 {
 360     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 361     ULONG refcount = InterlockedDecrement(&buffer->refcount);
 362
 363     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 364
 365     if (!refcount)
 366     {
 367         IDirect3DDevice8 *device = buffer->parent_device;
 368
 369         wined3d_mutex_lock();
 370         wined3d_buffer_decref(buffer->wined3d_buffer);
 371         wined3d_mutex_unlock();
 372
 373         /* Release the device last, as it may cause the device to be destroyed. */
 374         IDirect3DDevice8_Release(device);
 375     }
 376
 377     return refcount;
 378 }
 379
 380 static HRESULT WINAPI d3d8_indexbuffer_GetDevice(IDirect3DIndexBuffer8 *iface,
 381         IDirect3DDevice8 **device)
 382 {
 383     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 384
 385     TRACE("iface %p, device %p.\n", iface, device);
 386
 387     *device = buffer->parent_device;
 388     IDirect3DDevice8_AddRef(*device);
 389
 390     TRACE("Returning device %p.\n", *device);
 391
 392     return D3D_OK;
 393 }
 394
 395 static HRESULT WINAPI d3d8_indexbuffer_SetPrivateData(IDirect3DIndexBuffer8 *iface,
 396         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 397 {
 398     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 399     struct wined3d_resource *resource;
 400     HRESULT hr;
 401
 402     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 403             iface, debugstr_guid(guid), data, data_size, flags);
 404
 405     wined3d_mutex_lock();
 406     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 407     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 408     wined3d_mutex_unlock();
 409
 410     return hr;
 411 }
 412
 413 static HRESULT WINAPI d3d8_indexbuffer_GetPrivateData(IDirect3DIndexBuffer8 *iface,
 414         REFGUID guid, void *data, DWORD *data_size)
 415 {
 416     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 417     struct wined3d_resource *resource;
 418     HRESULT hr;
 419
 420     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 421             iface, debugstr_guid(guid), data, data_size);
 422
 423     wined3d_mutex_lock();
 424     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 425     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 426     wined3d_mutex_unlock();
 427
 428     return hr;
 429 }
 430
 431 static HRESULT WINAPI d3d8_indexbuffer_FreePrivateData(IDirect3DIndexBuffer8 *iface, REFGUID guid)
 432 {
 433     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 434     struct wined3d_resource *resource;
 435     HRESULT hr;
 436
 437     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 438
 439     wined3d_mutex_lock();
 440     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 441     hr = wined3d_resource_free_private_data(resource, guid);
 442     wined3d_mutex_unlock();
 443
 444     return hr;
 445 }
 446
 447 static DWORD WINAPI d3d8_indexbuffer_SetPriority(IDirect3DIndexBuffer8 *iface, DWORD priority)
 448 {
 449     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 450     DWORD previous;
 451
 452     TRACE("iface %p, priority %u.\n", iface, priority);
 453
 454     wined3d_mutex_lock();
 455     previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority);
 456     wined3d_mutex_unlock();
 457
 458     return previous;
 459 }
 460
 461 static DWORD WINAPI d3d8_indexbuffer_GetPriority(IDirect3DIndexBuffer8 *iface)
 462 {
 463     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 464     DWORD priority;
 465
 466     TRACE("iface %p.\n", iface);
 467
 468     wined3d_mutex_lock();
 469     priority = wined3d_buffer_get_priority(buffer->wined3d_buffer);
 470     wined3d_mutex_unlock();
 471
 472     return priority;
 473 }
 474
 475 static void WINAPI d3d8_indexbuffer_PreLoad(IDirect3DIndexBuffer8 *iface)
 476 {
 477     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 478
 479     TRACE("iface %p.\n", iface);
 480
 481     wined3d_mutex_lock();
 482     wined3d_buffer_preload(buffer->wined3d_buffer);
 483     wined3d_mutex_unlock();
 484 }
 485
 486 static D3DRESOURCETYPE WINAPI d3d8_indexbuffer_GetType(IDirect3DIndexBuffer8 *iface)
 487 {
 488     TRACE("iface %p.\n", iface);
 489
 490     return D3DRTYPE_INDEXBUFFER;
 491 }
 492
 493 static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size,
 494         BYTE **data, DWORD flags)
 495 {
 496     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 497     HRESULT hr;
 498
 499     TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
 500             iface, offset, size, data, flags);
 501
 502     wined3d_mutex_lock();
 503     hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, data, flags);
 504     wined3d_mutex_unlock();
 505
 506     return hr;
 507 }
 508
 509 static HRESULT WINAPI d3d8_indexbuffer_Unlock(IDirect3DIndexBuffer8 *iface)
 510 {
 511     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 512
 513     TRACE("iface %p.\n", iface);
 514
 515     wined3d_mutex_lock();
 516     wined3d_buffer_unmap(buffer->wined3d_buffer);
 517     wined3d_mutex_unlock();
 518
 519     return D3D_OK;
 520 }
 521
 522 static HRESULT WINAPI d3d8_indexbuffer_GetDesc(IDirect3DIndexBuffer8 *iface,
 523         D3DINDEXBUFFER_DESC *desc)
 524 {
 525     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 526     struct wined3d_resource_desc wined3d_desc;
 527     struct wined3d_resource *wined3d_resource;
 528
 529     TRACE("iface %p, desc %p.\n", iface, desc);
 530
 531     wined3d_mutex_lock();
 532     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 533     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 534     wined3d_mutex_unlock();
 535
 536     desc->Format = d3dformat_from_wined3dformat(buffer->format);
 537     desc->Type = D3DRTYPE_INDEXBUFFER;
 538     desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 539     desc->Pool = wined3d_desc.pool;
 540     desc->Size = wined3d_desc.size;
 541
 542     return D3D_OK;
 543 }
 544
 545 static const IDirect3DIndexBuffer8Vtbl d3d8_indexbuffer_vtbl =
 546 {
 547     /* IUnknown */
 548     d3d8_indexbuffer_QueryInterface,
 549     d3d8_indexbuffer_AddRef,
 550     d3d8_indexbuffer_Release,
 551     /* IDirect3DResource8 */
 552     d3d8_indexbuffer_GetDevice,
 553     d3d8_indexbuffer_SetPrivateData,
 554     d3d8_indexbuffer_GetPrivateData,
 555     d3d8_indexbuffer_FreePrivateData,
 556     d3d8_indexbuffer_SetPriority,
 557     d3d8_indexbuffer_GetPriority,
 558     d3d8_indexbuffer_PreLoad,
 559     d3d8_indexbuffer_GetType,
 560     /* IDirect3DIndexBuffer8 */
 561     d3d8_indexbuffer_Lock,
 562     d3d8_indexbuffer_Unlock,
 563     d3d8_indexbuffer_GetDesc,
 564 };
 565
 566 static void STDMETHODCALLTYPE d3d8_indexbuffer_wined3d_object_destroyed(void *parent)
 567 {
 568     HeapFree(GetProcessHeap(), 0, parent);
 569 }
 570
 571 static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops =
 572 {
 573     d3d8_indexbuffer_wined3d_object_destroyed,
 574 };
 575
 576 HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device,
 577         UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
 578 {
 579     HRESULT hr;
 580
 581     buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl;
 582     buffer->refcount = 1;
 583     buffer->format = wined3dformat_from_d3dformat(format);
 584
 585     wined3d_mutex_lock();
 586     hr = wined3d_buffer_create_ib(device->wined3d_device, size, usage & WINED3DUSAGE_MASK,
 587             (enum wined3d_pool)pool, buffer, &d3d8_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
 588     wined3d_mutex_unlock();
 589     if (FAILED(hr))
 590     {
 591         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 592         return hr;
 593     }
 594
 595     buffer->parent_device = &device->IDirect3DDevice8_iface;
 596     IDirect3DDevice8_AddRef(buffer->parent_device);
 597
 598     return D3D_OK;
 599 }
 600
 601 struct d3d8_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 602 {
 603     if (!iface)
 604         return NULL;
 605     assert(iface->lpVtbl == &d3d8_indexbuffer_vtbl);
 606
 607     return impl_from_IDirect3DIndexBuffer8(iface);
 608 }