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