dlls/d3d11/inputlayout.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 #include "winternl.h"
  22 #include <vkd3d_shader.h>
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  25
  26 static BOOL is_vs_sysval_semantic(const struct vkd3d_shader_signature_element *e)
  27 {
  28     return !stricmp(e->semantic_name, "sv_instanceid") || !stricmp(e->semantic_name, "sv_vertexid");
  29 }
  30
  31 static unsigned int find_input_element(const D3D11_INPUT_ELEMENT_DESC *element_descs, unsigned int element_count,
  32         const struct vkd3d_shader_signature_element *ise)
  33 {
  34     const D3D11_INPUT_ELEMENT_DESC *f;
  35     unsigned int i;
  36
  37     if (ise->stream_index)
  38         return element_count;
  39
  40     for (i = 0; i < element_count; ++i)
  41     {
  42         f = &element_descs[i];
  43         if (!stricmp(ise->semantic_name, f->SemanticName) && ise->semantic_index == f->SemanticIndex)
  44             return i;
  45     }
  46     return element_count;
  47 }
  48
  49 static enum wined3d_input_classification wined3d_input_classification_from_d3d11(D3D11_INPUT_CLASSIFICATION slot_class)
  50 {
  51     return (enum wined3d_input_classification)slot_class;
  52 }
  53
  54 static HRESULT d3d11_input_layout_to_wined3d_declaration(const D3D11_INPUT_ELEMENT_DESC *element_descs,
  55         UINT element_count, const void *shader_byte_code, SIZE_T shader_byte_code_length,
  56         struct wined3d_vertex_element **wined3d_elements)
  57 {
  58     const struct vkd3d_shader_code dxbc = {shader_byte_code, shader_byte_code_length};
  59     struct vkd3d_shader_signature_element *ise;
  60     const D3D11_INPUT_ELEMENT_DESC *f;
  61     struct vkd3d_shader_signature is;
  62     unsigned int i, index;
  63     int ret;
  64
  65     if ((ret = vkd3d_shader_parse_input_signature(&dxbc, &is, NULL)) < 0)
  66     {
  67         ERR("Failed to extract input signature, ret %d.\n", ret);
  68         return E_FAIL;
  69     }
  70
  71     if (!(*wined3d_elements = calloc(element_count, sizeof(**wined3d_elements))))
  72     {
  73         ERR("Failed to allocate wined3d vertex element array memory.\n");
  74         vkd3d_shader_free_shader_signature(&is);
  75         return E_OUTOFMEMORY;
  76     }
  77
  78     for (i = 0; i < element_count; ++i)
  79     {
  80         struct wined3d_vertex_element *e = &(*wined3d_elements)[i];
  81
  82         f = &element_descs[i];
  83
  84         e->format = wined3dformat_from_dxgi_format(f->Format);
  85         e->input_slot = f->InputSlot;
  86         e->offset = f->AlignedByteOffset;
  87         e->output_slot = WINED3D_OUTPUT_SLOT_UNUSED;
  88         e->input_slot_class = wined3d_input_classification_from_d3d11(f->InputSlotClass);
  89         e->instance_data_step_rate = f->InstanceDataStepRate;
  90         e->method = WINED3D_DECL_METHOD_DEFAULT;
  91         e->usage = 0;
  92         e->usage_idx = 0;
  93     }
  94
  95     ise = is.elements;
  96
  97     for (i = 0; i < is.element_count; ++i)
  98     {
  99         if ((index = find_input_element(element_descs, element_count, &ise[i])) < element_count)
 100         {
 101             (*wined3d_elements)[index].output_slot = ise[i].register_index;
 102         }
 103         else if (!is_vs_sysval_semantic(&ise[i]))
 104         {
 105             WARN("Input element %s%u not found in shader signature.\n", ise[i].semantic_name, ise[i].semantic_index);
 106             free(*wined3d_elements);
 107             vkd3d_shader_free_shader_signature(&is);
 108             return E_INVALIDARG;
 109         }
 110     }
 111
 112     vkd3d_shader_free_shader_signature(&is);
 113
 114     return S_OK;
 115 }
 116
 117 /* ID3D11InputLayout methods */
 118
 119 static inline struct d3d_input_layout *impl_from_ID3D11InputLayout(ID3D11InputLayout *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct d3d_input_layout, ID3D11InputLayout_iface);
 122 }
 123
 124 static HRESULT STDMETHODCALLTYPE d3d11_input_layout_QueryInterface(ID3D11InputLayout *iface,
 125         REFIID riid, void **object)
 126 {
 127     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 128
 129     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 130
 131     if (IsEqualGUID(riid, &IID_ID3D11InputLayout)
 132             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 133             || IsEqualGUID(riid, &IID_IUnknown))
 134     {
 135         ID3D11InputLayout_AddRef(iface);
 136         *object = iface;
 137         return S_OK;
 138     }
 139
 140     if (IsEqualGUID(riid, &IID_ID3D10InputLayout)
 141             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 142     {
 143         ID3D10InputLayout_AddRef(&layout->ID3D10InputLayout_iface);
 144         *object = &layout->ID3D10InputLayout_iface;
 145         return S_OK;
 146     }
 147
 148     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 149
 150     *object = NULL;
 151     return E_NOINTERFACE;
 152 }
 153
 154 static ULONG STDMETHODCALLTYPE d3d11_input_layout_AddRef(ID3D11InputLayout *iface)
 155 {
 156     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 157     ULONG refcount = InterlockedIncrement(&layout->refcount);
 158
 159     TRACE("%p increasing refcount to %lu.\n", layout, refcount);
 160
 161     if (refcount == 1)
 162     {
 163         ID3D11Device2_AddRef(layout->device);
 164         wined3d_vertex_declaration_incref(layout->wined3d_decl);
 165     }
 166
 167     return refcount;
 168 }
 169
 170 static ULONG STDMETHODCALLTYPE d3d11_input_layout_Release(ID3D11InputLayout *iface)
 171 {
 172     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 173     ULONG refcount = InterlockedDecrement(&layout->refcount);
 174
 175     TRACE("%p decreasing refcount to %lu.\n", layout, refcount);
 176
 177     if (!refcount)
 178     {
 179         ID3D11Device2 *device = layout->device;
 180         wined3d_vertex_declaration_decref(layout->wined3d_decl);
 181         ID3D11Device2_Release(device);
 182     }
 183
 184     return refcount;
 185 }
 186
 187 static void STDMETHODCALLTYPE d3d11_input_layout_GetDevice(ID3D11InputLayout *iface,
 188         ID3D11Device **device)
 189 {
 190     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 191
 192     TRACE("iface %p, device %p.\n", iface, device);
 193
 194     ID3D11Device_AddRef(*device = (ID3D11Device *)layout->device);
 195 }
 196
 197 static HRESULT STDMETHODCALLTYPE d3d11_input_layout_GetPrivateData(ID3D11InputLayout *iface,
 198         REFGUID guid, UINT *data_size, void *data)
 199 {
 200     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 201
 202     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 203
 204     return d3d_get_private_data(&layout->private_store, guid, data_size, data);
 205 }
 206
 207 static HRESULT STDMETHODCALLTYPE d3d11_input_layout_SetPrivateData(ID3D11InputLayout *iface,
 208         REFGUID guid, UINT data_size, const void *data)
 209 {
 210     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 211
 212     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 213
 214     return d3d_set_private_data(&layout->private_store, guid, data_size, data);
 215 }
 216
 217 static HRESULT STDMETHODCALLTYPE d3d11_input_layout_SetPrivateDataInterface(ID3D11InputLayout *iface,
 218         REFGUID guid, const IUnknown *data)
 219 {
 220     struct d3d_input_layout *layout = impl_from_ID3D11InputLayout(iface);
 221
 222     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 223
 224     return d3d_set_private_data_interface(&layout->private_store, guid, data);
 225 }
 226
 227 static const struct ID3D11InputLayoutVtbl d3d11_input_layout_vtbl =
 228 {
 229     /* IUnknown methods */
 230     d3d11_input_layout_QueryInterface,
 231     d3d11_input_layout_AddRef,
 232     d3d11_input_layout_Release,
 233     /* ID3D11DeviceChild methods */
 234     d3d11_input_layout_GetDevice,
 235     d3d11_input_layout_GetPrivateData,
 236     d3d11_input_layout_SetPrivateData,
 237     d3d11_input_layout_SetPrivateDataInterface,
 238 };
 239
 240 /* ID3D10InputLayout methods */
 241
 242 static inline struct d3d_input_layout *impl_from_ID3D10InputLayout(ID3D10InputLayout *iface)
 243 {
 244     return CONTAINING_RECORD(iface, struct d3d_input_layout, ID3D10InputLayout_iface);
 245 }
 246
 247 /* IUnknown methods */
 248
 249 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_QueryInterface(ID3D10InputLayout *iface,
 250         REFIID riid, void **object)
 251 {
 252     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 253
 254     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 255
 256     return d3d11_input_layout_QueryInterface(&layout->ID3D11InputLayout_iface, riid, object);
 257 }
 258
 259 static ULONG STDMETHODCALLTYPE d3d10_input_layout_AddRef(ID3D10InputLayout *iface)
 260 {
 261     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 262
 263     TRACE("iface %p.\n", iface);
 264
 265     return d3d11_input_layout_AddRef(&layout->ID3D11InputLayout_iface);
 266 }
 267
 268 static ULONG STDMETHODCALLTYPE d3d10_input_layout_Release(ID3D10InputLayout *iface)
 269 {
 270     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 271
 272     TRACE("iface %p.\n", iface);
 273
 274     return d3d11_input_layout_Release(&layout->ID3D11InputLayout_iface);
 275 }
 276
 277 /* ID3D10DeviceChild methods */
 278
 279 static void STDMETHODCALLTYPE d3d10_input_layout_GetDevice(ID3D10InputLayout *iface, ID3D10Device **device)
 280 {
 281     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 282
 283     TRACE("iface %p, device %p.\n", iface, device);
 284
 285     ID3D11Device2_QueryInterface(layout->device, &IID_ID3D10Device, (void **)device);
 286 }
 287
 288 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_GetPrivateData(ID3D10InputLayout *iface,
 289         REFGUID guid, UINT *data_size, void *data)
 290 {
 291     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 292
 293     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 294             iface, debugstr_guid(guid), data_size, data);
 295
 296     return d3d_get_private_data(&layout->private_store, guid, data_size, data);
 297 }
 298
 299 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_SetPrivateData(ID3D10InputLayout *iface,
 300         REFGUID guid, UINT data_size, const void *data)
 301 {
 302     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 303
 304     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 305             iface, debugstr_guid(guid), data_size, data);
 306
 307     return d3d_set_private_data(&layout->private_store, guid, data_size, data);
 308 }
 309
 310 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_SetPrivateDataInterface(ID3D10InputLayout *iface,
 311         REFGUID guid, const IUnknown *data)
 312 {
 313     struct d3d_input_layout *layout = impl_from_ID3D10InputLayout(iface);
 314
 315     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 316
 317     return d3d_set_private_data_interface(&layout->private_store, guid, data);
 318 }
 319
 320 static const struct ID3D10InputLayoutVtbl d3d10_input_layout_vtbl =
 321 {
 322     /* IUnknown methods */
 323     d3d10_input_layout_QueryInterface,
 324     d3d10_input_layout_AddRef,
 325     d3d10_input_layout_Release,
 326     /* ID3D10DeviceChild methods */
 327     d3d10_input_layout_GetDevice,
 328     d3d10_input_layout_GetPrivateData,
 329     d3d10_input_layout_SetPrivateData,
 330     d3d10_input_layout_SetPrivateDataInterface,
 331 };
 332
 333 static void STDMETHODCALLTYPE d3d_input_layout_wined3d_object_destroyed(void *parent)
 334 {
 335     struct d3d_input_layout *layout = parent;
 336
 337     wined3d_private_store_cleanup(&layout->private_store);
 338     free(parent);
 339 }
 340
 341 static const struct wined3d_parent_ops d3d_input_layout_wined3d_parent_ops =
 342 {
 343     d3d_input_layout_wined3d_object_destroyed,
 344 };
 345
 346 static HRESULT d3d_input_layout_init(struct d3d_input_layout *layout, struct d3d_device *device,
 347         const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
 348         const void *shader_byte_code, SIZE_T shader_byte_code_length)
 349 {
 350     struct wined3d_vertex_element *wined3d_elements;
 351     HRESULT hr;
 352
 353     layout->ID3D11InputLayout_iface.lpVtbl = &d3d11_input_layout_vtbl;
 354     layout->ID3D10InputLayout_iface.lpVtbl = &d3d10_input_layout_vtbl;
 355     layout->refcount = 1;
 356     wined3d_mutex_lock();
 357     wined3d_private_store_init(&layout->private_store);
 358
 359     if (FAILED(hr = d3d11_input_layout_to_wined3d_declaration(element_descs, element_count,
 360             shader_byte_code, shader_byte_code_length, &wined3d_elements)))
 361     {
 362         WARN("Failed to create wined3d vertex declaration elements, hr %#lx.\n", hr);
 363         wined3d_private_store_cleanup(&layout->private_store);
 364         wined3d_mutex_unlock();
 365         return hr;
 366     }
 367
 368     hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, element_count,
 369             layout, &d3d_input_layout_wined3d_parent_ops, &layout->wined3d_decl);
 370     free(wined3d_elements);
 371     if (FAILED(hr))
 372     {
 373         WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
 374         wined3d_private_store_cleanup(&layout->private_store);
 375         wined3d_mutex_unlock();
 376         return hr;
 377     }
 378     wined3d_mutex_unlock();
 379
 380     ID3D11Device2_AddRef(layout->device = &device->ID3D11Device2_iface);
 381
 382     return S_OK;
 383 }
 384
 385 HRESULT d3d_input_layout_create(struct d3d_device *device,
 386         const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
 387         const void *shader_byte_code, SIZE_T shader_byte_code_length,
 388         struct d3d_input_layout **layout)
 389 {
 390     struct d3d_input_layout *object;
 391     HRESULT hr;
 392
 393     if (!element_descs) return E_INVALIDARG;
 394
 395     if (!(object = calloc(1, sizeof(*object))))
 396         return E_OUTOFMEMORY;
 397
 398     if (FAILED(hr = d3d_input_layout_init(object, device, element_descs, element_count,
 399             shader_byte_code, shader_byte_code_length)))
 400     {
 401         WARN("Failed to initialise input layout, hr %#lx.\n", hr);
 402         free(object);
 403         return hr;
 404     }
 405
 406     TRACE("Created input layout %p.\n", object);
 407     *layout = object;
 408
 409     return S_OK;
 410 }
 411
 412 struct d3d_input_layout *unsafe_impl_from_ID3D11InputLayout(ID3D11InputLayout *iface)
 413 {
 414     if (!iface)
 415         return NULL;
 416     assert(iface->lpVtbl == &d3d11_input_layout_vtbl);
 417
 418     return impl_from_ID3D11InputLayout(iface);
 419 }
 420
 421 struct d3d_input_layout *unsafe_impl_from_ID3D10InputLayout(ID3D10InputLayout *iface)
 422 {
 423     if (!iface)
 424         return NULL;
 425     assert(iface->lpVtbl == &d3d10_input_layout_vtbl);
 426
 427     return impl_from_ID3D10InputLayout(iface);
 428 }