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