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 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #define NONAMELESSUNION
  24 #include "d3d11_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  27
  28 static void STDMETHODCALLTYPE d3d_null_wined3d_object_destroyed(void *parent) {}
  29
  30 const struct wined3d_parent_ops d3d_null_wined3d_parent_ops =
  31 {
  32     d3d_null_wined3d_object_destroyed,
  33 };
  34
  35 /* ID3D11DeviceContext - immediate context methods */
  36
  37 static inline struct d3d11_immediate_context *impl_from_ID3D11DeviceContext(ID3D11DeviceContext *iface)
  38 {
  39     return CONTAINING_RECORD(iface, struct d3d11_immediate_context, ID3D11DeviceContext_iface);
  40 }
  41
  42 static inline struct d3d_device *device_from_immediate_ID3D11DeviceContext(ID3D11DeviceContext *iface)
  43 {
  44     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
  45     return CONTAINING_RECORD(context, struct d3d_device, immediate_context);
  46 }
  47
  48 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_QueryInterface(ID3D11DeviceContext *iface,
  49         REFIID riid, void **out)
  50 {
  51     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  52
  53     if (IsEqualGUID(riid, &IID_ID3D11DeviceContext)
  54             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
  55             || IsEqualGUID(riid, &IID_IUnknown))
  56     {
  57         ID3D11DeviceContext_AddRef(iface);
  58         *out = iface;
  59         return S_OK;
  60     }
  61
  62     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  63     *out = NULL;
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG STDMETHODCALLTYPE d3d11_immediate_context_AddRef(ID3D11DeviceContext *iface)
  68 {
  69     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
  70     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
  71     ULONG refcount = InterlockedIncrement(&context->refcount);
  72
  73     TRACE("%p increasing refcount to %u.\n", context, refcount);
  74
  75     if (refcount == 1)
  76     {
  77         ID3D11Device_AddRef(&device->ID3D11Device_iface);
  78     }
  79
  80     return refcount;
  81 }
  82
  83 static ULONG STDMETHODCALLTYPE d3d11_immediate_context_Release(ID3D11DeviceContext *iface)
  84 {
  85     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
  86     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
  87     ULONG refcount = InterlockedDecrement(&context->refcount);
  88
  89     TRACE("%p decreasing refcount to %u.\n", context, refcount);
  90
  91     if (!refcount)
  92     {
  93         ID3D11Device_Release(&device->ID3D11Device_iface);
  94     }
  95
  96     return refcount;
  97 }
  98
  99 static void STDMETHODCALLTYPE d3d11_immediate_context_GetDevice(ID3D11DeviceContext *iface, ID3D11Device **device)
 100 {
 101     struct d3d_device *device_object = device_from_immediate_ID3D11DeviceContext(iface);
 102
 103     TRACE("iface %p, device %p.\n", iface, device);
 104
 105     *device = &device_object->ID3D11Device_iface;
 106     ID3D11Device_AddRef(*device);
 107 }
 108
 109 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_GetPrivateData(ID3D11DeviceContext *iface, REFGUID guid,
 110         UINT *data_size, void *data)
 111 {
 112     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
 113
 114     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 115
 116     return d3d_get_private_data(&context->private_store, guid, data_size, data);
 117 }
 118
 119 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_SetPrivateData(ID3D11DeviceContext *iface, REFGUID guid,
 120         UINT data_size, const void *data)
 121 {
 122     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
 123
 124     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 125
 126     return d3d_set_private_data(&context->private_store, guid, data_size, data);
 127 }
 128
 129 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_SetPrivateDataInterface(ID3D11DeviceContext *iface,
 130         REFGUID guid, const IUnknown *data)
 131 {
 132     struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
 133
 134     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 135
 136     return d3d_set_private_data_interface(&context->private_store, guid, data);
 137 }
 138
 139 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetConstantBuffers(ID3D11DeviceContext *iface,
 140         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 141 {
 142     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 143     unsigned int i;
 144
 145     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 146             iface, start_slot, buffer_count, buffers);
 147
 148     wined3d_mutex_lock();
 149     for (i = 0; i < buffer_count; ++i)
 150     {
 151         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 152
 153         wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
 154                 buffer ? buffer->wined3d_buffer : NULL);
 155     }
 156     wined3d_mutex_unlock();
 157 }
 158
 159 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetShaderResources(ID3D11DeviceContext *iface,
 160         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
 161 {
 162     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 163     unsigned int i;
 164
 165     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
 166             iface, start_slot, view_count, views);
 167
 168     wined3d_mutex_lock();
 169     for (i = 0; i < view_count; ++i)
 170     {
 171         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
 172
 173         wined3d_device_set_ps_resource_view(device->wined3d_device, start_slot + i,
 174                 view ? view->wined3d_view : NULL);
 175     }
 176     wined3d_mutex_unlock();
 177 }
 178
 179 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetShader(ID3D11DeviceContext *iface,
 180         ID3D11PixelShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 181 {
 182     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 183     struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D11PixelShader(shader);
 184
 185     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 186             iface, shader, class_instances, class_instance_count);
 187
 188     if (class_instances)
 189         FIXME("Dynamic linking is not implemented yet.\n");
 190
 191     wined3d_mutex_lock();
 192     wined3d_device_set_pixel_shader(device->wined3d_device, ps ? ps->wined3d_shader : NULL);
 193     wined3d_mutex_unlock();
 194 }
 195
 196 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetSamplers(ID3D11DeviceContext *iface,
 197         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
 198 {
 199     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 200     unsigned int i;
 201
 202     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 203             iface, start_slot, sampler_count, samplers);
 204
 205     wined3d_mutex_lock();
 206     for (i = 0; i < sampler_count; ++i)
 207     {
 208         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
 209
 210         wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
 211                 sampler ? sampler->wined3d_sampler : NULL);
 212     }
 213     wined3d_mutex_unlock();
 214 }
 215
 216 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetShader(ID3D11DeviceContext *iface,
 217         ID3D11VertexShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 218 {
 219     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 220     struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D11VertexShader(shader);
 221
 222     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 223             iface, shader, class_instances, class_instance_count);
 224
 225     if (class_instances)
 226         FIXME("Dynamic linking is not implemented yet.\n");
 227
 228     wined3d_mutex_lock();
 229     wined3d_device_set_vertex_shader(device->wined3d_device, vs ? vs->wined3d_shader : NULL);
 230     wined3d_mutex_unlock();
 231 }
 232
 233 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexed(ID3D11DeviceContext *iface,
 234         UINT index_count, UINT start_index_location, INT base_vertex_location)
 235 {
 236     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 237
 238     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
 239             iface, index_count, start_index_location, base_vertex_location);
 240
 241     wined3d_mutex_lock();
 242     wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
 243     wined3d_device_draw_indexed_primitive(device->wined3d_device, start_index_location, index_count);
 244     wined3d_mutex_unlock();
 245 }
 246
 247 static void STDMETHODCALLTYPE d3d11_immediate_context_Draw(ID3D11DeviceContext *iface,
 248         UINT vertex_count, UINT start_vertex_location)
 249 {
 250     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 251
 252     TRACE("iface %p, vertex_count %u, start_vertex_location %u.\n",
 253             iface, vertex_count, start_vertex_location);
 254
 255     wined3d_mutex_lock();
 256     wined3d_device_draw_primitive(device->wined3d_device, start_vertex_location, vertex_count);
 257     wined3d_mutex_unlock();
 258 }
 259
 260 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_Map(ID3D11DeviceContext *iface, ID3D11Resource *resource,
 261         UINT subresource_idx, D3D11_MAP map_type, UINT map_flags, D3D11_MAPPED_SUBRESOURCE *mapped_subresource)
 262 {
 263     struct wined3d_resource *wined3d_resource;
 264     struct wined3d_map_desc map_desc;
 265     HRESULT hr;
 266
 267     TRACE("iface %p, resource %p, subresource_idx %u, map_type %u, map_flags %#x, mapped_subresource %p.\n",
 268             iface, resource, subresource_idx, map_type, map_flags, mapped_subresource);
 269
 270     if (map_flags)
 271         FIXME("Ignoring map_flags %#x.\n", map_flags);
 272
 273     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
 274
 275     wined3d_mutex_lock();
 276     hr = wined3d_resource_map(wined3d_resource, subresource_idx,
 277             &map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type));
 278     wined3d_mutex_unlock();
 279
 280     mapped_subresource->pData = map_desc.data;
 281     mapped_subresource->RowPitch = map_desc.row_pitch;
 282     mapped_subresource->DepthPitch = map_desc.slice_pitch;
 283
 284     return hr;
 285 }
 286
 287 static void STDMETHODCALLTYPE d3d11_immediate_context_Unmap(ID3D11DeviceContext *iface, ID3D11Resource *resource,
 288         UINT subresource_idx)
 289 {
 290     struct wined3d_resource *wined3d_resource;
 291
 292     TRACE("iface %p, resource %p, subresource_idx %u.\n", iface, resource, subresource_idx);
 293
 294     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
 295
 296     wined3d_mutex_lock();
 297     wined3d_resource_unmap(wined3d_resource, subresource_idx);
 298     wined3d_mutex_unlock();
 299 }
 300
 301 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetConstantBuffers(ID3D11DeviceContext *iface,
 302         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 303 {
 304     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 305     unsigned int i;
 306
 307     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 308             iface, start_slot, buffer_count, buffers);
 309
 310     wined3d_mutex_lock();
 311     for (i = 0; i < buffer_count; ++i)
 312     {
 313         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 314
 315         wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
 316                 buffer ? buffer->wined3d_buffer : NULL);
 317     }
 318     wined3d_mutex_unlock();
 319 }
 320
 321 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetInputLayout(ID3D11DeviceContext *iface,
 322         ID3D11InputLayout *input_layout)
 323 {
 324     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 325     struct d3d_input_layout *layout = unsafe_impl_from_ID3D11InputLayout(input_layout);
 326
 327     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
 328
 329     wined3d_mutex_lock();
 330     wined3d_device_set_vertex_declaration(device->wined3d_device, layout ? layout->wined3d_decl : NULL);
 331     wined3d_mutex_unlock();
 332 }
 333
 334 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetVertexBuffers(ID3D11DeviceContext *iface,
 335         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers, const UINT *strides, const UINT *offsets)
 336 {
 337     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 338     unsigned int i;
 339
 340     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
 341             iface, start_slot, buffer_count, buffers, strides, offsets);
 342
 343     wined3d_mutex_lock();
 344     for (i = 0; i < buffer_count; ++i)
 345     {
 346         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 347
 348         wined3d_device_set_stream_source(device->wined3d_device, start_slot + i,
 349                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
 350     }
 351     wined3d_mutex_unlock();
 352 }
 353
 354 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetIndexBuffer(ID3D11DeviceContext *iface,
 355         ID3D11Buffer *buffer, DXGI_FORMAT format, UINT offset)
 356 {
 357     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 358     struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D11Buffer(buffer);
 359
 360     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
 361             iface, buffer, debug_dxgi_format(format), offset);
 362
 363     if (offset)
 364         FIXME("offset %u not supported.\n", offset);
 365
 366     wined3d_mutex_lock();
 367     wined3d_device_set_index_buffer(device->wined3d_device,
 368             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
 369             wined3dformat_from_dxgi_format(format));
 370     wined3d_mutex_unlock();
 371 }
 372
 373 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexedInstanced(ID3D11DeviceContext *iface,
 374         UINT instance_index_count, UINT instance_count, UINT start_index_location, INT base_vertex_location,
 375         UINT start_instance_location)
 376 {
 377     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 378
 379     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
 380             "base_vertex_location %d, start_instance_location %u.\n",
 381             iface, instance_index_count, instance_count, start_index_location,
 382             base_vertex_location, start_instance_location);
 383
 384     wined3d_mutex_lock();
 385     wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
 386     wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
 387             instance_index_count, start_instance_location, instance_count);
 388     wined3d_mutex_unlock();
 389 }
 390
 391 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawInstanced(ID3D11DeviceContext *iface,
 392         UINT instance_vertex_count, UINT instance_count, UINT start_vertex_location, UINT start_instance_location)
 393 {
 394     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 395
 396     TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
 397             "start_instance_location %u.\n",
 398             iface, instance_vertex_count, instance_count, start_vertex_location,
 399             start_instance_location);
 400
 401     wined3d_mutex_lock();
 402     wined3d_device_draw_primitive_instanced(device->wined3d_device, start_vertex_location,
 403             instance_vertex_count, start_instance_location, instance_count);
 404     wined3d_mutex_unlock();
 405 }
 406
 407 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetConstantBuffers(ID3D11DeviceContext *iface,
 408         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
 409 {
 410     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 411     unsigned int i;
 412
 413     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 414             iface, start_slot, buffer_count, buffers);
 415
 416     wined3d_mutex_lock();
 417     for (i = 0; i < buffer_count; ++i)
 418     {
 419         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 420
 421         wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
 422                 buffer ? buffer->wined3d_buffer : NULL);
 423     }
 424     wined3d_mutex_unlock();
 425 }
 426
 427 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetShader(ID3D11DeviceContext *iface,
 428         ID3D11GeometryShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
 429 {
 430     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 431     struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D11GeometryShader(shader);
 432
 433     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
 434             iface, shader, class_instances, class_instance_count);
 435
 436     if (class_instances)
 437         FIXME("Dynamic linking is not implemented yet.\n");
 438
 439     wined3d_mutex_lock();
 440     wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
 441     wined3d_mutex_unlock();
 442 }
 443
 444 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetPrimitiveTopology(ID3D11DeviceContext *iface,
 445         D3D11_PRIMITIVE_TOPOLOGY topology)
 446 {
 447     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 448
 449     TRACE("iface %p, topology %u.\n", iface, topology);
 450
 451     wined3d_mutex_lock();
 452     wined3d_device_set_primitive_type(device->wined3d_device, (enum wined3d_primitive_type)topology);
 453     wined3d_mutex_unlock();
 454 }
 455
 456 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetShaderResources(ID3D11DeviceContext *iface,
 457         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
 458 {
 459     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 460     unsigned int i;
 461
 462     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
 463
 464     wined3d_mutex_lock();
 465     for (i = 0; i < view_count; ++i)
 466     {
 467         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
 468
 469         wined3d_device_set_vs_resource_view(device->wined3d_device, start_slot + i,
 470                 view ? view->wined3d_view : NULL);
 471     }
 472     wined3d_mutex_unlock();
 473 }
 474
 475 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetSamplers(ID3D11DeviceContext *iface,
 476         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
 477 {
 478     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 479     unsigned int i;
 480
 481     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 482             iface, start_slot, sampler_count, samplers);
 483
 484     wined3d_mutex_lock();
 485     for (i = 0; i < sampler_count; ++i)
 486     {
 487         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
 488
 489         wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
 490                 sampler ? sampler->wined3d_sampler : NULL);
 491     }
 492     wined3d_mutex_unlock();
 493 }
 494
 495 static void STDMETHODCALLTYPE d3d11_immediate_context_Begin(ID3D11DeviceContext *iface,
 496         ID3D11Asynchronous *asynchronous)
 497 {
 498     FIXME("iface %p, asynchronous %p stub!\n", iface, asynchronous);
 499 }
 500
 501 static void STDMETHODCALLTYPE d3d11_immediate_context_End(ID3D11DeviceContext *iface,
 502         ID3D11Asynchronous *asynchronous)
 503 {
 504     FIXME("iface %p, asynchronous %p stub!\n", iface, asynchronous);
 505 }
 506
 507 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_GetData(ID3D11DeviceContext *iface,
 508         ID3D11Asynchronous *asynchronous, void *data, UINT data_size, UINT data_flags)
 509 {
 510     FIXME("iface %p, asynchronous %p, data %p, data_size %u, data_flags %#x stub!\n",
 511             iface, asynchronous, data, data_size, data_flags);
 512
 513     return E_NOTIMPL;
 514 }
 515
 516 static void STDMETHODCALLTYPE d3d11_immediate_context_SetPredication(ID3D11DeviceContext *iface,
 517         ID3D11Predicate *predicate, BOOL value)
 518 {
 519     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 520     struct d3d_query *query;
 521
 522     TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
 523
 524     query = unsafe_impl_from_ID3D11Query((ID3D11Query *)predicate);
 525
 526     wined3d_mutex_lock();
 527     wined3d_device_set_predication(device->wined3d_device, query ? query->wined3d_query : NULL, value);
 528     wined3d_mutex_unlock();
 529 }
 530
 531 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetShaderResources(ID3D11DeviceContext *iface,
 532         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
 533 {
 534     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 535     unsigned int i;
 536
 537     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
 538
 539     wined3d_mutex_lock();
 540     for (i = 0; i < view_count; ++i)
 541     {
 542         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
 543
 544         wined3d_device_set_gs_resource_view(device->wined3d_device, start_slot + i,
 545                 view ? view->wined3d_view : NULL);
 546     }
 547     wined3d_mutex_unlock();
 548 }
 549
 550 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetSamplers(ID3D11DeviceContext *iface,
 551         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
 552 {
 553     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 554     unsigned int i;
 555
 556     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 557             iface, start_slot, sampler_count, samplers);
 558
 559     wined3d_mutex_lock();
 560     for (i = 0; i < sampler_count; ++i)
 561     {
 562         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
 563
 564         wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
 565                 sampler ? sampler->wined3d_sampler : NULL);
 566     }
 567     wined3d_mutex_unlock();
 568 }
 569
 570 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetRenderTargets(ID3D11DeviceContext *iface,
 571         UINT render_target_view_count, ID3D11RenderTargetView *const *render_target_views,
 572         ID3D11DepthStencilView *depth_stencil_view)
 573 {
 574     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 575     struct d3d_depthstencil_view *dsv;
 576     unsigned int i;
 577
 578     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
 579             iface, render_target_view_count, render_target_views, depth_stencil_view);
 580
 581     wined3d_mutex_lock();
 582     for (i = 0; i < render_target_view_count; ++i)
 583     {
 584         struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D11RenderTargetView(render_target_views[i]);
 585         wined3d_device_set_rendertarget_view(device->wined3d_device, i, rtv ? rtv->wined3d_view : NULL, FALSE);
 586     }
 587     for (; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 588     {
 589         wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
 590     }
 591
 592     dsv = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
 593     wined3d_device_set_depth_stencil_view(device->wined3d_device, dsv ? dsv->wined3d_view : NULL);
 594     wined3d_mutex_unlock();
 595 }
 596
 597 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetRenderTargetsAndUnorderedAccessViews(
 598         ID3D11DeviceContext *iface, UINT render_target_view_count,
 599         ID3D11RenderTargetView *const *render_target_views, ID3D11DepthStencilView *depth_stencil_view,
 600         UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
 601         ID3D11UnorderedAccessView *const *unordered_access_views, const UINT *initial_counts)
 602 {
 603     FIXME("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
 604             "unordered_access_view_start_slot %u, unordered_access_view_count %u, unordered_access_views %p, "
 605             "initial_counts %p stub!\n",
 606             iface, render_target_view_count, render_target_views, depth_stencil_view,
 607             unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views,
 608             initial_counts);
 609 }
 610
 611 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetBlendState(ID3D11DeviceContext *iface,
 612         ID3D11BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
 613 {
 614     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 615     static const float default_blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
 616     const D3D11_BLEND_DESC *desc;
 617
 618     TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
 619             iface, blend_state, debug_float4(blend_factor), sample_mask);
 620
 621     if (!blend_factor)
 622         blend_factor = default_blend_factor;
 623
 624     if (blend_factor[0] != 1.0f || blend_factor[1] != 1.0f || blend_factor[2] != 1.0f || blend_factor[3] != 1.0f)
 625         FIXME("Ignoring blend factor %s.\n", debug_float4(blend_factor));
 626
 627     wined3d_mutex_lock();
 628     memcpy(device->blend_factor, blend_factor, 4 * sizeof(*blend_factor));
 629     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK, sample_mask);
 630     if (!(device->blend_state = unsafe_impl_from_ID3D11BlendState(blend_state)))
 631     {
 632         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE, FALSE);
 633         wined3d_device_set_render_state(device->wined3d_device,
 634                 WINED3D_RS_COLORWRITEENABLE, D3D11_COLOR_WRITE_ENABLE_ALL);
 635         wined3d_device_set_render_state(device->wined3d_device,
 636                 WINED3D_RS_COLORWRITEENABLE1, D3D11_COLOR_WRITE_ENABLE_ALL);
 637         wined3d_device_set_render_state(device->wined3d_device,
 638                 WINED3D_RS_COLORWRITEENABLE2, D3D11_COLOR_WRITE_ENABLE_ALL);
 639         wined3d_device_set_render_state(device->wined3d_device,
 640                 WINED3D_RS_COLORWRITEENABLE3, D3D11_COLOR_WRITE_ENABLE_ALL);
 641         wined3d_mutex_unlock();
 642         return;
 643     }
 644
 645     desc = &device->blend_state->desc;
 646     /* glSampleCoverage() */
 647     if (desc->AlphaToCoverageEnable)
 648         FIXME("Ignoring AlphaToCoverageEnable %#x.\n", desc->AlphaToCoverageEnable);
 649     /* glEnableIndexedEXT(GL_BLEND, ...) */
 650     FIXME("Per-rendertarget blend not implemented.\n");
 651     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE,
 652             desc->RenderTarget[0].BlendEnable);
 653     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLEND, desc->RenderTarget[0].SrcBlend);
 654     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLEND, desc->RenderTarget[0].DestBlend);
 655     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOP, desc->RenderTarget[0].BlendOp);
 656     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SEPARATEALPHABLENDENABLE, TRUE);
 657     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLENDALPHA,
 658             desc->RenderTarget[0].SrcBlendAlpha);
 659     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLENDALPHA,
 660             desc->RenderTarget[0].DestBlendAlpha);
 661     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOPALPHA,
 662             desc->RenderTarget[0].BlendOpAlpha);
 663     FIXME("Color mask > 3 not implemented.\n");
 664     wined3d_device_set_render_state(device->wined3d_device,
 665             WINED3D_RS_COLORWRITEENABLE, desc->RenderTarget[0].RenderTargetWriteMask);
 666     wined3d_device_set_render_state(device->wined3d_device,
 667             WINED3D_RS_COLORWRITEENABLE1, desc->RenderTarget[1].RenderTargetWriteMask);
 668     wined3d_device_set_render_state(device->wined3d_device,
 669             WINED3D_RS_COLORWRITEENABLE2, desc->RenderTarget[2].RenderTargetWriteMask);
 670     wined3d_device_set_render_state(device->wined3d_device,
 671             WINED3D_RS_COLORWRITEENABLE3, desc->RenderTarget[3].RenderTargetWriteMask);
 672     wined3d_mutex_unlock();
 673 }
 674
 675 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetDepthStencilState(ID3D11DeviceContext *iface,
 676         ID3D11DepthStencilState *depth_stencil_state, UINT stencil_ref)
 677 {
 678     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 679     const D3D11_DEPTH_STENCILOP_DESC *stencil_desc;
 680     const D3D11_DEPTH_STENCIL_DESC *desc;
 681
 682     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
 683             iface, depth_stencil_state, stencil_ref);
 684
 685     wined3d_mutex_lock();
 686     device->stencil_ref = stencil_ref;
 687     if (!(device->depth_stencil_state = unsafe_impl_from_ID3D11DepthStencilState(depth_stencil_state)))
 688     {
 689         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, TRUE);
 690         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZWRITEENABLE, D3D11_DEPTH_WRITE_MASK_ALL);
 691         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZFUNC, D3D11_COMPARISON_LESS);
 692         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILENABLE, FALSE);
 693         wined3d_mutex_unlock();
 694         return;
 695     }
 696
 697     desc = &device->depth_stencil_state->desc;
 698
 699     if (desc->FrontFace.StencilFailOp != desc->BackFace.StencilFailOp
 700             || desc->FrontFace.StencilDepthFailOp != desc->BackFace.StencilDepthFailOp
 701             || desc->FrontFace.StencilPassOp != desc->BackFace.StencilPassOp
 702             || desc->FrontFace.StencilFunc != desc->BackFace.StencilFunc)
 703         FIXME("Two-sided stencil testing not supported.\n");
 704
 705     stencil_desc = &desc->FrontFace;
 706
 707     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, desc->DepthEnable);
 708     if (desc->DepthEnable)
 709     {
 710         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZWRITEENABLE, desc->DepthWriteMask);
 711         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZFUNC, desc->DepthFunc);
 712     }
 713
 714     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILENABLE, desc->StencilEnable);
 715     if (desc->StencilEnable)
 716     {
 717         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILMASK, desc->StencilReadMask);
 718         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILWRITEMASK, desc->StencilWriteMask);
 719         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILFAIL, stencil_desc->StencilFailOp);
 720         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILZFAIL,
 721                 stencil_desc->StencilDepthFailOp);
 722         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILPASS, stencil_desc->StencilPassOp);
 723         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILFUNC, stencil_desc->StencilFunc);
 724         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILREF, stencil_ref);
 725     }
 726     wined3d_mutex_unlock();
 727 }
 728
 729 static void STDMETHODCALLTYPE d3d11_immediate_context_SOSetTargets(ID3D11DeviceContext *iface, UINT buffer_count,
 730         ID3D11Buffer *const *buffers, const UINT *offsets)
 731 {
 732     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 733     unsigned int count, i;
 734
 735     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n", iface, buffer_count, buffers, offsets);
 736
 737     count = min(buffer_count, D3D11_SO_BUFFER_SLOT_COUNT);
 738     wined3d_mutex_lock();
 739     for (i = 0; i < count; ++i)
 740     {
 741         struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
 742
 743         wined3d_device_set_stream_output(device->wined3d_device, i,
 744                 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
 745     }
 746     for (; i < D3D11_SO_BUFFER_SLOT_COUNT; ++i)
 747     {
 748         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
 749     }
 750     wined3d_mutex_unlock();
 751 }
 752
 753 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawAuto(ID3D11DeviceContext *iface)
 754 {
 755     FIXME("iface %p stub!\n", iface);
 756 }
 757
 758 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexedInstancedIndirect(ID3D11DeviceContext *iface,
 759         ID3D11Buffer *buffer, UINT offset)
 760 {
 761     FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
 762 }
 763
 764 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawInstancedIndirect(ID3D11DeviceContext *iface,
 765         ID3D11Buffer *buffer, UINT offset)
 766 {
 767     FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
 768 }
 769
 770 static void STDMETHODCALLTYPE d3d11_immediate_context_Dispatch(ID3D11DeviceContext *iface,
 771         UINT thread_group_count_x, UINT thread_group_count_y, UINT thread_group_count_z)
 772 {
 773     FIXME("iface %p, thread_group_count_x %u, thread_group_count_y %u, thread_group_count_z %u stub!\n",
 774             iface, thread_group_count_x, thread_group_count_y, thread_group_count_z);
 775 }
 776
 777 static void STDMETHODCALLTYPE d3d11_immediate_context_DispatchIndirect(ID3D11DeviceContext *iface,
 778         ID3D11Buffer *buffer, UINT offset)
 779 {
 780     FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
 781 }
 782
 783 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetState(ID3D11DeviceContext *iface,
 784         ID3D11RasterizerState *rasterizer_state)
 785 {
 786     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 787     const D3D11_RASTERIZER_DESC *desc;
 788
 789     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
 790
 791     wined3d_mutex_lock();
 792     if (!(device->rasterizer_state = unsafe_impl_from_ID3D11RasterizerState(rasterizer_state)))
 793     {
 794         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, WINED3D_FILL_SOLID);
 795         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, WINED3D_CULL_CCW);
 796         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, FALSE);
 797         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, FALSE);
 798         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ANTIALIASEDLINEENABLE, FALSE);
 799         wined3d_mutex_unlock();
 800         return;
 801     }
 802
 803     desc = &device->rasterizer_state->desc;
 804     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, desc->FillMode);
 805     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, desc->CullMode);
 806     /* glFrontFace() */
 807     if (desc->FrontCounterClockwise)
 808         FIXME("Ignoring FrontCounterClockwise %#x.\n", desc->FrontCounterClockwise);
 809     /* OpenGL style depth bias. */
 810     if (desc->DepthBias || desc->SlopeScaledDepthBias)
 811         FIXME("Ignoring depth bias.\n");
 812     /* GL_DEPTH_CLAMP */
 813     if (!desc->DepthClipEnable)
 814         FIXME("Ignoring DepthClipEnable %#x.\n", desc->DepthClipEnable);
 815     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, desc->ScissorEnable);
 816     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, desc->MultisampleEnable);
 817     wined3d_device_set_render_state(device->wined3d_device,
 818             WINED3D_RS_ANTIALIASEDLINEENABLE, desc->AntialiasedLineEnable);
 819     wined3d_mutex_unlock();
 820 }
 821
 822 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetViewports(ID3D11DeviceContext *iface,
 823         UINT viewport_count, const D3D11_VIEWPORT *viewports)
 824 {
 825     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 826     struct wined3d_viewport wined3d_vp;
 827
 828     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
 829
 830     if (viewport_count > 1)
 831         FIXME("Multiple viewports not implemented.\n");
 832
 833     if (!viewport_count)
 834         return;
 835
 836     if (viewports[0].TopLeftX != (UINT)viewports[0].TopLeftX
 837             || viewports[0].TopLeftY != (UINT)viewports[0].TopLeftY
 838             || viewports[0].Width != (UINT)viewports[0].Width
 839             || viewports[0].Height != (UINT)viewports[0].Height)
 840         FIXME("Floating-point viewports not implemented.\n");
 841
 842     wined3d_vp.x = viewports[0].TopLeftX;
 843     wined3d_vp.y = viewports[0].TopLeftY;
 844     wined3d_vp.width = viewports[0].Width;
 845     wined3d_vp.height = viewports[0].Height;
 846     wined3d_vp.min_z = viewports[0].MinDepth;
 847     wined3d_vp.max_z = viewports[0].MaxDepth;
 848
 849     wined3d_mutex_lock();
 850     wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
 851     wined3d_mutex_unlock();
 852 }
 853
 854 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetScissorRects(ID3D11DeviceContext *iface,
 855         UINT rect_count, const D3D11_RECT *rects)
 856 {
 857     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 858
 859     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
 860
 861     if (rect_count > 1)
 862         FIXME("Multiple scissor rects not implemented.\n");
 863
 864     if (!rect_count)
 865         return;
 866
 867     wined3d_mutex_lock();
 868     wined3d_device_set_scissor_rect(device->wined3d_device, rects);
 869     wined3d_mutex_unlock();
 870 }
 871
 872 static void STDMETHODCALLTYPE d3d11_immediate_context_CopySubresourceRegion(ID3D11DeviceContext *iface,
 873         ID3D11Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
 874         ID3D11Resource *src_resource, UINT src_subresource_idx, const D3D11_BOX *src_box)
 875 {
 876     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 877     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
 878     struct wined3d_box wined3d_src_box;
 879
 880     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
 881             "src_resource %p, src_subresource_idx %u, src_box %p.\n",
 882             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
 883             src_resource, src_subresource_idx, src_box);
 884
 885     if (src_box)
 886     {
 887         wined3d_src_box.left = src_box->left;
 888         wined3d_src_box.top = src_box->top;
 889         wined3d_src_box.front = src_box->front;
 890         wined3d_src_box.right = src_box->right;
 891         wined3d_src_box.bottom = src_box->bottom;
 892         wined3d_src_box.back = src_box->back;
 893     }
 894
 895     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
 896     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
 897     wined3d_mutex_lock();
 898     wined3d_device_copy_sub_resource_region(device->wined3d_device, wined3d_dst_resource, dst_subresource_idx,
 899             dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL);
 900     wined3d_mutex_unlock();
 901 }
 902
 903 static void STDMETHODCALLTYPE d3d11_immediate_context_CopyResource(ID3D11DeviceContext *iface,
 904         ID3D11Resource *dst_resource, ID3D11Resource *src_resource)
 905 {
 906     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 907     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
 908
 909     TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
 910
 911     wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
 912     wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
 913     wined3d_mutex_lock();
 914     wined3d_device_copy_resource(device->wined3d_device, wined3d_dst_resource, wined3d_src_resource);
 915     wined3d_mutex_unlock();
 916 }
 917
 918 static void STDMETHODCALLTYPE d3d11_immediate_context_UpdateSubresource(ID3D11DeviceContext *iface,
 919         ID3D11Resource *resource, UINT subresource_idx, const D3D11_BOX *box,
 920         const void *data, UINT row_pitch, UINT depth_pitch)
 921 {
 922     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 923     struct wined3d_resource *wined3d_resource;
 924     struct wined3d_box wined3d_box;
 925
 926     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
 927             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
 928
 929     if (box)
 930     {
 931         wined3d_box.left = box->left;
 932         wined3d_box.top = box->top;
 933         wined3d_box.front = box->front;
 934         wined3d_box.right = box->right;
 935         wined3d_box.bottom = box->bottom;
 936         wined3d_box.back = box->back;
 937     }
 938
 939     wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
 940     wined3d_mutex_lock();
 941     wined3d_device_update_sub_resource(device->wined3d_device, wined3d_resource,
 942             subresource_idx, box ? &wined3d_box : NULL, data, row_pitch, depth_pitch);
 943     wined3d_mutex_unlock();
 944 }
 945
 946 static void STDMETHODCALLTYPE d3d11_immediate_context_CopyStructureCount(ID3D11DeviceContext *iface,
 947         ID3D11Buffer *dst_buffer, UINT dst_offset, ID3D11UnorderedAccessView *src_view)
 948 {
 949     FIXME("iface %p, dst_buffer %p, dst_offset %u, src_view %p stub!\n",
 950             iface, dst_buffer, dst_offset, src_view);
 951 }
 952
 953 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearRenderTargetView(ID3D11DeviceContext *iface,
 954         ID3D11RenderTargetView *render_target_view, const float color_rgba[4])
 955 {
 956     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 957     struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D11RenderTargetView(render_target_view);
 958     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
 959     HRESULT hr;
 960
 961     TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
 962             iface, render_target_view, debug_float4(color_rgba));
 963
 964     wined3d_mutex_lock();
 965     if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
 966             WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
 967         ERR("Failed to clear view, hr %#x.\n", hr);
 968     wined3d_mutex_unlock();
 969 }
 970
 971 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearUnorderedAccessViewUint(ID3D11DeviceContext *iface,
 972         ID3D11UnorderedAccessView *unordered_access_view, const UINT values[4])
 973 {
 974     FIXME("iface %p, unordered_access_view %p, values {%u %u %u %u} stub!\n",
 975             iface, unordered_access_view, values[0], values[1], values[2], values[3]);
 976 }
 977
 978 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearUnorderedAccessViewFloat(ID3D11DeviceContext *iface,
 979         ID3D11UnorderedAccessView *unordered_access_view, const float values[4])
 980 {
 981     FIXME("iface %p, unordered_access_view %p, values %s stub!\n",
 982             iface, unordered_access_view, debug_float4(values));
 983 }
 984
 985 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearDepthStencilView(ID3D11DeviceContext *iface,
 986         ID3D11DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
 987 {
 988     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
 989     struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
 990     DWORD wined3d_flags;
 991     HRESULT hr;
 992
 993     TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
 994             iface, depth_stencil_view, flags, depth, stencil);
 995
 996     wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
 997
 998     wined3d_mutex_lock();
 999     if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
1000             wined3d_flags, NULL, depth, stencil)))
1001         ERR("Failed to clear view, hr %#x.\n", hr);
1002     wined3d_mutex_unlock();
1003 }
1004
1005 static void STDMETHODCALLTYPE d3d11_immediate_context_GenerateMips(ID3D11DeviceContext *iface,
1006         ID3D11ShaderResourceView *view)
1007 {
1008     FIXME("iface %p, view %p stub!\n", iface, view);
1009 }
1010
1011 static void STDMETHODCALLTYPE d3d11_immediate_context_SetResourceMinLOD(ID3D11DeviceContext *iface,
1012         ID3D11Resource *resource, FLOAT min_lod)
1013 {
1014     FIXME("iface %p, resource %p, min_lod %f stub!\n", iface, resource, min_lod);
1015 }
1016
1017 static FLOAT STDMETHODCALLTYPE d3d11_immediate_context_GetResourceMinLOD(ID3D11DeviceContext *iface,
1018         ID3D11Resource *resource)
1019 {
1020     FIXME("iface %p, resource %p stub!\n", iface, resource);
1021
1022     return 0.0f;
1023 }
1024
1025 static void STDMETHODCALLTYPE d3d11_immediate_context_ResolveSubresource(ID3D11DeviceContext *iface,
1026         ID3D11Resource *dst_resource, UINT dst_subresource_idx,
1027         ID3D11Resource *src_resource, UINT src_subresource_idx,
1028         DXGI_FORMAT format)
1029 {
1030     FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, src_resource %p, src_subresource_idx %u, "
1031             "format %s stub!\n",
1032             iface, dst_resource, dst_subresource_idx, src_resource, src_subresource_idx,
1033             debug_dxgi_format(format));
1034 }
1035
1036 static void STDMETHODCALLTYPE d3d11_immediate_context_ExecuteCommandList(ID3D11DeviceContext *iface,
1037         ID3D11CommandList *command_list, BOOL restore_state)
1038 {
1039     FIXME("iface %p, command_list %p, restore_state %#x stub!\n", iface, command_list, restore_state);
1040 }
1041
1042 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetShaderResources(ID3D11DeviceContext *iface,
1043         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1044 {
1045     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
1046             iface, start_slot, view_count, views);
1047 }
1048
1049 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetShader(ID3D11DeviceContext *iface,
1050         ID3D11HullShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1051 {
1052     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %u stub!\n",
1053             iface, shader, class_instances, class_instance_count);
1054 }
1055
1056 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetSamplers(ID3D11DeviceContext *iface,
1057         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1058 {
1059     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1060             iface, start_slot, sampler_count, samplers);
1061 }
1062
1063 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetConstantBuffers(ID3D11DeviceContext *iface,
1064         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1065 {
1066     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p stub!\n",
1067             iface, start_slot, buffer_count, buffers);
1068 }
1069
1070 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetShaderResources(ID3D11DeviceContext *iface,
1071         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1072 {
1073     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
1074             iface, start_slot, view_count, views);
1075 }
1076
1077 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetShader(ID3D11DeviceContext *iface,
1078         ID3D11DomainShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1079 {
1080     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %u stub!\n",
1081             iface, shader, class_instances, class_instance_count);
1082 }
1083
1084 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetSamplers(ID3D11DeviceContext *iface,
1085         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1086 {
1087     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1088             iface, start_slot, sampler_count, samplers);
1089 }
1090
1091 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetConstantBuffers(ID3D11DeviceContext *iface,
1092         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1093 {
1094     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p stub!\n",
1095             iface, start_slot, buffer_count, buffers);
1096 }
1097
1098 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetShaderResources(ID3D11DeviceContext *iface,
1099         UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1100 {
1101     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
1102             iface, start_slot, view_count, views);
1103 }
1104
1105 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetUnorderedAccessViews(ID3D11DeviceContext *iface,
1106         UINT start_slot, UINT view_count, ID3D11UnorderedAccessView *const *views, const UINT *initial_counts)
1107 {
1108     FIXME("iface %p, start_slot %u, view_count %u, views %p, initial_counts %p stub!\n",
1109             iface, start_slot, view_count, views, initial_counts);
1110 }
1111
1112 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetShader(ID3D11DeviceContext *iface,
1113         ID3D11ComputeShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1114 {
1115     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %u stub!\n",
1116             iface, shader, class_instances, class_instance_count);
1117 }
1118
1119 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetSamplers(ID3D11DeviceContext *iface,
1120         UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1121 {
1122     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1123             iface, start_slot, sampler_count, samplers);
1124 }
1125
1126 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetConstantBuffers(ID3D11DeviceContext *iface,
1127         UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1128 {
1129     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p stub!\n",
1130             iface, start_slot, buffer_count, buffers);
1131 }
1132
1133 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetConstantBuffers(ID3D11DeviceContext *iface,
1134         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1135 {
1136     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1137     unsigned int i;
1138
1139     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1140             iface, start_slot, buffer_count, buffers);
1141
1142     wined3d_mutex_lock();
1143     for (i = 0; i < buffer_count; ++i)
1144     {
1145         struct wined3d_buffer *wined3d_buffer;
1146         struct d3d_buffer *buffer_impl;
1147
1148         if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
1149         {
1150             buffers[i] = NULL;
1151             continue;
1152         }
1153
1154         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1155         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1156         ID3D11Buffer_AddRef(buffers[i]);
1157     }
1158     wined3d_mutex_unlock();
1159 }
1160
1161 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetShaderResources(ID3D11DeviceContext *iface,
1162         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1163 {
1164     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1165     unsigned int i;
1166
1167     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1168             iface, start_slot, view_count, views);
1169
1170     wined3d_mutex_lock();
1171     for (i = 0; i < view_count; ++i)
1172     {
1173         struct wined3d_shader_resource_view *wined3d_view;
1174         struct d3d_shader_resource_view *view_impl;
1175
1176         if (!(wined3d_view = wined3d_device_get_ps_resource_view(device->wined3d_device, start_slot + i)))
1177         {
1178             views[i] = NULL;
1179             continue;
1180         }
1181
1182         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1183         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1184         ID3D11ShaderResourceView_AddRef(views[i]);
1185     }
1186     wined3d_mutex_unlock();
1187 }
1188
1189 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetShader(ID3D11DeviceContext *iface,
1190         ID3D11PixelShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1191 {
1192     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1193     struct wined3d_shader *wined3d_shader;
1194     struct d3d_pixel_shader *shader_impl;
1195
1196     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1197             iface, shader, class_instances, class_instance_count);
1198
1199     if (class_instances || class_instance_count)
1200         FIXME("Dynamic linking not implemented yet.\n");
1201
1202     wined3d_mutex_lock();
1203     if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
1204     {
1205         wined3d_mutex_unlock();
1206         *shader = NULL;
1207         return;
1208     }
1209
1210     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1211     wined3d_mutex_unlock();
1212     *shader = &shader_impl->ID3D11PixelShader_iface;
1213     ID3D11PixelShader_AddRef(*shader);
1214 }
1215
1216 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetSamplers(ID3D11DeviceContext *iface,
1217         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1218 {
1219     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1220     unsigned int i;
1221
1222     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1223             iface, start_slot, sampler_count, samplers);
1224
1225     wined3d_mutex_lock();
1226     for (i = 0; i < sampler_count; ++i)
1227     {
1228         struct wined3d_sampler *wined3d_sampler;
1229         struct d3d_sampler_state *sampler_impl;
1230
1231         if (!(wined3d_sampler = wined3d_device_get_ps_sampler(device->wined3d_device, start_slot + i)))
1232         {
1233             samplers[i] = NULL;
1234             continue;
1235         }
1236
1237         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1238         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1239         ID3D11SamplerState_AddRef(samplers[i]);
1240     }
1241     wined3d_mutex_unlock();
1242 }
1243
1244 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetShader(ID3D11DeviceContext *iface,
1245         ID3D11VertexShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1246 {
1247     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1248     struct d3d_vertex_shader *shader_impl;
1249     struct wined3d_shader *wined3d_shader;
1250
1251     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1252             iface, shader, class_instances, class_instance_count);
1253
1254     if (class_instances || class_instance_count)
1255         FIXME("Dynamic linking not implemented yet.\n");
1256
1257     wined3d_mutex_lock();
1258     if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
1259     {
1260         wined3d_mutex_unlock();
1261         *shader = NULL;
1262         return;
1263     }
1264
1265     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1266     wined3d_mutex_unlock();
1267     *shader = &shader_impl->ID3D11VertexShader_iface;
1268     ID3D11VertexShader_AddRef(*shader);
1269 }
1270
1271 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetConstantBuffers(ID3D11DeviceContext *iface,
1272         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1273 {
1274     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1275     unsigned int i;
1276
1277     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1278             iface, start_slot, buffer_count, buffers);
1279
1280     wined3d_mutex_lock();
1281     for (i = 0; i < buffer_count; ++i)
1282     {
1283         struct wined3d_buffer *wined3d_buffer;
1284         struct d3d_buffer *buffer_impl;
1285
1286         if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
1287         {
1288             buffers[i] = NULL;
1289             continue;
1290         }
1291
1292         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1293         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1294         ID3D11Buffer_AddRef(buffers[i]);
1295     }
1296     wined3d_mutex_unlock();
1297 }
1298
1299 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetInputLayout(ID3D11DeviceContext *iface,
1300         ID3D11InputLayout **input_layout)
1301 {
1302     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1303     struct wined3d_vertex_declaration *wined3d_declaration;
1304     struct d3d_input_layout *input_layout_impl;
1305
1306     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
1307
1308     wined3d_mutex_lock();
1309     if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
1310     {
1311         wined3d_mutex_unlock();
1312         *input_layout = NULL;
1313         return;
1314     }
1315
1316     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
1317     wined3d_mutex_unlock();
1318     *input_layout = &input_layout_impl->ID3D11InputLayout_iface;
1319     ID3D11InputLayout_AddRef(*input_layout);
1320 }
1321
1322 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetVertexBuffers(ID3D11DeviceContext *iface,
1323         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *strides, UINT *offsets)
1324 {
1325     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p stub!\n",
1326             iface, start_slot, buffer_count, buffers, strides, offsets);
1327 }
1328
1329 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetIndexBuffer(ID3D11DeviceContext *iface,
1330         ID3D11Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
1331 {
1332     FIXME("iface %p, buffer %p, format %p, offset %p stub!\n", iface, buffer, format, offset);
1333 }
1334
1335 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetConstantBuffers(ID3D11DeviceContext *iface,
1336         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1337 {
1338     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1339     unsigned int i;
1340
1341     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1342             iface, start_slot, buffer_count, buffers);
1343
1344     wined3d_mutex_lock();
1345     for (i = 0; i < buffer_count; ++i)
1346     {
1347         struct wined3d_buffer *wined3d_buffer;
1348         struct d3d_buffer *buffer_impl;
1349
1350         if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
1351         {
1352             buffers[i] = NULL;
1353             continue;
1354         }
1355
1356         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1357         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1358         ID3D11Buffer_AddRef(buffers[i]);
1359     }
1360     wined3d_mutex_unlock();
1361 }
1362
1363 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetShader(ID3D11DeviceContext *iface,
1364         ID3D11GeometryShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1365 {
1366     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1367     struct d3d_geometry_shader *shader_impl;
1368     struct wined3d_shader *wined3d_shader;
1369
1370     TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1371             iface, shader, class_instances, class_instance_count);
1372
1373     if (class_instances || class_instance_count)
1374         FIXME("Dynamic linking not implemented yet.\n");
1375
1376     wined3d_mutex_lock();
1377     if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
1378     {
1379         wined3d_mutex_unlock();
1380         *shader = NULL;
1381         return;
1382     }
1383
1384     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1385     wined3d_mutex_unlock();
1386     *shader = &shader_impl->ID3D11GeometryShader_iface;
1387     ID3D11GeometryShader_AddRef(*shader);
1388 }
1389
1390 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetPrimitiveTopology(ID3D11DeviceContext *iface,
1391         D3D11_PRIMITIVE_TOPOLOGY *topology)
1392 {
1393     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1394
1395     TRACE("iface %p, topology %p.\n", iface, topology);
1396
1397     wined3d_mutex_lock();
1398     wined3d_device_get_primitive_type(device->wined3d_device, (enum wined3d_primitive_type *)topology);
1399     wined3d_mutex_unlock();
1400 }
1401
1402 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetShaderResources(ID3D11DeviceContext *iface,
1403         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1404 {
1405     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1406     unsigned int i;
1407
1408     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
1409
1410     wined3d_mutex_lock();
1411     for (i = 0; i < view_count; ++i)
1412     {
1413         struct wined3d_shader_resource_view *wined3d_view;
1414         struct d3d_shader_resource_view *view_impl;
1415
1416         if (!(wined3d_view = wined3d_device_get_vs_resource_view(device->wined3d_device, start_slot + i)))
1417         {
1418             views[i] = NULL;
1419             continue;
1420         }
1421
1422         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1423         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1424         ID3D11ShaderResourceView_AddRef(views[i]);
1425     }
1426     wined3d_mutex_unlock();
1427 }
1428
1429 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetSamplers(ID3D11DeviceContext *iface,
1430         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1431 {
1432     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1433     unsigned int i;
1434
1435     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1436             iface, start_slot, sampler_count, samplers);
1437
1438     wined3d_mutex_lock();
1439     for (i = 0; i < sampler_count; ++i)
1440     {
1441         struct wined3d_sampler *wined3d_sampler;
1442         struct d3d_sampler_state *sampler_impl;
1443
1444         if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
1445         {
1446             samplers[i] = NULL;
1447             continue;
1448         }
1449
1450         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1451         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1452         ID3D11SamplerState_AddRef(samplers[i]);
1453     }
1454     wined3d_mutex_unlock();
1455 }
1456
1457 static void STDMETHODCALLTYPE d3d11_immediate_context_GetPredication(ID3D11DeviceContext *iface,
1458         ID3D11Predicate **predicate, BOOL *value)
1459 {
1460     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1461     struct wined3d_query *wined3d_predicate;
1462     struct d3d_query *predicate_impl;
1463
1464     TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
1465
1466     wined3d_mutex_lock();
1467     if (!(wined3d_predicate = wined3d_device_get_predication(device->wined3d_device, value)))
1468     {
1469         wined3d_mutex_unlock();
1470         *predicate = NULL;
1471         return;
1472     }
1473
1474     predicate_impl = wined3d_query_get_parent(wined3d_predicate);
1475     wined3d_mutex_unlock();
1476     *predicate = (ID3D11Predicate *)&predicate_impl->ID3D11Query_iface;
1477     ID3D11Predicate_AddRef(*predicate);
1478 }
1479
1480 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetShaderResources(ID3D11DeviceContext *iface,
1481         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1482 {
1483     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1484     unsigned int i;
1485
1486     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
1487
1488     wined3d_mutex_lock();
1489     for (i = 0; i < view_count; ++i)
1490     {
1491         struct wined3d_shader_resource_view *wined3d_view;
1492         struct d3d_shader_resource_view *view_impl;
1493
1494         if (!(wined3d_view = wined3d_device_get_gs_resource_view(device->wined3d_device, start_slot + i)))
1495         {
1496             views[i] = NULL;
1497             continue;
1498         }
1499
1500         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1501         views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1502         ID3D11ShaderResourceView_AddRef(views[i]);
1503     }
1504     wined3d_mutex_unlock();
1505 }
1506
1507 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetSamplers(ID3D11DeviceContext *iface,
1508         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1509 {
1510     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1511     unsigned int i;
1512
1513     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1514             iface, start_slot, sampler_count, samplers);
1515
1516     wined3d_mutex_lock();
1517     for (i = 0; i < sampler_count; ++i)
1518     {
1519         struct d3d_sampler_state *sampler_impl;
1520         struct wined3d_sampler *wined3d_sampler;
1521
1522         if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
1523         {
1524             samplers[i] = NULL;
1525             continue;
1526         }
1527
1528         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1529         samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1530         ID3D11SamplerState_AddRef(samplers[i]);
1531     }
1532     wined3d_mutex_unlock();
1533 }
1534
1535 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetRenderTargets(ID3D11DeviceContext *iface,
1536         UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
1537         ID3D11DepthStencilView **depth_stencil_view)
1538 {
1539     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1540     struct wined3d_rendertarget_view *wined3d_view;
1541
1542     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
1543             iface, render_target_view_count, render_target_views, depth_stencil_view);
1544
1545     wined3d_mutex_lock();
1546     if (render_target_views)
1547     {
1548         struct d3d_rendertarget_view *view_impl;
1549         unsigned int i;
1550
1551         for (i = 0; i < render_target_view_count; ++i)
1552         {
1553             if (!(wined3d_view = wined3d_device_get_rendertarget_view(device->wined3d_device, i))
1554                     || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1555             {
1556                 render_target_views[i] = NULL;
1557                 continue;
1558             }
1559
1560             render_target_views[i] = &view_impl->ID3D11RenderTargetView_iface;
1561             ID3D11RenderTargetView_AddRef(render_target_views[i]);
1562         }
1563     }
1564
1565     if (depth_stencil_view)
1566     {
1567         struct d3d_depthstencil_view *view_impl;
1568
1569         if (!(wined3d_view = wined3d_device_get_depth_stencil_view(device->wined3d_device))
1570                 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1571         {
1572             *depth_stencil_view = NULL;
1573         }
1574         else
1575         {
1576             *depth_stencil_view = &view_impl->ID3D11DepthStencilView_iface;
1577             ID3D11DepthStencilView_AddRef(*depth_stencil_view);
1578         }
1579     }
1580     wined3d_mutex_unlock();
1581 }
1582
1583 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetRenderTargetsAndUnorderedAccessViews(
1584         ID3D11DeviceContext *iface,
1585         UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
1586         ID3D11DepthStencilView **depth_stencil_view,
1587         UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
1588         ID3D11UnorderedAccessView **unordered_access_views)
1589 {
1590     FIXME("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
1591             "unordered_access_view_start_slot %u, unordered_access_view_count %u, "
1592             "unordered_access_views %p stub!\n",
1593             iface, render_target_view_count, render_target_views, depth_stencil_view,
1594             unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views);
1595 }
1596
1597 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetBlendState(ID3D11DeviceContext *iface,
1598         ID3D11BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
1599 {
1600     FIXME("iface %p, blend_state %p, blend_factor %p, sample_mask %p stub!\n",
1601             iface, blend_state, blend_factor, sample_mask);
1602 }
1603
1604 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetDepthStencilState(ID3D11DeviceContext *iface,
1605         ID3D11DepthStencilState **depth_stencil_state, UINT *stencil_ref)
1606 {
1607     FIXME("iface %p, depth_stencil_state %p, stencil_ref %p stub!\n", iface, depth_stencil_state, stencil_ref);
1608 }
1609
1610 static void STDMETHODCALLTYPE d3d11_immediate_context_SOGetTargets(ID3D11DeviceContext *iface,
1611         UINT buffer_count, ID3D11Buffer **buffers)
1612 {
1613     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1614     unsigned int i;
1615
1616     TRACE("iface %p, buffer_count %u, buffers %p.\n", iface, buffer_count, buffers);
1617
1618     wined3d_mutex_lock();
1619     for (i = 0; i < buffer_count; ++i)
1620     {
1621         struct wined3d_buffer *wined3d_buffer;
1622         struct d3d_buffer *buffer_impl;
1623
1624         if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, NULL)))
1625         {
1626             buffers[i] = NULL;
1627             continue;
1628         }
1629
1630         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1631         buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1632         ID3D11Buffer_AddRef(buffers[i]);
1633     }
1634     wined3d_mutex_unlock();
1635 }
1636
1637 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetState(ID3D11DeviceContext *iface,
1638         ID3D11RasterizerState **rasterizer_state)
1639 {
1640     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1641
1642     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
1643
1644     if ((*rasterizer_state = device->rasterizer_state ? &device->rasterizer_state->ID3D11RasterizerState_iface : NULL))
1645         ID3D11RasterizerState_AddRef(*rasterizer_state);
1646 }
1647
1648 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetViewports(ID3D11DeviceContext *iface,
1649         UINT *viewport_count, D3D11_VIEWPORT *viewports)
1650 {
1651     struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1652     struct wined3d_viewport wined3d_vp;
1653
1654     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
1655
1656     if (!viewports)
1657     {
1658         *viewport_count = 1;
1659         return;
1660     }
1661
1662     if (!*viewport_count)
1663         return;
1664
1665     wined3d_mutex_lock();
1666     wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
1667     wined3d_mutex_unlock();
1668
1669     viewports[0].TopLeftX = wined3d_vp.x;
1670     viewports[0].TopLeftY = wined3d_vp.y;
1671     viewports[0].Width = wined3d_vp.width;
1672     viewports[0].Height = wined3d_vp.height;
1673     viewports[0].MinDepth = wined3d_vp.min_z;
1674     viewports[0].MaxDepth = wined3d_vp.max_z;
1675
1676     if (*viewport_count > 1)
1677         memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
1678 }
1679
1680 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetScissorRects(ID3D11DeviceContext *iface,
1681         UINT *rect_count, D3D11_RECT *rects)
1682 {
1683     FIXME("iface %p, rect_count %p, rects %p stub!\n", iface, rect_count, rects);
1684 }
1685
1686 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetShaderResources(ID3D11DeviceContext *iface,
1687         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1688 {
1689     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n", iface, start_slot, view_count, views);
1690 }
1691
1692 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetShader(ID3D11DeviceContext *iface,
1693         ID3D11HullShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1694 {
1695     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %p stub!\n",
1696             iface, shader, class_instances, class_instance_count);
1697 }
1698
1699 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetSamplers(ID3D11DeviceContext *iface,
1700         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1701 {
1702     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1703             iface, start_slot, sampler_count, samplers);
1704 }
1705
1706 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetConstantBuffers(ID3D11DeviceContext *iface,
1707         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1708 {
1709     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p stub!\n",
1710             iface, start_slot, buffer_count, buffers);
1711 }
1712
1713 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetShaderResources(ID3D11DeviceContext *iface,
1714         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1715 {
1716     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
1717             iface, start_slot, view_count, views);
1718 }
1719
1720 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetShader(ID3D11DeviceContext *iface,
1721         ID3D11DomainShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1722 {
1723     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %p stub!\n",
1724             iface, shader, class_instances, class_instance_count);
1725 }
1726
1727 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetSamplers(ID3D11DeviceContext *iface,
1728         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1729 {
1730     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1731             iface, start_slot, sampler_count, samplers);
1732 }
1733
1734 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetConstantBuffers(ID3D11DeviceContext *iface,
1735         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1736 {
1737     FIXME("iface %p, start_slot %u, buffer_count %u, buffers %p stub!\n",
1738             iface, start_slot, buffer_count, buffers);
1739 }
1740
1741 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetShaderResources(ID3D11DeviceContext *iface,
1742         UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1743 {
1744     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n", iface, start_slot, view_count, views);
1745 }
1746
1747 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetUnorderedAccessViews(ID3D11DeviceContext *iface,
1748         UINT start_slot, UINT view_count, ID3D11UnorderedAccessView **views)
1749 {
1750     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n", iface, start_slot, view_count, views);
1751 }
1752
1753 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetShader(ID3D11DeviceContext *iface,
1754         ID3D11ComputeShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1755 {
1756     FIXME("iface %p, shader %p, class_instances %p, class_instance_count %p stub!\n",
1757             iface, shader, class_instances, class_instance_count);
1758 }
1759
1760 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetSamplers(ID3D11DeviceContext *iface,
1761         UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1762 {
1763     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
1764             iface, start_slot, sampler_count, samplers);
1765 }
1766
1767 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetConstantBuffers(ID3D11DeviceContext *iface,
1768         UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1769 {
1770     FIXME("iface %p, start_slot %u, buffer_count %u, buffer %p stub!\n",
1771             iface, start_slot, buffer_count, buffers);
1772 }
1773
1774 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearState(ID3D11DeviceContext *iface)
1775 {
1776     FIXME("iface %p stub!\n", iface);
1777 }
1778
1779 static void STDMETHODCALLTYPE d3d11_immediate_context_Flush(ID3D11DeviceContext *iface)
1780 {
1781     FIXME("iface %p stub!\n", iface);
1782 }
1783
1784 static D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE d3d11_immediate_context_GetType(ID3D11DeviceContext *iface)
1785 {
1786     TRACE("iface %p.\n", iface);
1787
1788     return D3D11_DEVICE_CONTEXT_IMMEDIATE;
1789 }
1790
1791 static UINT STDMETHODCALLTYPE d3d11_immediate_context_GetContextFlags(ID3D11DeviceContext *iface)
1792 {
1793     FIXME("iface %p stub!\n", iface);
1794
1795     return 0;
1796 }
1797
1798 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_FinishCommandList(ID3D11DeviceContext *iface,
1799         BOOL restore, ID3D11CommandList **command_list)
1800 {
1801     FIXME("iface %p, restore %#x, command_list %p stub!\n", iface, restore, command_list);
1802
1803     return E_NOTIMPL;
1804 }
1805
1806 static const struct ID3D11DeviceContextVtbl d3d11_immediate_context_vtbl =
1807 {
1808     /* IUnknown methods */
1809     d3d11_immediate_context_QueryInterface,
1810     d3d11_immediate_context_AddRef,
1811     d3d11_immediate_context_Release,
1812     /* ID3D11DeviceChild methods */
1813     d3d11_immediate_context_GetDevice,
1814     d3d11_immediate_context_GetPrivateData,
1815     d3d11_immediate_context_SetPrivateData,
1816     d3d11_immediate_context_SetPrivateDataInterface,
1817     /* ID3D11DeviceContext methods */
1818     d3d11_immediate_context_VSSetConstantBuffers,
1819     d3d11_immediate_context_PSSetShaderResources,
1820     d3d11_immediate_context_PSSetShader,
1821     d3d11_immediate_context_PSSetSamplers,
1822     d3d11_immediate_context_VSSetShader,
1823     d3d11_immediate_context_DrawIndexed,
1824     d3d11_immediate_context_Draw,
1825     d3d11_immediate_context_Map,
1826     d3d11_immediate_context_Unmap,
1827     d3d11_immediate_context_PSSetConstantBuffers,
1828     d3d11_immediate_context_IASetInputLayout,
1829     d3d11_immediate_context_IASetVertexBuffers,
1830     d3d11_immediate_context_IASetIndexBuffer,
1831     d3d11_immediate_context_DrawIndexedInstanced,
1832     d3d11_immediate_context_DrawInstanced,
1833     d3d11_immediate_context_GSSetConstantBuffers,
1834     d3d11_immediate_context_GSSetShader,
1835     d3d11_immediate_context_IASetPrimitiveTopology,
1836     d3d11_immediate_context_VSSetShaderResources,
1837     d3d11_immediate_context_VSSetSamplers,
1838     d3d11_immediate_context_Begin,
1839     d3d11_immediate_context_End,
1840     d3d11_immediate_context_GetData,
1841     d3d11_immediate_context_SetPredication,
1842     d3d11_immediate_context_GSSetShaderResources,
1843     d3d11_immediate_context_GSSetSamplers,
1844     d3d11_immediate_context_OMSetRenderTargets,
1845     d3d11_immediate_context_OMSetRenderTargetsAndUnorderedAccessViews,
1846     d3d11_immediate_context_OMSetBlendState,
1847     d3d11_immediate_context_OMSetDepthStencilState,
1848     d3d11_immediate_context_SOSetTargets,
1849     d3d11_immediate_context_DrawAuto,
1850     d3d11_immediate_context_DrawIndexedInstancedIndirect,
1851     d3d11_immediate_context_DrawInstancedIndirect,
1852     d3d11_immediate_context_Dispatch,
1853     d3d11_immediate_context_DispatchIndirect,
1854     d3d11_immediate_context_RSSetState,
1855     d3d11_immediate_context_RSSetViewports,
1856     d3d11_immediate_context_RSSetScissorRects,
1857     d3d11_immediate_context_CopySubresourceRegion,
1858     d3d11_immediate_context_CopyResource,
1859     d3d11_immediate_context_UpdateSubresource,
1860     d3d11_immediate_context_CopyStructureCount,
1861     d3d11_immediate_context_ClearRenderTargetView,
1862     d3d11_immediate_context_ClearUnorderedAccessViewUint,
1863     d3d11_immediate_context_ClearUnorderedAccessViewFloat,
1864     d3d11_immediate_context_ClearDepthStencilView,
1865     d3d11_immediate_context_GenerateMips,
1866     d3d11_immediate_context_SetResourceMinLOD,
1867     d3d11_immediate_context_GetResourceMinLOD,
1868     d3d11_immediate_context_ResolveSubresource,
1869     d3d11_immediate_context_ExecuteCommandList,
1870     d3d11_immediate_context_HSSetShaderResources,
1871     d3d11_immediate_context_HSSetShader,
1872     d3d11_immediate_context_HSSetSamplers,
1873     d3d11_immediate_context_HSSetConstantBuffers,
1874     d3d11_immediate_context_DSSetShaderResources,
1875     d3d11_immediate_context_DSSetShader,
1876     d3d11_immediate_context_DSSetSamplers,
1877     d3d11_immediate_context_DSSetConstantBuffers,
1878     d3d11_immediate_context_CSSetShaderResources,
1879     d3d11_immediate_context_CSSetUnorderedAccessViews,
1880     d3d11_immediate_context_CSSetShader,
1881     d3d11_immediate_context_CSSetSamplers,
1882     d3d11_immediate_context_CSSetConstantBuffers,
1883     d3d11_immediate_context_VSGetConstantBuffers,
1884     d3d11_immediate_context_PSGetShaderResources,
1885     d3d11_immediate_context_PSGetShader,
1886     d3d11_immediate_context_PSGetSamplers,
1887     d3d11_immediate_context_VSGetShader,
1888     d3d11_immediate_context_PSGetConstantBuffers,
1889     d3d11_immediate_context_IAGetInputLayout,
1890     d3d11_immediate_context_IAGetVertexBuffers,
1891     d3d11_immediate_context_IAGetIndexBuffer,
1892     d3d11_immediate_context_GSGetConstantBuffers,
1893     d3d11_immediate_context_GSGetShader,
1894     d3d11_immediate_context_IAGetPrimitiveTopology,
1895     d3d11_immediate_context_VSGetShaderResources,
1896     d3d11_immediate_context_VSGetSamplers,
1897     d3d11_immediate_context_GetPredication,
1898     d3d11_immediate_context_GSGetShaderResources,
1899     d3d11_immediate_context_GSGetSamplers,
1900     d3d11_immediate_context_OMGetRenderTargets,
1901     d3d11_immediate_context_OMGetRenderTargetsAndUnorderedAccessViews,
1902     d3d11_immediate_context_OMGetBlendState,
1903     d3d11_immediate_context_OMGetDepthStencilState,
1904     d3d11_immediate_context_SOGetTargets,
1905     d3d11_immediate_context_RSGetState,
1906     d3d11_immediate_context_RSGetViewports,
1907     d3d11_immediate_context_RSGetScissorRects,
1908     d3d11_immediate_context_HSGetShaderResources,
1909     d3d11_immediate_context_HSGetShader,
1910     d3d11_immediate_context_HSGetSamplers,
1911     d3d11_immediate_context_HSGetConstantBuffers,
1912     d3d11_immediate_context_DSGetShaderResources,
1913     d3d11_immediate_context_DSGetShader,
1914     d3d11_immediate_context_DSGetSamplers,
1915     d3d11_immediate_context_DSGetConstantBuffers,
1916     d3d11_immediate_context_CSGetShaderResources,
1917     d3d11_immediate_context_CSGetUnorderedAccessViews,
1918     d3d11_immediate_context_CSGetShader,
1919     d3d11_immediate_context_CSGetSamplers,
1920     d3d11_immediate_context_CSGetConstantBuffers,
1921     d3d11_immediate_context_ClearState,
1922     d3d11_immediate_context_Flush,
1923     d3d11_immediate_context_GetType,
1924     d3d11_immediate_context_GetContextFlags,
1925     d3d11_immediate_context_FinishCommandList,
1926 };
1927
1928 static void d3d11_immediate_context_init(struct d3d11_immediate_context *context, struct d3d_device *device)
1929 {
1930     context->ID3D11DeviceContext_iface.lpVtbl = &d3d11_immediate_context_vtbl;
1931     context->refcount = 1;
1932
1933     ID3D11Device_AddRef(&device->ID3D11Device_iface);
1934
1935     wined3d_private_store_init(&context->private_store);
1936 }
1937
1938 static void d3d11_immediate_context_destroy(struct d3d11_immediate_context *context)
1939 {
1940     wined3d_private_store_cleanup(&context->private_store);
1941 }
1942
1943 /* ID3D11Device methods */
1944
1945 static HRESULT STDMETHODCALLTYPE d3d11_device_QueryInterface(ID3D11Device *iface, REFIID riid, void **out)
1946 {
1947     struct d3d_device *device = impl_from_ID3D11Device(iface);
1948     return IUnknown_QueryInterface(device->outer_unk, riid, out);
1949 }
1950
1951 static ULONG STDMETHODCALLTYPE d3d11_device_AddRef(ID3D11Device *iface)
1952 {
1953     struct d3d_device *device = impl_from_ID3D11Device(iface);
1954     return IUnknown_AddRef(device->outer_unk);
1955 }
1956
1957 static ULONG STDMETHODCALLTYPE d3d11_device_Release(ID3D11Device *iface)
1958 {
1959     struct d3d_device *device = impl_from_ID3D11Device(iface);
1960     return IUnknown_Release(device->outer_unk);
1961 }
1962
1963 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBuffer(ID3D11Device *iface, const D3D11_BUFFER_DESC *desc,
1964         const D3D11_SUBRESOURCE_DATA *data, ID3D11Buffer **buffer)
1965 {
1966     struct d3d_device *device = impl_from_ID3D11Device(iface);
1967     struct d3d_buffer *object;
1968     HRESULT hr;
1969
1970     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
1971
1972     if (FAILED(hr = d3d_buffer_create(device, desc, data, &object)))
1973         return hr;
1974
1975     *buffer = &object->ID3D11Buffer_iface;
1976
1977     return S_OK;
1978 }
1979
1980 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture1D(ID3D11Device *iface,
1981         const D3D11_TEXTURE1D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture1D **texture)
1982 {
1983     FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
1984
1985     return E_NOTIMPL;
1986 }
1987
1988 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture2D(ID3D11Device *iface,
1989         const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture2D **texture)
1990 {
1991     struct d3d_device *device = impl_from_ID3D11Device(iface);
1992     struct d3d_texture2d *object;
1993     HRESULT hr;
1994
1995     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
1996
1997     if (FAILED(hr = d3d_texture2d_create(device, desc, data, &object)))
1998         return hr;
1999
2000     *texture = &object->ID3D11Texture2D_iface;
2001
2002     return S_OK;
2003 }
2004
2005 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture3D(ID3D11Device *iface,
2006         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture3D **texture)
2007 {
2008     struct d3d_device *device = impl_from_ID3D11Device(iface);
2009     struct d3d_texture3d *object;
2010     HRESULT hr;
2011
2012     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
2013
2014     if (FAILED(hr = d3d_texture3d_create(device, desc, data, &object)))
2015         return hr;
2016
2017     *texture = &object->ID3D11Texture3D_iface;
2018
2019     return S_OK;
2020 }
2021
2022 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateShaderResourceView(ID3D11Device *iface,
2023         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11ShaderResourceView **view)
2024 {
2025     struct d3d_device *device = impl_from_ID3D11Device(iface);
2026     struct d3d_shader_resource_view *object;
2027     HRESULT hr;
2028
2029     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2030
2031     if (FAILED(hr = d3d_shader_resource_view_create(device, resource, desc, &object)))
2032         return hr;
2033
2034     *view = &object->ID3D11ShaderResourceView_iface;
2035
2036     return S_OK;
2037 }
2038
2039 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateUnorderedAccessView(ID3D11Device *iface,
2040         ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11UnorderedAccessView **view)
2041 {
2042     FIXME("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
2043
2044     return E_NOTIMPL;
2045 }
2046
2047 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRenderTargetView(ID3D11Device *iface,
2048         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11RenderTargetView **view)
2049 {
2050     struct d3d_device *device = impl_from_ID3D11Device(iface);
2051     struct d3d_rendertarget_view *object;
2052     HRESULT hr;
2053
2054     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2055
2056     if (FAILED(hr = d3d_rendertarget_view_create(device, resource, desc, &object)))
2057         return hr;
2058
2059     *view = &object->ID3D11RenderTargetView_iface;
2060
2061     return S_OK;
2062 }
2063
2064 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilView(ID3D11Device *iface,
2065         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11DepthStencilView **view)
2066 {
2067     struct d3d_device *device = impl_from_ID3D11Device(iface);
2068     struct d3d_depthstencil_view *object;
2069     HRESULT hr;
2070
2071     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2072
2073     if (FAILED(hr = d3d_depthstencil_view_create(device, resource, desc, &object)))
2074         return hr;
2075
2076     *view = &object->ID3D11DepthStencilView_iface;
2077
2078     return S_OK;
2079 }
2080
2081 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateInputLayout(ID3D11Device *iface,
2082         const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count, const void *shader_byte_code,
2083         SIZE_T shader_byte_code_length, ID3D11InputLayout **input_layout)
2084 {
2085     struct d3d_device *device = impl_from_ID3D11Device(iface);
2086     struct d3d_input_layout *object;
2087     HRESULT hr;
2088
2089     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, shader_byte_code_length %lu, "
2090             "input_layout %p.\n", iface, element_descs, element_count, shader_byte_code,
2091             shader_byte_code_length, input_layout);
2092
2093     if (FAILED(hr = d3d_input_layout_create(device, element_descs, element_count,
2094             shader_byte_code, shader_byte_code_length, &object)))
2095         return hr;
2096
2097     *input_layout = &object->ID3D11InputLayout_iface;
2098
2099     return S_OK;
2100 }
2101
2102 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateVertexShader(ID3D11Device *iface, const void *byte_code,
2103         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11VertexShader **shader)
2104 {
2105     struct d3d_device *device = impl_from_ID3D11Device(iface);
2106     struct d3d_vertex_shader *object;
2107     HRESULT hr;
2108
2109     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2110             iface, byte_code, byte_code_length, class_linkage, shader);
2111
2112     if (class_linkage)
2113         FIXME("Class linkage is not implemented yet.\n");
2114
2115     if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
2116         return hr;
2117
2118     *shader = &object->ID3D11VertexShader_iface;
2119
2120     return S_OK;
2121 }
2122
2123 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShader(ID3D11Device *iface, const void *byte_code,
2124         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
2125 {
2126     struct d3d_device *device = impl_from_ID3D11Device(iface);
2127     struct d3d_geometry_shader *object;
2128     HRESULT hr;
2129
2130     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2131             iface, byte_code, byte_code_length, class_linkage, shader);
2132
2133     if (class_linkage)
2134         FIXME("Class linkage is not implemented yet.\n");
2135
2136     if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length, &object)))
2137         return hr;
2138
2139     *shader = &object->ID3D11GeometryShader_iface;
2140
2141     return S_OK;
2142 }
2143
2144 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShaderWithStreamOutput(ID3D11Device *iface,
2145         const void *byte_code, SIZE_T byte_code_length, const D3D11_SO_DECLARATION_ENTRY *so_entries,
2146         UINT entry_count, const UINT *buffer_strides, UINT strides_count, UINT rasterized_stream,
2147         ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
2148 {
2149     FIXME("iface %p, byte_code %p, byte_code_length %lu, so_entries %p, entry_count %u, "
2150             "buffer_strides %p, strides_count %u, rasterized_stream %u, class_linkage %p, shader %p stub!\n",
2151             iface, byte_code, byte_code_length, so_entries, entry_count, buffer_strides, strides_count,
2152             rasterized_stream, class_linkage, shader);
2153
2154     return E_NOTIMPL;
2155 }
2156
2157 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePixelShader(ID3D11Device *iface, const void *byte_code,
2158         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11PixelShader **shader)
2159 {
2160     struct d3d_device *device = impl_from_ID3D11Device(iface);
2161     struct d3d_pixel_shader *object;
2162     HRESULT hr;
2163
2164     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2165             iface, byte_code, byte_code_length, class_linkage, shader);
2166
2167     if (class_linkage)
2168         FIXME("Class linkage is not implemented yet.\n");
2169
2170     if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
2171         return hr;
2172
2173     *shader = &object->ID3D11PixelShader_iface;
2174
2175     return S_OK;
2176 }
2177
2178 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateHullShader(ID3D11Device *iface, const void *byte_code,
2179         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11HullShader **shader)
2180 {
2181     struct d3d_device *device = impl_from_ID3D11Device(iface);
2182     struct d3d11_hull_shader *object;
2183     HRESULT hr;
2184
2185     TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2186             iface, byte_code, byte_code_length, class_linkage, shader);
2187
2188     if (class_linkage)
2189         FIXME("Class linkage is not implemented yet.\n");
2190
2191     if (FAILED(hr = d3d11_hull_shader_create(device, byte_code, byte_code_length, &object)))
2192         return hr;
2193
2194     *shader = &object->ID3D11HullShader_iface;
2195
2196     return S_OK;
2197 }
2198
2199 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDomainShader(ID3D11Device *iface, const void *byte_code,
2200         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11DomainShader **shader)
2201 {
2202     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
2203             iface, byte_code, byte_code_length, class_linkage, shader);
2204
2205     return E_NOTIMPL;
2206 }
2207
2208 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateComputeShader(ID3D11Device *iface, const void *byte_code,
2209         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11ComputeShader **shader)
2210 {
2211     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
2212             iface, byte_code, byte_code_length, class_linkage, shader);
2213
2214     return E_NOTIMPL;
2215 }
2216
2217 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateClassLinkage(ID3D11Device *iface,
2218         ID3D11ClassLinkage **class_linkage)
2219 {
2220     FIXME("iface %p, class_linkage %p stub!\n", iface, class_linkage);
2221
2222     return E_NOTIMPL;
2223 }
2224
2225 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBlendState(ID3D11Device *iface,
2226         const D3D11_BLEND_DESC *desc, ID3D11BlendState **blend_state)
2227 {
2228     struct d3d_device *device = impl_from_ID3D11Device(iface);
2229     struct d3d_blend_state *object;
2230     struct wine_rb_entry *entry;
2231     D3D11_BLEND_DESC tmp_desc;
2232     unsigned int i, j;
2233     HRESULT hr;
2234
2235     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
2236
2237     if (!desc)
2238         return E_INVALIDARG;
2239
2240     /* D3D11_RENDER_TARGET_BLEND_DESC has a hole, which is a problem because we use
2241      * D3D11_BLEND_DESC as a key in the rbtree. */
2242     memset(&tmp_desc, 0, sizeof(tmp_desc));
2243     tmp_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
2244     tmp_desc.IndependentBlendEnable = desc->IndependentBlendEnable;
2245     for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
2246     {
2247         j = desc->IndependentBlendEnable ? i : 0;
2248         tmp_desc.RenderTarget[i].BlendEnable = desc->RenderTarget[j].BlendEnable;
2249         tmp_desc.RenderTarget[i].SrcBlend = desc->RenderTarget[j].SrcBlend;
2250         tmp_desc.RenderTarget[i].DestBlend = desc->RenderTarget[j].DestBlend;
2251         tmp_desc.RenderTarget[i].BlendOp = desc->RenderTarget[j].BlendOp;
2252         tmp_desc.RenderTarget[i].SrcBlendAlpha = desc->RenderTarget[j].SrcBlendAlpha;
2253         tmp_desc.RenderTarget[i].DestBlendAlpha = desc->RenderTarget[j].DestBlendAlpha;
2254         tmp_desc.RenderTarget[i].BlendOpAlpha = desc->RenderTarget[j].BlendOpAlpha;
2255         tmp_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTarget[j].RenderTargetWriteMask;
2256     }
2257
2258     wined3d_mutex_lock();
2259     if ((entry = wine_rb_get(&device->blend_states, &tmp_desc)))
2260     {
2261         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_blend_state, entry);
2262
2263         TRACE("Returning existing blend state %p.\n", object);
2264         *blend_state = &object->ID3D11BlendState_iface;
2265         ID3D11BlendState_AddRef(*blend_state);
2266         wined3d_mutex_unlock();
2267
2268         return S_OK;
2269     }
2270     wined3d_mutex_unlock();
2271
2272     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2273         return E_OUTOFMEMORY;
2274
2275     if (FAILED(hr = d3d_blend_state_init(object, device, &tmp_desc)))
2276     {
2277         WARN("Failed to initialize blend state, hr %#x.\n", hr);
2278         HeapFree(GetProcessHeap(), 0, object);
2279         return hr;
2280     }
2281
2282     TRACE("Created blend state %p.\n", object);
2283     *blend_state = &object->ID3D11BlendState_iface;
2284
2285     return S_OK;
2286 }
2287
2288 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilState(ID3D11Device *iface,
2289         const D3D11_DEPTH_STENCIL_DESC *desc, ID3D11DepthStencilState **depth_stencil_state)
2290 {
2291     struct d3d_device *device = impl_from_ID3D11Device(iface);
2292     struct d3d_depthstencil_state *object;
2293     D3D11_DEPTH_STENCIL_DESC tmp_desc;
2294     struct wine_rb_entry *entry;
2295     HRESULT hr;
2296
2297     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
2298
2299     if (!desc)
2300         return E_INVALIDARG;
2301
2302     /* D3D11_DEPTH_STENCIL_DESC has a hole, which is a problem because we use
2303      * it as a key in the rbtree. */
2304     memset(&tmp_desc, 0, sizeof(tmp_desc));
2305     tmp_desc.DepthEnable = desc->DepthEnable;
2306     if (desc->DepthEnable)
2307     {
2308         tmp_desc.DepthWriteMask = desc->DepthWriteMask;
2309         tmp_desc.DepthFunc = desc->DepthFunc;
2310     }
2311     else
2312     {
2313         tmp_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
2314         tmp_desc.DepthFunc = D3D11_COMPARISON_LESS;
2315     }
2316     tmp_desc.StencilEnable = desc->StencilEnable;
2317     if (desc->StencilEnable)
2318     {
2319         tmp_desc.StencilReadMask = desc->StencilReadMask;
2320         tmp_desc.StencilWriteMask = desc->StencilWriteMask;
2321         tmp_desc.FrontFace = desc->FrontFace;
2322         tmp_desc.BackFace = desc->BackFace;
2323     }
2324     else
2325     {
2326         tmp_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
2327         tmp_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
2328         tmp_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
2329         tmp_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
2330         tmp_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
2331         tmp_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
2332         tmp_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
2333         tmp_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
2334         tmp_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
2335         tmp_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
2336     }
2337
2338     wined3d_mutex_lock();
2339     if ((entry = wine_rb_get(&device->depthstencil_states, &tmp_desc)))
2340     {
2341         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_depthstencil_state, entry);
2342
2343         TRACE("Returning existing depthstencil state %p.\n", object);
2344         *depth_stencil_state = &object->ID3D11DepthStencilState_iface;
2345         ID3D11DepthStencilState_AddRef(*depth_stencil_state);
2346         wined3d_mutex_unlock();
2347
2348         return S_OK;
2349     }
2350     wined3d_mutex_unlock();
2351
2352     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2353         return E_OUTOFMEMORY;
2354
2355     if (FAILED(hr = d3d_depthstencil_state_init(object, device, &tmp_desc)))
2356     {
2357         WARN("Failed to initialize depthstencil state, hr %#x.\n", hr);
2358         HeapFree(GetProcessHeap(), 0, object);
2359         return hr;
2360     }
2361
2362     TRACE("Created depthstencil state %p.\n", object);
2363     *depth_stencil_state = &object->ID3D11DepthStencilState_iface;
2364
2365     return S_OK;
2366 }
2367
2368 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device *iface,
2369         const D3D11_RASTERIZER_DESC *desc, ID3D11RasterizerState **rasterizer_state)
2370 {
2371     struct d3d_device *device = impl_from_ID3D11Device(iface);
2372     struct d3d_rasterizer_state *object;
2373     struct wine_rb_entry *entry;
2374     HRESULT hr;
2375
2376     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
2377
2378     if (!desc)
2379         return E_INVALIDARG;
2380
2381     wined3d_mutex_lock();
2382     if ((entry = wine_rb_get(&device->rasterizer_states, desc)))
2383     {
2384         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_rasterizer_state, entry);
2385
2386         TRACE("Returning existing rasterizer state %p.\n", object);
2387         *rasterizer_state = &object->ID3D11RasterizerState_iface;
2388         ID3D11RasterizerState_AddRef(*rasterizer_state);
2389         wined3d_mutex_unlock();
2390
2391         return S_OK;
2392     }
2393     wined3d_mutex_unlock();
2394
2395     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2396         return E_OUTOFMEMORY;
2397
2398     if (FAILED(hr = d3d_rasterizer_state_init(object, device, desc)))
2399     {
2400         WARN("Failed to initialize rasterizer state, hr %#x.\n", hr);
2401         HeapFree(GetProcessHeap(), 0, object);
2402         return hr;
2403     }
2404
2405     TRACE("Created rasterizer state %p.\n", object);
2406     *rasterizer_state = &object->ID3D11RasterizerState_iface;
2407
2408     return S_OK;
2409 }
2410
2411 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateSamplerState(ID3D11Device *iface,
2412         const D3D11_SAMPLER_DESC *desc, ID3D11SamplerState **sampler_state)
2413 {
2414     struct d3d_device *device = impl_from_ID3D11Device(iface);
2415     D3D11_SAMPLER_DESC normalized_desc;
2416     struct d3d_sampler_state *object;
2417     struct wine_rb_entry *entry;
2418     HRESULT hr;
2419
2420     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
2421
2422     if (!desc)
2423         return E_INVALIDARG;
2424
2425     normalized_desc = *desc;
2426     if (!D3D11_DECODE_IS_ANISOTROPIC_FILTER(normalized_desc.Filter))
2427         normalized_desc.MaxAnisotropy = 0;
2428     if (!D3D11_DECODE_IS_COMPARISON_FILTER(normalized_desc.Filter))
2429         normalized_desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
2430     if (normalized_desc.AddressU != D3D11_TEXTURE_ADDRESS_BORDER
2431             && normalized_desc.AddressV != D3D11_TEXTURE_ADDRESS_BORDER
2432             && normalized_desc.AddressW != D3D11_TEXTURE_ADDRESS_BORDER)
2433         memset(&normalized_desc.BorderColor, 0, sizeof(normalized_desc.BorderColor));
2434
2435     wined3d_mutex_lock();
2436     if ((entry = wine_rb_get(&device->sampler_states, &normalized_desc)))
2437     {
2438         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_sampler_state, entry);
2439
2440         TRACE("Returning existing sampler state %p.\n", object);
2441         *sampler_state = &object->ID3D11SamplerState_iface;
2442         ID3D11SamplerState_AddRef(*sampler_state);
2443         wined3d_mutex_unlock();
2444
2445         return S_OK;
2446     }
2447     wined3d_mutex_unlock();
2448
2449     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2450         return E_OUTOFMEMORY;
2451
2452     if (FAILED(hr = d3d_sampler_state_init(object, device, &normalized_desc)))
2453     {
2454         WARN("Failed to initialize sampler state, hr %#x.\n", hr);
2455         HeapFree(GetProcessHeap(), 0, object);
2456         return hr;
2457     }
2458
2459     TRACE("Created sampler state %p.\n", object);
2460     *sampler_state = &object->ID3D11SamplerState_iface;
2461
2462     return S_OK;
2463 }
2464
2465 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateQuery(ID3D11Device *iface,
2466         const D3D11_QUERY_DESC *desc, ID3D11Query **query)
2467 {
2468     struct d3d_device *device = impl_from_ID3D11Device(iface);
2469     struct d3d_query *object;
2470     HRESULT hr;
2471
2472     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
2473
2474     if (FAILED(hr = d3d_query_create(device, desc, FALSE, &object)))
2475         return hr;
2476
2477     *query = &object->ID3D11Query_iface;
2478
2479     return S_OK;
2480 }
2481
2482 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePredicate(ID3D11Device *iface, const D3D11_QUERY_DESC *desc,
2483         ID3D11Predicate **predicate)
2484 {
2485     struct d3d_device *device = impl_from_ID3D11Device(iface);
2486     struct d3d_query *object;
2487     HRESULT hr;
2488
2489     TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
2490
2491     if (FAILED(hr = d3d_query_create(device, desc, TRUE, &object)))
2492         return hr;
2493
2494     *predicate = (ID3D11Predicate *)&object->ID3D11Query_iface;
2495
2496     return S_OK;
2497 }
2498
2499 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
2500         ID3D11Counter **counter)
2501 {
2502     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
2503
2504     return E_NOTIMPL;
2505 }
2506
2507 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext(ID3D11Device *iface, UINT flags,
2508         ID3D11DeviceContext **context)
2509 {
2510     FIXME("iface %p, flags %#x, context %p stub!\n", iface, flags, context);
2511
2512     return E_NOTIMPL;
2513 }
2514
2515 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource(ID3D11Device *iface, HANDLE resource, REFIID riid,
2516         void **out)
2517 {
2518     FIXME("iface %p, resource %p, riid %s, out %p stub!\n", iface, resource, debugstr_guid(riid), out);
2519
2520     return E_NOTIMPL;
2521 }
2522
2523 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device *iface, DXGI_FORMAT format,
2524         UINT *format_support)
2525 {
2526     FIXME("iface %p, format %u, format_support %p stub!\n", iface, format, format_support);
2527
2528     return E_NOTIMPL;
2529 }
2530
2531 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckMultisampleQualityLevels(ID3D11Device *iface,
2532         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
2533 {
2534     struct d3d_device *device = impl_from_ID3D11Device(iface);
2535     struct wined3d_device_creation_parameters params;
2536     struct wined3d *wined3d;
2537     HRESULT hr;
2538
2539     TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
2540             iface, debug_dxgi_format(format), sample_count, quality_level_count);
2541
2542     if (!quality_level_count)
2543         return E_INVALIDARG;
2544
2545     *quality_level_count = 0;
2546
2547     if (!sample_count)
2548         return E_FAIL;
2549     if (sample_count == 1)
2550     {
2551         *quality_level_count = 1;
2552         return S_OK;
2553     }
2554     if (sample_count > D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT)
2555         return E_FAIL;
2556
2557     wined3d_mutex_lock();
2558     wined3d = wined3d_device_get_wined3d(device->wined3d_device);
2559     wined3d_device_get_creation_parameters(device->wined3d_device, &params);
2560     hr = wined3d_check_device_multisample_type(wined3d, params.adapter_idx, params.device_type,
2561             wined3dformat_from_dxgi_format(format), TRUE, sample_count, quality_level_count);
2562     wined3d_mutex_unlock();
2563
2564     if (hr == WINED3DERR_INVALIDCALL)
2565         return E_INVALIDARG;
2566     if (hr == WINED3DERR_NOTAVAILABLE)
2567         return S_OK;
2568     return hr;
2569 }
2570
2571 static void STDMETHODCALLTYPE d3d11_device_CheckCounterInfo(ID3D11Device *iface, D3D11_COUNTER_INFO *info)
2572 {
2573     FIXME("iface %p, info %p stub!\n", iface, info);
2574 }
2575
2576 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
2577         D3D11_COUNTER_TYPE *type, UINT *active_counter_count, char *name, UINT *name_length,
2578         char *units, UINT *units_length, char *description, UINT *description_length)
2579 {
2580     FIXME("iface %p, desc %p, type %p, active_counter_count %p, name %p, name_length %p, "
2581             "units %p, units_length %p, description %p, description_length %p stub!\n",
2582             iface, desc, type, active_counter_count, name, name_length,
2583             units, units_length, description, description_length);
2584
2585     return E_NOTIMPL;
2586 }
2587
2588 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFeatureSupport(ID3D11Device *iface, D3D11_FEATURE feature,
2589         void *feature_support_data, UINT feature_support_data_size)
2590 {
2591     FIXME("iface %p, feature %u, feature_support_data %p, feature_support_data_size %u stub!\n",
2592             iface, feature, feature_support_data, feature_support_data_size);
2593
2594     return E_NOTIMPL;
2595 }
2596
2597 static HRESULT STDMETHODCALLTYPE d3d11_device_GetPrivateData(ID3D11Device *iface, REFGUID guid,
2598         UINT *data_size, void *data)
2599 {
2600     IDXGIDevice *dxgi_device;
2601     HRESULT hr;
2602
2603     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2604
2605     if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
2606         return hr;
2607     hr = IDXGIDevice_GetPrivateData(dxgi_device, guid, data_size, data);
2608     IDXGIDevice_Release(dxgi_device);
2609
2610     return hr;
2611 }
2612
2613 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateData(ID3D11Device *iface, REFGUID guid,
2614         UINT data_size, const void *data)
2615 {
2616     IDXGIDevice *dxgi_device;
2617     HRESULT hr;
2618
2619     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2620
2621     if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
2622         return hr;
2623     hr = IDXGIDevice_SetPrivateData(dxgi_device, guid, data_size, data);
2624     IDXGIDevice_Release(dxgi_device);
2625
2626     return hr;
2627 }
2628
2629 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateDataInterface(ID3D11Device *iface, REFGUID guid,
2630         const IUnknown *data)
2631 {
2632     IDXGIDevice *dxgi_device;
2633     HRESULT hr;
2634
2635     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2636
2637     if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
2638         return hr;
2639     hr = IDXGIDevice_SetPrivateDataInterface(dxgi_device, guid, data);
2640     IDXGIDevice_Release(dxgi_device);
2641
2642     return hr;
2643 }
2644
2645 static D3D_FEATURE_LEVEL STDMETHODCALLTYPE d3d11_device_GetFeatureLevel(ID3D11Device *iface)
2646 {
2647     struct d3d_device *device = impl_from_ID3D11Device(iface);
2648
2649     TRACE("iface %p.\n", iface);
2650
2651     return device->feature_level;
2652 }
2653
2654 static UINT STDMETHODCALLTYPE d3d11_device_GetCreationFlags(ID3D11Device *iface)
2655 {
2656     FIXME("iface %p stub!\n", iface);
2657
2658     return 0;
2659 }
2660
2661 static HRESULT STDMETHODCALLTYPE d3d11_device_GetDeviceRemovedReason(ID3D11Device *iface)
2662 {
2663     FIXME("iface %p stub!\n", iface);
2664
2665     return S_OK;
2666 }
2667
2668 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext(ID3D11Device *iface,
2669         ID3D11DeviceContext **immediate_context)
2670 {
2671     struct d3d_device *device = impl_from_ID3D11Device(iface);
2672
2673     TRACE("iface %p, immediate_context %p.\n", iface, immediate_context);
2674
2675     *immediate_context = &device->immediate_context.ID3D11DeviceContext_iface;
2676     ID3D11DeviceContext_AddRef(*immediate_context);
2677 }
2678
2679 static HRESULT STDMETHODCALLTYPE d3d11_device_SetExceptionMode(ID3D11Device *iface, UINT flags)
2680 {
2681     FIXME("iface %p, flags %#x stub!\n", iface, flags);
2682
2683     return E_NOTIMPL;
2684 }
2685
2686 static UINT STDMETHODCALLTYPE d3d11_device_GetExceptionMode(ID3D11Device *iface)
2687 {
2688     FIXME("iface %p stub!\n", iface);
2689
2690     return 0;
2691 }
2692
2693 static const struct ID3D11DeviceVtbl d3d11_device_vtbl =
2694 {
2695     /* IUnknown methods */
2696     d3d11_device_QueryInterface,
2697     d3d11_device_AddRef,
2698     d3d11_device_Release,
2699     /* ID3D11Device methods */
2700     d3d11_device_CreateBuffer,
2701     d3d11_device_CreateTexture1D,
2702     d3d11_device_CreateTexture2D,
2703     d3d11_device_CreateTexture3D,
2704     d3d11_device_CreateShaderResourceView,
2705     d3d11_device_CreateUnorderedAccessView,
2706     d3d11_device_CreateRenderTargetView,
2707     d3d11_device_CreateDepthStencilView,
2708     d3d11_device_CreateInputLayout,
2709     d3d11_device_CreateVertexShader,
2710     d3d11_device_CreateGeometryShader,
2711     d3d11_device_CreateGeometryShaderWithStreamOutput,
2712     d3d11_device_CreatePixelShader,
2713     d3d11_device_CreateHullShader,
2714     d3d11_device_CreateDomainShader,
2715     d3d11_device_CreateComputeShader,
2716     d3d11_device_CreateClassLinkage,
2717     d3d11_device_CreateBlendState,
2718     d3d11_device_CreateDepthStencilState,
2719     d3d11_device_CreateRasterizerState,
2720     d3d11_device_CreateSamplerState,
2721     d3d11_device_CreateQuery,
2722     d3d11_device_CreatePredicate,
2723     d3d11_device_CreateCounter,
2724     d3d11_device_CreateDeferredContext,
2725     d3d11_device_OpenSharedResource,
2726     d3d11_device_CheckFormatSupport,
2727     d3d11_device_CheckMultisampleQualityLevels,
2728     d3d11_device_CheckCounterInfo,
2729     d3d11_device_CheckCounter,
2730     d3d11_device_CheckFeatureSupport,
2731     d3d11_device_GetPrivateData,
2732     d3d11_device_SetPrivateData,
2733     d3d11_device_SetPrivateDataInterface,
2734     d3d11_device_GetFeatureLevel,
2735     d3d11_device_GetCreationFlags,
2736     d3d11_device_GetDeviceRemovedReason,
2737     d3d11_device_GetImmediateContext,
2738     d3d11_device_SetExceptionMode,
2739     d3d11_device_GetExceptionMode,
2740 };
2741
2742 /* Inner IUnknown methods */
2743
2744 static inline struct d3d_device *impl_from_IUnknown(IUnknown *iface)
2745 {
2746     return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
2747 }
2748
2749 static HRESULT STDMETHODCALLTYPE d3d_device_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out)
2750 {
2751     struct d3d_device *device = impl_from_IUnknown(iface);
2752
2753     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
2754
2755     if (IsEqualGUID(riid, &IID_ID3D11Device)
2756             || IsEqualGUID(riid, &IID_IUnknown))
2757     {
2758         *out = &device->ID3D11Device_iface;
2759     }
2760     else if (IsEqualGUID(riid, &IID_ID3D10Device1)
2761             || IsEqualGUID(riid, &IID_ID3D10Device))
2762     {
2763         *out = &device->ID3D10Device1_iface;
2764     }
2765     else if (IsEqualGUID(riid, &IID_ID3D10Multithread))
2766     {
2767         *out = &device->ID3D10Multithread_iface;
2768     }
2769     else if (IsEqualGUID(riid, &IID_IWineDXGIDeviceParent))
2770     {
2771         *out = &device->IWineDXGIDeviceParent_iface;
2772     }
2773     else
2774     {
2775         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2776         *out = NULL;
2777         return E_NOINTERFACE;
2778     }
2779
2780     IUnknown_AddRef((IUnknown *)*out);
2781     return S_OK;
2782 }
2783
2784 static ULONG STDMETHODCALLTYPE d3d_device_inner_AddRef(IUnknown *iface)
2785 {
2786     struct d3d_device *device = impl_from_IUnknown(iface);
2787     ULONG refcount = InterlockedIncrement(&device->refcount);
2788
2789     TRACE("%p increasing refcount to %u.\n", device, refcount);
2790
2791     return refcount;
2792 }
2793
2794 static ULONG STDMETHODCALLTYPE d3d_device_inner_Release(IUnknown *iface)
2795 {
2796     struct d3d_device *device = impl_from_IUnknown(iface);
2797     ULONG refcount = InterlockedDecrement(&device->refcount);
2798
2799     TRACE("%p decreasing refcount to %u.\n", device, refcount);
2800
2801     if (!refcount)
2802     {
2803         d3d11_immediate_context_destroy(&device->immediate_context);
2804         if (device->wined3d_device)
2805         {
2806             wined3d_mutex_lock();
2807             wined3d_device_decref(device->wined3d_device);
2808             wined3d_mutex_unlock();
2809         }
2810         wine_rb_destroy(&device->sampler_states, NULL, NULL);
2811         wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
2812         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
2813         wine_rb_destroy(&device->blend_states, NULL, NULL);
2814     }
2815
2816     return refcount;
2817 }
2818
2819 /* IUnknown methods */
2820
2821 static HRESULT STDMETHODCALLTYPE d3d10_device_QueryInterface(ID3D10Device1 *iface, REFIID riid,
2822         void **ppv)
2823 {
2824     struct d3d_device *This = impl_from_ID3D10Device(iface);
2825     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
2826 }
2827
2828 static ULONG STDMETHODCALLTYPE d3d10_device_AddRef(ID3D10Device1 *iface)
2829 {
2830     struct d3d_device *This = impl_from_ID3D10Device(iface);
2831     return IUnknown_AddRef(This->outer_unk);
2832 }
2833
2834 static ULONG STDMETHODCALLTYPE d3d10_device_Release(ID3D10Device1 *iface)
2835 {
2836     struct d3d_device *This = impl_from_ID3D10Device(iface);
2837     return IUnknown_Release(This->outer_unk);
2838 }
2839
2840 /* ID3D10Device methods */
2841
2842 static void STDMETHODCALLTYPE d3d10_device_VSSetConstantBuffers(ID3D10Device1 *iface,
2843         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
2844 {
2845     struct d3d_device *device = impl_from_ID3D10Device(iface);
2846     unsigned int i;
2847
2848     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2849             iface, start_slot, buffer_count, buffers);
2850
2851     wined3d_mutex_lock();
2852     for (i = 0; i < buffer_count; ++i)
2853     {
2854         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
2855
2856         wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
2857                 buffer ? buffer->wined3d_buffer : NULL);
2858     }
2859     wined3d_mutex_unlock();
2860 }
2861
2862 static void STDMETHODCALLTYPE d3d10_device_PSSetShaderResources(ID3D10Device1 *iface,
2863         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
2864 {
2865     struct d3d_device *device = impl_from_ID3D10Device(iface);
2866     unsigned int i;
2867
2868     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
2869             iface, start_slot, view_count, views);
2870
2871     wined3d_mutex_lock();
2872     for (i = 0; i < view_count; ++i)
2873     {
2874         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
2875
2876         wined3d_device_set_ps_resource_view(device->wined3d_device, start_slot + i,
2877                 view ? view->wined3d_view : NULL);
2878     }
2879     wined3d_mutex_unlock();
2880 }
2881
2882 static void STDMETHODCALLTYPE d3d10_device_PSSetShader(ID3D10Device1 *iface,
2883         ID3D10PixelShader *shader)
2884 {
2885     struct d3d_device *This = impl_from_ID3D10Device(iface);
2886     struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D10PixelShader(shader);
2887
2888     TRACE("iface %p, shader %p\n", iface, shader);
2889
2890     wined3d_mutex_lock();
2891     wined3d_device_set_pixel_shader(This->wined3d_device, ps ? ps->wined3d_shader : NULL);
2892     wined3d_mutex_unlock();
2893 }
2894
2895 static void STDMETHODCALLTYPE d3d10_device_PSSetSamplers(ID3D10Device1 *iface,
2896         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
2897 {
2898     struct d3d_device *device = impl_from_ID3D10Device(iface);
2899     unsigned int i;
2900
2901     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2902             iface, start_slot, sampler_count, samplers);
2903
2904     wined3d_mutex_lock();
2905     for (i = 0; i < sampler_count; ++i)
2906     {
2907         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
2908
2909         wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
2910                 sampler ? sampler->wined3d_sampler : NULL);
2911     }
2912     wined3d_mutex_unlock();
2913 }
2914
2915 static void STDMETHODCALLTYPE d3d10_device_VSSetShader(ID3D10Device1 *iface,
2916         ID3D10VertexShader *shader)
2917 {
2918     struct d3d_device *This = impl_from_ID3D10Device(iface);
2919     struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D10VertexShader(shader);
2920
2921     TRACE("iface %p, shader %p\n", iface, shader);
2922
2923     wined3d_mutex_lock();
2924     wined3d_device_set_vertex_shader(This->wined3d_device, vs ? vs->wined3d_shader : NULL);
2925     wined3d_mutex_unlock();
2926 }
2927
2928 static void STDMETHODCALLTYPE d3d10_device_DrawIndexed(ID3D10Device1 *iface, UINT index_count,
2929         UINT start_index_location, INT base_vertex_location)
2930 {
2931     struct d3d_device *This = impl_from_ID3D10Device(iface);
2932
2933     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
2934             iface, index_count, start_index_location, base_vertex_location);
2935
2936     wined3d_mutex_lock();
2937     wined3d_device_set_base_vertex_index(This->wined3d_device, base_vertex_location);
2938     wined3d_device_draw_indexed_primitive(This->wined3d_device, start_index_location, index_count);
2939     wined3d_mutex_unlock();
2940 }
2941
2942 static void STDMETHODCALLTYPE d3d10_device_Draw(ID3D10Device1 *iface, UINT vertex_count,
2943         UINT start_vertex_location)
2944 {
2945     struct d3d_device *This = impl_from_ID3D10Device(iface);
2946
2947     TRACE("iface %p, vertex_count %u, start_vertex_location %u\n",
2948             iface, vertex_count, start_vertex_location);
2949
2950     wined3d_mutex_lock();
2951     wined3d_device_draw_primitive(This->wined3d_device, start_vertex_location, vertex_count);
2952     wined3d_mutex_unlock();
2953 }
2954
2955 static void STDMETHODCALLTYPE d3d10_device_PSSetConstantBuffers(ID3D10Device1 *iface,
2956         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
2957 {
2958     struct d3d_device *device = impl_from_ID3D10Device(iface);
2959     unsigned int i;
2960
2961     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2962             iface, start_slot, buffer_count, buffers);
2963
2964     wined3d_mutex_lock();
2965     for (i = 0; i < buffer_count; ++i)
2966     {
2967         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
2968
2969         wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
2970                 buffer ? buffer->wined3d_buffer : NULL);
2971     }
2972     wined3d_mutex_unlock();
2973 }
2974
2975 static void STDMETHODCALLTYPE d3d10_device_IASetInputLayout(ID3D10Device1 *iface,
2976         ID3D10InputLayout *input_layout)
2977 {
2978     struct d3d_device *This = impl_from_ID3D10Device(iface);
2979     struct d3d_input_layout *layout = unsafe_impl_from_ID3D10InputLayout(input_layout);
2980
2981     TRACE("iface %p, input_layout %p\n", iface, input_layout);
2982
2983     wined3d_mutex_lock();
2984     wined3d_device_set_vertex_declaration(This->wined3d_device,
2985             layout ? layout->wined3d_decl : NULL);
2986     wined3d_mutex_unlock();
2987 }
2988
2989 static void STDMETHODCALLTYPE d3d10_device_IASetVertexBuffers(ID3D10Device1 *iface, UINT start_slot,
2990         UINT buffer_count, ID3D10Buffer *const *buffers, const UINT *strides, const UINT *offsets)
2991 {
2992     struct d3d_device *This = impl_from_ID3D10Device(iface);
2993     unsigned int i;
2994
2995     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p\n",
2996             iface, start_slot, buffer_count, buffers, strides, offsets);
2997
2998     wined3d_mutex_lock();
2999     for (i = 0; i < buffer_count; ++i)
3000     {
3001         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3002
3003         wined3d_device_set_stream_source(This->wined3d_device, start_slot + i,
3004                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
3005     }
3006     wined3d_mutex_unlock();
3007 }
3008
3009 static void STDMETHODCALLTYPE d3d10_device_IASetIndexBuffer(ID3D10Device1 *iface,
3010         ID3D10Buffer *buffer, DXGI_FORMAT format, UINT offset)
3011 {
3012     struct d3d_device *This = impl_from_ID3D10Device(iface);
3013     struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D10Buffer(buffer);
3014
3015     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
3016             iface, buffer, debug_dxgi_format(format), offset);
3017
3018     wined3d_mutex_lock();
3019     wined3d_device_set_index_buffer(This->wined3d_device,
3020             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
3021             wined3dformat_from_dxgi_format(format));
3022     wined3d_mutex_unlock();
3023     if (offset) FIXME("offset %u not supported.\n", offset);
3024 }
3025
3026 static void STDMETHODCALLTYPE d3d10_device_DrawIndexedInstanced(ID3D10Device1 *iface,
3027         UINT instance_index_count, UINT instance_count, UINT start_index_location,
3028         INT base_vertex_location, UINT start_instance_location)
3029 {
3030     struct d3d_device *device = impl_from_ID3D10Device(iface);
3031
3032     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
3033             "base_vertex_location %d, start_instance_location %u.\n",
3034             iface, instance_index_count, instance_count, start_index_location,
3035             base_vertex_location, start_instance_location);
3036
3037     wined3d_mutex_lock();
3038     wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
3039     wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
3040             instance_index_count, start_instance_location, instance_count);
3041     wined3d_mutex_unlock();
3042 }
3043
3044 static void STDMETHODCALLTYPE d3d10_device_DrawInstanced(ID3D10Device1 *iface,
3045         UINT instance_vertex_count, UINT instance_count,
3046         UINT start_vertex_location, UINT start_instance_location)
3047 {
3048     struct d3d_device *device = impl_from_ID3D10Device(iface);
3049
3050     TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
3051             "start_instance_location %u.\n", iface, instance_vertex_count, instance_count,
3052             start_vertex_location, start_instance_location);
3053
3054     wined3d_mutex_lock();
3055     wined3d_device_draw_primitive_instanced(device->wined3d_device, start_vertex_location,
3056             instance_vertex_count, start_instance_location, instance_count);
3057     wined3d_mutex_unlock();
3058 }
3059
3060 static void STDMETHODCALLTYPE d3d10_device_GSSetConstantBuffers(ID3D10Device1 *iface,
3061         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
3062 {
3063     struct d3d_device *device = impl_from_ID3D10Device(iface);
3064     unsigned int i;
3065
3066     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3067             iface, start_slot, buffer_count, buffers);
3068
3069     wined3d_mutex_lock();
3070     for (i = 0; i < buffer_count; ++i)
3071     {
3072         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3073
3074         wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
3075                 buffer ? buffer->wined3d_buffer : NULL);
3076     }
3077     wined3d_mutex_unlock();
3078 }
3079
3080 static void STDMETHODCALLTYPE d3d10_device_GSSetShader(ID3D10Device1 *iface, ID3D10GeometryShader *shader)
3081 {
3082     struct d3d_device *device = impl_from_ID3D10Device(iface);
3083     struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D10GeometryShader(shader);
3084
3085     TRACE("iface %p, shader %p.\n", iface, shader);
3086
3087     wined3d_mutex_lock();
3088     wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
3089     wined3d_mutex_unlock();
3090 }
3091
3092 static void STDMETHODCALLTYPE d3d10_device_IASetPrimitiveTopology(ID3D10Device1 *iface,
3093         D3D10_PRIMITIVE_TOPOLOGY topology)
3094 {
3095     struct d3d_device *This = impl_from_ID3D10Device(iface);
3096
3097     TRACE("iface %p, topology %s\n", iface, debug_d3d10_primitive_topology(topology));
3098
3099     wined3d_mutex_lock();
3100     wined3d_device_set_primitive_type(This->wined3d_device, (enum wined3d_primitive_type)topology);
3101     wined3d_mutex_unlock();
3102 }
3103
3104 static void STDMETHODCALLTYPE d3d10_device_VSSetShaderResources(ID3D10Device1 *iface,
3105         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
3106 {
3107     struct d3d_device *device = impl_from_ID3D10Device(iface);
3108     unsigned int i;
3109
3110     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3111             iface, start_slot, view_count, views);
3112
3113     wined3d_mutex_lock();
3114     for (i = 0; i < view_count; ++i)
3115     {
3116         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
3117
3118         wined3d_device_set_vs_resource_view(device->wined3d_device, start_slot + i,
3119                 view ? view->wined3d_view : NULL);
3120     }
3121     wined3d_mutex_unlock();
3122 }
3123
3124 static void STDMETHODCALLTYPE d3d10_device_VSSetSamplers(ID3D10Device1 *iface,
3125         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
3126 {
3127     struct d3d_device *device = impl_from_ID3D10Device(iface);
3128     unsigned int i;
3129
3130     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3131             iface, start_slot, sampler_count, samplers);
3132
3133     wined3d_mutex_lock();
3134     for (i = 0; i < sampler_count; ++i)
3135     {
3136         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
3137
3138         wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
3139                 sampler ? sampler->wined3d_sampler : NULL);
3140     }
3141     wined3d_mutex_unlock();
3142 }
3143
3144 static void STDMETHODCALLTYPE d3d10_device_SetPredication(ID3D10Device1 *iface, ID3D10Predicate *predicate, BOOL value)
3145 {
3146     struct d3d_device *device = impl_from_ID3D10Device(iface);
3147     struct d3d_query *query;
3148
3149     TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
3150
3151     query = unsafe_impl_from_ID3D10Query((ID3D10Query *)predicate);
3152     wined3d_mutex_lock();
3153     wined3d_device_set_predication(device->wined3d_device, query ? query->wined3d_query : NULL, value);
3154     wined3d_mutex_unlock();
3155 }
3156
3157 static void STDMETHODCALLTYPE d3d10_device_GSSetShaderResources(ID3D10Device1 *iface,
3158         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
3159 {
3160     struct d3d_device *device = impl_from_ID3D10Device(iface);
3161     unsigned int i;
3162
3163     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3164             iface, start_slot, view_count, views);
3165
3166     wined3d_mutex_lock();
3167     for (i = 0; i < view_count; ++i)
3168     {
3169         struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
3170
3171         wined3d_device_set_gs_resource_view(device->wined3d_device, start_slot + i,
3172                 view ? view->wined3d_view : NULL);
3173     }
3174     wined3d_mutex_unlock();
3175 }
3176
3177 static void STDMETHODCALLTYPE d3d10_device_GSSetSamplers(ID3D10Device1 *iface,
3178         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
3179 {
3180     struct d3d_device *device = impl_from_ID3D10Device(iface);
3181     unsigned int i;
3182
3183     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3184             iface, start_slot, sampler_count, samplers);
3185
3186     wined3d_mutex_lock();
3187     for (i = 0; i < sampler_count; ++i)
3188     {
3189         struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
3190
3191         wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
3192                 sampler ? sampler->wined3d_sampler : NULL);
3193     }
3194     wined3d_mutex_unlock();
3195 }
3196
3197 static void STDMETHODCALLTYPE d3d10_device_OMSetRenderTargets(ID3D10Device1 *iface,
3198         UINT render_target_view_count, ID3D10RenderTargetView *const *render_target_views,
3199         ID3D10DepthStencilView *depth_stencil_view)
3200 {
3201     struct d3d_device *device = impl_from_ID3D10Device(iface);
3202     struct d3d_depthstencil_view *dsv;
3203     unsigned int i;
3204
3205     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
3206             iface, render_target_view_count, render_target_views, depth_stencil_view);
3207
3208     wined3d_mutex_lock();
3209     for (i = 0; i < render_target_view_count; ++i)
3210     {
3211         struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D10RenderTargetView(render_target_views[i]);
3212
3213         wined3d_device_set_rendertarget_view(device->wined3d_device, i,
3214                 rtv ? rtv->wined3d_view : NULL, FALSE);
3215     }
3216     for (; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
3217     {
3218         wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
3219     }
3220
3221     dsv = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
3222     wined3d_device_set_depth_stencil_view(device->wined3d_device,
3223             dsv ? dsv->wined3d_view : NULL);
3224     wined3d_mutex_unlock();
3225 }
3226
3227 static void STDMETHODCALLTYPE d3d10_device_OMSetBlendState(ID3D10Device1 *iface,
3228         ID3D10BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
3229 {
3230     struct d3d_device *device = impl_from_ID3D10Device(iface);
3231     struct d3d_blend_state *blend_state_object;
3232
3233     TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
3234             iface, blend_state, debug_float4(blend_factor), sample_mask);
3235
3236     blend_state_object = unsafe_impl_from_ID3D10BlendState(blend_state);
3237     d3d11_immediate_context_OMSetBlendState(&device->immediate_context.ID3D11DeviceContext_iface,
3238             blend_state_object ? &blend_state_object->ID3D11BlendState_iface : NULL, blend_factor, sample_mask);
3239 }
3240
3241 static void STDMETHODCALLTYPE d3d10_device_OMSetDepthStencilState(ID3D10Device1 *iface,
3242         ID3D10DepthStencilState *depth_stencil_state, UINT stencil_ref)
3243 {
3244     struct d3d_device *device = impl_from_ID3D10Device(iface);
3245     struct d3d_depthstencil_state *ds_state_object;
3246
3247     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
3248             iface, depth_stencil_state, stencil_ref);
3249
3250     ds_state_object = unsafe_impl_from_ID3D10DepthStencilState(depth_stencil_state);
3251     d3d11_immediate_context_OMSetDepthStencilState(&device->immediate_context.ID3D11DeviceContext_iface,
3252             ds_state_object ? &ds_state_object->ID3D11DepthStencilState_iface : NULL, stencil_ref);
3253 }
3254
3255 static void STDMETHODCALLTYPE d3d10_device_SOSetTargets(ID3D10Device1 *iface,
3256         UINT target_count, ID3D10Buffer *const *targets, const UINT *offsets)
3257 {
3258     struct d3d_device *device = impl_from_ID3D10Device(iface);
3259     unsigned int count, i;
3260
3261     TRACE("iface %p, target_count %u, targets %p, offsets %p.\n", iface, target_count, targets, offsets);
3262
3263     count = min(target_count, 4);
3264     wined3d_mutex_lock();
3265     for (i = 0; i < count; ++i)
3266     {
3267         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(targets[i]);
3268
3269         wined3d_device_set_stream_output(device->wined3d_device, i,
3270                 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
3271     }
3272
3273     for (i = count; i < 4; ++i)
3274     {
3275         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
3276     }
3277     wined3d_mutex_unlock();
3278 }
3279
3280 static void STDMETHODCALLTYPE d3d10_device_DrawAuto(ID3D10Device1 *iface)
3281 {
3282     FIXME("iface %p stub!\n", iface);
3283 }
3284
3285 static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device1 *iface, ID3D10RasterizerState *rasterizer_state)
3286 {
3287     struct d3d_device *device = impl_from_ID3D10Device(iface);
3288     struct d3d_rasterizer_state *rasterizer_state_object;
3289
3290     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
3291
3292     rasterizer_state_object = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state);
3293     d3d11_immediate_context_RSSetState(&device->immediate_context.ID3D11DeviceContext_iface,
3294             rasterizer_state_object ? &rasterizer_state_object->ID3D11RasterizerState_iface : NULL);
3295 }
3296
3297 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device1 *iface,
3298         UINT viewport_count, const D3D10_VIEWPORT *viewports)
3299 {
3300     struct d3d_device *device = impl_from_ID3D10Device(iface);
3301     struct wined3d_viewport wined3d_vp;
3302
3303     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
3304
3305     if (viewport_count > 1)
3306         FIXME("Multiple viewports not implemented.\n");
3307
3308     if (!viewport_count)
3309         return;
3310
3311     wined3d_vp.x = viewports[0].TopLeftX;
3312     wined3d_vp.y = viewports[0].TopLeftY;
3313     wined3d_vp.width = viewports[0].Width;
3314     wined3d_vp.height = viewports[0].Height;
3315     wined3d_vp.min_z = viewports[0].MinDepth;
3316     wined3d_vp.max_z = viewports[0].MaxDepth;
3317
3318     wined3d_mutex_lock();
3319     wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
3320     wined3d_mutex_unlock();
3321 }
3322
3323 static void STDMETHODCALLTYPE d3d10_device_RSSetScissorRects(ID3D10Device1 *iface,
3324         UINT rect_count, const D3D10_RECT *rects)
3325 {
3326     struct d3d_device *device = impl_from_ID3D10Device(iface);
3327
3328     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
3329
3330     if (rect_count > 1)
3331         FIXME("Multiple scissor rects not implemented.\n");
3332
3333     if (!rect_count)
3334         return;
3335
3336     wined3d_mutex_lock();
3337     wined3d_device_set_scissor_rect(device->wined3d_device, rects);
3338     wined3d_mutex_unlock();
3339 }
3340
3341 static void STDMETHODCALLTYPE d3d10_device_CopySubresourceRegion(ID3D10Device1 *iface,
3342         ID3D10Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
3343         ID3D10Resource *src_resource, UINT src_subresource_idx, const D3D10_BOX *src_box)
3344 {
3345     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
3346     struct d3d_device *device = impl_from_ID3D10Device(iface);
3347     struct wined3d_box wined3d_src_box;
3348
3349     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
3350             "src_resource %p, src_subresource_idx %u, src_box %p.\n",
3351             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
3352             src_resource, src_subresource_idx, src_box);
3353
3354     if (src_box)
3355     {
3356         wined3d_src_box.left = src_box->left;
3357         wined3d_src_box.top = src_box->top;
3358         wined3d_src_box.front = src_box->front;
3359         wined3d_src_box.right = src_box->right;
3360         wined3d_src_box.bottom = src_box->bottom;
3361         wined3d_src_box.back = src_box->back;
3362     }
3363
3364     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
3365     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
3366     wined3d_mutex_lock();
3367     wined3d_device_copy_sub_resource_region(device->wined3d_device, wined3d_dst_resource, dst_subresource_idx,
3368             dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL);
3369     wined3d_mutex_unlock();
3370 }
3371
3372 static void STDMETHODCALLTYPE d3d10_device_CopyResource(ID3D10Device1 *iface,
3373         ID3D10Resource *dst_resource, ID3D10Resource *src_resource)
3374 {
3375     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
3376     struct d3d_device *device = impl_from_ID3D10Device(iface);
3377
3378     TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
3379
3380     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
3381     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
3382     wined3d_mutex_lock();
3383     wined3d_device_copy_resource(device->wined3d_device, wined3d_dst_resource, wined3d_src_resource);
3384     wined3d_mutex_unlock();
3385 }
3386
3387 static void STDMETHODCALLTYPE d3d10_device_UpdateSubresource(ID3D10Device1 *iface,
3388         ID3D10Resource *resource, UINT subresource_idx, const D3D10_BOX *box,
3389         const void *data, UINT row_pitch, UINT depth_pitch)
3390 {
3391     struct d3d_device *device = impl_from_ID3D10Device(iface);
3392     ID3D11Resource *d3d11_resource;
3393
3394     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
3395             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
3396
3397     ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource);
3398     d3d11_immediate_context_UpdateSubresource(&device->immediate_context.ID3D11DeviceContext_iface,
3399             d3d11_resource, subresource_idx, (const D3D11_BOX *)box, data, row_pitch, depth_pitch);
3400     ID3D11Resource_Release(d3d11_resource);
3401 }
3402
3403 static void STDMETHODCALLTYPE d3d10_device_ClearRenderTargetView(ID3D10Device1 *iface,
3404         ID3D10RenderTargetView *render_target_view, const float color_rgba[4])
3405 {
3406     struct d3d_device *device = impl_from_ID3D10Device(iface);
3407     struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D10RenderTargetView(render_target_view);
3408     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
3409     HRESULT hr;
3410
3411     TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
3412             iface, render_target_view, debug_float4(color_rgba));
3413
3414     wined3d_mutex_lock();
3415     if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
3416             WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
3417         ERR("Failed to clear view, hr %#x.\n", hr);
3418     wined3d_mutex_unlock();
3419 }
3420
3421 static void STDMETHODCALLTYPE d3d10_device_ClearDepthStencilView(ID3D10Device1 *iface,
3422         ID3D10DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
3423 {
3424     struct d3d_device *device = impl_from_ID3D10Device(iface);
3425     struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
3426     DWORD wined3d_flags;
3427     HRESULT hr;
3428
3429     TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
3430             iface, depth_stencil_view, flags, depth, stencil);
3431
3432     wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
3433
3434     wined3d_mutex_lock();
3435     if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
3436             wined3d_flags, NULL, depth, stencil)))
3437         ERR("Failed to clear view, hr %#x.\n", hr);
3438     wined3d_mutex_unlock();
3439 }
3440
3441 static void STDMETHODCALLTYPE d3d10_device_GenerateMips(ID3D10Device1 *iface,
3442         ID3D10ShaderResourceView *shader_resource_view)
3443 {
3444     FIXME("iface %p, shader_resource_view %p stub!\n", iface, shader_resource_view);
3445 }
3446
3447 static void STDMETHODCALLTYPE d3d10_device_ResolveSubresource(ID3D10Device1 *iface,
3448         ID3D10Resource *dst_resource, UINT dst_subresource_idx,
3449         ID3D10Resource *src_resource, UINT src_subresource_idx, DXGI_FORMAT format)
3450 {
3451     FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, "
3452             "src_resource %p, src_subresource_idx %u, format %s stub!\n",
3453             iface, dst_resource, dst_subresource_idx,
3454             src_resource, src_subresource_idx, debug_dxgi_format(format));
3455 }
3456
3457 static void STDMETHODCALLTYPE d3d10_device_VSGetConstantBuffers(ID3D10Device1 *iface,
3458         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
3459 {
3460     struct d3d_device *device = impl_from_ID3D10Device(iface);
3461     unsigned int i;
3462
3463     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3464             iface, start_slot, buffer_count, buffers);
3465
3466     wined3d_mutex_lock();
3467     for (i = 0; i < buffer_count; ++i)
3468     {
3469         struct wined3d_buffer *wined3d_buffer;
3470         struct d3d_buffer *buffer_impl;
3471
3472         if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
3473         {
3474             buffers[i] = NULL;
3475             continue;
3476         }
3477
3478         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3479         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
3480         ID3D10Buffer_AddRef(buffers[i]);
3481     }
3482     wined3d_mutex_unlock();
3483 }
3484
3485 static void STDMETHODCALLTYPE d3d10_device_PSGetShaderResources(ID3D10Device1 *iface,
3486         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
3487 {
3488     struct d3d_device *device = impl_from_ID3D10Device(iface);
3489     unsigned int i;
3490
3491     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3492             iface, start_slot, view_count, views);
3493
3494     wined3d_mutex_lock();
3495     for (i = 0; i < view_count; ++i)
3496     {
3497         struct wined3d_shader_resource_view *wined3d_view;
3498         struct d3d_shader_resource_view *view_impl;
3499
3500         if (!(wined3d_view = wined3d_device_get_ps_resource_view(device->wined3d_device, start_slot + i)))
3501         {
3502             views[i] = NULL;
3503             continue;
3504         }
3505
3506         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
3507         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
3508         ID3D10ShaderResourceView_AddRef(views[i]);
3509     }
3510     wined3d_mutex_unlock();
3511 }
3512
3513 static void STDMETHODCALLTYPE d3d10_device_PSGetShader(ID3D10Device1 *iface, ID3D10PixelShader **shader)
3514 {
3515     struct d3d_device *device = impl_from_ID3D10Device(iface);
3516     struct d3d_pixel_shader *shader_impl;
3517     struct wined3d_shader *wined3d_shader;
3518
3519     TRACE("iface %p, shader %p.\n", iface, shader);
3520
3521     wined3d_mutex_lock();
3522     if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
3523     {
3524         wined3d_mutex_unlock();
3525         *shader = NULL;
3526         return;
3527     }
3528
3529     shader_impl = wined3d_shader_get_parent(wined3d_shader);
3530     wined3d_mutex_unlock();
3531     *shader = &shader_impl->ID3D10PixelShader_iface;
3532     ID3D10PixelShader_AddRef(*shader);
3533 }
3534
3535 static void STDMETHODCALLTYPE d3d10_device_PSGetSamplers(ID3D10Device1 *iface,
3536         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
3537 {
3538     struct d3d_device *device = impl_from_ID3D10Device(iface);
3539     unsigned int i;
3540
3541     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3542             iface, start_slot, sampler_count, samplers);
3543
3544     wined3d_mutex_lock();
3545     for (i = 0; i < sampler_count; ++i)
3546     {
3547         struct d3d_sampler_state *sampler_impl;
3548         struct wined3d_sampler *wined3d_sampler;
3549
3550         if (!(wined3d_sampler = wined3d_device_get_ps_sampler(device->wined3d_device, start_slot + i)))
3551         {
3552             samplers[i] = NULL;
3553             continue;
3554         }
3555
3556         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
3557         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
3558         ID3D10SamplerState_AddRef(samplers[i]);
3559     }
3560     wined3d_mutex_unlock();
3561 }
3562
3563 static void STDMETHODCALLTYPE d3d10_device_VSGetShader(ID3D10Device1 *iface, ID3D10VertexShader **shader)
3564 {
3565     struct d3d_device *device = impl_from_ID3D10Device(iface);
3566     struct d3d_vertex_shader *shader_impl;
3567     struct wined3d_shader *wined3d_shader;
3568
3569     TRACE("iface %p, shader %p.\n", iface, shader);
3570
3571     wined3d_mutex_lock();
3572     if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
3573     {
3574         wined3d_mutex_unlock();
3575         *shader = NULL;
3576         return;
3577     }
3578
3579     shader_impl = wined3d_shader_get_parent(wined3d_shader);
3580     wined3d_mutex_unlock();
3581     *shader = &shader_impl->ID3D10VertexShader_iface;
3582     ID3D10VertexShader_AddRef(*shader);
3583 }
3584
3585 static void STDMETHODCALLTYPE d3d10_device_PSGetConstantBuffers(ID3D10Device1 *iface,
3586         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
3587 {
3588     struct d3d_device *device = impl_from_ID3D10Device(iface);
3589     unsigned int i;
3590
3591     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3592             iface, start_slot, buffer_count, buffers);
3593
3594     wined3d_mutex_lock();
3595     for (i = 0; i < buffer_count; ++i)
3596     {
3597         struct wined3d_buffer *wined3d_buffer;
3598         struct d3d_buffer *buffer_impl;
3599
3600         if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
3601         {
3602             buffers[i] = NULL;
3603             continue;
3604         }
3605
3606         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3607         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
3608         ID3D10Buffer_AddRef(buffers[i]);
3609     }
3610     wined3d_mutex_unlock();
3611 }
3612
3613 static void STDMETHODCALLTYPE d3d10_device_IAGetInputLayout(ID3D10Device1 *iface, ID3D10InputLayout **input_layout)
3614 {
3615     struct d3d_device *device = impl_from_ID3D10Device(iface);
3616     struct wined3d_vertex_declaration *wined3d_declaration;
3617     struct d3d_input_layout *input_layout_impl;
3618
3619     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
3620
3621     wined3d_mutex_lock();
3622     if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
3623     {
3624         wined3d_mutex_unlock();
3625         *input_layout = NULL;
3626         return;
3627     }
3628
3629     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
3630     wined3d_mutex_unlock();
3631     *input_layout = &input_layout_impl->ID3D10InputLayout_iface;
3632     ID3D10InputLayout_AddRef(*input_layout);
3633 }
3634
3635 static void STDMETHODCALLTYPE d3d10_device_IAGetVertexBuffers(ID3D10Device1 *iface,
3636         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers, UINT *strides, UINT *offsets)
3637 {
3638     struct d3d_device *device = impl_from_ID3D10Device(iface);
3639     unsigned int i;
3640
3641     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
3642             iface, start_slot, buffer_count, buffers, strides, offsets);
3643
3644     wined3d_mutex_lock();
3645     for (i = 0; i < buffer_count; ++i)
3646     {
3647         struct wined3d_buffer *wined3d_buffer;
3648         struct d3d_buffer *buffer_impl;
3649
3650         if (FAILED(wined3d_device_get_stream_source(device->wined3d_device, start_slot + i,
3651                 &wined3d_buffer, &offsets[i], &strides[i])))
3652             ERR("Failed to get vertex buffer.\n");
3653
3654         if (!wined3d_buffer)
3655         {
3656             buffers[i] = NULL;
3657             continue;
3658         }
3659
3660         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3661         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
3662         ID3D10Buffer_AddRef(buffers[i]);
3663     }
3664     wined3d_mutex_unlock();
3665 }
3666
3667 static void STDMETHODCALLTYPE d3d10_device_IAGetIndexBuffer(ID3D10Device1 *iface,
3668         ID3D10Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
3669 {
3670     struct d3d_device *device = impl_from_ID3D10Device(iface);
3671     enum wined3d_format_id wined3d_format;
3672     struct wined3d_buffer *wined3d_buffer;
3673     struct d3d_buffer *buffer_impl;
3674
3675     TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
3676
3677     wined3d_mutex_lock();
3678     wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format);
3679     *format = dxgi_format_from_wined3dformat(wined3d_format);
3680     *offset = 0; /* FIXME */
3681     if (!wined3d_buffer)
3682     {
3683         wined3d_mutex_unlock();
3684         *buffer = NULL;
3685         return;
3686     }
3687
3688     buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3689     wined3d_mutex_unlock();
3690     *buffer = &buffer_impl->ID3D10Buffer_iface;
3691     ID3D10Buffer_AddRef(*buffer);
3692 }
3693
3694 static void STDMETHODCALLTYPE d3d10_device_GSGetConstantBuffers(ID3D10Device1 *iface,
3695         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
3696 {
3697     struct d3d_device *device = impl_from_ID3D10Device(iface);
3698     unsigned int i;
3699
3700     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3701             iface, start_slot, buffer_count, buffers);
3702
3703     wined3d_mutex_lock();
3704     for (i = 0; i < buffer_count; ++i)
3705     {
3706         struct wined3d_buffer *wined3d_buffer;
3707         struct d3d_buffer *buffer_impl;
3708
3709         if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
3710         {
3711             buffers[i] = NULL;
3712             continue;
3713         }
3714
3715         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3716         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
3717         ID3D10Buffer_AddRef(buffers[i]);
3718     }
3719     wined3d_mutex_unlock();
3720 }
3721
3722 static void STDMETHODCALLTYPE d3d10_device_GSGetShader(ID3D10Device1 *iface, ID3D10GeometryShader **shader)
3723 {
3724     struct d3d_device *device = impl_from_ID3D10Device(iface);
3725     struct d3d_geometry_shader *shader_impl;
3726     struct wined3d_shader *wined3d_shader;
3727
3728     TRACE("iface %p, shader %p.\n", iface, shader);
3729
3730     wined3d_mutex_lock();
3731     if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
3732     {
3733         wined3d_mutex_unlock();
3734         *shader = NULL;
3735         return;
3736     }
3737
3738     shader_impl = wined3d_shader_get_parent(wined3d_shader);
3739     wined3d_mutex_unlock();
3740     *shader = &shader_impl->ID3D10GeometryShader_iface;
3741     ID3D10GeometryShader_AddRef(*shader);
3742 }
3743
3744 static void STDMETHODCALLTYPE d3d10_device_IAGetPrimitiveTopology(ID3D10Device1 *iface,
3745         D3D10_PRIMITIVE_TOPOLOGY *topology)
3746 {
3747     struct d3d_device *This = impl_from_ID3D10Device(iface);
3748
3749     TRACE("iface %p, topology %p\n", iface, topology);
3750
3751     wined3d_mutex_lock();
3752     wined3d_device_get_primitive_type(This->wined3d_device, (enum wined3d_primitive_type *)topology);
3753     wined3d_mutex_unlock();
3754 }
3755
3756 static void STDMETHODCALLTYPE d3d10_device_VSGetShaderResources(ID3D10Device1 *iface,
3757         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
3758 {
3759     struct d3d_device *device = impl_from_ID3D10Device(iface);
3760     unsigned int i;
3761
3762     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3763             iface, start_slot, view_count, views);
3764
3765     wined3d_mutex_lock();
3766     for (i = 0; i < view_count; ++i)
3767     {
3768         struct wined3d_shader_resource_view *wined3d_view;
3769         struct d3d_shader_resource_view *view_impl;
3770
3771         if (!(wined3d_view = wined3d_device_get_vs_resource_view(device->wined3d_device, start_slot + i)))
3772         {
3773             views[i] = NULL;
3774             continue;
3775         }
3776
3777         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
3778         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
3779         ID3D10ShaderResourceView_AddRef(views[i]);
3780     }
3781     wined3d_mutex_unlock();
3782 }
3783
3784 static void STDMETHODCALLTYPE d3d10_device_VSGetSamplers(ID3D10Device1 *iface,
3785         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
3786 {
3787     struct d3d_device *device = impl_from_ID3D10Device(iface);
3788     unsigned int i;
3789
3790     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3791             iface, start_slot, sampler_count, samplers);
3792
3793     wined3d_mutex_lock();
3794     for (i = 0; i < sampler_count; ++i)
3795     {
3796         struct d3d_sampler_state *sampler_impl;
3797         struct wined3d_sampler *wined3d_sampler;
3798
3799         if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
3800         {
3801             samplers[i] = NULL;
3802             continue;
3803         }
3804
3805         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
3806         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
3807         ID3D10SamplerState_AddRef(samplers[i]);
3808     }
3809     wined3d_mutex_unlock();
3810 }
3811
3812 static void STDMETHODCALLTYPE d3d10_device_GetPredication(ID3D10Device1 *iface,
3813         ID3D10Predicate **predicate, BOOL *value)
3814 {
3815     struct d3d_device *device = impl_from_ID3D10Device(iface);
3816     struct wined3d_query *wined3d_predicate;
3817     struct d3d_query *predicate_impl;
3818
3819     TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
3820
3821     wined3d_mutex_lock();
3822     if (!(wined3d_predicate = wined3d_device_get_predication(device->wined3d_device, value)))
3823     {
3824         wined3d_mutex_unlock();
3825         *predicate = NULL;
3826         return;
3827     }
3828
3829     predicate_impl = wined3d_query_get_parent(wined3d_predicate);
3830     wined3d_mutex_unlock();
3831     *predicate = (ID3D10Predicate *)&predicate_impl->ID3D10Query_iface;
3832     ID3D10Predicate_AddRef(*predicate);
3833 }
3834
3835 static void STDMETHODCALLTYPE d3d10_device_GSGetShaderResources(ID3D10Device1 *iface,
3836         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
3837 {
3838     struct d3d_device *device = impl_from_ID3D10Device(iface);
3839     unsigned int i;
3840
3841     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3842             iface, start_slot, view_count, views);
3843
3844     wined3d_mutex_lock();
3845     for (i = 0; i < view_count; ++i)
3846     {
3847         struct wined3d_shader_resource_view *wined3d_view;
3848         struct d3d_shader_resource_view *view_impl;
3849
3850         if (!(wined3d_view = wined3d_device_get_gs_resource_view(device->wined3d_device, start_slot + i)))
3851         {
3852             views[i] = NULL;
3853             continue;
3854         }
3855
3856         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
3857         views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
3858         ID3D10ShaderResourceView_AddRef(views[i]);
3859     }
3860     wined3d_mutex_unlock();
3861 }
3862
3863 static void STDMETHODCALLTYPE d3d10_device_GSGetSamplers(ID3D10Device1 *iface,
3864         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
3865 {
3866     struct d3d_device *device = impl_from_ID3D10Device(iface);
3867     unsigned int i;
3868
3869     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3870             iface, start_slot, sampler_count, samplers);
3871
3872     wined3d_mutex_lock();
3873     for (i = 0; i < sampler_count; ++i)
3874     {
3875         struct d3d_sampler_state *sampler_impl;
3876         struct wined3d_sampler *wined3d_sampler;
3877
3878         if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
3879         {
3880             samplers[i] = NULL;
3881             continue;
3882         }
3883
3884         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
3885         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
3886         ID3D10SamplerState_AddRef(samplers[i]);
3887     }
3888     wined3d_mutex_unlock();
3889 }
3890
3891 static void STDMETHODCALLTYPE d3d10_device_OMGetRenderTargets(ID3D10Device1 *iface,
3892         UINT view_count, ID3D10RenderTargetView **render_target_views, ID3D10DepthStencilView **depth_stencil_view)
3893 {
3894     struct d3d_device *device = impl_from_ID3D10Device(iface);
3895     struct wined3d_rendertarget_view *wined3d_view;
3896
3897     TRACE("iface %p, view_count %u, render_target_views %p, depth_stencil_view %p.\n",
3898             iface, view_count, render_target_views, depth_stencil_view);
3899
3900     wined3d_mutex_lock();
3901     if (render_target_views)
3902     {
3903         struct d3d_rendertarget_view *view_impl;
3904         unsigned int i;
3905
3906         for (i = 0; i < view_count; ++i)
3907         {
3908             if (!(wined3d_view = wined3d_device_get_rendertarget_view(device->wined3d_device, i))
3909                     || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
3910             {
3911                 render_target_views[i] = NULL;
3912                 continue;
3913             }
3914
3915             render_target_views[i] = &view_impl->ID3D10RenderTargetView_iface;
3916             ID3D10RenderTargetView_AddRef(render_target_views[i]);
3917         }
3918     }
3919
3920     if (depth_stencil_view)
3921     {
3922         struct d3d_depthstencil_view *view_impl;
3923
3924         if (!(wined3d_view = wined3d_device_get_depth_stencil_view(device->wined3d_device))
3925                 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
3926         {
3927             *depth_stencil_view = NULL;
3928         }
3929         else
3930         {
3931             *depth_stencil_view = &view_impl->ID3D10DepthStencilView_iface;
3932             ID3D10DepthStencilView_AddRef(*depth_stencil_view);
3933         }
3934     }
3935     wined3d_mutex_unlock();
3936 }
3937
3938 static void STDMETHODCALLTYPE d3d10_device_OMGetBlendState(ID3D10Device1 *iface,
3939         ID3D10BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
3940 {
3941     struct d3d_device *device = impl_from_ID3D10Device(iface);
3942
3943     TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
3944             iface, blend_state, blend_factor, sample_mask);
3945
3946     if ((*blend_state = device->blend_state ? (ID3D10BlendState *)&device->blend_state->ID3D10BlendState1_iface : NULL))
3947         ID3D10BlendState_AddRef(*blend_state);
3948     wined3d_mutex_lock();
3949     memcpy(blend_factor, device->blend_factor, 4 * sizeof(*blend_factor));
3950     *sample_mask = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK);
3951     wined3d_mutex_unlock();
3952 }
3953
3954 static void STDMETHODCALLTYPE d3d10_device_OMGetDepthStencilState(ID3D10Device1 *iface,
3955         ID3D10DepthStencilState **depth_stencil_state, UINT *stencil_ref)
3956 {
3957     struct d3d_device *device = impl_from_ID3D10Device(iface);
3958
3959     TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
3960             iface, depth_stencil_state, stencil_ref);
3961
3962     if ((*depth_stencil_state = device->depth_stencil_state
3963             ? &device->depth_stencil_state->ID3D10DepthStencilState_iface : NULL))
3964         ID3D10DepthStencilState_AddRef(*depth_stencil_state);
3965     *stencil_ref = device->stencil_ref;
3966 }
3967
3968 static void STDMETHODCALLTYPE d3d10_device_SOGetTargets(ID3D10Device1 *iface,
3969         UINT buffer_count, ID3D10Buffer **buffers, UINT *offsets)
3970 {
3971     struct d3d_device *device = impl_from_ID3D10Device(iface);
3972     unsigned int i;
3973
3974     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n",
3975             iface, buffer_count, buffers, offsets);
3976
3977     wined3d_mutex_lock();
3978     for (i = 0; i < buffer_count; ++i)
3979     {
3980         struct wined3d_buffer *wined3d_buffer;
3981         struct d3d_buffer *buffer_impl;
3982
3983         if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, &offsets[i])))
3984         {
3985             buffers[i] = NULL;
3986             continue;
3987         }
3988
3989         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
3990         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
3991         ID3D10Buffer_AddRef(buffers[i]);
3992     }
3993     wined3d_mutex_unlock();
3994 }
3995
3996 static void STDMETHODCALLTYPE d3d10_device_RSGetState(ID3D10Device1 *iface, ID3D10RasterizerState **rasterizer_state)
3997 {
3998     struct d3d_device *device = impl_from_ID3D10Device(iface);
3999
4000     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
4001
4002     if ((*rasterizer_state = device->rasterizer_state ? &device->rasterizer_state->ID3D10RasterizerState_iface : NULL))
4003         ID3D10RasterizerState_AddRef(*rasterizer_state);
4004 }
4005
4006 static void STDMETHODCALLTYPE d3d10_device_RSGetViewports(ID3D10Device1 *iface,
4007         UINT *viewport_count, D3D10_VIEWPORT *viewports)
4008 {
4009     struct d3d_device *device = impl_from_ID3D10Device(iface);
4010     struct wined3d_viewport wined3d_vp;
4011
4012     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
4013
4014     if (!viewports)
4015     {
4016         *viewport_count = 1;
4017         return;
4018     }
4019
4020     if (!*viewport_count)
4021         return;
4022
4023     wined3d_mutex_lock();
4024     wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
4025     wined3d_mutex_unlock();
4026
4027     viewports[0].TopLeftX = wined3d_vp.x;
4028     viewports[0].TopLeftY = wined3d_vp.y;
4029     viewports[0].Width = wined3d_vp.width;
4030     viewports[0].Height = wined3d_vp.height;
4031     viewports[0].MinDepth = wined3d_vp.min_z;
4032     viewports[0].MaxDepth = wined3d_vp.max_z;
4033
4034     if (*viewport_count > 1)
4035         memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
4036 }
4037
4038 static void STDMETHODCALLTYPE d3d10_device_RSGetScissorRects(ID3D10Device1 *iface, UINT *rect_count, D3D10_RECT *rects)
4039 {
4040     struct d3d_device *device = impl_from_ID3D10Device(iface);
4041
4042     TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
4043
4044     if (!rects)
4045     {
4046         *rect_count = 1;
4047         return;
4048     }
4049
4050     if (!*rect_count)
4051         return;
4052
4053     wined3d_mutex_lock();
4054     wined3d_device_get_scissor_rect(device->wined3d_device, rects);
4055     wined3d_mutex_unlock();
4056     if (*rect_count > 1)
4057         memset(&rects[1], 0, (*rect_count - 1) * sizeof(*rects));
4058 }
4059
4060 static HRESULT STDMETHODCALLTYPE d3d10_device_GetDeviceRemovedReason(ID3D10Device1 *iface)
4061 {
4062     TRACE("iface %p.\n", iface);
4063
4064     /* In the current implementation the device is never removed, so we can
4065      * just return S_OK here. */
4066
4067     return S_OK;
4068 }
4069
4070 static HRESULT STDMETHODCALLTYPE d3d10_device_SetExceptionMode(ID3D10Device1 *iface, UINT flags)
4071 {
4072     FIXME("iface %p, flags %#x stub!\n", iface, flags);
4073
4074     return E_NOTIMPL;
4075 }
4076
4077 static UINT STDMETHODCALLTYPE d3d10_device_GetExceptionMode(ID3D10Device1 *iface)
4078 {
4079     FIXME("iface %p stub!\n", iface);
4080
4081     return 0;
4082 }
4083
4084 static HRESULT STDMETHODCALLTYPE d3d10_device_GetPrivateData(ID3D10Device1 *iface,
4085         REFGUID guid, UINT *data_size, void *data)
4086 {
4087     struct d3d_device *device = impl_from_ID3D10Device(iface);
4088
4089     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4090
4091     return d3d11_device_GetPrivateData(&device->ID3D11Device_iface, guid, data_size, data);
4092 }
4093
4094 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateData(ID3D10Device1 *iface,
4095         REFGUID guid, UINT data_size, const void *data)
4096 {
4097     struct d3d_device *device = impl_from_ID3D10Device(iface);
4098
4099     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4100
4101     return d3d11_device_SetPrivateData(&device->ID3D11Device_iface, guid, data_size, data);
4102 }
4103
4104 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateDataInterface(ID3D10Device1 *iface,
4105         REFGUID guid, const IUnknown *data)
4106 {
4107     struct d3d_device *device = impl_from_ID3D10Device(iface);
4108
4109     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
4110
4111     return d3d11_device_SetPrivateDataInterface(&device->ID3D11Device_iface, guid, data);
4112 }
4113
4114 static void STDMETHODCALLTYPE d3d10_device_ClearState(ID3D10Device1 *iface)
4115 {
4116     static const float blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
4117     struct d3d_device *device = impl_from_ID3D10Device(iface);
4118     unsigned int i;
4119
4120     TRACE("iface %p.\n", iface);
4121
4122     wined3d_mutex_lock();
4123     wined3d_device_set_vertex_shader(device->wined3d_device, NULL);
4124     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
4125     {
4126         wined3d_device_set_vs_sampler(device->wined3d_device, i, NULL);
4127     }
4128     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
4129     {
4130         wined3d_device_set_vs_resource_view(device->wined3d_device, i, NULL);
4131     }
4132     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
4133     {
4134         wined3d_device_set_vs_cb(device->wined3d_device, i, NULL);
4135     }
4136     wined3d_device_set_geometry_shader(device->wined3d_device, NULL);
4137     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
4138     {
4139         wined3d_device_set_gs_sampler(device->wined3d_device, i, NULL);
4140     }
4141     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
4142     {
4143         wined3d_device_set_gs_resource_view(device->wined3d_device, i, NULL);
4144     }
4145     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
4146     {
4147         wined3d_device_set_gs_cb(device->wined3d_device, i, NULL);
4148     }
4149     wined3d_device_set_pixel_shader(device->wined3d_device, NULL);
4150     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
4151     {
4152         wined3d_device_set_ps_sampler(device->wined3d_device, i, NULL);
4153     }
4154     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
4155     {
4156         wined3d_device_set_ps_resource_view(device->wined3d_device, i, NULL);
4157     }
4158     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
4159     {
4160         wined3d_device_set_ps_cb(device->wined3d_device, i, NULL);
4161     }
4162     for (i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i)
4163     {
4164         wined3d_device_set_stream_source(device->wined3d_device, i, NULL, 0, 0);
4165     }
4166     wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN);
4167     wined3d_device_set_vertex_declaration(device->wined3d_device, NULL);
4168     wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_UNDEFINED);
4169     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
4170     {
4171         wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
4172     }
4173     wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
4174     ID3D10Device1_OMSetDepthStencilState(iface, NULL, 0);
4175     ID3D10Device1_OMSetBlendState(iface, NULL, blend_factor, D3D10_DEFAULT_SAMPLE_MASK);
4176     ID3D10Device1_RSSetViewports(iface, 0, NULL);
4177     ID3D10Device1_RSSetScissorRects(iface, 0, NULL);
4178     ID3D10Device1_RSSetState(iface, NULL);
4179     for (i = 0; i < D3D10_SO_BUFFER_SLOT_COUNT; ++i)
4180     {
4181         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
4182     }
4183     wined3d_device_set_predication(device->wined3d_device, NULL, FALSE);
4184     wined3d_mutex_unlock();
4185 }
4186
4187 static void STDMETHODCALLTYPE d3d10_device_Flush(ID3D10Device1 *iface)
4188 {
4189     FIXME("iface %p stub!\n", iface);
4190 }
4191
4192 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBuffer(ID3D10Device1 *iface,
4193         const D3D10_BUFFER_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Buffer **buffer)
4194 {
4195     struct d3d_device *device = impl_from_ID3D10Device(iface);
4196     D3D11_BUFFER_DESC d3d11_desc;
4197     struct d3d_buffer *object;
4198     HRESULT hr;
4199
4200     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
4201
4202     d3d11_desc.ByteWidth = desc->ByteWidth;
4203     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
4204     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
4205     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
4206     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
4207     d3d11_desc.StructureByteStride = 0;
4208
4209     if (FAILED(hr = d3d_buffer_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
4210         return hr;
4211
4212     *buffer = &object->ID3D10Buffer_iface;
4213
4214     return S_OK;
4215 }
4216
4217 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture1D(ID3D10Device1 *iface,
4218         const D3D10_TEXTURE1D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Texture1D **texture)
4219 {
4220     FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
4221
4222     return E_NOTIMPL;
4223 }
4224
4225 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture2D(ID3D10Device1 *iface,
4226         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
4227         ID3D10Texture2D **texture)
4228 {
4229     struct d3d_device *device = impl_from_ID3D10Device(iface);
4230     D3D11_TEXTURE2D_DESC d3d11_desc;
4231     struct d3d_texture2d *object;
4232     HRESULT hr;
4233
4234     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
4235
4236     d3d11_desc.Width = desc->Width;
4237     d3d11_desc.Height = desc->Height;
4238     d3d11_desc.MipLevels = desc->MipLevels;
4239     d3d11_desc.ArraySize = desc->ArraySize;
4240     d3d11_desc.Format = desc->Format;
4241     d3d11_desc.SampleDesc = desc->SampleDesc;
4242     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
4243     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
4244     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
4245     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
4246
4247     if (FAILED(hr = d3d_texture2d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
4248         return hr;
4249
4250     *texture = &object->ID3D10Texture2D_iface;
4251
4252     return S_OK;
4253 }
4254
4255 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture3D(ID3D10Device1 *iface,
4256         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
4257         ID3D10Texture3D **texture)
4258 {
4259     struct d3d_device *device = impl_from_ID3D10Device(iface);
4260     D3D11_TEXTURE3D_DESC d3d11_desc;
4261     struct d3d_texture3d *object;
4262     HRESULT hr;
4263
4264     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
4265
4266     d3d11_desc.Width = desc->Width;
4267     d3d11_desc.Height = desc->Height;
4268     d3d11_desc.Depth = desc->Depth;
4269     d3d11_desc.MipLevels = desc->MipLevels;
4270     d3d11_desc.Format = desc->Format;
4271     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
4272     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
4273     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
4274     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
4275
4276     if (FAILED(hr = d3d_texture3d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
4277         return hr;
4278
4279     *texture = &object->ID3D10Texture3D_iface;
4280
4281     return S_OK;
4282 }
4283
4284 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView1(ID3D10Device1 *iface,
4285         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc, ID3D10ShaderResourceView1 **view)
4286 {
4287     struct d3d_device *device = impl_from_ID3D10Device(iface);
4288     struct d3d_shader_resource_view *object;
4289     ID3D11Resource *d3d11_resource;
4290     HRESULT hr;
4291
4292     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
4293
4294     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
4295     {
4296         ERR("Resource does not implement ID3D11Resource.\n");
4297         return E_FAIL;
4298     }
4299
4300     hr = d3d_shader_resource_view_create(device, d3d11_resource, (const D3D11_SHADER_RESOURCE_VIEW_DESC *)desc,
4301             &object);
4302     ID3D11Resource_Release(d3d11_resource);
4303     if (FAILED(hr))
4304         return hr;
4305
4306     *view = &object->ID3D10ShaderResourceView1_iface;
4307
4308     return S_OK;
4309 }
4310
4311 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView(ID3D10Device1 *iface,
4312         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10ShaderResourceView **view)
4313 {
4314     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
4315
4316     return d3d10_device_CreateShaderResourceView1(iface, resource,
4317             (const D3D10_SHADER_RESOURCE_VIEW_DESC1 *)desc, (ID3D10ShaderResourceView1 **)view);
4318 }
4319
4320 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRenderTargetView(ID3D10Device1 *iface,
4321         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10RenderTargetView **view)
4322 {
4323     struct d3d_device *device = impl_from_ID3D10Device(iface);
4324     struct d3d_rendertarget_view *object;
4325     ID3D11Resource *d3d11_resource;
4326     HRESULT hr;
4327
4328     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
4329
4330     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
4331     {
4332         ERR("Resource does not implement ID3D11Resource.\n");
4333         return E_FAIL;
4334     }
4335
4336     hr = d3d_rendertarget_view_create(device, d3d11_resource, (const D3D11_RENDER_TARGET_VIEW_DESC *)desc, &object);
4337     ID3D11Resource_Release(d3d11_resource);
4338     if (FAILED(hr))
4339         return hr;
4340
4341     *view = &object->ID3D10RenderTargetView_iface;
4342
4343     return S_OK;
4344 }
4345
4346 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilView(ID3D10Device1 *iface,
4347         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10DepthStencilView **view)
4348 {
4349     struct d3d_device *device = impl_from_ID3D10Device(iface);
4350     D3D11_DEPTH_STENCIL_VIEW_DESC d3d11_desc;
4351     struct d3d_depthstencil_view *object;
4352     ID3D11Resource *d3d11_resource;
4353     HRESULT hr;
4354
4355     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
4356
4357     if (desc)
4358     {
4359         d3d11_desc.Format = desc->Format;
4360         d3d11_desc.ViewDimension = desc->ViewDimension;
4361         d3d11_desc.Flags = 0;
4362         memcpy(&d3d11_desc.u, &desc->u, sizeof(d3d11_desc.u));
4363     }
4364
4365     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
4366     {
4367         ERR("Resource does not implement ID3D11Resource.\n");
4368         return E_FAIL;
4369     }
4370
4371     hr = d3d_depthstencil_view_create(device, d3d11_resource, desc ? &d3d11_desc : NULL, &object);
4372     ID3D11Resource_Release(d3d11_resource);
4373     if (FAILED(hr))
4374         return hr;
4375
4376     *view = &object->ID3D10DepthStencilView_iface;
4377
4378     return S_OK;
4379 }
4380
4381 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateInputLayout(ID3D10Device1 *iface,
4382         const D3D10_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
4383         const void *shader_byte_code, SIZE_T shader_byte_code_length,
4384         ID3D10InputLayout **input_layout)
4385 {
4386     struct d3d_device *device = impl_from_ID3D10Device(iface);
4387     struct d3d_input_layout *object;
4388     HRESULT hr;
4389
4390     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, "
4391             "shader_byte_code_length %lu, input_layout %p\n",
4392             iface, element_descs, element_count, shader_byte_code,
4393             shader_byte_code_length, input_layout);
4394
4395     if (FAILED(hr = d3d_input_layout_create(device, (const D3D11_INPUT_ELEMENT_DESC *)element_descs, element_count,
4396             shader_byte_code, shader_byte_code_length, &object)))
4397         return hr;
4398
4399     *input_layout = &object->ID3D10InputLayout_iface;
4400
4401     return S_OK;
4402 }
4403
4404 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateVertexShader(ID3D10Device1 *iface,
4405         const void *byte_code, SIZE_T byte_code_length, ID3D10VertexShader **shader)
4406 {
4407     struct d3d_device *device = impl_from_ID3D10Device(iface);
4408     struct d3d_vertex_shader *object;
4409     HRESULT hr;
4410
4411     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
4412             iface, byte_code, byte_code_length, shader);
4413
4414     if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
4415         return hr;
4416
4417     *shader = &object->ID3D10VertexShader_iface;
4418
4419     return S_OK;
4420 }
4421
4422 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShader(ID3D10Device1 *iface,
4423         const void *byte_code, SIZE_T byte_code_length, ID3D10GeometryShader **shader)
4424 {
4425     struct d3d_device *device = impl_from_ID3D10Device(iface);
4426     struct d3d_geometry_shader *object;
4427     HRESULT hr;
4428
4429     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
4430             iface, byte_code, byte_code_length, shader);
4431
4432     if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length, &object)))
4433         return hr;
4434
4435     *shader = &object->ID3D10GeometryShader_iface;
4436
4437     return S_OK;
4438 }
4439
4440 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShaderWithStreamOutput(ID3D10Device1 *iface,
4441         const void *byte_code, SIZE_T byte_code_length, const D3D10_SO_DECLARATION_ENTRY *output_stream_decls,
4442         UINT output_stream_decl_count, UINT output_stream_stride, ID3D10GeometryShader **shader)
4443 {
4444     FIXME("iface %p, byte_code %p, byte_code_length %lu, output_stream_decls %p, "
4445             "output_stream_decl_count %u, output_stream_stride %u, shader %p stub!\n",
4446             iface, byte_code, byte_code_length, output_stream_decls,
4447             output_stream_decl_count, output_stream_stride, shader);
4448
4449     return E_NOTIMPL;
4450 }
4451
4452 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePixelShader(ID3D10Device1 *iface,
4453         const void *byte_code, SIZE_T byte_code_length, ID3D10PixelShader **shader)
4454 {
4455     struct d3d_device *device = impl_from_ID3D10Device(iface);
4456     struct d3d_pixel_shader *object;
4457     HRESULT hr;
4458
4459     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
4460             iface, byte_code, byte_code_length, shader);
4461
4462     if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
4463         return hr;
4464
4465     *shader = &object->ID3D10PixelShader_iface;
4466
4467     return S_OK;
4468 }
4469
4470 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState1(ID3D10Device1 *iface,
4471         const D3D10_BLEND_DESC1 *desc, ID3D10BlendState1 **blend_state)
4472 {
4473     struct d3d_device *device = impl_from_ID3D10Device(iface);
4474     ID3D11BlendState *d3d11_blend_state;
4475     HRESULT hr;
4476
4477     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
4478
4479     if (FAILED(hr = d3d11_device_CreateBlendState(&device->ID3D11Device_iface, (D3D11_BLEND_DESC *)desc,
4480             &d3d11_blend_state)))
4481         return hr;
4482
4483     hr = ID3D11BlendState_QueryInterface(d3d11_blend_state, &IID_ID3D10BlendState1, (void **)blend_state);
4484     ID3D11BlendState_Release(d3d11_blend_state);
4485     return hr;
4486 }
4487
4488 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState(ID3D10Device1 *iface,
4489         const D3D10_BLEND_DESC *desc, ID3D10BlendState **blend_state)
4490 {
4491     D3D10_BLEND_DESC1 d3d10_1_desc;
4492     unsigned int i;
4493
4494     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
4495
4496     if (!desc)
4497         return E_INVALIDARG;
4498
4499     d3d10_1_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
4500     d3d10_1_desc.IndependentBlendEnable = FALSE;
4501     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT - 1; ++i)
4502     {
4503         if (desc->BlendEnable[i] != desc->BlendEnable[i + 1]
4504                 || desc->RenderTargetWriteMask[i] != desc->RenderTargetWriteMask[i + 1])
4505             d3d10_1_desc.IndependentBlendEnable = TRUE;
4506     }
4507
4508     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
4509     {
4510         d3d10_1_desc.RenderTarget[i].BlendEnable = desc->BlendEnable[i];
4511         d3d10_1_desc.RenderTarget[i].SrcBlend = desc->SrcBlend;
4512         d3d10_1_desc.RenderTarget[i].DestBlend = desc->DestBlend;
4513         d3d10_1_desc.RenderTarget[i].BlendOp = desc->BlendOp;
4514         d3d10_1_desc.RenderTarget[i].SrcBlendAlpha = desc->SrcBlendAlpha;
4515         d3d10_1_desc.RenderTarget[i].DestBlendAlpha = desc->DestBlendAlpha;
4516         d3d10_1_desc.RenderTarget[i].BlendOpAlpha = desc->BlendOpAlpha;
4517         d3d10_1_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTargetWriteMask[i];
4518     }
4519
4520     return d3d10_device_CreateBlendState1(iface, &d3d10_1_desc, (ID3D10BlendState1 **)blend_state);
4521 }
4522
4523 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilState(ID3D10Device1 *iface,
4524         const D3D10_DEPTH_STENCIL_DESC *desc, ID3D10DepthStencilState **depth_stencil_state)
4525 {
4526     struct d3d_device *device = impl_from_ID3D10Device(iface);
4527     ID3D11DepthStencilState *d3d11_depth_stencil_state;
4528     HRESULT hr;
4529
4530     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
4531
4532     if (FAILED(hr = d3d11_device_CreateDepthStencilState(&device->ID3D11Device_iface,
4533             (const D3D11_DEPTH_STENCIL_DESC *)desc, &d3d11_depth_stencil_state)))
4534         return hr;
4535
4536     hr = ID3D11DepthStencilState_QueryInterface(d3d11_depth_stencil_state, &IID_ID3D10DepthStencilState,
4537             (void **)depth_stencil_state);
4538     ID3D11DepthStencilState_Release(d3d11_depth_stencil_state);
4539     return hr;
4540 }
4541
4542 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device1 *iface,
4543         const D3D10_RASTERIZER_DESC *desc, ID3D10RasterizerState **rasterizer_state)
4544 {
4545     struct d3d_device *device = impl_from_ID3D10Device(iface);
4546     ID3D11RasterizerState *d3d11_rasterizer_state;
4547     HRESULT hr;
4548
4549     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
4550
4551     if (FAILED(hr = d3d11_device_CreateRasterizerState(&device->ID3D11Device_iface,
4552             (const D3D11_RASTERIZER_DESC *)desc, &d3d11_rasterizer_state)))
4553         return hr;
4554
4555     hr = ID3D11RasterizerState_QueryInterface(d3d11_rasterizer_state,
4556             &IID_ID3D10RasterizerState, (void **)rasterizer_state);
4557     ID3D11RasterizerState_Release(d3d11_rasterizer_state);
4558     return hr;
4559 }
4560
4561 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateSamplerState(ID3D10Device1 *iface,
4562         const D3D10_SAMPLER_DESC *desc, ID3D10SamplerState **sampler_state)
4563 {
4564     struct d3d_device *device = impl_from_ID3D10Device(iface);
4565     ID3D11SamplerState *d3d11_sampler_state;
4566     HRESULT hr;
4567
4568     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
4569
4570     if (FAILED(hr = d3d11_device_CreateSamplerState(&device->ID3D11Device_iface,
4571             (const D3D11_SAMPLER_DESC *)desc, &d3d11_sampler_state)))
4572         return hr;
4573
4574     hr = ID3D11SamplerState_QueryInterface(d3d11_sampler_state, &IID_ID3D10SamplerState, (void **)sampler_state);
4575     ID3D11SamplerState_Release(d3d11_sampler_state);
4576     return hr;
4577 }
4578
4579 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateQuery(ID3D10Device1 *iface,
4580         const D3D10_QUERY_DESC *desc, ID3D10Query **query)
4581 {
4582     struct d3d_device *device = impl_from_ID3D10Device(iface);
4583     struct d3d_query *object;
4584     HRESULT hr;
4585
4586     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
4587
4588     if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, FALSE, &object)))
4589         return hr;
4590
4591     *query = &object->ID3D10Query_iface;
4592
4593     return S_OK;
4594 }
4595
4596 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePredicate(ID3D10Device1 *iface,
4597         const D3D10_QUERY_DESC *desc, ID3D10Predicate **predicate)
4598 {
4599     struct d3d_device *device = impl_from_ID3D10Device(iface);
4600     struct d3d_query *object;
4601     HRESULT hr;
4602
4603     TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
4604
4605     if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, TRUE, &object)))
4606         return hr;
4607
4608     *predicate = (ID3D10Predicate *)&object->ID3D10Query_iface;
4609
4610     return S_OK;
4611 }
4612
4613 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateCounter(ID3D10Device1 *iface,
4614         const D3D10_COUNTER_DESC *desc, ID3D10Counter **counter)
4615 {
4616     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
4617
4618     return E_NOTIMPL;
4619 }
4620
4621 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckFormatSupport(ID3D10Device1 *iface,
4622         DXGI_FORMAT format, UINT *format_support)
4623 {
4624     FIXME("iface %p, format %s, format_support %p stub!\n",
4625             iface, debug_dxgi_format(format), format_support);
4626
4627     return E_NOTIMPL;
4628 }
4629
4630 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckMultisampleQualityLevels(ID3D10Device1 *iface,
4631         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
4632 {
4633     struct d3d_device *device = impl_from_ID3D10Device(iface);
4634
4635     TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
4636             iface, debug_dxgi_format(format), sample_count, quality_level_count);
4637
4638     return d3d11_device_CheckMultisampleQualityLevels(&device->ID3D11Device_iface, format,
4639             sample_count, quality_level_count);
4640 }
4641
4642 static void STDMETHODCALLTYPE d3d10_device_CheckCounterInfo(ID3D10Device1 *iface, D3D10_COUNTER_INFO *counter_info)
4643 {
4644     FIXME("iface %p, counter_info %p stub!\n", iface, counter_info);
4645 }
4646
4647 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckCounter(ID3D10Device1 *iface,
4648         const D3D10_COUNTER_DESC *desc, D3D10_COUNTER_TYPE *type, UINT *active_counters, char *name,
4649         UINT *name_length, char *units, UINT *units_length, char *description, UINT *description_length)
4650 {
4651     FIXME("iface %p, desc %p, type %p, active_counters %p, name %p, name_length %p, "
4652             "units %p, units_length %p, description %p, description_length %p stub!\n",
4653             iface, desc, type, active_counters, name, name_length,
4654             units, units_length, description, description_length);
4655
4656     return E_NOTIMPL;
4657 }
4658
4659 static UINT STDMETHODCALLTYPE d3d10_device_GetCreationFlags(ID3D10Device1 *iface)
4660 {
4661     FIXME("iface %p stub!\n", iface);
4662
4663     return 0;
4664 }
4665
4666 static HRESULT STDMETHODCALLTYPE d3d10_device_OpenSharedResource(ID3D10Device1 *iface,
4667         HANDLE resource_handle, REFIID guid, void **resource)
4668 {
4669     FIXME("iface %p, resource_handle %p, guid %s, resource %p stub!\n",
4670             iface, resource_handle, debugstr_guid(guid), resource);
4671
4672     return E_NOTIMPL;
4673 }
4674
4675 static void STDMETHODCALLTYPE d3d10_device_SetTextFilterSize(ID3D10Device1 *iface, UINT width, UINT height)
4676 {
4677     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
4678 }
4679
4680 static void STDMETHODCALLTYPE d3d10_device_GetTextFilterSize(ID3D10Device1 *iface, UINT *width, UINT *height)
4681 {
4682     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
4683 }
4684
4685 static D3D10_FEATURE_LEVEL1 STDMETHODCALLTYPE d3d10_device_GetFeatureLevel(ID3D10Device1 *iface)
4686 {
4687     struct d3d_device *device = impl_from_ID3D10Device(iface);
4688
4689     TRACE("iface %p.\n", iface);
4690
4691     return device->feature_level;
4692 }
4693
4694 static const struct ID3D10Device1Vtbl d3d10_device1_vtbl =
4695 {
4696     /* IUnknown methods */
4697     d3d10_device_QueryInterface,
4698     d3d10_device_AddRef,
4699     d3d10_device_Release,
4700     /* ID3D10Device methods */
4701     d3d10_device_VSSetConstantBuffers,
4702     d3d10_device_PSSetShaderResources,
4703     d3d10_device_PSSetShader,
4704     d3d10_device_PSSetSamplers,
4705     d3d10_device_VSSetShader,
4706     d3d10_device_DrawIndexed,
4707     d3d10_device_Draw,
4708     d3d10_device_PSSetConstantBuffers,
4709     d3d10_device_IASetInputLayout,
4710     d3d10_device_IASetVertexBuffers,
4711     d3d10_device_IASetIndexBuffer,
4712     d3d10_device_DrawIndexedInstanced,
4713     d3d10_device_DrawInstanced,
4714     d3d10_device_GSSetConstantBuffers,
4715     d3d10_device_GSSetShader,
4716     d3d10_device_IASetPrimitiveTopology,
4717     d3d10_device_VSSetShaderResources,
4718     d3d10_device_VSSetSamplers,
4719     d3d10_device_SetPredication,
4720     d3d10_device_GSSetShaderResources,
4721     d3d10_device_GSSetSamplers,
4722     d3d10_device_OMSetRenderTargets,
4723     d3d10_device_OMSetBlendState,
4724     d3d10_device_OMSetDepthStencilState,
4725     d3d10_device_SOSetTargets,
4726     d3d10_device_DrawAuto,
4727     d3d10_device_RSSetState,
4728     d3d10_device_RSSetViewports,
4729     d3d10_device_RSSetScissorRects,
4730     d3d10_device_CopySubresourceRegion,
4731     d3d10_device_CopyResource,
4732     d3d10_device_UpdateSubresource,
4733     d3d10_device_ClearRenderTargetView,
4734     d3d10_device_ClearDepthStencilView,
4735     d3d10_device_GenerateMips,
4736     d3d10_device_ResolveSubresource,
4737     d3d10_device_VSGetConstantBuffers,
4738     d3d10_device_PSGetShaderResources,
4739     d3d10_device_PSGetShader,
4740     d3d10_device_PSGetSamplers,
4741     d3d10_device_VSGetShader,
4742     d3d10_device_PSGetConstantBuffers,
4743     d3d10_device_IAGetInputLayout,
4744     d3d10_device_IAGetVertexBuffers,
4745     d3d10_device_IAGetIndexBuffer,
4746     d3d10_device_GSGetConstantBuffers,
4747     d3d10_device_GSGetShader,
4748     d3d10_device_IAGetPrimitiveTopology,
4749     d3d10_device_VSGetShaderResources,
4750     d3d10_device_VSGetSamplers,
4751     d3d10_device_GetPredication,
4752     d3d10_device_GSGetShaderResources,
4753     d3d10_device_GSGetSamplers,
4754     d3d10_device_OMGetRenderTargets,
4755     d3d10_device_OMGetBlendState,
4756     d3d10_device_OMGetDepthStencilState,
4757     d3d10_device_SOGetTargets,
4758     d3d10_device_RSGetState,
4759     d3d10_device_RSGetViewports,
4760     d3d10_device_RSGetScissorRects,
4761     d3d10_device_GetDeviceRemovedReason,
4762     d3d10_device_SetExceptionMode,
4763     d3d10_device_GetExceptionMode,
4764     d3d10_device_GetPrivateData,
4765     d3d10_device_SetPrivateData,
4766     d3d10_device_SetPrivateDataInterface,
4767     d3d10_device_ClearState,
4768     d3d10_device_Flush,
4769     d3d10_device_CreateBuffer,
4770     d3d10_device_CreateTexture1D,
4771     d3d10_device_CreateTexture2D,
4772     d3d10_device_CreateTexture3D,
4773     d3d10_device_CreateShaderResourceView,
4774     d3d10_device_CreateRenderTargetView,
4775     d3d10_device_CreateDepthStencilView,
4776     d3d10_device_CreateInputLayout,
4777     d3d10_device_CreateVertexShader,
4778     d3d10_device_CreateGeometryShader,
4779     d3d10_device_CreateGeometryShaderWithStreamOutput,
4780     d3d10_device_CreatePixelShader,
4781     d3d10_device_CreateBlendState,
4782     d3d10_device_CreateDepthStencilState,
4783     d3d10_device_CreateRasterizerState,
4784     d3d10_device_CreateSamplerState,
4785     d3d10_device_CreateQuery,
4786     d3d10_device_CreatePredicate,
4787     d3d10_device_CreateCounter,
4788     d3d10_device_CheckFormatSupport,
4789     d3d10_device_CheckMultisampleQualityLevels,
4790     d3d10_device_CheckCounterInfo,
4791     d3d10_device_CheckCounter,
4792     d3d10_device_GetCreationFlags,
4793     d3d10_device_OpenSharedResource,
4794     d3d10_device_SetTextFilterSize,
4795     d3d10_device_GetTextFilterSize,
4796     d3d10_device_CreateShaderResourceView1,
4797     d3d10_device_CreateBlendState1,
4798     d3d10_device_GetFeatureLevel,
4799 };
4800
4801 static const struct IUnknownVtbl d3d_device_inner_unknown_vtbl =
4802 {
4803     /* IUnknown methods */
4804     d3d_device_inner_QueryInterface,
4805     d3d_device_inner_AddRef,
4806     d3d_device_inner_Release,
4807 };
4808
4809 /* ID3D10Multithread methods */
4810
4811 static inline struct d3d_device *impl_from_ID3D10Multithread(ID3D10Multithread *iface)
4812 {
4813     return CONTAINING_RECORD(iface, struct d3d_device, ID3D10Multithread_iface);
4814 }
4815
4816 static HRESULT STDMETHODCALLTYPE d3d10_multithread_QueryInterface(ID3D10Multithread *iface, REFIID iid, void **out)
4817 {
4818     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
4819
4820     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
4821
4822     return IUnknown_QueryInterface(device->outer_unk, iid, out);
4823 }
4824
4825 static ULONG STDMETHODCALLTYPE d3d10_multithread_AddRef(ID3D10Multithread *iface)
4826 {
4827     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
4828
4829     TRACE("iface %p.\n", iface);
4830
4831     return IUnknown_AddRef(device->outer_unk);
4832 }
4833
4834 static ULONG STDMETHODCALLTYPE d3d10_multithread_Release(ID3D10Multithread *iface)
4835 {
4836     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
4837
4838     TRACE("iface %p.\n", iface);
4839
4840     return IUnknown_Release(device->outer_unk);
4841 }
4842
4843 static void STDMETHODCALLTYPE d3d10_multithread_Enter(ID3D10Multithread *iface)
4844 {
4845     TRACE("iface %p.\n", iface);
4846
4847     wined3d_mutex_lock();
4848 }
4849
4850 static void STDMETHODCALLTYPE d3d10_multithread_Leave(ID3D10Multithread *iface)
4851 {
4852     TRACE("iface %p.\n", iface);
4853
4854     wined3d_mutex_unlock();
4855 }
4856
4857 static BOOL STDMETHODCALLTYPE d3d10_multithread_SetMultithreadProtected(ID3D10Multithread *iface, BOOL protect)
4858 {
4859     FIXME("iface %p, protect %#x stub!\n", iface, protect);
4860
4861     return TRUE;
4862 }
4863
4864 static BOOL STDMETHODCALLTYPE d3d10_multithread_GetMultithreadProtected(ID3D10Multithread *iface)
4865 {
4866     FIXME("iface %p stub!\n", iface);
4867
4868     return TRUE;
4869 }
4870
4871 static const struct ID3D10MultithreadVtbl d3d10_multithread_vtbl =
4872 {
4873     d3d10_multithread_QueryInterface,
4874     d3d10_multithread_AddRef,
4875     d3d10_multithread_Release,
4876     d3d10_multithread_Enter,
4877     d3d10_multithread_Leave,
4878     d3d10_multithread_SetMultithreadProtected,
4879     d3d10_multithread_GetMultithreadProtected,
4880 };
4881
4882 /* IWineDXGIDeviceParent IUnknown methods */
4883
4884 static inline struct d3d_device *device_from_dxgi_device_parent(IWineDXGIDeviceParent *iface)
4885 {
4886     return CONTAINING_RECORD(iface, struct d3d_device, IWineDXGIDeviceParent_iface);
4887 }
4888
4889 static HRESULT STDMETHODCALLTYPE dxgi_device_parent_QueryInterface(IWineDXGIDeviceParent *iface,
4890         REFIID riid, void **ppv)
4891 {
4892     struct d3d_device *device = device_from_dxgi_device_parent(iface);
4893     return IUnknown_QueryInterface(device->outer_unk, riid, ppv);
4894 }
4895
4896 static ULONG STDMETHODCALLTYPE dxgi_device_parent_AddRef(IWineDXGIDeviceParent *iface)
4897 {
4898     struct d3d_device *device = device_from_dxgi_device_parent(iface);
4899     return IUnknown_AddRef(device->outer_unk);
4900 }
4901
4902 static ULONG STDMETHODCALLTYPE dxgi_device_parent_Release(IWineDXGIDeviceParent *iface)
4903 {
4904     struct d3d_device *device = device_from_dxgi_device_parent(iface);
4905     return IUnknown_Release(device->outer_unk);
4906 }
4907
4908 static struct wined3d_device_parent * STDMETHODCALLTYPE dxgi_device_parent_get_wined3d_device_parent(
4909         IWineDXGIDeviceParent *iface)
4910 {
4911     struct d3d_device *device = device_from_dxgi_device_parent(iface);
4912     return &device->device_parent;
4913 }
4914
4915 static const struct IWineDXGIDeviceParentVtbl d3d_dxgi_device_parent_vtbl =
4916 {
4917     /* IUnknown methods */
4918     dxgi_device_parent_QueryInterface,
4919     dxgi_device_parent_AddRef,
4920     dxgi_device_parent_Release,
4921     /* IWineDXGIDeviceParent methods */
4922     dxgi_device_parent_get_wined3d_device_parent,
4923 };
4924
4925 static inline struct d3d_device *device_from_wined3d_device_parent(struct wined3d_device_parent *device_parent)
4926 {
4927     return CONTAINING_RECORD(device_parent, struct d3d_device, device_parent);
4928 }
4929
4930 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
4931         struct wined3d_device *wined3d_device)
4932 {
4933     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
4934
4935     TRACE("device_parent %p, wined3d_device %p.\n", device_parent, wined3d_device);
4936
4937     wined3d_device_incref(wined3d_device);
4938     device->wined3d_device = wined3d_device;
4939 }
4940
4941 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
4942 {
4943     TRACE("device_parent %p.\n", device_parent);
4944 }
4945
4946 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
4947 {
4948     TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
4949 }
4950
4951 static HRESULT CDECL device_parent_sub_resource_created(struct wined3d_device_parent *device_parent,
4952         struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, void **parent,
4953         const struct wined3d_parent_ops **parent_ops)
4954 {
4955     TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4956             device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
4957
4958     *parent = NULL;
4959     *parent_ops = &d3d_null_wined3d_parent_ops;
4960
4961     return S_OK;
4962 }
4963
4964 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
4965         void *container_parent, const struct wined3d_resource_desc *wined3d_desc,
4966         struct wined3d_texture **wined3d_texture)
4967 {
4968     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
4969     struct d3d_texture2d *texture;
4970     ID3D10Texture2D *texture_iface;
4971     D3D10_TEXTURE2D_DESC desc;
4972     HRESULT hr;
4973
4974     FIXME("device_parent %p, container_parent %p, wined3d_desc %p, wined3d_texture %p partial stub!\n",
4975             device_parent, container_parent, wined3d_desc, wined3d_texture);
4976
4977     FIXME("Implement DXGI<->wined3d usage conversion.\n");
4978
4979     desc.Width = wined3d_desc->width;
4980     desc.Height = wined3d_desc->height;
4981     desc.MipLevels = 1;
4982     desc.ArraySize = 1;
4983     desc.Format = dxgi_format_from_wined3dformat(wined3d_desc->format);
4984     desc.SampleDesc.Count = wined3d_desc->multisample_type ? wined3d_desc->multisample_type : 1;
4985     desc.SampleDesc.Quality = wined3d_desc->multisample_quality;
4986     desc.Usage = D3D10_USAGE_DEFAULT;
4987     desc.BindFlags = D3D10_BIND_RENDER_TARGET;
4988     desc.CPUAccessFlags = 0;
4989     desc.MiscFlags = 0;
4990
4991     if (FAILED(hr = d3d10_device_CreateTexture2D(&device->ID3D10Device1_iface,
4992             &desc, NULL, &texture_iface)))
4993     {
4994         WARN("CreateTexture2D failed, returning %#x.\n", hr);
4995         return hr;
4996     }
4997
4998     texture = impl_from_ID3D10Texture2D(texture_iface);
4999
5000     *wined3d_texture = texture->wined3d_texture;
5001     wined3d_texture_incref(*wined3d_texture);
5002     ID3D10Texture2D_Release(&texture->ID3D10Texture2D_iface);
5003
5004     return S_OK;
5005 }
5006
5007 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
5008         struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
5009 {
5010     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
5011     IWineDXGIDevice *wine_device;
5012     HRESULT hr;
5013
5014     TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
5015
5016     if (FAILED(hr = d3d10_device_QueryInterface(&device->ID3D10Device1_iface,
5017             &IID_IWineDXGIDevice, (void **)&wine_device)))
5018     {
5019         ERR("Device should implement IWineDXGIDevice.\n");
5020         return E_FAIL;
5021     }
5022
5023     hr = IWineDXGIDevice_create_swapchain(wine_device, desc, swapchain);
5024     IWineDXGIDevice_Release(wine_device);
5025     if (FAILED(hr))
5026     {
5027         ERR("Failed to create DXGI swapchain, returning %#x\n", hr);
5028         return hr;
5029     }
5030
5031     return S_OK;
5032 }
5033
5034 static const struct wined3d_device_parent_ops d3d_wined3d_device_parent_ops =
5035 {
5036     device_parent_wined3d_device_created,
5037     device_parent_mode_changed,
5038     device_parent_activate,
5039     device_parent_sub_resource_created,
5040     device_parent_sub_resource_created,
5041     device_parent_create_swapchain_texture,
5042     device_parent_create_swapchain,
5043 };
5044
5045 static void *d3d_rb_alloc(size_t size)
5046 {
5047     return HeapAlloc(GetProcessHeap(), 0, size);
5048 }
5049
5050 static void *d3d_rb_realloc(void *ptr, size_t size)
5051 {
5052     return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
5053 }
5054
5055 static void d3d_rb_free(void *ptr)
5056 {
5057     HeapFree(GetProcessHeap(), 0, ptr);
5058 }
5059
5060 static int d3d_sampler_state_compare(const void *key, const struct wine_rb_entry *entry)
5061 {
5062     const D3D11_SAMPLER_DESC *ka = key;
5063     const D3D11_SAMPLER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_sampler_state, entry)->desc;
5064
5065     return memcmp(ka, kb, sizeof(*ka));
5066 }
5067
5068 static const struct wine_rb_functions d3d_sampler_state_rb_ops =
5069 {
5070     d3d_rb_alloc,
5071     d3d_rb_realloc,
5072     d3d_rb_free,
5073     d3d_sampler_state_compare,
5074 };
5075
5076 static int d3d_blend_state_compare(const void *key, const struct wine_rb_entry *entry)
5077 {
5078     const D3D11_BLEND_DESC *ka = key;
5079     const D3D11_BLEND_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_blend_state, entry)->desc;
5080
5081     return memcmp(ka, kb, sizeof(*ka));
5082 }
5083
5084 static const struct wine_rb_functions d3d_blend_state_rb_ops =
5085 {
5086     d3d_rb_alloc,
5087     d3d_rb_realloc,
5088     d3d_rb_free,
5089     d3d_blend_state_compare,
5090 };
5091
5092 static int d3d_depthstencil_state_compare(const void *key, const struct wine_rb_entry *entry)
5093 {
5094     const D3D11_DEPTH_STENCIL_DESC *ka = key;
5095     const D3D11_DEPTH_STENCIL_DESC *kb = &WINE_RB_ENTRY_VALUE(entry,
5096             const struct d3d_depthstencil_state, entry)->desc;
5097
5098     return memcmp(ka, kb, sizeof(*ka));
5099 }
5100
5101 static const struct wine_rb_functions d3d_depthstencil_state_rb_ops =
5102 {
5103     d3d_rb_alloc,
5104     d3d_rb_realloc,
5105     d3d_rb_free,
5106     d3d_depthstencil_state_compare,
5107 };
5108
5109 static int d3d_rasterizer_state_compare(const void *key, const struct wine_rb_entry *entry)
5110 {
5111     const D3D11_RASTERIZER_DESC *ka = key;
5112     const D3D11_RASTERIZER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_rasterizer_state, entry)->desc;
5113
5114     return memcmp(ka, kb, sizeof(*ka));
5115 }
5116
5117 static const struct wine_rb_functions d3d_rasterizer_state_rb_ops =
5118 {
5119     d3d_rb_alloc,
5120     d3d_rb_realloc,
5121     d3d_rb_free,
5122     d3d_rasterizer_state_compare,
5123 };
5124
5125 HRESULT d3d_device_init(struct d3d_device *device, void *outer_unknown)
5126 {
5127     device->IUnknown_inner.lpVtbl = &d3d_device_inner_unknown_vtbl;
5128     device->ID3D11Device_iface.lpVtbl = &d3d11_device_vtbl;
5129     device->ID3D10Device1_iface.lpVtbl = &d3d10_device1_vtbl;
5130     device->ID3D10Multithread_iface.lpVtbl = &d3d10_multithread_vtbl;
5131     device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d_dxgi_device_parent_vtbl;
5132     device->device_parent.ops = &d3d_wined3d_device_parent_ops;
5133     device->refcount = 1;
5134     /* COM aggregation always takes place */
5135     device->outer_unk = outer_unknown;
5136
5137     d3d11_immediate_context_init(&device->immediate_context, device);
5138     ID3D11DeviceContext_Release(&device->immediate_context.ID3D11DeviceContext_iface);
5139
5140     if (wine_rb_init(&device->blend_states, &d3d_blend_state_rb_ops) == -1)
5141     {
5142         WARN("Failed to initialize blend state rbtree.\n");
5143         return E_FAIL;
5144     }
5145     device->blend_factor[0] = 1.0f;
5146     device->blend_factor[1] = 1.0f;
5147     device->blend_factor[2] = 1.0f;
5148     device->blend_factor[3] = 1.0f;
5149
5150     if (wine_rb_init(&device->depthstencil_states, &d3d_depthstencil_state_rb_ops) == -1)
5151     {
5152         WARN("Failed to initialize depthstencil state rbtree.\n");
5153         wine_rb_destroy(&device->blend_states, NULL, NULL);
5154         return E_FAIL;
5155     }
5156
5157     if (wine_rb_init(&device->rasterizer_states, &d3d_rasterizer_state_rb_ops) == -1)
5158     {
5159         WARN("Failed to initialize rasterizer state rbtree.\n");
5160         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
5161         wine_rb_destroy(&device->blend_states, NULL, NULL);
5162         return E_FAIL;
5163     }
5164
5165     if (wine_rb_init(&device->sampler_states, &d3d_sampler_state_rb_ops) == -1)
5166     {
5167         WARN("Failed to initialize sampler state rbtree.\n");
5168         wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
5169         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
5170         wine_rb_destroy(&device->blend_states, NULL, NULL);
5171         return E_FAIL;
5172     }
5173
5174     return S_OK;
5175 }