dlls/d3d11/shader.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 "config.h"
  21 #include "wine/port.h"
  22
  23 #include "d3d11_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  26
  27 static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
  28 {
  29     struct wined3d_shader_desc *desc = ctx;
  30     HRESULT hr;
  31
  32     switch (tag)
  33     {
  34         case TAG_ISGN:
  35             if (FAILED(hr = shader_parse_signature(data, data_size, &desc->input_signature)))
  36                 return hr;
  37             break;
  38
  39         case TAG_OSGN:
  40             if (FAILED(hr = shader_parse_signature(data, data_size, &desc->output_signature)))
  41                 return hr;
  42             break;
  43
  44         case TAG_SHDR:
  45         case TAG_SHEX:
  46             if (desc->byte_code)
  47                 FIXME("Multiple SHDR/SHEX chunks.\n");
  48             desc->byte_code = (const DWORD *)data;
  49             break;
  50
  51         default:
  52             FIXME("Unhandled chunk %s\n", debugstr_an((const char *)&tag, 4));
  53             break;
  54     }
  55
  56     return S_OK;
  57 }
  58
  59 static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length, struct wined3d_shader_desc *desc)
  60 {
  61     HRESULT hr;
  62
  63     desc->byte_code = NULL;
  64     memset(&desc->input_signature, 0, sizeof(desc->input_signature));
  65     memset(&desc->output_signature, 0, sizeof(desc->output_signature));
  66
  67     hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, desc);
  68     if (!desc->byte_code)
  69         hr = E_INVALIDARG;
  70
  71     if (FAILED(hr))
  72     {
  73         FIXME("Failed to parse shader, hr %#x.\n", hr);
  74         shader_free_signature(&desc->input_signature);
  75         shader_free_signature(&desc->output_signature);
  76     }
  77
  78     return hr;
  79 }
  80
  81 HRESULT shader_parse_signature(const char *data, DWORD data_size, struct wined3d_shader_signature *s)
  82 {
  83     struct wined3d_shader_signature_element *e;
  84     const char *ptr = data;
  85     unsigned int i;
  86     DWORD count;
  87
  88     read_dword(&ptr, &count);
  89     TRACE("%u elements\n", count);
  90
  91     skip_dword_unknown(&ptr, 1);
  92
  93     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
  94     if (!e)
  95     {
  96         ERR("Failed to allocate input signature memory.\n");
  97         return E_OUTOFMEMORY;
  98     }
  99
 100     for (i = 0; i < count; ++i)
 101     {
 102         UINT name_offset;
 103
 104         read_dword(&ptr, &name_offset);
 105         e[i].semantic_name = data + name_offset;
 106         read_dword(&ptr, &e[i].semantic_idx);
 107         read_dword(&ptr, &e[i].sysval_semantic);
 108         read_dword(&ptr, &e[i].component_type);
 109         read_dword(&ptr, &e[i].register_idx);
 110         read_dword(&ptr, &e[i].mask);
 111
 112         TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 113                 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
 114                 debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic,
 115                 e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
 116     }
 117
 118     s->elements = e;
 119     s->element_count = count;
 120
 121     return S_OK;
 122 }
 123
 124 void shader_free_signature(struct wined3d_shader_signature *s)
 125 {
 126     HeapFree(GetProcessHeap(), 0, s->elements);
 127 }
 128
 129 /* ID3D11VertexShader methods */
 130
 131 static inline struct d3d_vertex_shader *impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 132 {
 133     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D11VertexShader_iface);
 134 }
 135
 136 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_QueryInterface(ID3D11VertexShader *iface,
 137         REFIID riid, void **object)
 138 {
 139     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 140
 141     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 142
 143     if (IsEqualGUID(riid, &IID_ID3D11VertexShader)
 144             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 145             || IsEqualGUID(riid, &IID_IUnknown))
 146     {
 147         ID3D11VertexShader_AddRef(iface);
 148         *object = iface;
 149         return S_OK;
 150     }
 151
 152     if (IsEqualGUID(riid, &IID_ID3D10VertexShader)
 153             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 154     {
 155         IUnknown_AddRef(&shader->ID3D10VertexShader_iface);
 156         *object = &shader->ID3D10VertexShader_iface;
 157         return S_OK;
 158     }
 159
 160     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 161
 162     *object = NULL;
 163     return E_NOINTERFACE;
 164 }
 165
 166 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_AddRef(ID3D11VertexShader *iface)
 167 {
 168     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 169     ULONG refcount = InterlockedIncrement(&shader->refcount);
 170
 171     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 172
 173     if (refcount == 1)
 174     {
 175         ID3D11Device_AddRef(shader->device);
 176         wined3d_mutex_lock();
 177         wined3d_shader_incref(shader->wined3d_shader);
 178         wined3d_mutex_unlock();
 179     }
 180
 181     return refcount;
 182 }
 183
 184 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_Release(ID3D11VertexShader *iface)
 185 {
 186     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 187     ULONG refcount = InterlockedDecrement(&shader->refcount);
 188
 189     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 190
 191     if (!refcount)
 192     {
 193         ID3D11Device *device = shader->device;
 194
 195         wined3d_mutex_lock();
 196         wined3d_shader_decref(shader->wined3d_shader);
 197         wined3d_mutex_unlock();
 198         /* Release the device last, it may cause the wined3d device to be
 199          * destroyed. */
 200         ID3D11Device_Release(device);
 201     }
 202
 203     return refcount;
 204 }
 205
 206 static void STDMETHODCALLTYPE d3d11_vertex_shader_GetDevice(ID3D11VertexShader *iface,
 207         ID3D11Device **device)
 208 {
 209     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 210
 211     TRACE("iface %p, device %p.\n", iface, device);
 212
 213     *device = shader->device;
 214     ID3D11Device_AddRef(*device);
 215 }
 216
 217 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_GetPrivateData(ID3D11VertexShader *iface,
 218         REFGUID guid, UINT *data_size, void *data)
 219 {
 220     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 221
 222     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 223
 224     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 225 }
 226
 227 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateData(ID3D11VertexShader *iface,
 228         REFGUID guid, UINT data_size, const void *data)
 229 {
 230     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 231
 232     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 233
 234     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 235 }
 236
 237 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateDataInterface(ID3D11VertexShader *iface,
 238         REFGUID guid, const IUnknown *data)
 239 {
 240     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 241
 242     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 243
 244     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 245 }
 246
 247 static const struct ID3D11VertexShaderVtbl d3d11_vertex_shader_vtbl =
 248 {
 249     /* IUnknown methods */
 250     d3d11_vertex_shader_QueryInterface,
 251     d3d11_vertex_shader_AddRef,
 252     d3d11_vertex_shader_Release,
 253     /* ID3D11DeviceChild methods */
 254     d3d11_vertex_shader_GetDevice,
 255     d3d11_vertex_shader_GetPrivateData,
 256     d3d11_vertex_shader_SetPrivateData,
 257     d3d11_vertex_shader_SetPrivateDataInterface,
 258 };
 259
 260 /* ID3D10VertexShader methods */
 261
 262 static inline struct d3d_vertex_shader *impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 263 {
 264     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D10VertexShader_iface);
 265 }
 266
 267 /* IUnknown methods */
 268
 269 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_QueryInterface(ID3D10VertexShader *iface,
 270         REFIID riid, void **object)
 271 {
 272     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 273
 274     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 275
 276     return d3d11_vertex_shader_QueryInterface(&shader->ID3D11VertexShader_iface, riid, object);
 277 }
 278
 279 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *iface)
 280 {
 281     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 282
 283     TRACE("iface %p.\n", iface);
 284
 285     return d3d11_vertex_shader_AddRef(&shader->ID3D11VertexShader_iface);
 286 }
 287
 288 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *iface)
 289 {
 290     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 291
 292     TRACE("iface %p.\n", iface);
 293
 294     return d3d11_vertex_shader_Release(&shader->ID3D11VertexShader_iface);
 295 }
 296
 297 /* ID3D10DeviceChild methods */
 298
 299 static void STDMETHODCALLTYPE d3d10_vertex_shader_GetDevice(ID3D10VertexShader *iface, ID3D10Device **device)
 300 {
 301     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 302
 303     TRACE("iface %p, device %p.\n", iface, device);
 304
 305     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
 306 }
 307
 308 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_GetPrivateData(ID3D10VertexShader *iface,
 309         REFGUID guid, UINT *data_size, void *data)
 310 {
 311     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 312
 313     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 314             iface, debugstr_guid(guid), data_size, data);
 315
 316     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 317 }
 318
 319 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateData(ID3D10VertexShader *iface,
 320         REFGUID guid, UINT data_size, const void *data)
 321 {
 322     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 323
 324     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 325             iface, debugstr_guid(guid), data_size, data);
 326
 327     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 328 }
 329
 330 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateDataInterface(ID3D10VertexShader *iface,
 331         REFGUID guid, const IUnknown *data)
 332 {
 333     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 334
 335     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 336
 337     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 338 }
 339
 340 static const struct ID3D10VertexShaderVtbl d3d10_vertex_shader_vtbl =
 341 {
 342     /* IUnknown methods */
 343     d3d10_vertex_shader_QueryInterface,
 344     d3d10_vertex_shader_AddRef,
 345     d3d10_vertex_shader_Release,
 346     /* ID3D10DeviceChild methods */
 347     d3d10_vertex_shader_GetDevice,
 348     d3d10_vertex_shader_GetPrivateData,
 349     d3d10_vertex_shader_SetPrivateData,
 350     d3d10_vertex_shader_SetPrivateDataInterface,
 351 };
 352
 353 static void STDMETHODCALLTYPE d3d_vertex_shader_wined3d_object_destroyed(void *parent)
 354 {
 355     struct d3d_vertex_shader *shader = parent;
 356
 357     wined3d_private_store_cleanup(&shader->private_store);
 358     HeapFree(GetProcessHeap(), 0, parent);
 359 }
 360
 361 static const struct wined3d_parent_ops d3d_vertex_shader_wined3d_parent_ops =
 362 {
 363     d3d_vertex_shader_wined3d_object_destroyed,
 364 };
 365
 366 static unsigned int d3d_sm_from_feature_level(D3D_FEATURE_LEVEL feature_level)
 367 {
 368     switch (feature_level)
 369     {
 370         case D3D_FEATURE_LEVEL_11_1:
 371         case D3D_FEATURE_LEVEL_11_0:
 372             return 5;
 373         case D3D_FEATURE_LEVEL_10_1:
 374         case D3D_FEATURE_LEVEL_10_0:
 375             return 4;
 376         case D3D_FEATURE_LEVEL_9_3:
 377             return 3;
 378         case D3D_FEATURE_LEVEL_9_2:
 379         case D3D_FEATURE_LEVEL_9_1:
 380             return 2;
 381         default:
 382             ERR("Unexpected feature_level %#x.\n", feature_level);
 383     }
 384     return 0;
 385 }
 386
 387 static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d3d_device *device,
 388         const void *byte_code, SIZE_T byte_code_length)
 389 {
 390     struct wined3d_shader_desc desc;
 391     HRESULT hr;
 392
 393     shader->ID3D11VertexShader_iface.lpVtbl = &d3d11_vertex_shader_vtbl;
 394     shader->ID3D10VertexShader_iface.lpVtbl = &d3d10_vertex_shader_vtbl;
 395     shader->refcount = 1;
 396     wined3d_mutex_lock();
 397     wined3d_private_store_init(&shader->private_store);
 398
 399     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc)))
 400     {
 401         WARN("Failed to extract shader, hr %#x.\n", hr);
 402         wined3d_private_store_cleanup(&shader->private_store);
 403         wined3d_mutex_unlock();
 404         return hr;
 405     }
 406     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 407
 408     hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
 409             &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader);
 410     shader_free_signature(&desc.input_signature);
 411     shader_free_signature(&desc.output_signature);
 412     if (FAILED(hr))
 413     {
 414         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 415         wined3d_private_store_cleanup(&shader->private_store);
 416         wined3d_mutex_unlock();
 417         return E_INVALIDARG;
 418     }
 419     wined3d_mutex_unlock();
 420
 421     shader->device = &device->ID3D11Device_iface;
 422     ID3D11Device_AddRef(shader->device);
 423
 424     return S_OK;
 425 }
 426
 427 HRESULT d3d_vertex_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 428         struct d3d_vertex_shader **shader)
 429 {
 430     struct d3d_vertex_shader *object;
 431     HRESULT hr;
 432
 433     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 434         return E_OUTOFMEMORY;
 435
 436     if (FAILED(hr = d3d_vertex_shader_init(object, device, byte_code, byte_code_length)))
 437     {
 438         WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
 439         HeapFree(GetProcessHeap(), 0, object);
 440         return hr;
 441     }
 442
 443     TRACE("Created vertex shader %p.\n", object);
 444     *shader = object;
 445
 446     return S_OK;
 447 }
 448
 449 struct d3d_vertex_shader *unsafe_impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 450 {
 451     if (!iface)
 452         return NULL;
 453     assert(iface->lpVtbl == &d3d11_vertex_shader_vtbl);
 454
 455     return impl_from_ID3D11VertexShader(iface);
 456 }
 457
 458 struct d3d_vertex_shader *unsafe_impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 459 {
 460     if (!iface)
 461         return NULL;
 462     assert(iface->lpVtbl == &d3d10_vertex_shader_vtbl);
 463
 464     return impl_from_ID3D10VertexShader(iface);
 465 }
 466
 467 /* ID3D11HullShader methods */
 468
 469 static inline struct d3d11_hull_shader *impl_from_ID3D11HullShader(ID3D11HullShader *iface)
 470 {
 471     return CONTAINING_RECORD(iface, struct d3d11_hull_shader, ID3D11HullShader_iface);
 472 }
 473
 474 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_QueryInterface(ID3D11HullShader *iface,
 475         REFIID riid, void **object)
 476 {
 477     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 478
 479     if (IsEqualGUID(riid, &IID_ID3D11HullShader)
 480             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 481             || IsEqualGUID(riid, &IID_IUnknown))
 482     {
 483         ID3D11HullShader_AddRef(iface);
 484         *object = iface;
 485         return S_OK;
 486     }
 487
 488     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 489
 490     *object = NULL;
 491     return E_NOINTERFACE;
 492 }
 493
 494 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_AddRef(ID3D11HullShader *iface)
 495 {
 496     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 497     ULONG refcount = InterlockedIncrement(&shader->refcount);
 498
 499     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 500
 501     return refcount;
 502 }
 503
 504 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_Release(ID3D11HullShader *iface)
 505 {
 506     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 507     ULONG refcount = InterlockedDecrement(&shader->refcount);
 508
 509     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 510
 511     if (!refcount)
 512     {
 513         ID3D11Device *device = shader->device;
 514
 515         wined3d_mutex_lock();
 516         wined3d_shader_decref(shader->wined3d_shader);
 517         wined3d_mutex_unlock();
 518
 519         /* Release the device last, it may cause the wined3d device to be
 520          * destroyed. */
 521         ID3D11Device_Release(device);
 522     }
 523
 524     return refcount;
 525 }
 526
 527 static void STDMETHODCALLTYPE d3d11_hull_shader_GetDevice(ID3D11HullShader *iface,
 528         ID3D11Device **device)
 529 {
 530     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 531
 532     TRACE("iface %p, device %p.\n", iface, device);
 533
 534     *device = shader->device;
 535     ID3D11Device_AddRef(*device);
 536 }
 537
 538 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_GetPrivateData(ID3D11HullShader *iface,
 539         REFGUID guid, UINT *data_size, void *data)
 540 {
 541     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 542
 543     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 544
 545     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 546 }
 547
 548 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateData(ID3D11HullShader *iface,
 549         REFGUID guid, UINT data_size, const void *data)
 550 {
 551     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 552
 553     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 554
 555     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 556 }
 557
 558 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateDataInterface(ID3D11HullShader *iface,
 559         REFGUID guid, const IUnknown *data)
 560 {
 561     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 562
 563     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 564
 565     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 566 }
 567
 568 static const struct ID3D11HullShaderVtbl d3d11_hull_shader_vtbl =
 569 {
 570     /* IUnknown methods */
 571     d3d11_hull_shader_QueryInterface,
 572     d3d11_hull_shader_AddRef,
 573     d3d11_hull_shader_Release,
 574     /* ID3D11DeviceChild methods */
 575     d3d11_hull_shader_GetDevice,
 576     d3d11_hull_shader_GetPrivateData,
 577     d3d11_hull_shader_SetPrivateData,
 578     d3d11_hull_shader_SetPrivateDataInterface,
 579 };
 580
 581 static void STDMETHODCALLTYPE d3d11_hull_shader_wined3d_object_destroyed(void *parent)
 582 {
 583     struct d3d11_hull_shader *shader = parent;
 584
 585     wined3d_private_store_cleanup(&shader->private_store);
 586     HeapFree(GetProcessHeap(), 0, parent);
 587 }
 588
 589 static const struct wined3d_parent_ops d3d11_hull_shader_wined3d_parent_ops =
 590 {
 591     d3d11_hull_shader_wined3d_object_destroyed,
 592 };
 593
 594 static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d3d_device *device,
 595         const void *byte_code, SIZE_T byte_code_length)
 596 {
 597     struct wined3d_shader_desc desc;
 598     HRESULT hr;
 599
 600     shader->ID3D11HullShader_iface.lpVtbl = &d3d11_hull_shader_vtbl;
 601     shader->refcount = 1;
 602     wined3d_mutex_lock();
 603     wined3d_private_store_init(&shader->private_store);
 604
 605     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc)))
 606     {
 607         WARN("Failed to extract shader, hr %#x.\n", hr);
 608         wined3d_private_store_cleanup(&shader->private_store);
 609         wined3d_mutex_unlock();
 610         return hr;
 611     }
 612     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 613
 614     hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader,
 615             &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader);
 616     shader_free_signature(&desc.input_signature);
 617     shader_free_signature(&desc.output_signature);
 618     if (FAILED(hr))
 619     {
 620         WARN("Failed to create wined3d hull shader, hr %#x.\n", hr);
 621         wined3d_private_store_cleanup(&shader->private_store);
 622         wined3d_mutex_unlock();
 623         return E_INVALIDARG;
 624     }
 625     wined3d_mutex_unlock();
 626
 627     shader->device = &device->ID3D11Device_iface;
 628     ID3D11Device_AddRef(shader->device);
 629
 630     return S_OK;
 631 }
 632
 633 HRESULT d3d11_hull_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 634         struct d3d11_hull_shader **shader)
 635 {
 636     struct d3d11_hull_shader *object;
 637     HRESULT hr;
 638
 639     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 640         return E_OUTOFMEMORY;
 641
 642     if (FAILED(hr = d3d11_hull_shader_init(object, device, byte_code, byte_code_length)))
 643     {
 644         HeapFree(GetProcessHeap(), 0, object);
 645         return hr;
 646     }
 647
 648     TRACE("Created hull shader %p.\n", object);
 649     *shader = object;
 650
 651     return S_OK;
 652 }
 653
 654 /* ID3D11DomainShader methods */
 655
 656 static inline struct d3d11_domain_shader *impl_from_ID3D11DomainShader(ID3D11DomainShader *iface)
 657 {
 658     return CONTAINING_RECORD(iface, struct d3d11_domain_shader, ID3D11DomainShader_iface);
 659 }
 660
 661 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_QueryInterface(ID3D11DomainShader *iface,
 662         REFIID riid, void **object)
 663 {
 664     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 665
 666     if (IsEqualGUID(riid, &IID_ID3D11DomainShader)
 667             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 668             || IsEqualGUID(riid, &IID_IUnknown))
 669     {
 670         ID3D11DomainShader_AddRef(iface);
 671         *object = iface;
 672         return S_OK;
 673     }
 674
 675     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 676
 677     *object = NULL;
 678     return E_NOINTERFACE;
 679 }
 680
 681 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_AddRef(ID3D11DomainShader *iface)
 682 {
 683     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 684     ULONG refcount = InterlockedIncrement(&shader->refcount);
 685
 686     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 687
 688     return refcount;
 689 }
 690
 691 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_Release(ID3D11DomainShader *iface)
 692 {
 693     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 694     ULONG refcount = InterlockedDecrement(&shader->refcount);
 695
 696     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 697
 698     if (!refcount)
 699     {
 700         ID3D11Device *device = shader->device;
 701
 702         wined3d_mutex_lock();
 703         wined3d_shader_decref(shader->wined3d_shader);
 704         wined3d_mutex_unlock();
 705
 706         /* Release the device last, it may cause the wined3d device to be
 707          * destroyed. */
 708         ID3D11Device_Release(device);
 709     }
 710
 711     return refcount;
 712 }
 713
 714 static void STDMETHODCALLTYPE d3d11_domain_shader_GetDevice(ID3D11DomainShader *iface,
 715         ID3D11Device **device)
 716 {
 717     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 718
 719     TRACE("iface %p, device %p.\n", iface, device);
 720
 721     *device = shader->device;
 722     ID3D11Device_AddRef(*device);
 723 }
 724
 725 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_GetPrivateData(ID3D11DomainShader *iface,
 726         REFGUID guid, UINT *data_size, void *data)
 727 {
 728     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 729
 730     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 731
 732     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 733 }
 734
 735 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateData(ID3D11DomainShader *iface,
 736         REFGUID guid, UINT data_size, const void *data)
 737 {
 738     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 739
 740     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 741
 742     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 743 }
 744
 745 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateDataInterface(ID3D11DomainShader *iface,
 746         REFGUID guid, const IUnknown *data)
 747 {
 748     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 749
 750     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 751
 752     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 753 }
 754
 755 static const struct ID3D11DomainShaderVtbl d3d11_domain_shader_vtbl =
 756 {
 757     /* IUnknown methods */
 758     d3d11_domain_shader_QueryInterface,
 759     d3d11_domain_shader_AddRef,
 760     d3d11_domain_shader_Release,
 761     /* ID3D11DeviceChild methods */
 762     d3d11_domain_shader_GetDevice,
 763     d3d11_domain_shader_GetPrivateData,
 764     d3d11_domain_shader_SetPrivateData,
 765     d3d11_domain_shader_SetPrivateDataInterface,
 766 };
 767
 768 static void STDMETHODCALLTYPE d3d11_domain_shader_wined3d_object_destroyed(void *parent)
 769 {
 770     struct d3d11_domain_shader *shader = parent;
 771
 772     wined3d_private_store_cleanup(&shader->private_store);
 773     HeapFree(GetProcessHeap(), 0, parent);
 774 }
 775
 776 static const struct wined3d_parent_ops d3d11_domain_shader_wined3d_parent_ops =
 777 {
 778     d3d11_domain_shader_wined3d_object_destroyed,
 779 };
 780
 781 static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, struct d3d_device *device,
 782         const void *byte_code, SIZE_T byte_code_length)
 783 {
 784     struct wined3d_shader_desc desc;
 785     HRESULT hr;
 786
 787     shader->ID3D11DomainShader_iface.lpVtbl = &d3d11_domain_shader_vtbl;
 788     shader->refcount = 1;
 789     wined3d_mutex_lock();
 790     wined3d_private_store_init(&shader->private_store);
 791
 792     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc)))
 793     {
 794         WARN("Failed to extract shader, hr %#x.\n", hr);
 795         wined3d_private_store_cleanup(&shader->private_store);
 796         wined3d_mutex_unlock();
 797         return hr;
 798     }
 799     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 800
 801     hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader,
 802             &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader);
 803     shader_free_signature(&desc.input_signature);
 804     shader_free_signature(&desc.output_signature);
 805     if (FAILED(hr))
 806     {
 807         WARN("Failed to create wined3d domain shader, hr %#x.\n", hr);
 808         wined3d_private_store_cleanup(&shader->private_store);
 809         wined3d_mutex_unlock();
 810         return E_INVALIDARG;
 811     }
 812     wined3d_mutex_unlock();
 813
 814     shader->device = &device->ID3D11Device_iface;
 815     ID3D11Device_AddRef(shader->device);
 816
 817     return S_OK;
 818 }
 819
 820 HRESULT d3d11_domain_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 821         struct d3d11_domain_shader **shader)
 822 {
 823     struct d3d11_domain_shader *object;
 824     HRESULT hr;
 825
 826     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 827         return E_OUTOFMEMORY;
 828
 829     if (FAILED(hr = d3d11_domain_shader_init(object, device, byte_code, byte_code_length)))
 830     {
 831         HeapFree(GetProcessHeap(), 0, object);
 832         return hr;
 833     }
 834
 835     TRACE("Created domain shader %p.\n", object);
 836     *shader = object;
 837
 838     return S_OK;
 839 }
 840
 841 /* ID3D11GeometryShader methods */
 842
 843 static inline struct d3d_geometry_shader *impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
 844 {
 845     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D11GeometryShader_iface);
 846 }
 847
 848 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_QueryInterface(ID3D11GeometryShader *iface,
 849         REFIID riid, void **object)
 850 {
 851     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 852
 853     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 854
 855     if (IsEqualGUID(riid, &IID_ID3D11GeometryShader)
 856             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 857             || IsEqualGUID(riid, &IID_IUnknown))
 858     {
 859         ID3D11GeometryShader_AddRef(iface);
 860         *object = iface;
 861         return S_OK;
 862     }
 863
 864     if (IsEqualGUID(riid, &IID_ID3D10GeometryShader)
 865             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 866     {
 867         ID3D10GeometryShader_AddRef(&shader->ID3D10GeometryShader_iface);
 868         *object = &shader->ID3D10GeometryShader_iface;
 869         return S_OK;
 870     }
 871
 872     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 873
 874     *object = NULL;
 875     return E_NOINTERFACE;
 876 }
 877
 878 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_AddRef(ID3D11GeometryShader *iface)
 879 {
 880     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 881     ULONG refcount = InterlockedIncrement(&shader->refcount);
 882
 883     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 884
 885     return refcount;
 886 }
 887
 888 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_Release(ID3D11GeometryShader *iface)
 889 {
 890     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 891     ULONG refcount = InterlockedDecrement(&shader->refcount);
 892
 893     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 894
 895     if (!refcount)
 896     {
 897         ID3D11Device *device = shader->device;
 898
 899         wined3d_mutex_lock();
 900         wined3d_shader_decref(shader->wined3d_shader);
 901         wined3d_mutex_unlock();
 902
 903         /* Release the device last, it may cause the wined3d device to be
 904          * destroyed. */
 905         ID3D11Device_Release(device);
 906     }
 907
 908     return refcount;
 909 }
 910
 911 static void STDMETHODCALLTYPE d3d11_geometry_shader_GetDevice(ID3D11GeometryShader *iface,
 912         ID3D11Device **device)
 913 {
 914     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 915
 916     TRACE("iface %p, device %p.\n", iface, device);
 917
 918     *device = shader->device;
 919     ID3D11Device_AddRef(*device);
 920 }
 921
 922 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_GetPrivateData(ID3D11GeometryShader *iface,
 923         REFGUID guid, UINT *data_size, void *data)
 924 {
 925     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 926
 927     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 928
 929     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 930 }
 931
 932 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateData(ID3D11GeometryShader *iface,
 933         REFGUID guid, UINT data_size, const void *data)
 934 {
 935     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 936
 937     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 938
 939     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 940 }
 941
 942 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateDataInterface(ID3D11GeometryShader *iface,
 943         REFGUID guid, const IUnknown *data)
 944 {
 945     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
 946
 947     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 948
 949     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 950 }
 951
 952 static const struct ID3D11GeometryShaderVtbl d3d11_geometry_shader_vtbl =
 953 {
 954     /* IUnknown methods */
 955     d3d11_geometry_shader_QueryInterface,
 956     d3d11_geometry_shader_AddRef,
 957     d3d11_geometry_shader_Release,
 958     /* ID3D11DeviceChild methods */
 959     d3d11_geometry_shader_GetDevice,
 960     d3d11_geometry_shader_GetPrivateData,
 961     d3d11_geometry_shader_SetPrivateData,
 962     d3d11_geometry_shader_SetPrivateDataInterface,
 963 };
 964
 965 /* ID3D10GeometryShader methods */
 966
 967 static inline struct d3d_geometry_shader *impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
 968 {
 969     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D10GeometryShader_iface);
 970 }
 971
 972 /* IUnknown methods */
 973
 974 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_QueryInterface(ID3D10GeometryShader *iface,
 975         REFIID riid, void **object)
 976 {
 977     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 978
 979     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 980
 981     return d3d11_geometry_shader_QueryInterface(&shader->ID3D11GeometryShader_iface, riid, object);
 982 }
 983
 984 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_AddRef(ID3D10GeometryShader *iface)
 985 {
 986     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 987
 988     TRACE("iface %p.\n", iface);
 989
 990     return d3d11_geometry_shader_AddRef(&shader->ID3D11GeometryShader_iface);
 991 }
 992
 993 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShader *iface)
 994 {
 995     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 996
 997     TRACE("iface %p.\n", iface);
 998
 999     return d3d11_geometry_shader_Release(&shader->ID3D11GeometryShader_iface);
1000 }
1001
1002 /* ID3D10DeviceChild methods */
1003
1004 static void STDMETHODCALLTYPE d3d10_geometry_shader_GetDevice(ID3D10GeometryShader *iface, ID3D10Device **device)
1005 {
1006     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1007
1008     TRACE("iface %p, device %p.\n", iface, device);
1009
1010     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1011 }
1012
1013 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_GetPrivateData(ID3D10GeometryShader *iface,
1014         REFGUID guid, UINT *data_size, void *data)
1015 {
1016     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1017
1018     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1019             iface, debugstr_guid(guid), data_size, data);
1020
1021     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1022 }
1023
1024 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateData(ID3D10GeometryShader *iface,
1025         REFGUID guid, UINT data_size, const void *data)
1026 {
1027     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1028
1029     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1030             iface, debugstr_guid(guid), data_size, data);
1031
1032     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1033 }
1034
1035 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateDataInterface(ID3D10GeometryShader *iface,
1036         REFGUID guid, const IUnknown *data)
1037 {
1038     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1039
1040     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1041
1042     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1043 }
1044
1045 static const struct ID3D10GeometryShaderVtbl d3d10_geometry_shader_vtbl =
1046 {
1047     /* IUnknown methods */
1048     d3d10_geometry_shader_QueryInterface,
1049     d3d10_geometry_shader_AddRef,
1050     d3d10_geometry_shader_Release,
1051     /* ID3D10DeviceChild methods */
1052     d3d10_geometry_shader_GetDevice,
1053     d3d10_geometry_shader_GetPrivateData,
1054     d3d10_geometry_shader_SetPrivateData,
1055     d3d10_geometry_shader_SetPrivateDataInterface,
1056 };
1057
1058 static void STDMETHODCALLTYPE d3d_geometry_shader_wined3d_object_destroyed(void *parent)
1059 {
1060     struct d3d_geometry_shader *shader = parent;
1061
1062     wined3d_private_store_cleanup(&shader->private_store);
1063     HeapFree(GetProcessHeap(), 0, parent);
1064 }
1065
1066 static const struct wined3d_parent_ops d3d_geometry_shader_wined3d_parent_ops =
1067 {
1068     d3d_geometry_shader_wined3d_object_destroyed,
1069 };
1070
1071 static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, struct d3d_device *device,
1072         const void *byte_code, SIZE_T byte_code_length)
1073 {
1074     struct wined3d_shader_desc desc;
1075     HRESULT hr;
1076
1077     shader->ID3D11GeometryShader_iface.lpVtbl = &d3d11_geometry_shader_vtbl;
1078     shader->ID3D10GeometryShader_iface.lpVtbl = &d3d10_geometry_shader_vtbl;
1079     shader->refcount = 1;
1080     wined3d_mutex_lock();
1081     wined3d_private_store_init(&shader->private_store);
1082
1083     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc)))
1084     {
1085         WARN("Failed to extract shader, hr %#x.\n", hr);
1086         wined3d_private_store_cleanup(&shader->private_store);
1087         wined3d_mutex_unlock();
1088         return hr;
1089     }
1090     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1091
1092     hr = wined3d_shader_create_gs(device->wined3d_device, &desc, shader,
1093             &d3d_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader);
1094     shader_free_signature(&desc.input_signature);
1095     shader_free_signature(&desc.output_signature);
1096     if (FAILED(hr))
1097     {
1098         WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr);
1099         wined3d_private_store_cleanup(&shader->private_store);
1100         wined3d_mutex_unlock();
1101         return E_INVALIDARG;
1102     }
1103     wined3d_mutex_unlock();
1104
1105     shader->device = &device->ID3D11Device_iface;
1106     ID3D11Device_AddRef(shader->device);
1107
1108     return S_OK;
1109 }
1110
1111 HRESULT d3d_geometry_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1112         struct d3d_geometry_shader **shader)
1113 {
1114     struct d3d_geometry_shader *object;
1115     HRESULT hr;
1116
1117     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1118         return E_OUTOFMEMORY;
1119
1120     if (FAILED(hr = d3d_geometry_shader_init(object, device, byte_code, byte_code_length)))
1121     {
1122         WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
1123         HeapFree(GetProcessHeap(), 0, object);
1124         return hr;
1125     }
1126
1127     TRACE("Created geometry shader %p.\n", object);
1128     *shader = object;
1129
1130     return S_OK;
1131 }
1132
1133 struct d3d_geometry_shader *unsafe_impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
1134 {
1135     if (!iface)
1136         return NULL;
1137     assert(iface->lpVtbl == &d3d11_geometry_shader_vtbl);
1138
1139     return impl_from_ID3D11GeometryShader(iface);
1140 }
1141
1142 struct d3d_geometry_shader *unsafe_impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
1143 {
1144     if (!iface)
1145         return NULL;
1146     assert(iface->lpVtbl == &d3d10_geometry_shader_vtbl);
1147
1148     return impl_from_ID3D10GeometryShader(iface);
1149 }
1150
1151 /* ID3D11PixelShader methods */
1152
1153 static inline struct d3d_pixel_shader *impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1154 {
1155     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D11PixelShader_iface);
1156 }
1157
1158 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_QueryInterface(ID3D11PixelShader *iface,
1159         REFIID riid, void **object)
1160 {
1161     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1162
1163     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1164
1165     if (IsEqualGUID(riid, &IID_ID3D11PixelShader)
1166             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1167             || IsEqualGUID(riid, &IID_IUnknown))
1168     {
1169         ID3D11PixelShader_AddRef(iface);
1170         *object = iface;
1171         return S_OK;
1172     }
1173
1174     if (IsEqualGUID(riid, &IID_ID3D10PixelShader)
1175             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1176     {
1177         IUnknown_AddRef(&shader->ID3D10PixelShader_iface);
1178         *object = &shader->ID3D10PixelShader_iface;
1179         return S_OK;
1180     }
1181
1182     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1183
1184     *object = NULL;
1185     return E_NOINTERFACE;
1186 }
1187
1188 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_AddRef(ID3D11PixelShader *iface)
1189 {
1190     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1191     ULONG refcount = InterlockedIncrement(&shader->refcount);
1192
1193     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1194
1195     if (refcount == 1)
1196     {
1197         ID3D11Device_AddRef(shader->device);
1198         wined3d_mutex_lock();
1199         wined3d_shader_incref(shader->wined3d_shader);
1200         wined3d_mutex_unlock();
1201     }
1202
1203     return refcount;
1204 }
1205
1206 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_Release(ID3D11PixelShader *iface)
1207 {
1208     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1209     ULONG refcount = InterlockedDecrement(&shader->refcount);
1210
1211     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1212
1213     if (!refcount)
1214     {
1215         ID3D11Device *device = shader->device;
1216
1217         wined3d_mutex_lock();
1218         wined3d_shader_decref(shader->wined3d_shader);
1219         wined3d_mutex_unlock();
1220         /* Release the device last, it may cause the wined3d device to be
1221          * destroyed. */
1222         ID3D11Device_Release(device);
1223     }
1224
1225     return refcount;
1226 }
1227
1228 static void STDMETHODCALLTYPE d3d11_pixel_shader_GetDevice(ID3D11PixelShader *iface,
1229         ID3D11Device **device)
1230 {
1231     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1232
1233     TRACE("iface %p, device %p.\n", iface, device);
1234
1235     *device = shader->device;
1236     ID3D11Device_AddRef(*device);
1237 }
1238
1239 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_GetPrivateData(ID3D11PixelShader *iface,
1240         REFGUID guid, UINT *data_size, void *data)
1241 {
1242     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1243
1244     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1245
1246     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1247 }
1248
1249 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateData(ID3D11PixelShader *iface,
1250         REFGUID guid, UINT data_size, const void *data)
1251 {
1252     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1253
1254     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1255
1256     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1257 }
1258
1259 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateDataInterface(ID3D11PixelShader *iface,
1260         REFGUID guid, const IUnknown *data)
1261 {
1262     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1263
1264     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1265
1266     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1267 }
1268
1269 static const struct ID3D11PixelShaderVtbl d3d11_pixel_shader_vtbl =
1270 {
1271     /* IUnknown methods */
1272     d3d11_pixel_shader_QueryInterface,
1273     d3d11_pixel_shader_AddRef,
1274     d3d11_pixel_shader_Release,
1275     /* ID3D11DeviceChild methods */
1276     d3d11_pixel_shader_GetDevice,
1277     d3d11_pixel_shader_GetPrivateData,
1278     d3d11_pixel_shader_SetPrivateData,
1279     d3d11_pixel_shader_SetPrivateDataInterface,
1280 };
1281
1282 /* ID3D10PixelShader methods */
1283
1284 static inline struct d3d_pixel_shader *impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1285 {
1286     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D10PixelShader_iface);
1287 }
1288
1289 /* IUnknown methods */
1290
1291 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_QueryInterface(ID3D10PixelShader *iface,
1292         REFIID riid, void **object)
1293 {
1294     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1295
1296     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1297
1298     return d3d11_pixel_shader_QueryInterface(&shader->ID3D11PixelShader_iface, riid, object);
1299 }
1300
1301 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
1302 {
1303     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1304
1305     TRACE("iface %p.\n", iface);
1306
1307     return d3d11_pixel_shader_AddRef(&shader->ID3D11PixelShader_iface);
1308 }
1309
1310 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *iface)
1311 {
1312     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1313
1314     TRACE("iface %p.\n", iface);
1315
1316     return d3d11_pixel_shader_Release(&shader->ID3D11PixelShader_iface);
1317 }
1318
1319 /* ID3D10DeviceChild methods */
1320
1321 static void STDMETHODCALLTYPE d3d10_pixel_shader_GetDevice(ID3D10PixelShader *iface, ID3D10Device **device)
1322 {
1323     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1324
1325     TRACE("iface %p, device %p.\n", iface, device);
1326
1327     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1328 }
1329
1330 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_GetPrivateData(ID3D10PixelShader *iface,
1331         REFGUID guid, UINT *data_size, void *data)
1332 {
1333     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1334
1335     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1336             iface, debugstr_guid(guid), data_size, data);
1337
1338     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1339 }
1340
1341 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateData(ID3D10PixelShader *iface,
1342         REFGUID guid, UINT data_size, const void *data)
1343 {
1344     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1345
1346     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1347             iface, debugstr_guid(guid), data_size, data);
1348
1349     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1350 }
1351
1352 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateDataInterface(ID3D10PixelShader *iface,
1353         REFGUID guid, const IUnknown *data)
1354 {
1355     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1356
1357     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1358
1359     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1360 }
1361
1362 static const struct ID3D10PixelShaderVtbl d3d10_pixel_shader_vtbl =
1363 {
1364     /* IUnknown methods */
1365     d3d10_pixel_shader_QueryInterface,
1366     d3d10_pixel_shader_AddRef,
1367     d3d10_pixel_shader_Release,
1368     /* ID3D10DeviceChild methods */
1369     d3d10_pixel_shader_GetDevice,
1370     d3d10_pixel_shader_GetPrivateData,
1371     d3d10_pixel_shader_SetPrivateData,
1372     d3d10_pixel_shader_SetPrivateDataInterface,
1373 };
1374
1375 static void STDMETHODCALLTYPE d3d_pixel_shader_wined3d_object_destroyed(void *parent)
1376 {
1377     struct d3d_pixel_shader *shader = parent;
1378
1379     wined3d_private_store_cleanup(&shader->private_store);
1380     HeapFree(GetProcessHeap(), 0, parent);
1381 }
1382
1383 static const struct wined3d_parent_ops d3d_pixel_shader_wined3d_parent_ops =
1384 {
1385     d3d_pixel_shader_wined3d_object_destroyed,
1386 };
1387
1388 static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d_device *device,
1389         const void *byte_code, SIZE_T byte_code_length)
1390 {
1391     struct wined3d_shader_desc desc;
1392     HRESULT hr;
1393
1394     shader->ID3D11PixelShader_iface.lpVtbl = &d3d11_pixel_shader_vtbl;
1395     shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
1396     shader->refcount = 1;
1397     wined3d_mutex_lock();
1398     wined3d_private_store_init(&shader->private_store);
1399
1400     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc)))
1401     {
1402         WARN("Failed to extract shader, hr %#x.\n", hr);
1403         wined3d_private_store_cleanup(&shader->private_store);
1404         wined3d_mutex_unlock();
1405         return hr;
1406     }
1407     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1408
1409     hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
1410             &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader);
1411     shader_free_signature(&desc.input_signature);
1412     shader_free_signature(&desc.output_signature);
1413     if (FAILED(hr))
1414     {
1415         WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
1416         wined3d_private_store_cleanup(&shader->private_store);
1417         wined3d_mutex_unlock();
1418         return E_INVALIDARG;
1419     }
1420     wined3d_mutex_unlock();
1421
1422     shader->device = &device->ID3D11Device_iface;
1423     ID3D11Device_AddRef(shader->device);
1424
1425     return S_OK;
1426 }
1427
1428 HRESULT d3d_pixel_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1429         struct d3d_pixel_shader **shader)
1430 {
1431     struct d3d_pixel_shader *object;
1432     HRESULT hr;
1433
1434     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1435         return E_OUTOFMEMORY;
1436
1437     if (FAILED(hr = d3d_pixel_shader_init(object, device, byte_code, byte_code_length)))
1438     {
1439         WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
1440         HeapFree(GetProcessHeap(), 0, object);
1441         return hr;
1442     }
1443
1444     TRACE("Created pixel shader %p.\n", object);
1445     *shader = object;
1446
1447     return S_OK;
1448 }
1449
1450 struct d3d_pixel_shader *unsafe_impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1451 {
1452     if (!iface)
1453         return NULL;
1454     assert(iface->lpVtbl == &d3d11_pixel_shader_vtbl);
1455
1456     return impl_from_ID3D11PixelShader(iface);
1457 }
1458
1459 struct d3d_pixel_shader *unsafe_impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1460 {
1461     if (!iface)
1462         return NULL;
1463     assert(iface->lpVtbl == &d3d10_pixel_shader_vtbl);
1464
1465     return impl_from_ID3D10PixelShader(iface);
1466 }
1467
1468 /* ID3D11ClassLinkage methods */
1469
1470 static inline struct d3d11_class_linkage *impl_from_ID3D11ClassLinkage(ID3D11ClassLinkage *iface)
1471 {
1472     return CONTAINING_RECORD(iface, struct d3d11_class_linkage, ID3D11ClassLinkage_iface);
1473 }
1474
1475 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_QueryInterface(ID3D11ClassLinkage *iface,
1476         REFIID riid, void **object)
1477 {
1478     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1479
1480     if (IsEqualGUID(riid, &IID_ID3D11ClassLinkage)
1481             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1482             || IsEqualGUID(riid, &IID_IUnknown))
1483     {
1484         ID3D11ClassLinkage_AddRef(*object = iface);
1485         return S_OK;
1486     }
1487
1488     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1489
1490     *object = NULL;
1491     return E_NOINTERFACE;
1492 }
1493
1494 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_AddRef(ID3D11ClassLinkage *iface)
1495 {
1496     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
1497     ULONG refcount = InterlockedIncrement(&class_linkage->refcount);
1498
1499     TRACE("%p increasing refcount to %u.\n", class_linkage, refcount);
1500
1501     return refcount;
1502 }
1503
1504 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_Release(ID3D11ClassLinkage *iface)
1505 {
1506     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
1507     ULONG refcount = InterlockedDecrement(&class_linkage->refcount);
1508
1509     TRACE("%p decreasing refcount to %u.\n", class_linkage, refcount);
1510
1511     if (!refcount)
1512     {
1513         wined3d_private_store_cleanup(&class_linkage->private_store);
1514         HeapFree(GetProcessHeap(), 0, class_linkage);
1515     }
1516
1517     return refcount;
1518 }
1519
1520 static void STDMETHODCALLTYPE d3d11_class_linkage_GetDevice(ID3D11ClassLinkage *iface,
1521         ID3D11Device **device)
1522 {
1523     FIXME("iface %p, device %p stub!\n", iface, device);
1524 }
1525
1526 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetPrivateData(ID3D11ClassLinkage *iface,
1527         REFGUID guid, UINT *data_size, void *data)
1528 {
1529     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
1530
1531     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1532
1533     return d3d_get_private_data(&class_linkage->private_store, guid, data_size, data);
1534 }
1535
1536 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateData(ID3D11ClassLinkage *iface,
1537         REFGUID guid, UINT data_size, const void *data)
1538 {
1539     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
1540
1541     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1542
1543     return d3d_set_private_data(&class_linkage->private_store, guid, data_size, data);
1544 }
1545
1546 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateDataInterface(ID3D11ClassLinkage *iface,
1547         REFGUID guid, const IUnknown *data)
1548 {
1549     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
1550
1551     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1552
1553     return d3d_set_private_data_interface(&class_linkage->private_store, guid, data);
1554 }
1555
1556 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetClassInstance(ID3D11ClassLinkage *iface,
1557         const char *instance_name, UINT instance_index, ID3D11ClassInstance **class_instance)
1558 {
1559     FIXME("iface %p, instance_name %s, instance_index %u, class_instance %p stub!\n",
1560             iface, debugstr_a(instance_name), instance_index, class_instance);
1561
1562     return E_NOTIMPL;
1563 }
1564
1565 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_CreateClassInstance(ID3D11ClassLinkage *iface,
1566         const char *type_name, UINT cb_offset, UINT cb_vector_offset, UINT texture_offset,
1567         UINT sampler_offset, ID3D11ClassInstance **class_instance)
1568 {
1569     FIXME("iface %p, type_name %s, cb_offset %u, cb_vector_offset %u, texture_offset %u, "
1570             "sampler_offset %u, class_instance %p stub!\n",
1571             iface, debugstr_a(type_name), cb_offset, cb_vector_offset, texture_offset,
1572             sampler_offset, class_instance);
1573
1574     return E_NOTIMPL;
1575 }
1576
1577 static const struct ID3D11ClassLinkageVtbl d3d11_class_linkage_vtbl =
1578 {
1579     /* IUnknown methods */
1580     d3d11_class_linkage_QueryInterface,
1581     d3d11_class_linkage_AddRef,
1582     d3d11_class_linkage_Release,
1583     /* ID3D11DeviceChild methods */
1584     d3d11_class_linkage_GetDevice,
1585     d3d11_class_linkage_GetPrivateData,
1586     d3d11_class_linkage_SetPrivateData,
1587     d3d11_class_linkage_SetPrivateDataInterface,
1588     /* ID3D11ClassLinkage methods */
1589     d3d11_class_linkage_GetClassInstance,
1590     d3d11_class_linkage_CreateClassInstance,
1591 };
1592
1593 HRESULT d3d11_class_linkage_create(struct d3d_device *device, struct d3d11_class_linkage **class_linkage)
1594 {
1595     struct d3d11_class_linkage *object;
1596
1597     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1598         return E_OUTOFMEMORY;
1599
1600     object->ID3D11ClassLinkage_iface.lpVtbl = &d3d11_class_linkage_vtbl;
1601     object->refcount = 1;
1602     wined3d_private_store_init(&object->private_store);
1603
1604     TRACE("Created class linkage %p.\n", object);
1605     *class_linkage = object;
1606
1607     return S_OK;
1608 }