reactos/dll/directx/wine/d3d9/buffer.c

   1 /*
   2  * Copyright 2002-2004 Jason Edmeades
   3  * Copyright 2002-2004 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 "d3d9_private.h"
  22
  23 static inline struct d3d9_vertexbuffer *impl_from_IDirect3DVertexBuffer9(IDirect3DVertexBuffer9 *iface)
  24 {
  25     return CONTAINING_RECORD(iface, struct d3d9_vertexbuffer, IDirect3DVertexBuffer9_iface);
  26 }
  27
  28 static HRESULT WINAPI d3d9_vertexbuffer_QueryInterface(IDirect3DVertexBuffer9 *iface, REFIID riid, void **out)
  29 {
  30     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  31
  32     if (IsEqualGUID(riid, &IID_IDirect3DVertexBuffer9)
  33             || IsEqualGUID(riid, &IID_IDirect3DResource9)
  34             || IsEqualGUID(riid, &IID_IUnknown))
  35     {
  36         IDirect3DVertexBuffer9_AddRef(iface);
  37         *out = iface;
  38         return S_OK;
  39     }
  40
  41     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  42
  43     *out = NULL;
  44     return E_NOINTERFACE;
  45 }
  46
  47 static ULONG WINAPI d3d9_vertexbuffer_AddRef(IDirect3DVertexBuffer9 *iface)
  48 {
  49     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
  50     ULONG refcount = InterlockedIncrement(&buffer->refcount);
  51
  52     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  53
  54     if (refcount == 1)
  55     {
  56         IDirect3DDevice9Ex_AddRef(buffer->parent_device);
  57         wined3d_mutex_lock();
  58         wined3d_buffer_incref(buffer->wined3d_buffer);
  59         wined3d_mutex_unlock();
  60     }
  61
  62     return refcount;
  63 }
  64
  65 static ULONG WINAPI d3d9_vertexbuffer_Release(IDirect3DVertexBuffer9 *iface)
  66 {
  67     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
  68     ULONG refcount = InterlockedDecrement(&buffer->refcount);
  69
  70     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  71
  72     if (!refcount)
  73     {
  74         IDirect3DDevice9Ex *device = buffer->parent_device;
  75
  76         wined3d_mutex_lock();
  77         wined3d_buffer_decref(buffer->wined3d_buffer);
  78         wined3d_mutex_unlock();
  79
  80         /* Release the device last, as it may cause the device to be destroyed. */
  81         IDirect3DDevice9Ex_Release(device);
  82     }
  83
  84     return refcount;
  85 }
  86
  87 static HRESULT WINAPI d3d9_vertexbuffer_GetDevice(IDirect3DVertexBuffer9 *iface, IDirect3DDevice9 **device)
  88 {
  89     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
  90
  91     TRACE("iface %p, device %p.\n", iface, device);
  92
  93     *device = (IDirect3DDevice9 *)buffer->parent_device;
  94     IDirect3DDevice9_AddRef(*device);
  95
  96     TRACE("Returning device %p.\n", *device);
  97
  98     return D3D_OK;
  99 }
 100
 101 static HRESULT WINAPI d3d9_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer9 *iface,
 102         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 103 {
 104     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 105     struct wined3d_resource *resource;
 106     HRESULT hr;
 107
 108     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 109             iface, debugstr_guid(guid), data, data_size, flags);
 110
 111     wined3d_mutex_lock();
 112     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 113     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 114     wined3d_mutex_unlock();
 115
 116     return hr;
 117 }
 118
 119 static HRESULT WINAPI d3d9_vertexbuffer_GetPrivateData(IDirect3DVertexBuffer9 *iface,
 120         REFGUID guid, void *data, DWORD *data_size)
 121 {
 122     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 123     struct wined3d_resource *resource;
 124     HRESULT hr;
 125
 126     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 127             iface, debugstr_guid(guid), data, data_size);
 128
 129     wined3d_mutex_lock();
 130     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 131     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 132     wined3d_mutex_unlock();
 133
 134     return hr;
 135 }
 136
 137 static HRESULT WINAPI d3d9_vertexbuffer_FreePrivateData(IDirect3DVertexBuffer9 *iface, REFGUID guid)
 138 {
 139     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 140     struct wined3d_resource *resource;
 141     HRESULT hr;
 142
 143     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 144
 145     wined3d_mutex_lock();
 146     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 147     hr = wined3d_resource_free_private_data(resource, guid);
 148     wined3d_mutex_unlock();
 149
 150     return hr;
 151 }
 152
 153 static DWORD WINAPI d3d9_vertexbuffer_SetPriority(IDirect3DVertexBuffer9 *iface, DWORD priority)
 154 {
 155     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 156     DWORD previous;
 157
 158     TRACE("iface %p, priority %u.\n", iface, priority);
 159
 160     wined3d_mutex_lock();
 161     previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority);
 162     wined3d_mutex_unlock();
 163
 164     return previous;
 165 }
 166
 167 static DWORD WINAPI d3d9_vertexbuffer_GetPriority(IDirect3DVertexBuffer9 *iface)
 168 {
 169     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 170     DWORD priority;
 171
 172     TRACE("iface %p.\n", iface);
 173
 174     wined3d_mutex_lock();
 175     priority = wined3d_buffer_get_priority(buffer->wined3d_buffer);
 176     wined3d_mutex_unlock();
 177
 178     return priority;
 179 }
 180
 181 static void WINAPI d3d9_vertexbuffer_PreLoad(IDirect3DVertexBuffer9 *iface)
 182 {
 183     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 184
 185     TRACE("iface %p.\n", iface);
 186
 187     wined3d_mutex_lock();
 188     wined3d_buffer_preload(buffer->wined3d_buffer);
 189     wined3d_mutex_unlock();
 190 }
 191
 192 static D3DRESOURCETYPE WINAPI d3d9_vertexbuffer_GetType(IDirect3DVertexBuffer9 *iface)
 193 {
 194     TRACE("iface %p.\n", iface);
 195
 196     return D3DRTYPE_VERTEXBUFFER;
 197 }
 198
 199 static HRESULT WINAPI d3d9_vertexbuffer_Lock(IDirect3DVertexBuffer9 *iface, UINT offset, UINT size,
 200         void **data, DWORD flags)
 201 {
 202     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 203     HRESULT hr;
 204
 205     TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
 206             iface, offset, size, data, flags);
 207
 208     wined3d_mutex_lock();
 209     hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, (BYTE **)data, flags);
 210     wined3d_mutex_unlock();
 211
 212     return hr;
 213 }
 214
 215 static HRESULT WINAPI d3d9_vertexbuffer_Unlock(IDirect3DVertexBuffer9 *iface)
 216 {
 217     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 218
 219     TRACE("iface %p.\n", iface);
 220
 221     wined3d_mutex_lock();
 222     wined3d_buffer_unmap(buffer->wined3d_buffer);
 223     wined3d_mutex_unlock();
 224
 225     return D3D_OK;
 226 }
 227
 228 static HRESULT WINAPI d3d9_vertexbuffer_GetDesc(IDirect3DVertexBuffer9 *iface,
 229         D3DVERTEXBUFFER_DESC *desc)
 230 {
 231     struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface);
 232     struct wined3d_resource_desc wined3d_desc;
 233     struct wined3d_resource *wined3d_resource;
 234
 235     TRACE("iface %p, desc %p.\n", iface, desc);
 236
 237     wined3d_mutex_lock();
 238     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 239     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 240     wined3d_mutex_unlock();
 241
 242     desc->Format = D3DFMT_VERTEXDATA;
 243     desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 244     desc->Pool = wined3d_desc.pool;
 245     desc->Size = wined3d_desc.size;
 246     desc->Type = D3DRTYPE_VERTEXBUFFER;
 247     desc->FVF = buffer->fvf;
 248
 249     return D3D_OK;
 250 }
 251
 252 static const IDirect3DVertexBuffer9Vtbl d3d9_vertexbuffer_vtbl =
 253 {
 254     /* IUnknown */
 255     d3d9_vertexbuffer_QueryInterface,
 256     d3d9_vertexbuffer_AddRef,
 257     d3d9_vertexbuffer_Release,
 258     /* IDirect3DResource9 */
 259     d3d9_vertexbuffer_GetDevice,
 260     d3d9_vertexbuffer_SetPrivateData,
 261     d3d9_vertexbuffer_GetPrivateData,
 262     d3d9_vertexbuffer_FreePrivateData,
 263     d3d9_vertexbuffer_SetPriority,
 264     d3d9_vertexbuffer_GetPriority,
 265     d3d9_vertexbuffer_PreLoad,
 266     d3d9_vertexbuffer_GetType,
 267     /* IDirect3DVertexBuffer9 */
 268     d3d9_vertexbuffer_Lock,
 269     d3d9_vertexbuffer_Unlock,
 270     d3d9_vertexbuffer_GetDesc,
 271 };
 272
 273 static void STDMETHODCALLTYPE d3d9_vertexbuffer_wined3d_object_destroyed(void *parent)
 274 {
 275     HeapFree(GetProcessHeap(), 0, parent);
 276 }
 277
 278 static const struct wined3d_parent_ops d3d9_vertexbuffer_wined3d_parent_ops =
 279 {
 280     d3d9_vertexbuffer_wined3d_object_destroyed,
 281 };
 282
 283 HRESULT vertexbuffer_init(struct d3d9_vertexbuffer *buffer, struct d3d9_device *device,
 284         UINT size, UINT usage, DWORD fvf, D3DPOOL pool)
 285 {
 286     HRESULT hr;
 287
 288     buffer->IDirect3DVertexBuffer9_iface.lpVtbl = &d3d9_vertexbuffer_vtbl;
 289     buffer->refcount = 1;
 290     buffer->fvf = fvf;
 291
 292     wined3d_mutex_lock();
 293     hr = wined3d_buffer_create_vb(device->wined3d_device, size, usage & WINED3DUSAGE_MASK,
 294             (enum wined3d_pool)pool, buffer, &d3d9_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
 295     wined3d_mutex_unlock();
 296     if (FAILED(hr))
 297     {
 298         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 299         return hr;
 300     }
 301
 302     buffer->parent_device = &device->IDirect3DDevice9Ex_iface;
 303     IDirect3DDevice9Ex_AddRef(buffer->parent_device);
 304
 305     return D3D_OK;
 306 }
 307
 308 struct d3d9_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer9(IDirect3DVertexBuffer9 *iface)
 309 {
 310     if (!iface)
 311         return NULL;
 312     assert(iface->lpVtbl == &d3d9_vertexbuffer_vtbl);
 313
 314     return impl_from_IDirect3DVertexBuffer9(iface);
 315 }
 316
 317 static inline struct d3d9_indexbuffer *impl_from_IDirect3DIndexBuffer9(IDirect3DIndexBuffer9 *iface)
 318 {
 319     return CONTAINING_RECORD(iface, struct d3d9_indexbuffer, IDirect3DIndexBuffer9_iface);
 320 }
 321
 322 static HRESULT WINAPI d3d9_indexbuffer_QueryInterface(IDirect3DIndexBuffer9 *iface, REFIID riid, void **out)
 323 {
 324     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 325
 326     if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer9)
 327             || IsEqualGUID(riid, &IID_IDirect3DResource9)
 328             || IsEqualGUID(riid, &IID_IUnknown))
 329     {
 330         IDirect3DIndexBuffer9_AddRef(iface);
 331         *out = iface;
 332         return S_OK;
 333     }
 334
 335     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 336
 337     *out = NULL;
 338     return E_NOINTERFACE;
 339 }
 340
 341 static ULONG WINAPI d3d9_indexbuffer_AddRef(IDirect3DIndexBuffer9 *iface)
 342 {
 343     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface);
 344     ULONG refcount = InterlockedIncrement(&buffer->refcount);
 345
 346     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 347
 348     if (refcount == 1)
 349     {
 350         IDirect3DDevice9Ex_AddRef(buffer->parent_device);
 351         wined3d_mutex_lock();
 352         wined3d_buffer_incref(buffer->wined3d_buffer);
 353         wined3d_mutex_unlock();
 354     }
 355
 356     return refcount;
 357 }
 358
 359 static ULONG WINAPI d3d9_indexbuffer_Release(IDirect3DIndexBuffer9 *iface)
 360 {
 361     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface);
 362     ULONG refcount = InterlockedDecrement(&buffer->refcount);
 363
 364     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 365
 366     if (!refcount)
 367     {
 368         IDirect3DDevice9Ex *device = buffer->parent_device;
 369
 370         wined3d_mutex_lock();
 371         wined3d_buffer_decref(buffer->wined3d_buffer);
 372         wined3d_mutex_unlock();
 373
 374         /* Release the device last, as it may cause the device to be destroyed. */
 375         IDirect3DDevice9Ex_Release(device);
 376     }
 377
 378     return refcount;
 379 }
 380
 381 static HRESULT WINAPI d3d9_indexbuffer_GetDevice(IDirect3DIndexBuffer9 *iface, IDirect3DDevice9 **device)
 382 {
 383     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface);
 384
 385     TRACE("iface %p, device %p.\n", iface, device);
 386
 387     *device = (IDirect3DDevice9 *)buffer->parent_device;
 388     IDirect3DDevice9_AddRef(*device);
 389
 390     TRACE("Returning device %p.\n", *device);
 391
 392     return D3D_OK;
 393 }
 394
 395 static HRESULT WINAPI d3d9_indexbuffer_SetPrivateData(IDirect3DIndexBuffer9 *iface,
 396         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 397 {
 398     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_GetPrivateData(IDirect3DIndexBuffer9 *iface,
 414         REFGUID guid, void *data, DWORD *data_size)
 415 {
 416     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_FreePrivateData(IDirect3DIndexBuffer9 *iface, REFGUID guid)
 432 {
 433     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_SetPriority(IDirect3DIndexBuffer9 *iface, DWORD priority)
 448 {
 449     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_GetPriority(IDirect3DIndexBuffer9 *iface)
 462 {
 463     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_PreLoad(IDirect3DIndexBuffer9 *iface)
 476 {
 477     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_GetType(IDirect3DIndexBuffer9 *iface)
 487 {
 488     TRACE("iface %p.\n", iface);
 489
 490     return D3DRTYPE_INDEXBUFFER;
 491 }
 492
 493 static HRESULT WINAPI d3d9_indexbuffer_Lock(IDirect3DIndexBuffer9 *iface,
 494         UINT offset, UINT size, void **data, DWORD flags)
 495 {
 496     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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, (BYTE **)data, flags);
 504     wined3d_mutex_unlock();
 505
 506     return hr;
 507 }
 508
 509 static HRESULT WINAPI d3d9_indexbuffer_Unlock(IDirect3DIndexBuffer9 *iface)
 510 {
 511     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(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 d3d9_indexbuffer_GetDesc(IDirect3DIndexBuffer9 *iface, D3DINDEXBUFFER_DESC *desc)
 523 {
 524     struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface);
 525     struct wined3d_resource_desc wined3d_desc;
 526     struct wined3d_resource *wined3d_resource;
 527
 528     TRACE("iface %p, desc %p.\n", iface, desc);
 529
 530     wined3d_mutex_lock();
 531     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 532     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 533     wined3d_mutex_unlock();
 534
 535     desc->Format = d3dformat_from_wined3dformat(buffer->format);
 536     desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
 537     desc->Pool = wined3d_desc.pool;
 538     desc->Size = wined3d_desc.size;
 539     desc->Type = D3DRTYPE_INDEXBUFFER;
 540
 541     return D3D_OK;
 542 }
 543
 544 static const IDirect3DIndexBuffer9Vtbl d3d9_indexbuffer_vtbl =
 545 {
 546     /* IUnknown */
 547     d3d9_indexbuffer_QueryInterface,
 548     d3d9_indexbuffer_AddRef,
 549     d3d9_indexbuffer_Release,
 550     /* IDirect3DResource9 */
 551     d3d9_indexbuffer_GetDevice,
 552     d3d9_indexbuffer_SetPrivateData,
 553     d3d9_indexbuffer_GetPrivateData,
 554     d3d9_indexbuffer_FreePrivateData,
 555     d3d9_indexbuffer_SetPriority,
 556     d3d9_indexbuffer_GetPriority,
 557     d3d9_indexbuffer_PreLoad,
 558     d3d9_indexbuffer_GetType,
 559     /* IDirect3DIndexBuffer9 */
 560     d3d9_indexbuffer_Lock,
 561     d3d9_indexbuffer_Unlock,
 562     d3d9_indexbuffer_GetDesc,
 563 };
 564
 565 static void STDMETHODCALLTYPE d3d9_indexbuffer_wined3d_object_destroyed(void *parent)
 566 {
 567     HeapFree(GetProcessHeap(), 0, parent);
 568 }
 569
 570 static const struct wined3d_parent_ops d3d9_indexbuffer_wined3d_parent_ops =
 571 {
 572     d3d9_indexbuffer_wined3d_object_destroyed,
 573 };
 574
 575 HRESULT indexbuffer_init(struct d3d9_indexbuffer *buffer, struct d3d9_device *device,
 576         UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
 577 {
 578     HRESULT hr;
 579
 580     buffer->IDirect3DIndexBuffer9_iface.lpVtbl = &d3d9_indexbuffer_vtbl;
 581     buffer->refcount = 1;
 582     buffer->format = wined3dformat_from_d3dformat(format);
 583
 584     wined3d_mutex_lock();
 585     hr = wined3d_buffer_create_ib(device->wined3d_device, size, usage & WINED3DUSAGE_MASK,
 586             (enum wined3d_pool)pool, buffer, &d3d9_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
 587     wined3d_mutex_unlock();
 588     if (FAILED(hr))
 589     {
 590         WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
 591         return hr;
 592     }
 593
 594     buffer->parent_device = &device->IDirect3DDevice9Ex_iface;
 595     IDirect3DDevice9Ex_AddRef(buffer->parent_device);
 596
 597     return D3D_OK;
 598 }
 599
 600 struct d3d9_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer9(IDirect3DIndexBuffer9 *iface)
 601 {
 602     if (!iface)
 603         return NULL;
 604     assert(iface->lpVtbl == &d3d9_indexbuffer_vtbl);
 605
 606     return impl_from_IDirect3DIndexBuffer9(iface);
 607 }