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