dlls/d3d11/device.c

   1 /*
   2  * Copyright 2008-2012 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 #define NONAMELESSUNION
  21 #define WINE_NO_NAMELESS_EXTENSION
  22 #include "d3d11_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  25
  26 static BOOL d3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
  27 {
  28     SIZE_T max_capacity, new_capacity;
  29     void *new_elements;
  30
  31     if (count <= *capacity)
  32         return TRUE;
  33
  34     max_capacity = ~(SIZE_T)0 / size;
  35     if (count > max_capacity)
  36         return FALSE;
  37
  38     new_capacity = max(1, *capacity);
  39     while (new_capacity < count && new_capacity <= max_capacity / 2)
  40         new_capacity *= 2;
  41     if (new_capacity < count)
  42         new_capacity = count;
  43
  44     if (!(new_elements = heap_realloc(*elements, new_capacity * size)))
  45         return FALSE;
  46
  47     *elements = new_elements;
  48     *capacity = new_capacity;
  49     return TRUE;
  50 }
  51
  52 static void STDMETHODCALLTYPE d3d_null_wined3d_object_destroyed(void *parent) {}
  53
  54 static const struct wined3d_parent_ops d3d_null_wined3d_parent_ops =
  55 {
  56     d3d_null_wined3d_object_destroyed,
  57 };
  58
  59 static inline BOOL d3d_device_is_d3d10_active(struct d3d_device *device)
  60 {
  61     return !device->state
  62                 || IsEqualGUID(&device->state->emulated_interface, &IID_ID3D10Device)
  63                 || IsEqualGUID(&device->state->emulated_interface, &IID_ID3D10Device1);
  64 }
  65
  66 static D3D_FEATURE_LEVEL d3d_feature_level_from_wined3d(enum wined3d_feature_level level)
  67 {
  68     return (D3D_FEATURE_LEVEL)level;
  69 }
  70
  71 /* ID3DDeviceContextState methods */
  72
  73 static inline struct d3d_device_context_state *impl_from_ID3DDeviceContextState(ID3DDeviceContextState *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct d3d_device_context_state, ID3DDeviceContextState_iface);
  76 }
  77
  78 static HRESULT STDMETHODCALLTYPE d3d_device_context_state_QueryInterface(ID3DDeviceContextState *iface,
  79         REFIID iid, void **out)
  80 {
  81     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  82
  83     if (IsEqualGUID(iid, &IID_ID3DDeviceContextState)
  84             || IsEqualGUID(iid, &IID_ID3D11DeviceChild)
  85             || IsEqualGUID(iid, &IID_IUnknown))
  86     {
  87         ID3DDeviceContextState_AddRef(iface);
  88         *out = iface;
  89         return S_OK;
  90     }
  91
  92     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  93     *out = NULL;
  94
  95     return E_NOINTERFACE;
  96 }
  97
  98 static ULONG d3d_device_context_state_private_addref(struct d3d_device_context_state *state)
  99 {
 100     ULONG refcount = InterlockedIncrement(&state->private_refcount);
 101
 102     TRACE("%p increasing private refcount to %u.\n", state, refcount);
 103
 104     return refcount;
 105 }
 106
 107 static ULONG STDMETHODCALLTYPE d3d_device_context_state_AddRef(ID3DDeviceContextState *iface)
 108 {
 109     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 110     ULONG refcount = InterlockedIncrement(&state->refcount);
 111
 112     TRACE("%p increasing refcount to %u.\n", state, refcount);
 113
 114     if (refcount == 1)
 115     {
 116         d3d_device_context_state_private_addref(state);
 117         ID3D11Device2_AddRef(state->device);
 118     }
 119
 120     return refcount;
 121 }
 122
 123 static void d3d_device_remove_context_state(struct d3d_device *device, struct d3d_device_context_state *state)
 124 {
 125     unsigned int i;
 126
 127     for (i = 0; i < device->context_state_count; ++i)
 128     {
 129         if (device->context_states[i] != state)
 130             continue;
 131
 132         if (i != device->context_state_count - 1)
 133             device->context_states[i] = device->context_states[device->context_state_count - 1];
 134         --device->context_state_count;
 135         break;
 136     }
 137 }
 138
 139 static void d3d_device_context_state_private_release(struct d3d_device_context_state *state)
 140 {
 141     ULONG refcount = InterlockedDecrement(&state->private_refcount);
 142     struct d3d_device_context_state_entry *entry;
 143     struct d3d_device *device;
 144     unsigned int i;
 145
 146     TRACE("%p decreasing private refcount to %u.\n", state, refcount);
 147
 148     if (!refcount)
 149     {
 150         wined3d_private_store_cleanup(&state->private_store);
 151         for (i = 0; i < state->entry_count; ++i)
 152         {
 153             entry = &state->entries[i];
 154             device = entry->device;
 155
 156             if (entry->wined3d_state != wined3d_device_get_state(device->wined3d_device))
 157                 wined3d_state_destroy(entry->wined3d_state);
 158
 159             d3d_device_remove_context_state(device, state);
 160         }
 161         heap_free(state->entries);
 162         wined3d_device_decref(state->wined3d_device);
 163         heap_free(state);
 164     }
 165 }
 166
 167 static ULONG STDMETHODCALLTYPE d3d_device_context_state_Release(ID3DDeviceContextState *iface)
 168 {
 169     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 170     ULONG refcount = InterlockedDecrement(&state->refcount);
 171
 172     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 173
 174     if (!refcount)
 175     {
 176         ID3D11Device2_Release(state->device);
 177         d3d_device_context_state_private_release(state);
 178     }
 179
 180     return refcount;
 181 }
 182
 183 static void STDMETHODCALLTYPE d3d_device_context_state_GetDevice(ID3DDeviceContextState *iface, ID3D11Device **device)
 184 {
 185     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 186
 187     TRACE("iface %p, device %p.\n", iface, device);
 188
 189     *device = (ID3D11Device *)state->device;
 190     ID3D11Device_AddRef(*device);
 191 }
 192
 193 static HRESULT STDMETHODCALLTYPE d3d_device_context_state_GetPrivateData(ID3DDeviceContextState *iface, REFGUID guid,
 194         UINT *data_size, void *data)
 195 {
 196     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 197
 198     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 199
 200     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 201 }
 202
 203 static HRESULT STDMETHODCALLTYPE d3d_device_context_state_SetPrivateData(ID3DDeviceContextState *iface, REFGUID guid,
 204         UINT data_size, const void *data)
 205 {
 206     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 207
 208     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 209
 210     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 211 }
 212
 213 static HRESULT STDMETHODCALLTYPE d3d_device_context_state_SetPrivateDataInterface(ID3DDeviceContextState *iface,
 214         REFGUID guid, const IUnknown *data)
 215 {
 216     struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface);
 217
 218     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 219
 220     return d3d_set_private_data_interface(&state->private_store, guid, data);
 221 }
 222
 223 static const struct ID3DDeviceContextStateVtbl d3d_device_context_state_vtbl =
 224 {
 225     /* IUnknown methods */
 226     d3d_device_context_state_QueryInterface,
 227     d3d_device_context_state_AddRef,
 228     d3d_device_context_state_Release,
 229     /* ID3D11DeviceChild methods */
 230     d3d_device_context_state_GetDevice,
 231     d3d_device_context_state_GetPrivateData,
 232     d3d_device_context_state_SetPrivateData,
 233     d3d_device_context_state_SetPrivateDataInterface,
 234     /* ID3DDeviceContextState methods */
 235 };
 236
 237 static struct d3d_device_context_state_entry *d3d_device_context_state_get_entry(
 238         struct d3d_device_context_state *state, struct d3d_device *device)
 239 {
 240     unsigned int i;
 241
 242     for (i = 0; i < state->entry_count; ++i)
 243     {
 244         if (state->entries[i].device == device)
 245             return &state->entries[i];
 246     }
 247
 248     return NULL;
 249 }
 250
 251 static BOOL d3d_device_context_state_add_entry(struct d3d_device_context_state *state,
 252         struct d3d_device *device, struct wined3d_state *wined3d_state)
 253 {
 254     struct d3d_device_context_state_entry *entry;
 255
 256     if (!d3d_array_reserve((void **)&state->entries, &state->entries_size,
 257             state->entry_count + 1, sizeof(*state->entries)))
 258         return FALSE;
 259
 260     if (!d3d_array_reserve((void **)&device->context_states, &device->context_states_size,
 261             device->context_state_count + 1, sizeof(*device->context_states)))
 262         return FALSE;
 263
 264     entry = &state->entries[state->entry_count++];
 265     entry->device = device;
 266     entry->wined3d_state = wined3d_state;
 267
 268     device->context_states[device->context_state_count++] = state;
 269
 270     return TRUE;
 271 }
 272
 273 static void d3d_device_context_state_remove_entry(struct d3d_device_context_state *state, struct d3d_device *device)
 274 {
 275     struct d3d_device_context_state_entry *entry;
 276     unsigned int i;
 277
 278     for (i = 0; i < state->entry_count; ++i)
 279     {
 280         entry = &state->entries[i];
 281         if (entry->device != device)
 282             continue;
 283
 284         if (entry->wined3d_state != wined3d_device_get_state(device->wined3d_device))
 285             wined3d_state_destroy(entry->wined3d_state);
 286
 287         if (i != state->entry_count)
 288             state->entries[i] = state->entries[state->entry_count - 1];
 289         --state->entry_count;
 290
 291         break;
 292     }
 293 }
 294
 295 static struct wined3d_state *d3d_device_context_state_get_wined3d_state(struct d3d_device_context_state *state,
 296         struct d3d_device *device)
 297 {
 298     struct d3d_device_context_state_entry *entry;
 299     struct wined3d_state *wined3d_state;
 300
 301     if ((entry = d3d_device_context_state_get_entry(state, device)))
 302         return entry->wined3d_state;
 303
 304     if (FAILED(wined3d_state_create(device->wined3d_device,
 305             (enum wined3d_feature_level *)&state->feature_level, 1, &wined3d_state)))
 306         return NULL;
 307
 308     if (!d3d_device_context_state_add_entry(state, device, wined3d_state))
 309     {
 310         wined3d_state_destroy(wined3d_state);
 311         return NULL;
 312     }
 313
 314     return wined3d_state;
 315 }
 316
 317 static void d3d_device_context_state_init(struct d3d_device_context_state *state,
 318         struct d3d_device *device, D3D_FEATURE_LEVEL feature_level, REFIID emulated_interface)
 319 {
 320     state->ID3DDeviceContextState_iface.lpVtbl = &d3d_device_context_state_vtbl;
 321     state->refcount = state->private_refcount = 0;
 322
 323     wined3d_private_store_init(&state->private_store);
 324
 325     state->feature_level = feature_level;
 326     state->emulated_interface = *emulated_interface;
 327     wined3d_device_incref(state->wined3d_device = device->wined3d_device);
 328     state->device = &device->ID3D11Device2_iface;
 329
 330     d3d_device_context_state_AddRef(&state->ID3DDeviceContextState_iface);
 331 }
 332
 333 /* ID3D11CommandList methods */
 334
 335 static inline struct d3d11_command_list *impl_from_ID3D11CommandList(ID3D11CommandList *iface)
 336 {
 337     return CONTAINING_RECORD(iface, struct d3d11_command_list, ID3D11CommandList_iface);
 338 }
 339
 340 static HRESULT STDMETHODCALLTYPE d3d11_command_list_QueryInterface(ID3D11CommandList *iface, REFIID iid, void **out)
 341 {
 342     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 343
 344     if (IsEqualGUID(iid, &IID_ID3D11CommandList)
 345             || IsEqualGUID(iid, &IID_ID3D11DeviceChild)
 346             || IsEqualGUID(iid, &IID_IUnknown))
 347     {
 348         ID3D11CommandList_AddRef(iface);
 349         *out = iface;
 350         return S_OK;
 351     }
 352
 353     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 354     *out = NULL;
 355
 356     return E_NOINTERFACE;
 357 }
 358
 359 static ULONG STDMETHODCALLTYPE d3d11_command_list_AddRef(ID3D11CommandList *iface)
 360 {
 361     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 362     ULONG refcount = InterlockedIncrement(&list->refcount);
 363
 364     TRACE("%p increasing refcount to %u.\n", list, refcount);
 365
 366     return refcount;
 367 }
 368
 369 static ULONG STDMETHODCALLTYPE d3d11_command_list_Release(ID3D11CommandList *iface)
 370 {
 371     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 372     ULONG refcount = InterlockedDecrement(&list->refcount);
 373
 374     TRACE("%p decreasing refcount to %u.\n", list, refcount);
 375
 376     if (!refcount)
 377     {
 378         wined3d_mutex_lock();
 379         wined3d_command_list_decref(list->wined3d_list);
 380         wined3d_mutex_unlock();
 381         wined3d_private_store_cleanup(&list->private_store);
 382         ID3D11Device2_Release(list->device);
 383         heap_free(list);
 384     }
 385
 386     return refcount;
 387 }
 388
 389 static void STDMETHODCALLTYPE d3d11_command_list_GetDevice(ID3D11CommandList *iface, ID3D11Device **device)
 390 {
 391     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 392
 393     TRACE("iface %p, device %p.\n", iface, device);
 394
 395     *device = (ID3D11Device *)list->device;
 396     ID3D11Device2_AddRef(list->device);
 397 }
 398
 399 static HRESULT STDMETHODCALLTYPE d3d11_command_list_GetPrivateData(ID3D11CommandList *iface, REFGUID guid,
 400         UINT *data_size, void *data)
 401 {
 402     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 403
 404     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 405
 406     return d3d_get_private_data(&list->private_store, guid, data_size, data);
 407 }
 408
 409 static HRESULT STDMETHODCALLTYPE d3d11_command_list_SetPrivateData(ID3D11CommandList *iface, REFGUID guid,
 410         UINT data_size, const void *data)
 411 {
 412     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 413
 414     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 415
 416     return d3d_set_private_data(&list->private_store, guid, data_size, data);
 417 }
 418
 419 static HRESULT STDMETHODCALLTYPE d3d11_command_list_SetPrivateDataInterface(ID3D11CommandList *iface,
 420         REFGUID guid, const IUnknown *data)
 421 {
 422     struct d3d11_command_list *list = impl_from_ID3D11CommandList(iface);
 423
 424     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 425
 426     return d3d_set_private_data_interface(&list->private_store, guid, data);
 427 }
 428
 429 static UINT STDMETHODCALLTYPE d3d11_command_list_GetContextFlags(ID3D11CommandList *iface)
 430 {
 431     TRACE("iface %p.\n", iface);
 432
 433     return 0;
 434 }
 435
 436 static const struct ID3D11CommandListVtbl d3d11_command_list_vtbl =
 437 {
 438     /* IUnknown methods */
 439     d3d11_command_list_QueryInterface,
 440     d3d11_command_list_AddRef,
 441     d3d11_command_list_Release,
 442     /* ID3D11DeviceChild methods */
 443     d3d11_command_list_GetDevice,
 444     d3d11_command_list_GetPrivateData,
 445     d3d11_command_list_SetPrivateData,
 446     d3d11_command_list_SetPrivateDataInterface,
 447     /* ID3D11CommandList methods */
 448     d3d11_command_list_GetContextFlags,
 449 };
 450
 451 static void d3d11_device_context_cleanup(struct d3d11_device_context *context)
 452 {
 453     wined3d_private_store_cleanup(&context->private_store);
 454 }
 455
 456 /* ID3D11DeviceContext - immediate context methods */
 457
 458 static inline struct d3d11_device_context *impl_from_ID3D11DeviceContext1(ID3D11DeviceContext1 *iface)
 459 {
 460     return CONTAINING_RECORD(iface, struct d3d11_device_context, ID3D11DeviceContext1_iface);
 461 }
 462
 463 static HRESULT STDMETHODCALLTYPE d3d11_device_context_QueryInterface(ID3D11DeviceContext1 *iface,
 464         REFIID iid, void **out)
 465 {
 466     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 467
 468     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 469
 470     if (IsEqualGUID(iid, &IID_ID3D11DeviceContext1)
 471             || IsEqualGUID(iid, &IID_ID3D11DeviceContext)
 472             || IsEqualGUID(iid, &IID_ID3D11DeviceChild)
 473             || IsEqualGUID(iid, &IID_IUnknown))
 474     {
 475         *out = &context->ID3D11DeviceContext1_iface;
 476     }
 477     else if (context->type == D3D11_DEVICE_CONTEXT_IMMEDIATE && IsEqualGUID(iid, &IID_ID3D11Multithread))
 478     {
 479         *out = &context->ID3D11Multithread_iface;
 480     }
 481     else
 482     {
 483         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 484         *out = NULL;
 485         return E_NOINTERFACE;
 486     }
 487
 488     ID3D11DeviceContext1_AddRef(iface);
 489     return S_OK;
 490 }
 491
 492 static ULONG STDMETHODCALLTYPE d3d11_device_context_AddRef(ID3D11DeviceContext1 *iface)
 493 {
 494     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 495     ULONG refcount = InterlockedIncrement(&context->refcount);
 496
 497     TRACE("%p increasing refcount to %u.\n", context, refcount);
 498
 499     if (refcount == 1)
 500     {
 501         ID3D11Device2_AddRef(&context->device->ID3D11Device2_iface);
 502     }
 503
 504     return refcount;
 505 }
 506
 507 static ULONG STDMETHODCALLTYPE d3d11_device_context_Release(ID3D11DeviceContext1 *iface)
 508 {
 509     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 510     ULONG refcount = InterlockedDecrement(&context->refcount);
 511
 512     TRACE("%p decreasing refcount to %u.\n", context, refcount);
 513
 514     if (!refcount)
 515     {
 516         if (context->type != D3D11_DEVICE_CONTEXT_IMMEDIATE)
 517         {
 518             wined3d_deferred_context_destroy(context->wined3d_context);
 519             d3d11_device_context_cleanup(context);
 520             heap_free(context);
 521         }
 522         ID3D11Device2_Release(&context->device->ID3D11Device2_iface);
 523     }
 524
 525     return refcount;
 526 }
 527
 528 static void d3d11_device_context_get_constant_buffers(ID3D11DeviceContext1 *iface,
 529         enum wined3d_shader_type type, UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
 530 {
 531     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 532     unsigned int i;
 533
 534     wined3d_mutex_lock();
 535     for (i = 0; i < buffer_count; ++i)
 536     {
 537         struct wined3d_buffer *wined3d_buffer;
 538         struct d3d_buffer *buffer_impl;
 539
 540         if (!(wined3d_buffer = wined3d_device_context_get_constant_buffer(context->wined3d_context,
 541                 type, start_slot + i)))
 542         {
 543             buffers[i] = NULL;
 544             continue;
 545         }
 546
 547         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 548         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
 549         ID3D11Buffer_AddRef(buffers[i]);
 550     }
 551     wined3d_mutex_unlock();
 552 }
 553
 554 static void d3d11_device_context_set_constant_buffers(ID3D11DeviceContext1 *iface,
 555         enum wined3d_shader_type type, UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 556 {
 557     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 558     unsigned int i;
 559
 560     wined3d_mutex_lock();
 561     for (i = 0; i < buffer_count; ++i)
 562     {
 563         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 564
 565         wined3d_device_context_set_constant_buffer(context->wined3d_context, type, start_slot + i,
 566                 buffer ? buffer->wined3d_buffer : NULL);
 567     }
 568     wined3d_mutex_unlock();
 569 }
 570
 571 static void STDMETHODCALLTYPE d3d11_device_context_GetDevice(ID3D11DeviceContext1 *iface, ID3D11Device **device)
 572 {
 573     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 574
 575     TRACE("iface %p, device %p.\n", iface, device);
 576
 577     *device = (ID3D11Device *)&context->device->ID3D11Device2_iface;
 578     ID3D11Device_AddRef(*device);
 579 }
 580
 581 static HRESULT STDMETHODCALLTYPE d3d11_device_context_GetPrivateData(ID3D11DeviceContext1 *iface, REFGUID guid,
 582         UINT *data_size, void *data)
 583 {
 584     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 585
 586     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 587
 588     return d3d_get_private_data(&context->private_store, guid, data_size, data);
 589 }
 590
 591 static HRESULT STDMETHODCALLTYPE d3d11_device_context_SetPrivateData(ID3D11DeviceContext1 *iface, REFGUID guid,
 592         UINT data_size, const void *data)
 593 {
 594     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 595
 596     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 597
 598     return d3d_set_private_data(&context->private_store, guid, data_size, data);
 599 }
 600
 601 static HRESULT STDMETHODCALLTYPE d3d11_device_context_SetPrivateDataInterface(ID3D11DeviceContext1 *iface,
 602         REFGUID guid, const IUnknown *data)
 603 {
 604     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 605
 606     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 607
 608     return d3d_set_private_data_interface(&context->private_store, guid, data);
 609 }
 610
 611 static void STDMETHODCALLTYPE d3d11_device_context_VSSetConstantBuffers(ID3D11DeviceContext1 *iface,
 612         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 613 {
 614     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 615             iface, start_slot, buffer_count, buffers);
 616
 617     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_VERTEX, start_slot,
 618             buffer_count, buffers);
 619 }
 620
 621 static void STDMETHODCALLTYPE d3d11_device_context_PSSetShaderResources(ID3D11DeviceContext1 *iface,
 622         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
 623 {
 624     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 625     unsigned int i;
 626
 627     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
 628             iface, start_slot, view_count, views);
 629
 630     wined3d_mutex_lock();
 631     for (i = 0; i < view_count; ++i)
 632     {
 633         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
 634
 635         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL,
 636                 start_slot + i, view ? view->wined3d_view : NULL);
 637     }
 638     wined3d_mutex_unlock();
 639 }
 640
 641 static void STDMETHODCALLTYPE d3d11_device_context_PSSetShader(ID3D11DeviceContext1 *iface,
 642         ID3D11PixelShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 643 {
 644     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 645     struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D11PixelShader(shader);
 646
 647     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 648             iface, shader, class_instances, class_instance_count);
 649
 650     if (class_instances)
 651         FIXME("Dynamic linking is not implemented yet.\n");
 652
 653     wined3d_mutex_lock();
 654     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL,
 655             ps ? ps->wined3d_shader : NULL);
 656     wined3d_mutex_unlock();
 657 }
 658
 659 static void STDMETHODCALLTYPE d3d11_device_context_PSSetSamplers(ID3D11DeviceContext1 *iface,
 660         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
 661 {
 662     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 663     unsigned int i;
 664
 665     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 666             iface, start_slot, sampler_count, samplers);
 667
 668     wined3d_mutex_lock();
 669     for (i = 0; i < sampler_count; ++i)
 670     {
 671         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
 672
 673         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL, start_slot + i,
 674                 sampler ? sampler->wined3d_sampler : NULL);
 675     }
 676     wined3d_mutex_unlock();
 677 }
 678
 679 static void STDMETHODCALLTYPE d3d11_device_context_VSSetShader(ID3D11DeviceContext1 *iface,
 680         ID3D11VertexShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 681 {
 682     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 683     struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D11VertexShader(shader);
 684
 685     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 686             iface, shader, class_instances, class_instance_count);
 687
 688     if (class_instances)
 689         FIXME("Dynamic linking is not implemented yet.\n");
 690
 691     wined3d_mutex_lock();
 692     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX,
 693             vs ? vs->wined3d_shader : NULL);
 694     wined3d_mutex_unlock();
 695 }
 696
 697 static void STDMETHODCALLTYPE d3d11_device_context_DrawIndexed(ID3D11DeviceContext1 *iface,
 698         UINT index_count, UINT start_index_location, INT base_vertex_location)
 699 {
 700     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 701
 702     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
 703             iface, index_count, start_index_location, base_vertex_location);
 704
 705     wined3d_mutex_lock();
 706     wined3d_device_context_draw_indexed(context->wined3d_context,
 707             base_vertex_location, start_index_location, index_count, 0, 0);
 708     wined3d_mutex_unlock();
 709 }
 710
 711 static void STDMETHODCALLTYPE d3d11_device_context_Draw(ID3D11DeviceContext1 *iface,
 712         UINT vertex_count, UINT start_vertex_location)
 713 {
 714     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 715
 716     TRACE("iface %p, vertex_count %u, start_vertex_location %u.\n",
 717             iface, vertex_count, start_vertex_location);
 718
 719     wined3d_mutex_lock();
 720     wined3d_device_context_draw(context->wined3d_context, start_vertex_location, vertex_count, 0, 0);
 721     wined3d_mutex_unlock();
 722 }
 723
 724 static HRESULT STDMETHODCALLTYPE d3d11_device_context_Map(ID3D11DeviceContext1 *iface, ID3D11Resource *resource,
 725         UINT subresource_idx, D3D11_MAP map_type, UINT map_flags, D3D11_MAPPED_SUBRESOURCE *mapped_subresource)
 726 {
 727     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 728     struct wined3d_resource *wined3d_resource;
 729     struct wined3d_map_desc map_desc;
 730     HRESULT hr;
 731
 732     TRACE("iface %p, resource %p, subresource_idx %u, map_type %u, map_flags %#x, mapped_subresource %p.\n",
 733             iface, resource, subresource_idx, map_type, map_flags, mapped_subresource);
 734
 735     if (map_flags)
 736         FIXME("Ignoring map_flags %#x.\n", map_flags);
 737
 738     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
 739
 740     wined3d_mutex_lock();
 741     hr = wined3d_device_context_map(context->wined3d_context, wined3d_resource, subresource_idx,
 742             &map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type));
 743     wined3d_mutex_unlock();
 744
 745     mapped_subresource->pData = map_desc.data;
 746     mapped_subresource->RowPitch = map_desc.row_pitch;
 747     mapped_subresource->DepthPitch = map_desc.slice_pitch;
 748
 749     return hr;
 750 }
 751
 752 static void STDMETHODCALLTYPE d3d11_device_context_Unmap(ID3D11DeviceContext1 *iface, ID3D11Resource *resource,
 753         UINT subresource_idx)
 754 {
 755     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 756     struct wined3d_resource *wined3d_resource;
 757
 758     TRACE("iface %p, resource %p, subresource_idx %u.\n", iface, resource, subresource_idx);
 759
 760     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
 761
 762     wined3d_mutex_lock();
 763     wined3d_device_context_unmap(context->wined3d_context, wined3d_resource, subresource_idx);
 764     wined3d_mutex_unlock();
 765 }
 766
 767 static void STDMETHODCALLTYPE d3d11_device_context_PSSetConstantBuffers(ID3D11DeviceContext1 *iface,
 768         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 769 {
 770     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 771             iface, start_slot, buffer_count, buffers);
 772
 773     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_PIXEL, start_slot,
 774             buffer_count, buffers);
 775 }
 776
 777 static void STDMETHODCALLTYPE d3d11_device_context_IASetInputLayout(ID3D11DeviceContext1 *iface,
 778         ID3D11InputLayout *input_layout)
 779 {
 780     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 781     struct d3d_input_layout *layout = unsafe_impl_from_ID3D11InputLayout(input_layout);
 782
 783     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
 784
 785     wined3d_mutex_lock();
 786     wined3d_device_context_set_vertex_declaration(context->wined3d_context, layout ? layout->wined3d_decl : NULL);
 787     wined3d_mutex_unlock();
 788 }
 789
 790 static void STDMETHODCALLTYPE d3d11_device_context_IASetVertexBuffers(ID3D11DeviceContext1 *iface,
 791         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers, const UINT *strides, const UINT *offsets)
 792 {
 793     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 794     unsigned int i;
 795
 796     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
 797             iface, start_slot, buffer_count, buffers, strides, offsets);
 798
 799     wined3d_mutex_lock();
 800     for (i = 0; i < buffer_count; ++i)
 801     {
 802         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 803
 804         wined3d_device_context_set_stream_source(context->wined3d_context, start_slot + i,
 805                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
 806     }
 807     wined3d_mutex_unlock();
 808 }
 809
 810 static void STDMETHODCALLTYPE d3d11_device_context_IASetIndexBuffer(ID3D11DeviceContext1 *iface,
 811         ID3D11Buffer *buffer, DXGI_FORMAT format, UINT offset)
 812 {
 813     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 814     struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D11Buffer(buffer);
 815
 816     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
 817             iface, buffer, debug_dxgi_format(format), offset);
 818
 819     wined3d_mutex_lock();
 820     wined3d_device_context_set_index_buffer(context->wined3d_context,
 821             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
 822             wined3dformat_from_dxgi_format(format), offset);
 823     wined3d_mutex_unlock();
 824 }
 825
 826 static void STDMETHODCALLTYPE d3d11_device_context_DrawIndexedInstanced(ID3D11DeviceContext1 *iface,
 827         UINT instance_index_count, UINT instance_count, UINT start_index_location, INT base_vertex_location,
 828         UINT start_instance_location)
 829 {
 830     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 831
 832     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
 833             "base_vertex_location %d, start_instance_location %u.\n",
 834             iface, instance_index_count, instance_count, start_index_location,
 835             base_vertex_location, start_instance_location);
 836
 837     wined3d_mutex_lock();
 838     wined3d_device_context_draw_indexed(context->wined3d_context, base_vertex_location,
 839             start_index_location, instance_index_count, start_instance_location, instance_count);
 840     wined3d_mutex_unlock();
 841 }
 842
 843 static void STDMETHODCALLTYPE d3d11_device_context_DrawInstanced(ID3D11DeviceContext1 *iface,
 844         UINT instance_vertex_count, UINT instance_count, UINT start_vertex_location, UINT start_instance_location)
 845 {
 846     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 847
 848     TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
 849             "start_instance_location %u.\n",
 850             iface, instance_vertex_count, instance_count, start_vertex_location,
 851             start_instance_location);
 852
 853     wined3d_mutex_lock();
 854     wined3d_device_context_draw(context->wined3d_context, start_vertex_location,
 855             instance_vertex_count, start_instance_location, instance_count);
 856     wined3d_mutex_unlock();
 857 }
 858
 859 static void STDMETHODCALLTYPE d3d11_device_context_GSSetConstantBuffers(ID3D11DeviceContext1 *iface,
 860         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 861 {
 862     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 863             iface, start_slot, buffer_count, buffers);
 864
 865     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_GEOMETRY, start_slot,
 866             buffer_count, buffers);
 867 }
 868
 869 static void STDMETHODCALLTYPE d3d11_device_context_GSSetShader(ID3D11DeviceContext1 *iface,
 870         ID3D11GeometryShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 871 {
 872     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 873     struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D11GeometryShader(shader);
 874
 875     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 876             iface, shader, class_instances, class_instance_count);
 877
 878     if (class_instances)
 879         FIXME("Dynamic linking is not implemented yet.\n");
 880
 881     wined3d_mutex_lock();
 882     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY,
 883             gs ? gs->wined3d_shader : NULL);
 884     wined3d_mutex_unlock();
 885 }
 886
 887 static void STDMETHODCALLTYPE d3d11_device_context_IASetPrimitiveTopology(ID3D11DeviceContext1 *iface,
 888         D3D11_PRIMITIVE_TOPOLOGY topology)
 889 {
 890     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 891     enum wined3d_primitive_type primitive_type;
 892     unsigned int patch_vertex_count;
 893
 894     TRACE("iface %p, topology %#x.\n", iface, topology);
 895
 896     wined3d_primitive_type_from_d3d11_primitive_topology(topology, &primitive_type, &patch_vertex_count);
 897
 898     wined3d_mutex_lock();
 899     wined3d_device_context_set_primitive_type(context->wined3d_context, primitive_type, patch_vertex_count);
 900     wined3d_mutex_unlock();
 901 }
 902
 903 static void STDMETHODCALLTYPE d3d11_device_context_VSSetShaderResources(ID3D11DeviceContext1 *iface,
 904         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
 905 {
 906     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 907     unsigned int i;
 908
 909     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
 910
 911     wined3d_mutex_lock();
 912     for (i = 0; i < view_count; ++i)
 913     {
 914         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
 915
 916         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX,
 917                 start_slot + i, view ? view->wined3d_view : NULL);
 918     }
 919     wined3d_mutex_unlock();
 920 }
 921
 922 static void STDMETHODCALLTYPE d3d11_device_context_VSSetSamplers(ID3D11DeviceContext1 *iface,
 923         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
 924 {
 925     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 926     unsigned int i;
 927
 928     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 929             iface, start_slot, sampler_count, samplers);
 930
 931     wined3d_mutex_lock();
 932     for (i = 0; i < sampler_count; ++i)
 933     {
 934         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
 935
 936         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX, start_slot + i,
 937                 sampler ? sampler->wined3d_sampler : NULL);
 938     }
 939     wined3d_mutex_unlock();
 940 }
 941
 942 static void STDMETHODCALLTYPE d3d11_device_context_Begin(ID3D11DeviceContext1 *iface,
 943         ID3D11Asynchronous *asynchronous)
 944 {
 945     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 946     struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
 947
 948     TRACE("iface %p, asynchronous %p.\n", iface, asynchronous);
 949
 950     wined3d_mutex_lock();
 951     wined3d_device_context_issue_query(context->wined3d_context, query->wined3d_query, WINED3DISSUE_BEGIN);
 952     wined3d_mutex_unlock();
 953 }
 954
 955 static void STDMETHODCALLTYPE d3d11_device_context_End(ID3D11DeviceContext1 *iface,
 956         ID3D11Asynchronous *asynchronous)
 957 {
 958     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
 959     struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
 960
 961     TRACE("iface %p, asynchronous %p.\n", iface, asynchronous);
 962
 963     wined3d_mutex_lock();
 964     wined3d_device_context_issue_query(context->wined3d_context, query->wined3d_query, WINED3DISSUE_END);
 965     wined3d_mutex_unlock();
 966 }
 967
 968 static HRESULT STDMETHODCALLTYPE d3d11_device_context_GetData(ID3D11DeviceContext1 *iface,
 969         ID3D11Asynchronous *asynchronous, void *data, UINT data_size, UINT data_flags)
 970 {
 971     struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
 972     unsigned int wined3d_flags;
 973     HRESULT hr;
 974
 975     TRACE("iface %p, asynchronous %p, data %p, data_size %u, data_flags %#x.\n",
 976             iface, asynchronous, data, data_size, data_flags);
 977
 978     if (!data && data_size)
 979         return E_INVALIDARG;
 980
 981     wined3d_flags = wined3d_getdata_flags_from_d3d11_async_getdata_flags(data_flags);
 982
 983     wined3d_mutex_lock();
 984     if (!data_size || wined3d_query_get_data_size(query->wined3d_query) == data_size)
 985     {
 986         hr = wined3d_query_get_data(query->wined3d_query, data, data_size, wined3d_flags);
 987         if (hr == WINED3DERR_INVALIDCALL)
 988             hr = DXGI_ERROR_INVALID_CALL;
 989     }
 990     else
 991     {
 992         WARN("Invalid data size %u.\n", data_size);
 993         hr = E_INVALIDARG;
 994     }
 995     wined3d_mutex_unlock();
 996
 997     return hr;
 998 }
 999
1000 static void STDMETHODCALLTYPE d3d11_device_context_SetPredication(ID3D11DeviceContext1 *iface,
1001         ID3D11Predicate *predicate, BOOL value)
1002 {
1003     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1004     struct d3d_query *query;
1005
1006     TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
1007
1008     query = unsafe_impl_from_ID3D11Query((ID3D11Query *)predicate);
1009
1010     wined3d_mutex_lock();
1011     wined3d_device_context_set_predication(context->wined3d_context, query ? query->wined3d_query : NULL, value);
1012     wined3d_mutex_unlock();
1013 }
1014
1015 static void STDMETHODCALLTYPE d3d11_device_context_GSSetShaderResources(ID3D11DeviceContext1 *iface,
1016         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1017 {
1018     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1019     unsigned int i;
1020
1021     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
1022
1023     wined3d_mutex_lock();
1024     for (i = 0; i < view_count; ++i)
1025     {
1026         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1027
1028         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY,
1029                 start_slot + i, view ? view->wined3d_view : NULL);
1030     }
1031     wined3d_mutex_unlock();
1032 }
1033
1034 static void STDMETHODCALLTYPE d3d11_device_context_GSSetSamplers(ID3D11DeviceContext1 *iface,
1035         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1036 {
1037     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1038     unsigned int i;
1039
1040     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1041             iface, start_slot, sampler_count, samplers);
1042
1043     wined3d_mutex_lock();
1044     for (i = 0; i < sampler_count; ++i)
1045     {
1046         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1047
1048         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i,
1049                 sampler ? sampler->wined3d_sampler : NULL);
1050     }
1051     wined3d_mutex_unlock();
1052 }
1053
1054 static void STDMETHODCALLTYPE d3d11_device_context_OMSetRenderTargets(ID3D11DeviceContext1 *iface,
1055         UINT render_target_view_count, ID3D11RenderTargetView *const *render_target_views,
1056         ID3D11DepthStencilView *depth_stencil_view)
1057 {
1058     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1059     struct d3d_depthstencil_view *dsv;
1060     unsigned int i;
1061
1062     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
1063             iface, render_target_view_count, render_target_views, depth_stencil_view);
1064
1065     wined3d_mutex_lock();
1066     for (i = 0; i < render_target_view_count; ++i)
1067     {
1068         struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D11RenderTargetView(render_target_views[i]);
1069         wined3d_device_context_set_rendertarget_view(context->wined3d_context, i,
1070                 rtv ? rtv->wined3d_view : NULL, FALSE);
1071     }
1072     for (; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
1073     {
1074         wined3d_device_context_set_rendertarget_view(context->wined3d_context, i, NULL, FALSE);
1075     }
1076
1077     dsv = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
1078     wined3d_device_context_set_depth_stencil_view(context->wined3d_context, dsv ? dsv->wined3d_view : NULL);
1079     wined3d_mutex_unlock();
1080 }
1081
1082 static void STDMETHODCALLTYPE d3d11_device_context_OMSetRenderTargetsAndUnorderedAccessViews(
1083         ID3D11DeviceContext1 *iface, UINT render_target_view_count,
1084         ID3D11RenderTargetView *const *render_target_views, ID3D11DepthStencilView *depth_stencil_view,
1085         UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
1086         ID3D11UnorderedAccessView *const *unordered_access_views, const UINT *initial_counts)
1087 {
1088     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1089     unsigned int i;
1090
1091     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
1092             "unordered_access_view_start_slot %u, unordered_access_view_count %u, unordered_access_views %p, "
1093             "initial_counts %p.\n",
1094             iface, render_target_view_count, render_target_views, depth_stencil_view,
1095             unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views,
1096             initial_counts);
1097
1098     if (render_target_view_count != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL)
1099     {
1100         d3d11_device_context_OMSetRenderTargets(iface, render_target_view_count, render_target_views,
1101                 depth_stencil_view);
1102     }
1103
1104     if (unordered_access_view_count != D3D11_KEEP_UNORDERED_ACCESS_VIEWS)
1105     {
1106         wined3d_mutex_lock();
1107         for (i = 0; i < unordered_access_view_start_slot; ++i)
1108         {
1109             wined3d_device_context_set_unordered_access_view(context->wined3d_context,
1110                     WINED3D_PIPELINE_GRAPHICS, i, NULL, ~0u);
1111         }
1112         for (i = 0; i < unordered_access_view_count; ++i)
1113         {
1114             struct d3d11_unordered_access_view *view
1115                     = unsafe_impl_from_ID3D11UnorderedAccessView(unordered_access_views[i]);
1116
1117             wined3d_device_context_set_unordered_access_view(context->wined3d_context,
1118                     WINED3D_PIPELINE_GRAPHICS, unordered_access_view_start_slot + i,
1119                     view ? view->wined3d_view : NULL, initial_counts ? initial_counts[i] : ~0u);
1120         }
1121         for (; unordered_access_view_start_slot + i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i)
1122         {
1123             wined3d_device_context_set_unordered_access_view(context->wined3d_context,
1124                     WINED3D_PIPELINE_GRAPHICS, unordered_access_view_start_slot + i, NULL, ~0u);
1125         }
1126         wined3d_mutex_unlock();
1127     }
1128 }
1129
1130 static void STDMETHODCALLTYPE d3d11_device_context_OMSetBlendState(ID3D11DeviceContext1 *iface,
1131         ID3D11BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
1132 {
1133     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1134     static const float default_blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
1135     struct d3d_blend_state *blend_state_impl;
1136
1137     TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
1138             iface, blend_state, debug_float4(blend_factor), sample_mask);
1139
1140     if (!blend_factor)
1141         blend_factor = default_blend_factor;
1142
1143     wined3d_mutex_lock();
1144     if (!(blend_state_impl = unsafe_impl_from_ID3D11BlendState(blend_state)))
1145         wined3d_device_context_set_blend_state(context->wined3d_context, NULL,
1146                 (const struct wined3d_color *)blend_factor, sample_mask);
1147     else
1148         wined3d_device_context_set_blend_state(context->wined3d_context, blend_state_impl->wined3d_state,
1149                 (const struct wined3d_color *)blend_factor, sample_mask);
1150     wined3d_mutex_unlock();
1151 }
1152
1153 static void STDMETHODCALLTYPE d3d11_device_context_OMSetDepthStencilState(ID3D11DeviceContext1 *iface,
1154         ID3D11DepthStencilState *depth_stencil_state, UINT stencil_ref)
1155 {
1156     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1157     struct d3d_depthstencil_state *state_impl;
1158
1159     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
1160             iface, depth_stencil_state, stencil_ref);
1161
1162     wined3d_mutex_lock();
1163     if (!(state_impl = unsafe_impl_from_ID3D11DepthStencilState(depth_stencil_state)))
1164     {
1165         wined3d_device_context_set_depth_stencil_state(context->wined3d_context, NULL, stencil_ref);
1166         wined3d_mutex_unlock();
1167         return;
1168     }
1169
1170     wined3d_device_context_set_depth_stencil_state(context->wined3d_context, state_impl->wined3d_state, stencil_ref);
1171     wined3d_mutex_unlock();
1172 }
1173
1174 static void STDMETHODCALLTYPE d3d11_device_context_SOSetTargets(ID3D11DeviceContext1 *iface, UINT buffer_count,
1175         ID3D11Buffer *const *buffers, const UINT *offsets)
1176 {
1177     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1178     unsigned int count, i;
1179
1180     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n", iface, buffer_count, buffers, offsets);
1181
1182     count = min(buffer_count, D3D11_SO_BUFFER_SLOT_COUNT);
1183     wined3d_mutex_lock();
1184     for (i = 0; i < count; ++i)
1185     {
1186         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
1187
1188         wined3d_device_context_set_stream_output(context->wined3d_context, i,
1189                 buffer ? buffer->wined3d_buffer : NULL, offsets ? offsets[i] : 0);
1190     }
1191     for (; i < D3D11_SO_BUFFER_SLOT_COUNT; ++i)
1192     {
1193         wined3d_device_context_set_stream_output(context->wined3d_context, i, NULL, 0);
1194     }
1195     wined3d_mutex_unlock();
1196 }
1197
1198 static void STDMETHODCALLTYPE d3d11_device_context_DrawAuto(ID3D11DeviceContext1 *iface)
1199 {
1200     FIXME("iface %p stub!\n", iface);
1201 }
1202
1203 static void STDMETHODCALLTYPE d3d11_device_context_DrawIndexedInstancedIndirect(ID3D11DeviceContext1 *iface,
1204         ID3D11Buffer *buffer, UINT offset)
1205 {
1206     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1207     struct d3d_buffer *d3d_buffer;
1208
1209     TRACE("iface %p, buffer %p, offset %u.\n", iface, buffer, offset);
1210
1211     d3d_buffer = unsafe_impl_from_ID3D11Buffer(buffer);
1212
1213     wined3d_mutex_lock();
1214     wined3d_device_context_draw_indirect(context->wined3d_context, d3d_buffer->wined3d_buffer, offset, true);
1215     wined3d_mutex_unlock();
1216 }
1217
1218 static void STDMETHODCALLTYPE d3d11_device_context_DrawInstancedIndirect(ID3D11DeviceContext1 *iface,
1219         ID3D11Buffer *buffer, UINT offset)
1220 {
1221     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1222     struct d3d_buffer *d3d_buffer;
1223
1224     TRACE("iface %p, buffer %p, offset %u.\n", iface, buffer, offset);
1225
1226     d3d_buffer = unsafe_impl_from_ID3D11Buffer(buffer);
1227
1228     wined3d_mutex_lock();
1229     wined3d_device_context_draw_indirect(context->wined3d_context, d3d_buffer->wined3d_buffer, offset, false);
1230     wined3d_mutex_unlock();
1231 }
1232
1233 static void STDMETHODCALLTYPE d3d11_device_context_Dispatch(ID3D11DeviceContext1 *iface,
1234         UINT thread_group_count_x, UINT thread_group_count_y, UINT thread_group_count_z)
1235 {
1236     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1237
1238     TRACE("iface %p, thread_group_count_x %u, thread_group_count_y %u, thread_group_count_z %u.\n",
1239             iface, thread_group_count_x, thread_group_count_y, thread_group_count_z);
1240
1241     wined3d_mutex_lock();
1242     wined3d_device_context_dispatch(context->wined3d_context,
1243             thread_group_count_x, thread_group_count_y, thread_group_count_z);
1244     wined3d_mutex_unlock();
1245 }
1246
1247 static void STDMETHODCALLTYPE d3d11_device_context_DispatchIndirect(ID3D11DeviceContext1 *iface,
1248         ID3D11Buffer *buffer, UINT offset)
1249 {
1250     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1251     struct d3d_buffer *buffer_impl;
1252
1253     TRACE("iface %p, buffer %p, offset %u.\n", iface, buffer, offset);
1254
1255     buffer_impl = unsafe_impl_from_ID3D11Buffer(buffer);
1256
1257     wined3d_mutex_lock();
1258     wined3d_device_context_dispatch_indirect(context->wined3d_context, buffer_impl->wined3d_buffer, offset);
1259     wined3d_mutex_unlock();
1260 }
1261
1262 static void STDMETHODCALLTYPE d3d11_device_context_RSSetState(ID3D11DeviceContext1 *iface,
1263         ID3D11RasterizerState *rasterizer_state)
1264 {
1265     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1266     struct d3d_rasterizer_state *rasterizer_state_impl;
1267
1268     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
1269
1270     wined3d_mutex_lock();
1271     rasterizer_state_impl = unsafe_impl_from_ID3D11RasterizerState(rasterizer_state);
1272     wined3d_device_context_set_rasterizer_state(context->wined3d_context,
1273             rasterizer_state_impl ? rasterizer_state_impl->wined3d_state : NULL);
1274     wined3d_mutex_unlock();
1275 }
1276
1277 static void STDMETHODCALLTYPE d3d11_device_context_RSSetViewports(ID3D11DeviceContext1 *iface,
1278         UINT viewport_count, const D3D11_VIEWPORT *viewports)
1279 {
1280     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1281     struct wined3d_viewport wined3d_vp[WINED3D_MAX_VIEWPORTS];
1282     unsigned int i;
1283
1284     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
1285
1286     if (viewport_count > ARRAY_SIZE(wined3d_vp))
1287         return;
1288
1289     for (i = 0; i < viewport_count; ++i)
1290     {
1291         wined3d_vp[i].x = viewports[i].TopLeftX;
1292         wined3d_vp[i].y = viewports[i].TopLeftY;
1293         wined3d_vp[i].width = viewports[i].Width;
1294         wined3d_vp[i].height = viewports[i].Height;
1295         wined3d_vp[i].min_z = viewports[i].MinDepth;
1296         wined3d_vp[i].max_z = viewports[i].MaxDepth;
1297     }
1298
1299     wined3d_mutex_lock();
1300     wined3d_device_context_set_viewports(context->wined3d_context, viewport_count, wined3d_vp);
1301     wined3d_mutex_unlock();
1302 }
1303
1304 static void STDMETHODCALLTYPE d3d11_device_context_RSSetScissorRects(ID3D11DeviceContext1 *iface,
1305         UINT rect_count, const D3D11_RECT *rects)
1306 {
1307     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1308
1309     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
1310
1311     if (rect_count > WINED3D_MAX_VIEWPORTS)
1312         return;
1313
1314     wined3d_mutex_lock();
1315     wined3d_device_context_set_scissor_rects(context->wined3d_context, rect_count, rects);
1316     wined3d_mutex_unlock();
1317 }
1318
1319 static void STDMETHODCALLTYPE d3d11_device_context_CopySubresourceRegion(ID3D11DeviceContext1 *iface,
1320         ID3D11Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
1321         ID3D11Resource *src_resource, UINT src_subresource_idx, const D3D11_BOX *src_box)
1322 {
1323     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1324     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
1325     struct wined3d_box wined3d_src_box;
1326
1327     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
1328             "src_resource %p, src_subresource_idx %u, src_box %p.\n",
1329             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
1330             src_resource, src_subresource_idx, src_box);
1331
1332     if (!dst_resource || !src_resource)
1333         return;
1334
1335     if (src_box)
1336         wined3d_box_set(&wined3d_src_box, src_box->left, src_box->top,
1337                 src_box->right, src_box->bottom, src_box->front, src_box->back);
1338
1339     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
1340     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
1341     wined3d_mutex_lock();
1342     wined3d_device_context_copy_sub_resource_region(context->wined3d_context, wined3d_dst_resource, dst_subresource_idx,
1343             dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL, 0);
1344     wined3d_mutex_unlock();
1345 }
1346
1347 static void STDMETHODCALLTYPE d3d11_device_context_CopyResource(ID3D11DeviceContext1 *iface,
1348         ID3D11Resource *dst_resource, ID3D11Resource *src_resource)
1349 {
1350     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1351     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
1352
1353     TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
1354
1355     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
1356     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
1357     wined3d_mutex_lock();
1358     wined3d_device_context_copy_resource(context->wined3d_context, wined3d_dst_resource, wined3d_src_resource);
1359     wined3d_mutex_unlock();
1360 }
1361
1362 static void STDMETHODCALLTYPE d3d11_device_context_UpdateSubresource(ID3D11DeviceContext1 *iface,
1363         ID3D11Resource *resource, UINT subresource_idx, const D3D11_BOX *box,
1364         const void *data, UINT row_pitch, UINT depth_pitch)
1365 {
1366     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1367     struct wined3d_resource *wined3d_resource;
1368     struct wined3d_box wined3d_box;
1369
1370     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
1371             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
1372
1373     if (box)
1374         wined3d_box_set(&wined3d_box, box->left, box->top, box->right, box->bottom, box->front, box->back);
1375
1376     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
1377     wined3d_mutex_lock();
1378     wined3d_device_context_update_sub_resource(context->wined3d_context, wined3d_resource,
1379             subresource_idx, box ? &wined3d_box : NULL, data, row_pitch, depth_pitch, 0);
1380     wined3d_mutex_unlock();
1381 }
1382
1383 static void STDMETHODCALLTYPE d3d11_device_context_CopyStructureCount(ID3D11DeviceContext1 *iface,
1384         ID3D11Buffer *dst_buffer, UINT dst_offset, ID3D11UnorderedAccessView *src_view)
1385 {
1386     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1387     struct d3d11_unordered_access_view *uav;
1388     struct d3d_buffer *buffer_impl;
1389
1390     TRACE("iface %p, dst_buffer %p, dst_offset %u, src_view %p.\n",
1391             iface, dst_buffer, dst_offset, src_view);
1392
1393     buffer_impl = unsafe_impl_from_ID3D11Buffer(dst_buffer);
1394     uav = unsafe_impl_from_ID3D11UnorderedAccessView(src_view);
1395
1396     wined3d_mutex_lock();
1397     wined3d_device_context_copy_uav_counter(context->wined3d_context,
1398             buffer_impl->wined3d_buffer, dst_offset, uav->wined3d_view);
1399     wined3d_mutex_unlock();
1400 }
1401
1402 static void STDMETHODCALLTYPE d3d11_device_context_ClearRenderTargetView(ID3D11DeviceContext1 *iface,
1403         ID3D11RenderTargetView *render_target_view, const float color_rgba[4])
1404 {
1405     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1406     struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D11RenderTargetView(render_target_view);
1407     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
1408     HRESULT hr;
1409
1410     TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
1411             iface, render_target_view, debug_float4(color_rgba));
1412
1413     if (!view)
1414         return;
1415
1416     wined3d_mutex_lock();
1417     if (FAILED(hr = wined3d_device_context_clear_rendertarget_view(context->wined3d_context, view->wined3d_view, NULL,
1418             WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
1419         ERR("Failed to clear view, hr %#x.\n", hr);
1420     wined3d_mutex_unlock();
1421 }
1422
1423 static void STDMETHODCALLTYPE d3d11_device_context_ClearUnorderedAccessViewUint(ID3D11DeviceContext1 *iface,
1424         ID3D11UnorderedAccessView *unordered_access_view, const UINT values[4])
1425 {
1426     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1427     struct d3d11_unordered_access_view *view;
1428
1429     TRACE("iface %p, unordered_access_view %p, values {%u, %u, %u, %u}.\n",
1430             iface, unordered_access_view, values[0], values[1], values[2], values[3]);
1431
1432     view = unsafe_impl_from_ID3D11UnorderedAccessView(unordered_access_view);
1433     wined3d_mutex_lock();
1434     wined3d_device_context_clear_uav_uint(context->wined3d_context,
1435             view->wined3d_view, (const struct wined3d_uvec4 *)values);
1436     wined3d_mutex_unlock();
1437 }
1438
1439 static void STDMETHODCALLTYPE d3d11_device_context_ClearUnorderedAccessViewFloat(ID3D11DeviceContext1 *iface,
1440         ID3D11UnorderedAccessView *unordered_access_view, const float values[4])
1441 {
1442     FIXME("iface %p, unordered_access_view %p, values %s stub!\n",
1443             iface, unordered_access_view, debug_float4(values));
1444 }
1445
1446 static void STDMETHODCALLTYPE d3d11_device_context_ClearDepthStencilView(ID3D11DeviceContext1 *iface,
1447         ID3D11DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
1448 {
1449     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1450     struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
1451     DWORD wined3d_flags;
1452     HRESULT hr;
1453
1454     TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
1455             iface, depth_stencil_view, flags, depth, stencil);
1456
1457     if (!view)
1458         return;
1459
1460     wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
1461
1462     wined3d_mutex_lock();
1463     if (FAILED(hr = wined3d_device_context_clear_rendertarget_view(context->wined3d_context, view->wined3d_view, NULL,
1464             wined3d_flags, NULL, depth, stencil)))
1465         ERR("Failed to clear view, hr %#x.\n", hr);
1466     wined3d_mutex_unlock();
1467 }
1468
1469 static void STDMETHODCALLTYPE d3d11_device_context_GenerateMips(ID3D11DeviceContext1 *iface,
1470         ID3D11ShaderResourceView *view)
1471 {
1472     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1473     struct d3d_shader_resource_view *srv = unsafe_impl_from_ID3D11ShaderResourceView(view);
1474
1475     TRACE("iface %p, view %p.\n", iface, view);
1476
1477     wined3d_mutex_lock();
1478     wined3d_device_context_generate_mipmaps(context->wined3d_context, srv->wined3d_view);
1479     wined3d_mutex_unlock();
1480 }
1481
1482 static void STDMETHODCALLTYPE d3d11_device_context_SetResourceMinLOD(ID3D11DeviceContext1 *iface,
1483         ID3D11Resource *resource, FLOAT min_lod)
1484 {
1485     FIXME("iface %p, resource %p, min_lod %f stub!\n", iface, resource, min_lod);
1486 }
1487
1488 static FLOAT STDMETHODCALLTYPE d3d11_device_context_GetResourceMinLOD(ID3D11DeviceContext1 *iface,
1489         ID3D11Resource *resource)
1490 {
1491     FIXME("iface %p, resource %p stub!\n", iface, resource);
1492
1493     return 0.0f;
1494 }
1495
1496 static void STDMETHODCALLTYPE d3d11_device_context_ResolveSubresource(ID3D11DeviceContext1 *iface,
1497         ID3D11Resource *dst_resource, UINT dst_subresource_idx,
1498         ID3D11Resource *src_resource, UINT src_subresource_idx,
1499         DXGI_FORMAT format)
1500 {
1501     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1502     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
1503     enum wined3d_format_id wined3d_format;
1504
1505     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, "
1506             "src_resource %p, src_subresource_idx %u, format %s.\n",
1507             iface, dst_resource, dst_subresource_idx,
1508             src_resource, src_subresource_idx, debug_dxgi_format(format));
1509
1510     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
1511     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
1512     wined3d_format = wined3dformat_from_dxgi_format(format);
1513     wined3d_mutex_lock();
1514     wined3d_device_context_resolve_sub_resource(context->wined3d_context,
1515             wined3d_dst_resource, dst_subresource_idx,
1516             wined3d_src_resource, src_subresource_idx, wined3d_format);
1517     wined3d_mutex_unlock();
1518 }
1519
1520 static void STDMETHODCALLTYPE d3d11_device_context_ExecuteCommandList(ID3D11DeviceContext1 *iface,
1521         ID3D11CommandList *command_list, BOOL restore_state)
1522 {
1523     FIXME("iface %p, command_list %p, restore_state %#x stub!\n", iface, command_list, restore_state);
1524 }
1525
1526 static void STDMETHODCALLTYPE d3d11_device_context_HSSetShaderResources(ID3D11DeviceContext1 *iface,
1527         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1528 {
1529     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1530     unsigned int i;
1531
1532     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1533             iface, start_slot, view_count, views);
1534
1535     wined3d_mutex_lock();
1536     for (i = 0; i < view_count; ++i)
1537     {
1538         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1539
1540         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_HULL,
1541                 start_slot + i, view ? view->wined3d_view : NULL);
1542     }
1543     wined3d_mutex_unlock();
1544 }
1545
1546 static void STDMETHODCALLTYPE d3d11_device_context_HSSetShader(ID3D11DeviceContext1 *iface,
1547         ID3D11HullShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1548 {
1549     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1550     struct d3d11_hull_shader *hs = unsafe_impl_from_ID3D11HullShader(shader);
1551
1552     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1553             iface, shader, class_instances, class_instance_count);
1554
1555     if (class_instances)
1556         FIXME("Dynamic linking is not implemented yet.\n");
1557
1558     wined3d_mutex_lock();
1559     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_HULL,
1560             hs ? hs->wined3d_shader : NULL);
1561     wined3d_mutex_unlock();
1562 }
1563
1564 static void STDMETHODCALLTYPE d3d11_device_context_HSSetSamplers(ID3D11DeviceContext1 *iface,
1565         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1566 {
1567     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1568     unsigned int i;
1569
1570     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1571             iface, start_slot, sampler_count, samplers);
1572
1573     wined3d_mutex_lock();
1574     for (i = 0; i < sampler_count; ++i)
1575     {
1576         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1577
1578         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_HULL, start_slot + i,
1579                 sampler ? sampler->wined3d_sampler : NULL);
1580     }
1581     wined3d_mutex_unlock();
1582 }
1583
1584 static void STDMETHODCALLTYPE d3d11_device_context_HSSetConstantBuffers(ID3D11DeviceContext1 *iface,
1585         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1586 {
1587     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1588             iface, start_slot, buffer_count, buffers);
1589
1590     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_HULL, start_slot,
1591             buffer_count, buffers);
1592 }
1593
1594 static void STDMETHODCALLTYPE d3d11_device_context_DSSetShaderResources(ID3D11DeviceContext1 *iface,
1595         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1596 {
1597     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1598     unsigned int i;
1599
1600     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1601             iface, start_slot, view_count, views);
1602
1603     wined3d_mutex_lock();
1604     for (i = 0; i < view_count; ++i)
1605     {
1606         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1607
1608         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN,
1609                 start_slot + i, view ? view->wined3d_view : NULL);
1610     }
1611     wined3d_mutex_unlock();
1612 }
1613
1614 static void STDMETHODCALLTYPE d3d11_device_context_DSSetShader(ID3D11DeviceContext1 *iface,
1615         ID3D11DomainShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1616 {
1617     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1618     struct d3d11_domain_shader *ds = unsafe_impl_from_ID3D11DomainShader(shader);
1619
1620     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1621             iface, shader, class_instances, class_instance_count);
1622
1623     if (class_instances)
1624         FIXME("Dynamic linking is not implemented yet.\n");
1625
1626     wined3d_mutex_lock();
1627     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN,
1628             ds ? ds->wined3d_shader : NULL);
1629     wined3d_mutex_unlock();
1630 }
1631
1632 static void STDMETHODCALLTYPE d3d11_device_context_DSSetSamplers(ID3D11DeviceContext1 *iface,
1633         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1634 {
1635     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1636     unsigned int i;
1637
1638     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1639             iface, start_slot, sampler_count, samplers);
1640
1641     wined3d_mutex_lock();
1642     for (i = 0; i < sampler_count; ++i)
1643     {
1644         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1645
1646         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN, start_slot + i,
1647                 sampler ? sampler->wined3d_sampler : NULL);
1648     }
1649     wined3d_mutex_unlock();
1650 }
1651
1652 static void STDMETHODCALLTYPE d3d11_device_context_DSSetConstantBuffers(ID3D11DeviceContext1 *iface,
1653         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1654 {
1655     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1656             iface, start_slot, buffer_count, buffers);
1657
1658     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_DOMAIN, start_slot,
1659             buffer_count, buffers);
1660 }
1661
1662 static void STDMETHODCALLTYPE d3d11_device_context_CSSetShaderResources(ID3D11DeviceContext1 *iface,
1663         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1664 {
1665     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1666     unsigned int i;
1667
1668     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1669             iface, start_slot, view_count, views);
1670
1671     wined3d_mutex_lock();
1672     for (i = 0; i < view_count; ++i)
1673     {
1674         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1675
1676         wined3d_device_context_set_shader_resource_view(context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE,
1677                 start_slot + i, view ? view->wined3d_view : NULL);
1678     }
1679     wined3d_mutex_unlock();
1680 }
1681
1682 static void STDMETHODCALLTYPE d3d11_device_context_CSSetUnorderedAccessViews(ID3D11DeviceContext1 *iface,
1683         UINT start_slot, UINT view_count, ID3D11UnorderedAccessView *const *views, const UINT *initial_counts)
1684 {
1685     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1686     unsigned int i;
1687
1688     TRACE("iface %p, start_slot %u, view_count %u, views %p, initial_counts %p.\n",
1689             iface, start_slot, view_count, views, initial_counts);
1690
1691     wined3d_mutex_lock();
1692     for (i = 0; i < view_count; ++i)
1693     {
1694         struct d3d11_unordered_access_view *view = unsafe_impl_from_ID3D11UnorderedAccessView(views[i]);
1695
1696         wined3d_device_context_set_unordered_access_view(context->wined3d_context, WINED3D_PIPELINE_COMPUTE,
1697                 start_slot + i, view ? view->wined3d_view : NULL, initial_counts ? initial_counts[i] : ~0u);
1698     }
1699     wined3d_mutex_unlock();
1700 }
1701
1702 static void STDMETHODCALLTYPE d3d11_device_context_CSSetShader(ID3D11DeviceContext1 *iface,
1703         ID3D11ComputeShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1704 {
1705     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1706     struct d3d11_compute_shader *cs = unsafe_impl_from_ID3D11ComputeShader(shader);
1707
1708     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1709             iface, shader, class_instances, class_instance_count);
1710
1711     if (class_instances)
1712         FIXME("Dynamic linking is not implemented yet.\n");
1713
1714     wined3d_mutex_lock();
1715     wined3d_device_context_set_shader(context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE,
1716             cs ? cs->wined3d_shader : NULL);
1717     wined3d_mutex_unlock();
1718 }
1719
1720 static void STDMETHODCALLTYPE d3d11_device_context_CSSetSamplers(ID3D11DeviceContext1 *iface,
1721         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1722 {
1723     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1724     unsigned int i;
1725
1726     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1727             iface, start_slot, sampler_count, samplers);
1728
1729     wined3d_mutex_lock();
1730     for (i = 0; i < sampler_count; ++i)
1731     {
1732         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1733
1734         wined3d_device_context_set_sampler(context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE, start_slot + i,
1735                 sampler ? sampler->wined3d_sampler : NULL);
1736     }
1737     wined3d_mutex_unlock();
1738 }
1739
1740 static void STDMETHODCALLTYPE d3d11_device_context_CSSetConstantBuffers(ID3D11DeviceContext1 *iface,
1741         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1742 {
1743     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1744             iface, start_slot, buffer_count, buffers);
1745
1746     d3d11_device_context_set_constant_buffers(iface, WINED3D_SHADER_TYPE_COMPUTE, start_slot,
1747             buffer_count, buffers);
1748 }
1749
1750 static void STDMETHODCALLTYPE d3d11_device_context_VSGetConstantBuffers(ID3D11DeviceContext1 *iface,
1751         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1752 {
1753     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1754             iface, start_slot, buffer_count, buffers);
1755
1756     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_VERTEX, start_slot,
1757             buffer_count, buffers);
1758 }
1759
1760 static void STDMETHODCALLTYPE d3d11_device_context_PSGetShaderResources(ID3D11DeviceContext1 *iface,
1761         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1762 {
1763     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1764     unsigned int i;
1765
1766     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1767             iface, start_slot, view_count, views);
1768
1769     wined3d_mutex_lock();
1770     for (i = 0; i < view_count; ++i)
1771     {
1772         struct wined3d_shader_resource_view *wined3d_view;
1773         struct d3d_shader_resource_view *view_impl;
1774
1775         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
1776                 context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL, start_slot + i)))
1777         {
1778             views[i] = NULL;
1779             continue;
1780         }
1781
1782         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1783         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1784         ID3D11ShaderResourceView_AddRef(views[i]);
1785     }
1786     wined3d_mutex_unlock();
1787 }
1788
1789 static void STDMETHODCALLTYPE d3d11_device_context_PSGetShader(ID3D11DeviceContext1 *iface,
1790         ID3D11PixelShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1791 {
1792     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1793     struct wined3d_shader *wined3d_shader;
1794     struct d3d_pixel_shader *shader_impl;
1795
1796     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1797             iface, shader, class_instances, class_instance_count);
1798
1799     if (class_instances || class_instance_count)
1800         FIXME("Dynamic linking not implemented yet.\n");
1801     if (class_instance_count)
1802         *class_instance_count = 0;
1803
1804     wined3d_mutex_lock();
1805     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL)))
1806     {
1807         wined3d_mutex_unlock();
1808         *shader = NULL;
1809         return;
1810     }
1811
1812     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1813     wined3d_mutex_unlock();
1814     *shader = &shader_impl->ID3D11PixelShader_iface;
1815     ID3D11PixelShader_AddRef(*shader);
1816 }
1817
1818 static void STDMETHODCALLTYPE d3d11_device_context_PSGetSamplers(ID3D11DeviceContext1 *iface,
1819         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1820 {
1821     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1822     unsigned int i;
1823
1824     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1825             iface, start_slot, sampler_count, samplers);
1826
1827     wined3d_mutex_lock();
1828     for (i = 0; i < sampler_count; ++i)
1829     {
1830         struct wined3d_sampler *wined3d_sampler;
1831         struct d3d_sampler_state *sampler_impl;
1832
1833         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
1834                 context->wined3d_context, WINED3D_SHADER_TYPE_PIXEL, start_slot + i)))
1835         {
1836             samplers[i] = NULL;
1837             continue;
1838         }
1839
1840         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1841         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1842         ID3D11SamplerState_AddRef(samplers[i]);
1843     }
1844     wined3d_mutex_unlock();
1845 }
1846
1847 static void STDMETHODCALLTYPE d3d11_device_context_VSGetShader(ID3D11DeviceContext1 *iface,
1848         ID3D11VertexShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1849 {
1850     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1851     struct d3d_vertex_shader *shader_impl;
1852     struct wined3d_shader *wined3d_shader;
1853
1854     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1855             iface, shader, class_instances, class_instance_count);
1856
1857     if (class_instances || class_instance_count)
1858         FIXME("Dynamic linking not implemented yet.\n");
1859     if (class_instance_count)
1860         *class_instance_count = 0;
1861
1862     wined3d_mutex_lock();
1863     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX)))
1864     {
1865         wined3d_mutex_unlock();
1866         *shader = NULL;
1867         return;
1868     }
1869
1870     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1871     wined3d_mutex_unlock();
1872     *shader = &shader_impl->ID3D11VertexShader_iface;
1873     ID3D11VertexShader_AddRef(*shader);
1874 }
1875
1876 static void STDMETHODCALLTYPE d3d11_device_context_PSGetConstantBuffers(ID3D11DeviceContext1 *iface,
1877         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1878 {
1879     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1880             iface, start_slot, buffer_count, buffers);
1881
1882     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_PIXEL, start_slot,
1883             buffer_count, buffers);
1884 }
1885
1886 static void STDMETHODCALLTYPE d3d11_device_context_IAGetInputLayout(ID3D11DeviceContext1 *iface,
1887         ID3D11InputLayout **input_layout)
1888 {
1889     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1890     struct wined3d_vertex_declaration *wined3d_declaration;
1891     struct d3d_input_layout *input_layout_impl;
1892
1893     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
1894
1895     wined3d_mutex_lock();
1896     if (!(wined3d_declaration = wined3d_device_context_get_vertex_declaration(context->wined3d_context)))
1897     {
1898         wined3d_mutex_unlock();
1899         *input_layout = NULL;
1900         return;
1901     }
1902
1903     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
1904     wined3d_mutex_unlock();
1905     *input_layout = &input_layout_impl->ID3D11InputLayout_iface;
1906     ID3D11InputLayout_AddRef(*input_layout);
1907 }
1908
1909 static void STDMETHODCALLTYPE d3d11_device_context_IAGetVertexBuffers(ID3D11DeviceContext1 *iface,
1910         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *strides, UINT *offsets)
1911 {
1912     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1913     unsigned int i;
1914
1915     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
1916             iface, start_slot, buffer_count, buffers, strides, offsets);
1917
1918     wined3d_mutex_lock();
1919     for (i = 0; i < buffer_count; ++i)
1920     {
1921         struct wined3d_buffer *wined3d_buffer = NULL;
1922         struct d3d_buffer *buffer_impl;
1923
1924         if (FAILED(wined3d_device_context_get_stream_source(context->wined3d_context, start_slot + i,
1925                 &wined3d_buffer, &offsets[i], &strides[i])))
1926         {
1927             FIXME("Failed to get vertex buffer %u.\n", start_slot + i);
1928             if (strides)
1929                 strides[i] = 0;
1930             if (offsets)
1931                 offsets[i] = 0;
1932         }
1933
1934         if (!wined3d_buffer)
1935         {
1936             buffers[i] = NULL;
1937             continue;
1938         }
1939
1940         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1941         ID3D11Buffer_AddRef(buffers[i] = &buffer_impl->ID3D11Buffer_iface);
1942     }
1943     wined3d_mutex_unlock();
1944 }
1945
1946 static void STDMETHODCALLTYPE d3d11_device_context_IAGetIndexBuffer(ID3D11DeviceContext1 *iface,
1947         ID3D11Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
1948 {
1949     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1950     enum wined3d_format_id wined3d_format;
1951     struct wined3d_buffer *wined3d_buffer;
1952     struct d3d_buffer *buffer_impl;
1953
1954     TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
1955
1956     wined3d_mutex_lock();
1957     wined3d_buffer = wined3d_device_context_get_index_buffer(context->wined3d_context, &wined3d_format, offset);
1958     *format = dxgi_format_from_wined3dformat(wined3d_format);
1959     if (!wined3d_buffer)
1960     {
1961         wined3d_mutex_unlock();
1962         *buffer = NULL;
1963         return;
1964     }
1965
1966     buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1967     wined3d_mutex_unlock();
1968     ID3D11Buffer_AddRef(*buffer = &buffer_impl->ID3D11Buffer_iface);
1969 }
1970
1971 static void STDMETHODCALLTYPE d3d11_device_context_GSGetConstantBuffers(ID3D11DeviceContext1 *iface,
1972         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1973 {
1974     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1975             iface, start_slot, buffer_count, buffers);
1976
1977     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_GEOMETRY, start_slot,
1978             buffer_count, buffers);
1979 }
1980
1981 static void STDMETHODCALLTYPE d3d11_device_context_GSGetShader(ID3D11DeviceContext1 *iface,
1982         ID3D11GeometryShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1983 {
1984     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
1985     struct d3d_geometry_shader *shader_impl;
1986     struct wined3d_shader *wined3d_shader;
1987
1988     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1989             iface, shader, class_instances, class_instance_count);
1990
1991     if (class_instances || class_instance_count)
1992         FIXME("Dynamic linking not implemented yet.\n");
1993     if (class_instance_count)
1994         *class_instance_count = 0;
1995
1996     wined3d_mutex_lock();
1997     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY)))
1998     {
1999         wined3d_mutex_unlock();
2000         *shader = NULL;
2001         return;
2002     }
2003
2004     shader_impl = wined3d_shader_get_parent(wined3d_shader);
2005     wined3d_mutex_unlock();
2006     *shader = &shader_impl->ID3D11GeometryShader_iface;
2007     ID3D11GeometryShader_AddRef(*shader);
2008 }
2009
2010 static void STDMETHODCALLTYPE d3d11_device_context_IAGetPrimitiveTopology(ID3D11DeviceContext1 *iface,
2011         D3D11_PRIMITIVE_TOPOLOGY *topology)
2012 {
2013     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2014     enum wined3d_primitive_type primitive_type;
2015     unsigned int patch_vertex_count;
2016
2017     TRACE("iface %p, topology %p.\n", iface, topology);
2018
2019     wined3d_mutex_lock();
2020     wined3d_device_context_get_primitive_type(context->wined3d_context, &primitive_type, &patch_vertex_count);
2021     wined3d_mutex_unlock();
2022
2023     d3d11_primitive_topology_from_wined3d_primitive_type(primitive_type, patch_vertex_count, topology);
2024 }
2025
2026 static void STDMETHODCALLTYPE d3d11_device_context_VSGetShaderResources(ID3D11DeviceContext1 *iface,
2027         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2028 {
2029     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2030     unsigned int i;
2031
2032     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2033
2034     wined3d_mutex_lock();
2035     for (i = 0; i < view_count; ++i)
2036     {
2037         struct wined3d_shader_resource_view *wined3d_view;
2038         struct d3d_shader_resource_view *view_impl;
2039
2040         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
2041                 context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX, start_slot + i)))
2042         {
2043             views[i] = NULL;
2044             continue;
2045         }
2046
2047         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2048         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
2049         ID3D11ShaderResourceView_AddRef(views[i]);
2050     }
2051     wined3d_mutex_unlock();
2052 }
2053
2054 static void STDMETHODCALLTYPE d3d11_device_context_VSGetSamplers(ID3D11DeviceContext1 *iface,
2055         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2056 {
2057     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2058     unsigned int i;
2059
2060     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2061             iface, start_slot, sampler_count, samplers);
2062
2063     wined3d_mutex_lock();
2064     for (i = 0; i < sampler_count; ++i)
2065     {
2066         struct wined3d_sampler *wined3d_sampler;
2067         struct d3d_sampler_state *sampler_impl;
2068
2069         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
2070                 context->wined3d_context, WINED3D_SHADER_TYPE_VERTEX, start_slot + i)))
2071         {
2072             samplers[i] = NULL;
2073             continue;
2074         }
2075
2076         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2077         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
2078         ID3D11SamplerState_AddRef(samplers[i]);
2079     }
2080     wined3d_mutex_unlock();
2081 }
2082
2083 static void STDMETHODCALLTYPE d3d11_device_context_GetPredication(ID3D11DeviceContext1 *iface,
2084         ID3D11Predicate **predicate, BOOL *value)
2085 {
2086     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2087     struct wined3d_query *wined3d_predicate;
2088     struct d3d_query *predicate_impl;
2089
2090     TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
2091
2092     wined3d_mutex_lock();
2093     if (!(wined3d_predicate = wined3d_device_context_get_predication(context->wined3d_context, value)))
2094     {
2095         wined3d_mutex_unlock();
2096         *predicate = NULL;
2097         return;
2098     }
2099
2100     predicate_impl = wined3d_query_get_parent(wined3d_predicate);
2101     wined3d_mutex_unlock();
2102     *predicate = (ID3D11Predicate *)&predicate_impl->ID3D11Query_iface;
2103     ID3D11Predicate_AddRef(*predicate);
2104 }
2105
2106 static void STDMETHODCALLTYPE d3d11_device_context_GSGetShaderResources(ID3D11DeviceContext1 *iface,
2107         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2108 {
2109     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2110     unsigned int i;
2111
2112     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2113
2114     wined3d_mutex_lock();
2115     for (i = 0; i < view_count; ++i)
2116     {
2117         struct wined3d_shader_resource_view *wined3d_view;
2118         struct d3d_shader_resource_view *view_impl;
2119
2120         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
2121                 context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i)))
2122         {
2123             views[i] = NULL;
2124             continue;
2125         }
2126
2127         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2128         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
2129         ID3D11ShaderResourceView_AddRef(views[i]);
2130     }
2131     wined3d_mutex_unlock();
2132 }
2133
2134 static void STDMETHODCALLTYPE d3d11_device_context_GSGetSamplers(ID3D11DeviceContext1 *iface,
2135         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2136 {
2137     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2138     unsigned int i;
2139
2140     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2141             iface, start_slot, sampler_count, samplers);
2142
2143     wined3d_mutex_lock();
2144     for (i = 0; i < sampler_count; ++i)
2145     {
2146         struct d3d_sampler_state *sampler_impl;
2147         struct wined3d_sampler *wined3d_sampler;
2148
2149         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
2150                 context->wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i)))
2151         {
2152             samplers[i] = NULL;
2153             continue;
2154         }
2155
2156         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2157         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
2158         ID3D11SamplerState_AddRef(samplers[i]);
2159     }
2160     wined3d_mutex_unlock();
2161 }
2162
2163 static void STDMETHODCALLTYPE d3d11_device_context_OMGetRenderTargets(ID3D11DeviceContext1 *iface,
2164         UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
2165         ID3D11DepthStencilView **depth_stencil_view)
2166 {
2167     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2168     struct wined3d_rendertarget_view *wined3d_view;
2169
2170     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
2171             iface, render_target_view_count, render_target_views, depth_stencil_view);
2172
2173     wined3d_mutex_lock();
2174     if (render_target_views)
2175     {
2176         struct d3d_rendertarget_view *view_impl;
2177         unsigned int i;
2178
2179         for (i = 0; i < render_target_view_count; ++i)
2180         {
2181             if (!(wined3d_view = wined3d_device_context_get_rendertarget_view(context->wined3d_context, i))
2182                     || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
2183             {
2184                 render_target_views[i] = NULL;
2185                 continue;
2186             }
2187
2188             render_target_views[i] = &view_impl->ID3D11RenderTargetView_iface;
2189             ID3D11RenderTargetView_AddRef(render_target_views[i]);
2190         }
2191     }
2192
2193     if (depth_stencil_view)
2194     {
2195         struct d3d_depthstencil_view *view_impl;
2196
2197         if (!(wined3d_view = wined3d_device_context_get_depth_stencil_view(context->wined3d_context))
2198                 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
2199         {
2200             *depth_stencil_view = NULL;
2201         }
2202         else
2203         {
2204             *depth_stencil_view = &view_impl->ID3D11DepthStencilView_iface;
2205             ID3D11DepthStencilView_AddRef(*depth_stencil_view);
2206         }
2207     }
2208     wined3d_mutex_unlock();
2209 }
2210
2211 static void STDMETHODCALLTYPE d3d11_device_context_OMGetRenderTargetsAndUnorderedAccessViews(
2212         ID3D11DeviceContext1 *iface,
2213         UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
2214         ID3D11DepthStencilView **depth_stencil_view,
2215         UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
2216         ID3D11UnorderedAccessView **unordered_access_views)
2217 {
2218     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2219     struct wined3d_unordered_access_view *wined3d_view;
2220     struct d3d11_unordered_access_view *view_impl;
2221     unsigned int i;
2222
2223     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
2224             "unordered_access_view_start_slot %u, unordered_access_view_count %u, "
2225             "unordered_access_views %p.\n",
2226             iface, render_target_view_count, render_target_views, depth_stencil_view,
2227             unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views);
2228
2229     if (render_target_views || depth_stencil_view)
2230         d3d11_device_context_OMGetRenderTargets(iface, render_target_view_count,
2231                 render_target_views, depth_stencil_view);
2232
2233     if (unordered_access_views)
2234     {
2235         wined3d_mutex_lock();
2236         for (i = 0; i < unordered_access_view_count; ++i)
2237         {
2238             if (!(wined3d_view = wined3d_device_context_get_unordered_access_view(context->wined3d_context,
2239                     WINED3D_PIPELINE_GRAPHICS, unordered_access_view_start_slot + i)))
2240             {
2241                 unordered_access_views[i] = NULL;
2242                 continue;
2243             }
2244
2245             view_impl = wined3d_unordered_access_view_get_parent(wined3d_view);
2246             unordered_access_views[i] = &view_impl->ID3D11UnorderedAccessView_iface;
2247             ID3D11UnorderedAccessView_AddRef(unordered_access_views[i]);
2248         }
2249         wined3d_mutex_unlock();
2250     }
2251 }
2252
2253 static void STDMETHODCALLTYPE d3d11_device_context_OMGetBlendState(ID3D11DeviceContext1 *iface,
2254         ID3D11BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
2255 {
2256     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2257     struct wined3d_blend_state *wined3d_state;
2258     struct d3d_blend_state *blend_state_impl;
2259
2260     TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
2261             iface, blend_state, blend_factor, sample_mask);
2262
2263     wined3d_mutex_lock();
2264     if ((wined3d_state = wined3d_device_context_get_blend_state(context->wined3d_context,
2265             (struct wined3d_color *)blend_factor, sample_mask)))
2266     {
2267         blend_state_impl = wined3d_blend_state_get_parent(wined3d_state);
2268         ID3D11BlendState_AddRef(*blend_state = &blend_state_impl->ID3D11BlendState_iface);
2269     }
2270     else
2271     {
2272         *blend_state = NULL;
2273     }
2274     wined3d_mutex_unlock();
2275 }
2276
2277 static void STDMETHODCALLTYPE d3d11_device_context_OMGetDepthStencilState(ID3D11DeviceContext1 *iface,
2278         ID3D11DepthStencilState **depth_stencil_state, UINT *stencil_ref)
2279 {
2280     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2281     struct wined3d_depth_stencil_state *wined3d_state;
2282     struct d3d_depthstencil_state *state_impl;
2283
2284     TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
2285             iface, depth_stencil_state, stencil_ref);
2286
2287     wined3d_mutex_lock();
2288     if ((wined3d_state = wined3d_device_context_get_depth_stencil_state(context->wined3d_context, stencil_ref)))
2289     {
2290         state_impl = wined3d_depth_stencil_state_get_parent(wined3d_state);
2291         ID3D11DepthStencilState_AddRef(*depth_stencil_state = &state_impl->ID3D11DepthStencilState_iface);
2292     }
2293     else
2294     {
2295         *depth_stencil_state = NULL;
2296     }
2297     wined3d_mutex_unlock();
2298 }
2299
2300 static void STDMETHODCALLTYPE d3d11_device_context_SOGetTargets(ID3D11DeviceContext1 *iface,
2301         UINT buffer_count, ID3D11Buffer **buffers)
2302 {
2303     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2304     unsigned int i;
2305
2306     TRACE("iface %p, buffer_count %u, buffers %p.\n", iface, buffer_count, buffers);
2307
2308     wined3d_mutex_lock();
2309     for (i = 0; i < buffer_count; ++i)
2310     {
2311         struct wined3d_buffer *wined3d_buffer;
2312         struct d3d_buffer *buffer_impl;
2313
2314         if (!(wined3d_buffer = wined3d_device_context_get_stream_output(context->wined3d_context, i, NULL)))
2315         {
2316             buffers[i] = NULL;
2317             continue;
2318         }
2319
2320         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
2321         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
2322         ID3D11Buffer_AddRef(buffers[i]);
2323     }
2324     wined3d_mutex_unlock();
2325 }
2326
2327 static void STDMETHODCALLTYPE d3d11_device_context_RSGetState(ID3D11DeviceContext1 *iface,
2328         ID3D11RasterizerState **rasterizer_state)
2329 {
2330     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2331     struct d3d_rasterizer_state *rasterizer_state_impl;
2332     struct wined3d_rasterizer_state *wined3d_state;
2333
2334     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
2335
2336     wined3d_mutex_lock();
2337     if ((wined3d_state = wined3d_device_context_get_rasterizer_state(context->wined3d_context)))
2338     {
2339         rasterizer_state_impl = wined3d_rasterizer_state_get_parent(wined3d_state);
2340         ID3D11RasterizerState_AddRef(*rasterizer_state = &rasterizer_state_impl->ID3D11RasterizerState_iface);
2341     }
2342     else
2343     {
2344         *rasterizer_state = NULL;
2345     }
2346     wined3d_mutex_unlock();
2347 }
2348
2349 static void STDMETHODCALLTYPE d3d11_device_context_RSGetViewports(ID3D11DeviceContext1 *iface,
2350         UINT *viewport_count, D3D11_VIEWPORT *viewports)
2351 {
2352     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2353     struct wined3d_viewport wined3d_vp[WINED3D_MAX_VIEWPORTS];
2354     unsigned int actual_count = ARRAY_SIZE(wined3d_vp), i;
2355
2356     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
2357
2358     if (!viewport_count)
2359         return;
2360
2361     wined3d_mutex_lock();
2362     wined3d_device_context_get_viewports(context->wined3d_context, &actual_count, viewports ? wined3d_vp : NULL);
2363     wined3d_mutex_unlock();
2364
2365     if (!viewports)
2366     {
2367         *viewport_count = actual_count;
2368         return;
2369     }
2370
2371     if (*viewport_count > actual_count)
2372         memset(&viewports[actual_count], 0, (*viewport_count - actual_count) * sizeof(*viewports));
2373
2374     *viewport_count = min(actual_count, *viewport_count);
2375     for (i = 0; i < *viewport_count; ++i)
2376     {
2377         viewports[i].TopLeftX = wined3d_vp[i].x;
2378         viewports[i].TopLeftY = wined3d_vp[i].y;
2379         viewports[i].Width = wined3d_vp[i].width;
2380         viewports[i].Height = wined3d_vp[i].height;
2381         viewports[i].MinDepth = wined3d_vp[i].min_z;
2382         viewports[i].MaxDepth = wined3d_vp[i].max_z;
2383     }
2384 }
2385
2386 static void STDMETHODCALLTYPE d3d11_device_context_RSGetScissorRects(ID3D11DeviceContext1 *iface,
2387         UINT *rect_count, D3D11_RECT *rects)
2388 {
2389     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2390     unsigned int actual_count;
2391
2392     TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
2393
2394     if (!rect_count)
2395         return;
2396
2397     actual_count = *rect_count;
2398
2399     wined3d_mutex_lock();
2400     wined3d_device_context_get_scissor_rects(context->wined3d_context, &actual_count, rects);
2401     wined3d_mutex_unlock();
2402
2403     if (rects && *rect_count > actual_count)
2404         memset(&rects[actual_count], 0, (*rect_count - actual_count) * sizeof(*rects));
2405     *rect_count = actual_count;
2406 }
2407
2408 static void STDMETHODCALLTYPE d3d11_device_context_HSGetShaderResources(ID3D11DeviceContext1 *iface,
2409         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2410 {
2411     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2412     unsigned int i;
2413
2414     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2415
2416     wined3d_mutex_lock();
2417     for (i = 0; i < view_count; ++i)
2418     {
2419         struct wined3d_shader_resource_view *wined3d_view;
2420         struct d3d_shader_resource_view *view_impl;
2421
2422         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
2423                 context->wined3d_context, WINED3D_SHADER_TYPE_HULL, start_slot + i)))
2424         {
2425             views[i] = NULL;
2426             continue;
2427         }
2428
2429         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2430         ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2431     }
2432     wined3d_mutex_unlock();
2433 }
2434
2435 static void STDMETHODCALLTYPE d3d11_device_context_HSGetShader(ID3D11DeviceContext1 *iface,
2436         ID3D11HullShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2437 {
2438     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2439     struct d3d11_hull_shader *shader_impl;
2440     struct wined3d_shader *wined3d_shader;
2441
2442     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2443             iface, shader, class_instances, class_instance_count);
2444
2445     if (class_instances || class_instance_count)
2446         FIXME("Dynamic linking not implemented yet.\n");
2447     if (class_instance_count)
2448         *class_instance_count = 0;
2449
2450     wined3d_mutex_lock();
2451     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_HULL)))
2452     {
2453         wined3d_mutex_unlock();
2454         *shader = NULL;
2455         return;
2456     }
2457
2458     shader_impl = wined3d_shader_get_parent(wined3d_shader);
2459     wined3d_mutex_unlock();
2460     ID3D11HullShader_AddRef(*shader = &shader_impl->ID3D11HullShader_iface);
2461 }
2462
2463 static void STDMETHODCALLTYPE d3d11_device_context_HSGetSamplers(ID3D11DeviceContext1 *iface,
2464         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2465 {
2466     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2467     unsigned int i;
2468
2469     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2470             iface, start_slot, sampler_count, samplers);
2471
2472     wined3d_mutex_lock();
2473     for (i = 0; i < sampler_count; ++i)
2474     {
2475         struct wined3d_sampler *wined3d_sampler;
2476         struct d3d_sampler_state *sampler_impl;
2477
2478         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
2479                 context->wined3d_context, WINED3D_SHADER_TYPE_HULL, start_slot + i)))
2480         {
2481             samplers[i] = NULL;
2482             continue;
2483         }
2484
2485         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2486         ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2487     }
2488     wined3d_mutex_unlock();
2489 }
2490
2491 static void STDMETHODCALLTYPE d3d11_device_context_HSGetConstantBuffers(ID3D11DeviceContext1 *iface,
2492         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2493 {
2494     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2495             iface, start_slot, buffer_count, buffers);
2496
2497     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_HULL, start_slot,
2498             buffer_count, buffers);
2499 }
2500
2501 static void STDMETHODCALLTYPE d3d11_device_context_DSGetShaderResources(ID3D11DeviceContext1 *iface,
2502         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2503 {
2504     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2505     unsigned int i;
2506
2507     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
2508             iface, start_slot, view_count, views);
2509
2510     wined3d_mutex_lock();
2511     for (i = 0; i < view_count; ++i)
2512     {
2513         struct wined3d_shader_resource_view *wined3d_view;
2514         struct d3d_shader_resource_view *view_impl;
2515
2516         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
2517                 context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN, start_slot + i)))
2518         {
2519             views[i] = NULL;
2520             continue;
2521         }
2522
2523         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2524         ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2525     }
2526     wined3d_mutex_unlock();
2527 }
2528
2529 static void STDMETHODCALLTYPE d3d11_device_context_DSGetShader(ID3D11DeviceContext1 *iface,
2530         ID3D11DomainShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2531 {
2532     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2533     struct d3d11_domain_shader *shader_impl;
2534     struct wined3d_shader *wined3d_shader;
2535
2536     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2537             iface, shader, class_instances, class_instance_count);
2538
2539     if (class_instances || class_instance_count)
2540         FIXME("Dynamic linking not implemented yet.\n");
2541     if (class_instance_count)
2542         *class_instance_count = 0;
2543
2544     wined3d_mutex_lock();
2545     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN)))
2546     {
2547         wined3d_mutex_unlock();
2548         *shader = NULL;
2549         return;
2550     }
2551
2552     shader_impl = wined3d_shader_get_parent(wined3d_shader);
2553     wined3d_mutex_unlock();
2554     ID3D11DomainShader_AddRef(*shader = &shader_impl->ID3D11DomainShader_iface);
2555 }
2556
2557 static void STDMETHODCALLTYPE d3d11_device_context_DSGetSamplers(ID3D11DeviceContext1 *iface,
2558         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2559 {
2560     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2561     unsigned int i;
2562
2563     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2564             iface, start_slot, sampler_count, samplers);
2565
2566     wined3d_mutex_lock();
2567     for (i = 0; i < sampler_count; ++i)
2568     {
2569         struct wined3d_sampler *wined3d_sampler;
2570         struct d3d_sampler_state *sampler_impl;
2571
2572         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
2573                 context->wined3d_context, WINED3D_SHADER_TYPE_DOMAIN, start_slot + i)))
2574         {
2575             samplers[i] = NULL;
2576             continue;
2577         }
2578
2579         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2580         ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2581     }
2582     wined3d_mutex_unlock();
2583 }
2584
2585 static void STDMETHODCALLTYPE d3d11_device_context_DSGetConstantBuffers(ID3D11DeviceContext1 *iface,
2586         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2587 {
2588     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2589             iface, start_slot, buffer_count, buffers);
2590
2591     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_DOMAIN, start_slot,
2592             buffer_count, buffers);
2593 }
2594
2595 static void STDMETHODCALLTYPE d3d11_device_context_CSGetShaderResources(ID3D11DeviceContext1 *iface,
2596         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2597 {
2598     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2599     unsigned int i;
2600
2601     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2602
2603     wined3d_mutex_lock();
2604     for (i = 0; i < view_count; ++i)
2605     {
2606         struct wined3d_shader_resource_view *wined3d_view;
2607         struct d3d_shader_resource_view *view_impl;
2608
2609         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
2610                 context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE, start_slot + i)))
2611         {
2612             views[i] = NULL;
2613             continue;
2614         }
2615
2616         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2617         ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2618     }
2619     wined3d_mutex_unlock();
2620 }
2621
2622 static void STDMETHODCALLTYPE d3d11_device_context_CSGetUnorderedAccessViews(ID3D11DeviceContext1 *iface,
2623         UINT start_slot, UINT view_count, ID3D11UnorderedAccessView **views)
2624 {
2625     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2626     unsigned int i;
2627
2628     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2629
2630     wined3d_mutex_lock();
2631     for (i = 0; i < view_count; ++i)
2632     {
2633         struct wined3d_unordered_access_view *wined3d_view;
2634         struct d3d11_unordered_access_view *view_impl;
2635
2636         if (!(wined3d_view = wined3d_device_context_get_unordered_access_view(
2637                 context->wined3d_context, WINED3D_PIPELINE_COMPUTE, start_slot + i)))
2638         {
2639             views[i] = NULL;
2640             continue;
2641         }
2642
2643         view_impl = wined3d_unordered_access_view_get_parent(wined3d_view);
2644         ID3D11UnorderedAccessView_AddRef(views[i] = &view_impl->ID3D11UnorderedAccessView_iface);
2645     }
2646     wined3d_mutex_unlock();
2647 }
2648
2649 static void STDMETHODCALLTYPE d3d11_device_context_CSGetShader(ID3D11DeviceContext1 *iface,
2650         ID3D11ComputeShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2651 {
2652     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2653     struct d3d11_compute_shader *shader_impl;
2654     struct wined3d_shader *wined3d_shader;
2655
2656     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2657             iface, shader, class_instances, class_instance_count);
2658
2659     if (class_instances || class_instance_count)
2660         FIXME("Dynamic linking not implemented yet.\n");
2661     if (class_instance_count)
2662         *class_instance_count = 0;
2663
2664     wined3d_mutex_lock();
2665     if (!(wined3d_shader = wined3d_device_context_get_shader(context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE)))
2666     {
2667         wined3d_mutex_unlock();
2668         *shader = NULL;
2669         return;
2670     }
2671
2672     shader_impl = wined3d_shader_get_parent(wined3d_shader);
2673     wined3d_mutex_unlock();
2674     ID3D11ComputeShader_AddRef(*shader = &shader_impl->ID3D11ComputeShader_iface);
2675 }
2676
2677 static void STDMETHODCALLTYPE d3d11_device_context_CSGetSamplers(ID3D11DeviceContext1 *iface,
2678         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2679 {
2680     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2681     unsigned int i;
2682
2683     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2684             iface, start_slot, sampler_count, samplers);
2685
2686     wined3d_mutex_lock();
2687     for (i = 0; i < sampler_count; ++i)
2688     {
2689         struct wined3d_sampler *wined3d_sampler;
2690         struct d3d_sampler_state *sampler_impl;
2691
2692         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
2693                 context->wined3d_context, WINED3D_SHADER_TYPE_COMPUTE, start_slot + i)))
2694         {
2695             samplers[i] = NULL;
2696             continue;
2697         }
2698
2699         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2700         ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2701     }
2702     wined3d_mutex_unlock();
2703 }
2704
2705 static void STDMETHODCALLTYPE d3d11_device_context_CSGetConstantBuffers(ID3D11DeviceContext1 *iface,
2706         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2707 {
2708     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2709             iface, start_slot, buffer_count, buffers);
2710
2711     d3d11_device_context_get_constant_buffers(iface, WINED3D_SHADER_TYPE_COMPUTE, start_slot,
2712             buffer_count, buffers);
2713 }
2714
2715 static void STDMETHODCALLTYPE d3d11_device_context_ClearState(ID3D11DeviceContext1 *iface)
2716 {
2717     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2718
2719     TRACE("iface %p.\n", iface);
2720
2721     wined3d_mutex_lock();
2722     wined3d_device_context_reset_state(context->wined3d_context);
2723     wined3d_mutex_unlock();
2724 }
2725
2726 static void STDMETHODCALLTYPE d3d11_device_context_Flush(ID3D11DeviceContext1 *iface)
2727 {
2728     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2729
2730     TRACE("iface %p.\n", iface);
2731
2732     wined3d_mutex_lock();
2733     wined3d_device_context_flush(context->wined3d_context);
2734     wined3d_mutex_unlock();
2735 }
2736
2737 static D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE d3d11_device_context_GetType(ID3D11DeviceContext1 *iface)
2738 {
2739     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2740
2741     TRACE("iface %p.\n", iface);
2742
2743     return context->type;
2744 }
2745
2746 static UINT STDMETHODCALLTYPE d3d11_device_context_GetContextFlags(ID3D11DeviceContext1 *iface)
2747 {
2748     TRACE("iface %p.\n", iface);
2749
2750     return 0;
2751 }
2752
2753 static HRESULT STDMETHODCALLTYPE d3d11_device_context_FinishCommandList(ID3D11DeviceContext1 *iface,
2754         BOOL restore, ID3D11CommandList **command_list)
2755 {
2756     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2757     struct d3d11_command_list *object;
2758     HRESULT hr;
2759
2760     TRACE("iface %p, restore %#x, command_list %p.\n", iface, restore, command_list);
2761
2762     if (context->type == D3D11_DEVICE_CONTEXT_IMMEDIATE)
2763     {
2764         WARN("Attempt to record command list on an immediate context; returning DXGI_ERROR_INVALID_CALL.\n");
2765         return DXGI_ERROR_INVALID_CALL;
2766     }
2767
2768     if (!(object = heap_alloc_zero(sizeof(*object))))
2769         return E_OUTOFMEMORY;
2770
2771     wined3d_mutex_lock();
2772
2773     if (FAILED(hr = wined3d_deferred_context_record_command_list(context->wined3d_context,
2774             !!restore, &object->wined3d_list)))
2775     {
2776         WARN("Failed to record wined3d command list, hr %#x.\n", hr);
2777         heap_free(object);
2778         return hr;
2779     }
2780
2781     wined3d_mutex_unlock();
2782
2783     object->ID3D11CommandList_iface.lpVtbl = &d3d11_command_list_vtbl;
2784     object->refcount = 1;
2785     object->device = &context->device->ID3D11Device2_iface;
2786     wined3d_private_store_init(&object->private_store);
2787
2788     ID3D11Device2_AddRef(object->device);
2789
2790     TRACE("Created command list %p.\n", object);
2791     *command_list = &object->ID3D11CommandList_iface;
2792
2793     return S_OK;
2794 }
2795
2796 static void STDMETHODCALLTYPE d3d11_device_context_CopySubresourceRegion1(ID3D11DeviceContext1 *iface,
2797         ID3D11Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
2798         ID3D11Resource *src_resource, UINT src_subresource_idx, const D3D11_BOX *src_box, UINT flags)
2799 {
2800     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2801     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
2802     struct wined3d_box wined3d_src_box;
2803
2804     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
2805             "src_resource %p, src_subresource_idx %u, src_box %p, flags %#x.\n",
2806             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
2807             src_resource, src_subresource_idx, src_box, flags);
2808
2809     if (!dst_resource || !src_resource)
2810         return;
2811
2812     if (src_box)
2813         wined3d_box_set(&wined3d_src_box, src_box->left, src_box->top,
2814                 src_box->right, src_box->bottom, src_box->front, src_box->back);
2815
2816     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
2817     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
2818     wined3d_mutex_lock();
2819     wined3d_device_context_copy_sub_resource_region(context->wined3d_context, wined3d_dst_resource, dst_subresource_idx,
2820             dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL, flags);
2821     wined3d_mutex_unlock();
2822 }
2823
2824 static void STDMETHODCALLTYPE d3d11_device_context_UpdateSubresource1(ID3D11DeviceContext1 *iface,
2825         ID3D11Resource *resource, UINT subresource_idx, const D3D11_BOX *box, const void *data,
2826         UINT row_pitch, UINT depth_pitch, UINT flags)
2827 {
2828     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2829     struct wined3d_resource *wined3d_resource;
2830     struct wined3d_box wined3d_box;
2831
2832     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u, flags %#x.\n",
2833             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch, flags);
2834
2835     if (box)
2836         wined3d_box_set(&wined3d_box, box->left, box->top, box->right, box->bottom,
2837                 box->front, box->back);
2838
2839     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
2840     wined3d_mutex_lock();
2841     wined3d_device_context_update_sub_resource(context->wined3d_context, wined3d_resource, subresource_idx,
2842             box ? &wined3d_box : NULL, data, row_pitch, depth_pitch, flags);
2843     wined3d_mutex_unlock();
2844 }
2845
2846 static void STDMETHODCALLTYPE d3d11_device_context_DiscardResource(ID3D11DeviceContext1 *iface,
2847         ID3D11Resource *resource)
2848 {
2849     FIXME("iface %p, resource %p stub!\n", iface, resource);
2850 }
2851
2852 static void STDMETHODCALLTYPE d3d11_device_context_DiscardView(ID3D11DeviceContext1 *iface, ID3D11View *view)
2853 {
2854     FIXME("iface %p, view %p stub!\n", iface, view);
2855 }
2856
2857 static void STDMETHODCALLTYPE d3d11_device_context_VSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2858         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2859         const UINT *num_constants)
2860 {
2861     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2862             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2863 }
2864
2865 static void STDMETHODCALLTYPE d3d11_device_context_HSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2866         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2867         const UINT *num_constants)
2868 {
2869     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2870             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2871 }
2872
2873 static void STDMETHODCALLTYPE d3d11_device_context_DSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2874         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2875         const UINT *num_constants)
2876 {
2877     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2878             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2879 }
2880
2881 static void STDMETHODCALLTYPE d3d11_device_context_GSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2882         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2883         const UINT *num_constants)
2884 {
2885     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2886             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2887 }
2888
2889 static void STDMETHODCALLTYPE d3d11_device_context_PSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2890         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2891         const UINT *num_constants)
2892 {
2893     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2894             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2895 }
2896
2897 static void STDMETHODCALLTYPE d3d11_device_context_CSSetConstantBuffers1(ID3D11DeviceContext1 *iface,
2898         UINT start_slot, UINT buffer_count, ID3D11Buffer * const *buffers, const UINT *first_constant,
2899         const UINT *num_constants)
2900 {
2901     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2902             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2903 }
2904
2905 static void STDMETHODCALLTYPE d3d11_device_context_VSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2906         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2907 {
2908     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2909             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2910 }
2911
2912 static void STDMETHODCALLTYPE d3d11_device_context_HSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2913         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2914 {
2915     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2916             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2917 }
2918
2919 static void STDMETHODCALLTYPE d3d11_device_context_DSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2920         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2921 {
2922     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2923             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2924 }
2925
2926 static void STDMETHODCALLTYPE d3d11_device_context_GSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2927         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2928 {
2929     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2930             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2931 }
2932
2933 static void STDMETHODCALLTYPE d3d11_device_context_PSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2934         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2935 {
2936     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2937             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2938 }
2939
2940 static void STDMETHODCALLTYPE d3d11_device_context_CSGetConstantBuffers1(ID3D11DeviceContext1 *iface,
2941         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *first_constant, UINT *num_constants)
2942 {
2943     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, first_constant %p, num_constants %p stub!\n",
2944             iface, start_slot, buffer_count, buffers, first_constant, num_constants);
2945 }
2946
2947 static void STDMETHODCALLTYPE d3d11_device_context_SwapDeviceContextState(ID3D11DeviceContext1 *iface,
2948         ID3DDeviceContextState *state, ID3DDeviceContextState **prev)
2949 {
2950     struct d3d11_device_context *context = impl_from_ID3D11DeviceContext1(iface);
2951     struct d3d_device_context_state *state_impl, *prev_impl;
2952     struct d3d_device *device = context->device;
2953     struct wined3d_state *wined3d_state;
2954
2955     TRACE("iface %p, state %p, prev %p.\n", iface, state, prev);
2956
2957     if (prev)
2958         *prev = NULL;
2959
2960     if (context->type != D3D11_DEVICE_CONTEXT_IMMEDIATE)
2961     {
2962         WARN("SwapDeviceContextState is not allowed on a deferred context.\n");
2963         return;
2964     }
2965
2966     if (!state)
2967         return;
2968
2969     wined3d_mutex_lock();
2970
2971     prev_impl = device->state;
2972     state_impl = impl_from_ID3DDeviceContextState(state);
2973     if (!(wined3d_state = d3d_device_context_state_get_wined3d_state(state_impl, device)))
2974         ERR("Failed to get wined3d state for device context state %p.\n", state_impl);
2975     wined3d_device_context_set_state(context->wined3d_context, wined3d_state);
2976
2977     if (prev)
2978         ID3DDeviceContextState_AddRef(*prev = &prev_impl->ID3DDeviceContextState_iface);
2979
2980     d3d_device_context_state_private_addref(state_impl);
2981     device->state = state_impl;
2982     d3d_device_context_state_private_release(prev_impl);
2983
2984     if (d3d_device_is_d3d10_active(device))
2985         FIXME("D3D10 interface emulation not fully implemented yet!\n");
2986     wined3d_mutex_unlock();
2987 }
2988
2989 static void STDMETHODCALLTYPE d3d11_device_context_ClearView(ID3D11DeviceContext1 *iface, ID3D11View *view,
2990         const FLOAT color[4], const D3D11_RECT *rect, UINT num_rects)
2991 {
2992     FIXME("iface %p, view %p, color %p, rect %p, num_rects %u stub!\n", iface, view, color, rect, num_rects);
2993 }
2994
2995 static void STDMETHODCALLTYPE d3d11_device_context_DiscardView1(ID3D11DeviceContext1 *iface, ID3D11View *view,
2996         const D3D11_RECT *rects, UINT num_rects)
2997 {
2998     FIXME("iface %p, view %p, rects %p, num_rects %u stub!\n", iface, view, rects, num_rects);
2999 }
3000
3001 static const struct ID3D11DeviceContext1Vtbl d3d11_device_context_vtbl =
3002 {
3003     /* IUnknown methods */
3004     d3d11_device_context_QueryInterface,
3005     d3d11_device_context_AddRef,
3006     d3d11_device_context_Release,
3007     /* ID3D11DeviceChild methods */
3008     d3d11_device_context_GetDevice,
3009     d3d11_device_context_GetPrivateData,
3010     d3d11_device_context_SetPrivateData,
3011     d3d11_device_context_SetPrivateDataInterface,
3012     /* ID3D11DeviceContext methods */
3013     d3d11_device_context_VSSetConstantBuffers,
3014     d3d11_device_context_PSSetShaderResources,
3015     d3d11_device_context_PSSetShader,
3016     d3d11_device_context_PSSetSamplers,
3017     d3d11_device_context_VSSetShader,
3018     d3d11_device_context_DrawIndexed,
3019     d3d11_device_context_Draw,
3020     d3d11_device_context_Map,
3021     d3d11_device_context_Unmap,
3022     d3d11_device_context_PSSetConstantBuffers,
3023     d3d11_device_context_IASetInputLayout,
3024     d3d11_device_context_IASetVertexBuffers,
3025     d3d11_device_context_IASetIndexBuffer,
3026     d3d11_device_context_DrawIndexedInstanced,
3027     d3d11_device_context_DrawInstanced,
3028     d3d11_device_context_GSSetConstantBuffers,
3029     d3d11_device_context_GSSetShader,
3030     d3d11_device_context_IASetPrimitiveTopology,
3031     d3d11_device_context_VSSetShaderResources,
3032     d3d11_device_context_VSSetSamplers,
3033     d3d11_device_context_Begin,
3034     d3d11_device_context_End,
3035     d3d11_device_context_GetData,
3036     d3d11_device_context_SetPredication,
3037     d3d11_device_context_GSSetShaderResources,
3038     d3d11_device_context_GSSetSamplers,
3039     d3d11_device_context_OMSetRenderTargets,
3040     d3d11_device_context_OMSetRenderTargetsAndUnorderedAccessViews,
3041     d3d11_device_context_OMSetBlendState,
3042     d3d11_device_context_OMSetDepthStencilState,
3043     d3d11_device_context_SOSetTargets,
3044     d3d11_device_context_DrawAuto,
3045     d3d11_device_context_DrawIndexedInstancedIndirect,
3046     d3d11_device_context_DrawInstancedIndirect,
3047     d3d11_device_context_Dispatch,
3048     d3d11_device_context_DispatchIndirect,
3049     d3d11_device_context_RSSetState,
3050     d3d11_device_context_RSSetViewports,
3051     d3d11_device_context_RSSetScissorRects,
3052     d3d11_device_context_CopySubresourceRegion,
3053     d3d11_device_context_CopyResource,
3054     d3d11_device_context_UpdateSubresource,
3055     d3d11_device_context_CopyStructureCount,
3056     d3d11_device_context_ClearRenderTargetView,
3057     d3d11_device_context_ClearUnorderedAccessViewUint,
3058     d3d11_device_context_ClearUnorderedAccessViewFloat,
3059     d3d11_device_context_ClearDepthStencilView,
3060     d3d11_device_context_GenerateMips,
3061     d3d11_device_context_SetResourceMinLOD,
3062     d3d11_device_context_GetResourceMinLOD,
3063     d3d11_device_context_ResolveSubresource,
3064     d3d11_device_context_ExecuteCommandList,
3065     d3d11_device_context_HSSetShaderResources,
3066     d3d11_device_context_HSSetShader,
3067     d3d11_device_context_HSSetSamplers,
3068     d3d11_device_context_HSSetConstantBuffers,
3069     d3d11_device_context_DSSetShaderResources,
3070     d3d11_device_context_DSSetShader,
3071     d3d11_device_context_DSSetSamplers,
3072     d3d11_device_context_DSSetConstantBuffers,
3073     d3d11_device_context_CSSetShaderResources,
3074     d3d11_device_context_CSSetUnorderedAccessViews,
3075     d3d11_device_context_CSSetShader,
3076     d3d11_device_context_CSSetSamplers,
3077     d3d11_device_context_CSSetConstantBuffers,
3078     d3d11_device_context_VSGetConstantBuffers,
3079     d3d11_device_context_PSGetShaderResources,
3080     d3d11_device_context_PSGetShader,
3081     d3d11_device_context_PSGetSamplers,
3082     d3d11_device_context_VSGetShader,
3083     d3d11_device_context_PSGetConstantBuffers,
3084     d3d11_device_context_IAGetInputLayout,
3085     d3d11_device_context_IAGetVertexBuffers,
3086     d3d11_device_context_IAGetIndexBuffer,
3087     d3d11_device_context_GSGetConstantBuffers,
3088     d3d11_device_context_GSGetShader,
3089     d3d11_device_context_IAGetPrimitiveTopology,
3090     d3d11_device_context_VSGetShaderResources,
3091     d3d11_device_context_VSGetSamplers,
3092     d3d11_device_context_GetPredication,
3093     d3d11_device_context_GSGetShaderResources,
3094     d3d11_device_context_GSGetSamplers,
3095     d3d11_device_context_OMGetRenderTargets,
3096     d3d11_device_context_OMGetRenderTargetsAndUnorderedAccessViews,
3097     d3d11_device_context_OMGetBlendState,
3098     d3d11_device_context_OMGetDepthStencilState,
3099     d3d11_device_context_SOGetTargets,
3100     d3d11_device_context_RSGetState,
3101     d3d11_device_context_RSGetViewports,
3102     d3d11_device_context_RSGetScissorRects,
3103     d3d11_device_context_HSGetShaderResources,
3104     d3d11_device_context_HSGetShader,
3105     d3d11_device_context_HSGetSamplers,
3106     d3d11_device_context_HSGetConstantBuffers,
3107     d3d11_device_context_DSGetShaderResources,
3108     d3d11_device_context_DSGetShader,
3109     d3d11_device_context_DSGetSamplers,
3110     d3d11_device_context_DSGetConstantBuffers,
3111     d3d11_device_context_CSGetShaderResources,
3112     d3d11_device_context_CSGetUnorderedAccessViews,
3113     d3d11_device_context_CSGetShader,
3114     d3d11_device_context_CSGetSamplers,
3115     d3d11_device_context_CSGetConstantBuffers,
3116     d3d11_device_context_ClearState,
3117     d3d11_device_context_Flush,
3118     d3d11_device_context_GetType,
3119     d3d11_device_context_GetContextFlags,
3120     d3d11_device_context_FinishCommandList,
3121     /* ID3D11DeviceContext1 methods */
3122     d3d11_device_context_CopySubresourceRegion1,
3123     d3d11_device_context_UpdateSubresource1,
3124     d3d11_device_context_DiscardResource,
3125     d3d11_device_context_DiscardView,
3126     d3d11_device_context_VSSetConstantBuffers1,
3127     d3d11_device_context_HSSetConstantBuffers1,
3128     d3d11_device_context_DSSetConstantBuffers1,
3129     d3d11_device_context_GSSetConstantBuffers1,
3130     d3d11_device_context_PSSetConstantBuffers1,
3131     d3d11_device_context_CSSetConstantBuffers1,
3132     d3d11_device_context_VSGetConstantBuffers1,
3133     d3d11_device_context_HSGetConstantBuffers1,
3134     d3d11_device_context_DSGetConstantBuffers1,
3135     d3d11_device_context_GSGetConstantBuffers1,
3136     d3d11_device_context_PSGetConstantBuffers1,
3137     d3d11_device_context_CSGetConstantBuffers1,
3138     d3d11_device_context_SwapDeviceContextState,
3139     d3d11_device_context_ClearView,
3140     d3d11_device_context_DiscardView1,
3141 };
3142
3143 /* ID3D11Multithread methods */
3144
3145 static inline struct d3d11_device_context *impl_from_ID3D11Multithread(ID3D11Multithread *iface)
3146 {
3147     return CONTAINING_RECORD(iface, struct d3d11_device_context, ID3D11Multithread_iface);
3148 }
3149
3150 static HRESULT STDMETHODCALLTYPE d3d11_multithread_QueryInterface(ID3D11Multithread *iface,
3151         REFIID iid, void **out)
3152 {
3153     struct d3d11_device_context *context = impl_from_ID3D11Multithread(iface);
3154
3155     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
3156
3157     return d3d11_device_context_QueryInterface(&context->ID3D11DeviceContext1_iface, iid, out);
3158 }
3159
3160 static ULONG STDMETHODCALLTYPE d3d11_multithread_AddRef(ID3D11Multithread *iface)
3161 {
3162     struct d3d11_device_context *context = impl_from_ID3D11Multithread(iface);
3163
3164     TRACE("iface %p.\n", iface);
3165
3166     return d3d11_device_context_AddRef(&context->ID3D11DeviceContext1_iface);
3167 }
3168
3169 static ULONG STDMETHODCALLTYPE d3d11_multithread_Release(ID3D11Multithread *iface)
3170 {
3171     struct d3d11_device_context *context = impl_from_ID3D11Multithread(iface);
3172
3173     TRACE("iface %p.\n", iface);
3174
3175     return d3d11_device_context_Release(&context->ID3D11DeviceContext1_iface);
3176 }
3177
3178 static void STDMETHODCALLTYPE d3d11_multithread_Enter(ID3D11Multithread *iface)
3179 {
3180     TRACE("iface %p.\n", iface);
3181
3182     wined3d_mutex_lock();
3183 }
3184
3185 static void STDMETHODCALLTYPE d3d11_multithread_Leave(ID3D11Multithread *iface)
3186 {
3187     TRACE("iface %p.\n", iface);
3188
3189     wined3d_mutex_unlock();
3190 }
3191
3192 static BOOL STDMETHODCALLTYPE d3d11_multithread_SetMultithreadProtected(
3193         ID3D11Multithread *iface, BOOL enable)
3194 {
3195     FIXME("iface %p, enable %#x stub!\n", iface, enable);
3196
3197     return TRUE;
3198 }
3199
3200 static BOOL STDMETHODCALLTYPE d3d11_multithread_GetMultithreadProtected(ID3D11Multithread *iface)
3201 {
3202     FIXME("iface %p stub!\n", iface);
3203
3204     return TRUE;
3205 }
3206
3207 static const struct ID3D11MultithreadVtbl d3d11_multithread_vtbl =
3208 {
3209     d3d11_multithread_QueryInterface,
3210     d3d11_multithread_AddRef,
3211     d3d11_multithread_Release,
3212     d3d11_multithread_Enter,
3213     d3d11_multithread_Leave,
3214     d3d11_multithread_SetMultithreadProtected,
3215     d3d11_multithread_GetMultithreadProtected,
3216 };
3217
3218 static void d3d11_device_context_init(struct d3d11_device_context *context, struct d3d_device *device,
3219         D3D11_DEVICE_CONTEXT_TYPE type)
3220 {
3221     context->ID3D11DeviceContext1_iface.lpVtbl = &d3d11_device_context_vtbl;
3222     context->ID3D11Multithread_iface.lpVtbl = &d3d11_multithread_vtbl;
3223     context->refcount = 1;
3224     context->type = type;
3225
3226     context->device = device;
3227     ID3D11Device2_AddRef(&device->ID3D11Device2_iface);
3228
3229     wined3d_private_store_init(&context->private_store);
3230 }
3231
3232 /* ID3D11Device methods */
3233
3234 static HRESULT STDMETHODCALLTYPE d3d11_device_QueryInterface(ID3D11Device2 *iface, REFIID iid, void **out)
3235 {
3236     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3237     return IUnknown_QueryInterface(device->outer_unk, iid, out);
3238 }
3239
3240 static ULONG STDMETHODCALLTYPE d3d11_device_AddRef(ID3D11Device2 *iface)
3241 {
3242     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3243     return IUnknown_AddRef(device->outer_unk);
3244 }
3245
3246 static ULONG STDMETHODCALLTYPE d3d11_device_Release(ID3D11Device2 *iface)
3247 {
3248     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3249     return IUnknown_Release(device->outer_unk);
3250 }
3251
3252 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBuffer(ID3D11Device2 *iface, const D3D11_BUFFER_DESC *desc,
3253         const D3D11_SUBRESOURCE_DATA *data, ID3D11Buffer **buffer)
3254 {
3255     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3256     struct d3d_buffer *object;
3257     HRESULT hr;
3258
3259     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
3260
3261     if (FAILED(hr = d3d_buffer_create(device, desc, data, &object)))
3262         return hr;
3263
3264     *buffer = &object->ID3D11Buffer_iface;
3265
3266     return S_OK;
3267 }
3268
3269 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture1D(ID3D11Device2 *iface,
3270         const D3D11_TEXTURE1D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture1D **texture)
3271 {
3272     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3273     struct d3d_texture1d *object;
3274     HRESULT hr;
3275
3276     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
3277
3278     if (FAILED(hr = d3d_texture1d_create(device, desc, data, &object)))
3279         return hr;
3280
3281     *texture = &object->ID3D11Texture1D_iface;
3282
3283     return S_OK;
3284 }
3285
3286 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture2D(ID3D11Device2 *iface,
3287         const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture2D **texture)
3288 {
3289     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3290     struct d3d_texture2d *object;
3291     HRESULT hr;
3292
3293     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
3294
3295     if (FAILED(hr = d3d_texture2d_create(device, desc, data, &object)))
3296         return hr;
3297
3298     *texture = &object->ID3D11Texture2D_iface;
3299
3300     return S_OK;
3301 }
3302
3303 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture3D(ID3D11Device2 *iface,
3304         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture3D **texture)
3305 {
3306     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3307     struct d3d_texture3d *object;
3308     HRESULT hr;
3309
3310     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
3311
3312     if (FAILED(hr = d3d_texture3d_create(device, desc, data, &object)))
3313         return hr;
3314
3315     *texture = &object->ID3D11Texture3D_iface;
3316
3317     return S_OK;
3318 }
3319
3320 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateShaderResourceView(ID3D11Device2 *iface,
3321         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11ShaderResourceView **view)
3322 {
3323     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3324     struct d3d_shader_resource_view *object;
3325     HRESULT hr;
3326
3327     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
3328
3329     if (!resource)
3330         return E_INVALIDARG;
3331
3332     if (FAILED(hr = d3d_shader_resource_view_create(device, resource, desc, &object)))
3333         return hr;
3334
3335     *view = &object->ID3D11ShaderResourceView_iface;
3336
3337     return S_OK;
3338 }
3339
3340 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateUnorderedAccessView(ID3D11Device2 *iface,
3341         ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11UnorderedAccessView **view)
3342 {
3343     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3344     struct d3d11_unordered_access_view *object;
3345     HRESULT hr;
3346
3347     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
3348
3349     if (FAILED(hr = d3d11_unordered_access_view_create(device, resource, desc, &object)))
3350         return hr;
3351
3352     *view = &object->ID3D11UnorderedAccessView_iface;
3353
3354     return S_OK;
3355 }
3356
3357 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRenderTargetView(ID3D11Device2 *iface,
3358         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11RenderTargetView **view)
3359 {
3360     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3361     struct d3d_rendertarget_view *object;
3362     HRESULT hr;
3363
3364     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
3365
3366     if (!resource)
3367         return E_INVALIDARG;
3368
3369     if (FAILED(hr = d3d_rendertarget_view_create(device, resource, desc, &object)))
3370         return hr;
3371
3372     *view = &object->ID3D11RenderTargetView_iface;
3373
3374     return S_OK;
3375 }
3376
3377 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilView(ID3D11Device2 *iface,
3378         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11DepthStencilView **view)
3379 {
3380     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3381     struct d3d_depthstencil_view *object;
3382     HRESULT hr;
3383
3384     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
3385
3386     if (FAILED(hr = d3d_depthstencil_view_create(device, resource, desc, &object)))
3387         return hr;
3388
3389     *view = &object->ID3D11DepthStencilView_iface;
3390
3391     return S_OK;
3392 }
3393
3394 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateInputLayout(ID3D11Device2 *iface,
3395         const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count, const void *shader_byte_code,
3396         SIZE_T shader_byte_code_length, ID3D11InputLayout **input_layout)
3397 {
3398     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3399     struct d3d_input_layout *object;
3400     HRESULT hr;
3401
3402     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, shader_byte_code_length %lu, "
3403             "input_layout %p.\n", iface, element_descs, element_count, shader_byte_code,
3404             shader_byte_code_length, input_layout);
3405
3406     if (FAILED(hr = d3d_input_layout_create(device, element_descs, element_count,
3407             shader_byte_code, shader_byte_code_length, &object)))
3408         return hr;
3409
3410     *input_layout = &object->ID3D11InputLayout_iface;
3411
3412     return S_OK;
3413 }
3414
3415 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateVertexShader(ID3D11Device2 *iface, const void *byte_code,
3416         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11VertexShader **shader)
3417 {
3418     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3419     struct d3d_vertex_shader *object;
3420     HRESULT hr;
3421
3422     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3423             iface, byte_code, byte_code_length, class_linkage, shader);
3424
3425     if (class_linkage)
3426         FIXME("Class linkage is not implemented yet.\n");
3427
3428     if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
3429         return hr;
3430
3431     *shader = &object->ID3D11VertexShader_iface;
3432
3433     return S_OK;
3434 }
3435
3436 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShader(ID3D11Device2 *iface, const void *byte_code,
3437         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
3438 {
3439     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3440     struct d3d_geometry_shader *object;
3441     HRESULT hr;
3442
3443     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3444             iface, byte_code, byte_code_length, class_linkage, shader);
3445
3446     if (class_linkage)
3447         FIXME("Class linkage is not implemented yet.\n");
3448
3449     if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
3450             NULL, 0, NULL, 0, 0, &object)))
3451         return hr;
3452
3453     *shader = &object->ID3D11GeometryShader_iface;
3454
3455     return S_OK;
3456 }
3457
3458 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShaderWithStreamOutput(ID3D11Device2 *iface,
3459         const void *byte_code, SIZE_T byte_code_length, const D3D11_SO_DECLARATION_ENTRY *so_entries,
3460         UINT entry_count, const UINT *buffer_strides, UINT strides_count, UINT rasterizer_stream,
3461         ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
3462 {
3463     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3464     struct d3d_geometry_shader *object;
3465     HRESULT hr;
3466
3467     TRACE("iface %p, byte_code %p, byte_code_length %lu, so_entries %p, entry_count %u, "
3468             "buffer_strides %p, strides_count %u, rasterizer_stream %u, class_linkage %p, shader %p.\n",
3469             iface, byte_code, byte_code_length, so_entries, entry_count, buffer_strides, strides_count,
3470             rasterizer_stream, class_linkage, shader);
3471
3472     if (class_linkage)
3473         FIXME("Class linkage is not implemented yet.\n");
3474
3475     if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
3476             so_entries, entry_count, buffer_strides, strides_count, rasterizer_stream, &object)))
3477     {
3478         *shader = NULL;
3479         return hr;
3480     }
3481
3482     *shader = &object->ID3D11GeometryShader_iface;
3483
3484     return hr;
3485 }
3486
3487 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePixelShader(ID3D11Device2 *iface, const void *byte_code,
3488         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11PixelShader **shader)
3489 {
3490     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3491     struct d3d_pixel_shader *object;
3492     HRESULT hr;
3493
3494     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3495             iface, byte_code, byte_code_length, class_linkage, shader);
3496
3497     if (class_linkage)
3498         FIXME("Class linkage is not implemented yet.\n");
3499
3500     if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
3501         return hr;
3502
3503     *shader = &object->ID3D11PixelShader_iface;
3504
3505     return S_OK;
3506 }
3507
3508 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateHullShader(ID3D11Device2 *iface, const void *byte_code,
3509         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11HullShader **shader)
3510 {
3511     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3512     struct d3d11_hull_shader *object;
3513     HRESULT hr;
3514
3515     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3516             iface, byte_code, byte_code_length, class_linkage, shader);
3517
3518     if (class_linkage)
3519         FIXME("Class linkage is not implemented yet.\n");
3520
3521     if (FAILED(hr = d3d11_hull_shader_create(device, byte_code, byte_code_length, &object)))
3522         return hr;
3523
3524     *shader = &object->ID3D11HullShader_iface;
3525
3526     return S_OK;
3527 }
3528
3529 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDomainShader(ID3D11Device2 *iface, const void *byte_code,
3530         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11DomainShader **shader)
3531 {
3532     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3533     struct d3d11_domain_shader *object;
3534     HRESULT hr;
3535
3536     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3537             iface, byte_code, byte_code_length, class_linkage, shader);
3538
3539     if (class_linkage)
3540         FIXME("Class linkage is not implemented yet.\n");
3541
3542     if (FAILED(hr = d3d11_domain_shader_create(device, byte_code, byte_code_length, &object)))
3543         return hr;
3544
3545     *shader = &object->ID3D11DomainShader_iface;
3546
3547     return S_OK;
3548 }
3549
3550 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateComputeShader(ID3D11Device2 *iface, const void *byte_code,
3551         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11ComputeShader **shader)
3552 {
3553     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3554     struct d3d11_compute_shader *object;
3555     HRESULT hr;
3556
3557     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
3558             iface, byte_code, byte_code_length, class_linkage, shader);
3559
3560     if (class_linkage)
3561         FIXME("Class linkage is not implemented yet.\n");
3562
3563     if (FAILED(hr = d3d11_compute_shader_create(device, byte_code, byte_code_length, &object)))
3564         return hr;
3565
3566     *shader = &object->ID3D11ComputeShader_iface;
3567
3568     return S_OK;
3569 }
3570
3571 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateClassLinkage(ID3D11Device2 *iface,
3572         ID3D11ClassLinkage **class_linkage)
3573 {
3574     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3575     struct d3d11_class_linkage *object;
3576     HRESULT hr;
3577
3578     TRACE("iface %p, class_linkage %p.\n", iface, class_linkage);
3579
3580     if (FAILED(hr = d3d11_class_linkage_create(device, &object)))
3581         return hr;
3582
3583     *class_linkage = &object->ID3D11ClassLinkage_iface;
3584
3585     return S_OK;
3586 }
3587
3588 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBlendState(ID3D11Device2 *iface,
3589         const D3D11_BLEND_DESC *desc, ID3D11BlendState **blend_state)
3590 {
3591     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3592     struct d3d_blend_state *object;
3593     HRESULT hr;
3594
3595     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
3596
3597     if (FAILED(hr = d3d_blend_state_create(device, desc, &object)))
3598         return hr;
3599
3600     *blend_state = &object->ID3D11BlendState_iface;
3601
3602     return S_OK;
3603 }
3604
3605 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilState(ID3D11Device2 *iface,
3606         const D3D11_DEPTH_STENCIL_DESC *desc, ID3D11DepthStencilState **depth_stencil_state)
3607 {
3608     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3609     struct d3d_depthstencil_state *object;
3610     HRESULT hr;
3611
3612     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
3613
3614     if (FAILED(hr = d3d_depthstencil_state_create(device, desc, &object)))
3615         return hr;
3616
3617     *depth_stencil_state = &object->ID3D11DepthStencilState_iface;
3618
3619     return S_OK;
3620 }
3621
3622 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device2 *iface,
3623         const D3D11_RASTERIZER_DESC *desc, ID3D11RasterizerState **rasterizer_state)
3624 {
3625     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3626     struct d3d_rasterizer_state *object;
3627     HRESULT hr;
3628
3629     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
3630
3631     if (FAILED(hr = d3d_rasterizer_state_create(device, desc, &object)))
3632         return hr;
3633
3634     *rasterizer_state = &object->ID3D11RasterizerState_iface;
3635
3636     return S_OK;
3637 }
3638
3639 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateSamplerState(ID3D11Device2 *iface,
3640         const D3D11_SAMPLER_DESC *desc, ID3D11SamplerState **sampler_state)
3641 {
3642     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3643     struct d3d_sampler_state *object;
3644     HRESULT hr;
3645
3646     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
3647
3648     if (FAILED(hr = d3d_sampler_state_create(device, desc, &object)))
3649         return hr;
3650
3651     *sampler_state = &object->ID3D11SamplerState_iface;
3652
3653     return S_OK;
3654 }
3655
3656 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateQuery(ID3D11Device2 *iface,
3657         const D3D11_QUERY_DESC *desc, ID3D11Query **query)
3658 {
3659     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3660     struct d3d_query *object;
3661     HRESULT hr;
3662
3663     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
3664
3665     if (FAILED(hr = d3d_query_create(device, desc, FALSE, &object)))
3666         return hr;
3667
3668     if (query)
3669     {
3670         *query = &object->ID3D11Query_iface;
3671         return S_OK;
3672     }
3673
3674     ID3D11Query_Release(&object->ID3D11Query_iface);
3675     return S_FALSE;
3676 }
3677
3678 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePredicate(ID3D11Device2 *iface, const D3D11_QUERY_DESC *desc,
3679         ID3D11Predicate **predicate)
3680 {
3681     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3682     struct d3d_query *object;
3683     HRESULT hr;
3684
3685     TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
3686
3687     if (FAILED(hr = d3d_query_create(device, desc, TRUE, &object)))
3688         return hr;
3689
3690     if (predicate)
3691     {
3692         *predicate = (ID3D11Predicate *)&object->ID3D11Query_iface;
3693         return S_OK;
3694     }
3695
3696     ID3D11Query_Release(&object->ID3D11Query_iface);
3697     return S_FALSE;
3698 }
3699
3700 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateCounter(ID3D11Device2 *iface, const D3D11_COUNTER_DESC *desc,
3701         ID3D11Counter **counter)
3702 {
3703     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
3704
3705     return E_NOTIMPL;
3706 }
3707
3708 static HRESULT d3d11_deferred_context_create(struct d3d_device *device,
3709         UINT flags, struct d3d11_device_context **context)
3710 {
3711     struct d3d11_device_context *object;
3712     HRESULT hr;
3713
3714     if (flags)
3715         FIXME("Ignoring flags %#x.\n", flags);
3716
3717     if (!(object = heap_alloc_zero(sizeof(*object))))
3718         return E_OUTOFMEMORY;
3719     d3d11_device_context_init(object, device, D3D11_DEVICE_CONTEXT_DEFERRED);
3720
3721     wined3d_mutex_lock();
3722     if (FAILED(hr = wined3d_deferred_context_create(device->wined3d_device, &object->wined3d_context)))
3723     {
3724         WARN("Failed to create wined3d deferred context, hr %#x.\n", hr);
3725         heap_free(object);
3726         wined3d_mutex_unlock();
3727         return hr;
3728     }
3729     wined3d_mutex_unlock();
3730
3731     TRACE("Created deferred context %p.\n", object);
3732     *context = object;
3733
3734     return S_OK;
3735 }
3736
3737 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext(ID3D11Device2 *iface, UINT flags,
3738         ID3D11DeviceContext **context)
3739 {
3740     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3741     struct d3d11_device_context *object;
3742     HRESULT hr;
3743
3744     TRACE("iface %p, flags %#x, context %p.\n", iface, flags, context);
3745
3746     if (FAILED(hr = d3d11_deferred_context_create(device, flags, &object)))
3747         return hr;
3748
3749     *context = (ID3D11DeviceContext *)&object->ID3D11DeviceContext1_iface;
3750     return S_OK;
3751 }
3752
3753 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource(ID3D11Device2 *iface, HANDLE resource, REFIID iid,
3754         void **out)
3755 {
3756     FIXME("iface %p, resource %p, iid %s, out %p stub!\n", iface, resource, debugstr_guid(iid), out);
3757
3758     return E_NOTIMPL;
3759 }
3760
3761 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device2 *iface, DXGI_FORMAT format,
3762         UINT *format_support)
3763 {
3764     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3765     struct wined3d_device_creation_parameters params;
3766     struct wined3d_adapter *wined3d_adapter;
3767     enum wined3d_format_id wined3d_format;
3768     D3D_FEATURE_LEVEL feature_level;
3769     struct wined3d *wined3d;
3770     unsigned int i;
3771
3772     static const struct
3773     {
3774         enum wined3d_resource_type rtype;
3775         unsigned int bind_flags;
3776         unsigned int usage;
3777         D3D11_FORMAT_SUPPORT flag;
3778     }
3779     flag_mapping[] =
3780     {
3781         {WINED3D_RTYPE_BUFFER,     WINED3D_BIND_SHADER_RESOURCE, 0, D3D11_FORMAT_SUPPORT_BUFFER},
3782         {WINED3D_RTYPE_TEXTURE_1D, WINED3D_BIND_SHADER_RESOURCE, 0, D3D11_FORMAT_SUPPORT_TEXTURE1D},
3783         {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_SHADER_RESOURCE, 0, D3D11_FORMAT_SUPPORT_TEXTURE2D},
3784         {WINED3D_RTYPE_TEXTURE_3D, WINED3D_BIND_SHADER_RESOURCE, 0, D3D11_FORMAT_SUPPORT_TEXTURE3D},
3785         {WINED3D_RTYPE_NONE,       WINED3D_BIND_RENDER_TARGET,   0, D3D11_FORMAT_SUPPORT_RENDER_TARGET},
3786         {WINED3D_RTYPE_NONE,       WINED3D_BIND_DEPTH_STENCIL,   0, D3D11_FORMAT_SUPPORT_DEPTH_STENCIL},
3787         {WINED3D_RTYPE_NONE,       WINED3D_BIND_UNORDERED_ACCESS, 0, D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW},
3788         {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_SHADER_RESOURCE, WINED3DUSAGE_QUERY_WRAPANDMIP, D3D11_FORMAT_SUPPORT_MIP},
3789         {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_SHADER_RESOURCE, WINED3DUSAGE_QUERY_GENMIPMAP, D3D11_FORMAT_SUPPORT_MIP_AUTOGEN},
3790         {WINED3D_RTYPE_NONE,       WINED3D_BIND_RENDER_TARGET, WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3D11_FORMAT_SUPPORT_BLENDABLE},
3791     };
3792     HRESULT hr;
3793
3794     FIXME("iface %p, format %u, format_support %p partial-stub!\n", iface, format, format_support);
3795
3796     wined3d_format = wined3dformat_from_dxgi_format(format);
3797     if (format && !wined3d_format)
3798     {
3799         WARN("Invalid format %#x.\n", format);
3800         *format_support = 0;
3801         return E_FAIL;
3802     }
3803
3804     *format_support = 0;
3805
3806     wined3d_mutex_lock();
3807     feature_level = device->state->feature_level;
3808     wined3d = wined3d_device_get_wined3d(device->wined3d_device);
3809     wined3d_device_get_creation_parameters(device->wined3d_device, &params);
3810     wined3d_adapter = wined3d_get_adapter(wined3d, params.adapter_idx);
3811     for (i = 0; i < ARRAY_SIZE(flag_mapping); ++i)
3812     {
3813         hr = wined3d_check_device_format(wined3d, wined3d_adapter, params.device_type,
3814                 WINED3DFMT_UNKNOWN, flag_mapping[i].usage, flag_mapping[i].bind_flags, flag_mapping[i].rtype, wined3d_format);
3815         if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DOK_NOMIPGEN)
3816             continue;
3817         if (hr != WINED3D_OK)
3818         {
3819             WARN("Failed to check device format support, hr %#x.\n", hr);
3820             wined3d_mutex_unlock();
3821             return E_FAIL;
3822         }
3823
3824         *format_support |= flag_mapping[i].flag;
3825     }
3826     wined3d_mutex_unlock();
3827
3828     if (feature_level < D3D_FEATURE_LEVEL_10_0)
3829         *format_support &= ~D3D11_FORMAT_SUPPORT_BUFFER;
3830
3831     if (*format_support & (D3D11_FORMAT_SUPPORT_TEXTURE1D
3832             | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D))
3833     {
3834         *format_support |= D3D11_FORMAT_SUPPORT_SHADER_LOAD;
3835         *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE;
3836         *format_support |= D3D11_FORMAT_SUPPORT_TEXTURECUBE;
3837
3838         if (feature_level >= D3D_FEATURE_LEVEL_10_1)
3839             *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER;
3840
3841         if (*format_support & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)
3842         {
3843             if (feature_level >= D3D_FEATURE_LEVEL_10_0)
3844                 *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON;
3845
3846             if (feature_level >= D3D_FEATURE_LEVEL_10_1)
3847                 *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON;
3848         }
3849     }
3850
3851     /* d3d11 requires 4 and 8 sample counts support for formats reported to
3852      * support multisample. */
3853     if (wined3d_check_device_multisample_type(wined3d_adapter, params.device_type, wined3d_format,
3854             TRUE, WINED3D_MULTISAMPLE_4_SAMPLES, NULL) == WINED3D_OK &&
3855             wined3d_check_device_multisample_type(wined3d_adapter, params.device_type, wined3d_format,
3856             TRUE, WINED3D_MULTISAMPLE_8_SAMPLES, NULL) == WINED3D_OK)
3857     {
3858         *format_support |= D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE
3859                 | D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET
3860                 | D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD;
3861     }
3862
3863     return S_OK;
3864 }
3865
3866 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckMultisampleQualityLevels(ID3D11Device2 *iface,
3867         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
3868 {
3869     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3870     struct wined3d_device_creation_parameters params;
3871     struct wined3d_adapter *wined3d_adapter;
3872     struct wined3d *wined3d;
3873     HRESULT hr;
3874
3875     TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
3876             iface, debug_dxgi_format(format), sample_count, quality_level_count);
3877
3878     if (!quality_level_count)
3879         return E_INVALIDARG;
3880
3881     *quality_level_count = 0;
3882
3883     if (!sample_count)
3884         return E_FAIL;
3885     if (sample_count == 1)
3886     {
3887         *quality_level_count = 1;
3888         return S_OK;
3889     }
3890     if (sample_count > D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT)
3891         return E_FAIL;
3892
3893     wined3d_mutex_lock();
3894     wined3d = wined3d_device_get_wined3d(device->wined3d_device);
3895     wined3d_device_get_creation_parameters(device->wined3d_device, &params);
3896     wined3d_adapter = wined3d_get_adapter(wined3d, params.adapter_idx);
3897     hr = wined3d_check_device_multisample_type(wined3d_adapter, params.device_type,
3898             wined3dformat_from_dxgi_format(format), TRUE, sample_count, quality_level_count);
3899     wined3d_mutex_unlock();
3900
3901     if (hr == WINED3DERR_INVALIDCALL)
3902         return E_INVALIDARG;
3903     if (hr == WINED3DERR_NOTAVAILABLE)
3904         return S_OK;
3905     return hr;
3906 }
3907
3908 static void STDMETHODCALLTYPE d3d11_device_CheckCounterInfo(ID3D11Device2 *iface, D3D11_COUNTER_INFO *info)
3909 {
3910     FIXME("iface %p, info %p stub!\n", iface, info);
3911 }
3912
3913 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckCounter(ID3D11Device2 *iface, const D3D11_COUNTER_DESC *desc,
3914         D3D11_COUNTER_TYPE *type, UINT *active_counter_count, char *name, UINT *name_length,
3915         char *units, UINT *units_length, char *description, UINT *description_length)
3916 {
3917     FIXME("iface %p, desc %p, type %p, active_counter_count %p, name %p, name_length %p, "
3918             "units %p, units_length %p, description %p, description_length %p stub!\n",
3919             iface, desc, type, active_counter_count, name, name_length,
3920             units, units_length, description, description_length);
3921
3922     return E_NOTIMPL;
3923 }
3924
3925 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFeatureSupport(ID3D11Device2 *iface, D3D11_FEATURE feature,
3926         void *feature_support_data, UINT feature_support_data_size)
3927 {
3928     struct d3d_device *device = impl_from_ID3D11Device2(iface);
3929     struct wined3d_caps wined3d_caps;
3930     HRESULT hr;
3931
3932     TRACE("iface %p, feature %u, feature_support_data %p, feature_support_data_size %u.\n",
3933             iface, feature, feature_support_data, feature_support_data_size);
3934
3935     switch (feature)
3936     {
3937         case D3D11_FEATURE_THREADING:
3938         {
3939             D3D11_FEATURE_DATA_THREADING *threading_data = feature_support_data;
3940             if (feature_support_data_size != sizeof(*threading_data))
3941             {
3942                 WARN("Invalid data size.\n");
3943                 return E_INVALIDARG;
3944             }
3945
3946             /* We lie about the threading support to make Tomb Raider 2013 and
3947              * Deus Ex: Human Revolution happy. */
3948             FIXME("Returning fake threading support data.\n");
3949             threading_data->DriverConcurrentCreates = TRUE;
3950             threading_data->DriverCommandLists = TRUE;
3951             return S_OK;
3952         }
3953
3954         case D3D11_FEATURE_DOUBLES:
3955         {
3956             D3D11_FEATURE_DATA_DOUBLES *doubles_data = feature_support_data;
3957             if (feature_support_data_size != sizeof(*doubles_data))
3958             {
3959                 WARN("Invalid data size.\n");
3960                 return E_INVALIDARG;
3961             }
3962
3963             wined3d_mutex_lock();
3964             hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
3965             wined3d_mutex_unlock();
3966             if (FAILED(hr))
3967             {
3968                 WARN("Failed to get device caps, hr %#x.\n", hr);
3969                 return hr;
3970             }
3971
3972             doubles_data->DoublePrecisionFloatShaderOps = wined3d_caps.shader_double_precision;
3973             return S_OK;
3974         }
3975
3976         case D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS:
3977         {
3978             D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS *options = feature_support_data;
3979             if (feature_support_data_size != sizeof(*options))
3980             {
3981                 WARN("Invalid data size.\n");
3982                 return E_INVALIDARG;
3983             }
3984
3985             wined3d_mutex_lock();
3986             hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
3987             wined3d_mutex_unlock();
3988             if (FAILED(hr))
3989             {
3990                 WARN("Failed to get device caps, hr %#x.\n", hr);
3991                 return hr;
3992             }
3993
3994             options->ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x
3995                     = wined3d_caps.max_feature_level >= WINED3D_FEATURE_LEVEL_11;
3996             return S_OK;
3997         }
3998
3999         case D3D11_FEATURE_D3D11_OPTIONS:
4000         {
4001             D3D11_FEATURE_DATA_D3D11_OPTIONS *options = feature_support_data;
4002             if (feature_support_data_size != sizeof(*options))
4003             {
4004                 WARN("Invalid data size.\n");
4005                 return E_INVALIDARG;
4006             }
4007
4008             FIXME("Returning fake Options support data.\n");
4009             options->OutputMergerLogicOp = FALSE;
4010             options->UAVOnlyRenderingForcedSampleCount = FALSE;
4011             options->DiscardAPIsSeenByDriver = FALSE;
4012             options->FlagsForUpdateAndCopySeenByDriver = FALSE;
4013             options->ClearView = FALSE;
4014             options->CopyWithOverlap = FALSE;
4015             options->ConstantBufferPartialUpdate = FALSE;
4016             options->ConstantBufferOffsetting = FALSE;
4017             options->MapNoOverwriteOnDynamicConstantBuffer = FALSE;
4018             options->MapNoOverwriteOnDynamicBufferSRV = FALSE;
4019             options->MultisampleRTVWithForcedSampleCountOne = FALSE;
4020             options->SAD4ShaderInstructions = FALSE;
4021             options->ExtendedDoublesShaderInstructions = FALSE;
4022             options->ExtendedResourceSharing = FALSE;
4023             return S_OK;
4024         }
4025
4026         case D3D11_FEATURE_D3D11_OPTIONS1:
4027         {
4028             D3D11_FEATURE_DATA_D3D11_OPTIONS1 *options = feature_support_data;
4029             if (feature_support_data_size != sizeof(*options))
4030             {
4031                 WARN("Invalid data size.\n");
4032                 return E_INVALIDARG;
4033             }
4034
4035             FIXME("Returning fake Options1 support data.\n");
4036             options->TiledResourcesTier = D3D11_TILED_RESOURCES_NOT_SUPPORTED;
4037             options->MinMaxFiltering = FALSE;
4038             options->ClearViewAlsoSupportsDepthOnlyFormats = FALSE;
4039             options->MapOnDefaultBuffers = FALSE;
4040             return S_OK;
4041         }
4042
4043         case D3D11_FEATURE_D3D11_OPTIONS3:
4044         {
4045             D3D11_FEATURE_DATA_D3D11_OPTIONS3 *options = feature_support_data;
4046             if (feature_support_data_size != sizeof(*options))
4047             {
4048                 WARN("Invalid data size.\n");
4049                 return E_INVALIDARG;
4050             }
4051
4052             wined3d_mutex_lock();
4053             hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
4054             wined3d_mutex_unlock();
4055             if (FAILED(hr))
4056             {
4057                 WARN("Failed to get device caps, hr %#x.\n", hr);
4058                 return hr;
4059             }
4060
4061             options->VPAndRTArrayIndexFromAnyShaderFeedingRasterizer
4062                     = wined3d_caps.viewport_array_index_any_shader;
4063             return S_OK;
4064         }
4065
4066         case D3D11_FEATURE_ARCHITECTURE_INFO:
4067         {
4068             D3D11_FEATURE_DATA_ARCHITECTURE_INFO *options = feature_support_data;
4069             if (feature_support_data_size != sizeof(*options))
4070             {
4071                 WARN("Invalid data size.\n");
4072                 return E_INVALIDARG;
4073             }
4074
4075             FIXME("Returning fake data architecture info.\n");
4076             options->TileBasedDeferredRenderer = FALSE;
4077             return S_OK;
4078         }
4079
4080         default:
4081             FIXME("Unhandled feature %#x.\n", feature);
4082             return E_NOTIMPL;
4083     }
4084 }
4085
4086 static HRESULT STDMETHODCALLTYPE d3d11_device_GetPrivateData(ID3D11Device2 *iface, REFGUID guid,
4087         UINT *data_size, void *data)
4088 {
4089     IDXGIDevice *dxgi_device;
4090     HRESULT hr;
4091
4092     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4093
4094     if (FAILED(hr = ID3D11Device2_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
4095         return hr;
4096     hr = IDXGIDevice_GetPrivateData(dxgi_device, guid, data_size, data);
4097     IDXGIDevice_Release(dxgi_device);
4098
4099     return hr;
4100 }
4101
4102 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateData(ID3D11Device2 *iface, REFGUID guid,
4103         UINT data_size, const void *data)
4104 {
4105     IDXGIDevice *dxgi_device;
4106     HRESULT hr;
4107
4108     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4109
4110     if (FAILED(hr = ID3D11Device2_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
4111         return hr;
4112     hr = IDXGIDevice_SetPrivateData(dxgi_device, guid, data_size, data);
4113     IDXGIDevice_Release(dxgi_device);
4114
4115     return hr;
4116 }
4117
4118 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateDataInterface(ID3D11Device2 *iface, REFGUID guid,
4119         const IUnknown *data)
4120 {
4121     IDXGIDevice *dxgi_device;
4122     HRESULT hr;
4123
4124     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
4125
4126     if (FAILED(hr = ID3D11Device2_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
4127         return hr;
4128     hr = IDXGIDevice_SetPrivateDataInterface(dxgi_device, guid, data);
4129     IDXGIDevice_Release(dxgi_device);
4130
4131     return hr;
4132 }
4133
4134 static D3D_FEATURE_LEVEL STDMETHODCALLTYPE d3d11_device_GetFeatureLevel(ID3D11Device2 *iface)
4135 {
4136     struct d3d_device *device = impl_from_ID3D11Device2(iface);
4137
4138     TRACE("iface %p.\n", iface);
4139
4140     return device->state->feature_level;
4141 }
4142
4143 static UINT STDMETHODCALLTYPE d3d11_device_GetCreationFlags(ID3D11Device2 *iface)
4144 {
4145     FIXME("iface %p stub!\n", iface);
4146
4147     return 0;
4148 }
4149
4150 static HRESULT STDMETHODCALLTYPE d3d11_device_GetDeviceRemovedReason(ID3D11Device2 *iface)
4151 {
4152     WARN("iface %p stub!\n", iface);
4153
4154     return S_OK;
4155 }
4156
4157 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext(ID3D11Device2 *iface,
4158         ID3D11DeviceContext **immediate_context)
4159 {
4160     struct d3d_device *device = impl_from_ID3D11Device2(iface);
4161
4162     TRACE("iface %p, immediate_context %p.\n", iface, immediate_context);
4163
4164     *immediate_context = (ID3D11DeviceContext *)&device->immediate_context.ID3D11DeviceContext1_iface;
4165     ID3D11DeviceContext_AddRef(*immediate_context);
4166 }
4167
4168 static HRESULT STDMETHODCALLTYPE d3d11_device_SetExceptionMode(ID3D11Device2 *iface, UINT flags)
4169 {
4170     FIXME("iface %p, flags %#x stub!\n", iface, flags);
4171
4172     return E_NOTIMPL;
4173 }
4174
4175 static UINT STDMETHODCALLTYPE d3d11_device_GetExceptionMode(ID3D11Device2 *iface)
4176 {
4177     FIXME("iface %p stub!\n", iface);
4178
4179     return 0;
4180 }
4181
4182 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext1(ID3D11Device2 *iface,
4183         ID3D11DeviceContext1 **immediate_context)
4184 {
4185     struct d3d_device *device = impl_from_ID3D11Device2(iface);
4186
4187     TRACE("iface %p, immediate_context %p.\n", iface, immediate_context);
4188
4189     *immediate_context = &device->immediate_context.ID3D11DeviceContext1_iface;
4190     ID3D11DeviceContext1_AddRef(*immediate_context);
4191 }
4192
4193 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext1(ID3D11Device2 *iface, UINT flags,
4194         ID3D11DeviceContext1 **context)
4195 {
4196     struct d3d_device *device = impl_from_ID3D11Device2(iface);
4197     struct d3d11_device_context *object;
4198     HRESULT hr;
4199
4200     TRACE("iface %p, flags %#x, context %p.\n", iface, flags, context);
4201
4202     if (FAILED(hr = d3d11_deferred_context_create(device, flags, &object)))
4203         return hr;
4204
4205     *context = &object->ID3D11DeviceContext1_iface;
4206     return S_OK;
4207 }
4208
4209 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBlendState1(ID3D11Device2 *iface,
4210         const D3D11_BLEND_DESC1 *desc, ID3D11BlendState1 **state)
4211 {
4212     FIXME("iface %p, desc %p, state %p stub!\n", iface, desc, state);
4213
4214     return E_NOTIMPL;
4215 }
4216
4217 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState1(ID3D11Device2 *iface,
4218         const D3D11_RASTERIZER_DESC1 *desc, ID3D11RasterizerState1 **state)
4219 {
4220     FIXME("iface %p, desc %p, state %p stub!\n", iface, desc, state);
4221
4222     return E_NOTIMPL;
4223 }
4224
4225 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeviceContextState(ID3D11Device2 *iface, UINT flags,
4226         const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, UINT sdk_version,
4227         REFIID emulated_interface, D3D_FEATURE_LEVEL *chosen_feature_level, ID3DDeviceContextState **state)
4228 {
4229     struct d3d_device *device = impl_from_ID3D11Device2(iface);
4230     struct d3d_device_context_state *state_impl;
4231     struct wined3d_state *wined3d_state;
4232     D3D_FEATURE_LEVEL feature_level;
4233     HRESULT hr = E_INVALIDARG;
4234
4235     TRACE("iface %p, flags %#x, feature_levels %p, feature_level_count %u, "
4236             "sdk_version %u, emulated_interface %s, chosen_feature_level %p, state %p.\n",
4237             iface, flags, feature_levels, feature_level_count,
4238             sdk_version, debugstr_guid(emulated_interface), chosen_feature_level, state);
4239
4240     if (flags)
4241         FIXME("Ignoring flags %#x.\n", flags);
4242
4243     wined3d_mutex_lock();
4244
4245     if (!feature_level_count)
4246         goto fail;
4247
4248     if (FAILED(hr = wined3d_state_create(device->wined3d_device,
4249             (const enum wined3d_feature_level *)feature_levels, feature_level_count, &wined3d_state)))
4250         goto fail;
4251     feature_level = d3d_feature_level_from_wined3d(wined3d_state_get_feature_level(wined3d_state));
4252
4253     if (chosen_feature_level)
4254         *chosen_feature_level = feature_level;
4255
4256     if (!state)
4257     {
4258         wined3d_state_destroy(wined3d_state);
4259         wined3d_mutex_unlock();
4260         return S_FALSE;
4261     }
4262
4263     if (!(state_impl = heap_alloc_zero(sizeof(*state_impl))))
4264     {
4265         wined3d_state_destroy(wined3d_state);
4266         hr = E_OUTOFMEMORY;
4267         goto fail;
4268     }
4269
4270     d3d_device_context_state_init(state_impl, device, feature_level, emulated_interface);
4271     if (!d3d_device_context_state_add_entry(state_impl, device, wined3d_state))
4272     {
4273         wined3d_state_destroy(wined3d_state);
4274         ID3DDeviceContextState_Release(&state_impl->ID3DDeviceContextState_iface);
4275         hr = E_FAIL;
4276         goto fail;
4277     }
4278
4279     *state = &state_impl->ID3DDeviceContextState_iface;
4280     device->d3d11_only = FALSE;
4281     wined3d_mutex_unlock();
4282
4283     return S_OK;
4284
4285 fail:
4286     wined3d_mutex_unlock();
4287     if (chosen_feature_level)
4288         *chosen_feature_level = 0;
4289     if (state)
4290         *state = NULL;
4291     return hr;
4292 }
4293
4294 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource1(ID3D11Device2 *iface, HANDLE handle,
4295         REFIID iid, void **resource)
4296 {
4297     FIXME("iface %p, handle %p, iid %s, resource %p stub!\n", iface, handle, debugstr_guid(iid), resource);
4298
4299     return E_NOTIMPL;
4300 }
4301
4302 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResourceByName(ID3D11Device2 *iface, const WCHAR *name,
4303         DWORD access, REFIID iid, void **resource)
4304 {
4305     FIXME("iface %p, name %s, access %#x, iid %s, resource %p stub!\n", iface, debugstr_w(name), access,
4306             debugstr_guid(iid), resource);
4307
4308     return E_NOTIMPL;
4309 }
4310
4311 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext2(ID3D11Device2 *iface,
4312         ID3D11DeviceContext2 **context)
4313 {
4314     FIXME("iface %p, context %p stub!\n", iface, context);
4315 }
4316
4317 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext2(ID3D11Device2 *iface,
4318         UINT flags, ID3D11DeviceContext2 **context)
4319 {
4320     FIXME("iface %p, flags %#x, context %p stub!\n", iface, flags, context);
4321
4322     return E_NOTIMPL;
4323 }
4324
4325 static void STDMETHODCALLTYPE d3d11_device_GetResourceTiling(ID3D11Device2 *iface,
4326         ID3D11Resource *resource, UINT *tile_count, D3D11_PACKED_MIP_DESC *mip_desc,
4327         D3D11_TILE_SHAPE *tile_shape, UINT *subresource_tiling_count, UINT first_subresource_tiling,
4328         D3D11_SUBRESOURCE_TILING *subresource_tiling)
4329 {
4330     FIXME("iface %p, resource %p, tile_count %p, mip_desc %p, tile_shape %p, "
4331             "subresource_tiling_count %p, first_subresource_tiling %u, subresource_tiling %p stub!\n",
4332             iface, resource, tile_count, mip_desc, tile_shape,
4333             subresource_tiling_count, first_subresource_tiling, subresource_tiling);
4334 }
4335
4336 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckMultisampleQualityLevels1(ID3D11Device2 *iface,
4337         DXGI_FORMAT format, UINT sample_count, UINT flags, UINT *quality_level_count)
4338 {
4339     FIXME("iface %p, format %#x, sample_count %u, flags %#x, quality_level_count %p stub!\n",
4340             iface, format, sample_count, flags, quality_level_count);
4341
4342     return E_NOTIMPL;
4343 }
4344
4345 static const struct ID3D11Device2Vtbl d3d11_device_vtbl =
4346 {
4347     /* IUnknown methods */
4348     d3d11_device_QueryInterface,
4349     d3d11_device_AddRef,
4350     d3d11_device_Release,
4351     /* ID3D11Device methods */
4352     d3d11_device_CreateBuffer,
4353     d3d11_device_CreateTexture1D,
4354     d3d11_device_CreateTexture2D,
4355     d3d11_device_CreateTexture3D,
4356     d3d11_device_CreateShaderResourceView,
4357     d3d11_device_CreateUnorderedAccessView,
4358     d3d11_device_CreateRenderTargetView,
4359     d3d11_device_CreateDepthStencilView,
4360     d3d11_device_CreateInputLayout,
4361     d3d11_device_CreateVertexShader,
4362     d3d11_device_CreateGeometryShader,
4363     d3d11_device_CreateGeometryShaderWithStreamOutput,
4364     d3d11_device_CreatePixelShader,
4365     d3d11_device_CreateHullShader,
4366     d3d11_device_CreateDomainShader,
4367     d3d11_device_CreateComputeShader,
4368     d3d11_device_CreateClassLinkage,
4369     d3d11_device_CreateBlendState,
4370     d3d11_device_CreateDepthStencilState,
4371     d3d11_device_CreateRasterizerState,
4372     d3d11_device_CreateSamplerState,
4373     d3d11_device_CreateQuery,
4374     d3d11_device_CreatePredicate,
4375     d3d11_device_CreateCounter,
4376     d3d11_device_CreateDeferredContext,
4377     d3d11_device_OpenSharedResource,
4378     d3d11_device_CheckFormatSupport,
4379     d3d11_device_CheckMultisampleQualityLevels,
4380     d3d11_device_CheckCounterInfo,
4381     d3d11_device_CheckCounter,
4382     d3d11_device_CheckFeatureSupport,
4383     d3d11_device_GetPrivateData,
4384     d3d11_device_SetPrivateData,
4385     d3d11_device_SetPrivateDataInterface,
4386     d3d11_device_GetFeatureLevel,
4387     d3d11_device_GetCreationFlags,
4388     d3d11_device_GetDeviceRemovedReason,
4389     d3d11_device_GetImmediateContext,
4390     d3d11_device_SetExceptionMode,
4391     d3d11_device_GetExceptionMode,
4392     /* ID3D11Device1 methods */
4393     d3d11_device_GetImmediateContext1,
4394     d3d11_device_CreateDeferredContext1,
4395     d3d11_device_CreateBlendState1,
4396     d3d11_device_CreateRasterizerState1,
4397     d3d11_device_CreateDeviceContextState,
4398     d3d11_device_OpenSharedResource1,
4399     d3d11_device_OpenSharedResourceByName,
4400     /* ID3D11Device2 methods */
4401     d3d11_device_GetImmediateContext2,
4402     d3d11_device_CreateDeferredContext2,
4403     d3d11_device_GetResourceTiling,
4404     d3d11_device_CheckMultisampleQualityLevels1,
4405 };
4406
4407 /* Inner IUnknown methods */
4408
4409 static inline struct d3d_device *impl_from_IUnknown(IUnknown *iface)
4410 {
4411     return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
4412 }
4413
4414 static HRESULT STDMETHODCALLTYPE d3d_device_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out)
4415 {
4416     struct d3d_device *device = impl_from_IUnknown(iface);
4417
4418     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
4419
4420     if (IsEqualGUID(riid, &IID_ID3D11Device2)
4421             || IsEqualGUID(riid, &IID_ID3D11Device1)
4422             || IsEqualGUID(riid, &IID_ID3D11Device)
4423             || IsEqualGUID(riid, &IID_IUnknown))
4424     {
4425         *out = &device->ID3D11Device2_iface;
4426     }
4427     else if (!device->d3d11_only
4428             && (IsEqualGUID(riid, &IID_ID3D10Device1)
4429             || IsEqualGUID(riid, &IID_ID3D10Device)))
4430     {
4431         *out = &device->ID3D10Device1_iface;
4432     }
4433     else if (IsEqualGUID(riid, &IID_ID3D10Multithread))
4434     {
4435         *out = &device->ID3D10Multithread_iface;
4436     }
4437     else if (IsEqualGUID(riid, &IID_IWineDXGIDeviceParent))
4438     {
4439         *out = &device->IWineDXGIDeviceParent_iface;
4440     }
4441     else
4442     {
4443         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
4444         *out = NULL;
4445         return E_NOINTERFACE;
4446     }
4447
4448     IUnknown_AddRef((IUnknown *)*out);
4449     return S_OK;
4450 }
4451
4452 static ULONG STDMETHODCALLTYPE d3d_device_inner_AddRef(IUnknown *iface)
4453 {
4454     struct d3d_device *device = impl_from_IUnknown(iface);
4455     ULONG refcount = InterlockedIncrement(&device->refcount);
4456
4457     TRACE("%p increasing refcount to %u.\n", device, refcount);
4458
4459     return refcount;
4460 }
4461
4462 static ULONG STDMETHODCALLTYPE d3d_device_inner_Release(IUnknown *iface)
4463 {
4464     struct d3d_device *device = impl_from_IUnknown(iface);
4465     ULONG refcount = InterlockedDecrement(&device->refcount);
4466     unsigned int i;
4467
4468     TRACE("%p decreasing refcount to %u.\n", device, refcount);
4469
4470     if (!refcount)
4471     {
4472         if (device->state)
4473             d3d_device_context_state_private_release(device->state);
4474         for (i = 0; i < device->context_state_count; ++i)
4475         {
4476             d3d_device_context_state_remove_entry(device->context_states[i], device);
4477         }
4478         heap_free(device->context_states);
4479         d3d11_device_context_cleanup(&device->immediate_context);
4480         if (device->wined3d_device)
4481         {
4482             wined3d_mutex_lock();
4483             wined3d_device_decref(device->wined3d_device);
4484             wined3d_mutex_unlock();
4485         }
4486         wine_rb_destroy(&device->sampler_states, NULL, NULL);
4487         wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
4488         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
4489         wine_rb_destroy(&device->blend_states, NULL, NULL);
4490     }
4491
4492     return refcount;
4493 }
4494
4495 /* IUnknown methods */
4496
4497 static HRESULT STDMETHODCALLTYPE d3d10_device_QueryInterface(ID3D10Device1 *iface, REFIID iid,
4498         void **out)
4499 {
4500     struct d3d_device *device = impl_from_ID3D10Device(iface);
4501     return IUnknown_QueryInterface(device->outer_unk, iid, out);
4502 }
4503
4504 static ULONG STDMETHODCALLTYPE d3d10_device_AddRef(ID3D10Device1 *iface)
4505 {
4506     struct d3d_device *device = impl_from_ID3D10Device(iface);
4507     return IUnknown_AddRef(device->outer_unk);
4508 }
4509
4510 static ULONG STDMETHODCALLTYPE d3d10_device_Release(ID3D10Device1 *iface)
4511 {
4512     struct d3d_device *device = impl_from_ID3D10Device(iface);
4513     return IUnknown_Release(device->outer_unk);
4514 }
4515
4516 /* ID3D10Device methods */
4517
4518 static void d3d10_device_get_constant_buffers(ID3D10Device1 *iface,
4519         enum wined3d_shader_type type, UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
4520 {
4521     struct d3d_device *device = impl_from_ID3D10Device(iface);
4522     unsigned int i;
4523
4524     wined3d_mutex_lock();
4525     for (i = 0; i < buffer_count; ++i)
4526     {
4527         struct wined3d_buffer *wined3d_buffer;
4528         struct d3d_buffer *buffer_impl;
4529
4530         if (!(wined3d_buffer = wined3d_device_context_get_constant_buffer(device->immediate_context.wined3d_context,
4531                 type, start_slot + i)))
4532         {
4533             buffers[i] = NULL;
4534             continue;
4535         }
4536
4537         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4538         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4539         ID3D10Buffer_AddRef(buffers[i]);
4540     }
4541     wined3d_mutex_unlock();
4542 }
4543
4544 static void d3d10_device_set_constant_buffers(ID3D10Device1 *iface,
4545         enum wined3d_shader_type type, UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
4546 {
4547     struct d3d_device *device = impl_from_ID3D10Device(iface);
4548     unsigned int i;
4549
4550     wined3d_mutex_lock();
4551     for (i = 0; i < buffer_count; ++i)
4552     {
4553         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
4554
4555         wined3d_device_context_set_constant_buffer(device->immediate_context.wined3d_context, type, start_slot + i,
4556                 buffer ? buffer->wined3d_buffer : NULL);
4557     }
4558     wined3d_mutex_unlock();
4559 }
4560
4561 static void STDMETHODCALLTYPE d3d10_device_VSSetConstantBuffers(ID3D10Device1 *iface,
4562         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
4563 {
4564     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4565             iface, start_slot, buffer_count, buffers);
4566
4567     d3d10_device_set_constant_buffers(iface, WINED3D_SHADER_TYPE_VERTEX, start_slot,
4568             buffer_count, buffers);
4569 }
4570
4571 static void STDMETHODCALLTYPE d3d10_device_PSSetShaderResources(ID3D10Device1 *iface,
4572         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
4573 {
4574     struct d3d_device *device = impl_from_ID3D10Device(iface);
4575     unsigned int i;
4576
4577     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4578             iface, start_slot, view_count, views);
4579
4580     wined3d_mutex_lock();
4581     for (i = 0; i < view_count; ++i)
4582     {
4583         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
4584
4585         wined3d_device_context_set_shader_resource_view(device->immediate_context.wined3d_context,
4586                 WINED3D_SHADER_TYPE_PIXEL, start_slot + i, view ? view->wined3d_view : NULL);
4587     }
4588     wined3d_mutex_unlock();
4589 }
4590
4591 static void STDMETHODCALLTYPE d3d10_device_PSSetShader(ID3D10Device1 *iface,
4592         ID3D10PixelShader *shader)
4593 {
4594     struct d3d_device *device = impl_from_ID3D10Device(iface);
4595     struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D10PixelShader(shader);
4596
4597     TRACE("iface %p, shader %p\n", iface, shader);
4598
4599     wined3d_mutex_lock();
4600     wined3d_device_context_set_shader(device->immediate_context.wined3d_context,
4601             WINED3D_SHADER_TYPE_PIXEL, ps ? ps->wined3d_shader : NULL);
4602     wined3d_mutex_unlock();
4603 }
4604
4605 static void STDMETHODCALLTYPE d3d10_device_PSSetSamplers(ID3D10Device1 *iface,
4606         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
4607 {
4608     struct d3d_device *device = impl_from_ID3D10Device(iface);
4609     unsigned int i;
4610
4611     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4612             iface, start_slot, sampler_count, samplers);
4613
4614     wined3d_mutex_lock();
4615     for (i = 0; i < sampler_count; ++i)
4616     {
4617         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
4618
4619         wined3d_device_context_set_sampler(device->immediate_context.wined3d_context,
4620                 WINED3D_SHADER_TYPE_PIXEL, start_slot + i, sampler ? sampler->wined3d_sampler : NULL);
4621     }
4622     wined3d_mutex_unlock();
4623 }
4624
4625 static void STDMETHODCALLTYPE d3d10_device_VSSetShader(ID3D10Device1 *iface,
4626         ID3D10VertexShader *shader)
4627 {
4628     struct d3d_device *device = impl_from_ID3D10Device(iface);
4629     struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D10VertexShader(shader);
4630
4631     TRACE("iface %p, shader %p\n", iface, shader);
4632
4633     wined3d_mutex_lock();
4634     wined3d_device_context_set_shader(device->immediate_context.wined3d_context,
4635             WINED3D_SHADER_TYPE_VERTEX, vs ? vs->wined3d_shader : NULL);
4636     wined3d_mutex_unlock();
4637 }
4638
4639 static void STDMETHODCALLTYPE d3d10_device_DrawIndexed(ID3D10Device1 *iface, UINT index_count,
4640         UINT start_index_location, INT base_vertex_location)
4641 {
4642     struct d3d_device *device = impl_from_ID3D10Device(iface);
4643
4644     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
4645             iface, index_count, start_index_location, base_vertex_location);
4646
4647     wined3d_mutex_lock();
4648     wined3d_device_context_draw_indexed(device->immediate_context.wined3d_context,
4649             base_vertex_location, start_index_location, index_count, 0, 0);
4650     wined3d_mutex_unlock();
4651 }
4652
4653 static void STDMETHODCALLTYPE d3d10_device_Draw(ID3D10Device1 *iface, UINT vertex_count,
4654         UINT start_vertex_location)
4655 {
4656     struct d3d_device *device = impl_from_ID3D10Device(iface);
4657
4658     TRACE("iface %p, vertex_count %u, start_vertex_location %u\n",
4659             iface, vertex_count, start_vertex_location);
4660
4661     wined3d_mutex_lock();
4662     wined3d_device_context_draw(device->immediate_context.wined3d_context, start_vertex_location, vertex_count, 0, 0);
4663     wined3d_mutex_unlock();
4664 }
4665
4666 static void STDMETHODCALLTYPE d3d10_device_PSSetConstantBuffers(ID3D10Device1 *iface,
4667         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
4668 {
4669     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4670             iface, start_slot, buffer_count, buffers);
4671
4672     d3d10_device_set_constant_buffers(iface, WINED3D_SHADER_TYPE_PIXEL, start_slot,
4673             buffer_count, buffers);
4674 }
4675
4676 static void STDMETHODCALLTYPE d3d10_device_IASetInputLayout(ID3D10Device1 *iface,
4677         ID3D10InputLayout *input_layout)
4678 {
4679     struct d3d_device *device = impl_from_ID3D10Device(iface);
4680     struct d3d_input_layout *layout = unsafe_impl_from_ID3D10InputLayout(input_layout);
4681
4682     TRACE("iface %p, input_layout %p\n", iface, input_layout);
4683
4684     wined3d_mutex_lock();
4685     wined3d_device_context_set_vertex_declaration(device->immediate_context.wined3d_context,
4686             layout ? layout->wined3d_decl : NULL);
4687     wined3d_mutex_unlock();
4688 }
4689
4690 static void STDMETHODCALLTYPE d3d10_device_IASetVertexBuffers(ID3D10Device1 *iface, UINT start_slot,
4691         UINT buffer_count, ID3D10Buffer *const *buffers, const UINT *strides, const UINT *offsets)
4692 {
4693     struct d3d_device *device = impl_from_ID3D10Device(iface);
4694     unsigned int i;
4695
4696     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p\n",
4697             iface, start_slot, buffer_count, buffers, strides, offsets);
4698
4699     wined3d_mutex_lock();
4700     for (i = 0; i < buffer_count; ++i)
4701     {
4702         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
4703
4704         wined3d_device_context_set_stream_source(device->immediate_context.wined3d_context, start_slot + i,
4705                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
4706     }
4707     wined3d_mutex_unlock();
4708 }
4709
4710 static void STDMETHODCALLTYPE d3d10_device_IASetIndexBuffer(ID3D10Device1 *iface,
4711         ID3D10Buffer *buffer, DXGI_FORMAT format, UINT offset)
4712 {
4713     struct d3d_device *device = impl_from_ID3D10Device(iface);
4714     struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D10Buffer(buffer);
4715
4716     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
4717             iface, buffer, debug_dxgi_format(format), offset);
4718
4719     wined3d_mutex_lock();
4720     wined3d_device_context_set_index_buffer(device->immediate_context.wined3d_context,
4721             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
4722             wined3dformat_from_dxgi_format(format), offset);
4723     wined3d_mutex_unlock();
4724 }
4725
4726 static void STDMETHODCALLTYPE d3d10_device_DrawIndexedInstanced(ID3D10Device1 *iface,
4727         UINT instance_index_count, UINT instance_count, UINT start_index_location,
4728         INT base_vertex_location, UINT start_instance_location)
4729 {
4730     struct d3d_device *device = impl_from_ID3D10Device(iface);
4731
4732     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
4733             "base_vertex_location %d, start_instance_location %u.\n",
4734             iface, instance_index_count, instance_count, start_index_location,
4735             base_vertex_location, start_instance_location);
4736
4737     wined3d_mutex_lock();
4738     wined3d_device_context_draw_indexed(device->immediate_context.wined3d_context, base_vertex_location,
4739             start_index_location, instance_index_count, start_instance_location, instance_count);
4740     wined3d_mutex_unlock();
4741 }
4742
4743 static void STDMETHODCALLTYPE d3d10_device_DrawInstanced(ID3D10Device1 *iface,
4744         UINT instance_vertex_count, UINT instance_count,
4745         UINT start_vertex_location, UINT start_instance_location)
4746 {
4747     struct d3d_device *device = impl_from_ID3D10Device(iface);
4748
4749     TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
4750             "start_instance_location %u.\n", iface, instance_vertex_count, instance_count,
4751             start_vertex_location, start_instance_location);
4752
4753     wined3d_mutex_lock();
4754     wined3d_device_context_draw(device->immediate_context.wined3d_context, start_vertex_location,
4755             instance_vertex_count, start_instance_location, instance_count);
4756     wined3d_mutex_unlock();
4757 }
4758
4759 static void STDMETHODCALLTYPE d3d10_device_GSSetConstantBuffers(ID3D10Device1 *iface,
4760         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
4761 {
4762     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4763             iface, start_slot, buffer_count, buffers);
4764
4765     d3d10_device_set_constant_buffers(iface, WINED3D_SHADER_TYPE_GEOMETRY, start_slot,
4766             buffer_count, buffers);
4767 }
4768
4769 static void STDMETHODCALLTYPE d3d10_device_GSSetShader(ID3D10Device1 *iface, ID3D10GeometryShader *shader)
4770 {
4771     struct d3d_device *device = impl_from_ID3D10Device(iface);
4772     struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D10GeometryShader(shader);
4773
4774     TRACE("iface %p, shader %p.\n", iface, shader);
4775
4776     wined3d_mutex_lock();
4777     wined3d_device_context_set_shader(device->immediate_context.wined3d_context,
4778             WINED3D_SHADER_TYPE_GEOMETRY, gs ? gs->wined3d_shader : NULL);
4779     wined3d_mutex_unlock();
4780 }
4781
4782 static void STDMETHODCALLTYPE d3d10_device_IASetPrimitiveTopology(ID3D10Device1 *iface,
4783         D3D10_PRIMITIVE_TOPOLOGY topology)
4784 {
4785     struct d3d_device *device = impl_from_ID3D10Device(iface);
4786
4787     TRACE("iface %p, topology %s.\n", iface, debug_d3d10_primitive_topology(topology));
4788
4789     wined3d_mutex_lock();
4790     wined3d_device_context_set_primitive_type(device->immediate_context.wined3d_context,
4791             (enum wined3d_primitive_type)topology, 0);
4792     wined3d_mutex_unlock();
4793 }
4794
4795 static void STDMETHODCALLTYPE d3d10_device_VSSetShaderResources(ID3D10Device1 *iface,
4796         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
4797 {
4798     struct d3d_device *device = impl_from_ID3D10Device(iface);
4799     unsigned int i;
4800
4801     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4802             iface, start_slot, view_count, views);
4803
4804     wined3d_mutex_lock();
4805     for (i = 0; i < view_count; ++i)
4806     {
4807         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
4808
4809         wined3d_device_context_set_shader_resource_view(device->immediate_context.wined3d_context,
4810                 WINED3D_SHADER_TYPE_VERTEX, start_slot + i, view ? view->wined3d_view : NULL);
4811     }
4812     wined3d_mutex_unlock();
4813 }
4814
4815 static void STDMETHODCALLTYPE d3d10_device_VSSetSamplers(ID3D10Device1 *iface,
4816         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
4817 {
4818     struct d3d_device *device = impl_from_ID3D10Device(iface);
4819     unsigned int i;
4820
4821     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4822             iface, start_slot, sampler_count, samplers);
4823
4824     wined3d_mutex_lock();
4825     for (i = 0; i < sampler_count; ++i)
4826     {
4827         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
4828
4829         wined3d_device_context_set_sampler(device->immediate_context.wined3d_context,
4830                 WINED3D_SHADER_TYPE_VERTEX, start_slot + i, sampler ? sampler->wined3d_sampler : NULL);
4831     }
4832     wined3d_mutex_unlock();
4833 }
4834
4835 static void STDMETHODCALLTYPE d3d10_device_SetPredication(ID3D10Device1 *iface, ID3D10Predicate *predicate, BOOL value)
4836 {
4837     struct d3d_device *device = impl_from_ID3D10Device(iface);
4838     struct d3d_query *query;
4839
4840     TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
4841
4842     query = unsafe_impl_from_ID3D10Query((ID3D10Query *)predicate);
4843     wined3d_mutex_lock();
4844     wined3d_device_context_set_predication(device->immediate_context.wined3d_context,
4845             query ? query->wined3d_query : NULL, value);
4846     wined3d_mutex_unlock();
4847 }
4848
4849 static void STDMETHODCALLTYPE d3d10_device_GSSetShaderResources(ID3D10Device1 *iface,
4850         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
4851 {
4852     struct d3d_device *device = impl_from_ID3D10Device(iface);
4853     unsigned int i;
4854
4855     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4856             iface, start_slot, view_count, views);
4857
4858     wined3d_mutex_lock();
4859     for (i = 0; i < view_count; ++i)
4860     {
4861         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
4862
4863         wined3d_device_context_set_shader_resource_view(device->immediate_context.wined3d_context,
4864                 WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i, view ? view->wined3d_view : NULL);
4865     }
4866     wined3d_mutex_unlock();
4867 }
4868
4869 static void STDMETHODCALLTYPE d3d10_device_GSSetSamplers(ID3D10Device1 *iface,
4870         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
4871 {
4872     struct d3d_device *device = impl_from_ID3D10Device(iface);
4873     unsigned int i;
4874
4875     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4876             iface, start_slot, sampler_count, samplers);
4877
4878     wined3d_mutex_lock();
4879     for (i = 0; i < sampler_count; ++i)
4880     {
4881         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
4882
4883         wined3d_device_context_set_sampler(device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY,
4884                 start_slot + i, sampler ? sampler->wined3d_sampler : NULL);
4885     }
4886     wined3d_mutex_unlock();
4887 }
4888
4889 static void STDMETHODCALLTYPE d3d10_device_OMSetRenderTargets(ID3D10Device1 *iface,
4890         UINT render_target_view_count, ID3D10RenderTargetView *const *render_target_views,
4891         ID3D10DepthStencilView *depth_stencil_view)
4892 {
4893     struct d3d_device *device = impl_from_ID3D10Device(iface);
4894     struct d3d_depthstencil_view *dsv;
4895     unsigned int i;
4896
4897     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
4898             iface, render_target_view_count, render_target_views, depth_stencil_view);
4899
4900     wined3d_mutex_lock();
4901     for (i = 0; i < render_target_view_count; ++i)
4902     {
4903         struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D10RenderTargetView(render_target_views[i]);
4904
4905         wined3d_device_context_set_rendertarget_view(device->immediate_context.wined3d_context, i,
4906                 rtv ? rtv->wined3d_view : NULL, FALSE);
4907     }
4908     for (; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
4909     {
4910         wined3d_device_context_set_rendertarget_view(device->immediate_context.wined3d_context, i, NULL, FALSE);
4911     }
4912
4913     dsv = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
4914     wined3d_device_context_set_depth_stencil_view(device->immediate_context.wined3d_context,
4915             dsv ? dsv->wined3d_view : NULL);
4916     wined3d_mutex_unlock();
4917 }
4918
4919 static void STDMETHODCALLTYPE d3d10_device_OMSetBlendState(ID3D10Device1 *iface,
4920         ID3D10BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
4921 {
4922     struct d3d_device *device = impl_from_ID3D10Device(iface);
4923     struct d3d_blend_state *blend_state_object;
4924
4925     TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
4926             iface, blend_state, debug_float4(blend_factor), sample_mask);
4927
4928     blend_state_object = unsafe_impl_from_ID3D10BlendState(blend_state);
4929     d3d11_device_context_OMSetBlendState(&device->immediate_context.ID3D11DeviceContext1_iface,
4930             blend_state_object ? &blend_state_object->ID3D11BlendState_iface : NULL, blend_factor, sample_mask);
4931 }
4932
4933 static void STDMETHODCALLTYPE d3d10_device_OMSetDepthStencilState(ID3D10Device1 *iface,
4934         ID3D10DepthStencilState *depth_stencil_state, UINT stencil_ref)
4935 {
4936     struct d3d_device *device = impl_from_ID3D10Device(iface);
4937     struct d3d_depthstencil_state *ds_state_object;
4938
4939     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
4940             iface, depth_stencil_state, stencil_ref);
4941
4942     ds_state_object = unsafe_impl_from_ID3D10DepthStencilState(depth_stencil_state);
4943     d3d11_device_context_OMSetDepthStencilState(&device->immediate_context.ID3D11DeviceContext1_iface,
4944             ds_state_object ? &ds_state_object->ID3D11DepthStencilState_iface : NULL, stencil_ref);
4945 }
4946
4947 static void STDMETHODCALLTYPE d3d10_device_SOSetTargets(ID3D10Device1 *iface,
4948         UINT target_count, ID3D10Buffer *const *targets, const UINT *offsets)
4949 {
4950     struct d3d_device *device = impl_from_ID3D10Device(iface);
4951     unsigned int count, i;
4952
4953     TRACE("iface %p, target_count %u, targets %p, offsets %p.\n", iface, target_count, targets, offsets);
4954
4955     count = min(target_count, D3D10_SO_BUFFER_SLOT_COUNT);
4956     wined3d_mutex_lock();
4957     for (i = 0; i < count; ++i)
4958     {
4959         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(targets[i]);
4960
4961         wined3d_device_context_set_stream_output(device->immediate_context.wined3d_context, i,
4962                 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
4963     }
4964
4965     for (i = count; i < D3D10_SO_BUFFER_SLOT_COUNT; ++i)
4966     {
4967         wined3d_device_context_set_stream_output(device->immediate_context.wined3d_context, i, NULL, 0);
4968     }
4969     wined3d_mutex_unlock();
4970 }
4971
4972 static void STDMETHODCALLTYPE d3d10_device_DrawAuto(ID3D10Device1 *iface)
4973 {
4974     FIXME("iface %p stub!\n", iface);
4975 }
4976
4977 static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device1 *iface, ID3D10RasterizerState *rasterizer_state)
4978 {
4979     struct d3d_device *device = impl_from_ID3D10Device(iface);
4980     struct d3d_rasterizer_state *rasterizer_state_object;
4981
4982     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
4983
4984     rasterizer_state_object = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state);
4985     d3d11_device_context_RSSetState(&device->immediate_context.ID3D11DeviceContext1_iface,
4986             rasterizer_state_object ? &rasterizer_state_object->ID3D11RasterizerState_iface : NULL);
4987 }
4988
4989 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device1 *iface,
4990         UINT viewport_count, const D3D10_VIEWPORT *viewports)
4991 {
4992     struct d3d_device *device = impl_from_ID3D10Device(iface);
4993     struct wined3d_viewport wined3d_vp[WINED3D_MAX_VIEWPORTS];
4994     unsigned int i;
4995
4996     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
4997
4998     if (viewport_count > ARRAY_SIZE(wined3d_vp))
4999         return;
5000
5001     for (i = 0; i < viewport_count; ++i)
5002     {
5003         wined3d_vp[i].x = viewports[i].TopLeftX;
5004         wined3d_vp[i].y = viewports[i].TopLeftY;
5005         wined3d_vp[i].width = viewports[i].Width;
5006         wined3d_vp[i].height = viewports[i].Height;
5007         wined3d_vp[i].min_z = viewports[i].MinDepth;
5008         wined3d_vp[i].max_z = viewports[i].MaxDepth;
5009     }
5010
5011     wined3d_mutex_lock();
5012     wined3d_device_context_set_viewports(device->immediate_context.wined3d_context, viewport_count, wined3d_vp);
5013     wined3d_mutex_unlock();
5014 }
5015
5016 static void STDMETHODCALLTYPE d3d10_device_RSSetScissorRects(ID3D10Device1 *iface,
5017         UINT rect_count, const D3D10_RECT *rects)
5018 {
5019     struct d3d_device *device = impl_from_ID3D10Device(iface);
5020
5021     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
5022
5023     if (rect_count > WINED3D_MAX_VIEWPORTS)
5024         return;
5025
5026     wined3d_mutex_lock();
5027     wined3d_device_context_set_scissor_rects(device->immediate_context.wined3d_context, rect_count, rects);
5028     wined3d_mutex_unlock();
5029 }
5030
5031 static void STDMETHODCALLTYPE d3d10_device_CopySubresourceRegion(ID3D10Device1 *iface,
5032         ID3D10Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
5033         ID3D10Resource *src_resource, UINT src_subresource_idx, const D3D10_BOX *src_box)
5034 {
5035     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
5036     struct d3d_device *device = impl_from_ID3D10Device(iface);
5037     struct wined3d_box wined3d_src_box;
5038
5039     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
5040             "src_resource %p, src_subresource_idx %u, src_box %p.\n",
5041             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
5042             src_resource, src_subresource_idx, src_box);
5043
5044     if (!dst_resource || !src_resource)
5045         return;
5046
5047     if (src_box)
5048         wined3d_box_set(&wined3d_src_box, src_box->left, src_box->top,
5049                 src_box->right, src_box->bottom, src_box->front, src_box->back);
5050
5051     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
5052     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
5053     wined3d_mutex_lock();
5054     wined3d_device_context_copy_sub_resource_region(device->immediate_context.wined3d_context,
5055             wined3d_dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
5056             wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL, 0);
5057     wined3d_mutex_unlock();
5058 }
5059
5060 static void STDMETHODCALLTYPE d3d10_device_CopyResource(ID3D10Device1 *iface,
5061         ID3D10Resource *dst_resource, ID3D10Resource *src_resource)
5062 {
5063     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
5064     struct d3d_device *device = impl_from_ID3D10Device(iface);
5065
5066     TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
5067
5068     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
5069     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
5070     wined3d_mutex_lock();
5071     wined3d_device_context_copy_resource(device->immediate_context.wined3d_context,
5072             wined3d_dst_resource, wined3d_src_resource);
5073     wined3d_mutex_unlock();
5074 }
5075
5076 static void STDMETHODCALLTYPE d3d10_device_UpdateSubresource(ID3D10Device1 *iface,
5077         ID3D10Resource *resource, UINT subresource_idx, const D3D10_BOX *box,
5078         const void *data, UINT row_pitch, UINT depth_pitch)
5079 {
5080     struct d3d_device *device = impl_from_ID3D10Device(iface);
5081     ID3D11Resource *d3d11_resource;
5082
5083     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
5084             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
5085
5086     ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource);
5087     d3d11_device_context_UpdateSubresource(&device->immediate_context.ID3D11DeviceContext1_iface,
5088             d3d11_resource, subresource_idx, (const D3D11_BOX *)box, data, row_pitch, depth_pitch);
5089     ID3D11Resource_Release(d3d11_resource);
5090 }
5091
5092 static void STDMETHODCALLTYPE d3d10_device_ClearRenderTargetView(ID3D10Device1 *iface,
5093         ID3D10RenderTargetView *render_target_view, const float color_rgba[4])
5094 {
5095     struct d3d_device *device = impl_from_ID3D10Device(iface);
5096     struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D10RenderTargetView(render_target_view);
5097     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
5098     HRESULT hr;
5099
5100     TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
5101             iface, render_target_view, debug_float4(color_rgba));
5102
5103     if (!view)
5104         return;
5105
5106     wined3d_mutex_lock();
5107     if (FAILED(hr = wined3d_device_context_clear_rendertarget_view(device->immediate_context.wined3d_context,
5108             view->wined3d_view, NULL, WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
5109         ERR("Failed to clear view, hr %#x.\n", hr);
5110     wined3d_mutex_unlock();
5111 }
5112
5113 static void STDMETHODCALLTYPE d3d10_device_ClearDepthStencilView(ID3D10Device1 *iface,
5114         ID3D10DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
5115 {
5116     struct d3d_device *device = impl_from_ID3D10Device(iface);
5117     struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
5118     DWORD wined3d_flags;
5119     HRESULT hr;
5120
5121     TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
5122             iface, depth_stencil_view, flags, depth, stencil);
5123
5124     if (!view)
5125         return;
5126
5127     wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
5128
5129     wined3d_mutex_lock();
5130     if (FAILED(hr = wined3d_device_context_clear_rendertarget_view(device->immediate_context.wined3d_context,
5131             view->wined3d_view, NULL, wined3d_flags, NULL, depth, stencil)))
5132         ERR("Failed to clear view, hr %#x.\n", hr);
5133     wined3d_mutex_unlock();
5134 }
5135
5136 static void STDMETHODCALLTYPE d3d10_device_GenerateMips(ID3D10Device1 *iface,
5137         ID3D10ShaderResourceView *view)
5138 {
5139     struct d3d_device *device = impl_from_ID3D10Device(iface);
5140     struct d3d_shader_resource_view *srv = unsafe_impl_from_ID3D10ShaderResourceView(view);
5141
5142     TRACE("iface %p, view %p.\n", iface, view);
5143
5144     wined3d_mutex_lock();
5145     wined3d_device_context_generate_mipmaps(device->immediate_context.wined3d_context, srv->wined3d_view);
5146     wined3d_mutex_unlock();
5147 }
5148
5149 static void STDMETHODCALLTYPE d3d10_device_ResolveSubresource(ID3D10Device1 *iface,
5150         ID3D10Resource *dst_resource, UINT dst_subresource_idx,
5151         ID3D10Resource *src_resource, UINT src_subresource_idx, DXGI_FORMAT format)
5152 {
5153     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
5154     struct d3d_device *device = impl_from_ID3D10Device(iface);
5155     enum wined3d_format_id wined3d_format;
5156
5157     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, "
5158             "src_resource %p, src_subresource_idx %u, format %s.\n",
5159             iface, dst_resource, dst_subresource_idx,
5160             src_resource, src_subresource_idx, debug_dxgi_format(format));
5161
5162     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
5163     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
5164     wined3d_format = wined3dformat_from_dxgi_format(format);
5165     wined3d_mutex_lock();
5166     wined3d_device_context_resolve_sub_resource(device->immediate_context.wined3d_context,
5167             wined3d_dst_resource, dst_subresource_idx,
5168             wined3d_src_resource, src_subresource_idx, wined3d_format);
5169     wined3d_mutex_unlock();
5170 }
5171
5172 static void STDMETHODCALLTYPE d3d10_device_VSGetConstantBuffers(ID3D10Device1 *iface,
5173         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
5174 {
5175     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
5176             iface, start_slot, buffer_count, buffers);
5177
5178     d3d10_device_get_constant_buffers(iface, WINED3D_SHADER_TYPE_VERTEX, start_slot, buffer_count,
5179             buffers);
5180 }
5181
5182 static void STDMETHODCALLTYPE d3d10_device_PSGetShaderResources(ID3D10Device1 *iface,
5183         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
5184 {
5185     struct d3d_device *device = impl_from_ID3D10Device(iface);
5186     unsigned int i;
5187
5188     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
5189             iface, start_slot, view_count, views);
5190
5191     wined3d_mutex_lock();
5192     for (i = 0; i < view_count; ++i)
5193     {
5194         struct wined3d_shader_resource_view *wined3d_view;
5195         struct d3d_shader_resource_view *view_impl;
5196
5197         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
5198                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_PIXEL, start_slot + i)))
5199         {
5200             views[i] = NULL;
5201             continue;
5202         }
5203
5204         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
5205         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
5206         ID3D10ShaderResourceView_AddRef(views[i]);
5207     }
5208     wined3d_mutex_unlock();
5209 }
5210
5211 static void STDMETHODCALLTYPE d3d10_device_PSGetShader(ID3D10Device1 *iface, ID3D10PixelShader **shader)
5212 {
5213     struct d3d_device *device = impl_from_ID3D10Device(iface);
5214     struct d3d_pixel_shader *shader_impl;
5215     struct wined3d_shader *wined3d_shader;
5216
5217     TRACE("iface %p, shader %p.\n", iface, shader);
5218
5219     wined3d_mutex_lock();
5220     if (!(wined3d_shader = wined3d_device_context_get_shader(device->immediate_context.wined3d_context,
5221             WINED3D_SHADER_TYPE_PIXEL)))
5222     {
5223         wined3d_mutex_unlock();
5224         *shader = NULL;
5225         return;
5226     }
5227
5228     shader_impl = wined3d_shader_get_parent(wined3d_shader);
5229     wined3d_mutex_unlock();
5230     *shader = &shader_impl->ID3D10PixelShader_iface;
5231     ID3D10PixelShader_AddRef(*shader);
5232 }
5233
5234 static void STDMETHODCALLTYPE d3d10_device_PSGetSamplers(ID3D10Device1 *iface,
5235         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
5236 {
5237     struct d3d_device *device = impl_from_ID3D10Device(iface);
5238     unsigned int i;
5239
5240     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
5241             iface, start_slot, sampler_count, samplers);
5242
5243     wined3d_mutex_lock();
5244     for (i = 0; i < sampler_count; ++i)
5245     {
5246         struct d3d_sampler_state *sampler_impl;
5247         struct wined3d_sampler *wined3d_sampler;
5248
5249         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
5250                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_PIXEL, start_slot + i)))
5251         {
5252             samplers[i] = NULL;
5253             continue;
5254         }
5255
5256         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
5257         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
5258         ID3D10SamplerState_AddRef(samplers[i]);
5259     }
5260     wined3d_mutex_unlock();
5261 }
5262
5263 static void STDMETHODCALLTYPE d3d10_device_VSGetShader(ID3D10Device1 *iface, ID3D10VertexShader **shader)
5264 {
5265     struct d3d_device *device = impl_from_ID3D10Device(iface);
5266     struct d3d_vertex_shader *shader_impl;
5267     struct wined3d_shader *wined3d_shader;
5268
5269     TRACE("iface %p, shader %p.\n", iface, shader);
5270
5271     wined3d_mutex_lock();
5272     if (!(wined3d_shader = wined3d_device_context_get_shader(device->immediate_context.wined3d_context,
5273             WINED3D_SHADER_TYPE_VERTEX)))
5274     {
5275         wined3d_mutex_unlock();
5276         *shader = NULL;
5277         return;
5278     }
5279
5280     shader_impl = wined3d_shader_get_parent(wined3d_shader);
5281     wined3d_mutex_unlock();
5282     *shader = &shader_impl->ID3D10VertexShader_iface;
5283     ID3D10VertexShader_AddRef(*shader);
5284 }
5285
5286 static void STDMETHODCALLTYPE d3d10_device_PSGetConstantBuffers(ID3D10Device1 *iface,
5287         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
5288 {
5289     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
5290             iface, start_slot, buffer_count, buffers);
5291
5292     d3d10_device_get_constant_buffers(iface, WINED3D_SHADER_TYPE_PIXEL, start_slot, buffer_count,
5293             buffers);
5294 }
5295
5296 static void STDMETHODCALLTYPE d3d10_device_IAGetInputLayout(ID3D10Device1 *iface, ID3D10InputLayout **input_layout)
5297 {
5298     struct d3d_device *device = impl_from_ID3D10Device(iface);
5299     struct wined3d_vertex_declaration *wined3d_declaration;
5300     struct d3d_input_layout *input_layout_impl;
5301
5302     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
5303
5304     wined3d_mutex_lock();
5305     if (!(wined3d_declaration = wined3d_device_context_get_vertex_declaration(
5306             device->immediate_context.wined3d_context)))
5307     {
5308         wined3d_mutex_unlock();
5309         *input_layout = NULL;
5310         return;
5311     }
5312
5313     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
5314     wined3d_mutex_unlock();
5315     *input_layout = &input_layout_impl->ID3D10InputLayout_iface;
5316     ID3D10InputLayout_AddRef(*input_layout);
5317 }
5318
5319 static void STDMETHODCALLTYPE d3d10_device_IAGetVertexBuffers(ID3D10Device1 *iface,
5320         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers, UINT *strides, UINT *offsets)
5321 {
5322     struct d3d_device *device = impl_from_ID3D10Device(iface);
5323     unsigned int i;
5324
5325     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
5326             iface, start_slot, buffer_count, buffers, strides, offsets);
5327
5328     wined3d_mutex_lock();
5329     for (i = 0; i < buffer_count; ++i)
5330     {
5331         struct wined3d_buffer *wined3d_buffer = NULL;
5332         struct d3d_buffer *buffer_impl;
5333
5334         if (FAILED(wined3d_device_context_get_stream_source(device->immediate_context.wined3d_context, start_slot + i,
5335                 &wined3d_buffer, &offsets[i], &strides[i])))
5336             ERR("Failed to get vertex buffer.\n");
5337
5338         if (!wined3d_buffer)
5339         {
5340             buffers[i] = NULL;
5341             continue;
5342         }
5343
5344         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
5345         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
5346         ID3D10Buffer_AddRef(buffers[i]);
5347     }
5348     wined3d_mutex_unlock();
5349 }
5350
5351 static void STDMETHODCALLTYPE d3d10_device_IAGetIndexBuffer(ID3D10Device1 *iface,
5352         ID3D10Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
5353 {
5354     struct d3d_device *device = impl_from_ID3D10Device(iface);
5355     enum wined3d_format_id wined3d_format;
5356     struct wined3d_buffer *wined3d_buffer;
5357     struct d3d_buffer *buffer_impl;
5358
5359     TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
5360
5361     wined3d_mutex_lock();
5362     wined3d_buffer = wined3d_device_context_get_index_buffer(
5363             device->immediate_context.wined3d_context, &wined3d_format, offset);
5364     *format = dxgi_format_from_wined3dformat(wined3d_format);
5365     if (!wined3d_buffer)
5366     {
5367         wined3d_mutex_unlock();
5368         *buffer = NULL;
5369         return;
5370     }
5371
5372     buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
5373     wined3d_mutex_unlock();
5374     *buffer = &buffer_impl->ID3D10Buffer_iface;
5375     ID3D10Buffer_AddRef(*buffer);
5376 }
5377
5378 static void STDMETHODCALLTYPE d3d10_device_GSGetConstantBuffers(ID3D10Device1 *iface,
5379         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
5380 {
5381     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
5382             iface, start_slot, buffer_count, buffers);
5383
5384     d3d10_device_get_constant_buffers(iface, WINED3D_SHADER_TYPE_GEOMETRY, start_slot, buffer_count,
5385             buffers);
5386 }
5387
5388 static void STDMETHODCALLTYPE d3d10_device_GSGetShader(ID3D10Device1 *iface, ID3D10GeometryShader **shader)
5389 {
5390     struct d3d_device *device = impl_from_ID3D10Device(iface);
5391     struct d3d_geometry_shader *shader_impl;
5392     struct wined3d_shader *wined3d_shader;
5393
5394     TRACE("iface %p, shader %p.\n", iface, shader);
5395
5396     wined3d_mutex_lock();
5397     if (!(wined3d_shader = wined3d_device_context_get_shader(device->immediate_context.wined3d_context,
5398             WINED3D_SHADER_TYPE_GEOMETRY)))
5399     {
5400         wined3d_mutex_unlock();
5401         *shader = NULL;
5402         return;
5403     }
5404
5405     shader_impl = wined3d_shader_get_parent(wined3d_shader);
5406     wined3d_mutex_unlock();
5407     *shader = &shader_impl->ID3D10GeometryShader_iface;
5408     ID3D10GeometryShader_AddRef(*shader);
5409 }
5410
5411 static void STDMETHODCALLTYPE d3d10_device_IAGetPrimitiveTopology(ID3D10Device1 *iface,
5412         D3D10_PRIMITIVE_TOPOLOGY *topology)
5413 {
5414     struct d3d_device *device = impl_from_ID3D10Device(iface);
5415
5416     TRACE("iface %p, topology %p.\n", iface, topology);
5417
5418     wined3d_mutex_lock();
5419     wined3d_device_context_get_primitive_type(device->immediate_context.wined3d_context,
5420             (enum wined3d_primitive_type *)topology, NULL);
5421     wined3d_mutex_unlock();
5422 }
5423
5424 static void STDMETHODCALLTYPE d3d10_device_VSGetShaderResources(ID3D10Device1 *iface,
5425         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
5426 {
5427     struct d3d_device *device = impl_from_ID3D10Device(iface);
5428     unsigned int i;
5429
5430     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
5431             iface, start_slot, view_count, views);
5432
5433     wined3d_mutex_lock();
5434     for (i = 0; i < view_count; ++i)
5435     {
5436         struct wined3d_shader_resource_view *wined3d_view;
5437         struct d3d_shader_resource_view *view_impl;
5438
5439         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
5440                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_VERTEX, start_slot + i)))
5441         {
5442             views[i] = NULL;
5443             continue;
5444         }
5445
5446         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
5447         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
5448         ID3D10ShaderResourceView_AddRef(views[i]);
5449     }
5450     wined3d_mutex_unlock();
5451 }
5452
5453 static void STDMETHODCALLTYPE d3d10_device_VSGetSamplers(ID3D10Device1 *iface,
5454         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
5455 {
5456     struct d3d_device *device = impl_from_ID3D10Device(iface);
5457     unsigned int i;
5458
5459     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
5460             iface, start_slot, sampler_count, samplers);
5461
5462     wined3d_mutex_lock();
5463     for (i = 0; i < sampler_count; ++i)
5464     {
5465         struct d3d_sampler_state *sampler_impl;
5466         struct wined3d_sampler *wined3d_sampler;
5467
5468         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
5469                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_VERTEX, start_slot + i)))
5470         {
5471             samplers[i] = NULL;
5472             continue;
5473         }
5474
5475         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
5476         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
5477         ID3D10SamplerState_AddRef(samplers[i]);
5478     }
5479     wined3d_mutex_unlock();
5480 }
5481
5482 static void STDMETHODCALLTYPE d3d10_device_GetPredication(ID3D10Device1 *iface,
5483         ID3D10Predicate **predicate, BOOL *value)
5484 {
5485     struct d3d_device *device = impl_from_ID3D10Device(iface);
5486     struct wined3d_query *wined3d_predicate;
5487     struct d3d_query *predicate_impl;
5488
5489     TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
5490
5491     wined3d_mutex_lock();
5492     if (!(wined3d_predicate = wined3d_device_context_get_predication(device->immediate_context.wined3d_context, value)))
5493     {
5494         wined3d_mutex_unlock();
5495         *predicate = NULL;
5496         return;
5497     }
5498
5499     predicate_impl = wined3d_query_get_parent(wined3d_predicate);
5500     wined3d_mutex_unlock();
5501     *predicate = (ID3D10Predicate *)&predicate_impl->ID3D10Query_iface;
5502     ID3D10Predicate_AddRef(*predicate);
5503 }
5504
5505 static void STDMETHODCALLTYPE d3d10_device_GSGetShaderResources(ID3D10Device1 *iface,
5506         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
5507 {
5508     struct d3d_device *device = impl_from_ID3D10Device(iface);
5509     unsigned int i;
5510
5511     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
5512             iface, start_slot, view_count, views);
5513
5514     wined3d_mutex_lock();
5515     for (i = 0; i < view_count; ++i)
5516     {
5517         struct wined3d_shader_resource_view *wined3d_view;
5518         struct d3d_shader_resource_view *view_impl;
5519
5520         if (!(wined3d_view = wined3d_device_context_get_shader_resource_view(
5521                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i)))
5522         {
5523             views[i] = NULL;
5524             continue;
5525         }
5526
5527         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
5528         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
5529         ID3D10ShaderResourceView_AddRef(views[i]);
5530     }
5531     wined3d_mutex_unlock();
5532 }
5533
5534 static void STDMETHODCALLTYPE d3d10_device_GSGetSamplers(ID3D10Device1 *iface,
5535         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
5536 {
5537     struct d3d_device *device = impl_from_ID3D10Device(iface);
5538     unsigned int i;
5539
5540     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
5541             iface, start_slot, sampler_count, samplers);
5542
5543     wined3d_mutex_lock();
5544     for (i = 0; i < sampler_count; ++i)
5545     {
5546         struct d3d_sampler_state *sampler_impl;
5547         struct wined3d_sampler *wined3d_sampler;
5548
5549         if (!(wined3d_sampler = wined3d_device_context_get_sampler(
5550                 device->immediate_context.wined3d_context, WINED3D_SHADER_TYPE_GEOMETRY, start_slot + i)))
5551         {
5552             samplers[i] = NULL;
5553             continue;
5554         }
5555
5556         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
5557         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
5558         ID3D10SamplerState_AddRef(samplers[i]);
5559     }
5560     wined3d_mutex_unlock();
5561 }
5562
5563 static void STDMETHODCALLTYPE d3d10_device_OMGetRenderTargets(ID3D10Device1 *iface,
5564         UINT view_count, ID3D10RenderTargetView **render_target_views, ID3D10DepthStencilView **depth_stencil_view)
5565 {
5566     struct d3d_device *device = impl_from_ID3D10Device(iface);
5567     struct wined3d_rendertarget_view *wined3d_view;
5568
5569     TRACE("iface %p, view_count %u, render_target_views %p, depth_stencil_view %p.\n",
5570             iface, view_count, render_target_views, depth_stencil_view);
5571
5572     wined3d_mutex_lock();
5573     if (render_target_views)
5574     {
5575         struct d3d_rendertarget_view *view_impl;
5576         unsigned int i;
5577
5578         for (i = 0; i < view_count; ++i)
5579         {
5580             if (!(wined3d_view = wined3d_device_context_get_rendertarget_view(
5581                     device->immediate_context.wined3d_context, i))
5582                     || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
5583             {
5584                 render_target_views[i] = NULL;
5585                 continue;
5586             }
5587
5588             render_target_views[i] = &view_impl->ID3D10RenderTargetView_iface;
5589             ID3D10RenderTargetView_AddRef(render_target_views[i]);
5590         }
5591     }
5592
5593     if (depth_stencil_view)
5594     {
5595         struct d3d_depthstencil_view *view_impl;
5596
5597         if (!(wined3d_view = wined3d_device_context_get_depth_stencil_view(device->immediate_context.wined3d_context))
5598                 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
5599         {
5600             *depth_stencil_view = NULL;
5601         }
5602         else
5603         {
5604             *depth_stencil_view = &view_impl->ID3D10DepthStencilView_iface;
5605             ID3D10DepthStencilView_AddRef(*depth_stencil_view);
5606         }
5607     }
5608     wined3d_mutex_unlock();
5609 }
5610
5611 static void STDMETHODCALLTYPE d3d10_device_OMGetBlendState(ID3D10Device1 *iface,
5612         ID3D10BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
5613 {
5614     struct d3d_device *device = impl_from_ID3D10Device(iface);
5615     ID3D11BlendState *d3d11_blend_state;
5616
5617     TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
5618             iface, blend_state, blend_factor, sample_mask);
5619
5620     d3d11_device_context_OMGetBlendState(&device->immediate_context.ID3D11DeviceContext1_iface,
5621             &d3d11_blend_state, blend_factor, sample_mask);
5622
5623     if (d3d11_blend_state)
5624         *blend_state = (ID3D10BlendState *)&impl_from_ID3D11BlendState(d3d11_blend_state)->ID3D10BlendState1_iface;
5625     else
5626         *blend_state = NULL;
5627 }
5628
5629 static void STDMETHODCALLTYPE d3d10_device_OMGetDepthStencilState(ID3D10Device1 *iface,
5630         ID3D10DepthStencilState **depth_stencil_state, UINT *stencil_ref)
5631 {
5632     struct d3d_device *device = impl_from_ID3D10Device(iface);
5633     ID3D11DepthStencilState *d3d11_iface;
5634
5635     TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
5636             iface, depth_stencil_state, stencil_ref);
5637
5638     d3d11_device_context_OMGetDepthStencilState(&device->immediate_context.ID3D11DeviceContext1_iface,
5639             &d3d11_iface, stencil_ref);
5640
5641     if (d3d11_iface)
5642         *depth_stencil_state = &impl_from_ID3D11DepthStencilState(d3d11_iface)->ID3D10DepthStencilState_iface;
5643     else
5644         *depth_stencil_state = NULL;
5645 }
5646
5647 static void STDMETHODCALLTYPE d3d10_device_SOGetTargets(ID3D10Device1 *iface,
5648         UINT buffer_count, ID3D10Buffer **buffers, UINT *offsets)
5649 {
5650     struct d3d_device *device = impl_from_ID3D10Device(iface);
5651     unsigned int i;
5652
5653     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n",
5654             iface, buffer_count, buffers, offsets);
5655
5656     wined3d_mutex_lock();
5657     for (i = 0; i < buffer_count; ++i)
5658     {
5659         struct wined3d_buffer *wined3d_buffer;
5660         struct d3d_buffer *buffer_impl;
5661
5662         if (!(wined3d_buffer = wined3d_device_context_get_stream_output(
5663                 device->immediate_context.wined3d_context, i, &offsets[i])))
5664         {
5665             buffers[i] = NULL;
5666             continue;
5667         }
5668
5669         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
5670         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
5671         ID3D10Buffer_AddRef(buffers[i]);
5672     }
5673     wined3d_mutex_unlock();
5674 }
5675
5676 static void STDMETHODCALLTYPE d3d10_device_RSGetState(ID3D10Device1 *iface, ID3D10RasterizerState **rasterizer_state)
5677 {
5678     struct d3d_device *device = impl_from_ID3D10Device(iface);
5679     struct d3d_rasterizer_state *rasterizer_state_impl;
5680     struct wined3d_rasterizer_state *wined3d_state;
5681
5682     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
5683
5684     wined3d_mutex_lock();
5685     if ((wined3d_state = wined3d_device_context_get_rasterizer_state(device->immediate_context.wined3d_context)))
5686     {
5687         rasterizer_state_impl = wined3d_rasterizer_state_get_parent(wined3d_state);
5688         ID3D10RasterizerState_AddRef(*rasterizer_state = &rasterizer_state_impl->ID3D10RasterizerState_iface);
5689     }
5690     else
5691     {
5692         *rasterizer_state = NULL;
5693     }
5694     wined3d_mutex_unlock();
5695 }
5696
5697 static void STDMETHODCALLTYPE d3d10_device_RSGetViewports(ID3D10Device1 *iface,
5698         UINT *viewport_count, D3D10_VIEWPORT *viewports)
5699 {
5700     struct d3d_device *device = impl_from_ID3D10Device(iface);
5701     struct wined3d_viewport wined3d_vp[WINED3D_MAX_VIEWPORTS];
5702     unsigned int actual_count = ARRAY_SIZE(wined3d_vp), i;
5703
5704     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
5705
5706     if (!viewport_count)
5707         return;
5708
5709     wined3d_mutex_lock();
5710     wined3d_device_context_get_viewports(device->immediate_context.wined3d_context,
5711             &actual_count, viewports ? wined3d_vp : NULL);
5712     wined3d_mutex_unlock();
5713
5714     if (!viewports)
5715     {
5716         *viewport_count = actual_count;
5717         return;
5718     }
5719
5720     if (*viewport_count > actual_count)
5721         memset(&viewports[actual_count], 0, (*viewport_count - actual_count) * sizeof(*viewports));
5722
5723     *viewport_count = min(actual_count, *viewport_count);
5724     for (i = 0; i < *viewport_count; ++i)
5725     {
5726         viewports[i].TopLeftX = wined3d_vp[i].x;
5727         viewports[i].TopLeftY = wined3d_vp[i].y;
5728         viewports[i].Width = wined3d_vp[i].width;
5729         viewports[i].Height = wined3d_vp[i].height;
5730         viewports[i].MinDepth = wined3d_vp[i].min_z;
5731         viewports[i].MaxDepth = wined3d_vp[i].max_z;
5732     }
5733 }
5734
5735 static void STDMETHODCALLTYPE d3d10_device_RSGetScissorRects(ID3D10Device1 *iface, UINT *rect_count, D3D10_RECT *rects)
5736 {
5737     struct d3d_device *device = impl_from_ID3D10Device(iface);
5738     unsigned int actual_count;
5739
5740     TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
5741
5742     if (!rect_count)
5743         return;
5744
5745     actual_count = *rect_count;
5746
5747     wined3d_mutex_lock();
5748     wined3d_device_context_get_scissor_rects(device->immediate_context.wined3d_context, &actual_count, rects);
5749     wined3d_mutex_unlock();
5750
5751     if (!rects)
5752     {
5753         *rect_count = actual_count;
5754         return;
5755     }
5756
5757     if (*rect_count > actual_count)
5758         memset(&rects[actual_count], 0, (*rect_count - actual_count) * sizeof(*rects));
5759 }
5760
5761 static HRESULT STDMETHODCALLTYPE d3d10_device_GetDeviceRemovedReason(ID3D10Device1 *iface)
5762 {
5763     TRACE("iface %p.\n", iface);
5764
5765     /* In the current implementation the device is never removed, so we can
5766      * just return S_OK here. */
5767
5768     return S_OK;
5769 }
5770
5771 static HRESULT STDMETHODCALLTYPE d3d10_device_SetExceptionMode(ID3D10Device1 *iface, UINT flags)
5772 {
5773     FIXME("iface %p, flags %#x stub!\n", iface, flags);
5774
5775     return E_NOTIMPL;
5776 }
5777
5778 static UINT STDMETHODCALLTYPE d3d10_device_GetExceptionMode(ID3D10Device1 *iface)
5779 {
5780     FIXME("iface %p stub!\n", iface);
5781
5782     return 0;
5783 }
5784
5785 static HRESULT STDMETHODCALLTYPE d3d10_device_GetPrivateData(ID3D10Device1 *iface,
5786         REFGUID guid, UINT *data_size, void *data)
5787 {
5788     struct d3d_device *device = impl_from_ID3D10Device(iface);
5789
5790     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
5791
5792     return d3d11_device_GetPrivateData(&device->ID3D11Device2_iface, guid, data_size, data);
5793 }
5794
5795 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateData(ID3D10Device1 *iface,
5796         REFGUID guid, UINT data_size, const void *data)
5797 {
5798     struct d3d_device *device = impl_from_ID3D10Device(iface);
5799
5800     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
5801
5802     return d3d11_device_SetPrivateData(&device->ID3D11Device2_iface, guid, data_size, data);
5803 }
5804
5805 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateDataInterface(ID3D10Device1 *iface,
5806         REFGUID guid, const IUnknown *data)
5807 {
5808     struct d3d_device *device = impl_from_ID3D10Device(iface);
5809
5810     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
5811
5812     return d3d11_device_SetPrivateDataInterface(&device->ID3D11Device2_iface, guid, data);
5813 }
5814
5815 static void STDMETHODCALLTYPE d3d10_device_ClearState(ID3D10Device1 *iface)
5816 {
5817     struct d3d_device *device = impl_from_ID3D10Device(iface);
5818
5819     TRACE("iface %p.\n", iface);
5820
5821     d3d11_device_context_ClearState(&device->immediate_context.ID3D11DeviceContext1_iface);
5822 }
5823
5824 static void STDMETHODCALLTYPE d3d10_device_Flush(ID3D10Device1 *iface)
5825 {
5826     struct d3d_device *device = impl_from_ID3D10Device(iface);
5827
5828     TRACE("iface %p.\n", iface);
5829
5830     wined3d_mutex_lock();
5831     wined3d_device_context_flush(device->immediate_context.wined3d_context);
5832     wined3d_mutex_unlock();
5833 }
5834
5835 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBuffer(ID3D10Device1 *iface,
5836         const D3D10_BUFFER_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Buffer **buffer)
5837 {
5838     struct d3d_device *device = impl_from_ID3D10Device(iface);
5839     D3D11_BUFFER_DESC d3d11_desc;
5840     struct d3d_buffer *object;
5841     HRESULT hr;
5842
5843     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
5844
5845     d3d11_desc.ByteWidth = desc->ByteWidth;
5846     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5847     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5848     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5849     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5850     d3d11_desc.StructureByteStride = 0;
5851
5852     if (FAILED(hr = d3d_buffer_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5853         return hr;
5854
5855     *buffer = &object->ID3D10Buffer_iface;
5856
5857     return S_OK;
5858 }
5859
5860 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture1D(ID3D10Device1 *iface,
5861         const D3D10_TEXTURE1D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Texture1D **texture)
5862 {
5863     struct d3d_device *device = impl_from_ID3D10Device(iface);
5864     D3D11_TEXTURE1D_DESC d3d11_desc;
5865     struct d3d_texture1d *object;
5866     HRESULT hr;
5867
5868     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
5869
5870     d3d11_desc.Width = desc->Width;
5871     d3d11_desc.MipLevels = desc->MipLevels;
5872     d3d11_desc.ArraySize = desc->ArraySize;
5873     d3d11_desc.Format = desc->Format;
5874     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5875     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5876     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5877     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5878
5879     if (FAILED(hr = d3d_texture1d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5880         return hr;
5881
5882     *texture = &object->ID3D10Texture1D_iface;
5883
5884     return S_OK;
5885 }
5886
5887 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture2D(ID3D10Device1 *iface,
5888         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
5889         ID3D10Texture2D **texture)
5890 {
5891     struct d3d_device *device = impl_from_ID3D10Device(iface);
5892     D3D11_TEXTURE2D_DESC d3d11_desc;
5893     struct d3d_texture2d *object;
5894     HRESULT hr;
5895
5896     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
5897
5898     d3d11_desc.Width = desc->Width;
5899     d3d11_desc.Height = desc->Height;
5900     d3d11_desc.MipLevels = desc->MipLevels;
5901     d3d11_desc.ArraySize = desc->ArraySize;
5902     d3d11_desc.Format = desc->Format;
5903     d3d11_desc.SampleDesc = desc->SampleDesc;
5904     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5905     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5906     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5907     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5908
5909     if (FAILED(hr = d3d_texture2d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5910         return hr;
5911
5912     *texture = &object->ID3D10Texture2D_iface;
5913
5914     return S_OK;
5915 }
5916
5917 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture3D(ID3D10Device1 *iface,
5918         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
5919         ID3D10Texture3D **texture)
5920 {
5921     struct d3d_device *device = impl_from_ID3D10Device(iface);
5922     D3D11_TEXTURE3D_DESC d3d11_desc;
5923     struct d3d_texture3d *object;
5924     HRESULT hr;
5925
5926     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
5927
5928     d3d11_desc.Width = desc->Width;
5929     d3d11_desc.Height = desc->Height;
5930     d3d11_desc.Depth = desc->Depth;
5931     d3d11_desc.MipLevels = desc->MipLevels;
5932     d3d11_desc.Format = desc->Format;
5933     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5934     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5935     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5936     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5937
5938     if (FAILED(hr = d3d_texture3d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5939         return hr;
5940
5941     *texture = &object->ID3D10Texture3D_iface;
5942
5943     return S_OK;
5944 }
5945
5946 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView1(ID3D10Device1 *iface,
5947         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc, ID3D10ShaderResourceView1 **view)
5948 {
5949     struct d3d_device *device = impl_from_ID3D10Device(iface);
5950     struct d3d_shader_resource_view *object;
5951     ID3D11Resource *d3d11_resource;
5952     HRESULT hr;
5953
5954     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5955
5956     if (!resource)
5957         return E_INVALIDARG;
5958
5959     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
5960     {
5961         ERR("Resource does not implement ID3D11Resource.\n");
5962         return E_FAIL;
5963     }
5964
5965     hr = d3d_shader_resource_view_create(device, d3d11_resource, (const D3D11_SHADER_RESOURCE_VIEW_DESC *)desc,
5966             &object);
5967     ID3D11Resource_Release(d3d11_resource);
5968     if (FAILED(hr))
5969         return hr;
5970
5971     *view = &object->ID3D10ShaderResourceView1_iface;
5972
5973     return S_OK;
5974 }
5975
5976 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView(ID3D10Device1 *iface,
5977         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10ShaderResourceView **view)
5978 {
5979     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5980
5981     return d3d10_device_CreateShaderResourceView1(iface, resource,
5982             (const D3D10_SHADER_RESOURCE_VIEW_DESC1 *)desc, (ID3D10ShaderResourceView1 **)view);
5983 }
5984
5985 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRenderTargetView(ID3D10Device1 *iface,
5986         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10RenderTargetView **view)
5987 {
5988     struct d3d_device *device = impl_from_ID3D10Device(iface);
5989     struct d3d_rendertarget_view *object;
5990     ID3D11Resource *d3d11_resource;
5991     HRESULT hr;
5992
5993     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5994
5995     if (!resource)
5996         return E_INVALIDARG;
5997
5998     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
5999     {
6000         ERR("Resource does not implement ID3D11Resource.\n");
6001         return E_FAIL;
6002     }
6003
6004     hr = d3d_rendertarget_view_create(device, d3d11_resource, (const D3D11_RENDER_TARGET_VIEW_DESC *)desc, &object);
6005     ID3D11Resource_Release(d3d11_resource);
6006     if (FAILED(hr))
6007         return hr;
6008
6009     *view = &object->ID3D10RenderTargetView_iface;
6010
6011     return S_OK;
6012 }
6013
6014 static D3D11_DSV_DIMENSION d3d11_dsv_dimension_from_d3d10(D3D10_DSV_DIMENSION dim)
6015 {
6016     return (D3D11_DSV_DIMENSION)dim;
6017 }
6018
6019 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilView(ID3D10Device1 *iface,
6020         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10DepthStencilView **view)
6021 {
6022     struct d3d_device *device = impl_from_ID3D10Device(iface);
6023     D3D11_DEPTH_STENCIL_VIEW_DESC d3d11_desc;
6024     struct d3d_depthstencil_view *object;
6025     ID3D11Resource *d3d11_resource;
6026     HRESULT hr;
6027
6028     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
6029
6030     if (desc)
6031     {
6032         d3d11_desc.Format = desc->Format;
6033         d3d11_desc.ViewDimension = d3d11_dsv_dimension_from_d3d10(desc->ViewDimension);
6034         d3d11_desc.Flags = 0;
6035         memcpy(&d3d11_desc.u, &desc->u, sizeof(d3d11_desc.u));
6036     }
6037
6038     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
6039     {
6040         ERR("Resource does not implement ID3D11Resource.\n");
6041         return E_FAIL;
6042     }
6043
6044     hr = d3d_depthstencil_view_create(device, d3d11_resource, desc ? &d3d11_desc : NULL, &object);
6045     ID3D11Resource_Release(d3d11_resource);
6046     if (FAILED(hr))
6047         return hr;
6048
6049     *view = &object->ID3D10DepthStencilView_iface;
6050
6051     return S_OK;
6052 }
6053
6054 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateInputLayout(ID3D10Device1 *iface,
6055         const D3D10_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
6056         const void *shader_byte_code, SIZE_T shader_byte_code_length,
6057         ID3D10InputLayout **input_layout)
6058 {
6059     struct d3d_device *device = impl_from_ID3D10Device(iface);
6060     struct d3d_input_layout *object;
6061     HRESULT hr;
6062
6063     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, "
6064             "shader_byte_code_length %lu, input_layout %p\n",
6065             iface, element_descs, element_count, shader_byte_code,
6066             shader_byte_code_length, input_layout);
6067
6068     if (FAILED(hr = d3d_input_layout_create(device, (const D3D11_INPUT_ELEMENT_DESC *)element_descs, element_count,
6069             shader_byte_code, shader_byte_code_length, &object)))
6070         return hr;
6071
6072     *input_layout = &object->ID3D10InputLayout_iface;
6073
6074     return S_OK;
6075 }
6076
6077 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateVertexShader(ID3D10Device1 *iface,
6078         const void *byte_code, SIZE_T byte_code_length, ID3D10VertexShader **shader)
6079 {
6080     struct d3d_device *device = impl_from_ID3D10Device(iface);
6081     struct d3d_vertex_shader *object;
6082     HRESULT hr;
6083
6084     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
6085             iface, byte_code, byte_code_length, shader);
6086
6087     if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
6088         return hr;
6089
6090     *shader = &object->ID3D10VertexShader_iface;
6091
6092     return S_OK;
6093 }
6094
6095 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShader(ID3D10Device1 *iface,
6096         const void *byte_code, SIZE_T byte_code_length, ID3D10GeometryShader **shader)
6097 {
6098     struct d3d_device *device = impl_from_ID3D10Device(iface);
6099     struct d3d_geometry_shader *object;
6100     HRESULT hr;
6101
6102     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
6103             iface, byte_code, byte_code_length, shader);
6104
6105     if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
6106             NULL, 0, NULL, 0, 0, &object)))
6107         return hr;
6108
6109     *shader = &object->ID3D10GeometryShader_iface;
6110
6111     return S_OK;
6112 }
6113
6114 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShaderWithStreamOutput(ID3D10Device1 *iface,
6115         const void *byte_code, SIZE_T byte_code_length, const D3D10_SO_DECLARATION_ENTRY *output_stream_decls,
6116         UINT output_stream_decl_count, UINT output_stream_stride, ID3D10GeometryShader **shader)
6117 {
6118     struct d3d_device *device = impl_from_ID3D10Device(iface);
6119     D3D11_SO_DECLARATION_ENTRY *so_entries = NULL;
6120     struct d3d_geometry_shader *object;
6121     unsigned int i, stride_count = 1;
6122     HRESULT hr;
6123
6124     TRACE("iface %p, byte_code %p, byte_code_length %lu, output_stream_decls %p, "
6125             "output_stream_decl_count %u, output_stream_stride %u, shader %p.\n",
6126             iface, byte_code, byte_code_length, output_stream_decls,
6127             output_stream_decl_count, output_stream_stride, shader);
6128
6129     if (!output_stream_decl_count && output_stream_stride)
6130     {
6131         WARN("Stride must be 0 when declaration entry count is 0.\n");
6132         *shader = NULL;
6133         return E_INVALIDARG;
6134     }
6135
6136     if (output_stream_decl_count
6137             && !(so_entries = heap_calloc(output_stream_decl_count, sizeof(*so_entries))))
6138     {
6139         ERR("Failed to allocate D3D11 SO declaration array memory.\n");
6140         *shader = NULL;
6141         return E_OUTOFMEMORY;
6142     }
6143
6144     for (i = 0; i < output_stream_decl_count; ++i)
6145     {
6146         so_entries[i].Stream = 0;
6147         so_entries[i].SemanticName = output_stream_decls[i].SemanticName;
6148         so_entries[i].SemanticIndex = output_stream_decls[i].SemanticIndex;
6149         so_entries[i].StartComponent = output_stream_decls[i].StartComponent;
6150         so_entries[i].ComponentCount = output_stream_decls[i].ComponentCount;
6151         so_entries[i].OutputSlot = output_stream_decls[i].OutputSlot;
6152
6153         if (output_stream_decls[i].OutputSlot)
6154         {
6155             stride_count = 0;
6156             if (output_stream_stride)
6157             {
6158                 WARN("Stride must be 0 when multiple output slots are used.\n");
6159                 heap_free(so_entries);
6160                 *shader = NULL;
6161                 return E_INVALIDARG;
6162             }
6163         }
6164     }
6165
6166     hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
6167             so_entries, output_stream_decl_count, &output_stream_stride, stride_count, 0, &object);
6168     heap_free(so_entries);
6169     if (FAILED(hr))
6170     {
6171         *shader = NULL;
6172         return hr;
6173     }
6174
6175     *shader = &object->ID3D10GeometryShader_iface;
6176
6177     return hr;
6178 }
6179
6180 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePixelShader(ID3D10Device1 *iface,
6181         const void *byte_code, SIZE_T byte_code_length, ID3D10PixelShader **shader)
6182 {
6183     struct d3d_device *device = impl_from_ID3D10Device(iface);
6184     struct d3d_pixel_shader *object;
6185     HRESULT hr;
6186
6187     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
6188             iface, byte_code, byte_code_length, shader);
6189
6190     if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
6191         return hr;
6192
6193     *shader = &object->ID3D10PixelShader_iface;
6194
6195     return S_OK;
6196 }
6197
6198 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState1(ID3D10Device1 *iface,
6199         const D3D10_BLEND_DESC1 *desc, ID3D10BlendState1 **blend_state)
6200 {
6201     struct d3d_device *device = impl_from_ID3D10Device(iface);
6202     struct d3d_blend_state *object;
6203     HRESULT hr;
6204
6205     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
6206
6207     if (FAILED(hr = d3d_blend_state_create(device, (const D3D11_BLEND_DESC *)desc, &object)))
6208         return hr;
6209
6210     *blend_state = &object->ID3D10BlendState1_iface;
6211
6212     return S_OK;
6213 }
6214
6215 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState(ID3D10Device1 *iface,
6216         const D3D10_BLEND_DESC *desc, ID3D10BlendState **blend_state)
6217 {
6218     D3D10_BLEND_DESC1 d3d10_1_desc;
6219     unsigned int i;
6220
6221     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
6222
6223     if (!desc)
6224         return E_INVALIDARG;
6225
6226     d3d10_1_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
6227     d3d10_1_desc.IndependentBlendEnable = FALSE;
6228     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT - 1; ++i)
6229     {
6230         if (desc->BlendEnable[i] != desc->BlendEnable[i + 1]
6231                 || desc->RenderTargetWriteMask[i] != desc->RenderTargetWriteMask[i + 1])
6232             d3d10_1_desc.IndependentBlendEnable = TRUE;
6233     }
6234
6235     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
6236     {
6237         d3d10_1_desc.RenderTarget[i].BlendEnable = desc->BlendEnable[i];
6238         d3d10_1_desc.RenderTarget[i].SrcBlend = desc->SrcBlend;
6239         d3d10_1_desc.RenderTarget[i].DestBlend = desc->DestBlend;
6240         d3d10_1_desc.RenderTarget[i].BlendOp = desc->BlendOp;
6241         d3d10_1_desc.RenderTarget[i].SrcBlendAlpha = desc->SrcBlendAlpha;
6242         d3d10_1_desc.RenderTarget[i].DestBlendAlpha = desc->DestBlendAlpha;
6243         d3d10_1_desc.RenderTarget[i].BlendOpAlpha = desc->BlendOpAlpha;
6244         d3d10_1_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTargetWriteMask[i];
6245     }
6246
6247     return d3d10_device_CreateBlendState1(iface, &d3d10_1_desc, (ID3D10BlendState1 **)blend_state);
6248 }
6249
6250 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilState(ID3D10Device1 *iface,
6251         const D3D10_DEPTH_STENCIL_DESC *desc, ID3D10DepthStencilState **depth_stencil_state)
6252 {
6253     struct d3d_device *device = impl_from_ID3D10Device(iface);
6254     struct d3d_depthstencil_state *object;
6255     HRESULT hr;
6256
6257     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
6258
6259     if (FAILED(hr = d3d_depthstencil_state_create(device, (const D3D11_DEPTH_STENCIL_DESC *)desc, &object)))
6260         return hr;
6261
6262     *depth_stencil_state = &object->ID3D10DepthStencilState_iface;
6263
6264     return S_OK;
6265 }
6266
6267 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device1 *iface,
6268         const D3D10_RASTERIZER_DESC *desc, ID3D10RasterizerState **rasterizer_state)
6269 {
6270     struct d3d_device *device = impl_from_ID3D10Device(iface);
6271     struct d3d_rasterizer_state *object;
6272     HRESULT hr;
6273
6274     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
6275
6276     if (FAILED(hr = d3d_rasterizer_state_create(device, (const D3D11_RASTERIZER_DESC *)desc, &object)))
6277         return hr;
6278
6279     *rasterizer_state = &object->ID3D10RasterizerState_iface;
6280
6281     return S_OK;
6282 }
6283
6284 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateSamplerState(ID3D10Device1 *iface,
6285         const D3D10_SAMPLER_DESC *desc, ID3D10SamplerState **sampler_state)
6286 {
6287     struct d3d_device *device = impl_from_ID3D10Device(iface);
6288     struct d3d_sampler_state *object;
6289     HRESULT hr;
6290
6291     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
6292
6293     if (FAILED(hr = d3d_sampler_state_create(device, (const D3D11_SAMPLER_DESC *)desc, &object)))
6294         return hr;
6295
6296     *sampler_state = &object->ID3D10SamplerState_iface;
6297
6298     return S_OK;
6299 }
6300
6301 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateQuery(ID3D10Device1 *iface,
6302         const D3D10_QUERY_DESC *desc, ID3D10Query **query)
6303 {
6304     struct d3d_device *device = impl_from_ID3D10Device(iface);
6305     struct d3d_query *object;
6306     HRESULT hr;
6307
6308     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
6309
6310     if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, FALSE, &object)))
6311         return hr;
6312
6313     if (query)
6314     {
6315         *query = &object->ID3D10Query_iface;
6316         return S_OK;
6317     }
6318
6319     ID3D10Query_Release(&object->ID3D10Query_iface);
6320     return S_FALSE;
6321 }
6322
6323 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePredicate(ID3D10Device1 *iface,
6324         const D3D10_QUERY_DESC *desc, ID3D10Predicate **predicate)
6325 {
6326     struct d3d_device *device = impl_from_ID3D10Device(iface);
6327     struct d3d_query *object;
6328     HRESULT hr;
6329
6330     TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
6331
6332     if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, TRUE, &object)))
6333         return hr;
6334
6335     if (predicate)
6336     {
6337         *predicate = (ID3D10Predicate *)&object->ID3D10Query_iface;
6338         return S_OK;
6339     }
6340
6341     ID3D10Query_Release(&object->ID3D10Query_iface);
6342     return S_FALSE;
6343 }
6344
6345 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateCounter(ID3D10Device1 *iface,
6346         const D3D10_COUNTER_DESC *desc, ID3D10Counter **counter)
6347 {
6348     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
6349
6350     return E_NOTIMPL;
6351 }
6352
6353 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckFormatSupport(ID3D10Device1 *iface,
6354         DXGI_FORMAT format, UINT *format_support)
6355 {
6356     struct d3d_device *device = impl_from_ID3D10Device(iface);
6357
6358     TRACE("iface %p, format %s, format_support %p.\n",
6359             iface, debug_dxgi_format(format), format_support);
6360
6361     return d3d11_device_CheckFormatSupport(&device->ID3D11Device2_iface, format, format_support);
6362 }
6363
6364 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckMultisampleQualityLevels(ID3D10Device1 *iface,
6365         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
6366 {
6367     struct d3d_device *device = impl_from_ID3D10Device(iface);
6368
6369     TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
6370             iface, debug_dxgi_format(format), sample_count, quality_level_count);
6371
6372     return d3d11_device_CheckMultisampleQualityLevels(&device->ID3D11Device2_iface, format,
6373             sample_count, quality_level_count);
6374 }
6375
6376 static void STDMETHODCALLTYPE d3d10_device_CheckCounterInfo(ID3D10Device1 *iface, D3D10_COUNTER_INFO *counter_info)
6377 {
6378     FIXME("iface %p, counter_info %p stub!\n", iface, counter_info);
6379 }
6380
6381 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckCounter(ID3D10Device1 *iface,
6382         const D3D10_COUNTER_DESC *desc, D3D10_COUNTER_TYPE *type, UINT *active_counters, char *name,
6383         UINT *name_length, char *units, UINT *units_length, char *description, UINT *description_length)
6384 {
6385     FIXME("iface %p, desc %p, type %p, active_counters %p, name %p, name_length %p, "
6386             "units %p, units_length %p, description %p, description_length %p stub!\n",
6387             iface, desc, type, active_counters, name, name_length,
6388             units, units_length, description, description_length);
6389
6390     return E_NOTIMPL;
6391 }
6392
6393 static UINT STDMETHODCALLTYPE d3d10_device_GetCreationFlags(ID3D10Device1 *iface)
6394 {
6395     FIXME("iface %p stub!\n", iface);
6396
6397     return 0;
6398 }
6399
6400 static HRESULT STDMETHODCALLTYPE d3d10_device_OpenSharedResource(ID3D10Device1 *iface,
6401         HANDLE resource_handle, REFIID guid, void **resource)
6402 {
6403     FIXME("iface %p, resource_handle %p, guid %s, resource %p stub!\n",
6404             iface, resource_handle, debugstr_guid(guid), resource);
6405
6406     return E_NOTIMPL;
6407 }
6408
6409 static void STDMETHODCALLTYPE d3d10_device_SetTextFilterSize(ID3D10Device1 *iface, UINT width, UINT height)
6410 {
6411     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
6412 }
6413
6414 static void STDMETHODCALLTYPE d3d10_device_GetTextFilterSize(ID3D10Device1 *iface, UINT *width, UINT *height)
6415 {
6416     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
6417 }
6418
6419 static D3D10_FEATURE_LEVEL1 d3d10_feature_level1_from_d3d_feature_level(D3D_FEATURE_LEVEL level)
6420 {
6421     return (D3D10_FEATURE_LEVEL1)level;
6422 }
6423
6424 static D3D10_FEATURE_LEVEL1 STDMETHODCALLTYPE d3d10_device_GetFeatureLevel(ID3D10Device1 *iface)
6425 {
6426     struct d3d_device *device = impl_from_ID3D10Device(iface);
6427
6428     TRACE("iface %p.\n", iface);
6429
6430     return d3d10_feature_level1_from_d3d_feature_level(device->state->feature_level);
6431 }
6432
6433 static const struct ID3D10Device1Vtbl d3d10_device1_vtbl =
6434 {
6435     /* IUnknown methods */
6436     d3d10_device_QueryInterface,
6437     d3d10_device_AddRef,
6438     d3d10_device_Release,
6439     /* ID3D10Device methods */
6440     d3d10_device_VSSetConstantBuffers,
6441     d3d10_device_PSSetShaderResources,
6442     d3d10_device_PSSetShader,
6443     d3d10_device_PSSetSamplers,
6444     d3d10_device_VSSetShader,
6445     d3d10_device_DrawIndexed,
6446     d3d10_device_Draw,
6447     d3d10_device_PSSetConstantBuffers,
6448     d3d10_device_IASetInputLayout,
6449     d3d10_device_IASetVertexBuffers,
6450     d3d10_device_IASetIndexBuffer,
6451     d3d10_device_DrawIndexedInstanced,
6452     d3d10_device_DrawInstanced,
6453     d3d10_device_GSSetConstantBuffers,
6454     d3d10_device_GSSetShader,
6455     d3d10_device_IASetPrimitiveTopology,
6456     d3d10_device_VSSetShaderResources,
6457     d3d10_device_VSSetSamplers,
6458     d3d10_device_SetPredication,
6459     d3d10_device_GSSetShaderResources,
6460     d3d10_device_GSSetSamplers,
6461     d3d10_device_OMSetRenderTargets,
6462     d3d10_device_OMSetBlendState,
6463     d3d10_device_OMSetDepthStencilState,
6464     d3d10_device_SOSetTargets,
6465     d3d10_device_DrawAuto,
6466     d3d10_device_RSSetState,
6467     d3d10_device_RSSetViewports,
6468     d3d10_device_RSSetScissorRects,
6469     d3d10_device_CopySubresourceRegion,
6470     d3d10_device_CopyResource,
6471     d3d10_device_UpdateSubresource,
6472     d3d10_device_ClearRenderTargetView,
6473     d3d10_device_ClearDepthStencilView,
6474     d3d10_device_GenerateMips,
6475     d3d10_device_ResolveSubresource,
6476     d3d10_device_VSGetConstantBuffers,
6477     d3d10_device_PSGetShaderResources,
6478     d3d10_device_PSGetShader,
6479     d3d10_device_PSGetSamplers,
6480     d3d10_device_VSGetShader,
6481     d3d10_device_PSGetConstantBuffers,
6482     d3d10_device_IAGetInputLayout,
6483     d3d10_device_IAGetVertexBuffers,
6484     d3d10_device_IAGetIndexBuffer,
6485     d3d10_device_GSGetConstantBuffers,
6486     d3d10_device_GSGetShader,
6487     d3d10_device_IAGetPrimitiveTopology,
6488     d3d10_device_VSGetShaderResources,
6489     d3d10_device_VSGetSamplers,
6490     d3d10_device_GetPredication,
6491     d3d10_device_GSGetShaderResources,
6492     d3d10_device_GSGetSamplers,
6493     d3d10_device_OMGetRenderTargets,
6494     d3d10_device_OMGetBlendState,
6495     d3d10_device_OMGetDepthStencilState,
6496     d3d10_device_SOGetTargets,
6497     d3d10_device_RSGetState,
6498     d3d10_device_RSGetViewports,
6499     d3d10_device_RSGetScissorRects,
6500     d3d10_device_GetDeviceRemovedReason,
6501     d3d10_device_SetExceptionMode,
6502     d3d10_device_GetExceptionMode,
6503     d3d10_device_GetPrivateData,
6504     d3d10_device_SetPrivateData,
6505     d3d10_device_SetPrivateDataInterface,
6506     d3d10_device_ClearState,
6507     d3d10_device_Flush,
6508     d3d10_device_CreateBuffer,
6509     d3d10_device_CreateTexture1D,
6510     d3d10_device_CreateTexture2D,
6511     d3d10_device_CreateTexture3D,
6512     d3d10_device_CreateShaderResourceView,
6513     d3d10_device_CreateRenderTargetView,
6514     d3d10_device_CreateDepthStencilView,
6515     d3d10_device_CreateInputLayout,
6516     d3d10_device_CreateVertexShader,
6517     d3d10_device_CreateGeometryShader,
6518     d3d10_device_CreateGeometryShaderWithStreamOutput,
6519     d3d10_device_CreatePixelShader,
6520     d3d10_device_CreateBlendState,
6521     d3d10_device_CreateDepthStencilState,
6522     d3d10_device_CreateRasterizerState,
6523     d3d10_device_CreateSamplerState,
6524     d3d10_device_CreateQuery,
6525     d3d10_device_CreatePredicate,
6526     d3d10_device_CreateCounter,
6527     d3d10_device_CheckFormatSupport,
6528     d3d10_device_CheckMultisampleQualityLevels,
6529     d3d10_device_CheckCounterInfo,
6530     d3d10_device_CheckCounter,
6531     d3d10_device_GetCreationFlags,
6532     d3d10_device_OpenSharedResource,
6533     d3d10_device_SetTextFilterSize,
6534     d3d10_device_GetTextFilterSize,
6535     d3d10_device_CreateShaderResourceView1,
6536     d3d10_device_CreateBlendState1,
6537     d3d10_device_GetFeatureLevel,
6538 };
6539
6540 static const struct IUnknownVtbl d3d_device_inner_unknown_vtbl =
6541 {
6542     /* IUnknown methods */
6543     d3d_device_inner_QueryInterface,
6544     d3d_device_inner_AddRef,
6545     d3d_device_inner_Release,
6546 };
6547
6548 /* ID3D10Multithread methods */
6549
6550 static inline struct d3d_device *impl_from_ID3D10Multithread(ID3D10Multithread *iface)
6551 {
6552     return CONTAINING_RECORD(iface, struct d3d_device, ID3D10Multithread_iface);
6553 }
6554
6555 static HRESULT STDMETHODCALLTYPE d3d10_multithread_QueryInterface(ID3D10Multithread *iface, REFIID iid, void **out)
6556 {
6557     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
6558
6559     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
6560
6561     return IUnknown_QueryInterface(device->outer_unk, iid, out);
6562 }
6563
6564 static ULONG STDMETHODCALLTYPE d3d10_multithread_AddRef(ID3D10Multithread *iface)
6565 {
6566     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
6567
6568     TRACE("iface %p.\n", iface);
6569
6570     return IUnknown_AddRef(device->outer_unk);
6571 }
6572
6573 static ULONG STDMETHODCALLTYPE d3d10_multithread_Release(ID3D10Multithread *iface)
6574 {
6575     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
6576
6577     TRACE("iface %p.\n", iface);
6578
6579     return IUnknown_Release(device->outer_unk);
6580 }
6581
6582 static void STDMETHODCALLTYPE d3d10_multithread_Enter(ID3D10Multithread *iface)
6583 {
6584     TRACE("iface %p.\n", iface);
6585
6586     wined3d_mutex_lock();
6587 }
6588
6589 static void STDMETHODCALLTYPE d3d10_multithread_Leave(ID3D10Multithread *iface)
6590 {
6591     TRACE("iface %p.\n", iface);
6592
6593     wined3d_mutex_unlock();
6594 }
6595
6596 static BOOL STDMETHODCALLTYPE d3d10_multithread_SetMultithreadProtected(ID3D10Multithread *iface, BOOL enable)
6597 {
6598     FIXME("iface %p, enable %#x stub!\n", iface, enable);
6599
6600     return TRUE;
6601 }
6602
6603 static BOOL STDMETHODCALLTYPE d3d10_multithread_GetMultithreadProtected(ID3D10Multithread *iface)
6604 {
6605     FIXME("iface %p stub!\n", iface);
6606
6607     return TRUE;
6608 }
6609
6610 static const struct ID3D10MultithreadVtbl d3d10_multithread_vtbl =
6611 {
6612     d3d10_multithread_QueryInterface,
6613     d3d10_multithread_AddRef,
6614     d3d10_multithread_Release,
6615     d3d10_multithread_Enter,
6616     d3d10_multithread_Leave,
6617     d3d10_multithread_SetMultithreadProtected,
6618     d3d10_multithread_GetMultithreadProtected,
6619 };
6620
6621 /* IWineDXGIDeviceParent IUnknown methods */
6622
6623 static inline struct d3d_device *device_from_dxgi_device_parent(IWineDXGIDeviceParent *iface)
6624 {
6625     return CONTAINING_RECORD(iface, struct d3d_device, IWineDXGIDeviceParent_iface);
6626 }
6627
6628 static HRESULT STDMETHODCALLTYPE dxgi_device_parent_QueryInterface(IWineDXGIDeviceParent *iface,
6629         REFIID iid, void **out)
6630 {
6631     struct d3d_device *device = device_from_dxgi_device_parent(iface);
6632     return IUnknown_QueryInterface(device->outer_unk, iid, out);
6633 }
6634
6635 static ULONG STDMETHODCALLTYPE dxgi_device_parent_AddRef(IWineDXGIDeviceParent *iface)
6636 {
6637     struct d3d_device *device = device_from_dxgi_device_parent(iface);
6638     return IUnknown_AddRef(device->outer_unk);
6639 }
6640
6641 static ULONG STDMETHODCALLTYPE dxgi_device_parent_Release(IWineDXGIDeviceParent *iface)
6642 {
6643     struct d3d_device *device = device_from_dxgi_device_parent(iface);
6644     return IUnknown_Release(device->outer_unk);
6645 }
6646
6647 static struct wined3d_device_parent * STDMETHODCALLTYPE dxgi_device_parent_get_wined3d_device_parent(
6648         IWineDXGIDeviceParent *iface)
6649 {
6650     struct d3d_device *device = device_from_dxgi_device_parent(iface);
6651     return &device->device_parent;
6652 }
6653
6654 static const struct IWineDXGIDeviceParentVtbl d3d_dxgi_device_parent_vtbl =
6655 {
6656     /* IUnknown methods */
6657     dxgi_device_parent_QueryInterface,
6658     dxgi_device_parent_AddRef,
6659     dxgi_device_parent_Release,
6660     /* IWineDXGIDeviceParent methods */
6661     dxgi_device_parent_get_wined3d_device_parent,
6662 };
6663
6664 static inline struct d3d_device *device_from_wined3d_device_parent(struct wined3d_device_parent *device_parent)
6665 {
6666     return CONTAINING_RECORD(device_parent, struct d3d_device, device_parent);
6667 }
6668
6669 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
6670         struct wined3d_device *wined3d_device)
6671 {
6672     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
6673     struct d3d_device_context_state *state;
6674     struct wined3d_state *wined3d_state;
6675     D3D_FEATURE_LEVEL feature_level;
6676
6677     TRACE("device_parent %p, wined3d_device %p.\n", device_parent, wined3d_device);
6678
6679     wined3d_device_incref(wined3d_device);
6680     device->wined3d_device = wined3d_device;
6681     device->immediate_context.wined3d_context = wined3d_device_get_immediate_context(wined3d_device);
6682
6683     wined3d_state = wined3d_device_get_state(device->wined3d_device);
6684     feature_level = d3d_feature_level_from_wined3d(wined3d_state_get_feature_level(wined3d_state));
6685
6686     if (!(state = heap_alloc_zero(sizeof(*state))))
6687     {
6688         ERR("Failed to create the initial device context state.\n");
6689         return;
6690     }
6691
6692     d3d_device_context_state_init(state, device, feature_level,
6693             device->d3d11_only ? &IID_ID3D11Device2 : &IID_ID3D10Device1);
6694
6695     device->state = state;
6696     if (!d3d_device_context_state_add_entry(state, device, wined3d_state))
6697         ERR("Failed to add entry for wined3d state %p, device %p.\n", wined3d_state, device);
6698
6699     d3d_device_context_state_private_addref(state);
6700     ID3DDeviceContextState_Release(&state->ID3DDeviceContextState_iface);
6701 }
6702
6703 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
6704 {
6705     TRACE("device_parent %p.\n", device_parent);
6706 }
6707
6708 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
6709 {
6710     TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
6711 }
6712
6713 static HRESULT CDECL device_parent_texture_sub_resource_created(struct wined3d_device_parent *device_parent,
6714         enum wined3d_resource_type type, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
6715         void **parent, const struct wined3d_parent_ops **parent_ops)
6716 {
6717     TRACE("device_parent %p, type %#x, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
6718             device_parent, type, wined3d_texture, sub_resource_idx, parent, parent_ops);
6719
6720     *parent = NULL;
6721     *parent_ops = &d3d_null_wined3d_parent_ops;
6722
6723     return S_OK;
6724 }
6725
6726 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
6727         void *container_parent, const struct wined3d_resource_desc *wined3d_desc, DWORD texture_flags,
6728         struct wined3d_texture **wined3d_texture)
6729 {
6730     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
6731     struct d3d_texture2d *texture;
6732     ID3D11Texture2D *texture_iface;
6733     D3D11_TEXTURE2D_DESC desc;
6734     HRESULT hr;
6735
6736     TRACE("device_parent %p, container_parent %p, wined3d_desc %p, texture_flags %#x, wined3d_texture %p.\n",
6737             device_parent, container_parent, wined3d_desc, texture_flags, wined3d_texture);
6738
6739     desc.Width = wined3d_desc->width;
6740     desc.Height = wined3d_desc->height;
6741     desc.MipLevels = 1;
6742     desc.ArraySize = 1;
6743     desc.Format = dxgi_format_from_wined3dformat(wined3d_desc->format);
6744     desc.SampleDesc.Count = wined3d_desc->multisample_type ? wined3d_desc->multisample_type : 1;
6745     desc.SampleDesc.Quality = wined3d_desc->multisample_quality;
6746     desc.Usage = D3D11_USAGE_DEFAULT;
6747     desc.BindFlags = d3d11_bind_flags_from_wined3d(wined3d_desc->bind_flags);
6748     desc.CPUAccessFlags = 0;
6749     desc.MiscFlags = 0;
6750
6751     if (texture_flags & WINED3D_TEXTURE_CREATE_GET_DC)
6752     {
6753         desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
6754         texture_flags &= ~WINED3D_TEXTURE_CREATE_GET_DC;
6755     }
6756
6757     if (texture_flags)
6758         FIXME("Unhandled flags %#x.\n", texture_flags);
6759
6760     if (FAILED(hr = d3d11_device_CreateTexture2D(&device->ID3D11Device2_iface,
6761             &desc, NULL, &texture_iface)))
6762     {
6763         WARN("Failed to create 2D texture, hr %#x.\n", hr);
6764         return hr;
6765     }
6766
6767     texture = impl_from_ID3D11Texture2D(texture_iface);
6768
6769     *wined3d_texture = texture->wined3d_texture;
6770     wined3d_texture_incref(*wined3d_texture);
6771     ID3D11Texture2D_Release(&texture->ID3D11Texture2D_iface);
6772
6773     return S_OK;
6774 }
6775
6776 static const struct wined3d_device_parent_ops d3d_wined3d_device_parent_ops =
6777 {
6778     device_parent_wined3d_device_created,
6779     device_parent_mode_changed,
6780     device_parent_activate,
6781     device_parent_texture_sub_resource_created,
6782     device_parent_create_swapchain_texture,
6783 };
6784
6785 static int d3d_sampler_state_compare(const void *key, const struct wine_rb_entry *entry)
6786 {
6787     const D3D11_SAMPLER_DESC *ka = key;
6788     const D3D11_SAMPLER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_sampler_state, entry)->desc;
6789
6790     return memcmp(ka, kb, sizeof(*ka));
6791 }
6792
6793 static int d3d_blend_state_compare(const void *key, const struct wine_rb_entry *entry)
6794 {
6795     const D3D11_BLEND_DESC *ka = key;
6796     const D3D11_BLEND_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_blend_state, entry)->desc;
6797
6798     return memcmp(ka, kb, sizeof(*ka));
6799 }
6800
6801 static int d3d_depthstencil_state_compare(const void *key, const struct wine_rb_entry *entry)
6802 {
6803     const D3D11_DEPTH_STENCIL_DESC *ka = key;
6804     const D3D11_DEPTH_STENCIL_DESC *kb = &WINE_RB_ENTRY_VALUE(entry,
6805             const struct d3d_depthstencil_state, entry)->desc;
6806
6807     return memcmp(ka, kb, sizeof(*ka));
6808 }
6809
6810 static int d3d_rasterizer_state_compare(const void *key, const struct wine_rb_entry *entry)
6811 {
6812     const D3D11_RASTERIZER_DESC *ka = key;
6813     const D3D11_RASTERIZER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_rasterizer_state, entry)->desc;
6814
6815     return memcmp(ka, kb, sizeof(*ka));
6816 }
6817
6818 void d3d_device_init(struct d3d_device *device, void *outer_unknown)
6819 {
6820     device->IUnknown_inner.lpVtbl = &d3d_device_inner_unknown_vtbl;
6821     device->ID3D11Device2_iface.lpVtbl = &d3d11_device_vtbl;
6822     device->ID3D10Device1_iface.lpVtbl = &d3d10_device1_vtbl;
6823     device->ID3D10Multithread_iface.lpVtbl = &d3d10_multithread_vtbl;
6824     device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d_dxgi_device_parent_vtbl;
6825     device->device_parent.ops = &d3d_wined3d_device_parent_ops;
6826     device->refcount = 1;
6827     /* COM aggregation always takes place */
6828     device->outer_unk = outer_unknown;
6829     device->d3d11_only = FALSE;
6830     device->state = NULL;
6831
6832     d3d11_device_context_init(&device->immediate_context, device, D3D11_DEVICE_CONTEXT_IMMEDIATE);
6833     ID3D11DeviceContext1_Release(&device->immediate_context.ID3D11DeviceContext1_iface);
6834
6835     wine_rb_init(&device->blend_states, d3d_blend_state_compare);
6836     wine_rb_init(&device->depthstencil_states, d3d_depthstencil_state_compare);
6837     wine_rb_init(&device->rasterizer_states, d3d_rasterizer_state_compare);
6838     wine_rb_init(&device->sampler_states, d3d_sampler_state_compare);
6839 }