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 %lu.\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 %lu.\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 %lu, flags %#lx.\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 %lu.\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 %#lx.\n",
 193             iface, offset, size, data, flags);
 194
 195     if (buffer->discarded)
 196     {
 197         WARN("Filtering out redundant discard of %p.\n", buffer);
 198         flags = (flags & ~D3DLOCK_DISCARD) | D3DLOCK_NOOVERWRITE;
 199     }
 200     if (flags & D3DLOCK_DISCARD)
 201         buffer->discarded = true;
 202
 203     wined3d_box.left = offset;
 204     wined3d_box.right = offset + size;
 205     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 206     hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box,
 207             wined3dmapflags_from_d3dmapflags(flags, buffer->usage));
 208     *data = wined3d_map_desc.data;
 209
 210     return hr;
 211 }
 212
 213 static HRESULT WINAPI d3d8_vertexbuffer_Unlock(IDirect3DVertexBuffer8 *iface)
 214 {
 215     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 216
 217     TRACE("iface %p.\n", iface);
 218
 219     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 220
 221     return D3D_OK;
 222 }
 223
 224 static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface,
 225         D3DVERTEXBUFFER_DESC *desc)
 226 {
 227     struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
 228     struct wined3d_resource_desc wined3d_desc;
 229     struct wined3d_resource *wined3d_resource;
 230
 231     TRACE("iface %p, desc %p.\n", iface, desc);
 232
 233     wined3d_mutex_lock();
 234     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 235     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 236     wined3d_mutex_unlock();
 237
 238     desc->Format = D3DFMT_VERTEXDATA;
 239     desc->Type = D3DRTYPE_VERTEXBUFFER;
 240     desc->Usage = buffer->usage;
 241     desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 242     desc->Size = wined3d_desc.size;
 243     desc->FVF = buffer->fvf;
 244
 245     return D3D_OK;
 246 }
 247
 248 static const IDirect3DVertexBuffer8Vtbl Direct3DVertexBuffer8_Vtbl =
 249 {
 250     /* IUnknown */
 251     d3d8_vertexbuffer_QueryInterface,
 252     d3d8_vertexbuffer_AddRef,
 253     d3d8_vertexbuffer_Release,
 254     /* IDirect3DResource8 */
 255     d3d8_vertexbuffer_GetDevice,
 256     d3d8_vertexbuffer_SetPrivateData,
 257     d3d8_vertexbuffer_GetPrivateData,
 258     d3d8_vertexbuffer_FreePrivateData,
 259     d3d8_vertexbuffer_SetPriority,
 260     d3d8_vertexbuffer_GetPriority,
 261     d3d8_vertexbuffer_PreLoad,
 262     d3d8_vertexbuffer_GetType,
 263     /* IDirect3DVertexBuffer8 */
 264     d3d8_vertexbuffer_Lock,
 265     d3d8_vertexbuffer_Unlock,
 266     d3d8_vertexbuffer_GetDesc,
 267 };
 268
 269 static void STDMETHODCALLTYPE d3d8_vertexbuffer_wined3d_object_destroyed(void *parent)
 270 {
 271     struct d3d8_vertexbuffer *buffer = parent;
 272
 273     if (buffer->draw_buffer)
 274         wined3d_buffer_decref(buffer->wined3d_buffer);
 275     d3d8_resource_cleanup(&buffer->resource);
 276     free(buffer);
 277 }
 278
 279 static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops =
 280 {
 281     d3d8_vertexbuffer_wined3d_object_destroyed,
 282 };
 283
 284 HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device,
 285         UINT size, DWORD usage, DWORD fvf, D3DPOOL pool)
 286 {
 287     const struct wined3d_parent_ops *parent_ops = &d3d8_null_wined3d_parent_ops;
 288     struct wined3d_buffer_desc desc;
 289     HRESULT hr;
 290
 291     if (pool == D3DPOOL_SCRATCH)
 292     {
 293         WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n");
 294         return D3DERR_INVALIDCALL;
 295     }
 296
 297     /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
 298     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
 299         return D3DERR_INVALIDCALL;
 300
 301     buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl;
 302     d3d8_resource_init(&buffer->resource);
 303     buffer->fvf = fvf;
 304     buffer->usage = usage;
 305
 306     desc.byte_width = size;
 307     desc.usage = wined3d_usage_from_d3d(pool, usage);
 308     desc.bind_flags = 0;
 309     desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
 310     /* Buffers are always readable. */
 311     if (pool != D3DPOOL_DEFAULT)
 312         desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
 313     desc.misc_flags = 0;
 314     desc.structure_byte_stride = 0;
 315
 316     if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
 317     {
 318         desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
 319         parent_ops = &d3d8_vertexbuffer_wined3d_parent_ops;
 320     }
 321
 322     wined3d_mutex_lock();
 323     hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, parent_ops, &buffer->wined3d_buffer);
 324     if (SUCCEEDED(hr) && !(desc.access & WINED3D_RESOURCE_ACCESS_GPU))
 325     {
 326         desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
 327         desc.access = WINED3D_RESOURCE_ACCESS_GPU;
 328         if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
 329                 &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->draw_buffer)))
 330             wined3d_buffer_decref(buffer->wined3d_buffer);
 331     }
 332     wined3d_mutex_unlock();
 333     if (FAILED(hr))
 334     {
 335         WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
 336         return hr;
 337     }
 338
 339     buffer->parent_device = &device->IDirect3DDevice8_iface;
 340     IDirect3DDevice8_AddRef(buffer->parent_device);
 341
 342     return D3D_OK;
 343 }
 344
 345 struct d3d8_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface)
 346 {
 347     if (!iface)
 348         return NULL;
 349     assert(iface->lpVtbl == &Direct3DVertexBuffer8_Vtbl);
 350
 351     return impl_from_IDirect3DVertexBuffer8(iface);
 352 }
 353
 354 static inline struct d3d8_indexbuffer *impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 355 {
 356     return CONTAINING_RECORD(iface, struct d3d8_indexbuffer, IDirect3DIndexBuffer8_iface);
 357 }
 358
 359 static HRESULT WINAPI d3d8_indexbuffer_QueryInterface(IDirect3DIndexBuffer8 *iface, REFIID riid, void **object)
 360 {
 361     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 362
 363     if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer8)
 364             || IsEqualGUID(riid, &IID_IDirect3DResource8)
 365             || IsEqualGUID(riid, &IID_IUnknown))
 366     {
 367         IDirect3DIndexBuffer8_AddRef(iface);
 368         *object = iface;
 369         return S_OK;
 370     }
 371
 372     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 373
 374     *object = NULL;
 375     return E_NOINTERFACE;
 376 }
 377
 378 static ULONG WINAPI d3d8_indexbuffer_AddRef(IDirect3DIndexBuffer8 *iface)
 379 {
 380     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 381     ULONG refcount = InterlockedIncrement(&buffer->resource.refcount);
 382
 383     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 384
 385     if (refcount == 1)
 386     {
 387         IDirect3DDevice8_AddRef(buffer->parent_device);
 388         wined3d_buffer_incref(buffer->wined3d_buffer);
 389     }
 390
 391     return refcount;
 392 }
 393
 394 static ULONG WINAPI d3d8_indexbuffer_Release(IDirect3DIndexBuffer8 *iface)
 395 {
 396     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 397     ULONG refcount = InterlockedDecrement(&buffer->resource.refcount);
 398
 399     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 400
 401     if (!refcount)
 402     {
 403         IDirect3DDevice8 *device = buffer->parent_device;
 404
 405         wined3d_buffer_decref(buffer->wined3d_buffer);
 406
 407         /* Release the device last, as it may cause the device to be destroyed. */
 408         IDirect3DDevice8_Release(device);
 409     }
 410
 411     return refcount;
 412 }
 413
 414 static HRESULT WINAPI d3d8_indexbuffer_GetDevice(IDirect3DIndexBuffer8 *iface,
 415         IDirect3DDevice8 **device)
 416 {
 417     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 418
 419     TRACE("iface %p, device %p.\n", iface, device);
 420
 421     *device = buffer->parent_device;
 422     IDirect3DDevice8_AddRef(*device);
 423
 424     TRACE("Returning device %p.\n", *device);
 425
 426     return D3D_OK;
 427 }
 428
 429 static HRESULT WINAPI d3d8_indexbuffer_SetPrivateData(IDirect3DIndexBuffer8 *iface,
 430         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 431 {
 432     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 433     TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
 434             iface, debugstr_guid(guid), data, data_size, flags);
 435
 436     return d3d8_resource_set_private_data(&buffer->resource, guid, data, data_size, flags);
 437 }
 438
 439 static HRESULT WINAPI d3d8_indexbuffer_GetPrivateData(IDirect3DIndexBuffer8 *iface,
 440         REFGUID guid, void *data, DWORD *data_size)
 441 {
 442     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 443     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 444             iface, debugstr_guid(guid), data, data_size);
 445
 446     return d3d8_resource_get_private_data(&buffer->resource, guid, data, data_size);
 447 }
 448
 449 static HRESULT WINAPI d3d8_indexbuffer_FreePrivateData(IDirect3DIndexBuffer8 *iface, REFGUID guid)
 450 {
 451     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 452     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 453
 454     return d3d8_resource_free_private_data(&buffer->resource, guid);
 455 }
 456
 457 static DWORD WINAPI d3d8_indexbuffer_SetPriority(IDirect3DIndexBuffer8 *iface, DWORD priority)
 458 {
 459     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 460     struct wined3d_resource *resource;
 461     DWORD previous;
 462
 463     TRACE("iface %p, priority %lu.\n", iface, priority);
 464
 465     wined3d_mutex_lock();
 466     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 467     previous = wined3d_resource_set_priority(resource, priority);
 468     wined3d_mutex_unlock();
 469
 470     return previous;
 471 }
 472
 473 static DWORD WINAPI d3d8_indexbuffer_GetPriority(IDirect3DIndexBuffer8 *iface)
 474 {
 475     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 476     const struct wined3d_resource *resource;
 477     DWORD priority;
 478
 479     TRACE("iface %p.\n", iface);
 480
 481     wined3d_mutex_lock();
 482     resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 483     priority = wined3d_resource_get_priority(resource);
 484     wined3d_mutex_unlock();
 485
 486     return priority;
 487 }
 488
 489 static void WINAPI d3d8_indexbuffer_PreLoad(IDirect3DIndexBuffer8 *iface)
 490 {
 491     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 492
 493     TRACE("iface %p.\n", iface);
 494
 495     wined3d_mutex_lock();
 496     wined3d_resource_preload(wined3d_buffer_get_resource(buffer->wined3d_buffer));
 497     wined3d_mutex_unlock();
 498 }
 499
 500 static D3DRESOURCETYPE WINAPI d3d8_indexbuffer_GetType(IDirect3DIndexBuffer8 *iface)
 501 {
 502     TRACE("iface %p.\n", iface);
 503
 504     return D3DRTYPE_INDEXBUFFER;
 505 }
 506
 507 static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size,
 508         BYTE **data, DWORD flags)
 509 {
 510     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 511     struct wined3d_resource *wined3d_resource;
 512     struct wined3d_map_desc wined3d_map_desc;
 513     struct wined3d_box wined3d_box = {0};
 514     HRESULT hr;
 515
 516     TRACE("iface %p, offset %u, size %u, data %p, flags %#lx.\n",
 517             iface, offset, size, data, flags);
 518
 519     if (buffer->discarded)
 520     {
 521         WARN("Filtering out redundant discard of %p.\n", buffer);
 522         flags = (flags & ~D3DLOCK_DISCARD) | D3DLOCK_NOOVERWRITE;
 523     }
 524     if (flags & D3DLOCK_DISCARD)
 525         buffer->discarded = true;
 526
 527     wined3d_box.left = offset;
 528     wined3d_box.right = offset + size;
 529     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 530     hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box,
 531             wined3dmapflags_from_d3dmapflags(flags, buffer->usage));
 532     *data = wined3d_map_desc.data;
 533
 534     return hr;
 535 }
 536
 537 static HRESULT WINAPI d3d8_indexbuffer_Unlock(IDirect3DIndexBuffer8 *iface)
 538 {
 539     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 540
 541     TRACE("iface %p.\n", iface);
 542
 543     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 544
 545     return D3D_OK;
 546 }
 547
 548 static HRESULT WINAPI d3d8_indexbuffer_GetDesc(IDirect3DIndexBuffer8 *iface,
 549         D3DINDEXBUFFER_DESC *desc)
 550 {
 551     struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
 552     struct wined3d_resource_desc wined3d_desc;
 553     struct wined3d_resource *wined3d_resource;
 554
 555     TRACE("iface %p, desc %p.\n", iface, desc);
 556
 557     wined3d_mutex_lock();
 558     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 559     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 560     wined3d_mutex_unlock();
 561
 562     desc->Format = d3dformat_from_wined3dformat(buffer->format);
 563     desc->Type = D3DRTYPE_INDEXBUFFER;
 564     desc->Usage = buffer->usage;
 565     desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage);
 566     desc->Size = wined3d_desc.size;
 567
 568     return D3D_OK;
 569 }
 570
 571 static const IDirect3DIndexBuffer8Vtbl d3d8_indexbuffer_vtbl =
 572 {
 573     /* IUnknown */
 574     d3d8_indexbuffer_QueryInterface,
 575     d3d8_indexbuffer_AddRef,
 576     d3d8_indexbuffer_Release,
 577     /* IDirect3DResource8 */
 578     d3d8_indexbuffer_GetDevice,
 579     d3d8_indexbuffer_SetPrivateData,
 580     d3d8_indexbuffer_GetPrivateData,
 581     d3d8_indexbuffer_FreePrivateData,
 582     d3d8_indexbuffer_SetPriority,
 583     d3d8_indexbuffer_GetPriority,
 584     d3d8_indexbuffer_PreLoad,
 585     d3d8_indexbuffer_GetType,
 586     /* IDirect3DIndexBuffer8 */
 587     d3d8_indexbuffer_Lock,
 588     d3d8_indexbuffer_Unlock,
 589     d3d8_indexbuffer_GetDesc,
 590 };
 591
 592 static void STDMETHODCALLTYPE d3d8_indexbuffer_wined3d_object_destroyed(void *parent)
 593 {
 594     struct d3d8_indexbuffer *buffer = parent;
 595
 596     d3d8_resource_cleanup(&buffer->resource);
 597     free(buffer);
 598 }
 599
 600 static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops =
 601 {
 602     d3d8_indexbuffer_wined3d_object_destroyed,
 603 };
 604
 605 HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device,
 606         UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
 607 {
 608     struct wined3d_buffer_desc desc;
 609     HRESULT hr;
 610
 611     if (pool == D3DPOOL_SCRATCH)
 612         return D3DERR_INVALIDCALL;
 613
 614     /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
 615     if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
 616         return D3DERR_INVALIDCALL;
 617
 618     desc.byte_width = size;
 619     desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_STATICDECL;
 620     desc.bind_flags = 0;
 621     desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
 622     /* Buffers are always readable. */
 623     if (pool != D3DPOOL_DEFAULT)
 624         desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
 625     desc.misc_flags = 0;
 626     desc.structure_byte_stride = 0;
 627
 628     if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
 629         desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
 630
 631     buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl;
 632     d3d8_resource_init(&buffer->resource);
 633     buffer->format = wined3dformat_from_d3dformat(format);
 634     buffer->usage = usage;
 635     buffer->sysmem = !(desc.access & WINED3D_RESOURCE_ACCESS_GPU);
 636
 637     wined3d_mutex_lock();
 638     hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
 639             &d3d8_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
 640     wined3d_mutex_unlock();
 641     if (FAILED(hr))
 642     {
 643         WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
 644         return hr;
 645     }
 646
 647     buffer->parent_device = &device->IDirect3DDevice8_iface;
 648     IDirect3DDevice8_AddRef(buffer->parent_device);
 649
 650     return D3D_OK;
 651 }
 652
 653 struct d3d8_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface)
 654 {
 655     if (!iface)
 656         return NULL;
 657     assert(iface->lpVtbl == &d3d8_indexbuffer_vtbl);
 658
 659     return impl_from_IDirect3DIndexBuffer8(iface);
 660 }