dlls/d3d10core/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 "d3d10core_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10core);
  26
  27 static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
  28 {
  29     struct d3d10_shader_info *shader_info = ctx;
  30     HRESULT hr;
  31
  32     switch(tag)
  33     {
  34         case TAG_OSGN:
  35             hr = shader_parse_signature(data, data_size, shader_info->output_signature);
  36             if (FAILED(hr)) return hr;
  37             break;
  38
  39         case TAG_SHDR:
  40             shader_info->shader_code = (const DWORD *)data;
  41             break;
  42
  43         default:
  44             FIXME("Unhandled chunk %s\n", debugstr_an((const char *)&tag, 4));
  45             break;
  46     }
  47
  48     return S_OK;
  49 }
  50
  51 static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length, struct d3d10_shader_info *shader_info)
  52 {
  53     HRESULT hr;
  54
  55     shader_info->shader_code = NULL;
  56     memset(shader_info->output_signature, 0, sizeof(*shader_info->output_signature));
  57
  58     hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, shader_info);
  59     if (!shader_info->shader_code) hr = E_INVALIDARG;
  60
  61     if (FAILED(hr))
  62     {
  63         ERR("Failed to parse shader, hr %#x\n", hr);
  64         shader_free_signature(shader_info->output_signature);
  65     }
  66
  67     return hr;
  68 }
  69
  70 HRESULT shader_parse_signature(const char *data, DWORD data_size, struct wined3d_shader_signature *s)
  71 {
  72     struct wined3d_shader_signature_element *e;
  73     unsigned int string_data_offset;
  74     unsigned int string_data_size;
  75     const char *ptr = data;
  76     char *string_data;
  77     unsigned int i;
  78     DWORD count;
  79
  80     read_dword(&ptr, &count);
  81     TRACE("%u elements\n", count);
  82
  83     skip_dword_unknown(&ptr, 1);
  84
  85     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
  86     if (!e)
  87     {
  88         ERR("Failed to allocate input signature memory.\n");
  89         return E_OUTOFMEMORY;
  90     }
  91
  92     /* 2 DWORDs for the header, 6 for each element. */
  93     string_data_offset = 2 * sizeof(DWORD) + count * 6 * sizeof(DWORD);
  94     string_data_size = data_size - string_data_offset;
  95     string_data = HeapAlloc(GetProcessHeap(), 0, string_data_size);
  96     if (!string_data)
  97     {
  98         ERR("Failed to allocate string data memory.\n");
  99         HeapFree(GetProcessHeap(), 0, e);
 100         return E_OUTOFMEMORY;
 101     }
 102     memcpy(string_data, data + string_data_offset, string_data_size);
 103
 104     for (i = 0; i < count; ++i)
 105     {
 106         UINT name_offset;
 107
 108         read_dword(&ptr, &name_offset);
 109         e[i].semantic_name = string_data + (name_offset - string_data_offset);
 110         read_dword(&ptr, &e[i].semantic_idx);
 111         read_dword(&ptr, &e[i].sysval_semantic);
 112         read_dword(&ptr, &e[i].component_type);
 113         read_dword(&ptr, &e[i].register_idx);
 114         read_dword(&ptr, &e[i].mask);
 115
 116         TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 117                 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
 118                 debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic,
 119                 e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
 120     }
 121
 122     s->elements = e;
 123     s->element_count = count;
 124     s->string_data = string_data;
 125
 126     return S_OK;
 127 }
 128
 129 void shader_free_signature(struct wined3d_shader_signature *s)
 130 {
 131     HeapFree(GetProcessHeap(), 0, s->string_data);
 132     HeapFree(GetProcessHeap(), 0, s->elements);
 133 }
 134
 135 static inline struct d3d10_vertex_shader *impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 136 {
 137     return CONTAINING_RECORD(iface, struct d3d10_vertex_shader, ID3D10VertexShader_iface);
 138 }
 139
 140 /* IUnknown methods */
 141
 142 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_QueryInterface(ID3D10VertexShader *iface,
 143         REFIID riid, void **object)
 144 {
 145     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 146
 147     if (IsEqualGUID(riid, &IID_ID3D10VertexShader)
 148             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 149             || IsEqualGUID(riid, &IID_IUnknown))
 150     {
 151         IUnknown_AddRef(iface);
 152         *object = iface;
 153         return S_OK;
 154     }
 155
 156     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 157
 158     *object = NULL;
 159     return E_NOINTERFACE;
 160 }
 161
 162 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *iface)
 163 {
 164     struct d3d10_vertex_shader *This = impl_from_ID3D10VertexShader(iface);
 165     ULONG refcount = InterlockedIncrement(&This->refcount);
 166
 167     TRACE("%p increasing refcount to %u\n", This, refcount);
 168
 169     if (refcount == 1)
 170     {
 171         ID3D10Device1_AddRef(This->device);
 172         wined3d_shader_incref(This->wined3d_shader);
 173     }
 174
 175     return refcount;
 176 }
 177
 178 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *iface)
 179 {
 180     struct d3d10_vertex_shader *This = impl_from_ID3D10VertexShader(iface);
 181     ULONG refcount = InterlockedDecrement(&This->refcount);
 182
 183     TRACE("%p decreasing refcount to %u\n", This, refcount);
 184
 185     if (!refcount)
 186     {
 187         ID3D10Device1 *device = This->device;
 188
 189         wined3d_shader_decref(This->wined3d_shader);
 190         /* Release the device last, it may cause the wined3d device to be
 191          * destroyed. */
 192         ID3D10Device1_Release(device);
 193     }
 194
 195     return refcount;
 196 }
 197
 198 /* ID3D10DeviceChild methods */
 199
 200 static void STDMETHODCALLTYPE d3d10_vertex_shader_GetDevice(ID3D10VertexShader *iface, ID3D10Device **device)
 201 {
 202     struct d3d10_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 203
 204     TRACE("iface %p, device %p.\n", iface, device);
 205
 206     *device = (ID3D10Device *)shader->device;
 207     ID3D10Device_AddRef(*device);
 208 }
 209
 210 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_GetPrivateData(ID3D10VertexShader *iface,
 211         REFGUID guid, UINT *data_size, void *data)
 212 {
 213     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 214             iface, debugstr_guid(guid), data_size, data);
 215
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateData(ID3D10VertexShader *iface,
 220         REFGUID guid, UINT data_size, const void *data)
 221 {
 222     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 223             iface, debugstr_guid(guid), data_size, data);
 224
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateDataInterface(ID3D10VertexShader *iface,
 229         REFGUID guid, const IUnknown *data)
 230 {
 231     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static const struct ID3D10VertexShaderVtbl d3d10_vertex_shader_vtbl =
 237 {
 238     /* IUnknown methods */
 239     d3d10_vertex_shader_QueryInterface,
 240     d3d10_vertex_shader_AddRef,
 241     d3d10_vertex_shader_Release,
 242     /* ID3D10DeviceChild methods */
 243     d3d10_vertex_shader_GetDevice,
 244     d3d10_vertex_shader_GetPrivateData,
 245     d3d10_vertex_shader_SetPrivateData,
 246     d3d10_vertex_shader_SetPrivateDataInterface,
 247 };
 248
 249 static void STDMETHODCALLTYPE d3d10_vertex_shader_wined3d_object_destroyed(void *parent)
 250 {
 251     struct d3d10_vertex_shader *shader = parent;
 252     shader_free_signature(&shader->output_signature);
 253     HeapFree(GetProcessHeap(), 0, shader);
 254 }
 255
 256 static const struct wined3d_parent_ops d3d10_vertex_shader_wined3d_parent_ops =
 257 {
 258     d3d10_vertex_shader_wined3d_object_destroyed,
 259 };
 260
 261 HRESULT d3d10_vertex_shader_init(struct d3d10_vertex_shader *shader, struct d3d10_device *device,
 262         const void *byte_code, SIZE_T byte_code_length)
 263 {
 264     struct d3d10_shader_info shader_info;
 265     HRESULT hr;
 266
 267     shader->ID3D10VertexShader_iface.lpVtbl = &d3d10_vertex_shader_vtbl;
 268     shader->refcount = 1;
 269
 270     shader_info.output_signature = &shader->output_signature;
 271     hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info);
 272     if (FAILED(hr))
 273     {
 274         ERR("Failed to extract shader, hr %#x.\n", hr);
 275         return hr;
 276     }
 277
 278     hr = wined3d_shader_create_vs(device->wined3d_device, shader_info.shader_code,
 279             &shader->output_signature, shader, &d3d10_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader, 4);
 280     if (FAILED(hr))
 281     {
 282         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 283         shader_free_signature(&shader->output_signature);
 284         hr = E_INVALIDARG;
 285         return hr;
 286     }
 287
 288     shader->device = &device->ID3D10Device1_iface;
 289     ID3D10Device1_AddRef(shader->device);
 290
 291     return S_OK;
 292 }
 293
 294 struct d3d10_vertex_shader *unsafe_impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 295 {
 296     if (!iface)
 297         return NULL;
 298     assert(iface->lpVtbl == &d3d10_vertex_shader_vtbl);
 299
 300     return impl_from_ID3D10VertexShader(iface);
 301 }
 302
 303 static inline struct d3d10_geometry_shader *impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
 304 {
 305     return CONTAINING_RECORD(iface, struct d3d10_geometry_shader, ID3D10GeometryShader_iface);
 306 }
 307
 308 /* IUnknown methods */
 309
 310 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_QueryInterface(ID3D10GeometryShader *iface,
 311         REFIID riid, void **object)
 312 {
 313     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 314
 315     if (IsEqualGUID(riid, &IID_ID3D10GeometryShader)
 316             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 317             || IsEqualGUID(riid, &IID_IUnknown))
 318     {
 319         IUnknown_AddRef(iface);
 320         *object = iface;
 321         return S_OK;
 322     }
 323
 324     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 325
 326     *object = NULL;
 327     return E_NOINTERFACE;
 328 }
 329
 330 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_AddRef(ID3D10GeometryShader *iface)
 331 {
 332     struct d3d10_geometry_shader *This = impl_from_ID3D10GeometryShader(iface);
 333     ULONG refcount = InterlockedIncrement(&This->refcount);
 334
 335     TRACE("%p increasing refcount to %u\n", This, refcount);
 336
 337     return refcount;
 338 }
 339
 340 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShader *iface)
 341 {
 342     struct d3d10_geometry_shader *This = impl_from_ID3D10GeometryShader(iface);
 343     ULONG refcount = InterlockedDecrement(&This->refcount);
 344
 345     TRACE("%p decreasing refcount to %u\n", This, refcount);
 346
 347     if (!refcount)
 348         wined3d_shader_decref(This->wined3d_shader);
 349
 350     return refcount;
 351 }
 352
 353 /* ID3D10DeviceChild methods */
 354
 355 static void STDMETHODCALLTYPE d3d10_geometry_shader_GetDevice(ID3D10GeometryShader *iface, ID3D10Device **device)
 356 {
 357     FIXME("iface %p, device %p stub!\n", iface, device);
 358 }
 359
 360 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_GetPrivateData(ID3D10GeometryShader *iface,
 361         REFGUID guid, UINT *data_size, void *data)
 362 {
 363     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 364             iface, debugstr_guid(guid), data_size, data);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateData(ID3D10GeometryShader *iface,
 370         REFGUID guid, UINT data_size, const void *data)
 371 {
 372     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 373             iface, debugstr_guid(guid), data_size, data);
 374
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateDataInterface(ID3D10GeometryShader *iface,
 379         REFGUID guid, const IUnknown *data)
 380 {
 381     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 382
 383     return E_NOTIMPL;
 384 }
 385
 386 static const struct ID3D10GeometryShaderVtbl d3d10_geometry_shader_vtbl =
 387 {
 388     /* IUnknown methods */
 389     d3d10_geometry_shader_QueryInterface,
 390     d3d10_geometry_shader_AddRef,
 391     d3d10_geometry_shader_Release,
 392     /* ID3D10DeviceChild methods */
 393     d3d10_geometry_shader_GetDevice,
 394     d3d10_geometry_shader_GetPrivateData,
 395     d3d10_geometry_shader_SetPrivateData,
 396     d3d10_geometry_shader_SetPrivateDataInterface,
 397 };
 398
 399 static void STDMETHODCALLTYPE d3d10_geometry_shader_wined3d_object_destroyed(void *parent)
 400 {
 401     struct d3d10_geometry_shader *shader = parent;
 402     shader_free_signature(&shader->output_signature);
 403     HeapFree(GetProcessHeap(), 0, shader);
 404 }
 405
 406 static const struct wined3d_parent_ops d3d10_geometry_shader_wined3d_parent_ops =
 407 {
 408     d3d10_geometry_shader_wined3d_object_destroyed,
 409 };
 410
 411 HRESULT d3d10_geometry_shader_init(struct d3d10_geometry_shader *shader, struct d3d10_device *device,
 412         const void *byte_code, SIZE_T byte_code_length)
 413 {
 414     struct d3d10_shader_info shader_info;
 415     HRESULT hr;
 416
 417     shader->ID3D10GeometryShader_iface.lpVtbl = &d3d10_geometry_shader_vtbl;
 418     shader->refcount = 1;
 419
 420     shader_info.output_signature = &shader->output_signature;
 421     hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info);
 422     if (FAILED(hr))
 423     {
 424         ERR("Failed to extract shader, hr %#x.\n", hr);
 425         return hr;
 426     }
 427
 428     hr = wined3d_shader_create_gs(device->wined3d_device, shader_info.shader_code,
 429             &shader->output_signature, shader, &d3d10_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader, 4);
 430     if (FAILED(hr))
 431     {
 432         WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr);
 433         shader_free_signature(&shader->output_signature);
 434         hr = E_INVALIDARG;
 435         return hr;
 436     }
 437
 438     return S_OK;
 439 }
 440
 441 struct d3d10_geometry_shader *unsafe_impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
 442 {
 443     if (!iface)
 444         return NULL;
 445     assert(iface->lpVtbl == &d3d10_geometry_shader_vtbl);
 446
 447     return impl_from_ID3D10GeometryShader(iface);
 448 }
 449
 450 static inline struct d3d10_pixel_shader *impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
 451 {
 452     return CONTAINING_RECORD(iface, struct d3d10_pixel_shader, ID3D10PixelShader_iface);
 453 }
 454
 455 /* IUnknown methods */
 456
 457 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_QueryInterface(ID3D10PixelShader *iface,
 458         REFIID riid, void **object)
 459 {
 460     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 461
 462     if (IsEqualGUID(riid, &IID_ID3D10PixelShader)
 463             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 464             || IsEqualGUID(riid, &IID_IUnknown))
 465     {
 466         IUnknown_AddRef(iface);
 467         *object = iface;
 468         return S_OK;
 469     }
 470
 471     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 472
 473     *object = NULL;
 474     return E_NOINTERFACE;
 475 }
 476
 477 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
 478 {
 479     struct d3d10_pixel_shader *This = impl_from_ID3D10PixelShader(iface);
 480     ULONG refcount = InterlockedIncrement(&This->refcount);
 481
 482     TRACE("%p increasing refcount to %u\n", This, refcount);
 483
 484     if (refcount == 1)
 485     {
 486         ID3D10Device1_AddRef(This->device);
 487         wined3d_shader_incref(This->wined3d_shader);
 488     }
 489
 490     return refcount;
 491 }
 492
 493 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *iface)
 494 {
 495     struct d3d10_pixel_shader *This = impl_from_ID3D10PixelShader(iface);
 496     ULONG refcount = InterlockedDecrement(&This->refcount);
 497
 498     TRACE("%p decreasing refcount to %u\n", This, refcount);
 499
 500     if (!refcount)
 501     {
 502         ID3D10Device1 *device = This->device;
 503
 504         wined3d_shader_decref(This->wined3d_shader);
 505         /* Release the device last, it may cause the wined3d device to be
 506          * destroyed. */
 507         ID3D10Device1_Release(device);
 508     }
 509
 510     return refcount;
 511 }
 512
 513 /* ID3D10DeviceChild methods */
 514
 515 static void STDMETHODCALLTYPE d3d10_pixel_shader_GetDevice(ID3D10PixelShader *iface, ID3D10Device **device)
 516 {
 517     struct d3d10_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
 518
 519     TRACE("iface %p, device %p.\n", iface, device);
 520
 521     *device = (ID3D10Device *)shader->device;
 522     ID3D10Device_AddRef(*device);
 523 }
 524
 525 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_GetPrivateData(ID3D10PixelShader *iface,
 526         REFGUID guid, UINT *data_size, void *data)
 527 {
 528     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 529             iface, debugstr_guid(guid), data_size, data);
 530
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateData(ID3D10PixelShader *iface,
 535         REFGUID guid, UINT data_size, const void *data)
 536 {
 537     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 538             iface, debugstr_guid(guid), data_size, data);
 539
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateDataInterface(ID3D10PixelShader *iface,
 544         REFGUID guid, const IUnknown *data)
 545 {
 546     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 547
 548     return E_NOTIMPL;
 549 }
 550
 551 static const struct ID3D10PixelShaderVtbl d3d10_pixel_shader_vtbl =
 552 {
 553     /* IUnknown methods */
 554     d3d10_pixel_shader_QueryInterface,
 555     d3d10_pixel_shader_AddRef,
 556     d3d10_pixel_shader_Release,
 557     /* ID3D10DeviceChild methods */
 558     d3d10_pixel_shader_GetDevice,
 559     d3d10_pixel_shader_GetPrivateData,
 560     d3d10_pixel_shader_SetPrivateData,
 561     d3d10_pixel_shader_SetPrivateDataInterface,
 562 };
 563
 564 static void STDMETHODCALLTYPE d3d10_pixel_shader_wined3d_object_destroyed(void *parent)
 565 {
 566     struct d3d10_pixel_shader *shader = parent;
 567     shader_free_signature(&shader->output_signature);
 568     HeapFree(GetProcessHeap(), 0, shader);
 569 }
 570
 571 static const struct wined3d_parent_ops d3d10_pixel_shader_wined3d_parent_ops =
 572 {
 573     d3d10_pixel_shader_wined3d_object_destroyed,
 574 };
 575
 576 HRESULT d3d10_pixel_shader_init(struct d3d10_pixel_shader *shader, struct d3d10_device *device,
 577         const void *byte_code, SIZE_T byte_code_length)
 578 {
 579     struct d3d10_shader_info shader_info;
 580     HRESULT hr;
 581
 582     shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
 583     shader->refcount = 1;
 584
 585     shader_info.output_signature = &shader->output_signature;
 586     hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info);
 587     if (FAILED(hr))
 588     {
 589         ERR("Failed to extract shader, hr %#x.\n", hr);
 590         return hr;
 591     }
 592
 593     hr = wined3d_shader_create_ps(device->wined3d_device, shader_info.shader_code,
 594             &shader->output_signature, shader, &d3d10_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader, 4);
 595     if (FAILED(hr))
 596     {
 597         WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
 598         shader_free_signature(&shader->output_signature);
 599         hr = E_INVALIDARG;
 600         return hr;
 601     }
 602
 603     shader->device = &device->ID3D10Device1_iface;
 604     ID3D10Device1_AddRef(shader->device);
 605
 606     return S_OK;
 607 }
 608
 609 struct d3d10_pixel_shader *unsafe_impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
 610 {
 611     if (!iface)
 612         return NULL;
 613     assert(iface->lpVtbl == &d3d10_pixel_shader_vtbl);
 614
 615     return impl_from_ID3D10PixelShader(iface);
 616 }