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 struct aon9_header
  28 {
  29     DWORD chunk_size;
  30     DWORD shader_version;
  31     DWORD unknown;
  32     DWORD byte_code_offset;
  33 };
  34
  35 struct shader_handler_context
  36 {
  37     D3D_FEATURE_LEVEL feature_level;
  38     struct wined3d_shader_desc *desc;
  39 };
  40
  41 static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *context)
  42 {
  43     const struct shader_handler_context *ctx = context;
  44     struct wined3d_shader_desc *desc = ctx->desc;
  45     HRESULT hr;
  46
  47     switch (tag)
  48     {
  49         case TAG_ISGN:
  50             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  51             {
  52                 TRACE("Skipping shader input signature on feature level %#x.\n", ctx->feature_level);
  53                 break;
  54             }
  55             if (desc->input_signature.elements)
  56             {
  57                 FIXME("Multiple input signatures.\n");
  58                 break;
  59             }
  60             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->input_signature)))
  61                 return hr;
  62             break;
  63
  64         case TAG_OSGN:
  65         case TAG_OSG5:
  66             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  67             {
  68                 TRACE("Skipping shader output signature on feature level %#x.\n", ctx->feature_level);
  69                 break;
  70             }
  71             if (desc->output_signature.elements)
  72             {
  73                 FIXME("Multiple output signatures.\n");
  74                 break;
  75             }
  76             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->output_signature)))
  77                 return hr;
  78             break;
  79
  80         case TAG_PCSG:
  81             if (desc->patch_constant_signature.elements)
  82             {
  83                 FIXME("Multiple patch constant signatures.\n");
  84                 break;
  85             }
  86             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->patch_constant_signature)))
  87                 return hr;
  88             break;
  89
  90         case TAG_SHDR:
  91         case TAG_SHEX:
  92             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  93             {
  94                 TRACE("Skipping SM4+ shader code on feature level %#x.\n", ctx->feature_level);
  95                 break;
  96             }
  97             if (desc->byte_code)
  98                 FIXME("Multiple shader code chunks.\n");
  99             desc->byte_code = (const DWORD *)data;
 100             desc->byte_code_size = data_size;
 101             desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4;
 102             break;
 103
 104         case TAG_AON9:
 105             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
 106             {
 107                 const struct aon9_header *header = (const struct aon9_header *)data;
 108                 unsigned int unknown_dword_count;
 109                 const char *byte_code;
 110
 111                 if (data_size < sizeof(*header))
 112                 {
 113                     WARN("Invalid Aon9 data size %#x.\n", data_size);
 114                     return E_FAIL;
 115                 }
 116                 byte_code = data + header->byte_code_offset;
 117                 unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD);
 118
 119                 if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset)
 120                 {
 121                     WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size);
 122                     return E_FAIL;
 123                 }
 124                 FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count);
 125
 126                 if (desc->byte_code)
 127                     FIXME("Multiple shader code chunks.\n");
 128                 desc->byte_code = (const DWORD *)byte_code;
 129                 desc->byte_code_size = data_size - header->byte_code_offset;
 130                 desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1;
 131                 TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", header->shader_version, *desc->byte_code);
 132             }
 133             else
 134             {
 135                 TRACE("Skipping feature level 9 shader code on feature level %#x.\n", ctx->feature_level);
 136             }
 137             break;
 138
 139         case TAG_RDEF:
 140         case TAG_STAT:
 141             break;
 142
 143         default:
 144             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 145             break;
 146     }
 147
 148     return S_OK;
 149 }
 150
 151 static void free_shader_desc(struct wined3d_shader_desc *desc)
 152 {
 153     shader_free_signature(&desc->input_signature);
 154     shader_free_signature(&desc->output_signature);
 155     shader_free_signature(&desc->patch_constant_signature);
 156 }
 157
 158 static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length,
 159         struct wined3d_shader_desc *desc, D3D_FEATURE_LEVEL feature_level)
 160 {
 161     struct shader_handler_context ctx = {feature_level, desc};
 162     HRESULT hr;
 163
 164     desc->byte_code = NULL;
 165     desc->byte_code_size = 0;
 166     memset(&desc->input_signature, 0, sizeof(desc->input_signature));
 167     memset(&desc->output_signature, 0, sizeof(desc->output_signature));
 168     memset(&desc->patch_constant_signature, 0, sizeof(desc->patch_constant_signature));
 169
 170     hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, &ctx);
 171     if (!desc->byte_code)
 172         hr = E_INVALIDARG;
 173
 174     if (FAILED(hr))
 175     {
 176         FIXME("Failed to parse shader, hr %#x.\n", hr);
 177         free_shader_desc(desc);
 178     }
 179
 180     return hr;
 181 }
 182
 183 static const char *shader_get_string(const char *data, size_t data_size, DWORD offset)
 184 {
 185     size_t len, max_len;
 186
 187     if (offset >= data_size)
 188     {
 189         WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
 190         return NULL;
 191     }
 192
 193     max_len = data_size - offset;
 194     len = strnlen(data + offset, max_len);
 195
 196     if (len == max_len)
 197         return NULL;
 198
 199     return data + offset;
 200 }
 201
 202 HRESULT shader_parse_signature(DWORD tag, const char *data, DWORD data_size,
 203         struct wined3d_shader_signature *s)
 204 {
 205     struct wined3d_shader_signature_element *e;
 206     const char *ptr = data;
 207     unsigned int i;
 208     DWORD count;
 209
 210     if (!require_space(0, 2, sizeof(DWORD), data_size))
 211     {
 212         WARN("Invalid data size %#x.\n", data_size);
 213         return E_INVALIDARG;
 214     }
 215
 216     read_dword(&ptr, &count);
 217     TRACE("%u elements.\n", count);
 218
 219     skip_dword_unknown(&ptr, 1); /* It seems to always be 0x00000008. */
 220
 221     if (!require_space(ptr - data, count, 6 * sizeof(DWORD), data_size))
 222     {
 223         WARN("Invalid count %#x (data size %#x).\n", count, data_size);
 224         return E_INVALIDARG;
 225     }
 226
 227     if (!(e = heap_calloc(count, sizeof(*e))))
 228     {
 229         ERR("Failed to allocate input signature memory.\n");
 230         return E_OUTOFMEMORY;
 231     }
 232
 233     for (i = 0; i < count; ++i)
 234     {
 235         DWORD name_offset;
 236
 237         if (tag == TAG_OSG5)
 238             read_dword(&ptr, &e[i].stream_idx);
 239         else
 240             e[i].stream_idx = 0;
 241         read_dword(&ptr, &name_offset);
 242         if (!(e[i].semantic_name = shader_get_string(data, data_size, name_offset)))
 243         {
 244             WARN("Invalid name offset %#x (data size %#x).\n", name_offset, data_size);
 245             heap_free(e);
 246             return E_INVALIDARG;
 247         }
 248         read_dword(&ptr, &e[i].semantic_idx);
 249         read_dword(&ptr, &e[i].sysval_semantic);
 250         read_dword(&ptr, &e[i].component_type);
 251         read_dword(&ptr, &e[i].register_idx);
 252         read_dword(&ptr, &e[i].mask);
 253
 254         TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 255                 "type %u, register idx: %u, use_mask %#x, input_mask %#x.\n",
 256                 e[i].stream_idx, debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic,
 257                 e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
 258     }
 259
 260     s->elements = e;
 261     s->element_count = count;
 262
 263     return S_OK;
 264 }
 265
 266 struct wined3d_shader_signature_element *shader_find_signature_element(const struct wined3d_shader_signature *s,
 267         const char *semantic_name, unsigned int semantic_idx, unsigned int stream_idx)
 268 {
 269     struct wined3d_shader_signature_element *e = s->elements;
 270     unsigned int i;
 271
 272     for (i = 0; i < s->element_count; ++i)
 273     {
 274         if (!strcasecmp(e[i].semantic_name, semantic_name) && e[i].semantic_idx == semantic_idx
 275                 && e[i].stream_idx == stream_idx)
 276             return &e[i];
 277     }
 278
 279     return NULL;
 280 }
 281
 282 void shader_free_signature(struct wined3d_shader_signature *s)
 283 {
 284     heap_free(s->elements);
 285 }
 286
 287 /* ID3D11VertexShader methods */
 288
 289 static inline struct d3d_vertex_shader *impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 290 {
 291     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D11VertexShader_iface);
 292 }
 293
 294 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_QueryInterface(ID3D11VertexShader *iface,
 295         REFIID riid, void **object)
 296 {
 297     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 298
 299     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 300
 301     if (IsEqualGUID(riid, &IID_ID3D11VertexShader)
 302             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 303             || IsEqualGUID(riid, &IID_IUnknown))
 304     {
 305         ID3D11VertexShader_AddRef(iface);
 306         *object = iface;
 307         return S_OK;
 308     }
 309
 310     if (IsEqualGUID(riid, &IID_ID3D10VertexShader)
 311             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 312     {
 313         IUnknown_AddRef(&shader->ID3D10VertexShader_iface);
 314         *object = &shader->ID3D10VertexShader_iface;
 315         return S_OK;
 316     }
 317
 318     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 319
 320     *object = NULL;
 321     return E_NOINTERFACE;
 322 }
 323
 324 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_AddRef(ID3D11VertexShader *iface)
 325 {
 326     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 327     ULONG refcount = InterlockedIncrement(&shader->refcount);
 328
 329     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 330
 331     if (refcount == 1)
 332     {
 333         ID3D11Device2_AddRef(shader->device);
 334         wined3d_mutex_lock();
 335         wined3d_shader_incref(shader->wined3d_shader);
 336         wined3d_mutex_unlock();
 337     }
 338
 339     return refcount;
 340 }
 341
 342 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_Release(ID3D11VertexShader *iface)
 343 {
 344     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 345     ULONG refcount = InterlockedDecrement(&shader->refcount);
 346
 347     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 348
 349     if (!refcount)
 350     {
 351         ID3D11Device2 *device = shader->device;
 352
 353         wined3d_mutex_lock();
 354         wined3d_shader_decref(shader->wined3d_shader);
 355         wined3d_mutex_unlock();
 356         /* Release the device last, it may cause the wined3d device to be
 357          * destroyed. */
 358         ID3D11Device2_Release(device);
 359     }
 360
 361     return refcount;
 362 }
 363
 364 static void STDMETHODCALLTYPE d3d11_vertex_shader_GetDevice(ID3D11VertexShader *iface,
 365         ID3D11Device **device)
 366 {
 367     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 368
 369     TRACE("iface %p, device %p.\n", iface, device);
 370
 371     *device = (ID3D11Device *)shader->device;
 372     ID3D11Device_AddRef(*device);
 373 }
 374
 375 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_GetPrivateData(ID3D11VertexShader *iface,
 376         REFGUID guid, UINT *data_size, void *data)
 377 {
 378     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 379
 380     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 381
 382     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 383 }
 384
 385 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateData(ID3D11VertexShader *iface,
 386         REFGUID guid, UINT data_size, const void *data)
 387 {
 388     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 389
 390     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 391
 392     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 393 }
 394
 395 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateDataInterface(ID3D11VertexShader *iface,
 396         REFGUID guid, const IUnknown *data)
 397 {
 398     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 399
 400     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 401
 402     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 403 }
 404
 405 static const struct ID3D11VertexShaderVtbl d3d11_vertex_shader_vtbl =
 406 {
 407     /* IUnknown methods */
 408     d3d11_vertex_shader_QueryInterface,
 409     d3d11_vertex_shader_AddRef,
 410     d3d11_vertex_shader_Release,
 411     /* ID3D11DeviceChild methods */
 412     d3d11_vertex_shader_GetDevice,
 413     d3d11_vertex_shader_GetPrivateData,
 414     d3d11_vertex_shader_SetPrivateData,
 415     d3d11_vertex_shader_SetPrivateDataInterface,
 416 };
 417
 418 /* ID3D10VertexShader methods */
 419
 420 static inline struct d3d_vertex_shader *impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 421 {
 422     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D10VertexShader_iface);
 423 }
 424
 425 /* IUnknown methods */
 426
 427 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_QueryInterface(ID3D10VertexShader *iface,
 428         REFIID riid, void **object)
 429 {
 430     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 431
 432     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 433
 434     return d3d11_vertex_shader_QueryInterface(&shader->ID3D11VertexShader_iface, riid, object);
 435 }
 436
 437 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *iface)
 438 {
 439     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 440
 441     TRACE("iface %p.\n", iface);
 442
 443     return d3d11_vertex_shader_AddRef(&shader->ID3D11VertexShader_iface);
 444 }
 445
 446 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *iface)
 447 {
 448     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 449
 450     TRACE("iface %p.\n", iface);
 451
 452     return d3d11_vertex_shader_Release(&shader->ID3D11VertexShader_iface);
 453 }
 454
 455 /* ID3D10DeviceChild methods */
 456
 457 static void STDMETHODCALLTYPE d3d10_vertex_shader_GetDevice(ID3D10VertexShader *iface, ID3D10Device **device)
 458 {
 459     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 460
 461     TRACE("iface %p, device %p.\n", iface, device);
 462
 463     ID3D11Device2_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
 464 }
 465
 466 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_GetPrivateData(ID3D10VertexShader *iface,
 467         REFGUID guid, UINT *data_size, void *data)
 468 {
 469     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 470
 471     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 472             iface, debugstr_guid(guid), data_size, data);
 473
 474     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 475 }
 476
 477 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateData(ID3D10VertexShader *iface,
 478         REFGUID guid, UINT data_size, const void *data)
 479 {
 480     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 481
 482     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 483             iface, debugstr_guid(guid), data_size, data);
 484
 485     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 486 }
 487
 488 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateDataInterface(ID3D10VertexShader *iface,
 489         REFGUID guid, const IUnknown *data)
 490 {
 491     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 492
 493     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 494
 495     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 496 }
 497
 498 static const struct ID3D10VertexShaderVtbl d3d10_vertex_shader_vtbl =
 499 {
 500     /* IUnknown methods */
 501     d3d10_vertex_shader_QueryInterface,
 502     d3d10_vertex_shader_AddRef,
 503     d3d10_vertex_shader_Release,
 504     /* ID3D10DeviceChild methods */
 505     d3d10_vertex_shader_GetDevice,
 506     d3d10_vertex_shader_GetPrivateData,
 507     d3d10_vertex_shader_SetPrivateData,
 508     d3d10_vertex_shader_SetPrivateDataInterface,
 509 };
 510
 511 static void STDMETHODCALLTYPE d3d_vertex_shader_wined3d_object_destroyed(void *parent)
 512 {
 513     struct d3d_vertex_shader *shader = parent;
 514
 515     wined3d_private_store_cleanup(&shader->private_store);
 516     heap_free(parent);
 517 }
 518
 519 static const struct wined3d_parent_ops d3d_vertex_shader_wined3d_parent_ops =
 520 {
 521     d3d_vertex_shader_wined3d_object_destroyed,
 522 };
 523
 524 static unsigned int d3d_sm_from_feature_level(D3D_FEATURE_LEVEL feature_level)
 525 {
 526     switch (feature_level)
 527     {
 528         case D3D_FEATURE_LEVEL_11_1:
 529         case D3D_FEATURE_LEVEL_11_0:
 530             return 5;
 531         case D3D_FEATURE_LEVEL_10_1:
 532         case D3D_FEATURE_LEVEL_10_0:
 533             return 4;
 534         case D3D_FEATURE_LEVEL_9_3:
 535             return 3;
 536         case D3D_FEATURE_LEVEL_9_2:
 537         case D3D_FEATURE_LEVEL_9_1:
 538             return 2;
 539         default:
 540             ERR("Unexpected feature_level %#x.\n", feature_level);
 541     }
 542     return 0;
 543 }
 544
 545 static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d3d_device *device,
 546         const void *byte_code, SIZE_T byte_code_length)
 547 {
 548     struct wined3d_shader_desc desc;
 549     HRESULT hr;
 550
 551     shader->ID3D11VertexShader_iface.lpVtbl = &d3d11_vertex_shader_vtbl;
 552     shader->ID3D10VertexShader_iface.lpVtbl = &d3d10_vertex_shader_vtbl;
 553     shader->refcount = 1;
 554     wined3d_mutex_lock();
 555     wined3d_private_store_init(&shader->private_store);
 556
 557     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 558     {
 559         WARN("Failed to extract shader, hr %#x.\n", hr);
 560         wined3d_private_store_cleanup(&shader->private_store);
 561         wined3d_mutex_unlock();
 562         return hr;
 563     }
 564     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 565
 566     hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
 567             &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader);
 568     free_shader_desc(&desc);
 569     if (FAILED(hr))
 570     {
 571         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 572         wined3d_private_store_cleanup(&shader->private_store);
 573         wined3d_mutex_unlock();
 574         return E_INVALIDARG;
 575     }
 576     wined3d_mutex_unlock();
 577
 578     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
 579
 580     return S_OK;
 581 }
 582
 583 HRESULT d3d_vertex_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 584         struct d3d_vertex_shader **shader)
 585 {
 586     struct d3d_vertex_shader *object;
 587     HRESULT hr;
 588
 589     if (!(object = heap_alloc_zero(sizeof(*object))))
 590         return E_OUTOFMEMORY;
 591
 592     if (FAILED(hr = d3d_vertex_shader_init(object, device, byte_code, byte_code_length)))
 593     {
 594         WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
 595         heap_free(object);
 596         return hr;
 597     }
 598
 599     TRACE("Created vertex shader %p.\n", object);
 600     *shader = object;
 601
 602     return S_OK;
 603 }
 604
 605 struct d3d_vertex_shader *unsafe_impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 606 {
 607     if (!iface)
 608         return NULL;
 609     assert(iface->lpVtbl == &d3d11_vertex_shader_vtbl);
 610
 611     return impl_from_ID3D11VertexShader(iface);
 612 }
 613
 614 struct d3d_vertex_shader *unsafe_impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 615 {
 616     if (!iface)
 617         return NULL;
 618     assert(iface->lpVtbl == &d3d10_vertex_shader_vtbl);
 619
 620     return impl_from_ID3D10VertexShader(iface);
 621 }
 622
 623 /* ID3D11HullShader methods */
 624
 625 static inline struct d3d11_hull_shader *impl_from_ID3D11HullShader(ID3D11HullShader *iface)
 626 {
 627     return CONTAINING_RECORD(iface, struct d3d11_hull_shader, ID3D11HullShader_iface);
 628 }
 629
 630 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_QueryInterface(ID3D11HullShader *iface,
 631         REFIID riid, void **object)
 632 {
 633     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 634
 635     if (IsEqualGUID(riid, &IID_ID3D11HullShader)
 636             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 637             || IsEqualGUID(riid, &IID_IUnknown))
 638     {
 639         ID3D11HullShader_AddRef(iface);
 640         *object = iface;
 641         return S_OK;
 642     }
 643
 644     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 645
 646     *object = NULL;
 647     return E_NOINTERFACE;
 648 }
 649
 650 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_AddRef(ID3D11HullShader *iface)
 651 {
 652     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 653     ULONG refcount = InterlockedIncrement(&shader->refcount);
 654
 655     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 656
 657     if (refcount == 1)
 658     {
 659         ID3D11Device2_AddRef(shader->device);
 660         wined3d_mutex_lock();
 661         wined3d_shader_incref(shader->wined3d_shader);
 662         wined3d_mutex_unlock();
 663     }
 664
 665     return refcount;
 666 }
 667
 668 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_Release(ID3D11HullShader *iface)
 669 {
 670     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 671     ULONG refcount = InterlockedDecrement(&shader->refcount);
 672
 673     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 674
 675     if (!refcount)
 676     {
 677         ID3D11Device2 *device = shader->device;
 678
 679         wined3d_mutex_lock();
 680         wined3d_shader_decref(shader->wined3d_shader);
 681         wined3d_mutex_unlock();
 682
 683         /* Release the device last, it may cause the wined3d device to be
 684          * destroyed. */
 685         ID3D11Device2_Release(device);
 686     }
 687
 688     return refcount;
 689 }
 690
 691 static void STDMETHODCALLTYPE d3d11_hull_shader_GetDevice(ID3D11HullShader *iface,
 692         ID3D11Device **device)
 693 {
 694     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 695
 696     TRACE("iface %p, device %p.\n", iface, device);
 697
 698     *device = (ID3D11Device *)shader->device;
 699     ID3D11Device_AddRef(*device);
 700 }
 701
 702 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_GetPrivateData(ID3D11HullShader *iface,
 703         REFGUID guid, UINT *data_size, void *data)
 704 {
 705     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 706
 707     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 708
 709     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 710 }
 711
 712 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateData(ID3D11HullShader *iface,
 713         REFGUID guid, UINT data_size, const void *data)
 714 {
 715     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 716
 717     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 718
 719     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 720 }
 721
 722 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateDataInterface(ID3D11HullShader *iface,
 723         REFGUID guid, const IUnknown *data)
 724 {
 725     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 726
 727     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 728
 729     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 730 }
 731
 732 static const struct ID3D11HullShaderVtbl d3d11_hull_shader_vtbl =
 733 {
 734     /* IUnknown methods */
 735     d3d11_hull_shader_QueryInterface,
 736     d3d11_hull_shader_AddRef,
 737     d3d11_hull_shader_Release,
 738     /* ID3D11DeviceChild methods */
 739     d3d11_hull_shader_GetDevice,
 740     d3d11_hull_shader_GetPrivateData,
 741     d3d11_hull_shader_SetPrivateData,
 742     d3d11_hull_shader_SetPrivateDataInterface,
 743 };
 744
 745 static void STDMETHODCALLTYPE d3d11_hull_shader_wined3d_object_destroyed(void *parent)
 746 {
 747     struct d3d11_hull_shader *shader = parent;
 748
 749     wined3d_private_store_cleanup(&shader->private_store);
 750     heap_free(parent);
 751 }
 752
 753 static const struct wined3d_parent_ops d3d11_hull_shader_wined3d_parent_ops =
 754 {
 755     d3d11_hull_shader_wined3d_object_destroyed,
 756 };
 757
 758 static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d3d_device *device,
 759         const void *byte_code, SIZE_T byte_code_length)
 760 {
 761     struct wined3d_shader_desc desc;
 762     HRESULT hr;
 763
 764     shader->ID3D11HullShader_iface.lpVtbl = &d3d11_hull_shader_vtbl;
 765     shader->refcount = 1;
 766     wined3d_mutex_lock();
 767     wined3d_private_store_init(&shader->private_store);
 768
 769     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 770     {
 771         WARN("Failed to extract shader, hr %#x.\n", hr);
 772         wined3d_private_store_cleanup(&shader->private_store);
 773         wined3d_mutex_unlock();
 774         return hr;
 775     }
 776     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 777
 778     hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader,
 779             &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader);
 780     free_shader_desc(&desc);
 781     if (FAILED(hr))
 782     {
 783         WARN("Failed to create wined3d hull shader, hr %#x.\n", hr);
 784         wined3d_private_store_cleanup(&shader->private_store);
 785         wined3d_mutex_unlock();
 786         return E_INVALIDARG;
 787     }
 788     wined3d_mutex_unlock();
 789
 790     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
 791
 792     return S_OK;
 793 }
 794
 795 HRESULT d3d11_hull_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 796         struct d3d11_hull_shader **shader)
 797 {
 798     struct d3d11_hull_shader *object;
 799     HRESULT hr;
 800
 801     if (!(object = heap_alloc_zero(sizeof(*object))))
 802         return E_OUTOFMEMORY;
 803
 804     if (FAILED(hr = d3d11_hull_shader_init(object, device, byte_code, byte_code_length)))
 805     {
 806         heap_free(object);
 807         return hr;
 808     }
 809
 810     TRACE("Created hull shader %p.\n", object);
 811     *shader = object;
 812
 813     return S_OK;
 814 }
 815
 816 struct d3d11_hull_shader *unsafe_impl_from_ID3D11HullShader(ID3D11HullShader *iface)
 817 {
 818     if (!iface)
 819         return NULL;
 820     assert(iface->lpVtbl == &d3d11_hull_shader_vtbl);
 821
 822     return impl_from_ID3D11HullShader(iface);
 823 }
 824
 825 /* ID3D11DomainShader methods */
 826
 827 static inline struct d3d11_domain_shader *impl_from_ID3D11DomainShader(ID3D11DomainShader *iface)
 828 {
 829     return CONTAINING_RECORD(iface, struct d3d11_domain_shader, ID3D11DomainShader_iface);
 830 }
 831
 832 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_QueryInterface(ID3D11DomainShader *iface,
 833         REFIID riid, void **object)
 834 {
 835     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 836
 837     if (IsEqualGUID(riid, &IID_ID3D11DomainShader)
 838             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 839             || IsEqualGUID(riid, &IID_IUnknown))
 840     {
 841         ID3D11DomainShader_AddRef(iface);
 842         *object = iface;
 843         return S_OK;
 844     }
 845
 846     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 847
 848     *object = NULL;
 849     return E_NOINTERFACE;
 850 }
 851
 852 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_AddRef(ID3D11DomainShader *iface)
 853 {
 854     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 855     ULONG refcount = InterlockedIncrement(&shader->refcount);
 856
 857     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 858
 859     if (refcount == 1)
 860     {
 861         ID3D11Device2_AddRef(shader->device);
 862         wined3d_mutex_lock();
 863         wined3d_shader_incref(shader->wined3d_shader);
 864         wined3d_mutex_unlock();
 865     }
 866
 867     return refcount;
 868 }
 869
 870 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_Release(ID3D11DomainShader *iface)
 871 {
 872     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 873     ULONG refcount = InterlockedDecrement(&shader->refcount);
 874
 875     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 876
 877     if (!refcount)
 878     {
 879         ID3D11Device2 *device = shader->device;
 880
 881         wined3d_mutex_lock();
 882         wined3d_shader_decref(shader->wined3d_shader);
 883         wined3d_mutex_unlock();
 884
 885         /* Release the device last, it may cause the wined3d device to be
 886          * destroyed. */
 887         ID3D11Device2_Release(device);
 888     }
 889
 890     return refcount;
 891 }
 892
 893 static void STDMETHODCALLTYPE d3d11_domain_shader_GetDevice(ID3D11DomainShader *iface,
 894         ID3D11Device **device)
 895 {
 896     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 897
 898     TRACE("iface %p, device %p.\n", iface, device);
 899
 900     *device = (ID3D11Device *)shader->device;
 901     ID3D11Device_AddRef(*device);
 902 }
 903
 904 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_GetPrivateData(ID3D11DomainShader *iface,
 905         REFGUID guid, UINT *data_size, void *data)
 906 {
 907     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 908
 909     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 910
 911     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 912 }
 913
 914 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateData(ID3D11DomainShader *iface,
 915         REFGUID guid, UINT data_size, const void *data)
 916 {
 917     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 918
 919     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 920
 921     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 922 }
 923
 924 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateDataInterface(ID3D11DomainShader *iface,
 925         REFGUID guid, const IUnknown *data)
 926 {
 927     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 928
 929     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 930
 931     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 932 }
 933
 934 static const struct ID3D11DomainShaderVtbl d3d11_domain_shader_vtbl =
 935 {
 936     /* IUnknown methods */
 937     d3d11_domain_shader_QueryInterface,
 938     d3d11_domain_shader_AddRef,
 939     d3d11_domain_shader_Release,
 940     /* ID3D11DeviceChild methods */
 941     d3d11_domain_shader_GetDevice,
 942     d3d11_domain_shader_GetPrivateData,
 943     d3d11_domain_shader_SetPrivateData,
 944     d3d11_domain_shader_SetPrivateDataInterface,
 945 };
 946
 947 static void STDMETHODCALLTYPE d3d11_domain_shader_wined3d_object_destroyed(void *parent)
 948 {
 949     struct d3d11_domain_shader *shader = parent;
 950
 951     wined3d_private_store_cleanup(&shader->private_store);
 952     heap_free(parent);
 953 }
 954
 955 static const struct wined3d_parent_ops d3d11_domain_shader_wined3d_parent_ops =
 956 {
 957     d3d11_domain_shader_wined3d_object_destroyed,
 958 };
 959
 960 static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, struct d3d_device *device,
 961         const void *byte_code, SIZE_T byte_code_length)
 962 {
 963     struct wined3d_shader_desc desc;
 964     HRESULT hr;
 965
 966     shader->ID3D11DomainShader_iface.lpVtbl = &d3d11_domain_shader_vtbl;
 967     shader->refcount = 1;
 968     wined3d_mutex_lock();
 969     wined3d_private_store_init(&shader->private_store);
 970
 971     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 972     {
 973         WARN("Failed to extract shader, hr %#x.\n", hr);
 974         wined3d_private_store_cleanup(&shader->private_store);
 975         wined3d_mutex_unlock();
 976         return hr;
 977     }
 978     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 979
 980     hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader,
 981             &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader);
 982     free_shader_desc(&desc);
 983     if (FAILED(hr))
 984     {
 985         WARN("Failed to create wined3d domain shader, hr %#x.\n", hr);
 986         wined3d_private_store_cleanup(&shader->private_store);
 987         wined3d_mutex_unlock();
 988         return E_INVALIDARG;
 989     }
 990     wined3d_mutex_unlock();
 991
 992     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
 993
 994     return S_OK;
 995 }
 996
 997 HRESULT d3d11_domain_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 998         struct d3d11_domain_shader **shader)
 999 {
1000     struct d3d11_domain_shader *object;
1001     HRESULT hr;
1002
1003     if (!(object = heap_alloc_zero(sizeof(*object))))
1004         return E_OUTOFMEMORY;
1005
1006     if (FAILED(hr = d3d11_domain_shader_init(object, device, byte_code, byte_code_length)))
1007     {
1008         heap_free(object);
1009         return hr;
1010     }
1011
1012     TRACE("Created domain shader %p.\n", object);
1013     *shader = object;
1014
1015     return S_OK;
1016 }
1017
1018 struct d3d11_domain_shader *unsafe_impl_from_ID3D11DomainShader(ID3D11DomainShader *iface)
1019 {
1020     if (!iface)
1021         return NULL;
1022     assert(iface->lpVtbl == &d3d11_domain_shader_vtbl);
1023
1024     return impl_from_ID3D11DomainShader(iface);
1025 }
1026
1027 /* ID3D11GeometryShader methods */
1028
1029 static inline struct d3d_geometry_shader *impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
1030 {
1031     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D11GeometryShader_iface);
1032 }
1033
1034 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_QueryInterface(ID3D11GeometryShader *iface,
1035         REFIID riid, void **object)
1036 {
1037     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1038
1039     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1040
1041     if (IsEqualGUID(riid, &IID_ID3D11GeometryShader)
1042             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1043             || IsEqualGUID(riid, &IID_IUnknown))
1044     {
1045         ID3D11GeometryShader_AddRef(iface);
1046         *object = iface;
1047         return S_OK;
1048     }
1049
1050     if (IsEqualGUID(riid, &IID_ID3D10GeometryShader)
1051             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1052     {
1053         ID3D10GeometryShader_AddRef(&shader->ID3D10GeometryShader_iface);
1054         *object = &shader->ID3D10GeometryShader_iface;
1055         return S_OK;
1056     }
1057
1058     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1059
1060     *object = NULL;
1061     return E_NOINTERFACE;
1062 }
1063
1064 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_AddRef(ID3D11GeometryShader *iface)
1065 {
1066     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1067     ULONG refcount = InterlockedIncrement(&shader->refcount);
1068
1069     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1070
1071     if (refcount == 1)
1072     {
1073         ID3D11Device2_AddRef(shader->device);
1074         wined3d_mutex_lock();
1075         wined3d_shader_incref(shader->wined3d_shader);
1076         wined3d_mutex_unlock();
1077     }
1078
1079     return refcount;
1080 }
1081
1082 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_Release(ID3D11GeometryShader *iface)
1083 {
1084     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1085     ULONG refcount = InterlockedDecrement(&shader->refcount);
1086
1087     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1088
1089     if (!refcount)
1090     {
1091         ID3D11Device2 *device = shader->device;
1092
1093         wined3d_mutex_lock();
1094         wined3d_shader_decref(shader->wined3d_shader);
1095         wined3d_mutex_unlock();
1096
1097         /* Release the device last, it may cause the wined3d device to be
1098          * destroyed. */
1099         ID3D11Device2_Release(device);
1100     }
1101
1102     return refcount;
1103 }
1104
1105 static void STDMETHODCALLTYPE d3d11_geometry_shader_GetDevice(ID3D11GeometryShader *iface,
1106         ID3D11Device **device)
1107 {
1108     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1109
1110     TRACE("iface %p, device %p.\n", iface, device);
1111
1112     *device = (ID3D11Device *)shader->device;
1113     ID3D11Device_AddRef(*device);
1114 }
1115
1116 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_GetPrivateData(ID3D11GeometryShader *iface,
1117         REFGUID guid, UINT *data_size, void *data)
1118 {
1119     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1120
1121     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1122
1123     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1124 }
1125
1126 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateData(ID3D11GeometryShader *iface,
1127         REFGUID guid, UINT data_size, const void *data)
1128 {
1129     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1130
1131     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1132
1133     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1134 }
1135
1136 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateDataInterface(ID3D11GeometryShader *iface,
1137         REFGUID guid, const IUnknown *data)
1138 {
1139     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1140
1141     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1142
1143     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1144 }
1145
1146 static const struct ID3D11GeometryShaderVtbl d3d11_geometry_shader_vtbl =
1147 {
1148     /* IUnknown methods */
1149     d3d11_geometry_shader_QueryInterface,
1150     d3d11_geometry_shader_AddRef,
1151     d3d11_geometry_shader_Release,
1152     /* ID3D11DeviceChild methods */
1153     d3d11_geometry_shader_GetDevice,
1154     d3d11_geometry_shader_GetPrivateData,
1155     d3d11_geometry_shader_SetPrivateData,
1156     d3d11_geometry_shader_SetPrivateDataInterface,
1157 };
1158
1159 /* ID3D10GeometryShader methods */
1160
1161 static inline struct d3d_geometry_shader *impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
1162 {
1163     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D10GeometryShader_iface);
1164 }
1165
1166 /* IUnknown methods */
1167
1168 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_QueryInterface(ID3D10GeometryShader *iface,
1169         REFIID riid, void **object)
1170 {
1171     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1172
1173     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1174
1175     return d3d11_geometry_shader_QueryInterface(&shader->ID3D11GeometryShader_iface, riid, object);
1176 }
1177
1178 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_AddRef(ID3D10GeometryShader *iface)
1179 {
1180     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1181
1182     TRACE("iface %p.\n", iface);
1183
1184     return d3d11_geometry_shader_AddRef(&shader->ID3D11GeometryShader_iface);
1185 }
1186
1187 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShader *iface)
1188 {
1189     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1190
1191     TRACE("iface %p.\n", iface);
1192
1193     return d3d11_geometry_shader_Release(&shader->ID3D11GeometryShader_iface);
1194 }
1195
1196 /* ID3D10DeviceChild methods */
1197
1198 static void STDMETHODCALLTYPE d3d10_geometry_shader_GetDevice(ID3D10GeometryShader *iface, ID3D10Device **device)
1199 {
1200     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1201
1202     TRACE("iface %p, device %p.\n", iface, device);
1203
1204     ID3D11Device2_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1205 }
1206
1207 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_GetPrivateData(ID3D10GeometryShader *iface,
1208         REFGUID guid, UINT *data_size, void *data)
1209 {
1210     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1211
1212     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1213             iface, debugstr_guid(guid), data_size, data);
1214
1215     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1216 }
1217
1218 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateData(ID3D10GeometryShader *iface,
1219         REFGUID guid, UINT data_size, const void *data)
1220 {
1221     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1222
1223     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1224             iface, debugstr_guid(guid), data_size, data);
1225
1226     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1227 }
1228
1229 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateDataInterface(ID3D10GeometryShader *iface,
1230         REFGUID guid, const IUnknown *data)
1231 {
1232     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1233
1234     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1235
1236     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1237 }
1238
1239 static const struct ID3D10GeometryShaderVtbl d3d10_geometry_shader_vtbl =
1240 {
1241     /* IUnknown methods */
1242     d3d10_geometry_shader_QueryInterface,
1243     d3d10_geometry_shader_AddRef,
1244     d3d10_geometry_shader_Release,
1245     /* ID3D10DeviceChild methods */
1246     d3d10_geometry_shader_GetDevice,
1247     d3d10_geometry_shader_GetPrivateData,
1248     d3d10_geometry_shader_SetPrivateData,
1249     d3d10_geometry_shader_SetPrivateDataInterface,
1250 };
1251
1252 static void STDMETHODCALLTYPE d3d_geometry_shader_wined3d_object_destroyed(void *parent)
1253 {
1254     struct d3d_geometry_shader *shader = parent;
1255
1256     wined3d_private_store_cleanup(&shader->private_store);
1257     heap_free(parent);
1258 }
1259
1260 static const struct wined3d_parent_ops d3d_geometry_shader_wined3d_parent_ops =
1261 {
1262     d3d_geometry_shader_wined3d_object_destroyed,
1263 };
1264
1265 static HRESULT wined3d_so_elements_from_d3d11_so_entries(struct wined3d_stream_output_element *elements,
1266         const D3D11_SO_DECLARATION_ENTRY *entries, unsigned int entry_count,
1267         const unsigned int *buffer_strides, unsigned int buffer_stride_count,
1268         const struct wined3d_shader_signature *os, D3D_FEATURE_LEVEL feature_level)
1269 {
1270     unsigned int i, j, mask;
1271
1272     for (i = 0; i < entry_count; ++i)
1273     {
1274         struct wined3d_stream_output_element *e = &elements[i];
1275         const D3D11_SO_DECLARATION_ENTRY *f = &entries[i];
1276         struct wined3d_shader_signature_element *output;
1277
1278         TRACE("Stream: %u, semantic: %s, semantic idx: %u, start component: %u, "
1279                 "component count %u, output slot %u.\n",
1280                 f->Stream, debugstr_a(f->SemanticName), f->SemanticIndex,
1281                 f->StartComponent, f->ComponentCount, f->OutputSlot);
1282
1283         if (f->Stream >= D3D11_SO_STREAM_COUNT)
1284         {
1285             WARN("Invalid stream %u.\n", f->Stream);
1286             return E_INVALIDARG;
1287         }
1288         if (f->Stream && feature_level < D3D_FEATURE_LEVEL_11_0)
1289         {
1290             WARN("Invalid stream %u for feature level %#x.\n", f->Stream, feature_level);
1291             return E_INVALIDARG;
1292         }
1293         if (f->Stream)
1294         {
1295             FIXME("Streams not implemented yet.\n");
1296             return E_INVALIDARG;
1297         }
1298         if (f->OutputSlot >= D3D11_SO_BUFFER_SLOT_COUNT)
1299         {
1300             WARN("Invalid output slot %u.\n", f->OutputSlot);
1301             return E_INVALIDARG;
1302         }
1303
1304         e->stream_idx = f->Stream;
1305         e->component_idx = f->StartComponent;
1306         e->component_count = f->ComponentCount;
1307         e->output_slot = f->OutputSlot;
1308
1309         if (!f->SemanticName)
1310         {
1311             if (f->SemanticIndex)
1312             {
1313                 WARN("Invalid semantic idx %u for stream output gap.\n", f->SemanticIndex);
1314                 return E_INVALIDARG;
1315             }
1316             if (e->component_idx || !e->component_count)
1317             {
1318                 WARN("Invalid stream output gap %u-%u.\n", e->component_idx, e->component_count);
1319                 return E_INVALIDARG;
1320             }
1321
1322             e->register_idx = WINED3D_STREAM_OUTPUT_GAP;
1323         }
1324         else if ((output = shader_find_signature_element(os, f->SemanticName, f->SemanticIndex, f->Stream)))
1325         {
1326             if (e->component_idx > 3 || e->component_count > 4 || !e->component_count
1327                     || e->component_idx + e->component_count > 4)
1328             {
1329                 WARN("Invalid component range %u-%u.\n", e->component_idx, e->component_count);
1330                 return E_INVALIDARG;
1331             }
1332
1333             for (j = 0; j < 4; ++j)
1334             {
1335                 if ((1u << j) & output->mask)
1336                     break;
1337             }
1338             e->component_idx += j;
1339             mask = ((1u << e->component_count) - 1) << e->component_idx;
1340             if ((output->mask & 0xff & mask) != mask)
1341             {
1342                 WARN("Invalid component range %u-%u (mask %#x), output mask %#x.\n",
1343                         e->component_idx, e->component_count, mask, output->mask & 0xff);
1344                 return E_INVALIDARG;
1345             }
1346
1347             e->register_idx = output->register_idx;
1348             TRACE("Register idx: %u, register component idx %u, register mask %#x.\n",
1349                     e->register_idx, e->component_idx, mask);
1350         }
1351         else
1352         {
1353             WARN("Failed to find output signature element for stream output entry.\n");
1354             return E_INVALIDARG;
1355         }
1356     }
1357
1358     for (i = 0; i < entry_count; ++i)
1359     {
1360         const struct wined3d_stream_output_element *e1 = &elements[i];
1361         if (e1->register_idx == WINED3D_STREAM_OUTPUT_GAP)
1362             continue;
1363
1364         for (j = i + 1; j < entry_count; ++j)
1365         {
1366             const struct wined3d_stream_output_element *e2 = &elements[j];
1367
1368             if (e1->register_idx == e2->register_idx
1369                     && e1->component_idx < e2->component_idx + e2->component_count
1370                     && e1->component_idx + e1->component_count > e2->component_idx)
1371             {
1372                 WARN("Stream output elements %u and %u overlap.\n", i, j);
1373                 return E_INVALIDARG;
1374             }
1375         }
1376     }
1377
1378     for (i = 0; i < D3D11_SO_STREAM_COUNT; ++i)
1379     {
1380         unsigned int current_stride[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1381         unsigned int element_count[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1382         unsigned int gap_count[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1383
1384         for (j = 0; j < entry_count; ++j)
1385         {
1386             const struct wined3d_stream_output_element *e = &elements[j];
1387
1388             if (e->stream_idx != i)
1389                 continue;
1390             current_stride[e->output_slot] += 4 * e->component_count;
1391             ++element_count[e->output_slot];
1392             if (e->register_idx == WINED3D_STREAM_OUTPUT_GAP)
1393                 ++gap_count[e->output_slot];
1394         }
1395
1396         for (j = 0; j < D3D11_SO_BUFFER_SLOT_COUNT; ++j)
1397         {
1398             if (!element_count[j])
1399                 continue;
1400             if (element_count[j] == gap_count[j])
1401             {
1402                 WARN("Stream %u, output slot %u contains only gaps.\n", i, j);
1403                 return E_INVALIDARG;
1404             }
1405             if (buffer_stride_count)
1406             {
1407                 if (buffer_stride_count <= j)
1408                 {
1409                     WARN("Buffer strides are required for all buffer slots.\n");
1410                     return E_INVALIDARG;
1411                 }
1412                 if (buffer_strides[j] < current_stride[j] || buffer_strides[j] % 4)
1413                 {
1414                     WARN("Invalid stride %u for buffer slot %u.\n", buffer_strides[j], j);
1415                     return E_INVALIDARG;
1416                 }
1417             }
1418         }
1419
1420         if (!i && feature_level < D3D_FEATURE_LEVEL_11_0 && element_count[0] != entry_count)
1421         {
1422             for (j = 0; j < ARRAY_SIZE(element_count); ++j)
1423             {
1424                 if (element_count[j] > 1)
1425                 {
1426                     WARN("Only one element per output slot is allowed.\n");
1427                     return E_INVALIDARG;
1428                 }
1429             }
1430         }
1431     }
1432
1433     return S_OK;
1434 }
1435
1436 static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader,
1437         struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1438         const D3D11_SO_DECLARATION_ENTRY *so_entries, unsigned int so_entry_count,
1439         const unsigned int *buffer_strides, unsigned int buffer_stride_count,
1440         unsigned int rasterizer_stream)
1441 {
1442     struct wined3d_stream_output_desc so_desc;
1443     struct wined3d_shader_desc desc;
1444     unsigned int i;
1445     HRESULT hr;
1446
1447     if (so_entry_count > D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT)
1448     {
1449         WARN("Entry count %u is greater than %u.\n",
1450                 so_entry_count, D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT);
1451         return E_INVALIDARG;
1452     }
1453     if (so_entries && !so_entry_count)
1454     {
1455         WARN("Invalid SO entry count %u.\n", so_entry_count);
1456         return E_INVALIDARG;
1457     }
1458     if (rasterizer_stream != D3D11_SO_NO_RASTERIZED_STREAM && rasterizer_stream >= D3D11_SO_STREAM_COUNT)
1459     {
1460         WARN("Invalid rasterizer stream %u.\n", rasterizer_stream);
1461         return E_INVALIDARG;
1462     }
1463     if (device->feature_level < D3D_FEATURE_LEVEL_11_0)
1464     {
1465         if (rasterizer_stream)
1466         {
1467             WARN("Invalid rasterizer stream %u for feature level %#x.\n",
1468                     rasterizer_stream, device->feature_level);
1469             return E_INVALIDARG;
1470         }
1471         if (buffer_stride_count && buffer_stride_count != 1)
1472         {
1473             WARN("Invalid buffer stride count %u for feature level %#x.\n",
1474                     buffer_stride_count, device->feature_level);
1475             return E_INVALIDARG;
1476         }
1477     }
1478
1479     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
1480     {
1481         WARN("Failed to extract shader, hr %#x.\n", hr);
1482         return hr;
1483     }
1484     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1485
1486     memset(&so_desc, 0, sizeof(so_desc));
1487     if (so_entries)
1488     {
1489         so_desc.element_count = so_entry_count;
1490         for (i = 0; i < min(buffer_stride_count, ARRAY_SIZE(so_desc.buffer_strides)); ++i)
1491             so_desc.buffer_strides[i] = buffer_strides[i];
1492         so_desc.buffer_stride_count = buffer_stride_count;
1493         so_desc.rasterizer_stream_idx = rasterizer_stream;
1494
1495         if (!(so_desc.elements = heap_calloc(so_entry_count, sizeof(*so_desc.elements))))
1496         {
1497             ERR("Failed to allocate wined3d stream output element array memory.\n");
1498             free_shader_desc(&desc);
1499             return E_OUTOFMEMORY;
1500         }
1501         if (FAILED(hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements,
1502                 so_entries, so_entry_count, buffer_strides, buffer_stride_count,
1503                 &desc.output_signature, device->feature_level)))
1504         {
1505             heap_free(so_desc.elements);
1506             free_shader_desc(&desc);
1507             return hr;
1508         }
1509     }
1510
1511     shader->ID3D11GeometryShader_iface.lpVtbl = &d3d11_geometry_shader_vtbl;
1512     shader->ID3D10GeometryShader_iface.lpVtbl = &d3d10_geometry_shader_vtbl;
1513     shader->refcount = 1;
1514     wined3d_mutex_lock();
1515     wined3d_private_store_init(&shader->private_store);
1516
1517     hr = wined3d_shader_create_gs(device->wined3d_device, &desc, so_entries ? &so_desc : NULL,
1518             shader, &d3d_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader);
1519     heap_free(so_desc.elements);
1520     free_shader_desc(&desc);
1521     if (FAILED(hr))
1522     {
1523         WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr);
1524         wined3d_private_store_cleanup(&shader->private_store);
1525         wined3d_mutex_unlock();
1526         return E_INVALIDARG;
1527     }
1528     wined3d_mutex_unlock();
1529
1530     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
1531
1532     return S_OK;
1533 }
1534
1535 HRESULT d3d_geometry_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1536         const D3D11_SO_DECLARATION_ENTRY *so_entries, unsigned int so_entry_count,
1537         const unsigned int *buffer_strides, unsigned int buffer_stride_count, unsigned int rasterizer_stream,
1538         struct d3d_geometry_shader **shader)
1539 {
1540     struct d3d_geometry_shader *object;
1541     HRESULT hr;
1542
1543     if (!(object = heap_alloc_zero(sizeof(*object))))
1544         return E_OUTOFMEMORY;
1545
1546     if (FAILED(hr = d3d_geometry_shader_init(object, device, byte_code, byte_code_length,
1547             so_entries, so_entry_count, buffer_strides, buffer_stride_count, rasterizer_stream)))
1548     {
1549         WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
1550         heap_free(object);
1551         return hr;
1552     }
1553
1554     TRACE("Created geometry shader %p.\n", object);
1555     *shader = object;
1556
1557     return S_OK;
1558 }
1559
1560 struct d3d_geometry_shader *unsafe_impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
1561 {
1562     if (!iface)
1563         return NULL;
1564     assert(iface->lpVtbl == &d3d11_geometry_shader_vtbl);
1565
1566     return impl_from_ID3D11GeometryShader(iface);
1567 }
1568
1569 struct d3d_geometry_shader *unsafe_impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
1570 {
1571     if (!iface)
1572         return NULL;
1573     assert(iface->lpVtbl == &d3d10_geometry_shader_vtbl);
1574
1575     return impl_from_ID3D10GeometryShader(iface);
1576 }
1577
1578 /* ID3D11PixelShader methods */
1579
1580 static inline struct d3d_pixel_shader *impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1581 {
1582     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D11PixelShader_iface);
1583 }
1584
1585 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_QueryInterface(ID3D11PixelShader *iface,
1586         REFIID riid, void **object)
1587 {
1588     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1589
1590     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1591
1592     if (IsEqualGUID(riid, &IID_ID3D11PixelShader)
1593             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1594             || IsEqualGUID(riid, &IID_IUnknown))
1595     {
1596         ID3D11PixelShader_AddRef(iface);
1597         *object = iface;
1598         return S_OK;
1599     }
1600
1601     if (IsEqualGUID(riid, &IID_ID3D10PixelShader)
1602             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1603     {
1604         IUnknown_AddRef(&shader->ID3D10PixelShader_iface);
1605         *object = &shader->ID3D10PixelShader_iface;
1606         return S_OK;
1607     }
1608
1609     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1610
1611     *object = NULL;
1612     return E_NOINTERFACE;
1613 }
1614
1615 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_AddRef(ID3D11PixelShader *iface)
1616 {
1617     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1618     ULONG refcount = InterlockedIncrement(&shader->refcount);
1619
1620     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1621
1622     if (refcount == 1)
1623     {
1624         ID3D11Device2_AddRef(shader->device);
1625         wined3d_mutex_lock();
1626         wined3d_shader_incref(shader->wined3d_shader);
1627         wined3d_mutex_unlock();
1628     }
1629
1630     return refcount;
1631 }
1632
1633 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_Release(ID3D11PixelShader *iface)
1634 {
1635     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1636     ULONG refcount = InterlockedDecrement(&shader->refcount);
1637
1638     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1639
1640     if (!refcount)
1641     {
1642         ID3D11Device2 *device = shader->device;
1643
1644         wined3d_mutex_lock();
1645         wined3d_shader_decref(shader->wined3d_shader);
1646         wined3d_mutex_unlock();
1647         /* Release the device last, it may cause the wined3d device to be
1648          * destroyed. */
1649         ID3D11Device2_Release(device);
1650     }
1651
1652     return refcount;
1653 }
1654
1655 static void STDMETHODCALLTYPE d3d11_pixel_shader_GetDevice(ID3D11PixelShader *iface,
1656         ID3D11Device **device)
1657 {
1658     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1659
1660     TRACE("iface %p, device %p.\n", iface, device);
1661
1662     *device = (ID3D11Device *)shader->device;
1663     ID3D11Device_AddRef(*device);
1664 }
1665
1666 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_GetPrivateData(ID3D11PixelShader *iface,
1667         REFGUID guid, UINT *data_size, void *data)
1668 {
1669     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1670
1671     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1672
1673     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1674 }
1675
1676 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateData(ID3D11PixelShader *iface,
1677         REFGUID guid, UINT data_size, const void *data)
1678 {
1679     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1680
1681     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1682
1683     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1684 }
1685
1686 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateDataInterface(ID3D11PixelShader *iface,
1687         REFGUID guid, const IUnknown *data)
1688 {
1689     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1690
1691     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1692
1693     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1694 }
1695
1696 static const struct ID3D11PixelShaderVtbl d3d11_pixel_shader_vtbl =
1697 {
1698     /* IUnknown methods */
1699     d3d11_pixel_shader_QueryInterface,
1700     d3d11_pixel_shader_AddRef,
1701     d3d11_pixel_shader_Release,
1702     /* ID3D11DeviceChild methods */
1703     d3d11_pixel_shader_GetDevice,
1704     d3d11_pixel_shader_GetPrivateData,
1705     d3d11_pixel_shader_SetPrivateData,
1706     d3d11_pixel_shader_SetPrivateDataInterface,
1707 };
1708
1709 /* ID3D10PixelShader methods */
1710
1711 static inline struct d3d_pixel_shader *impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1712 {
1713     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D10PixelShader_iface);
1714 }
1715
1716 /* IUnknown methods */
1717
1718 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_QueryInterface(ID3D10PixelShader *iface,
1719         REFIID riid, void **object)
1720 {
1721     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1722
1723     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1724
1725     return d3d11_pixel_shader_QueryInterface(&shader->ID3D11PixelShader_iface, riid, object);
1726 }
1727
1728 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
1729 {
1730     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1731
1732     TRACE("iface %p.\n", iface);
1733
1734     return d3d11_pixel_shader_AddRef(&shader->ID3D11PixelShader_iface);
1735 }
1736
1737 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *iface)
1738 {
1739     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1740
1741     TRACE("iface %p.\n", iface);
1742
1743     return d3d11_pixel_shader_Release(&shader->ID3D11PixelShader_iface);
1744 }
1745
1746 /* ID3D10DeviceChild methods */
1747
1748 static void STDMETHODCALLTYPE d3d10_pixel_shader_GetDevice(ID3D10PixelShader *iface, ID3D10Device **device)
1749 {
1750     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1751
1752     TRACE("iface %p, device %p.\n", iface, device);
1753
1754     ID3D11Device2_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1755 }
1756
1757 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_GetPrivateData(ID3D10PixelShader *iface,
1758         REFGUID guid, UINT *data_size, void *data)
1759 {
1760     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1761
1762     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1763             iface, debugstr_guid(guid), data_size, data);
1764
1765     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1766 }
1767
1768 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateData(ID3D10PixelShader *iface,
1769         REFGUID guid, UINT data_size, const void *data)
1770 {
1771     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1772
1773     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1774             iface, debugstr_guid(guid), data_size, data);
1775
1776     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1777 }
1778
1779 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateDataInterface(ID3D10PixelShader *iface,
1780         REFGUID guid, const IUnknown *data)
1781 {
1782     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1783
1784     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1785
1786     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1787 }
1788
1789 static const struct ID3D10PixelShaderVtbl d3d10_pixel_shader_vtbl =
1790 {
1791     /* IUnknown methods */
1792     d3d10_pixel_shader_QueryInterface,
1793     d3d10_pixel_shader_AddRef,
1794     d3d10_pixel_shader_Release,
1795     /* ID3D10DeviceChild methods */
1796     d3d10_pixel_shader_GetDevice,
1797     d3d10_pixel_shader_GetPrivateData,
1798     d3d10_pixel_shader_SetPrivateData,
1799     d3d10_pixel_shader_SetPrivateDataInterface,
1800 };
1801
1802 static void STDMETHODCALLTYPE d3d_pixel_shader_wined3d_object_destroyed(void *parent)
1803 {
1804     struct d3d_pixel_shader *shader = parent;
1805
1806     wined3d_private_store_cleanup(&shader->private_store);
1807     heap_free(parent);
1808 }
1809
1810 static const struct wined3d_parent_ops d3d_pixel_shader_wined3d_parent_ops =
1811 {
1812     d3d_pixel_shader_wined3d_object_destroyed,
1813 };
1814
1815 static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d_device *device,
1816         const void *byte_code, SIZE_T byte_code_length)
1817 {
1818     struct wined3d_shader_desc desc;
1819     HRESULT hr;
1820
1821     shader->ID3D11PixelShader_iface.lpVtbl = &d3d11_pixel_shader_vtbl;
1822     shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
1823     shader->refcount = 1;
1824     wined3d_mutex_lock();
1825     wined3d_private_store_init(&shader->private_store);
1826
1827     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
1828     {
1829         WARN("Failed to extract shader, hr %#x.\n", hr);
1830         wined3d_private_store_cleanup(&shader->private_store);
1831         wined3d_mutex_unlock();
1832         return hr;
1833     }
1834     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1835
1836     hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
1837             &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader);
1838     free_shader_desc(&desc);
1839     if (FAILED(hr))
1840     {
1841         WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
1842         wined3d_private_store_cleanup(&shader->private_store);
1843         wined3d_mutex_unlock();
1844         return E_INVALIDARG;
1845     }
1846     wined3d_mutex_unlock();
1847
1848     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
1849
1850     return S_OK;
1851 }
1852
1853 HRESULT d3d_pixel_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1854         struct d3d_pixel_shader **shader)
1855 {
1856     struct d3d_pixel_shader *object;
1857     HRESULT hr;
1858
1859     if (!(object = heap_alloc_zero(sizeof(*object))))
1860         return E_OUTOFMEMORY;
1861
1862     if (FAILED(hr = d3d_pixel_shader_init(object, device, byte_code, byte_code_length)))
1863     {
1864         WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
1865         heap_free(object);
1866         return hr;
1867     }
1868
1869     TRACE("Created pixel shader %p.\n", object);
1870     *shader = object;
1871
1872     return S_OK;
1873 }
1874
1875 struct d3d_pixel_shader *unsafe_impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1876 {
1877     if (!iface)
1878         return NULL;
1879     assert(iface->lpVtbl == &d3d11_pixel_shader_vtbl);
1880
1881     return impl_from_ID3D11PixelShader(iface);
1882 }
1883
1884 struct d3d_pixel_shader *unsafe_impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1885 {
1886     if (!iface)
1887         return NULL;
1888     assert(iface->lpVtbl == &d3d10_pixel_shader_vtbl);
1889
1890     return impl_from_ID3D10PixelShader(iface);
1891 }
1892
1893 /* ID3D11ComputeShader methods */
1894
1895 static inline struct d3d11_compute_shader *impl_from_ID3D11ComputeShader(ID3D11ComputeShader *iface)
1896 {
1897     return CONTAINING_RECORD(iface, struct d3d11_compute_shader, ID3D11ComputeShader_iface);
1898 }
1899
1900 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_QueryInterface(ID3D11ComputeShader *iface,
1901         REFIID riid, void **object)
1902 {
1903     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1904
1905     if (IsEqualGUID(riid, &IID_ID3D11ComputeShader)
1906             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1907             || IsEqualGUID(riid, &IID_IUnknown))
1908     {
1909         ID3D11ComputeShader_AddRef(*object = iface);
1910         return S_OK;
1911     }
1912
1913     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1914
1915     *object = NULL;
1916     return E_NOINTERFACE;
1917 }
1918
1919 static ULONG STDMETHODCALLTYPE d3d11_compute_shader_AddRef(ID3D11ComputeShader *iface)
1920 {
1921     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1922     ULONG refcount = InterlockedIncrement(&shader->refcount);
1923
1924     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1925
1926     if (refcount == 1)
1927     {
1928         ID3D11Device2_AddRef(shader->device);
1929         wined3d_mutex_lock();
1930         wined3d_shader_incref(shader->wined3d_shader);
1931         wined3d_mutex_unlock();
1932     }
1933
1934     return refcount;
1935 }
1936
1937 static ULONG STDMETHODCALLTYPE d3d11_compute_shader_Release(ID3D11ComputeShader *iface)
1938 {
1939     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1940     ULONG refcount = InterlockedDecrement(&shader->refcount);
1941
1942     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1943
1944     if (!refcount)
1945     {
1946         ID3D11Device2 *device = shader->device;
1947
1948         wined3d_mutex_lock();
1949         wined3d_shader_decref(shader->wined3d_shader);
1950         wined3d_mutex_unlock();
1951
1952         /* Release the device last, it may cause the wined3d device to be
1953          * destroyed. */
1954         ID3D11Device2_Release(device);
1955     }
1956
1957     return refcount;
1958 }
1959
1960 static void STDMETHODCALLTYPE d3d11_compute_shader_GetDevice(ID3D11ComputeShader *iface,
1961         ID3D11Device **device)
1962 {
1963     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1964
1965     TRACE("iface %p, device %p.\n", iface, device);
1966
1967     ID3D11Device_AddRef(*device = (ID3D11Device *)shader->device);
1968 }
1969
1970 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_GetPrivateData(ID3D11ComputeShader *iface,
1971         REFGUID guid, UINT *data_size, void *data)
1972 {
1973     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1974
1975     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1976
1977     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1978 }
1979
1980 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_SetPrivateData(ID3D11ComputeShader *iface,
1981         REFGUID guid, UINT data_size, const void *data)
1982 {
1983     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1984
1985     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1986
1987     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1988 }
1989
1990 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_SetPrivateDataInterface(ID3D11ComputeShader *iface,
1991         REFGUID guid, const IUnknown *data)
1992 {
1993     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1994
1995     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1996
1997     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1998 }
1999
2000 static const struct ID3D11ComputeShaderVtbl d3d11_compute_shader_vtbl =
2001 {
2002     /* IUnknown methods */
2003     d3d11_compute_shader_QueryInterface,
2004     d3d11_compute_shader_AddRef,
2005     d3d11_compute_shader_Release,
2006     /* ID3D11DeviceChild methods */
2007     d3d11_compute_shader_GetDevice,
2008     d3d11_compute_shader_GetPrivateData,
2009     d3d11_compute_shader_SetPrivateData,
2010     d3d11_compute_shader_SetPrivateDataInterface,
2011 };
2012
2013 static void STDMETHODCALLTYPE d3d11_compute_shader_wined3d_object_destroyed(void *parent)
2014 {
2015     struct d3d11_compute_shader *shader = parent;
2016
2017     wined3d_private_store_cleanup(&shader->private_store);
2018     heap_free(parent);
2019 }
2020
2021 static const struct wined3d_parent_ops d3d11_compute_shader_wined3d_parent_ops =
2022 {
2023     d3d11_compute_shader_wined3d_object_destroyed,
2024 };
2025
2026 static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, struct d3d_device *device,
2027         const void *byte_code, SIZE_T byte_code_length)
2028 {
2029     struct wined3d_shader_desc desc;
2030     HRESULT hr;
2031
2032     shader->ID3D11ComputeShader_iface.lpVtbl = &d3d11_compute_shader_vtbl;
2033     shader->refcount = 1;
2034     wined3d_mutex_lock();
2035     wined3d_private_store_init(&shader->private_store);
2036
2037     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
2038     {
2039         WARN("Failed to extract shader, hr %#x.\n", hr);
2040         wined3d_private_store_cleanup(&shader->private_store);
2041         wined3d_mutex_unlock();
2042         return hr;
2043     }
2044     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
2045
2046     hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader,
2047             &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader);
2048     free_shader_desc(&desc);
2049     if (FAILED(hr))
2050     {
2051         WARN("Failed to create wined3d compute shader, hr %#x.\n", hr);
2052         wined3d_private_store_cleanup(&shader->private_store);
2053         wined3d_mutex_unlock();
2054         return E_INVALIDARG;
2055     }
2056     wined3d_mutex_unlock();
2057
2058     ID3D11Device2_AddRef(shader->device = &device->ID3D11Device2_iface);
2059
2060     return S_OK;
2061 }
2062
2063 HRESULT d3d11_compute_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
2064         struct d3d11_compute_shader **shader)
2065 {
2066     struct d3d11_compute_shader *object;
2067     HRESULT hr;
2068
2069     if (!(object = heap_alloc_zero(sizeof(*object))))
2070         return E_OUTOFMEMORY;
2071
2072     if (FAILED(hr = d3d11_compute_shader_init(object, device, byte_code, byte_code_length)))
2073     {
2074         heap_free(object);
2075         return hr;
2076     }
2077
2078     TRACE("Created compute shader %p.\n", object);
2079     *shader = object;
2080
2081     return S_OK;
2082 }
2083
2084 struct d3d11_compute_shader *unsafe_impl_from_ID3D11ComputeShader(ID3D11ComputeShader *iface)
2085 {
2086     if (!iface)
2087         return NULL;
2088     assert(iface->lpVtbl == &d3d11_compute_shader_vtbl);
2089
2090     return impl_from_ID3D11ComputeShader(iface);
2091 }
2092
2093 /* ID3D11ClassLinkage methods */
2094
2095 static inline struct d3d11_class_linkage *impl_from_ID3D11ClassLinkage(ID3D11ClassLinkage *iface)
2096 {
2097     return CONTAINING_RECORD(iface, struct d3d11_class_linkage, ID3D11ClassLinkage_iface);
2098 }
2099
2100 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_QueryInterface(ID3D11ClassLinkage *iface,
2101         REFIID riid, void **object)
2102 {
2103     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2104
2105     if (IsEqualGUID(riid, &IID_ID3D11ClassLinkage)
2106             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2107             || IsEqualGUID(riid, &IID_IUnknown))
2108     {
2109         ID3D11ClassLinkage_AddRef(*object = iface);
2110         return S_OK;
2111     }
2112
2113     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2114
2115     *object = NULL;
2116     return E_NOINTERFACE;
2117 }
2118
2119 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_AddRef(ID3D11ClassLinkage *iface)
2120 {
2121     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2122     ULONG refcount = InterlockedIncrement(&class_linkage->refcount);
2123
2124     TRACE("%p increasing refcount to %u.\n", class_linkage, refcount);
2125
2126     return refcount;
2127 }
2128
2129 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_Release(ID3D11ClassLinkage *iface)
2130 {
2131     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2132     ULONG refcount = InterlockedDecrement(&class_linkage->refcount);
2133
2134     TRACE("%p decreasing refcount to %u.\n", class_linkage, refcount);
2135
2136     if (!refcount)
2137     {
2138         ID3D11Device2 *device = class_linkage->device;
2139
2140         wined3d_private_store_cleanup(&class_linkage->private_store);
2141         heap_free(class_linkage);
2142
2143         ID3D11Device2_Release(device);
2144     }
2145
2146     return refcount;
2147 }
2148
2149 static void STDMETHODCALLTYPE d3d11_class_linkage_GetDevice(ID3D11ClassLinkage *iface,
2150         ID3D11Device **device)
2151 {
2152     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2153
2154     TRACE("iface %p, device %p.\n", iface, device);
2155
2156     ID3D11Device_AddRef(*device = (ID3D11Device *)class_linkage->device);
2157 }
2158
2159 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetPrivateData(ID3D11ClassLinkage *iface,
2160         REFGUID guid, UINT *data_size, void *data)
2161 {
2162     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2163
2164     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2165
2166     return d3d_get_private_data(&class_linkage->private_store, guid, data_size, data);
2167 }
2168
2169 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateData(ID3D11ClassLinkage *iface,
2170         REFGUID guid, UINT data_size, const void *data)
2171 {
2172     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2173
2174     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2175
2176     return d3d_set_private_data(&class_linkage->private_store, guid, data_size, data);
2177 }
2178
2179 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateDataInterface(ID3D11ClassLinkage *iface,
2180         REFGUID guid, const IUnknown *data)
2181 {
2182     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2183
2184     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2185
2186     return d3d_set_private_data_interface(&class_linkage->private_store, guid, data);
2187 }
2188
2189 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetClassInstance(ID3D11ClassLinkage *iface,
2190         const char *instance_name, UINT instance_index, ID3D11ClassInstance **class_instance)
2191 {
2192     FIXME("iface %p, instance_name %s, instance_index %u, class_instance %p stub!\n",
2193             iface, debugstr_a(instance_name), instance_index, class_instance);
2194
2195     return E_NOTIMPL;
2196 }
2197
2198 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_CreateClassInstance(ID3D11ClassLinkage *iface,
2199         const char *type_name, UINT cb_offset, UINT cb_vector_offset, UINT texture_offset,
2200         UINT sampler_offset, ID3D11ClassInstance **class_instance)
2201 {
2202     FIXME("iface %p, type_name %s, cb_offset %u, cb_vector_offset %u, texture_offset %u, "
2203             "sampler_offset %u, class_instance %p stub!\n",
2204             iface, debugstr_a(type_name), cb_offset, cb_vector_offset, texture_offset,
2205             sampler_offset, class_instance);
2206
2207     return E_NOTIMPL;
2208 }
2209
2210 static const struct ID3D11ClassLinkageVtbl d3d11_class_linkage_vtbl =
2211 {
2212     /* IUnknown methods */
2213     d3d11_class_linkage_QueryInterface,
2214     d3d11_class_linkage_AddRef,
2215     d3d11_class_linkage_Release,
2216     /* ID3D11DeviceChild methods */
2217     d3d11_class_linkage_GetDevice,
2218     d3d11_class_linkage_GetPrivateData,
2219     d3d11_class_linkage_SetPrivateData,
2220     d3d11_class_linkage_SetPrivateDataInterface,
2221     /* ID3D11ClassLinkage methods */
2222     d3d11_class_linkage_GetClassInstance,
2223     d3d11_class_linkage_CreateClassInstance,
2224 };
2225
2226 HRESULT d3d11_class_linkage_create(struct d3d_device *device, struct d3d11_class_linkage **class_linkage)
2227 {
2228     struct d3d11_class_linkage *object;
2229
2230     if (!(object = heap_alloc_zero(sizeof(*object))))
2231         return E_OUTOFMEMORY;
2232
2233     object->ID3D11ClassLinkage_iface.lpVtbl = &d3d11_class_linkage_vtbl;
2234     object->refcount = 1;
2235     wined3d_private_store_init(&object->private_store);
2236
2237     ID3D11Device2_AddRef(object->device = &device->ID3D11Device2_iface);
2238
2239     TRACE("Created class linkage %p.\n", object);
2240     *class_linkage = object;
2241
2242     return S_OK;
2243 }