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 d3d10_null_wined3d_object_destroyed(void *parent) {}
  29
  30 const struct wined3d_parent_ops d3d10_null_wined3d_parent_ops =
  31 {
  32     d3d10_null_wined3d_object_destroyed,
  33 };
  34
  35 /* ID3D11Device methods */
  36
  37 static inline struct d3d_device *impl_from_ID3D11Device(ID3D11Device *iface)
  38 {
  39     return CONTAINING_RECORD(iface, struct d3d_device, ID3D11Device_iface);
  40 }
  41
  42 static HRESULT STDMETHODCALLTYPE d3d11_device_QueryInterface(ID3D11Device *iface, REFIID riid, void **out)
  43 {
  44     struct d3d_device *device = impl_from_ID3D11Device(iface);
  45     return IUnknown_QueryInterface(device->outer_unk, riid, out);
  46 }
  47
  48 static ULONG STDMETHODCALLTYPE d3d11_device_AddRef(ID3D11Device *iface)
  49 {
  50     struct d3d_device *device = impl_from_ID3D11Device(iface);
  51     return IUnknown_AddRef(device->outer_unk);
  52 }
  53
  54 static ULONG STDMETHODCALLTYPE d3d11_device_Release(ID3D11Device *iface)
  55 {
  56     struct d3d_device *device = impl_from_ID3D11Device(iface);
  57     return IUnknown_Release(device->outer_unk);
  58 }
  59
  60 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBuffer(ID3D11Device *iface, const D3D11_BUFFER_DESC *desc,
  61         const D3D11_SUBRESOURCE_DATA *data, ID3D11Buffer **buffer)
  62 {
  63     struct d3d_device *device = impl_from_ID3D11Device(iface);
  64     struct d3d_buffer *object;
  65     HRESULT hr;
  66
  67     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
  68
  69     if (FAILED(hr = d3d_buffer_create(device, desc, data, &object)))
  70         return hr;
  71
  72     *buffer = &object->ID3D11Buffer_iface;
  73
  74     return S_OK;
  75 }
  76
  77 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture1D(ID3D11Device *iface,
  78         const D3D11_TEXTURE1D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture1D **texture)
  79 {
  80     FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
  81
  82     return E_NOTIMPL;
  83 }
  84
  85 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture2D(ID3D11Device *iface,
  86         const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture2D **texture)
  87 {
  88     struct d3d_device *device = impl_from_ID3D11Device(iface);
  89     struct d3d_texture2d *object;
  90     HRESULT hr;
  91
  92     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
  93
  94     if (FAILED(hr = d3d_texture2d_create(device, desc, data, &object)))
  95         return hr;
  96
  97     *texture = &object->ID3D11Texture2D_iface;
  98
  99     return S_OK;
 100 }
 101
 102 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture3D(ID3D11Device *iface,
 103         const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture3D **texture)
 104 {
 105     struct d3d_device *device = impl_from_ID3D11Device(iface);
 106     struct d3d_texture3d *object;
 107     HRESULT hr;
 108
 109     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
 110
 111     if (FAILED(hr = d3d_texture3d_create(device, desc, data, &object)))
 112         return hr;
 113
 114     *texture = &object->ID3D11Texture3D_iface;
 115
 116     return S_OK;
 117 }
 118
 119 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateShaderResourceView(ID3D11Device *iface,
 120         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11ShaderResourceView **view)
 121 {
 122     FIXME("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
 123
 124     return E_NOTIMPL;
 125 }
 126
 127 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateUnorderedAccessView(ID3D11Device *iface,
 128         ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11UnorderedAccessView **view)
 129 {
 130     FIXME("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
 131
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRenderTargetView(ID3D11Device *iface,
 136         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11RenderTargetView **view)
 137 {
 138     FIXME("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
 139
 140     return E_NOTIMPL;
 141 }
 142
 143 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilView(ID3D11Device *iface,
 144         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11DepthStencilView **view)
 145 {
 146     struct d3d_device *device = impl_from_ID3D11Device(iface);
 147     struct d3d_depthstencil_view *object;
 148     HRESULT hr;
 149
 150     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
 151
 152     if (FAILED(hr = d3d_depthstencil_view_create(device, resource, desc, &object)))
 153         return hr;
 154
 155     *view = &object->ID3D11DepthStencilView_iface;
 156
 157     return S_OK;
 158 }
 159
 160 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateInputLayout(ID3D11Device *iface,
 161         const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count, const void *shader_byte_code,
 162         SIZE_T shader_byte_code_length, ID3D11InputLayout **input_layout)
 163 {
 164     FIXME("iface %p, element_descs %p, element_count %u, shader_byte_code %p, shader_byte_code_length %lu, "
 165             "input_layout %p stub!\n", iface, element_descs, element_count, shader_byte_code,
 166             shader_byte_code_length, input_layout);
 167
 168     return E_NOTIMPL;
 169 }
 170
 171 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateVertexShader(ID3D11Device *iface, const void *byte_code,
 172         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11VertexShader **shader)
 173 {
 174     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
 175             iface, byte_code, byte_code_length, class_linkage, shader);
 176
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShader(ID3D11Device *iface, const void *byte_code,
 181         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
 182 {
 183     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
 184             iface, byte_code, byte_code_length, class_linkage, shader);
 185
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShaderWithStreamOutput(ID3D11Device *iface,
 190         const void *byte_code, SIZE_T byte_code_length, const D3D11_SO_DECLARATION_ENTRY *so_entries,
 191         UINT entry_count, const UINT *buffer_strides, UINT strides_count, UINT rasterized_stream,
 192         ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
 193 {
 194     FIXME("iface %p, byte_code %p, byte_code_length %lu, so_entries %p, entry_count %u, "
 195             "buffer_strides %p, strides_count %u, rasterized_stream %u, class_linkage %p, shader %p stub!\n",
 196             iface, byte_code, byte_code_length, so_entries, entry_count, buffer_strides, strides_count,
 197             rasterized_stream, class_linkage, shader);
 198
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePixelShader(ID3D11Device *iface, const void *byte_code,
 203         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11PixelShader **shader)
 204 {
 205     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
 206             iface, byte_code, byte_code_length, class_linkage, shader);
 207
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateHullShader(ID3D11Device *iface, const void *byte_code,
 212         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11HullShader **shader)
 213 {
 214     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
 215             iface, byte_code, byte_code_length, class_linkage, shader);
 216
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDomainShader(ID3D11Device *iface, const void *byte_code,
 221         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11DomainShader **shader)
 222 {
 223     FIXME("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p stub!\n",
 224             iface, byte_code, byte_code_length, class_linkage, shader);
 225
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateComputeShader(ID3D11Device *iface, const void *byte_code,
 230         SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11ComputeShader **shader)
 231 {
 232     FIXME("iface %p, byte_code %p, byte_code_lenghth %lu, class_linkage %p, shader %p stub!\n",
 233             iface, byte_code, byte_code_length, class_linkage, shader);
 234
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateClassLinkage(ID3D11Device *iface,
 239         ID3D11ClassLinkage **class_linkage)
 240 {
 241     FIXME("iface %p, class_linkage %p stub!\n", iface, class_linkage);
 242
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBlendState(ID3D11Device *iface,
 247         const D3D11_BLEND_DESC *desc, ID3D11BlendState **blend_state)
 248 {
 249     FIXME("iface %p, desc %p, blend_state %p stub!\n", iface, desc, blend_state);
 250
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilState(ID3D11Device *iface,
 255         const D3D11_DEPTH_STENCIL_DESC *desc, ID3D11DepthStencilState **depth_stencil_state)
 256 {
 257     FIXME("iface %p, desc %p, depth_stencil_state %p stub!\n", iface, desc, depth_stencil_state);
 258
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device *iface,
 263         const D3D11_RASTERIZER_DESC *desc, ID3D11RasterizerState **rasterizer_state)
 264 {
 265     FIXME("iface %p, desc %p, rasterizer_state %p stub!\n", iface, desc, rasterizer_state);
 266
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateSamplerState(ID3D11Device *iface,
 271         const D3D11_SAMPLER_DESC *desc, ID3D11SamplerState **sampler_state)
 272 {
 273     FIXME("iface %p, desc %p, sampler_state %p stub!\n", iface, desc, sampler_state);
 274
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateQuery(ID3D11Device *iface,
 279     const D3D11_QUERY_DESC *desc, ID3D11Query **query)
 280 {
 281     FIXME("iface %p, desc %p, query %p stub!\n", iface, desc, query);
 282
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePredicate(ID3D11Device *iface, const D3D11_QUERY_DESC *desc,
 287         ID3D11Predicate **predicate)
 288 {
 289     FIXME("iface %p, desc %p, predicate %p stub!\n", iface, desc, predicate);
 290
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
 295         ID3D11Counter **counter)
 296 {
 297     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
 298
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext(ID3D11Device *iface, UINT flags,
 303         ID3D11DeviceContext **context)
 304 {
 305     FIXME("iface %p, flags %#x, context %p stub!\n", iface, flags, context);
 306
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource(ID3D11Device *iface, HANDLE resource, REFIID riid,
 311         void **out)
 312 {
 313     FIXME("iface %p, resource %p, riid %s, out %p stub!\n", iface, resource, debugstr_guid(riid), out);
 314
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device *iface, DXGI_FORMAT format,
 319         UINT *format_support)
 320 {
 321     FIXME("iface %p, format %u, format_support %p stub!\n", iface, format, format_support);
 322
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckMultisampleQualityLevels(ID3D11Device *iface,
 327         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
 328 {
 329     FIXME("iface %p, format %u, sample_count %u, quality_level_count %p stub!\n",
 330             iface, format, sample_count, quality_level_count);
 331
 332     return E_NOTIMPL;
 333 }
 334
 335 static void STDMETHODCALLTYPE d3d11_device_CheckCounterInfo(ID3D11Device *iface, D3D11_COUNTER_INFO *info)
 336 {
 337     FIXME("iface %p, info %p stub!\n", iface, info);
 338 }
 339
 340 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
 341         D3D11_COUNTER_TYPE *type, UINT *active_counter_count, char *name, UINT *name_length,
 342         char *units, UINT *units_length, char *description, UINT *description_length)
 343 {
 344     FIXME("iface %p, desc %p, type %p, active_counter_count %p, name %p, name_length %p, "
 345             "units %p, units_length %p, description %p, description_length %p stub!\n",
 346             iface, desc, type, active_counter_count, name, name_length,
 347             units, units_length, description, description_length);
 348
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFeatureSupport(ID3D11Device *iface, D3D11_FEATURE feature,
 353         void *feature_support_data, UINT feature_support_data_size)
 354 {
 355     FIXME("iface %p, feature %u, feature_support_data %p, feature_support_data_size %u stub!\n",
 356             iface, feature, feature_support_data, feature_support_data_size);
 357
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT STDMETHODCALLTYPE d3d11_device_GetPrivateData(ID3D11Device *iface, REFGUID guid,
 362         UINT *data_size, void *data)
 363 {
 364     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateData(ID3D11Device *iface, REFGUID guid,
 370         UINT data_size, const void *data)
 371 {
 372     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data);
 373
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateDataInterface(ID3D11Device *iface, REFGUID guid,
 378         const IUnknown *data_iface)
 379 {
 380     FIXME("iface %p, guid %s, data_iface %p stub!\n", iface, debugstr_guid(guid), data_iface);
 381
 382     return E_NOTIMPL;
 383 }
 384
 385 static D3D_FEATURE_LEVEL STDMETHODCALLTYPE d3d11_device_GetFeatureLevel(ID3D11Device *iface)
 386 {
 387     FIXME("iface %p stub!\n", iface);
 388
 389     return D3D_FEATURE_LEVEL_10_0;
 390 }
 391
 392 static UINT STDMETHODCALLTYPE d3d11_device_GetCreationFlags(ID3D11Device *iface)
 393 {
 394     FIXME("iface %p stub!\n", iface);
 395
 396     return 0;
 397 }
 398
 399 static HRESULT STDMETHODCALLTYPE d3d11_device_GetDeviceRemovedReason(ID3D11Device *iface)
 400 {
 401     FIXME("iface %p stub!\n", iface);
 402
 403     return S_OK;
 404 }
 405
 406 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext(ID3D11Device *iface,
 407         ID3D11DeviceContext **immediate_context)
 408 {
 409     FIXME("iface %p, immediate_context %p stub!\n", iface, immediate_context);
 410 }
 411
 412 static HRESULT STDMETHODCALLTYPE d3d11_device_SetExceptionMode(ID3D11Device *iface, UINT flags)
 413 {
 414     FIXME("iface %p, flags %#x stub!\n", iface, flags);
 415
 416     return E_NOTIMPL;
 417 }
 418
 419 static UINT STDMETHODCALLTYPE d3d11_device_GetExceptionMode(ID3D11Device *iface)
 420 {
 421     FIXME("iface %p stub!\n", iface);
 422
 423     return 0;
 424 }
 425
 426 static const struct ID3D11DeviceVtbl d3d11_device_vtbl =
 427 {
 428     /* IUnknown methods */
 429     d3d11_device_QueryInterface,
 430     d3d11_device_AddRef,
 431     d3d11_device_Release,
 432     /* ID3D11Device methods */
 433     d3d11_device_CreateBuffer,
 434     d3d11_device_CreateTexture1D,
 435     d3d11_device_CreateTexture2D,
 436     d3d11_device_CreateTexture3D,
 437     d3d11_device_CreateShaderResourceView,
 438     d3d11_device_CreateUnorderedAccessView,
 439     d3d11_device_CreateRenderTargetView,
 440     d3d11_device_CreateDepthStencilView,
 441     d3d11_device_CreateInputLayout,
 442     d3d11_device_CreateVertexShader,
 443     d3d11_device_CreateGeometryShader,
 444     d3d11_device_CreateGeometryShaderWithStreamOutput,
 445     d3d11_device_CreatePixelShader,
 446     d3d11_device_CreateHullShader,
 447     d3d11_device_CreateDomainShader,
 448     d3d11_device_CreateComputeShader,
 449     d3d11_device_CreateClassLinkage,
 450     d3d11_device_CreateBlendState,
 451     d3d11_device_CreateDepthStencilState,
 452     d3d11_device_CreateRasterizerState,
 453     d3d11_device_CreateSamplerState,
 454     d3d11_device_CreateQuery,
 455     d3d11_device_CreatePredicate,
 456     d3d11_device_CreateCounter,
 457     d3d11_device_CreateDeferredContext,
 458     d3d11_device_OpenSharedResource,
 459     d3d11_device_CheckFormatSupport,
 460     d3d11_device_CheckMultisampleQualityLevels,
 461     d3d11_device_CheckCounterInfo,
 462     d3d11_device_CheckCounter,
 463     d3d11_device_CheckFeatureSupport,
 464     d3d11_device_GetPrivateData,
 465     d3d11_device_SetPrivateData,
 466     d3d11_device_SetPrivateDataInterface,
 467     d3d11_device_GetFeatureLevel,
 468     d3d11_device_GetCreationFlags,
 469     d3d11_device_GetDeviceRemovedReason,
 470     d3d11_device_GetImmediateContext,
 471     d3d11_device_SetExceptionMode,
 472     d3d11_device_GetExceptionMode,
 473 };
 474
 475 /* Inner IUnknown methods */
 476
 477 static inline struct d3d_device *impl_from_IUnknown(IUnknown *iface)
 478 {
 479     return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
 480 }
 481
 482 static HRESULT STDMETHODCALLTYPE d3d10_device_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out)
 483 {
 484     struct d3d_device *device = impl_from_IUnknown(iface);
 485
 486     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 487
 488     if (IsEqualGUID(riid, &IID_ID3D11Device)
 489             || IsEqualGUID(riid, &IID_IUnknown))
 490     {
 491         *out = &device->ID3D11Device_iface;
 492     }
 493     else if (IsEqualGUID(riid, &IID_ID3D10Device1)
 494             || IsEqualGUID(riid, &IID_ID3D10Device))
 495     {
 496         *out = &device->ID3D10Device1_iface;
 497     }
 498     else if (IsEqualGUID(riid, &IID_ID3D10Multithread))
 499     {
 500         *out = &device->ID3D10Multithread_iface;
 501     }
 502     else if (IsEqualGUID(riid, &IID_IWineDXGIDeviceParent))
 503     {
 504         *out = &device->IWineDXGIDeviceParent_iface;
 505     }
 506     else
 507     {
 508         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 509         *out = NULL;
 510         return E_NOINTERFACE;
 511     }
 512
 513     IUnknown_AddRef((IUnknown *)*out);
 514     return S_OK;
 515 }
 516
 517 static ULONG STDMETHODCALLTYPE d3d10_device_inner_AddRef(IUnknown *iface)
 518 {
 519     struct d3d_device *This = impl_from_IUnknown(iface);
 520     ULONG refcount = InterlockedIncrement(&This->refcount);
 521
 522     TRACE("%p increasing refcount to %u\n", This, refcount);
 523
 524     return refcount;
 525 }
 526
 527 static ULONG STDMETHODCALLTYPE d3d10_device_inner_Release(IUnknown *iface)
 528 {
 529     struct d3d_device *device = impl_from_IUnknown(iface);
 530     ULONG refcount = InterlockedDecrement(&device->refcount);
 531
 532     TRACE("%p decreasing refcount to %u.\n", device, refcount);
 533
 534     if (!refcount)
 535     {
 536         if (device->wined3d_device)
 537         {
 538             wined3d_mutex_lock();
 539             wined3d_device_decref(device->wined3d_device);
 540             wined3d_mutex_unlock();
 541         }
 542         wine_rb_destroy(&device->sampler_states, NULL, NULL);
 543         wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
 544         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
 545         wine_rb_destroy(&device->blend_states, NULL, NULL);
 546     }
 547
 548     return refcount;
 549 }
 550
 551 /* IUnknown methods */
 552
 553 static HRESULT STDMETHODCALLTYPE d3d10_device_QueryInterface(ID3D10Device1 *iface, REFIID riid,
 554         void **ppv)
 555 {
 556     struct d3d_device *This = impl_from_ID3D10Device(iface);
 557     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 558 }
 559
 560 static ULONG STDMETHODCALLTYPE d3d10_device_AddRef(ID3D10Device1 *iface)
 561 {
 562     struct d3d_device *This = impl_from_ID3D10Device(iface);
 563     return IUnknown_AddRef(This->outer_unk);
 564 }
 565
 566 static ULONG STDMETHODCALLTYPE d3d10_device_Release(ID3D10Device1 *iface)
 567 {
 568     struct d3d_device *This = impl_from_ID3D10Device(iface);
 569     return IUnknown_Release(This->outer_unk);
 570 }
 571
 572 /* ID3D10Device methods */
 573
 574 static void STDMETHODCALLTYPE d3d10_device_VSSetConstantBuffers(ID3D10Device1 *iface,
 575         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 576 {
 577     struct d3d_device *device = impl_from_ID3D10Device(iface);
 578     unsigned int i;
 579
 580     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 581             iface, start_slot, buffer_count, buffers);
 582
 583     wined3d_mutex_lock();
 584     for (i = 0; i < buffer_count; ++i)
 585     {
 586         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 587
 588         wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
 589                 buffer ? buffer->wined3d_buffer : NULL);
 590     }
 591     wined3d_mutex_unlock();
 592 }
 593
 594 static void STDMETHODCALLTYPE d3d10_device_PSSetShaderResources(ID3D10Device1 *iface,
 595         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 596 {
 597     struct d3d_device *device = impl_from_ID3D10Device(iface);
 598     unsigned int i;
 599
 600     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
 601             iface, start_slot, view_count, views);
 602
 603     wined3d_mutex_lock();
 604     for (i = 0; i < view_count; ++i)
 605     {
 606         struct d3d10_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
 607
 608         wined3d_device_set_ps_resource_view(device->wined3d_device, start_slot + i,
 609                 view ? view->wined3d_view : NULL);
 610     }
 611     wined3d_mutex_unlock();
 612 }
 613
 614 static void STDMETHODCALLTYPE d3d10_device_PSSetShader(ID3D10Device1 *iface,
 615         ID3D10PixelShader *shader)
 616 {
 617     struct d3d_device *This = impl_from_ID3D10Device(iface);
 618     struct d3d10_pixel_shader *ps = unsafe_impl_from_ID3D10PixelShader(shader);
 619
 620     TRACE("iface %p, shader %p\n", iface, shader);
 621
 622     wined3d_mutex_lock();
 623     wined3d_device_set_pixel_shader(This->wined3d_device, ps ? ps->wined3d_shader : NULL);
 624     wined3d_mutex_unlock();
 625 }
 626
 627 static void STDMETHODCALLTYPE d3d10_device_PSSetSamplers(ID3D10Device1 *iface,
 628         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 629 {
 630     struct d3d_device *device = impl_from_ID3D10Device(iface);
 631     unsigned int i;
 632
 633     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 634             iface, start_slot, sampler_count, samplers);
 635
 636     wined3d_mutex_lock();
 637     for (i = 0; i < sampler_count; ++i)
 638     {
 639         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 640
 641         wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
 642                 sampler ? sampler->wined3d_sampler : NULL);
 643     }
 644     wined3d_mutex_unlock();
 645 }
 646
 647 static void STDMETHODCALLTYPE d3d10_device_VSSetShader(ID3D10Device1 *iface,
 648         ID3D10VertexShader *shader)
 649 {
 650     struct d3d_device *This = impl_from_ID3D10Device(iface);
 651     struct d3d10_vertex_shader *vs = unsafe_impl_from_ID3D10VertexShader(shader);
 652
 653     TRACE("iface %p, shader %p\n", iface, shader);
 654
 655     wined3d_mutex_lock();
 656     wined3d_device_set_vertex_shader(This->wined3d_device, vs ? vs->wined3d_shader : NULL);
 657     wined3d_mutex_unlock();
 658 }
 659
 660 static void STDMETHODCALLTYPE d3d10_device_DrawIndexed(ID3D10Device1 *iface, UINT index_count,
 661         UINT start_index_location, INT base_vertex_location)
 662 {
 663     struct d3d_device *This = impl_from_ID3D10Device(iface);
 664
 665     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
 666             iface, index_count, start_index_location, base_vertex_location);
 667
 668     wined3d_mutex_lock();
 669     wined3d_device_set_base_vertex_index(This->wined3d_device, base_vertex_location);
 670     wined3d_device_draw_indexed_primitive(This->wined3d_device, start_index_location, index_count);
 671     wined3d_mutex_unlock();
 672 }
 673
 674 static void STDMETHODCALLTYPE d3d10_device_Draw(ID3D10Device1 *iface, UINT vertex_count,
 675         UINT start_vertex_location)
 676 {
 677     struct d3d_device *This = impl_from_ID3D10Device(iface);
 678
 679     TRACE("iface %p, vertex_count %u, start_vertex_location %u\n",
 680             iface, vertex_count, start_vertex_location);
 681
 682     wined3d_mutex_lock();
 683     wined3d_device_draw_primitive(This->wined3d_device, start_vertex_location, vertex_count);
 684     wined3d_mutex_unlock();
 685 }
 686
 687 static void STDMETHODCALLTYPE d3d10_device_PSSetConstantBuffers(ID3D10Device1 *iface,
 688         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 689 {
 690     struct d3d_device *device = impl_from_ID3D10Device(iface);
 691     unsigned int i;
 692
 693     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 694             iface, start_slot, buffer_count, buffers);
 695
 696     wined3d_mutex_lock();
 697     for (i = 0; i < buffer_count; ++i)
 698     {
 699         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 700
 701         wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
 702                 buffer ? buffer->wined3d_buffer : NULL);
 703     }
 704     wined3d_mutex_unlock();
 705 }
 706
 707 static void STDMETHODCALLTYPE d3d10_device_IASetInputLayout(ID3D10Device1 *iface,
 708         ID3D10InputLayout *input_layout)
 709 {
 710     struct d3d_device *This = impl_from_ID3D10Device(iface);
 711     struct d3d10_input_layout *layout = unsafe_impl_from_ID3D10InputLayout(input_layout);
 712
 713     TRACE("iface %p, input_layout %p\n", iface, input_layout);
 714
 715     wined3d_mutex_lock();
 716     wined3d_device_set_vertex_declaration(This->wined3d_device,
 717             layout ? layout->wined3d_decl : NULL);
 718     wined3d_mutex_unlock();
 719 }
 720
 721 static void STDMETHODCALLTYPE d3d10_device_IASetVertexBuffers(ID3D10Device1 *iface, UINT start_slot,
 722         UINT buffer_count, ID3D10Buffer *const *buffers, const UINT *strides, const UINT *offsets)
 723 {
 724     struct d3d_device *This = impl_from_ID3D10Device(iface);
 725     unsigned int i;
 726
 727     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p\n",
 728             iface, start_slot, buffer_count, buffers, strides, offsets);
 729
 730     wined3d_mutex_lock();
 731     for (i = 0; i < buffer_count; ++i)
 732     {
 733         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 734
 735         wined3d_device_set_stream_source(This->wined3d_device, start_slot + i,
 736                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
 737     }
 738     wined3d_mutex_unlock();
 739 }
 740
 741 static void STDMETHODCALLTYPE d3d10_device_IASetIndexBuffer(ID3D10Device1 *iface,
 742         ID3D10Buffer *buffer, DXGI_FORMAT format, UINT offset)
 743 {
 744     struct d3d_device *This = impl_from_ID3D10Device(iface);
 745     struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D10Buffer(buffer);
 746
 747     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
 748             iface, buffer, debug_dxgi_format(format), offset);
 749
 750     wined3d_mutex_lock();
 751     wined3d_device_set_index_buffer(This->wined3d_device,
 752             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
 753             wined3dformat_from_dxgi_format(format));
 754     wined3d_mutex_unlock();
 755     if (offset) FIXME("offset %u not supported.\n", offset);
 756 }
 757
 758 static void STDMETHODCALLTYPE d3d10_device_DrawIndexedInstanced(ID3D10Device1 *iface,
 759         UINT instance_index_count, UINT instance_count, UINT start_index_location,
 760         INT base_vertex_location, UINT start_instance_location)
 761 {
 762     struct d3d_device *device = impl_from_ID3D10Device(iface);
 763
 764     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
 765             "base_vertex_location %d, start_instance_location %u.\n",
 766             iface, instance_index_count, instance_count, start_index_location,
 767             base_vertex_location, start_instance_location);
 768
 769     wined3d_mutex_lock();
 770     wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
 771     wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
 772             instance_index_count, start_instance_location, instance_count);
 773     wined3d_mutex_unlock();
 774 }
 775
 776 static void STDMETHODCALLTYPE d3d10_device_DrawInstanced(ID3D10Device1 *iface,
 777         UINT instance_vertex_count, UINT instance_count,
 778         UINT start_vertex_location, UINT start_instance_location)
 779 {
 780     struct d3d_device *device = impl_from_ID3D10Device(iface);
 781
 782     TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
 783             "start_instance_location %u.\n", iface, instance_vertex_count, instance_count,
 784             start_vertex_location, start_instance_location);
 785
 786     wined3d_mutex_lock();
 787     wined3d_device_draw_primitive_instanced(device->wined3d_device, start_vertex_location,
 788             instance_vertex_count, start_instance_location, instance_count);
 789     wined3d_mutex_unlock();
 790 }
 791
 792 static void STDMETHODCALLTYPE d3d10_device_GSSetConstantBuffers(ID3D10Device1 *iface,
 793         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 794 {
 795     struct d3d_device *device = impl_from_ID3D10Device(iface);
 796     unsigned int i;
 797
 798     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 799             iface, start_slot, buffer_count, buffers);
 800
 801     wined3d_mutex_lock();
 802     for (i = 0; i < buffer_count; ++i)
 803     {
 804         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 805
 806         wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
 807                 buffer ? buffer->wined3d_buffer : NULL);
 808     }
 809     wined3d_mutex_unlock();
 810 }
 811
 812 static void STDMETHODCALLTYPE d3d10_device_GSSetShader(ID3D10Device1 *iface, ID3D10GeometryShader *shader)
 813 {
 814     struct d3d_device *device = impl_from_ID3D10Device(iface);
 815     struct d3d10_geometry_shader *gs = unsafe_impl_from_ID3D10GeometryShader(shader);
 816
 817     TRACE("iface %p, shader %p.\n", iface, shader);
 818
 819     wined3d_mutex_lock();
 820     wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
 821     wined3d_mutex_unlock();
 822 }
 823
 824 static void STDMETHODCALLTYPE d3d10_device_IASetPrimitiveTopology(ID3D10Device1 *iface,
 825         D3D10_PRIMITIVE_TOPOLOGY topology)
 826 {
 827     struct d3d_device *This = impl_from_ID3D10Device(iface);
 828
 829     TRACE("iface %p, topology %s\n", iface, debug_d3d10_primitive_topology(topology));
 830
 831     wined3d_mutex_lock();
 832     wined3d_device_set_primitive_type(This->wined3d_device, (enum wined3d_primitive_type)topology);
 833     wined3d_mutex_unlock();
 834 }
 835
 836 static void STDMETHODCALLTYPE d3d10_device_VSSetShaderResources(ID3D10Device1 *iface,
 837         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 838 {
 839     struct d3d_device *device = impl_from_ID3D10Device(iface);
 840     unsigned int i;
 841
 842     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
 843             iface, start_slot, view_count, views);
 844
 845     wined3d_mutex_lock();
 846     for (i = 0; i < view_count; ++i)
 847     {
 848         struct d3d10_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
 849
 850         wined3d_device_set_vs_resource_view(device->wined3d_device, start_slot + i,
 851                 view ? view->wined3d_view : NULL);
 852     }
 853     wined3d_mutex_unlock();
 854 }
 855
 856 static void STDMETHODCALLTYPE d3d10_device_VSSetSamplers(ID3D10Device1 *iface,
 857         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 858 {
 859     struct d3d_device *device = impl_from_ID3D10Device(iface);
 860     unsigned int i;
 861
 862     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 863             iface, start_slot, sampler_count, samplers);
 864
 865     wined3d_mutex_lock();
 866     for (i = 0; i < sampler_count; ++i)
 867     {
 868         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 869
 870         wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
 871                 sampler ? sampler->wined3d_sampler : NULL);
 872     }
 873     wined3d_mutex_unlock();
 874 }
 875
 876 static void STDMETHODCALLTYPE d3d10_device_SetPredication(ID3D10Device1 *iface, ID3D10Predicate *predicate, BOOL value)
 877 {
 878     struct d3d_device *device = impl_from_ID3D10Device(iface);
 879     struct d3d10_query *query;
 880
 881     TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
 882
 883     query = unsafe_impl_from_ID3D10Query((ID3D10Query *)predicate);
 884     wined3d_mutex_lock();
 885     wined3d_device_set_predication(device->wined3d_device, query ? query->wined3d_query : NULL, value);
 886     wined3d_mutex_unlock();
 887 }
 888
 889 static void STDMETHODCALLTYPE d3d10_device_GSSetShaderResources(ID3D10Device1 *iface,
 890         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 891 {
 892     struct d3d_device *device = impl_from_ID3D10Device(iface);
 893     unsigned int i;
 894
 895     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
 896             iface, start_slot, view_count, views);
 897
 898     wined3d_mutex_lock();
 899     for (i = 0; i < view_count; ++i)
 900     {
 901         struct d3d10_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
 902
 903         wined3d_device_set_gs_resource_view(device->wined3d_device, start_slot + i,
 904                 view ? view->wined3d_view : NULL);
 905     }
 906     wined3d_mutex_unlock();
 907 }
 908
 909 static void STDMETHODCALLTYPE d3d10_device_GSSetSamplers(ID3D10Device1 *iface,
 910         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 911 {
 912     struct d3d_device *device = impl_from_ID3D10Device(iface);
 913     unsigned int i;
 914
 915     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 916             iface, start_slot, sampler_count, samplers);
 917
 918     wined3d_mutex_lock();
 919     for (i = 0; i < sampler_count; ++i)
 920     {
 921         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 922
 923         wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
 924                 sampler ? sampler->wined3d_sampler : NULL);
 925     }
 926     wined3d_mutex_unlock();
 927 }
 928
 929 static void STDMETHODCALLTYPE d3d10_device_OMSetRenderTargets(ID3D10Device1 *iface,
 930         UINT render_target_view_count, ID3D10RenderTargetView *const *render_target_views,
 931         ID3D10DepthStencilView *depth_stencil_view)
 932 {
 933     struct d3d_device *device = impl_from_ID3D10Device(iface);
 934     struct d3d_depthstencil_view *dsv;
 935     unsigned int i;
 936
 937     TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
 938             iface, render_target_view_count, render_target_views, depth_stencil_view);
 939
 940     wined3d_mutex_lock();
 941     for (i = 0; i < render_target_view_count; ++i)
 942     {
 943         struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D10RenderTargetView(render_target_views[i]);
 944
 945         wined3d_device_set_rendertarget_view(device->wined3d_device, i,
 946                 rtv ? rtv->wined3d_view : NULL, FALSE);
 947     }
 948     for (; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 949     {
 950         wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
 951     }
 952
 953     dsv = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
 954     wined3d_device_set_depth_stencil_view(device->wined3d_device,
 955             dsv ? dsv->wined3d_view : NULL);
 956     wined3d_mutex_unlock();
 957 }
 958
 959 static void STDMETHODCALLTYPE d3d10_device_OMSetBlendState(ID3D10Device1 *iface,
 960         ID3D10BlendState *blend_state, const FLOAT blend_factor[4], UINT sample_mask)
 961 {
 962     struct d3d_device *device = impl_from_ID3D10Device(iface);
 963     const D3D10_BLEND_DESC *desc;
 964
 965     TRACE("iface %p, blend_state %p, blend_factor {%.8e %.8e %.8e %.8e}, sample_mask 0x%08x.\n",
 966             iface, blend_state, blend_factor[0], blend_factor[1], blend_factor[2], blend_factor[3], sample_mask);
 967
 968     if (blend_factor[0] != 1.0f || blend_factor[1] != 1.0f || blend_factor[2] != 1.0f || blend_factor[3] != 1.0f)
 969         FIXME("Ignoring blend factor {%.8e %.8e %.8e %.8e}.\n",
 970                 blend_factor[0], blend_factor[1], blend_factor[2], blend_factor[3]);
 971     wined3d_mutex_lock();
 972     memcpy(device->blend_factor, blend_factor, 4 * sizeof(*blend_factor));
 973     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK, sample_mask);
 974     if (!(device->blend_state = unsafe_impl_from_ID3D10BlendState(blend_state)))
 975     {
 976         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE, FALSE);
 977         wined3d_device_set_render_state(device->wined3d_device,
 978                 WINED3D_RS_COLORWRITEENABLE, D3D10_COLOR_WRITE_ENABLE_ALL);
 979         wined3d_device_set_render_state(device->wined3d_device,
 980                 WINED3D_RS_COLORWRITEENABLE1, D3D10_COLOR_WRITE_ENABLE_ALL);
 981         wined3d_device_set_render_state(device->wined3d_device,
 982                 WINED3D_RS_COLORWRITEENABLE2, D3D10_COLOR_WRITE_ENABLE_ALL);
 983         wined3d_device_set_render_state(device->wined3d_device,
 984                 WINED3D_RS_COLORWRITEENABLE3, D3D10_COLOR_WRITE_ENABLE_ALL);
 985         wined3d_mutex_unlock();
 986         return;
 987     }
 988
 989     desc = &device->blend_state->desc;
 990     /* glSampleCoverage() */
 991     if (desc->AlphaToCoverageEnable)
 992         FIXME("Ignoring AlphaToCoverageEnable %#x.\n", desc->AlphaToCoverageEnable);
 993     /* glEnableIndexedEXT(GL_BLEND, ...) */
 994     FIXME("Per-rendertarget blend enable not implemented.\n");
 995     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE, desc->BlendEnable[0]);
 996     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLEND, desc->SrcBlend);
 997     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLEND, desc->DestBlend);
 998     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOP, desc->BlendOp);
 999     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SEPARATEALPHABLENDENABLE, TRUE);
1000     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLENDALPHA, desc->SrcBlendAlpha);
1001     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLENDALPHA, desc->DestBlendAlpha);
1002     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOPALPHA, desc->BlendOpAlpha);
1003     FIXME("Color mask > 3 not implemented.\n");
1004     wined3d_device_set_render_state(device->wined3d_device,
1005             WINED3D_RS_COLORWRITEENABLE, desc->RenderTargetWriteMask[0]);
1006     wined3d_device_set_render_state(device->wined3d_device,
1007             WINED3D_RS_COLORWRITEENABLE1, desc->RenderTargetWriteMask[1]);
1008     wined3d_device_set_render_state(device->wined3d_device,
1009             WINED3D_RS_COLORWRITEENABLE2, desc->RenderTargetWriteMask[2]);
1010     wined3d_device_set_render_state(device->wined3d_device,
1011             WINED3D_RS_COLORWRITEENABLE3, desc->RenderTargetWriteMask[3]);
1012     wined3d_mutex_unlock();
1013 }
1014
1015 static void STDMETHODCALLTYPE d3d10_device_OMSetDepthStencilState(ID3D10Device1 *iface,
1016         ID3D10DepthStencilState *depth_stencil_state, UINT stencil_ref)
1017 {
1018     struct d3d_device *device = impl_from_ID3D10Device(iface);
1019
1020     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
1021             iface, depth_stencil_state, stencil_ref);
1022
1023     device->depth_stencil_state = unsafe_impl_from_ID3D10DepthStencilState(depth_stencil_state);
1024     device->stencil_ref = stencil_ref;
1025 }
1026
1027 static void STDMETHODCALLTYPE d3d10_device_SOSetTargets(ID3D10Device1 *iface,
1028         UINT target_count, ID3D10Buffer *const *targets, const UINT *offsets)
1029 {
1030     struct d3d_device *device = impl_from_ID3D10Device(iface);
1031     unsigned int count, i;
1032
1033     TRACE("iface %p, target_count %u, targets %p, offsets %p.\n", iface, target_count, targets, offsets);
1034
1035     count = min(target_count, 4);
1036     wined3d_mutex_lock();
1037     for (i = 0; i < count; ++i)
1038     {
1039         struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(targets[i]);
1040
1041         wined3d_device_set_stream_output(device->wined3d_device, i,
1042                 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
1043     }
1044
1045     for (i = count; i < 4; ++i)
1046     {
1047         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
1048     }
1049     wined3d_mutex_unlock();
1050 }
1051
1052 static void STDMETHODCALLTYPE d3d10_device_DrawAuto(ID3D10Device1 *iface)
1053 {
1054     FIXME("iface %p stub!\n", iface);
1055 }
1056
1057 static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device1 *iface, ID3D10RasterizerState *rasterizer_state)
1058 {
1059     struct d3d_device *device = impl_from_ID3D10Device(iface);
1060     const D3D10_RASTERIZER_DESC *desc;
1061
1062     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
1063
1064     wined3d_mutex_lock();
1065     if (!(device->rasterizer_state = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state)))
1066     {
1067         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, WINED3D_FILL_SOLID);
1068         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, WINED3D_CULL_CCW);
1069         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, FALSE);
1070         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, FALSE);
1071         wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ANTIALIASEDLINEENABLE, FALSE);
1072         wined3d_mutex_unlock();
1073         return;
1074     }
1075
1076     desc = &device->rasterizer_state->desc;
1077     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, desc->FillMode);
1078     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, desc->CullMode);
1079     /* glFrontFace() */
1080     if (desc->FrontCounterClockwise)
1081         FIXME("Ignoring FrontCounterClockwise %#x.\n", desc->FrontCounterClockwise);
1082     /* OpenGL style depth bias. */
1083     if (desc->DepthBias || desc->SlopeScaledDepthBias)
1084         FIXME("Ignoring depth bias.\n");
1085     /* GL_DEPTH_CLAMP */
1086     if (!desc->DepthClipEnable)
1087         FIXME("Ignoring DepthClipEnable %#x.\n", desc->DepthClipEnable);
1088     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, desc->ScissorEnable);
1089     wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, desc->MultisampleEnable);
1090     wined3d_device_set_render_state(device->wined3d_device,
1091             WINED3D_RS_ANTIALIASEDLINEENABLE, desc->AntialiasedLineEnable);
1092     wined3d_mutex_unlock();
1093 }
1094
1095 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device1 *iface,
1096         UINT viewport_count, const D3D10_VIEWPORT *viewports)
1097 {
1098     struct d3d_device *device = impl_from_ID3D10Device(iface);
1099     struct wined3d_viewport wined3d_vp;
1100
1101     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
1102
1103     if (viewport_count > 1)
1104         FIXME("Multiple viewports not implemented.\n");
1105
1106     if (!viewport_count)
1107         return;
1108
1109     wined3d_vp.x = viewports[0].TopLeftX;
1110     wined3d_vp.y = viewports[0].TopLeftY;
1111     wined3d_vp.width = viewports[0].Width;
1112     wined3d_vp.height = viewports[0].Height;
1113     wined3d_vp.min_z = viewports[0].MinDepth;
1114     wined3d_vp.max_z = viewports[0].MaxDepth;
1115
1116     wined3d_mutex_lock();
1117     wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
1118     wined3d_mutex_unlock();
1119 }
1120
1121 static void STDMETHODCALLTYPE d3d10_device_RSSetScissorRects(ID3D10Device1 *iface,
1122         UINT rect_count, const D3D10_RECT *rects)
1123 {
1124     struct d3d_device *device = impl_from_ID3D10Device(iface);
1125
1126     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
1127
1128     if (rect_count > 1)
1129         FIXME("Multiple scissor rects not implemented.\n");
1130
1131     if (!rect_count)
1132         return;
1133
1134     wined3d_mutex_lock();
1135     wined3d_device_set_scissor_rect(device->wined3d_device, rects);
1136     wined3d_mutex_unlock();
1137 }
1138
1139 static void STDMETHODCALLTYPE d3d10_device_CopySubresourceRegion(ID3D10Device1 *iface,
1140         ID3D10Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
1141         ID3D10Resource *src_resource, UINT src_subresource_idx, const D3D10_BOX *src_box)
1142 {
1143     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
1144     struct d3d_device *device = impl_from_ID3D10Device(iface);
1145     struct wined3d_box wined3d_src_box;
1146
1147     TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
1148             "src_resource %p, src_subresource_idx %u, src_box %p.\n",
1149             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
1150             src_resource, src_subresource_idx, src_box);
1151
1152     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
1153     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
1154     wined3d_src_box.left = src_box->left;
1155     wined3d_src_box.top = src_box->top;
1156     wined3d_src_box.front = src_box->front;
1157     wined3d_src_box.right = src_box->right;
1158     wined3d_src_box.bottom = src_box->bottom;
1159     wined3d_src_box.back = src_box->back;
1160     wined3d_mutex_lock();
1161     wined3d_device_copy_sub_resource_region(device->wined3d_device, wined3d_dst_resource, dst_subresource_idx,
1162             dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, &wined3d_src_box);
1163     wined3d_mutex_unlock();
1164 }
1165
1166 static void STDMETHODCALLTYPE d3d10_device_CopyResource(ID3D10Device1 *iface,
1167         ID3D10Resource *dst_resource, ID3D10Resource *src_resource)
1168 {
1169     struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
1170     struct d3d_device *device = impl_from_ID3D10Device(iface);
1171
1172     TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
1173
1174     wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
1175     wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
1176     wined3d_mutex_lock();
1177     wined3d_device_copy_resource(device->wined3d_device, wined3d_dst_resource, wined3d_src_resource);
1178     wined3d_mutex_unlock();
1179 }
1180
1181 static void STDMETHODCALLTYPE d3d10_device_UpdateSubresource(ID3D10Device1 *iface,
1182         ID3D10Resource *resource, UINT subresource_idx, const D3D10_BOX *box,
1183         const void *data, UINT row_pitch, UINT depth_pitch)
1184 {
1185     struct d3d_device *device = impl_from_ID3D10Device(iface);
1186     struct wined3d_resource *wined3d_resource;
1187     struct wined3d_box wined3d_box;
1188
1189     TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
1190             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
1191
1192     if (box)
1193     {
1194         wined3d_box.left = box->left;
1195         wined3d_box.top = box->top;
1196         wined3d_box.front = box->front;
1197         wined3d_box.right = box->right;
1198         wined3d_box.bottom = box->bottom;
1199         wined3d_box.back = box->back;
1200     }
1201
1202     wined3d_resource = wined3d_resource_from_d3d10_resource(resource);
1203     wined3d_mutex_lock();
1204     wined3d_device_update_sub_resource(device->wined3d_device, wined3d_resource,
1205             subresource_idx, box ? &wined3d_box : NULL, data, row_pitch, depth_pitch);
1206     wined3d_mutex_unlock();
1207 }
1208
1209 static void STDMETHODCALLTYPE d3d10_device_ClearRenderTargetView(ID3D10Device1 *iface,
1210         ID3D10RenderTargetView *render_target_view, const FLOAT color_rgba[4])
1211 {
1212     struct d3d_device *device = impl_from_ID3D10Device(iface);
1213     struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D10RenderTargetView(render_target_view);
1214     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
1215     HRESULT hr;
1216
1217     TRACE("iface %p, render_target_view %p, color_rgba {%.8e, %.8e, %.8e, %.8e}.\n",
1218             iface, render_target_view, color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]);
1219
1220     wined3d_mutex_lock();
1221     if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL, &color)))
1222         ERR("Failed to clear view, hr %#x.\n", hr);
1223     wined3d_mutex_unlock();
1224 }
1225
1226 static void STDMETHODCALLTYPE d3d10_device_ClearDepthStencilView(ID3D10Device1 *iface,
1227         ID3D10DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
1228 {
1229     FIXME("iface %p, depth_stencil_view %p, flags %#x, depth %f, stencil %u stub!\n",
1230             iface, depth_stencil_view, flags, depth, stencil);
1231 }
1232
1233 static void STDMETHODCALLTYPE d3d10_device_GenerateMips(ID3D10Device1 *iface,
1234         ID3D10ShaderResourceView *shader_resource_view)
1235 {
1236     FIXME("iface %p, shader_resource_view %p stub!\n", iface, shader_resource_view);
1237 }
1238
1239 static void STDMETHODCALLTYPE d3d10_device_ResolveSubresource(ID3D10Device1 *iface,
1240         ID3D10Resource *dst_resource, UINT dst_subresource_idx,
1241         ID3D10Resource *src_resource, UINT src_subresource_idx, DXGI_FORMAT format)
1242 {
1243     FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, "
1244             "src_resource %p, src_subresource_idx %u, format %s stub!\n",
1245             iface, dst_resource, dst_subresource_idx,
1246             src_resource, src_subresource_idx, debug_dxgi_format(format));
1247 }
1248
1249 static void STDMETHODCALLTYPE d3d10_device_VSGetConstantBuffers(ID3D10Device1 *iface,
1250         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
1251 {
1252     struct d3d_device *device = impl_from_ID3D10Device(iface);
1253     unsigned int i;
1254
1255     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1256             iface, start_slot, buffer_count, buffers);
1257
1258     wined3d_mutex_lock();
1259     for (i = 0; i < buffer_count; ++i)
1260     {
1261         struct wined3d_buffer *wined3d_buffer;
1262         struct d3d_buffer *buffer_impl;
1263
1264         if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
1265         {
1266             buffers[i] = NULL;
1267             continue;
1268         }
1269
1270         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1271         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
1272         ID3D10Buffer_AddRef(buffers[i]);
1273     }
1274     wined3d_mutex_unlock();
1275 }
1276
1277 static void STDMETHODCALLTYPE d3d10_device_PSGetShaderResources(ID3D10Device1 *iface,
1278         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
1279 {
1280     struct d3d_device *device = impl_from_ID3D10Device(iface);
1281     unsigned int i;
1282
1283     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1284             iface, start_slot, view_count, views);
1285
1286     wined3d_mutex_lock();
1287     for (i = 0; i < view_count; ++i)
1288     {
1289         struct wined3d_shader_resource_view *wined3d_view;
1290         struct d3d10_shader_resource_view *view_impl;
1291
1292         if (!(wined3d_view = wined3d_device_get_ps_resource_view(device->wined3d_device, start_slot + i)))
1293         {
1294             views[i] = NULL;
1295             continue;
1296         }
1297
1298         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1299         views[i] = &view_impl->ID3D10ShaderResourceView_iface;
1300         ID3D10ShaderResourceView_AddRef(views[i]);
1301     }
1302     wined3d_mutex_unlock();
1303 }
1304
1305 static void STDMETHODCALLTYPE d3d10_device_PSGetShader(ID3D10Device1 *iface, ID3D10PixelShader **shader)
1306 {
1307     struct d3d_device *device = impl_from_ID3D10Device(iface);
1308     struct d3d10_pixel_shader *shader_impl;
1309     struct wined3d_shader *wined3d_shader;
1310
1311     TRACE("iface %p, shader %p.\n", iface, shader);
1312
1313     wined3d_mutex_lock();
1314     if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
1315     {
1316         wined3d_mutex_unlock();
1317         *shader = NULL;
1318         return;
1319     }
1320
1321     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1322     wined3d_mutex_unlock();
1323     *shader = &shader_impl->ID3D10PixelShader_iface;
1324     ID3D10PixelShader_AddRef(*shader);
1325 }
1326
1327 static void STDMETHODCALLTYPE d3d10_device_PSGetSamplers(ID3D10Device1 *iface,
1328         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
1329 {
1330     struct d3d_device *device = impl_from_ID3D10Device(iface);
1331     unsigned int i;
1332
1333     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1334             iface, start_slot, sampler_count, samplers);
1335
1336     wined3d_mutex_lock();
1337     for (i = 0; i < sampler_count; ++i)
1338     {
1339         struct d3d10_sampler_state *sampler_impl;
1340         struct wined3d_sampler *wined3d_sampler;
1341
1342         if (!(wined3d_sampler = wined3d_device_get_ps_sampler(device->wined3d_device, start_slot + i)))
1343         {
1344             samplers[i] = NULL;
1345             continue;
1346         }
1347
1348         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1349         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
1350         ID3D10SamplerState_AddRef(samplers[i]);
1351     }
1352     wined3d_mutex_unlock();
1353 }
1354
1355 static void STDMETHODCALLTYPE d3d10_device_VSGetShader(ID3D10Device1 *iface, ID3D10VertexShader **shader)
1356 {
1357     struct d3d_device *device = impl_from_ID3D10Device(iface);
1358     struct d3d10_vertex_shader *shader_impl;
1359     struct wined3d_shader *wined3d_shader;
1360
1361     TRACE("iface %p, shader %p.\n", iface, shader);
1362
1363     wined3d_mutex_lock();
1364     if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
1365     {
1366         wined3d_mutex_unlock();
1367         *shader = NULL;
1368         return;
1369     }
1370
1371     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1372     wined3d_mutex_unlock();
1373     *shader = &shader_impl->ID3D10VertexShader_iface;
1374     ID3D10VertexShader_AddRef(*shader);
1375 }
1376
1377 static void STDMETHODCALLTYPE d3d10_device_PSGetConstantBuffers(ID3D10Device1 *iface,
1378         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
1379 {
1380     struct d3d_device *device = impl_from_ID3D10Device(iface);
1381     unsigned int i;
1382
1383     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1384             iface, start_slot, buffer_count, buffers);
1385
1386     wined3d_mutex_lock();
1387     for (i = 0; i < buffer_count; ++i)
1388     {
1389         struct wined3d_buffer *wined3d_buffer;
1390         struct d3d_buffer *buffer_impl;
1391
1392         if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
1393         {
1394             buffers[i] = NULL;
1395             continue;
1396         }
1397
1398         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1399         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
1400         ID3D10Buffer_AddRef(buffers[i]);
1401     }
1402     wined3d_mutex_unlock();
1403 }
1404
1405 static void STDMETHODCALLTYPE d3d10_device_IAGetInputLayout(ID3D10Device1 *iface, ID3D10InputLayout **input_layout)
1406 {
1407     struct d3d_device *device = impl_from_ID3D10Device(iface);
1408     struct wined3d_vertex_declaration *wined3d_declaration;
1409     struct d3d10_input_layout *input_layout_impl;
1410
1411     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
1412
1413     wined3d_mutex_lock();
1414     if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
1415     {
1416         wined3d_mutex_unlock();
1417         *input_layout = NULL;
1418         return;
1419     }
1420
1421     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
1422     wined3d_mutex_unlock();
1423     *input_layout = &input_layout_impl->ID3D10InputLayout_iface;
1424     ID3D10InputLayout_AddRef(*input_layout);
1425 }
1426
1427 static void STDMETHODCALLTYPE d3d10_device_IAGetVertexBuffers(ID3D10Device1 *iface,
1428         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers, UINT *strides, UINT *offsets)
1429 {
1430     struct d3d_device *device = impl_from_ID3D10Device(iface);
1431     unsigned int i;
1432
1433     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
1434             iface, start_slot, buffer_count, buffers, strides, offsets);
1435
1436     wined3d_mutex_lock();
1437     for (i = 0; i < buffer_count; ++i)
1438     {
1439         struct wined3d_buffer *wined3d_buffer;
1440         struct d3d_buffer *buffer_impl;
1441
1442         if (FAILED(wined3d_device_get_stream_source(device->wined3d_device, start_slot + i,
1443                 &wined3d_buffer, &offsets[i], &strides[i])))
1444             ERR("Failed to get vertex buffer.\n");
1445
1446         if (!wined3d_buffer)
1447         {
1448             buffers[i] = NULL;
1449             continue;
1450         }
1451
1452         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1453         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
1454         ID3D10Buffer_AddRef(buffers[i]);
1455     }
1456     wined3d_mutex_unlock();
1457 }
1458
1459 static void STDMETHODCALLTYPE d3d10_device_IAGetIndexBuffer(ID3D10Device1 *iface,
1460         ID3D10Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
1461 {
1462     struct d3d_device *device = impl_from_ID3D10Device(iface);
1463     enum wined3d_format_id wined3d_format;
1464     struct wined3d_buffer *wined3d_buffer;
1465     struct d3d_buffer *buffer_impl;
1466
1467     TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
1468
1469     wined3d_mutex_lock();
1470     wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format);
1471     *format = dxgi_format_from_wined3dformat(wined3d_format);
1472     *offset = 0; /* FIXME */
1473     if (!wined3d_buffer)
1474     {
1475         wined3d_mutex_unlock();
1476         *buffer = NULL;
1477         return;
1478     }
1479
1480     buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1481     wined3d_mutex_unlock();
1482     *buffer = &buffer_impl->ID3D10Buffer_iface;
1483     ID3D10Buffer_AddRef(*buffer);
1484 }
1485
1486 static void STDMETHODCALLTYPE d3d10_device_GSGetConstantBuffers(ID3D10Device1 *iface,
1487         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
1488 {
1489     struct d3d_device *device = impl_from_ID3D10Device(iface);
1490     unsigned int i;
1491
1492     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1493             iface, start_slot, buffer_count, buffers);
1494
1495     wined3d_mutex_lock();
1496     for (i = 0; i < buffer_count; ++i)
1497     {
1498         struct wined3d_buffer *wined3d_buffer;
1499         struct d3d_buffer *buffer_impl;
1500
1501         if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
1502         {
1503             buffers[i] = NULL;
1504             continue;
1505         }
1506
1507         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1508         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
1509         ID3D10Buffer_AddRef(buffers[i]);
1510     }
1511     wined3d_mutex_unlock();
1512 }
1513
1514 static void STDMETHODCALLTYPE d3d10_device_GSGetShader(ID3D10Device1 *iface, ID3D10GeometryShader **shader)
1515 {
1516     struct d3d_device *device = impl_from_ID3D10Device(iface);
1517     struct d3d10_geometry_shader *shader_impl;
1518     struct wined3d_shader *wined3d_shader;
1519
1520     TRACE("iface %p, shader %p.\n", iface, shader);
1521
1522     wined3d_mutex_lock();
1523     if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
1524     {
1525         wined3d_mutex_unlock();
1526         *shader = NULL;
1527         return;
1528     }
1529
1530     shader_impl = wined3d_shader_get_parent(wined3d_shader);
1531     wined3d_mutex_unlock();
1532     *shader = &shader_impl->ID3D10GeometryShader_iface;
1533     ID3D10GeometryShader_AddRef(*shader);
1534 }
1535
1536 static void STDMETHODCALLTYPE d3d10_device_IAGetPrimitiveTopology(ID3D10Device1 *iface,
1537         D3D10_PRIMITIVE_TOPOLOGY *topology)
1538 {
1539     struct d3d_device *This = impl_from_ID3D10Device(iface);
1540
1541     TRACE("iface %p, topology %p\n", iface, topology);
1542
1543     wined3d_mutex_lock();
1544     wined3d_device_get_primitive_type(This->wined3d_device, (enum wined3d_primitive_type *)topology);
1545     wined3d_mutex_unlock();
1546 }
1547
1548 static void STDMETHODCALLTYPE d3d10_device_VSGetShaderResources(ID3D10Device1 *iface,
1549         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
1550 {
1551     struct d3d_device *device = impl_from_ID3D10Device(iface);
1552     unsigned int i;
1553
1554     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1555             iface, start_slot, view_count, views);
1556
1557     wined3d_mutex_lock();
1558     for (i = 0; i < view_count; ++i)
1559     {
1560         struct wined3d_shader_resource_view *wined3d_view;
1561         struct d3d10_shader_resource_view *view_impl;
1562
1563         if (!(wined3d_view = wined3d_device_get_vs_resource_view(device->wined3d_device, start_slot + i)))
1564         {
1565             views[i] = NULL;
1566             continue;
1567         }
1568
1569         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1570         views[i] = &view_impl->ID3D10ShaderResourceView_iface;
1571         ID3D10ShaderResourceView_AddRef(views[i]);
1572     }
1573     wined3d_mutex_unlock();
1574 }
1575
1576 static void STDMETHODCALLTYPE d3d10_device_VSGetSamplers(ID3D10Device1 *iface,
1577         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
1578 {
1579     struct d3d_device *device = impl_from_ID3D10Device(iface);
1580     unsigned int i;
1581
1582     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1583             iface, start_slot, sampler_count, samplers);
1584
1585     wined3d_mutex_lock();
1586     for (i = 0; i < sampler_count; ++i)
1587     {
1588         struct d3d10_sampler_state *sampler_impl;
1589         struct wined3d_sampler *wined3d_sampler;
1590
1591         if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
1592         {
1593             samplers[i] = NULL;
1594             continue;
1595         }
1596
1597         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1598         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
1599         ID3D10SamplerState_AddRef(samplers[i]);
1600     }
1601     wined3d_mutex_unlock();
1602 }
1603
1604 static void STDMETHODCALLTYPE d3d10_device_GetPredication(ID3D10Device1 *iface,
1605         ID3D10Predicate **predicate, BOOL *value)
1606 {
1607     struct d3d_device *device = impl_from_ID3D10Device(iface);
1608     struct wined3d_query *wined3d_predicate;
1609     struct d3d10_query *predicate_impl;
1610
1611     TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
1612
1613     wined3d_mutex_lock();
1614     if (!(wined3d_predicate = wined3d_device_get_predication(device->wined3d_device, value)))
1615     {
1616         wined3d_mutex_unlock();
1617         *predicate = NULL;
1618         return;
1619     }
1620
1621     predicate_impl = wined3d_query_get_parent(wined3d_predicate);
1622     wined3d_mutex_unlock();
1623     *predicate = (ID3D10Predicate *)&predicate_impl->ID3D10Query_iface;
1624     ID3D10Predicate_AddRef(*predicate);
1625 }
1626
1627 static void STDMETHODCALLTYPE d3d10_device_GSGetShaderResources(ID3D10Device1 *iface,
1628         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
1629 {
1630     struct d3d_device *device = impl_from_ID3D10Device(iface);
1631     unsigned int i;
1632
1633     TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1634             iface, start_slot, view_count, views);
1635
1636     wined3d_mutex_lock();
1637     for (i = 0; i < view_count; ++i)
1638     {
1639         struct wined3d_shader_resource_view *wined3d_view;
1640         struct d3d10_shader_resource_view *view_impl;
1641
1642         if (!(wined3d_view = wined3d_device_get_gs_resource_view(device->wined3d_device, start_slot + i)))
1643         {
1644             views[i] = NULL;
1645             continue;
1646         }
1647
1648         view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1649         views[i] = &view_impl->ID3D10ShaderResourceView_iface;
1650         ID3D10ShaderResourceView_AddRef(views[i]);
1651     }
1652     wined3d_mutex_unlock();
1653 }
1654
1655 static void STDMETHODCALLTYPE d3d10_device_GSGetSamplers(ID3D10Device1 *iface,
1656         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
1657 {
1658     struct d3d_device *device = impl_from_ID3D10Device(iface);
1659     unsigned int i;
1660
1661     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1662             iface, start_slot, sampler_count, samplers);
1663
1664     wined3d_mutex_lock();
1665     for (i = 0; i < sampler_count; ++i)
1666     {
1667         struct d3d10_sampler_state *sampler_impl;
1668         struct wined3d_sampler *wined3d_sampler;
1669
1670         if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
1671         {
1672             samplers[i] = NULL;
1673             continue;
1674         }
1675
1676         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1677         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
1678         ID3D10SamplerState_AddRef(samplers[i]);
1679     }
1680     wined3d_mutex_unlock();
1681 }
1682
1683 static void STDMETHODCALLTYPE d3d10_device_OMGetRenderTargets(ID3D10Device1 *iface,
1684         UINT view_count, ID3D10RenderTargetView **render_target_views, ID3D10DepthStencilView **depth_stencil_view)
1685 {
1686     struct d3d_device *device = impl_from_ID3D10Device(iface);
1687     struct wined3d_rendertarget_view *wined3d_view;
1688
1689     TRACE("iface %p, view_count %u, render_target_views %p, depth_stencil_view %p.\n",
1690             iface, view_count, render_target_views, depth_stencil_view);
1691
1692     wined3d_mutex_lock();
1693     if (render_target_views)
1694     {
1695         struct d3d_rendertarget_view *view_impl;
1696         unsigned int i;
1697
1698         for (i = 0; i < view_count; ++i)
1699         {
1700             if (!(wined3d_view = wined3d_device_get_rendertarget_view(device->wined3d_device, i))
1701                     || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1702             {
1703                 render_target_views[i] = NULL;
1704                 continue;
1705             }
1706
1707             render_target_views[i] = &view_impl->ID3D10RenderTargetView_iface;
1708             ID3D10RenderTargetView_AddRef(render_target_views[i]);
1709         }
1710     }
1711
1712     if (depth_stencil_view)
1713     {
1714         struct d3d_depthstencil_view *view_impl;
1715
1716         if (!(wined3d_view = wined3d_device_get_depth_stencil_view(device->wined3d_device))
1717                 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1718         {
1719             *depth_stencil_view = NULL;
1720         }
1721         else
1722         {
1723             *depth_stencil_view = &view_impl->ID3D10DepthStencilView_iface;
1724             ID3D10DepthStencilView_AddRef(*depth_stencil_view);
1725         }
1726     }
1727     wined3d_mutex_unlock();
1728 }
1729
1730 static void STDMETHODCALLTYPE d3d10_device_OMGetBlendState(ID3D10Device1 *iface,
1731         ID3D10BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
1732 {
1733     struct d3d_device *device = impl_from_ID3D10Device(iface);
1734
1735     TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
1736             iface, blend_state, blend_factor, sample_mask);
1737
1738     if ((*blend_state = device->blend_state ? &device->blend_state->ID3D10BlendState_iface : NULL))
1739         ID3D10BlendState_AddRef(*blend_state);
1740     wined3d_mutex_lock();
1741     memcpy(blend_factor, device->blend_factor, 4 * sizeof(*blend_factor));
1742     *sample_mask = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK);
1743     wined3d_mutex_unlock();
1744 }
1745
1746 static void STDMETHODCALLTYPE d3d10_device_OMGetDepthStencilState(ID3D10Device1 *iface,
1747         ID3D10DepthStencilState **depth_stencil_state, UINT *stencil_ref)
1748 {
1749     struct d3d_device *device = impl_from_ID3D10Device(iface);
1750
1751     TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
1752             iface, depth_stencil_state, stencil_ref);
1753
1754     if ((*depth_stencil_state = device->depth_stencil_state
1755             ? &device->depth_stencil_state->ID3D10DepthStencilState_iface : NULL))
1756         ID3D10DepthStencilState_AddRef(*depth_stencil_state);
1757     *stencil_ref = device->stencil_ref;
1758 }
1759
1760 static void STDMETHODCALLTYPE d3d10_device_SOGetTargets(ID3D10Device1 *iface,
1761         UINT buffer_count, ID3D10Buffer **buffers, UINT *offsets)
1762 {
1763     struct d3d_device *device = impl_from_ID3D10Device(iface);
1764     unsigned int i;
1765
1766     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n",
1767             iface, buffer_count, buffers, offsets);
1768
1769     wined3d_mutex_lock();
1770     for (i = 0; i < buffer_count; ++i)
1771     {
1772         struct wined3d_buffer *wined3d_buffer;
1773         struct d3d_buffer *buffer_impl;
1774
1775         if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, &offsets[i])))
1776         {
1777             buffers[i] = NULL;
1778             continue;
1779         }
1780
1781         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1782         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
1783         ID3D10Buffer_AddRef(buffers[i]);
1784     }
1785     wined3d_mutex_unlock();
1786 }
1787
1788 static void STDMETHODCALLTYPE d3d10_device_RSGetState(ID3D10Device1 *iface, ID3D10RasterizerState **rasterizer_state)
1789 {
1790     struct d3d_device *device = impl_from_ID3D10Device(iface);
1791
1792     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
1793
1794     if ((*rasterizer_state = device->rasterizer_state ? &device->rasterizer_state->ID3D10RasterizerState_iface : NULL))
1795         ID3D10RasterizerState_AddRef(*rasterizer_state);
1796 }
1797
1798 static void STDMETHODCALLTYPE d3d10_device_RSGetViewports(ID3D10Device1 *iface,
1799         UINT *viewport_count, D3D10_VIEWPORT *viewports)
1800 {
1801     struct d3d_device *device = impl_from_ID3D10Device(iface);
1802     struct wined3d_viewport wined3d_vp;
1803
1804     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
1805
1806     if (!viewports)
1807     {
1808         *viewport_count = 1;
1809         return;
1810     }
1811
1812     if (!*viewport_count)
1813         return;
1814
1815     wined3d_mutex_lock();
1816     wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
1817     wined3d_mutex_unlock();
1818
1819     viewports[0].TopLeftX = wined3d_vp.x;
1820     viewports[0].TopLeftY = wined3d_vp.y;
1821     viewports[0].Width = wined3d_vp.width;
1822     viewports[0].Height = wined3d_vp.height;
1823     viewports[0].MinDepth = wined3d_vp.min_z;
1824     viewports[0].MaxDepth = wined3d_vp.max_z;
1825
1826     if (*viewport_count > 1)
1827         memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
1828 }
1829
1830 static void STDMETHODCALLTYPE d3d10_device_RSGetScissorRects(ID3D10Device1 *iface, UINT *rect_count, D3D10_RECT *rects)
1831 {
1832     struct d3d_device *device = impl_from_ID3D10Device(iface);
1833
1834     TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
1835
1836     if (!rects)
1837     {
1838         *rect_count = 1;
1839         return;
1840     }
1841
1842     if (!*rect_count)
1843         return;
1844
1845     wined3d_mutex_lock();
1846     wined3d_device_get_scissor_rect(device->wined3d_device, rects);
1847     wined3d_mutex_unlock();
1848     if (*rect_count > 1)
1849         memset(&rects[1], 0, (*rect_count - 1) * sizeof(*rects));
1850 }
1851
1852 static HRESULT STDMETHODCALLTYPE d3d10_device_GetDeviceRemovedReason(ID3D10Device1 *iface)
1853 {
1854     TRACE("iface %p.\n", iface);
1855
1856     /* In the current implementation the device is never removed, so we can
1857      * just return S_OK here. */
1858
1859     return S_OK;
1860 }
1861
1862 static HRESULT STDMETHODCALLTYPE d3d10_device_SetExceptionMode(ID3D10Device1 *iface, UINT flags)
1863 {
1864     FIXME("iface %p, flags %#x stub!\n", iface, flags);
1865
1866     return E_NOTIMPL;
1867 }
1868
1869 static UINT STDMETHODCALLTYPE d3d10_device_GetExceptionMode(ID3D10Device1 *iface)
1870 {
1871     FIXME("iface %p stub!\n", iface);
1872
1873     return 0;
1874 }
1875
1876 static HRESULT STDMETHODCALLTYPE d3d10_device_GetPrivateData(ID3D10Device1 *iface,
1877         REFGUID guid, UINT *data_size, void *data)
1878 {
1879     IDXGIDevice *dxgi_device;
1880     HRESULT hr;
1881
1882     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1883             iface, debugstr_guid(guid), data_size, data);
1884
1885     if (FAILED(hr = ID3D10Device1_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
1886         return hr;
1887     hr = IDXGIDevice_GetPrivateData(dxgi_device, guid, data_size, data);
1888     IDXGIDevice_Release(dxgi_device);
1889
1890     return hr;
1891 }
1892
1893 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateData(ID3D10Device1 *iface,
1894         REFGUID guid, UINT data_size, const void *data)
1895 {
1896     IDXGIDevice *dxgi_device;
1897     HRESULT hr;
1898
1899     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1900             iface, debugstr_guid(guid), data_size, data);
1901
1902     if (FAILED(hr = ID3D10Device1_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
1903         return hr;
1904     hr = IDXGIDevice_SetPrivateData(dxgi_device, guid, data_size, data);
1905     IDXGIDevice_Release(dxgi_device);
1906
1907     return hr;
1908 }
1909
1910 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateDataInterface(ID3D10Device1 *iface,
1911         REFGUID guid, const IUnknown *data)
1912 {
1913     IDXGIDevice *dxgi_device;
1914     HRESULT hr;
1915
1916     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1917
1918     if (FAILED(hr = ID3D10Device1_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
1919         return hr;
1920     hr = IDXGIDevice_SetPrivateDataInterface(dxgi_device, guid, data);
1921     IDXGIDevice_Release(dxgi_device);
1922
1923     return hr;
1924 }
1925
1926 static void STDMETHODCALLTYPE d3d10_device_ClearState(ID3D10Device1 *iface)
1927 {
1928     static const float blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
1929     struct d3d_device *device = impl_from_ID3D10Device(iface);
1930     unsigned int i;
1931
1932     TRACE("iface %p.\n", iface);
1933
1934     wined3d_mutex_lock();
1935     wined3d_device_set_vertex_shader(device->wined3d_device, NULL);
1936     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
1937     {
1938         wined3d_device_set_vs_sampler(device->wined3d_device, i, NULL);
1939     }
1940     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
1941     {
1942         wined3d_device_set_vs_resource_view(device->wined3d_device, i, NULL);
1943     }
1944     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
1945     {
1946         wined3d_device_set_vs_cb(device->wined3d_device, i, NULL);
1947     }
1948     wined3d_device_set_geometry_shader(device->wined3d_device, NULL);
1949     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
1950     {
1951         wined3d_device_set_gs_sampler(device->wined3d_device, i, NULL);
1952     }
1953     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
1954     {
1955         wined3d_device_set_gs_resource_view(device->wined3d_device, i, NULL);
1956     }
1957     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
1958     {
1959         wined3d_device_set_gs_cb(device->wined3d_device, i, NULL);
1960     }
1961     wined3d_device_set_pixel_shader(device->wined3d_device, NULL);
1962     for (i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
1963     {
1964         wined3d_device_set_ps_sampler(device->wined3d_device, i, NULL);
1965     }
1966     for (i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
1967     {
1968         wined3d_device_set_ps_resource_view(device->wined3d_device, i, NULL);
1969     }
1970     for (i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
1971     {
1972         wined3d_device_set_ps_cb(device->wined3d_device, i, NULL);
1973     }
1974     for (i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i)
1975     {
1976         wined3d_device_set_stream_source(device->wined3d_device, i, NULL, 0, 0);
1977     }
1978     wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN);
1979     wined3d_device_set_vertex_declaration(device->wined3d_device, NULL);
1980     wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_UNDEFINED);
1981     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
1982     {
1983         wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
1984     }
1985     wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
1986     ID3D10Device1_OMSetDepthStencilState(iface, NULL, 0);
1987     ID3D10Device1_OMSetBlendState(iface, NULL, blend_factor, D3D10_DEFAULT_SAMPLE_MASK);
1988     ID3D10Device1_RSSetViewports(iface, 0, NULL);
1989     ID3D10Device1_RSSetScissorRects(iface, 0, NULL);
1990     ID3D10Device1_RSSetState(iface, NULL);
1991     for (i = 0; i < D3D10_SO_BUFFER_SLOT_COUNT; ++i)
1992     {
1993         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
1994     }
1995     wined3d_device_set_predication(device->wined3d_device, NULL, FALSE);
1996     wined3d_mutex_unlock();
1997 }
1998
1999 static void STDMETHODCALLTYPE d3d10_device_Flush(ID3D10Device1 *iface)
2000 {
2001     FIXME("iface %p stub!\n", iface);
2002 }
2003
2004 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBuffer(ID3D10Device1 *iface,
2005         const D3D10_BUFFER_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Buffer **buffer)
2006 {
2007     struct d3d_device *device = impl_from_ID3D10Device(iface);
2008     D3D11_BUFFER_DESC d3d11_desc;
2009     struct d3d_buffer *object;
2010     HRESULT hr;
2011
2012     TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
2013
2014     d3d11_desc.ByteWidth = desc->ByteWidth;
2015     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
2016     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
2017     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
2018     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
2019     d3d11_desc.StructureByteStride = 0;
2020
2021     if (FAILED(hr = d3d_buffer_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
2022         return hr;
2023
2024     *buffer = &object->ID3D10Buffer_iface;
2025
2026     return S_OK;
2027 }
2028
2029 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture1D(ID3D10Device1 *iface,
2030         const D3D10_TEXTURE1D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Texture1D **texture)
2031 {
2032     FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
2033
2034     return E_NOTIMPL;
2035 }
2036
2037 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture2D(ID3D10Device1 *iface,
2038         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
2039         ID3D10Texture2D **texture)
2040 {
2041     struct d3d_device *device = impl_from_ID3D10Device(iface);
2042     D3D11_TEXTURE2D_DESC d3d11_desc;
2043     struct d3d_texture2d *object;
2044     HRESULT hr;
2045
2046     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
2047
2048     d3d11_desc.Width = desc->Width;
2049     d3d11_desc.Height = desc->Height;
2050     d3d11_desc.MipLevels = desc->MipLevels;
2051     d3d11_desc.ArraySize = desc->ArraySize;
2052     d3d11_desc.Format = desc->Format;
2053     d3d11_desc.SampleDesc = desc->SampleDesc;
2054     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
2055     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
2056     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
2057     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
2058
2059     if (FAILED(hr = d3d_texture2d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
2060         return hr;
2061
2062     *texture = &object->ID3D10Texture2D_iface;
2063
2064     return S_OK;
2065 }
2066
2067 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture3D(ID3D10Device1 *iface,
2068         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
2069         ID3D10Texture3D **texture)
2070 {
2071     struct d3d_device *device = impl_from_ID3D10Device(iface);
2072     D3D11_TEXTURE3D_DESC d3d11_desc;
2073     struct d3d_texture3d *object;
2074     HRESULT hr;
2075
2076     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
2077
2078     d3d11_desc.Width = desc->Width;
2079     d3d11_desc.Height = desc->Height;
2080     d3d11_desc.Depth = desc->Depth;
2081     d3d11_desc.MipLevels = desc->MipLevels;
2082     d3d11_desc.Format = desc->Format;
2083     d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
2084     d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
2085     d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
2086     d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
2087
2088     if (FAILED(hr = d3d_texture3d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
2089         return hr;
2090
2091     *texture = &object->ID3D10Texture3D_iface;
2092
2093     return S_OK;
2094 }
2095
2096 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView(ID3D10Device1 *iface,
2097         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10ShaderResourceView **view)
2098 {
2099     struct d3d_device *device = impl_from_ID3D10Device(iface);
2100     struct d3d10_shader_resource_view *object;
2101     HRESULT hr;
2102
2103     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2104
2105     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2106         return E_OUTOFMEMORY;
2107
2108     if (FAILED(hr = d3d10_shader_resource_view_init(object, device, resource, desc)))
2109     {
2110         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
2111         HeapFree(GetProcessHeap(), 0, object);
2112         return hr;
2113     }
2114
2115     TRACE("Created shader resource view %p.\n", object);
2116     *view = &object->ID3D10ShaderResourceView_iface;
2117
2118     return S_OK;
2119 }
2120
2121 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRenderTargetView(ID3D10Device1 *iface,
2122         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10RenderTargetView **view)
2123 {
2124     struct d3d_device *device = impl_from_ID3D10Device(iface);
2125     struct d3d_rendertarget_view *object;
2126     HRESULT hr;
2127
2128     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2129
2130     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2131         return E_OUTOFMEMORY;
2132
2133     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
2134     {
2135         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
2136         HeapFree(GetProcessHeap(), 0, object);
2137         return hr;
2138     }
2139
2140     TRACE("Created rendertarget view %p.\n", object);
2141     *view = &object->ID3D10RenderTargetView_iface;
2142
2143     return S_OK;
2144 }
2145
2146 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilView(ID3D10Device1 *iface,
2147         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10DepthStencilView **view)
2148 {
2149     struct d3d_device *device = impl_from_ID3D10Device(iface);
2150     D3D11_DEPTH_STENCIL_VIEW_DESC d3d11_desc;
2151     struct d3d_depthstencil_view *object;
2152     ID3D11Resource *d3d11_resource;
2153     HRESULT hr;
2154
2155     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2156
2157     if (desc)
2158     {
2159         d3d11_desc.Format = desc->Format;
2160         d3d11_desc.ViewDimension = desc->ViewDimension;
2161         d3d11_desc.Flags = 0;
2162         memcpy(&d3d11_desc.u, &desc->u, sizeof(d3d11_desc.u));
2163     }
2164
2165     if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
2166     {
2167         ERR("Resource does not implement ID3D11Resource.\n");
2168         return E_FAIL;
2169     }
2170
2171     hr = d3d_depthstencil_view_create(device, d3d11_resource, desc ? &d3d11_desc : NULL, &object);
2172     ID3D11Resource_Release(d3d11_resource);
2173     if (FAILED(hr))
2174         return hr;
2175
2176     *view = &object->ID3D10DepthStencilView_iface;
2177
2178     return S_OK;
2179 }
2180
2181 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateInputLayout(ID3D10Device1 *iface,
2182         const D3D10_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
2183         const void *shader_byte_code, SIZE_T shader_byte_code_length,
2184         ID3D10InputLayout **input_layout)
2185 {
2186     struct d3d_device *This = impl_from_ID3D10Device(iface);
2187     struct d3d10_input_layout *object;
2188     HRESULT hr;
2189
2190     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, "
2191             "shader_byte_code_length %lu, input_layout %p\n",
2192             iface, element_descs, element_count, shader_byte_code,
2193             shader_byte_code_length, input_layout);
2194
2195     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2196     if (!object)
2197         return E_OUTOFMEMORY;
2198
2199     hr = d3d10_input_layout_init(object, This, element_descs, element_count,
2200             shader_byte_code, shader_byte_code_length);
2201     if (FAILED(hr))
2202     {
2203         WARN("Failed to initialize input layout, hr %#x.\n", hr);
2204         HeapFree(GetProcessHeap(), 0, object);
2205         return hr;
2206     }
2207
2208     TRACE("Created input layout %p.\n", object);
2209     *input_layout = &object->ID3D10InputLayout_iface;
2210
2211     return S_OK;
2212 }
2213
2214 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateVertexShader(ID3D10Device1 *iface,
2215         const void *byte_code, SIZE_T byte_code_length, ID3D10VertexShader **shader)
2216 {
2217     struct d3d_device *This = impl_from_ID3D10Device(iface);
2218     struct d3d10_vertex_shader *object;
2219     HRESULT hr;
2220
2221     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p\n",
2222             iface, byte_code, byte_code_length, shader);
2223
2224     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2225     if (!object)
2226         return E_OUTOFMEMORY;
2227
2228     hr = d3d10_vertex_shader_init(object, This, byte_code, byte_code_length);
2229     if (FAILED(hr))
2230     {
2231         WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
2232         HeapFree(GetProcessHeap(), 0, object);
2233         return hr;
2234     }
2235
2236     TRACE("Created vertex shader %p.\n", object);
2237     *shader = &object->ID3D10VertexShader_iface;
2238
2239     return S_OK;
2240 }
2241
2242 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShader(ID3D10Device1 *iface,
2243         const void *byte_code, SIZE_T byte_code_length, ID3D10GeometryShader **shader)
2244 {
2245     struct d3d_device *This = impl_from_ID3D10Device(iface);
2246     struct d3d10_geometry_shader *object;
2247     HRESULT hr;
2248
2249     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
2250             iface, byte_code, byte_code_length, shader);
2251
2252     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2253     if (!object)
2254         return E_OUTOFMEMORY;
2255
2256     hr = d3d10_geometry_shader_init(object, This, byte_code, byte_code_length);
2257     if (FAILED(hr))
2258     {
2259         WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
2260         HeapFree(GetProcessHeap(), 0, object);
2261         return hr;
2262     }
2263
2264     TRACE("Created geometry shader %p.\n", object);
2265     *shader = &object->ID3D10GeometryShader_iface;
2266
2267     return S_OK;
2268 }
2269
2270 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShaderWithStreamOutput(ID3D10Device1 *iface,
2271         const void *byte_code, SIZE_T byte_code_length, const D3D10_SO_DECLARATION_ENTRY *output_stream_decls,
2272         UINT output_stream_decl_count, UINT output_stream_stride, ID3D10GeometryShader **shader)
2273 {
2274     FIXME("iface %p, byte_code %p, byte_code_length %lu, output_stream_decls %p, "
2275             "output_stream_decl_count %u, output_stream_stride %u, shader %p stub!\n",
2276             iface, byte_code, byte_code_length, output_stream_decls,
2277             output_stream_decl_count, output_stream_stride, shader);
2278
2279     return E_NOTIMPL;
2280 }
2281
2282 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePixelShader(ID3D10Device1 *iface,
2283         const void *byte_code, SIZE_T byte_code_length, ID3D10PixelShader **shader)
2284 {
2285     struct d3d_device *This = impl_from_ID3D10Device(iface);
2286     struct d3d10_pixel_shader *object;
2287     HRESULT hr;
2288
2289     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p\n",
2290             iface, byte_code, byte_code_length, shader);
2291
2292     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2293     if (!object)
2294         return E_OUTOFMEMORY;
2295
2296     hr = d3d10_pixel_shader_init(object, This, byte_code, byte_code_length);
2297     if (FAILED(hr))
2298     {
2299         WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
2300         HeapFree(GetProcessHeap(), 0, object);
2301         return hr;
2302     }
2303
2304     TRACE("Created pixel shader %p.\n", object);
2305     *shader = &object->ID3D10PixelShader_iface;
2306
2307     return S_OK;
2308 }
2309
2310 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState(ID3D10Device1 *iface,
2311         const D3D10_BLEND_DESC *desc, ID3D10BlendState **blend_state)
2312 {
2313     struct d3d_device *device = impl_from_ID3D10Device(iface);
2314     struct d3d10_blend_state *object;
2315     struct wine_rb_entry *entry;
2316     HRESULT hr;
2317
2318     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
2319
2320     if (!desc)
2321         return E_INVALIDARG;
2322
2323     wined3d_mutex_lock();
2324     if ((entry = wine_rb_get(&device->blend_states, desc)))
2325     {
2326         object = WINE_RB_ENTRY_VALUE(entry, struct d3d10_blend_state, entry);
2327
2328         TRACE("Returning existing blend state %p.\n", object);
2329         *blend_state = &object->ID3D10BlendState_iface;
2330         ID3D10BlendState_AddRef(*blend_state);
2331         wined3d_mutex_unlock();
2332
2333         return S_OK;
2334     }
2335     wined3d_mutex_unlock();
2336
2337     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2338     if (!object)
2339         return E_OUTOFMEMORY;
2340
2341     if (FAILED(hr = d3d10_blend_state_init(object, device, desc)))
2342     {
2343         WARN("Failed to initialize blend state, hr %#x.\n", hr);
2344         HeapFree(GetProcessHeap(), 0, object);
2345         return hr;
2346     }
2347
2348     TRACE("Created blend state %p.\n", object);
2349     *blend_state = &object->ID3D10BlendState_iface;
2350
2351     return S_OK;
2352 }
2353
2354 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilState(ID3D10Device1 *iface,
2355         const D3D10_DEPTH_STENCIL_DESC *desc, ID3D10DepthStencilState **depth_stencil_state)
2356 {
2357     struct d3d_device *device = impl_from_ID3D10Device(iface);
2358     struct d3d10_depthstencil_state *object;
2359     D3D10_DEPTH_STENCIL_DESC tmp_desc;
2360     struct wine_rb_entry *entry;
2361     HRESULT hr;
2362
2363     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
2364
2365     if (!desc)
2366         return E_INVALIDARG;
2367
2368     /* D3D10_DEPTH_STENCIL_DESC has a hole, which is a problem because we use
2369      * it as a key in the rbtree. */
2370     memset(&tmp_desc, 0, sizeof(tmp_desc));
2371     tmp_desc.DepthEnable = desc->DepthEnable;
2372     tmp_desc.DepthWriteMask = desc->DepthWriteMask;
2373     tmp_desc.DepthFunc = desc->DepthFunc;
2374     tmp_desc.StencilEnable = desc->StencilEnable;
2375     tmp_desc.StencilReadMask = desc->StencilReadMask;
2376     tmp_desc.StencilWriteMask = desc->StencilWriteMask;
2377     tmp_desc.FrontFace = desc->FrontFace;
2378     tmp_desc.BackFace = desc->BackFace;
2379
2380     wined3d_mutex_lock();
2381     if ((entry = wine_rb_get(&device->depthstencil_states, &tmp_desc)))
2382     {
2383         object = WINE_RB_ENTRY_VALUE(entry, struct d3d10_depthstencil_state, entry);
2384
2385         TRACE("Returning existing depthstencil state %p.\n", object);
2386         *depth_stencil_state = &object->ID3D10DepthStencilState_iface;
2387         ID3D10DepthStencilState_AddRef(*depth_stencil_state);
2388         wined3d_mutex_unlock();
2389
2390         return S_OK;
2391     }
2392     wined3d_mutex_unlock();
2393
2394     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2395     if (!object)
2396         return E_OUTOFMEMORY;
2397
2398     if (FAILED(hr = d3d10_depthstencil_state_init(object, device, &tmp_desc)))
2399     {
2400         WARN("Failed to initialize depthstencil state, hr %#x.\n", hr);
2401         HeapFree(GetProcessHeap(), 0, object);
2402         return hr;
2403     }
2404
2405     TRACE("Created depthstencil state %p.\n", object);
2406     *depth_stencil_state = &object->ID3D10DepthStencilState_iface;
2407
2408     return S_OK;
2409 }
2410
2411 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device1 *iface,
2412         const D3D10_RASTERIZER_DESC *desc, ID3D10RasterizerState **rasterizer_state)
2413 {
2414     struct d3d_device *device = impl_from_ID3D10Device(iface);
2415     struct d3d10_rasterizer_state *object;
2416     struct wine_rb_entry *entry;
2417     HRESULT hr;
2418
2419     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
2420
2421     if (!desc)
2422         return E_INVALIDARG;
2423
2424     wined3d_mutex_lock();
2425     if ((entry = wine_rb_get(&device->rasterizer_states, desc)))
2426     {
2427         object = WINE_RB_ENTRY_VALUE(entry, struct d3d10_rasterizer_state, entry);
2428
2429         TRACE("Returning existing rasterizer state %p.\n", object);
2430         *rasterizer_state = &object->ID3D10RasterizerState_iface;
2431         ID3D10RasterizerState_AddRef(*rasterizer_state);
2432         wined3d_mutex_unlock();
2433
2434         return S_OK;
2435     }
2436     wined3d_mutex_unlock();
2437
2438     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2439     if (!object)
2440         return E_OUTOFMEMORY;
2441
2442     if (FAILED(hr = d3d10_rasterizer_state_init(object, device, desc)))
2443     {
2444         WARN("Failed to initialize rasterizer state, hr %#x.\n", hr);
2445         HeapFree(GetProcessHeap(), 0, object);
2446         return hr;
2447     }
2448
2449     TRACE("Created rasterizer state %p.\n", object);
2450     *rasterizer_state = &object->ID3D10RasterizerState_iface;
2451
2452     return S_OK;
2453 }
2454
2455 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateSamplerState(ID3D10Device1 *iface,
2456         const D3D10_SAMPLER_DESC *desc, ID3D10SamplerState **sampler_state)
2457 {
2458     struct d3d_device *device = impl_from_ID3D10Device(iface);
2459     struct d3d10_sampler_state *object;
2460     struct wine_rb_entry *entry;
2461     HRESULT hr;
2462
2463     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
2464
2465     if (!desc)
2466         return E_INVALIDARG;
2467
2468     wined3d_mutex_lock();
2469     if ((entry = wine_rb_get(&device->sampler_states, desc)))
2470     {
2471         object = WINE_RB_ENTRY_VALUE(entry, struct d3d10_sampler_state, entry);
2472
2473         TRACE("Returning existing sampler state %p.\n", object);
2474         *sampler_state = &object->ID3D10SamplerState_iface;
2475         ID3D10SamplerState_AddRef(*sampler_state);
2476         wined3d_mutex_unlock();
2477
2478         return S_OK;
2479     }
2480     wined3d_mutex_unlock();
2481
2482     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2483     if (!object)
2484         return E_OUTOFMEMORY;
2485
2486     if (FAILED(hr = d3d10_sampler_state_init(object, device, desc)))
2487     {
2488         WARN("Failed to initialize sampler state, hr %#x.\n", hr);
2489         HeapFree(GetProcessHeap(), 0, object);
2490         return hr;
2491     }
2492
2493     TRACE("Created sampler state %p.\n", object);
2494     *sampler_state = &object->ID3D10SamplerState_iface;
2495
2496     return S_OK;
2497 }
2498
2499 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateQuery(ID3D10Device1 *iface,
2500         const D3D10_QUERY_DESC *desc, ID3D10Query **query)
2501 {
2502     struct d3d_device *device = impl_from_ID3D10Device(iface);
2503     struct d3d10_query *object;
2504     HRESULT hr;
2505
2506     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
2507
2508     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2509         return E_OUTOFMEMORY;
2510
2511     if (FAILED(hr = d3d10_query_init(object, device, desc, FALSE)))
2512     {
2513         WARN("Failed to initialize query, hr %#x.\n", hr);
2514         HeapFree(GetProcessHeap(), 0, object);
2515         return hr;
2516     }
2517
2518     TRACE("Created query %p.\n", object);
2519     *query = &object->ID3D10Query_iface;
2520
2521     return S_OK;
2522 }
2523
2524 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePredicate(ID3D10Device1 *iface,
2525         const D3D10_QUERY_DESC *desc, ID3D10Predicate **predicate)
2526 {
2527     struct d3d_device *device = impl_from_ID3D10Device(iface);
2528     struct d3d10_query *object;
2529     HRESULT hr;
2530
2531     TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
2532
2533     if (!desc)
2534         return E_INVALIDARG;
2535
2536     if (desc->Query != D3D10_QUERY_OCCLUSION_PREDICATE && desc->Query != D3D10_QUERY_SO_OVERFLOW_PREDICATE)
2537     {
2538         WARN("Query type %#x is not a predicate.\n", desc->Query);
2539         return E_INVALIDARG;
2540     }
2541
2542     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2543         return E_OUTOFMEMORY;
2544
2545     if (FAILED(hr = d3d10_query_init(object, device, desc, TRUE)))
2546     {
2547         WARN("Failed to initialize predicate, hr %#x.\n", hr);
2548         HeapFree(GetProcessHeap(), 0, object);
2549         return hr;
2550     }
2551
2552     TRACE("Created predicate %p.\n", object);
2553     *predicate = (ID3D10Predicate *)&object->ID3D10Query_iface;
2554
2555     return S_OK;
2556 }
2557
2558 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateCounter(ID3D10Device1 *iface,
2559         const D3D10_COUNTER_DESC *desc, ID3D10Counter **counter)
2560 {
2561     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
2562
2563     return E_NOTIMPL;
2564 }
2565
2566 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckFormatSupport(ID3D10Device1 *iface,
2567         DXGI_FORMAT format, UINT *format_support)
2568 {
2569     FIXME("iface %p, format %s, format_support %p stub!\n",
2570             iface, debug_dxgi_format(format), format_support);
2571
2572     return E_NOTIMPL;
2573 }
2574
2575 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckMultisampleQualityLevels(ID3D10Device1 *iface,
2576         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
2577 {
2578     FIXME("iface %p, format %s, sample_count %u, quality_level_count %p stub!\n",
2579             iface, debug_dxgi_format(format), sample_count, quality_level_count);
2580
2581     return E_NOTIMPL;
2582 }
2583
2584 static void STDMETHODCALLTYPE d3d10_device_CheckCounterInfo(ID3D10Device1 *iface, D3D10_COUNTER_INFO *counter_info)
2585 {
2586     FIXME("iface %p, counter_info %p stub!\n", iface, counter_info);
2587 }
2588
2589 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckCounter(ID3D10Device1 *iface,
2590         const D3D10_COUNTER_DESC *desc, D3D10_COUNTER_TYPE *type, UINT *active_counters, char *name,
2591         UINT *name_length, char *units, UINT *units_length, char *description, UINT *description_length)
2592 {
2593     FIXME("iface %p, desc %p, type %p, active_counters %p, name %p, name_length %p, "
2594             "units %p, units_length %p, description %p, description_length %p stub!\n",
2595             iface, desc, type, active_counters, name, name_length,
2596             units, units_length, description, description_length);
2597
2598     return E_NOTIMPL;
2599 }
2600
2601 static UINT STDMETHODCALLTYPE d3d10_device_GetCreationFlags(ID3D10Device1 *iface)
2602 {
2603     FIXME("iface %p stub!\n", iface);
2604
2605     return 0;
2606 }
2607
2608 static HRESULT STDMETHODCALLTYPE d3d10_device_OpenSharedResource(ID3D10Device1 *iface,
2609         HANDLE resource_handle, REFIID guid, void **resource)
2610 {
2611     FIXME("iface %p, resource_handle %p, guid %s, resource %p stub!\n",
2612             iface, resource_handle, debugstr_guid(guid), resource);
2613
2614     return E_NOTIMPL;
2615 }
2616
2617 static void STDMETHODCALLTYPE d3d10_device_SetTextFilterSize(ID3D10Device1 *iface, UINT width, UINT height)
2618 {
2619     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
2620 }
2621
2622 static void STDMETHODCALLTYPE d3d10_device_GetTextFilterSize(ID3D10Device1 *iface, UINT *width, UINT *height)
2623 {
2624     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
2625 }
2626
2627 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView1(ID3D10Device1 *iface,
2628         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc, ID3D10ShaderResourceView1 **view)
2629 {
2630     FIXME("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
2631
2632     return E_NOTIMPL;
2633 }
2634
2635 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState1(ID3D10Device1 *iface,
2636         const D3D10_BLEND_DESC1 *desc, ID3D10BlendState1 **blend_state)
2637 {
2638     FIXME("iface %p, desc %p, blend_state %p stub!\n", iface, desc, blend_state);
2639
2640     return E_NOTIMPL;
2641 }
2642
2643 static D3D10_FEATURE_LEVEL1 STDMETHODCALLTYPE d3d10_device_GetFeatureLevel(ID3D10Device1 *iface)
2644 {
2645     FIXME("iface %p stub!\n", iface);
2646
2647     return D3D10_FEATURE_LEVEL_10_1;
2648 }
2649
2650 static const struct ID3D10Device1Vtbl d3d10_device1_vtbl =
2651 {
2652     /* IUnknown methods */
2653     d3d10_device_QueryInterface,
2654     d3d10_device_AddRef,
2655     d3d10_device_Release,
2656     /* ID3D10Device methods */
2657     d3d10_device_VSSetConstantBuffers,
2658     d3d10_device_PSSetShaderResources,
2659     d3d10_device_PSSetShader,
2660     d3d10_device_PSSetSamplers,
2661     d3d10_device_VSSetShader,
2662     d3d10_device_DrawIndexed,
2663     d3d10_device_Draw,
2664     d3d10_device_PSSetConstantBuffers,
2665     d3d10_device_IASetInputLayout,
2666     d3d10_device_IASetVertexBuffers,
2667     d3d10_device_IASetIndexBuffer,
2668     d3d10_device_DrawIndexedInstanced,
2669     d3d10_device_DrawInstanced,
2670     d3d10_device_GSSetConstantBuffers,
2671     d3d10_device_GSSetShader,
2672     d3d10_device_IASetPrimitiveTopology,
2673     d3d10_device_VSSetShaderResources,
2674     d3d10_device_VSSetSamplers,
2675     d3d10_device_SetPredication,
2676     d3d10_device_GSSetShaderResources,
2677     d3d10_device_GSSetSamplers,
2678     d3d10_device_OMSetRenderTargets,
2679     d3d10_device_OMSetBlendState,
2680     d3d10_device_OMSetDepthStencilState,
2681     d3d10_device_SOSetTargets,
2682     d3d10_device_DrawAuto,
2683     d3d10_device_RSSetState,
2684     d3d10_device_RSSetViewports,
2685     d3d10_device_RSSetScissorRects,
2686     d3d10_device_CopySubresourceRegion,
2687     d3d10_device_CopyResource,
2688     d3d10_device_UpdateSubresource,
2689     d3d10_device_ClearRenderTargetView,
2690     d3d10_device_ClearDepthStencilView,
2691     d3d10_device_GenerateMips,
2692     d3d10_device_ResolveSubresource,
2693     d3d10_device_VSGetConstantBuffers,
2694     d3d10_device_PSGetShaderResources,
2695     d3d10_device_PSGetShader,
2696     d3d10_device_PSGetSamplers,
2697     d3d10_device_VSGetShader,
2698     d3d10_device_PSGetConstantBuffers,
2699     d3d10_device_IAGetInputLayout,
2700     d3d10_device_IAGetVertexBuffers,
2701     d3d10_device_IAGetIndexBuffer,
2702     d3d10_device_GSGetConstantBuffers,
2703     d3d10_device_GSGetShader,
2704     d3d10_device_IAGetPrimitiveTopology,
2705     d3d10_device_VSGetShaderResources,
2706     d3d10_device_VSGetSamplers,
2707     d3d10_device_GetPredication,
2708     d3d10_device_GSGetShaderResources,
2709     d3d10_device_GSGetSamplers,
2710     d3d10_device_OMGetRenderTargets,
2711     d3d10_device_OMGetBlendState,
2712     d3d10_device_OMGetDepthStencilState,
2713     d3d10_device_SOGetTargets,
2714     d3d10_device_RSGetState,
2715     d3d10_device_RSGetViewports,
2716     d3d10_device_RSGetScissorRects,
2717     d3d10_device_GetDeviceRemovedReason,
2718     d3d10_device_SetExceptionMode,
2719     d3d10_device_GetExceptionMode,
2720     d3d10_device_GetPrivateData,
2721     d3d10_device_SetPrivateData,
2722     d3d10_device_SetPrivateDataInterface,
2723     d3d10_device_ClearState,
2724     d3d10_device_Flush,
2725     d3d10_device_CreateBuffer,
2726     d3d10_device_CreateTexture1D,
2727     d3d10_device_CreateTexture2D,
2728     d3d10_device_CreateTexture3D,
2729     d3d10_device_CreateShaderResourceView,
2730     d3d10_device_CreateRenderTargetView,
2731     d3d10_device_CreateDepthStencilView,
2732     d3d10_device_CreateInputLayout,
2733     d3d10_device_CreateVertexShader,
2734     d3d10_device_CreateGeometryShader,
2735     d3d10_device_CreateGeometryShaderWithStreamOutput,
2736     d3d10_device_CreatePixelShader,
2737     d3d10_device_CreateBlendState,
2738     d3d10_device_CreateDepthStencilState,
2739     d3d10_device_CreateRasterizerState,
2740     d3d10_device_CreateSamplerState,
2741     d3d10_device_CreateQuery,
2742     d3d10_device_CreatePredicate,
2743     d3d10_device_CreateCounter,
2744     d3d10_device_CheckFormatSupport,
2745     d3d10_device_CheckMultisampleQualityLevels,
2746     d3d10_device_CheckCounterInfo,
2747     d3d10_device_CheckCounter,
2748     d3d10_device_GetCreationFlags,
2749     d3d10_device_OpenSharedResource,
2750     d3d10_device_SetTextFilterSize,
2751     d3d10_device_GetTextFilterSize,
2752     d3d10_device_CreateShaderResourceView1,
2753     d3d10_device_CreateBlendState1,
2754     d3d10_device_GetFeatureLevel,
2755 };
2756
2757 static const struct IUnknownVtbl d3d10_device_inner_unknown_vtbl =
2758 {
2759     /* IUnknown methods */
2760     d3d10_device_inner_QueryInterface,
2761     d3d10_device_inner_AddRef,
2762     d3d10_device_inner_Release,
2763 };
2764
2765 /* ID3D10Multithread methods */
2766
2767 static inline struct d3d_device *impl_from_ID3D10Multithread(ID3D10Multithread *iface)
2768 {
2769     return CONTAINING_RECORD(iface, struct d3d_device, ID3D10Multithread_iface);
2770 }
2771
2772 static HRESULT STDMETHODCALLTYPE d3d10_multithread_QueryInterface(ID3D10Multithread *iface, REFIID iid, void **out)
2773 {
2774     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
2775
2776     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
2777
2778     return IUnknown_QueryInterface(device->outer_unk, iid, out);
2779 }
2780
2781 static ULONG STDMETHODCALLTYPE d3d10_multithread_AddRef(ID3D10Multithread *iface)
2782 {
2783     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
2784
2785     TRACE("iface %p.\n", iface);
2786
2787     return IUnknown_AddRef(device->outer_unk);
2788 }
2789
2790 static ULONG STDMETHODCALLTYPE d3d10_multithread_Release(ID3D10Multithread *iface)
2791 {
2792     struct d3d_device *device = impl_from_ID3D10Multithread(iface);
2793
2794     TRACE("iface %p.\n", iface);
2795
2796     return IUnknown_Release(device->outer_unk);
2797 }
2798
2799 static void STDMETHODCALLTYPE d3d10_multithread_Enter(ID3D10Multithread *iface)
2800 {
2801     TRACE("iface %p.\n", iface);
2802
2803     wined3d_mutex_lock();
2804 }
2805
2806 static void STDMETHODCALLTYPE d3d10_multithread_Leave(ID3D10Multithread *iface)
2807 {
2808     TRACE("iface %p.\n", iface);
2809
2810     wined3d_mutex_unlock();
2811 }
2812
2813 static BOOL STDMETHODCALLTYPE d3d10_multithread_SetMultithreadProtected(ID3D10Multithread *iface, BOOL protect)
2814 {
2815     FIXME("iface %p, protect %#x stub!\n", iface, protect);
2816
2817     return TRUE;
2818 }
2819
2820 static BOOL STDMETHODCALLTYPE d3d10_multithread_GetMultithreadProtected(ID3D10Multithread *iface)
2821 {
2822     FIXME("iface %p stub!\n", iface);
2823
2824     return TRUE;
2825 }
2826
2827 static const struct ID3D10MultithreadVtbl d3d10_multithread_vtbl =
2828 {
2829     d3d10_multithread_QueryInterface,
2830     d3d10_multithread_AddRef,
2831     d3d10_multithread_Release,
2832     d3d10_multithread_Enter,
2833     d3d10_multithread_Leave,
2834     d3d10_multithread_SetMultithreadProtected,
2835     d3d10_multithread_GetMultithreadProtected,
2836 };
2837
2838 /* IWineDXGIDeviceParent IUnknown methods */
2839
2840 static inline struct d3d_device *device_from_dxgi_device_parent(IWineDXGIDeviceParent *iface)
2841 {
2842     return CONTAINING_RECORD(iface, struct d3d_device, IWineDXGIDeviceParent_iface);
2843 }
2844
2845 static HRESULT STDMETHODCALLTYPE dxgi_device_parent_QueryInterface(IWineDXGIDeviceParent *iface,
2846         REFIID riid, void **ppv)
2847 {
2848     struct d3d_device *device = device_from_dxgi_device_parent(iface);
2849     return IUnknown_QueryInterface(device->outer_unk, riid, ppv);
2850 }
2851
2852 static ULONG STDMETHODCALLTYPE dxgi_device_parent_AddRef(IWineDXGIDeviceParent *iface)
2853 {
2854     struct d3d_device *device = device_from_dxgi_device_parent(iface);
2855     return IUnknown_AddRef(device->outer_unk);
2856 }
2857
2858 static ULONG STDMETHODCALLTYPE dxgi_device_parent_Release(IWineDXGIDeviceParent *iface)
2859 {
2860     struct d3d_device *device = device_from_dxgi_device_parent(iface);
2861     return IUnknown_Release(device->outer_unk);
2862 }
2863
2864 static struct wined3d_device_parent * STDMETHODCALLTYPE dxgi_device_parent_get_wined3d_device_parent(
2865         IWineDXGIDeviceParent *iface)
2866 {
2867     struct d3d_device *device = device_from_dxgi_device_parent(iface);
2868     return &device->device_parent;
2869 }
2870
2871 static const struct IWineDXGIDeviceParentVtbl d3d10_dxgi_device_parent_vtbl =
2872 {
2873     /* IUnknown methods */
2874     dxgi_device_parent_QueryInterface,
2875     dxgi_device_parent_AddRef,
2876     dxgi_device_parent_Release,
2877     /* IWineDXGIDeviceParent methods */
2878     dxgi_device_parent_get_wined3d_device_parent,
2879 };
2880
2881 static inline struct d3d_device *device_from_wined3d_device_parent(struct wined3d_device_parent *device_parent)
2882 {
2883     return CONTAINING_RECORD(device_parent, struct d3d_device, device_parent);
2884 }
2885
2886 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
2887         struct wined3d_device *wined3d_device)
2888 {
2889     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
2890
2891     TRACE("device_parent %p, wined3d_device %p.\n", device_parent, wined3d_device);
2892
2893     wined3d_device_incref(wined3d_device);
2894     device->wined3d_device = wined3d_device;
2895 }
2896
2897 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
2898 {
2899     TRACE("device_parent %p.\n", device_parent);
2900 }
2901
2902 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
2903 {
2904     TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
2905 }
2906
2907 static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent *device_parent,
2908         void *container_parent, struct wined3d_surface *surface, void **parent,
2909         const struct wined3d_parent_ops **parent_ops)
2910 {
2911     TRACE("device_parent %p, container_parent %p, surface %p, parent %p, parent_ops %p.\n",
2912             device_parent, container_parent, surface, parent, parent_ops);
2913
2914     *parent = NULL;
2915     *parent_ops = &d3d10_null_wined3d_parent_ops;
2916
2917     return S_OK;
2918 }
2919
2920 static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent *device_parent,
2921         void *container_parent, struct wined3d_volume *volume, void **parent,
2922         const struct wined3d_parent_ops **parent_ops)
2923 {
2924     TRACE("device_parent %p, container_parent %p, volume %p, parent %p, parent_ops %p.\n",
2925             device_parent, container_parent, volume, parent, parent_ops);
2926
2927     *parent = NULL;
2928     *parent_ops = &d3d10_null_wined3d_parent_ops;
2929
2930     return S_OK;
2931 }
2932
2933 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
2934         void *container_parent, const struct wined3d_resource_desc *wined3d_desc,
2935         struct wined3d_texture **wined3d_texture)
2936 {
2937     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
2938     struct d3d_texture2d *texture;
2939     ID3D10Texture2D *texture_iface;
2940     D3D10_TEXTURE2D_DESC desc;
2941     HRESULT hr;
2942
2943     FIXME("device_parent %p, container_parent %p, wined3d_desc %p, wined3d_texture %p partial stub!\n",
2944             device_parent, container_parent, wined3d_desc, wined3d_texture);
2945
2946     FIXME("Implement DXGI<->wined3d usage conversion\n");
2947
2948     desc.Width = wined3d_desc->width;
2949     desc.Height = wined3d_desc->height;
2950     desc.MipLevels = 1;
2951     desc.ArraySize = 1;
2952     desc.Format = dxgi_format_from_wined3dformat(wined3d_desc->format);
2953     desc.SampleDesc.Count = wined3d_desc->multisample_type ? wined3d_desc->multisample_type : 1;
2954     desc.SampleDesc.Quality = wined3d_desc->multisample_quality;
2955     desc.Usage = D3D10_USAGE_DEFAULT;
2956     desc.BindFlags = D3D10_BIND_RENDER_TARGET;
2957     desc.CPUAccessFlags = 0;
2958     desc.MiscFlags = 0;
2959
2960     if (FAILED(hr = d3d10_device_CreateTexture2D(&device->ID3D10Device1_iface,
2961             &desc, NULL, &texture_iface)))
2962     {
2963         ERR("CreateTexture2D failed, returning %#x\n", hr);
2964         return hr;
2965     }
2966
2967     texture = impl_from_ID3D10Texture2D(texture_iface);
2968
2969     *wined3d_texture = texture->wined3d_texture;
2970     wined3d_texture_incref(*wined3d_texture);
2971     ID3D10Texture2D_Release(&texture->ID3D10Texture2D_iface);
2972
2973     return S_OK;
2974 }
2975
2976 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
2977         struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
2978 {
2979     struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
2980     IWineDXGIDevice *wine_device;
2981     HRESULT hr;
2982
2983     TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
2984
2985     if (FAILED(hr = d3d10_device_QueryInterface(&device->ID3D10Device1_iface,
2986             &IID_IWineDXGIDevice, (void **)&wine_device)))
2987     {
2988         ERR("Device should implement IWineDXGIDevice.\n");
2989         return E_FAIL;
2990     }
2991
2992     hr = IWineDXGIDevice_create_swapchain(wine_device, desc, swapchain);
2993     IWineDXGIDevice_Release(wine_device);
2994     if (FAILED(hr))
2995     {
2996         ERR("Failed to create DXGI swapchain, returning %#x\n", hr);
2997         return hr;
2998     }
2999
3000     return S_OK;
3001 }
3002
3003 static const struct wined3d_device_parent_ops d3d10_wined3d_device_parent_ops =
3004 {
3005     device_parent_wined3d_device_created,
3006     device_parent_mode_changed,
3007     device_parent_activate,
3008     device_parent_surface_created,
3009     device_parent_volume_created,
3010     device_parent_create_swapchain_texture,
3011     device_parent_create_swapchain,
3012 };
3013
3014 static void *d3d10_rb_alloc(size_t size)
3015 {
3016     return HeapAlloc(GetProcessHeap(), 0, size);
3017 }
3018
3019 static void *d3d10_rb_realloc(void *ptr, size_t size)
3020 {
3021     return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
3022 }
3023
3024 static void d3d10_rb_free(void *ptr)
3025 {
3026     HeapFree(GetProcessHeap(), 0, ptr);
3027 }
3028
3029 static int d3d10_sampler_state_compare(const void *key, const struct wine_rb_entry *entry)
3030 {
3031     const D3D10_SAMPLER_DESC *ka = key;
3032     const D3D10_SAMPLER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d10_sampler_state, entry)->desc;
3033
3034     return memcmp(ka, kb, sizeof(*ka));
3035 }
3036
3037 static const struct wine_rb_functions d3d10_sampler_state_rb_ops =
3038 {
3039     d3d10_rb_alloc,
3040     d3d10_rb_realloc,
3041     d3d10_rb_free,
3042     d3d10_sampler_state_compare,
3043 };
3044
3045 static int d3d10_blend_state_compare(const void *key, const struct wine_rb_entry *entry)
3046 {
3047     const D3D10_BLEND_DESC *ka = key;
3048     const D3D10_BLEND_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d10_blend_state, entry)->desc;
3049
3050     return memcmp(ka, kb, sizeof(*ka));
3051 }
3052
3053 static const struct wine_rb_functions d3d10_blend_state_rb_ops =
3054 {
3055     d3d10_rb_alloc,
3056     d3d10_rb_realloc,
3057     d3d10_rb_free,
3058     d3d10_blend_state_compare,
3059 };
3060
3061 static int d3d10_depthstencil_state_compare(const void *key, const struct wine_rb_entry *entry)
3062 {
3063     const D3D10_DEPTH_STENCIL_DESC *ka = key;
3064     const D3D10_DEPTH_STENCIL_DESC *kb = &WINE_RB_ENTRY_VALUE(entry,
3065             const struct d3d10_depthstencil_state, entry)->desc;
3066
3067     return memcmp(ka, kb, sizeof(*ka));
3068 }
3069
3070 static const struct wine_rb_functions d3d10_depthstencil_state_rb_ops =
3071 {
3072     d3d10_rb_alloc,
3073     d3d10_rb_realloc,
3074     d3d10_rb_free,
3075     d3d10_depthstencil_state_compare,
3076 };
3077
3078 static int d3d10_rasterizer_state_compare(const void *key, const struct wine_rb_entry *entry)
3079 {
3080     const D3D10_RASTERIZER_DESC *ka = key;
3081     const D3D10_RASTERIZER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d10_rasterizer_state, entry)->desc;
3082
3083     return memcmp(ka, kb, sizeof(*ka));
3084 }
3085
3086 static const struct wine_rb_functions d3d10_rasterizer_state_rb_ops =
3087 {
3088     d3d10_rb_alloc,
3089     d3d10_rb_realloc,
3090     d3d10_rb_free,
3091     d3d10_rasterizer_state_compare,
3092 };
3093
3094 HRESULT d3d10_device_init(struct d3d_device *device, void *outer_unknown)
3095 {
3096     device->IUnknown_inner.lpVtbl = &d3d10_device_inner_unknown_vtbl;
3097     device->ID3D11Device_iface.lpVtbl = &d3d11_device_vtbl;
3098     device->ID3D10Device1_iface.lpVtbl = &d3d10_device1_vtbl;
3099     device->ID3D10Multithread_iface.lpVtbl = &d3d10_multithread_vtbl;
3100     device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d10_dxgi_device_parent_vtbl;
3101     device->device_parent.ops = &d3d10_wined3d_device_parent_ops;
3102     device->refcount = 1;
3103     /* COM aggregation always takes place */
3104     device->outer_unk = outer_unknown;
3105
3106     if (wine_rb_init(&device->blend_states, &d3d10_blend_state_rb_ops) == -1)
3107     {
3108         WARN("Failed to initialize blend state rbtree.\n");
3109         return E_FAIL;
3110     }
3111     device->blend_factor[0] = 1.0f;
3112     device->blend_factor[1] = 1.0f;
3113     device->blend_factor[2] = 1.0f;
3114     device->blend_factor[3] = 1.0f;
3115
3116     if (wine_rb_init(&device->depthstencil_states, &d3d10_depthstencil_state_rb_ops) == -1)
3117     {
3118         WARN("Failed to initialize depthstencil state rbtree.\n");
3119         wine_rb_destroy(&device->blend_states, NULL, NULL);
3120         return E_FAIL;
3121     }
3122
3123     if (wine_rb_init(&device->rasterizer_states, &d3d10_rasterizer_state_rb_ops) == -1)
3124     {
3125         WARN("Failed to initialize rasterizer state rbtree.\n");
3126         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
3127         wine_rb_destroy(&device->blend_states, NULL, NULL);
3128         return E_FAIL;
3129     }
3130
3131     if (wine_rb_init(&device->sampler_states, &d3d10_sampler_state_rb_ops) == -1)
3132     {
3133         WARN("Failed to initialize sampler state rbtree.\n");
3134         wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
3135         wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
3136         wine_rb_destroy(&device->blend_states, NULL, NULL);
3137         return E_FAIL;
3138     }
3139
3140     return S_OK;
3141 }