dlls/d3d11/buffer.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   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
  20 #include "d3d11_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  23
  24 /* ID3D11Buffer methods */
  25
  26 static inline struct d3d_buffer *impl_from_ID3D11Buffer(ID3D11Buffer *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D11Buffer_iface);
  29 }
  30
  31 static HRESULT STDMETHODCALLTYPE d3d11_buffer_QueryInterface(ID3D11Buffer *iface, REFIID riid, void **out)
  32 {
  33     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
  34
  35     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  36
  37     if (IsEqualGUID(riid, &IID_ID3D11Buffer)
  38             || IsEqualGUID(riid, &IID_ID3D11Resource)
  39             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
  40             || IsEqualGUID(riid, &IID_IUnknown))
  41     {
  42         ID3D11Buffer_AddRef(iface);
  43         *out = iface;
  44         return S_OK;
  45     }
  46
  47     if (IsEqualGUID(riid, &IID_ID3D10Buffer)
  48             || IsEqualGUID(riid, &IID_ID3D10Resource)
  49             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
  50     {
  51         ID3D10Buffer_AddRef(&buffer->ID3D10Buffer_iface);
  52         *out = &buffer->ID3D10Buffer_iface;
  53         return S_OK;
  54     }
  55
  56     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  57
  58     *out = NULL;
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG STDMETHODCALLTYPE d3d11_buffer_AddRef(ID3D11Buffer *iface)
  63 {
  64     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
  65     ULONG refcount = InterlockedIncrement(&buffer->refcount);
  66
  67     TRACE("%p increasing refcount to %lu.\n", buffer, refcount);
  68
  69     if (refcount == 1)
  70     {
  71         ID3D11Device2_AddRef(buffer->device);
  72         wined3d_buffer_incref(buffer->wined3d_buffer);
  73     }
  74
  75     return refcount;
  76 }
  77
  78 static ULONG STDMETHODCALLTYPE d3d11_buffer_Release(ID3D11Buffer *iface)
  79 {
  80     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
  81     ULONG refcount = InterlockedDecrement(&buffer->refcount);
  82
  83     TRACE("%p decreasing refcount to %lu.\n", buffer, refcount);
  84
  85     if (!refcount)
  86     {
  87         ID3D11Device2 *device = buffer->device;
  88
  89         wined3d_buffer_decref(buffer->wined3d_buffer);
  90         /* Release the device last, it may cause the wined3d device to be
  91          * destroyed. */
  92         ID3D11Device2_Release(device);
  93     }
  94
  95     return refcount;
  96 }
  97
  98 static void STDMETHODCALLTYPE d3d11_buffer_GetDevice(ID3D11Buffer *iface, ID3D11Device **device)
  99 {
 100     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
 101
 102     TRACE("iface %p, device %p.\n", iface, device);
 103
 104     *device = (ID3D11Device *)buffer->device;
 105     ID3D11Device_AddRef(*device);
 106 }
 107
 108 static HRESULT STDMETHODCALLTYPE d3d11_buffer_GetPrivateData(ID3D11Buffer *iface,
 109         REFGUID guid, UINT *data_size, void *data)
 110 {
 111     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
 112
 113     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 114
 115     return d3d_get_private_data(&buffer->private_store, guid, data_size, data);
 116 }
 117
 118 static HRESULT STDMETHODCALLTYPE d3d11_buffer_SetPrivateData(ID3D11Buffer *iface,
 119         REFGUID guid, UINT data_size, const void *data)
 120 {
 121     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
 122
 123     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 124
 125     return d3d_set_private_data(&buffer->private_store, guid, data_size, data);
 126 }
 127
 128 static HRESULT STDMETHODCALLTYPE d3d11_buffer_SetPrivateDataInterface(ID3D11Buffer *iface,
 129         REFGUID guid, const IUnknown *data)
 130 {
 131     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
 132
 133     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 134
 135     return d3d_set_private_data_interface(&buffer->private_store, guid, data);
 136 }
 137
 138 static void STDMETHODCALLTYPE d3d11_buffer_GetType(ID3D11Buffer *iface,
 139         D3D11_RESOURCE_DIMENSION *resource_dimension)
 140 {
 141     TRACE("iface %p, resource_dimension %p.\n", iface, resource_dimension);
 142
 143     *resource_dimension = D3D11_RESOURCE_DIMENSION_BUFFER;
 144 }
 145
 146 static void STDMETHODCALLTYPE d3d11_buffer_SetEvictionPriority(ID3D11Buffer *iface, UINT eviction_priority)
 147 {
 148     FIXME("iface %p, eviction_priority %#x stub!\n", iface, eviction_priority);
 149 }
 150
 151 static UINT STDMETHODCALLTYPE d3d11_buffer_GetEvictionPriority(ID3D11Buffer *iface)
 152 {
 153     FIXME("iface %p stub!\n", iface);
 154
 155     return 0;
 156 }
 157
 158 static void STDMETHODCALLTYPE d3d11_buffer_GetDesc(ID3D11Buffer *iface, D3D11_BUFFER_DESC *desc)
 159 {
 160     struct d3d_buffer *buffer = impl_from_ID3D11Buffer(iface);
 161
 162     TRACE("iface %p, desc %p.\n", iface, desc);
 163
 164     *desc = buffer->desc;
 165 }
 166
 167 static const struct ID3D11BufferVtbl d3d11_buffer_vtbl =
 168 {
 169     /* IUnknown methods */
 170     d3d11_buffer_QueryInterface,
 171     d3d11_buffer_AddRef,
 172     d3d11_buffer_Release,
 173     /* ID3D11DeviceChild methods */
 174     d3d11_buffer_GetDevice,
 175     d3d11_buffer_GetPrivateData,
 176     d3d11_buffer_SetPrivateData,
 177     d3d11_buffer_SetPrivateDataInterface,
 178     /* ID3D11Resource methods */
 179     d3d11_buffer_GetType,
 180     d3d11_buffer_SetEvictionPriority,
 181     d3d11_buffer_GetEvictionPriority,
 182     /* ID3D11Buffer methods */
 183     d3d11_buffer_GetDesc,
 184 };
 185
 186 struct d3d_buffer *unsafe_impl_from_ID3D11Buffer(ID3D11Buffer *iface)
 187 {
 188     if (!iface)
 189         return NULL;
 190     assert(iface->lpVtbl == &d3d11_buffer_vtbl);
 191     return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D11Buffer_iface);
 192 }
 193
 194 /* ID3D10Buffer methods */
 195
 196 static inline struct d3d_buffer *impl_from_ID3D10Buffer(ID3D10Buffer *iface)
 197 {
 198     return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D10Buffer_iface);
 199 }
 200
 201 /* IUnknown methods */
 202
 203 static HRESULT STDMETHODCALLTYPE d3d10_buffer_QueryInterface(ID3D10Buffer *iface, REFIID riid, void **out)
 204 {
 205     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 206
 207     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 208
 209     return d3d11_buffer_QueryInterface(&buffer->ID3D11Buffer_iface, riid, out);
 210 }
 211
 212 static ULONG STDMETHODCALLTYPE d3d10_buffer_AddRef(ID3D10Buffer *iface)
 213 {
 214     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 215
 216     TRACE("iface %p.\n", iface);
 217
 218     return d3d11_buffer_AddRef(&buffer->ID3D11Buffer_iface);
 219 }
 220
 221 static ULONG STDMETHODCALLTYPE d3d10_buffer_Release(ID3D10Buffer *iface)
 222 {
 223     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 224
 225     TRACE("iface %p.\n", iface);
 226
 227     return d3d11_buffer_Release(&buffer->ID3D11Buffer_iface);
 228 }
 229
 230 /* ID3D10DeviceChild methods */
 231
 232 static void STDMETHODCALLTYPE d3d10_buffer_GetDevice(ID3D10Buffer *iface, ID3D10Device **device)
 233 {
 234     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 235
 236     TRACE("iface %p, device %p.\n", iface, device);
 237
 238     ID3D11Device2_QueryInterface(buffer->device, &IID_ID3D10Device, (void **)device);
 239 }
 240
 241 static HRESULT STDMETHODCALLTYPE d3d10_buffer_GetPrivateData(ID3D10Buffer *iface,
 242         REFGUID guid, UINT *data_size, void *data)
 243 {
 244     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 245
 246     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 247             iface, debugstr_guid(guid), data_size, data);
 248
 249     return d3d_get_private_data(&buffer->private_store, guid, data_size, data);
 250 }
 251
 252 static HRESULT STDMETHODCALLTYPE d3d10_buffer_SetPrivateData(ID3D10Buffer *iface,
 253         REFGUID guid, UINT data_size, const void *data)
 254 {
 255     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 256
 257     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 258             iface, debugstr_guid(guid), data_size, data);
 259
 260     return d3d_set_private_data(&buffer->private_store, guid, data_size, data);
 261 }
 262
 263 static HRESULT STDMETHODCALLTYPE d3d10_buffer_SetPrivateDataInterface(ID3D10Buffer *iface,
 264         REFGUID guid, const IUnknown *data)
 265 {
 266     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 267
 268     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 269
 270     return d3d_set_private_data_interface(&buffer->private_store, guid, data);
 271 }
 272
 273 /* ID3D10Resource methods */
 274
 275 static void STDMETHODCALLTYPE d3d10_buffer_GetType(ID3D10Buffer *iface, D3D10_RESOURCE_DIMENSION *resource_dimension)
 276 {
 277     TRACE("iface %p, resource_dimension %p\n", iface, resource_dimension);
 278
 279     *resource_dimension = D3D10_RESOURCE_DIMENSION_BUFFER;
 280 }
 281
 282 static void STDMETHODCALLTYPE d3d10_buffer_SetEvictionPriority(ID3D10Buffer *iface, UINT eviction_priority)
 283 {
 284     FIXME("iface %p, eviction_priority %u stub!\n", iface, eviction_priority);
 285 }
 286
 287 static UINT STDMETHODCALLTYPE d3d10_buffer_GetEvictionPriority(ID3D10Buffer *iface)
 288 {
 289     FIXME("iface %p stub!\n", iface);
 290
 291     return 0;
 292 }
 293
 294 /* ID3D10Buffer methods */
 295
 296 static HRESULT STDMETHODCALLTYPE d3d10_buffer_Map(ID3D10Buffer *iface, D3D10_MAP map_type, UINT map_flags, void **data)
 297 {
 298     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 299     struct wined3d_map_desc wined3d_map_desc;
 300     HRESULT hr;
 301
 302     TRACE("iface %p, map_type %u, map_flags %#x, data %p.\n", iface, map_type, map_flags, data);
 303
 304     if (map_flags)
 305         FIXME("Ignoring map_flags %#x.\n", map_flags);
 306
 307     hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0,
 308             &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type));
 309     *data = wined3d_map_desc.data;
 310
 311     return hr;
 312 }
 313
 314 static void STDMETHODCALLTYPE d3d10_buffer_Unmap(ID3D10Buffer *iface)
 315 {
 316     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 317
 318     TRACE("iface %p.\n", iface);
 319
 320     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 321 }
 322
 323 static void STDMETHODCALLTYPE d3d10_buffer_GetDesc(ID3D10Buffer *iface, D3D10_BUFFER_DESC *desc)
 324 {
 325     struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface);
 326     const D3D11_BUFFER_DESC *d3d11_desc = &buffer->desc;
 327
 328     TRACE("iface %p, desc %p.\n", iface, desc);
 329
 330     desc->ByteWidth = d3d11_desc->ByteWidth;
 331     desc->Usage = d3d10_usage_from_d3d11_usage(d3d11_desc->Usage);
 332     desc->BindFlags = d3d10_bind_flags_from_d3d11_bind_flags(d3d11_desc->BindFlags);
 333     desc->CPUAccessFlags = d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(d3d11_desc->CPUAccessFlags);
 334     desc->MiscFlags = d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(d3d11_desc->MiscFlags);
 335 }
 336
 337 static const struct ID3D10BufferVtbl d3d10_buffer_vtbl =
 338 {
 339     /* IUnknown methods */
 340     d3d10_buffer_QueryInterface,
 341     d3d10_buffer_AddRef,
 342     d3d10_buffer_Release,
 343     /* ID3D10DeviceChild methods */
 344     d3d10_buffer_GetDevice,
 345     d3d10_buffer_GetPrivateData,
 346     d3d10_buffer_SetPrivateData,
 347     d3d10_buffer_SetPrivateDataInterface,
 348     /* ID3D10Resource methods */
 349     d3d10_buffer_GetType,
 350     d3d10_buffer_SetEvictionPriority,
 351     d3d10_buffer_GetEvictionPriority,
 352     /* ID3D10Buffer methods */
 353     d3d10_buffer_Map,
 354     d3d10_buffer_Unmap,
 355     d3d10_buffer_GetDesc,
 356 };
 357
 358 struct d3d_buffer *unsafe_impl_from_ID3D10Buffer(ID3D10Buffer *iface)
 359 {
 360     if (!iface)
 361         return NULL;
 362     assert(iface->lpVtbl == &d3d10_buffer_vtbl);
 363     return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D10Buffer_iface);
 364 }
 365
 366 static void STDMETHODCALLTYPE d3d_buffer_wined3d_object_released(void *parent)
 367 {
 368     struct d3d_buffer *buffer = parent;
 369
 370     wined3d_private_store_cleanup(&buffer->private_store);
 371     heap_free(parent);
 372 }
 373
 374 static const struct wined3d_parent_ops d3d_buffer_wined3d_parent_ops =
 375 {
 376     d3d_buffer_wined3d_object_released,
 377 };
 378
 379 static BOOL validate_buffer_desc(D3D11_BUFFER_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 380 {
 381     if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_BUFFER,
 382             desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
 383         return FALSE;
 384
 385     if (desc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS)
 386     {
 387         if (desc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 388         {
 389             WARN("Raw and structure buffers are mutually exclusive.\n");
 390             return FALSE;
 391         }
 392         if (!(desc->BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS)))
 393         {
 394             WARN("Invalid bind flags %#x for raw buffer.\n", desc->BindFlags);
 395             return FALSE;
 396         }
 397     }
 398
 399     if (desc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 400     {
 401         if (!desc->StructureByteStride || desc->StructureByteStride % 4)
 402         {
 403             WARN("Invalid structure byte stride %u.\n", desc->StructureByteStride);
 404             return FALSE;
 405         }
 406         if (desc->ByteWidth % desc->StructureByteStride)
 407         {
 408             WARN("Byte width %u is not divisible by structure byte stride %u.\n",
 409                     desc->ByteWidth, desc->StructureByteStride);
 410             return FALSE;
 411         }
 412     }
 413     else
 414     {
 415         desc->StructureByteStride = 0;
 416     }
 417
 418     if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
 419     {
 420         WARN("Buffer with the D3D11_RESOURCE_MISC_GENERATE_MIPS flag.\n");
 421         return FALSE;
 422     }
 423
 424     return TRUE;
 425 }
 426
 427 static HRESULT d3d_buffer_init(struct d3d_buffer *buffer, struct d3d_device *device,
 428         const D3D11_BUFFER_DESC *desc, const D3D11_SUBRESOURCE_DATA *data)
 429 {
 430     struct wined3d_buffer_desc wined3d_desc;
 431     HRESULT hr;
 432
 433     buffer->ID3D11Buffer_iface.lpVtbl = &d3d11_buffer_vtbl;
 434     buffer->ID3D10Buffer_iface.lpVtbl = &d3d10_buffer_vtbl;
 435     buffer->refcount = 1;
 436     buffer->desc = *desc;
 437
 438     if (!validate_buffer_desc(&buffer->desc, device->state->feature_level))
 439         return E_INVALIDARG;
 440
 441     wined3d_desc.byte_width = buffer->desc.ByteWidth;
 442     wined3d_desc.usage = wined3d_usage_from_d3d11(buffer->desc.Usage);
 443     wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(buffer->desc.BindFlags, buffer->desc.MiscFlags);
 444     wined3d_desc.access = wined3d_access_from_d3d11(buffer->desc.Usage, buffer->desc.CPUAccessFlags);
 445     wined3d_desc.misc_flags = buffer->desc.MiscFlags;
 446     wined3d_desc.structure_byte_stride = buffer->desc.StructureByteStride;
 447
 448     wined3d_mutex_lock();
 449     wined3d_private_store_init(&buffer->private_store);
 450
 451     if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &wined3d_desc,
 452             (const struct wined3d_sub_resource_data *)data, buffer,
 453             &d3d_buffer_wined3d_parent_ops, &buffer->wined3d_buffer)))
 454     {
 455         WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
 456         wined3d_private_store_cleanup(&buffer->private_store);
 457         wined3d_mutex_unlock();
 458         return hr;
 459     }
 460     wined3d_mutex_unlock();
 461
 462     ID3D11Device2_AddRef(buffer->device = &device->ID3D11Device2_iface);
 463
 464     return S_OK;
 465 }
 466
 467 HRESULT d3d_buffer_create(struct d3d_device *device, const D3D11_BUFFER_DESC *desc,
 468         const D3D11_SUBRESOURCE_DATA *data, struct d3d_buffer **buffer)
 469 {
 470     struct d3d_buffer *object;
 471     HRESULT hr;
 472
 473     if (!(object = heap_alloc_zero(sizeof(*object))))
 474         return E_OUTOFMEMORY;
 475
 476     if (FAILED(hr = d3d_buffer_init(object, device, desc, data)))
 477     {
 478         WARN("Failed to initialise buffer, hr %#lx.\n", hr);
 479         heap_free(object);
 480         return hr;
 481     }
 482
 483     TRACE("Created buffer %p.\n", object);
 484     *buffer = object;
 485
 486     return S_OK;
 487 }