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