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