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