dlls/d3d10core/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 #include "d3d10core_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10core);
  26
  27 static void STDMETHODCALLTYPE d3d10_null_wined3d_object_destroyed(void *parent) {}
  28
  29 const struct wined3d_parent_ops d3d10_null_wined3d_parent_ops =
  30 {
  31     d3d10_null_wined3d_object_destroyed,
  32 };
  33
  34 /* Inner IUnknown methods */
  35
  36 static inline struct d3d10_device *impl_from_IUnknown(IUnknown *iface)
  37 {
  38     return CONTAINING_RECORD(iface, struct d3d10_device, IUnknown_inner);
  39 }
  40
  41 static HRESULT STDMETHODCALLTYPE d3d10_device_inner_QueryInterface(IUnknown *iface, REFIID riid,
  42         void **ppv)
  43 {
  44     struct d3d10_device *This = impl_from_IUnknown(iface);
  45
  46     TRACE("iface %p, riid %s, ppv %p\n", iface, debugstr_guid(riid), ppv);
  47
  48     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ID3D10Device))
  49         *ppv = &This->ID3D10Device_iface;
  50     else if (IsEqualGUID(riid, &IID_IWineDXGIDeviceParent))
  51         *ppv = &This->IWineDXGIDeviceParent_iface;
  52     else
  53     {
  54         WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  55         *ppv = NULL;
  56         return E_NOINTERFACE;
  57     }
  58
  59     IUnknown_AddRef((IUnknown*)*ppv);
  60     return S_OK;
  61 }
  62
  63 static ULONG STDMETHODCALLTYPE d3d10_device_inner_AddRef(IUnknown *iface)
  64 {
  65     struct d3d10_device *This = impl_from_IUnknown(iface);
  66     ULONG refcount = InterlockedIncrement(&This->refcount);
  67
  68     TRACE("%p increasing refcount to %u\n", This, refcount);
  69
  70     return refcount;
  71 }
  72
  73 static ULONG STDMETHODCALLTYPE d3d10_device_inner_Release(IUnknown *iface)
  74 {
  75     struct d3d10_device *This = impl_from_IUnknown(iface);
  76     ULONG refcount = InterlockedDecrement(&This->refcount);
  77
  78     TRACE("%p decreasing refcount to %u\n", This, refcount);
  79
  80     if (!refcount)
  81     {
  82         if (This->wined3d_device)
  83             wined3d_device_decref(This->wined3d_device);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 /* IUnknown methods */
  90
  91 static inline struct d3d10_device *impl_from_ID3D10Device(ID3D10Device *iface)
  92 {
  93     return CONTAINING_RECORD(iface, struct d3d10_device, ID3D10Device_iface);
  94 }
  95
  96 static HRESULT STDMETHODCALLTYPE d3d10_device_QueryInterface(ID3D10Device *iface, REFIID riid,
  97         void **ppv)
  98 {
  99     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 100     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 101 }
 102
 103 static ULONG STDMETHODCALLTYPE d3d10_device_AddRef(ID3D10Device *iface)
 104 {
 105     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 106     return IUnknown_AddRef(This->outer_unk);
 107 }
 108
 109 static ULONG STDMETHODCALLTYPE d3d10_device_Release(ID3D10Device *iface)
 110 {
 111     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 112     return IUnknown_Release(This->outer_unk);
 113 }
 114
 115 /* ID3D10Device methods */
 116
 117 static void STDMETHODCALLTYPE d3d10_device_VSSetConstantBuffers(ID3D10Device *iface,
 118         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 119 {
 120     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 121     unsigned int i;
 122
 123     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 124             iface, start_slot, buffer_count, buffers);
 125
 126     for (i = 0; i < buffer_count; ++i)
 127     {
 128         struct d3d10_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 129
 130         wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
 131                 buffer ? buffer->wined3d_buffer : NULL);
 132     }
 133 }
 134
 135 static void STDMETHODCALLTYPE d3d10_device_PSSetShaderResources(ID3D10Device *iface,
 136         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 137 {
 138     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 139             iface, start_slot, view_count, views);
 140 }
 141
 142 static void STDMETHODCALLTYPE d3d10_device_PSSetShader(ID3D10Device *iface,
 143         ID3D10PixelShader *shader)
 144 {
 145     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 146     struct d3d10_pixel_shader *ps = unsafe_impl_from_ID3D10PixelShader(shader);
 147
 148     TRACE("iface %p, shader %p\n", iface, shader);
 149
 150     wined3d_device_set_pixel_shader(This->wined3d_device, ps ? ps->wined3d_shader : NULL);
 151 }
 152
 153 static void STDMETHODCALLTYPE d3d10_device_PSSetSamplers(ID3D10Device *iface,
 154         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 155 {
 156     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 157     unsigned int i;
 158
 159     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 160             iface, start_slot, sampler_count, samplers);
 161
 162     for (i = 0; i < sampler_count; ++i)
 163     {
 164         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 165
 166         wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
 167                 sampler ? sampler->wined3d_sampler : NULL);
 168     }
 169 }
 170
 171 static void STDMETHODCALLTYPE d3d10_device_VSSetShader(ID3D10Device *iface,
 172         ID3D10VertexShader *shader)
 173 {
 174     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 175     struct d3d10_vertex_shader *vs = unsafe_impl_from_ID3D10VertexShader(shader);
 176
 177     TRACE("iface %p, shader %p\n", iface, shader);
 178
 179     wined3d_device_set_vertex_shader(This->wined3d_device, vs ? vs->wined3d_shader : NULL);
 180 }
 181
 182 static void STDMETHODCALLTYPE d3d10_device_DrawIndexed(ID3D10Device *iface, UINT index_count,
 183         UINT start_index_location, INT base_vertex_location)
 184 {
 185     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 186
 187     TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
 188             iface, index_count, start_index_location, base_vertex_location);
 189
 190     wined3d_device_set_base_vertex_index(This->wined3d_device, base_vertex_location);
 191     wined3d_device_draw_indexed_primitive(This->wined3d_device, start_index_location, index_count);
 192 }
 193
 194 static void STDMETHODCALLTYPE d3d10_device_Draw(ID3D10Device *iface, UINT vertex_count,
 195         UINT start_vertex_location)
 196 {
 197     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 198
 199     TRACE("iface %p, vertex_count %u, start_vertex_location %u\n",
 200             iface, vertex_count, start_vertex_location);
 201
 202     wined3d_device_draw_primitive(This->wined3d_device, start_vertex_location, vertex_count);
 203 }
 204
 205 static void STDMETHODCALLTYPE d3d10_device_PSSetConstantBuffers(ID3D10Device *iface,
 206         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 207 {
 208     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 209     unsigned int i;
 210
 211     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 212             iface, start_slot, buffer_count, buffers);
 213
 214     for (i = 0; i < buffer_count; ++i)
 215     {
 216         struct d3d10_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 217
 218         wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
 219                 buffer ? buffer->wined3d_buffer : NULL);
 220     }
 221 }
 222
 223 static void STDMETHODCALLTYPE d3d10_device_IASetInputLayout(ID3D10Device *iface,
 224         ID3D10InputLayout *input_layout)
 225 {
 226     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 227     struct d3d10_input_layout *layout = unsafe_impl_from_ID3D10InputLayout(input_layout);
 228
 229     TRACE("iface %p, input_layout %p\n", iface, input_layout);
 230
 231     wined3d_device_set_vertex_declaration(This->wined3d_device,
 232             layout ? layout->wined3d_decl : NULL);
 233 }
 234
 235 static void STDMETHODCALLTYPE d3d10_device_IASetVertexBuffers(ID3D10Device *iface, UINT start_slot,
 236         UINT buffer_count, ID3D10Buffer *const *buffers, const UINT *strides, const UINT *offsets)
 237 {
 238     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 239     unsigned int i;
 240
 241     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p\n",
 242             iface, start_slot, buffer_count, buffers, strides, offsets);
 243
 244     for (i = 0; i < buffer_count; ++i)
 245     {
 246         struct d3d10_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 247
 248         wined3d_device_set_stream_source(This->wined3d_device, start_slot + i,
 249                 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
 250     }
 251 }
 252
 253 static void STDMETHODCALLTYPE d3d10_device_IASetIndexBuffer(ID3D10Device *iface,
 254         ID3D10Buffer *buffer, DXGI_FORMAT format, UINT offset)
 255 {
 256     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 257     struct d3d10_buffer *buffer_impl = unsafe_impl_from_ID3D10Buffer(buffer);
 258
 259     TRACE("iface %p, buffer %p, format %s, offset %u.\n",
 260             iface, buffer, debug_dxgi_format(format), offset);
 261
 262     wined3d_device_set_index_buffer(This->wined3d_device,
 263             buffer_impl ? buffer_impl->wined3d_buffer : NULL,
 264             wined3dformat_from_dxgi_format(format));
 265     if (offset) FIXME("offset %u not supported.\n", offset);
 266 }
 267
 268 static void STDMETHODCALLTYPE d3d10_device_DrawIndexedInstanced(ID3D10Device *iface,
 269         UINT instance_index_count, UINT instance_count, UINT start_index_location,
 270         INT base_vertex_location, UINT start_instance_location)
 271 {
 272     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 273
 274     TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u,\n"
 275             "\tbase_vertex_location %d, start_instance_location %u.\n",
 276             iface, instance_index_count, instance_count, start_index_location,
 277             base_vertex_location, start_instance_location);
 278
 279     wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
 280     wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
 281             instance_index_count, start_instance_location, instance_count);
 282 }
 283
 284 static void STDMETHODCALLTYPE d3d10_device_DrawInstanced(ID3D10Device *iface,
 285         UINT instance_vertex_count, UINT instance_count,
 286         UINT start_vertex_location, UINT start_instance_location)
 287 {
 288     FIXME("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u,\n"
 289             "\tstart_instance_location %u stub!\n", iface, instance_vertex_count, instance_count,
 290             start_vertex_location, start_instance_location);
 291 }
 292
 293 static void STDMETHODCALLTYPE d3d10_device_GSSetConstantBuffers(ID3D10Device *iface,
 294         UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
 295 {
 296     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 297     unsigned int i;
 298
 299     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 300             iface, start_slot, buffer_count, buffers);
 301
 302     for (i = 0; i < buffer_count; ++i)
 303     {
 304         struct d3d10_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
 305
 306         wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
 307                 buffer ? buffer->wined3d_buffer : NULL);
 308     }
 309 }
 310
 311 static void STDMETHODCALLTYPE d3d10_device_GSSetShader(ID3D10Device *iface, ID3D10GeometryShader *shader)
 312 {
 313     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 314     struct d3d10_geometry_shader *gs = unsafe_impl_from_ID3D10GeometryShader(shader);
 315
 316     TRACE("iface %p, shader %p.\n", iface, shader);
 317
 318     wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
 319 }
 320
 321 static void STDMETHODCALLTYPE d3d10_device_IASetPrimitiveTopology(ID3D10Device *iface,
 322         D3D10_PRIMITIVE_TOPOLOGY topology)
 323 {
 324     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 325
 326     TRACE("iface %p, topology %s\n", iface, debug_d3d10_primitive_topology(topology));
 327
 328     wined3d_device_set_primitive_type(This->wined3d_device, (enum wined3d_primitive_type)topology);
 329 }
 330
 331 static void STDMETHODCALLTYPE d3d10_device_VSSetShaderResources(ID3D10Device *iface,
 332         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 333 {
 334     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 335             iface, start_slot, view_count, views);
 336 }
 337
 338 static void STDMETHODCALLTYPE d3d10_device_VSSetSamplers(ID3D10Device *iface,
 339         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 340 {
 341     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 342     unsigned int i;
 343
 344     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 345             iface, start_slot, sampler_count, samplers);
 346
 347     for (i = 0; i < sampler_count; ++i)
 348     {
 349         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 350
 351         wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
 352                 sampler ? sampler->wined3d_sampler : NULL);
 353     }
 354 }
 355
 356 static void STDMETHODCALLTYPE d3d10_device_SetPredication(ID3D10Device *iface, ID3D10Predicate *predicate, BOOL value)
 357 {
 358     FIXME("iface %p, predicate %p, value %d stub!\n", iface, predicate, value);
 359 }
 360
 361 static void STDMETHODCALLTYPE d3d10_device_GSSetShaderResources(ID3D10Device *iface,
 362         UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
 363 {
 364     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 365             iface, start_slot, view_count, views);
 366 }
 367
 368 static void STDMETHODCALLTYPE d3d10_device_GSSetSamplers(ID3D10Device *iface,
 369         UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
 370 {
 371     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 372     unsigned int i;
 373
 374     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 375             iface, start_slot, sampler_count, samplers);
 376
 377     for (i = 0; i < sampler_count; ++i)
 378     {
 379         struct d3d10_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
 380
 381         wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
 382                 sampler ? sampler->wined3d_sampler : NULL);
 383     }
 384 }
 385
 386 static void STDMETHODCALLTYPE d3d10_device_OMSetRenderTargets(ID3D10Device *iface,
 387         UINT render_target_view_count, ID3D10RenderTargetView *const *render_target_views,
 388         ID3D10DepthStencilView *depth_stencil_view)
 389 {
 390     FIXME("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p\n",
 391             iface, render_target_view_count, render_target_views, depth_stencil_view);
 392 }
 393
 394 static void STDMETHODCALLTYPE d3d10_device_OMSetBlendState(ID3D10Device *iface,
 395         ID3D10BlendState *blend_state, const FLOAT blend_factor[4], UINT sample_mask)
 396 {
 397     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 398
 399     TRACE("iface %p, blend_state %p, blend_factor [%f %f %f %f], sample_mask 0x%08x.\n",
 400             iface, blend_state, blend_factor[0], blend_factor[1], blend_factor[2], blend_factor[3], sample_mask);
 401
 402     device->blend_state = unsafe_impl_from_ID3D10BlendState(blend_state);
 403     memcpy(device->blend_factor, blend_factor, 4 * sizeof(*blend_factor));
 404     device->sample_mask = sample_mask;
 405 }
 406
 407 static void STDMETHODCALLTYPE d3d10_device_OMSetDepthStencilState(ID3D10Device *iface,
 408         ID3D10DepthStencilState *depth_stencil_state, UINT stencil_ref)
 409 {
 410     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 411
 412     TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
 413             iface, depth_stencil_state, stencil_ref);
 414
 415     device->depth_stencil_state = unsafe_impl_from_ID3D10DepthStencilState(depth_stencil_state);
 416     device->stencil_ref = stencil_ref;
 417 }
 418
 419 static void STDMETHODCALLTYPE d3d10_device_SOSetTargets(ID3D10Device *iface,
 420         UINT target_count, ID3D10Buffer *const *targets, const UINT *offsets)
 421 {
 422     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 423     unsigned int count, i;
 424
 425     TRACE("iface %p, target_count %u, targets %p, offsets %p.\n", iface, target_count, targets, offsets);
 426
 427     count = min(target_count, 4);
 428     for (i = 0; i < count; ++i)
 429     {
 430         struct d3d10_buffer *buffer = unsafe_impl_from_ID3D10Buffer(targets[i]);
 431
 432         wined3d_device_set_stream_output(device->wined3d_device, i,
 433                 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
 434     }
 435
 436     for (i = count; i < 4; ++i)
 437     {
 438         wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
 439     }
 440 }
 441
 442 static void STDMETHODCALLTYPE d3d10_device_DrawAuto(ID3D10Device *iface)
 443 {
 444     FIXME("iface %p stub!\n", iface);
 445 }
 446
 447 static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device *iface, ID3D10RasterizerState *rasterizer_state)
 448 {
 449     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 450
 451     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
 452
 453     device->rasterizer_state = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state);
 454 }
 455
 456 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device *iface,
 457         UINT viewport_count, const D3D10_VIEWPORT *viewports)
 458 {
 459     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 460     struct wined3d_viewport wined3d_vp;
 461
 462     TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
 463
 464     if (viewport_count > 1)
 465         FIXME("Multiple viewports not implemented.\n");
 466
 467     if (!viewport_count)
 468         return;
 469
 470     wined3d_vp.x = viewports[0].TopLeftX;
 471     wined3d_vp.y = viewports[0].TopLeftY;
 472     wined3d_vp.width = viewports[0].Width;
 473     wined3d_vp.height = viewports[0].Height;
 474     wined3d_vp.min_z = viewports[0].MinDepth;
 475     wined3d_vp.max_z = viewports[0].MaxDepth;
 476
 477     wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
 478 }
 479
 480 static void STDMETHODCALLTYPE d3d10_device_RSSetScissorRects(ID3D10Device *iface,
 481         UINT rect_count, const D3D10_RECT *rects)
 482 {
 483     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 484
 485     TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
 486
 487     if (rect_count > 1)
 488         FIXME("Multiple scissor rects not implemented.\n");
 489
 490     if (!rect_count)
 491         return;
 492
 493     wined3d_device_set_scissor_rect(device->wined3d_device, rects);
 494 }
 495
 496 static void STDMETHODCALLTYPE d3d10_device_CopySubresourceRegion(ID3D10Device *iface,
 497         ID3D10Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
 498         ID3D10Resource *src_resource, UINT src_subresource_idx, const D3D10_BOX *src_box)
 499 {
 500     FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u,\n"
 501             "\tsrc_resource %p, src_subresource_idx %u, src_box %p stub!\n",
 502             iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
 503             src_resource, src_subresource_idx, src_box);
 504 }
 505
 506 static void STDMETHODCALLTYPE d3d10_device_CopyResource(ID3D10Device *iface,
 507         ID3D10Resource *dst_resource, ID3D10Resource *src_resource)
 508 {
 509     FIXME("iface %p, dst_resource %p, src_resource %p stub!\n", iface, dst_resource, src_resource);
 510 }
 511
 512 static void STDMETHODCALLTYPE d3d10_device_UpdateSubresource(ID3D10Device *iface,
 513         ID3D10Resource *resource, UINT subresource_idx, const D3D10_BOX *box,
 514         const void *data, UINT row_pitch, UINT depth_pitch)
 515 {
 516     FIXME("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u stub!\n",
 517             iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
 518 }
 519
 520 static void STDMETHODCALLTYPE d3d10_device_ClearRenderTargetView(ID3D10Device *iface,
 521         ID3D10RenderTargetView *render_target_view, const FLOAT color_rgba[4])
 522 {
 523     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 524     struct d3d10_rendertarget_view *view = unsafe_impl_from_ID3D10RenderTargetView(render_target_view);
 525     const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
 526
 527     TRACE("iface %p, render_target_view %p, color_rgba [%f %f %f %f]\n",
 528             iface, render_target_view, color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]);
 529
 530     wined3d_device_clear_rendertarget_view(This->wined3d_device, view->wined3d_view, &color);
 531 }
 532
 533 static void STDMETHODCALLTYPE d3d10_device_ClearDepthStencilView(ID3D10Device *iface,
 534         ID3D10DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
 535 {
 536     FIXME("iface %p, depth_stencil_view %p, flags %#x, depth %f, stencil %u stub!\n",
 537             iface, depth_stencil_view, flags, depth, stencil);
 538 }
 539
 540 static void STDMETHODCALLTYPE d3d10_device_GenerateMips(ID3D10Device *iface, ID3D10ShaderResourceView *shader_resource_view)
 541 {
 542     FIXME("iface %p, shader_resource_view %p stub!\n", iface, shader_resource_view);
 543 }
 544
 545 static void STDMETHODCALLTYPE d3d10_device_ResolveSubresource(ID3D10Device *iface,
 546         ID3D10Resource *dst_resource, UINT dst_subresource_idx,
 547         ID3D10Resource *src_resource, UINT src_subresource_idx, DXGI_FORMAT format)
 548 {
 549     FIXME("iface %p, dst_resource %p, dst_subresource_idx %u,\n"
 550             "\tsrc_resource %p, src_subresource_idx %u, format %s stub!\n",
 551             iface, dst_resource, dst_subresource_idx,
 552             src_resource, src_subresource_idx, debug_dxgi_format(format));
 553 }
 554
 555 static void STDMETHODCALLTYPE d3d10_device_VSGetConstantBuffers(ID3D10Device *iface,
 556         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
 557 {
 558     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 559     unsigned int i;
 560
 561     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 562             iface, start_slot, buffer_count, buffers);
 563
 564     for (i = 0; i < buffer_count; ++i)
 565     {
 566         struct wined3d_buffer *wined3d_buffer;
 567         struct d3d10_buffer *buffer_impl;
 568
 569         if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
 570         {
 571             buffers[i] = NULL;
 572             continue;
 573         }
 574
 575         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 576         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
 577         ID3D10Buffer_AddRef(buffers[i]);
 578     }
 579 }
 580
 581 static void STDMETHODCALLTYPE d3d10_device_PSGetShaderResources(ID3D10Device *iface,
 582         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
 583 {
 584     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 585             iface, start_slot, view_count, views);
 586 }
 587
 588 static void STDMETHODCALLTYPE d3d10_device_PSGetShader(ID3D10Device *iface, ID3D10PixelShader **shader)
 589 {
 590     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 591     struct d3d10_pixel_shader *shader_impl;
 592     struct wined3d_shader *wined3d_shader;
 593
 594     TRACE("iface %p, shader %p.\n", iface, shader);
 595
 596     if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
 597     {
 598         *shader = NULL;
 599         return;
 600     }
 601
 602     shader_impl = wined3d_shader_get_parent(wined3d_shader);
 603     *shader = &shader_impl->ID3D10PixelShader_iface;
 604     ID3D10PixelShader_AddRef(*shader);
 605 }
 606
 607 static void STDMETHODCALLTYPE d3d10_device_PSGetSamplers(ID3D10Device *iface,
 608         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
 609 {
 610     FIXME("iface %p, start_slot %u, sampler_count %u, samplers %p stub!\n",
 611             iface, start_slot, sampler_count, samplers);
 612 }
 613
 614 static void STDMETHODCALLTYPE d3d10_device_VSGetShader(ID3D10Device *iface, ID3D10VertexShader **shader)
 615 {
 616     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 617     struct d3d10_vertex_shader *shader_impl;
 618     struct wined3d_shader *wined3d_shader;
 619
 620     TRACE("iface %p, shader %p.\n", iface, shader);
 621
 622     if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
 623     {
 624         *shader = NULL;
 625         return;
 626     }
 627
 628     shader_impl = wined3d_shader_get_parent(wined3d_shader);
 629     *shader = &shader_impl->ID3D10VertexShader_iface;
 630     ID3D10VertexShader_AddRef(*shader);
 631 }
 632
 633 static void STDMETHODCALLTYPE d3d10_device_PSGetConstantBuffers(ID3D10Device *iface,
 634         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
 635 {
 636     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 637     unsigned int i;
 638
 639     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 640             iface, start_slot, buffer_count, buffers);
 641
 642     for (i = 0; i < buffer_count; ++i)
 643     {
 644         struct wined3d_buffer *wined3d_buffer;
 645         struct d3d10_buffer *buffer_impl;
 646
 647         if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
 648         {
 649             buffers[i] = NULL;
 650             continue;
 651         }
 652
 653         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 654         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
 655         ID3D10Buffer_AddRef(buffers[i]);
 656     }
 657 }
 658
 659 static void STDMETHODCALLTYPE d3d10_device_IAGetInputLayout(ID3D10Device *iface, ID3D10InputLayout **input_layout)
 660 {
 661     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 662     struct wined3d_vertex_declaration *wined3d_declaration;
 663     struct d3d10_input_layout *input_layout_impl;
 664
 665     TRACE("iface %p, input_layout %p.\n", iface, input_layout);
 666
 667     if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
 668     {
 669         *input_layout = NULL;
 670         return;
 671     }
 672
 673     input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
 674     *input_layout = &input_layout_impl->ID3D10InputLayout_iface;
 675     ID3D10InputLayout_AddRef(*input_layout);
 676 }
 677
 678 static void STDMETHODCALLTYPE d3d10_device_IAGetVertexBuffers(ID3D10Device *iface,
 679         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers, UINT *strides, UINT *offsets)
 680 {
 681     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 682     unsigned int i;
 683
 684     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
 685             iface, start_slot, buffer_count, buffers, strides, offsets);
 686
 687     for (i = 0; i < buffer_count; ++i)
 688     {
 689         struct wined3d_buffer *wined3d_buffer;
 690         struct d3d10_buffer *buffer_impl;
 691
 692         if (FAILED(wined3d_device_get_stream_source(device->wined3d_device, start_slot + i,
 693                 &wined3d_buffer, &offsets[i], &strides[i])))
 694             ERR("Failed to get vertex buffer.\n");
 695
 696         if (!wined3d_buffer)
 697         {
 698             buffers[i] = NULL;
 699             continue;
 700         }
 701
 702         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 703         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
 704         ID3D10Buffer_AddRef(buffers[i]);
 705     }
 706 }
 707
 708 static void STDMETHODCALLTYPE d3d10_device_IAGetIndexBuffer(ID3D10Device *iface,
 709         ID3D10Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
 710 {
 711     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 712     enum wined3d_format_id wined3d_format;
 713     struct wined3d_buffer *wined3d_buffer;
 714     struct d3d10_buffer *buffer_impl;
 715
 716     TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
 717
 718     wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format);
 719     *format = dxgi_format_from_wined3dformat(wined3d_format);
 720     *offset = 0; /* FIXME */
 721     if (!wined3d_buffer)
 722     {
 723         *buffer = NULL;
 724         return;
 725     }
 726
 727     buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 728     *buffer = &buffer_impl->ID3D10Buffer_iface;
 729     ID3D10Buffer_AddRef(*buffer);
 730 }
 731
 732 static void STDMETHODCALLTYPE d3d10_device_GSGetConstantBuffers(ID3D10Device *iface,
 733         UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
 734 {
 735     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 736     unsigned int i;
 737
 738     TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
 739             iface, start_slot, buffer_count, buffers);
 740
 741     for (i = 0; i < buffer_count; ++i)
 742     {
 743         struct wined3d_buffer *wined3d_buffer;
 744         struct d3d10_buffer *buffer_impl;
 745
 746         if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
 747         {
 748             buffers[i] = NULL;
 749             continue;
 750         }
 751
 752         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 753         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
 754         ID3D10Buffer_AddRef(buffers[i]);
 755     }
 756 }
 757
 758 static void STDMETHODCALLTYPE d3d10_device_GSGetShader(ID3D10Device *iface, ID3D10GeometryShader **shader)
 759 {
 760     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 761     struct d3d10_geometry_shader *shader_impl;
 762     struct wined3d_shader *wined3d_shader;
 763
 764     TRACE("iface %p, shader %p.\n", iface, shader);
 765
 766     if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
 767     {
 768         *shader = NULL;
 769         return;
 770     }
 771
 772     shader_impl = wined3d_shader_get_parent(wined3d_shader);
 773     *shader = &shader_impl->ID3D10GeometryShader_iface;
 774     ID3D10GeometryShader_AddRef(*shader);
 775 }
 776
 777 static void STDMETHODCALLTYPE d3d10_device_IAGetPrimitiveTopology(ID3D10Device *iface,
 778         D3D10_PRIMITIVE_TOPOLOGY *topology)
 779 {
 780     struct d3d10_device *This = impl_from_ID3D10Device(iface);
 781
 782     TRACE("iface %p, topology %p\n", iface, topology);
 783
 784     wined3d_device_get_primitive_type(This->wined3d_device, (enum wined3d_primitive_type *)topology);
 785 }
 786
 787 static void STDMETHODCALLTYPE d3d10_device_VSGetShaderResources(ID3D10Device *iface,
 788         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
 789 {
 790     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 791             iface, start_slot, view_count, views);
 792 }
 793
 794 static void STDMETHODCALLTYPE d3d10_device_VSGetSamplers(ID3D10Device *iface,
 795         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
 796 {
 797     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 798     unsigned int i;
 799
 800     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 801             iface, start_slot, sampler_count, samplers);
 802
 803     for (i = 0; i < sampler_count; ++i)
 804     {
 805         struct d3d10_sampler_state *sampler_impl;
 806         struct wined3d_sampler *wined3d_sampler;
 807
 808         if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
 809         {
 810             samplers[i] = NULL;
 811             continue;
 812         }
 813
 814         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
 815         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
 816         ID3D10SamplerState_AddRef(samplers[i]);
 817     }
 818 }
 819
 820 static void STDMETHODCALLTYPE d3d10_device_GetPredication(ID3D10Device *iface,
 821         ID3D10Predicate **predicate, BOOL *value)
 822 {
 823     FIXME("iface %p, predicate %p, value %p stub!\n", iface, predicate, value);
 824 }
 825
 826 static void STDMETHODCALLTYPE d3d10_device_GSGetShaderResources(ID3D10Device *iface,
 827         UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
 828 {
 829     FIXME("iface %p, start_slot %u, view_count %u, views %p stub!\n",
 830             iface, start_slot, view_count, views);
 831 }
 832
 833 static void STDMETHODCALLTYPE d3d10_device_GSGetSamplers(ID3D10Device *iface,
 834         UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
 835 {
 836     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 837     unsigned int i;
 838
 839     TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
 840             iface, start_slot, sampler_count, samplers);
 841
 842     for (i = 0; i < sampler_count; ++i)
 843     {
 844         struct d3d10_sampler_state *sampler_impl;
 845         struct wined3d_sampler *wined3d_sampler;
 846
 847         if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
 848         {
 849             samplers[i] = NULL;
 850             continue;
 851         }
 852
 853         sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
 854         samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
 855         ID3D10SamplerState_AddRef(samplers[i]);
 856     }
 857 }
 858
 859 static void STDMETHODCALLTYPE d3d10_device_OMGetRenderTargets(ID3D10Device *iface,
 860         UINT view_count, ID3D10RenderTargetView **render_target_views, ID3D10DepthStencilView **depth_stencil_view)
 861 {
 862     FIXME("iface %p, view_count %u, render_target_views %p, depth_stencil_view %p stub!\n",
 863             iface, view_count, render_target_views, depth_stencil_view);
 864 }
 865
 866 static void STDMETHODCALLTYPE d3d10_device_OMGetBlendState(ID3D10Device *iface,
 867         ID3D10BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
 868 {
 869     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 870
 871     TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
 872             iface, blend_state, blend_factor, sample_mask);
 873
 874     if ((*blend_state = device->blend_state ? &device->blend_state->ID3D10BlendState_iface : NULL))
 875         ID3D10BlendState_AddRef(*blend_state);
 876     memcpy(blend_factor, device->blend_factor, 4 * sizeof(*blend_factor));
 877     *sample_mask = device->sample_mask;
 878 }
 879
 880 static void STDMETHODCALLTYPE d3d10_device_OMGetDepthStencilState(ID3D10Device *iface,
 881         ID3D10DepthStencilState **depth_stencil_state, UINT *stencil_ref)
 882 {
 883     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 884
 885     TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
 886             iface, depth_stencil_state, stencil_ref);
 887
 888     if ((*depth_stencil_state = device->depth_stencil_state
 889             ? &device->depth_stencil_state->ID3D10DepthStencilState_iface : NULL))
 890         ID3D10DepthStencilState_AddRef(*depth_stencil_state);
 891     *stencil_ref = device->stencil_ref;
 892 }
 893
 894 static void STDMETHODCALLTYPE d3d10_device_SOGetTargets(ID3D10Device *iface,
 895         UINT buffer_count, ID3D10Buffer **buffers, UINT *offsets)
 896 {
 897     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 898     unsigned int i;
 899
 900     TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n",
 901             iface, buffer_count, buffers, offsets);
 902
 903     for (i = 0; i < buffer_count; ++i)
 904     {
 905         struct wined3d_buffer *wined3d_buffer;
 906         struct d3d10_buffer *buffer_impl;
 907
 908         if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, &offsets[i])))
 909         {
 910             buffers[i] = NULL;
 911             continue;
 912         }
 913
 914         buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
 915         buffers[i] = &buffer_impl->ID3D10Buffer_iface;
 916         ID3D10Buffer_AddRef(buffers[i]);
 917     }
 918 }
 919
 920 static void STDMETHODCALLTYPE d3d10_device_RSGetState(ID3D10Device *iface, ID3D10RasterizerState **rasterizer_state)
 921 {
 922     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 923
 924     TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
 925
 926     if ((*rasterizer_state = device->rasterizer_state ? &device->rasterizer_state->ID3D10RasterizerState_iface : NULL))
 927         ID3D10RasterizerState_AddRef(*rasterizer_state);
 928 }
 929
 930 static void STDMETHODCALLTYPE d3d10_device_RSGetViewports(ID3D10Device *iface,
 931         UINT *viewport_count, D3D10_VIEWPORT *viewports)
 932 {
 933     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 934     struct wined3d_viewport wined3d_vp;
 935
 936     TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
 937
 938     if (!viewports)
 939     {
 940         *viewport_count = 1;
 941         return;
 942     }
 943
 944     if (!*viewport_count)
 945         return;
 946
 947     wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
 948
 949     viewports[0].TopLeftX = wined3d_vp.x;
 950     viewports[0].TopLeftY = wined3d_vp.y;
 951     viewports[0].Width = wined3d_vp.width;
 952     viewports[0].Height = wined3d_vp.height;
 953     viewports[0].MinDepth = wined3d_vp.min_z;
 954     viewports[0].MaxDepth = wined3d_vp.max_z;
 955
 956     if (*viewport_count > 1)
 957         memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
 958 }
 959
 960 static void STDMETHODCALLTYPE d3d10_device_RSGetScissorRects(ID3D10Device *iface, UINT *rect_count, D3D10_RECT *rects)
 961 {
 962     struct d3d10_device *device = impl_from_ID3D10Device(iface);
 963
 964     TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
 965
 966     if (!rects)
 967     {
 968         *rect_count = 1;
 969         return;
 970     }
 971
 972     if (!*rect_count)
 973         return;
 974
 975     wined3d_device_get_scissor_rect(device->wined3d_device, rects);
 976     if (*rect_count > 1)
 977         memset(&rects[1], 0, (*rect_count - 1) * sizeof(*rects));
 978 }
 979
 980 static HRESULT STDMETHODCALLTYPE d3d10_device_GetDeviceRemovedReason(ID3D10Device *iface)
 981 {
 982     FIXME("iface %p stub!\n", iface);
 983
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT STDMETHODCALLTYPE d3d10_device_SetExceptionMode(ID3D10Device *iface, UINT flags)
 988 {
 989     FIXME("iface %p, flags %#x stub!\n", iface, flags);
 990
 991     return E_NOTIMPL;
 992 }
 993
 994 static UINT STDMETHODCALLTYPE d3d10_device_GetExceptionMode(ID3D10Device *iface)
 995 {
 996     FIXME("iface %p stub!\n", iface);
 997
 998     return 0;
 999 }
1000
1001 static HRESULT STDMETHODCALLTYPE d3d10_device_GetPrivateData(ID3D10Device *iface,
1002         REFGUID guid, UINT *data_size, void *data)
1003 {
1004     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
1005             iface, debugstr_guid(guid), data_size, data);
1006
1007     return E_NOTIMPL;
1008 }
1009
1010 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateData(ID3D10Device *iface,
1011         REFGUID guid, UINT data_size, const void *data)
1012 {
1013     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
1014             iface, debugstr_guid(guid), data_size, data);
1015
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateDataInterface(ID3D10Device *iface,
1020         REFGUID guid, const IUnknown *data)
1021 {
1022     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
1023
1024     return E_NOTIMPL;
1025 }
1026
1027 static void STDMETHODCALLTYPE d3d10_device_ClearState(ID3D10Device *iface)
1028 {
1029     FIXME("iface %p stub!\n", iface);
1030 }
1031
1032 static void STDMETHODCALLTYPE d3d10_device_Flush(ID3D10Device *iface)
1033 {
1034     FIXME("iface %p stub!\n", iface);
1035 }
1036
1037 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBuffer(ID3D10Device *iface,
1038         const D3D10_BUFFER_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Buffer **buffer)
1039 {
1040     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1041     struct d3d10_buffer *object;
1042     HRESULT hr;
1043
1044     FIXME("iface %p, desc %p, data %p, buffer %p partial stub!\n", iface, desc, data, buffer);
1045
1046     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1047     if (!object)
1048     {
1049         ERR("Failed to allocate D3D10 buffer object memory\n");
1050         return E_OUTOFMEMORY;
1051     }
1052
1053     hr = d3d10_buffer_init(object, This, desc, data);
1054     if (FAILED(hr))
1055     {
1056         WARN("Failed to initialize buffer, hr %#x.\n", hr);
1057         HeapFree(GetProcessHeap(), 0, object);
1058         return hr;
1059     }
1060
1061     *buffer = &object->ID3D10Buffer_iface;
1062
1063     TRACE("Created ID3D10Buffer %p\n", object);
1064
1065     return S_OK;
1066 }
1067
1068 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture1D(ID3D10Device *iface,
1069         const D3D10_TEXTURE1D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Texture1D **texture)
1070 {
1071     FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
1072
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture2D(ID3D10Device *iface,
1077         const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
1078         ID3D10Texture2D **texture)
1079 {
1080     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1081     struct d3d10_texture2d *object;
1082     HRESULT hr;
1083
1084     FIXME("iface %p, desc %p, data %p, texture %p partial stub!\n", iface, desc, data, texture);
1085
1086     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1087     if (!object)
1088     {
1089         ERR("Failed to allocate D3D10 texture2d object memory\n");
1090         return E_OUTOFMEMORY;
1091     }
1092
1093     hr = d3d10_texture2d_init(object, This, desc);
1094     if (FAILED(hr))
1095     {
1096         WARN("Failed to initialize texture, hr %#x.\n", hr);
1097         HeapFree(GetProcessHeap(), 0, object);
1098         return hr;
1099     }
1100
1101     *texture = &object->ID3D10Texture2D_iface;
1102
1103     TRACE("Created ID3D10Texture2D %p\n", object);
1104
1105     return S_OK;
1106 }
1107
1108 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture3D(ID3D10Device *iface,
1109         const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
1110         ID3D10Texture3D **texture)
1111 {
1112     struct d3d10_device *device = impl_from_ID3D10Device(iface);
1113     struct d3d10_texture3d *object;
1114     HRESULT hr;
1115
1116     TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
1117
1118     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1119     if (!object)
1120     {
1121         ERR("Failed to allocate D3D10 texture3d object memory.\n");
1122         return E_OUTOFMEMORY;
1123     }
1124
1125     hr = d3d10_texture3d_init(object, device, desc);
1126     if (FAILED(hr))
1127     {
1128         WARN("Failed to initialize texture, hr %#x.\n", hr);
1129         HeapFree(GetProcessHeap(), 0, object);
1130         return hr;
1131     }
1132
1133     TRACE("Created 3D texture %p.\n", object);
1134     *texture = &object->ID3D10Texture3D_iface;
1135
1136     return S_OK;
1137 }
1138
1139 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView(ID3D10Device *iface,
1140         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10ShaderResourceView **view)
1141 {
1142     struct d3d10_shader_resource_view *object;
1143     HRESULT hr;
1144
1145     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
1146
1147     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1148     if (!object)
1149     {
1150         ERR("Failed to allocate D3D10 shader resource view object memory.\n");
1151         return E_OUTOFMEMORY;
1152     }
1153
1154     if (FAILED(hr = d3d10_shader_resource_view_init(object, resource, desc)))
1155     {
1156         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
1157         HeapFree(GetProcessHeap(), 0, object);
1158         return hr;
1159     }
1160
1161     TRACE("Created shader resource view %p.\n", object);
1162     *view = &object->ID3D10ShaderResourceView_iface;
1163
1164     return S_OK;
1165 }
1166
1167 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRenderTargetView(ID3D10Device *iface,
1168         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10RenderTargetView **view)
1169 {
1170     struct d3d10_rendertarget_view *object;
1171     HRESULT hr;
1172
1173     TRACE("iface %p, resource %p, desc %p, view %p stub!\n", iface, resource, desc, view);
1174
1175     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1176     if (!object)
1177     {
1178         ERR("Failed to allocate D3D10 rendertarget view object memory\n");
1179         return E_OUTOFMEMORY;
1180     }
1181
1182     hr = d3d10_rendertarget_view_init(object, resource, desc);
1183     if (FAILED(hr))
1184     {
1185         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1186         HeapFree(GetProcessHeap(), 0, object);
1187         return hr;
1188     }
1189
1190     TRACE("Created rendertarget view %p.\n", object);
1191     *view = &object->ID3D10RenderTargetView_iface;
1192
1193     return S_OK;
1194 }
1195
1196 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilView(ID3D10Device *iface,
1197         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10DepthStencilView **view)
1198 {
1199     struct d3d10_depthstencil_view *object;
1200     HRESULT hr;
1201
1202     TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
1203
1204     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1205     if (!object)
1206     {
1207         ERR("Failed to allocate D3D10 depthstencil view object memory.\n");
1208         return E_OUTOFMEMORY;
1209     }
1210
1211     if (FAILED(hr = d3d10_depthstencil_view_init(object, resource, desc)))
1212     {
1213         WARN("Failed to initialize depthstencil view, hr %#x.\n", hr);
1214         HeapFree(GetProcessHeap(), 0, object);
1215         return hr;
1216     }
1217
1218     TRACE("Created depthstencil view %p.\n", object);
1219     *view = &object->ID3D10DepthStencilView_iface;
1220
1221     return S_OK;
1222 }
1223
1224 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateInputLayout(ID3D10Device *iface,
1225         const D3D10_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
1226         const void *shader_byte_code, SIZE_T shader_byte_code_length,
1227         ID3D10InputLayout **input_layout)
1228 {
1229     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1230     struct d3d10_input_layout *object;
1231     HRESULT hr;
1232
1233     TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p,"
1234             "\tshader_byte_code_length %lu, input_layout %p\n",
1235             iface, element_descs, element_count, shader_byte_code,
1236             shader_byte_code_length, input_layout);
1237
1238     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1239     if (!object)
1240     {
1241         ERR("Failed to allocate D3D10 input layout object memory\n");
1242         return E_OUTOFMEMORY;
1243     }
1244
1245     hr = d3d10_input_layout_init(object, This, element_descs, element_count,
1246             shader_byte_code, shader_byte_code_length);
1247     if (FAILED(hr))
1248     {
1249         WARN("Failed to initialize input layout, hr %#x.\n", hr);
1250         HeapFree(GetProcessHeap(), 0, object);
1251         return hr;
1252     }
1253
1254     TRACE("Created input layout %p.\n", object);
1255     *input_layout = &object->ID3D10InputLayout_iface;
1256
1257     return S_OK;
1258 }
1259
1260 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateVertexShader(ID3D10Device *iface,
1261         const void *byte_code, SIZE_T byte_code_length, ID3D10VertexShader **shader)
1262 {
1263     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1264     struct d3d10_vertex_shader *object;
1265     HRESULT hr;
1266
1267     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p\n",
1268             iface, byte_code, byte_code_length, shader);
1269
1270     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1271     if (!object)
1272     {
1273         ERR("Failed to allocate D3D10 vertex shader object memory\n");
1274         return E_OUTOFMEMORY;
1275     }
1276
1277     hr = d3d10_vertex_shader_init(object, This, byte_code, byte_code_length);
1278     if (FAILED(hr))
1279     {
1280         WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
1281         HeapFree(GetProcessHeap(), 0, object);
1282         return hr;
1283     }
1284
1285     TRACE("Created vertex shader %p.\n", object);
1286     *shader = &object->ID3D10VertexShader_iface;
1287
1288     return S_OK;
1289 }
1290
1291 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShader(ID3D10Device *iface,
1292         const void *byte_code, SIZE_T byte_code_length, ID3D10GeometryShader **shader)
1293 {
1294     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1295     struct d3d10_geometry_shader *object;
1296     HRESULT hr;
1297
1298     FIXME("iface %p, byte_code %p, byte_code_length %lu, shader %p stub!\n",
1299             iface, byte_code, byte_code_length, shader);
1300
1301     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1302     if (!object)
1303     {
1304         ERR("Failed to allocate D3D10 geometry shader object memory\n");
1305         return E_OUTOFMEMORY;
1306     }
1307
1308     hr = d3d10_geometry_shader_init(object, This, byte_code, byte_code_length);
1309     if (FAILED(hr))
1310     {
1311         WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
1312         HeapFree(GetProcessHeap(), 0, object);
1313         return hr;
1314     }
1315
1316     TRACE("Created geometry shader %p.\n", object);
1317     *shader = &object->ID3D10GeometryShader_iface;
1318
1319     return S_OK;
1320 }
1321
1322 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShaderWithStreamOutput(ID3D10Device *iface,
1323         const void *byte_code, SIZE_T byte_code_length, const D3D10_SO_DECLARATION_ENTRY *output_stream_decls,
1324         UINT output_stream_decl_count, UINT output_stream_stride, ID3D10GeometryShader **shader)
1325 {
1326     FIXME("iface %p, byte_code %p, byte_code_length %lu, output_stream_decls %p,\n"
1327             "\toutput_stream_decl_count %u, output_stream_stride %u, shader %p stub!\n",
1328             iface, byte_code, byte_code_length, output_stream_decls,
1329             output_stream_decl_count, output_stream_stride, shader);
1330
1331     return E_NOTIMPL;
1332 }
1333
1334 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePixelShader(ID3D10Device *iface,
1335         const void *byte_code, SIZE_T byte_code_length, ID3D10PixelShader **shader)
1336 {
1337     struct d3d10_device *This = impl_from_ID3D10Device(iface);
1338     struct d3d10_pixel_shader *object;
1339     HRESULT hr;
1340
1341     TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p\n",
1342             iface, byte_code, byte_code_length, shader);
1343
1344     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1345     if (!object)
1346     {
1347         ERR("Failed to allocate D3D10 pixel shader object memory\n");
1348         return E_OUTOFMEMORY;
1349     }
1350
1351     hr = d3d10_pixel_shader_init(object, This, byte_code, byte_code_length);
1352     if (FAILED(hr))
1353     {
1354         WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
1355         HeapFree(GetProcessHeap(), 0, object);
1356         return hr;
1357     }
1358
1359     TRACE("Created pixel shader %p.\n", object);
1360     *shader = &object->ID3D10PixelShader_iface;
1361
1362     return S_OK;
1363 }
1364
1365 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState(ID3D10Device *iface,
1366         const D3D10_BLEND_DESC *desc, ID3D10BlendState **blend_state)
1367 {
1368     struct d3d10_blend_state *object;
1369     HRESULT hr;
1370
1371     TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
1372
1373     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1374     if (!object)
1375     {
1376         ERR("Failed to allocate D3D10 blend state object memory.\n");
1377         return E_OUTOFMEMORY;
1378     }
1379
1380     hr = d3d10_blend_state_init(object);
1381     if (FAILED(hr))
1382     {
1383         WARN("Failed to initialize blend state, hr %#x.\n", hr);
1384         HeapFree(GetProcessHeap(), 0, object);
1385         return hr;
1386     }
1387
1388     TRACE("Created blend state %p.\n", object);
1389     *blend_state = &object->ID3D10BlendState_iface;
1390
1391     return S_OK;
1392 }
1393
1394 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilState(ID3D10Device *iface,
1395         const D3D10_DEPTH_STENCIL_DESC *desc, ID3D10DepthStencilState **depth_stencil_state)
1396 {
1397     struct d3d10_depthstencil_state *object;
1398     HRESULT hr;
1399
1400     TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
1401
1402     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1403     if (!object)
1404     {
1405         ERR("Failed to allocate D3D10 depthstencil state object memory.\n");
1406         return E_OUTOFMEMORY;
1407     }
1408
1409     hr = d3d10_depthstencil_state_init(object);
1410     if (FAILED(hr))
1411     {
1412         WARN("Failed to initialize depthstencil state, hr %#x.\n", hr);
1413         HeapFree(GetProcessHeap(), 0, object);
1414         return hr;
1415     }
1416
1417     TRACE("Created depthstencil state %p.\n", object);
1418     *depth_stencil_state = &object->ID3D10DepthStencilState_iface;
1419
1420     return S_OK;
1421 }
1422
1423 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device *iface,
1424         const D3D10_RASTERIZER_DESC *desc, ID3D10RasterizerState **rasterizer_state)
1425 {
1426     struct d3d10_rasterizer_state *object;
1427     HRESULT hr;
1428
1429     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
1430
1431     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1432     if (!object)
1433     {
1434         ERR("Failed to allocate D3D10 rasterizer state object memory.\n");
1435         return E_OUTOFMEMORY;
1436     }
1437
1438     hr = d3d10_rasterizer_state_init(object);
1439     if (FAILED(hr))
1440     {
1441         WARN("Failed to initialize rasterizer state, hr %#x.\n", hr);
1442         HeapFree(GetProcessHeap(), 0, object);
1443         return hr;
1444     }
1445
1446     TRACE("Created rasterizer state %p.\n", object);
1447     *rasterizer_state = &object->ID3D10RasterizerState_iface;
1448
1449     return S_OK;
1450 }
1451
1452 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateSamplerState(ID3D10Device *iface,
1453         const D3D10_SAMPLER_DESC *desc, ID3D10SamplerState **sampler_state)
1454 {
1455     struct d3d10_sampler_state *object;
1456     HRESULT hr;
1457
1458     TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
1459
1460     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1461     if (!object)
1462     {
1463         ERR("Failed to allocate D3D10 sampler state object memory.\n");
1464         return E_OUTOFMEMORY;
1465     }
1466
1467     hr = d3d10_sampler_state_init(object);
1468     if (FAILED(hr))
1469     {
1470         WARN("Failed to initialize sampler state, hr %#x.\n", hr);
1471         HeapFree(GetProcessHeap(), 0, object);
1472         return hr;
1473     }
1474
1475     TRACE("Created sampler state %p.\n", object);
1476     *sampler_state = &object->ID3D10SamplerState_iface;
1477
1478     return S_OK;
1479 }
1480
1481 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateQuery(ID3D10Device *iface,
1482         const D3D10_QUERY_DESC *desc, ID3D10Query **query)
1483 {
1484     struct d3d10_query *object;
1485     HRESULT hr;
1486
1487     TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
1488
1489     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1490     if (!object)
1491     {
1492         ERR("Failed to allocate D3D10 query object memory.\n");
1493         return E_OUTOFMEMORY;
1494     }
1495
1496     hr = d3d10_query_init(object);
1497     if (FAILED(hr))
1498     {
1499         WARN("Failed to initialize query, hr %#x.\n", hr);
1500         HeapFree(GetProcessHeap(), 0, object);
1501         return hr;
1502     }
1503
1504     TRACE("Created query %p.\n", object);
1505     *query = &object->ID3D10Query_iface;
1506
1507     return S_OK;
1508 }
1509
1510 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePredicate(ID3D10Device *iface,
1511         const D3D10_QUERY_DESC *desc, ID3D10Predicate **predicate)
1512 {
1513     FIXME("iface %p, desc %p, predicate %p stub!\n", iface, desc, predicate);
1514
1515     return E_NOTIMPL;
1516 }
1517
1518 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateCounter(ID3D10Device *iface,
1519         const D3D10_COUNTER_DESC *desc, ID3D10Counter **counter)
1520 {
1521     FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
1522
1523     return E_NOTIMPL;
1524 }
1525
1526 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckFormatSupport(ID3D10Device *iface,
1527         DXGI_FORMAT format, UINT *format_support)
1528 {
1529     FIXME("iface %p, format %s, format_support %p stub!\n",
1530             iface, debug_dxgi_format(format), format_support);
1531
1532     return E_NOTIMPL;
1533 }
1534
1535 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckMultisampleQualityLevels(ID3D10Device *iface,
1536         DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
1537 {
1538     FIXME("iface %p, format %s, sample_count %u, quality_level_count %p stub!\n",
1539             iface, debug_dxgi_format(format), sample_count, quality_level_count);
1540
1541     return E_NOTIMPL;
1542 }
1543
1544 static void STDMETHODCALLTYPE d3d10_device_CheckCounterInfo(ID3D10Device *iface, D3D10_COUNTER_INFO *counter_info)
1545 {
1546     FIXME("iface %p, counter_info %p stub!\n", iface, counter_info);
1547 }
1548
1549 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckCounter(ID3D10Device *iface,
1550         const D3D10_COUNTER_DESC *desc, D3D10_COUNTER_TYPE *type, UINT *active_counters, LPSTR name,
1551         UINT *name_length, LPSTR units, UINT *units_length, LPSTR description, UINT *description_length)
1552 {
1553     FIXME("iface %p, desc %p, type %p, active_counters %p, name %p, name_length %p,\n"
1554             "\tunits %p, units_length %p, description %p, description_length %p stub!\n",
1555             iface, desc, type, active_counters, name, name_length,
1556             units, units_length, description, description_length);
1557
1558     return E_NOTIMPL;
1559 }
1560
1561 static UINT STDMETHODCALLTYPE d3d10_device_GetCreationFlags(ID3D10Device *iface)
1562 {
1563     FIXME("iface %p stub!\n", iface);
1564
1565     return 0;
1566 }
1567
1568 static HRESULT STDMETHODCALLTYPE d3d10_device_OpenSharedResource(ID3D10Device *iface,
1569         HANDLE resource_handle, REFIID guid, void **resource)
1570 {
1571     FIXME("iface %p, resource_handle %p, guid %s, resource %p stub!\n",
1572             iface, resource_handle, debugstr_guid(guid), resource);
1573
1574     return E_NOTIMPL;
1575 }
1576
1577 static void STDMETHODCALLTYPE d3d10_device_SetTextFilterSize(ID3D10Device *iface, UINT width, UINT height)
1578 {
1579     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
1580 }
1581
1582 static void STDMETHODCALLTYPE d3d10_device_GetTextFilterSize(ID3D10Device *iface, UINT *width, UINT *height)
1583 {
1584     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
1585 }
1586
1587 static const struct ID3D10DeviceVtbl d3d10_device_vtbl =
1588 {
1589     /* IUnknown methods */
1590     d3d10_device_QueryInterface,
1591     d3d10_device_AddRef,
1592     d3d10_device_Release,
1593     /* ID3D10Device methods */
1594     d3d10_device_VSSetConstantBuffers,
1595     d3d10_device_PSSetShaderResources,
1596     d3d10_device_PSSetShader,
1597     d3d10_device_PSSetSamplers,
1598     d3d10_device_VSSetShader,
1599     d3d10_device_DrawIndexed,
1600     d3d10_device_Draw,
1601     d3d10_device_PSSetConstantBuffers,
1602     d3d10_device_IASetInputLayout,
1603     d3d10_device_IASetVertexBuffers,
1604     d3d10_device_IASetIndexBuffer,
1605     d3d10_device_DrawIndexedInstanced,
1606     d3d10_device_DrawInstanced,
1607     d3d10_device_GSSetConstantBuffers,
1608     d3d10_device_GSSetShader,
1609     d3d10_device_IASetPrimitiveTopology,
1610     d3d10_device_VSSetShaderResources,
1611     d3d10_device_VSSetSamplers,
1612     d3d10_device_SetPredication,
1613     d3d10_device_GSSetShaderResources,
1614     d3d10_device_GSSetSamplers,
1615     d3d10_device_OMSetRenderTargets,
1616     d3d10_device_OMSetBlendState,
1617     d3d10_device_OMSetDepthStencilState,
1618     d3d10_device_SOSetTargets,
1619     d3d10_device_DrawAuto,
1620     d3d10_device_RSSetState,
1621     d3d10_device_RSSetViewports,
1622     d3d10_device_RSSetScissorRects,
1623     d3d10_device_CopySubresourceRegion,
1624     d3d10_device_CopyResource,
1625     d3d10_device_UpdateSubresource,
1626     d3d10_device_ClearRenderTargetView,
1627     d3d10_device_ClearDepthStencilView,
1628     d3d10_device_GenerateMips,
1629     d3d10_device_ResolveSubresource,
1630     d3d10_device_VSGetConstantBuffers,
1631     d3d10_device_PSGetShaderResources,
1632     d3d10_device_PSGetShader,
1633     d3d10_device_PSGetSamplers,
1634     d3d10_device_VSGetShader,
1635     d3d10_device_PSGetConstantBuffers,
1636     d3d10_device_IAGetInputLayout,
1637     d3d10_device_IAGetVertexBuffers,
1638     d3d10_device_IAGetIndexBuffer,
1639     d3d10_device_GSGetConstantBuffers,
1640     d3d10_device_GSGetShader,
1641     d3d10_device_IAGetPrimitiveTopology,
1642     d3d10_device_VSGetShaderResources,
1643     d3d10_device_VSGetSamplers,
1644     d3d10_device_GetPredication,
1645     d3d10_device_GSGetShaderResources,
1646     d3d10_device_GSGetSamplers,
1647     d3d10_device_OMGetRenderTargets,
1648     d3d10_device_OMGetBlendState,
1649     d3d10_device_OMGetDepthStencilState,
1650     d3d10_device_SOGetTargets,
1651     d3d10_device_RSGetState,
1652     d3d10_device_RSGetViewports,
1653     d3d10_device_RSGetScissorRects,
1654     d3d10_device_GetDeviceRemovedReason,
1655     d3d10_device_SetExceptionMode,
1656     d3d10_device_GetExceptionMode,
1657     d3d10_device_GetPrivateData,
1658     d3d10_device_SetPrivateData,
1659     d3d10_device_SetPrivateDataInterface,
1660     d3d10_device_ClearState,
1661     d3d10_device_Flush,
1662     d3d10_device_CreateBuffer,
1663     d3d10_device_CreateTexture1D,
1664     d3d10_device_CreateTexture2D,
1665     d3d10_device_CreateTexture3D,
1666     d3d10_device_CreateShaderResourceView,
1667     d3d10_device_CreateRenderTargetView,
1668     d3d10_device_CreateDepthStencilView,
1669     d3d10_device_CreateInputLayout,
1670     d3d10_device_CreateVertexShader,
1671     d3d10_device_CreateGeometryShader,
1672     d3d10_device_CreateGeometryShaderWithStreamOutput,
1673     d3d10_device_CreatePixelShader,
1674     d3d10_device_CreateBlendState,
1675     d3d10_device_CreateDepthStencilState,
1676     d3d10_device_CreateRasterizerState,
1677     d3d10_device_CreateSamplerState,
1678     d3d10_device_CreateQuery,
1679     d3d10_device_CreatePredicate,
1680     d3d10_device_CreateCounter,
1681     d3d10_device_CheckFormatSupport,
1682     d3d10_device_CheckMultisampleQualityLevels,
1683     d3d10_device_CheckCounterInfo,
1684     d3d10_device_CheckCounter,
1685     d3d10_device_GetCreationFlags,
1686     d3d10_device_OpenSharedResource,
1687     d3d10_device_SetTextFilterSize,
1688     d3d10_device_GetTextFilterSize,
1689 };
1690
1691 static const struct IUnknownVtbl d3d10_device_inner_unknown_vtbl =
1692 {
1693     /* IUnknown methods */
1694     d3d10_device_inner_QueryInterface,
1695     d3d10_device_inner_AddRef,
1696     d3d10_device_inner_Release,
1697 };
1698
1699 static void STDMETHODCALLTYPE d3d10_subresource_destroyed(void *parent) {}
1700
1701 static const struct wined3d_parent_ops d3d10_subresource_parent_ops =
1702 {
1703     d3d10_subresource_destroyed,
1704 };
1705
1706 /* IWineDXGIDeviceParent IUnknown methods */
1707
1708 static inline struct d3d10_device *device_from_dxgi_device_parent(IWineDXGIDeviceParent *iface)
1709 {
1710     return CONTAINING_RECORD(iface, struct d3d10_device, IWineDXGIDeviceParent_iface);
1711 }
1712
1713 static HRESULT STDMETHODCALLTYPE dxgi_device_parent_QueryInterface(IWineDXGIDeviceParent *iface,
1714         REFIID riid, void **ppv)
1715 {
1716     struct d3d10_device *device = device_from_dxgi_device_parent(iface);
1717     return IUnknown_QueryInterface(device->outer_unk, riid, ppv);
1718 }
1719
1720 static ULONG STDMETHODCALLTYPE dxgi_device_parent_AddRef(IWineDXGIDeviceParent *iface)
1721 {
1722     struct d3d10_device *device = device_from_dxgi_device_parent(iface);
1723     return IUnknown_AddRef(device->outer_unk);
1724 }
1725
1726 static ULONG STDMETHODCALLTYPE dxgi_device_parent_Release(IWineDXGIDeviceParent *iface)
1727 {
1728     struct d3d10_device *device = device_from_dxgi_device_parent(iface);
1729     return IUnknown_Release(device->outer_unk);
1730 }
1731
1732 static struct wined3d_device_parent * STDMETHODCALLTYPE dxgi_device_parent_get_wined3d_device_parent(
1733         IWineDXGIDeviceParent *iface)
1734 {
1735     struct d3d10_device *device = device_from_dxgi_device_parent(iface);
1736     return &device->device_parent;
1737 }
1738
1739 static const struct IWineDXGIDeviceParentVtbl d3d10_dxgi_device_parent_vtbl =
1740 {
1741     /* IUnknown methods */
1742     dxgi_device_parent_QueryInterface,
1743     dxgi_device_parent_AddRef,
1744     dxgi_device_parent_Release,
1745     /* IWineDXGIDeviceParent methods */
1746     dxgi_device_parent_get_wined3d_device_parent,
1747 };
1748
1749 static inline struct d3d10_device *device_from_wined3d_device_parent(struct wined3d_device_parent *device_parent)
1750 {
1751     return CONTAINING_RECORD(device_parent, struct d3d10_device, device_parent);
1752 }
1753
1754 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
1755         struct wined3d_device *wined3d_device)
1756 {
1757     struct d3d10_device *device = device_from_wined3d_device_parent(device_parent);
1758
1759     TRACE("device_parent %p, wined3d_device %p.\n", device_parent, wined3d_device);
1760
1761     wined3d_device_incref(wined3d_device);
1762     device->wined3d_device = wined3d_device;
1763 }
1764
1765 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
1766 {
1767     TRACE("device_parent %p.\n", device_parent);
1768 }
1769
1770 static HRESULT CDECL device_parent_create_texture_surface(struct wined3d_device_parent *device_parent,
1771         void *container_parent, UINT width, UINT height, enum wined3d_format_id format, DWORD usage,
1772         enum wined3d_pool pool, UINT sub_resource_idx, struct wined3d_surface **surface)
1773 {
1774     struct d3d10_device *device = device_from_wined3d_device_parent(device_parent);
1775
1776     TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, usage %#x,\n"
1777             "\tpool %#x, sub_resource_idx %u, surface %p.\n",
1778             device_parent, container_parent, width, height, format, usage, pool, sub_resource_idx, surface);
1779
1780     return wined3d_surface_create(device->wined3d_device, width, height, format, usage, pool,
1781             WINED3D_MULTISAMPLE_NONE, 0, WINED3D_SURFACE_TYPE_OPENGL, 0, container_parent,
1782             &d3d10_null_wined3d_parent_ops, surface);
1783 }
1784
1785 static HRESULT CDECL device_parent_create_swapchain_surface(struct wined3d_device_parent *device_parent,
1786         void *container_parent, UINT width, UINT height, enum wined3d_format_id format_id, DWORD usage,
1787         enum wined3d_multisample_type multisample_type, DWORD multisample_quality, struct wined3d_surface **surface)
1788 {
1789     struct d3d10_device *device = device_from_wined3d_device_parent(device_parent);
1790     struct wined3d_resource *sub_resource;
1791     struct d3d10_texture2d *texture;
1792     D3D10_TEXTURE2D_DESC desc;
1793     HRESULT hr;
1794
1795     FIXME("device_parent %p, container_parent %p, width %u, height %u, format_id %#x, usage %#x,\n"
1796             "\tmultisample_type %#x, multisample_quality %u, surface %p partial stub!\n",
1797             device_parent, container_parent, width, height, format_id, usage,
1798             multisample_type, multisample_quality, surface);
1799
1800     FIXME("Implement DXGI<->wined3d usage conversion\n");
1801
1802     desc.Width = width;
1803     desc.Height = height;
1804     desc.MipLevels = 1;
1805     desc.ArraySize = 1;
1806     desc.Format = dxgi_format_from_wined3dformat(format_id);
1807     desc.SampleDesc.Count = multisample_type ? multisample_type : 1;
1808     desc.SampleDesc.Quality = multisample_quality;
1809     desc.Usage = D3D10_USAGE_DEFAULT;
1810     desc.BindFlags = D3D10_BIND_RENDER_TARGET;
1811     desc.CPUAccessFlags = 0;
1812     desc.MiscFlags = 0;
1813
1814     hr = d3d10_device_CreateTexture2D(&device->ID3D10Device_iface, &desc, NULL,
1815             (ID3D10Texture2D **)&texture);
1816     if (FAILED(hr))
1817     {
1818         ERR("CreateTexture2D failed, returning %#x\n", hr);
1819         return hr;
1820     }
1821
1822     sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, 0);
1823     *surface = wined3d_surface_from_resource(sub_resource);
1824     wined3d_surface_incref(*surface);
1825     ID3D10Texture2D_Release(&texture->ID3D10Texture2D_iface);
1826
1827     return S_OK;
1828 }
1829
1830 static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *device_parent,
1831         void *container_parent, UINT width, UINT height, UINT depth, enum wined3d_format_id format,
1832         enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume)
1833 {
1834     HRESULT hr;
1835
1836     TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, "
1837             "format %#x, pool %#x, usage %#x, volume %p.\n",
1838             device_parent, container_parent, width, height, depth,
1839             format, pool, usage, volume);
1840
1841     hr = wined3d_volume_create(device_from_wined3d_device_parent(device_parent)->wined3d_device,
1842             width, height, depth, usage, format, pool, NULL, &d3d10_subresource_parent_ops, volume);
1843     if (FAILED(hr))
1844     {
1845         WARN("Failed to create wined3d volume, hr %#x.\n", hr);
1846         return hr;
1847     }
1848
1849     return S_OK;
1850 }
1851
1852 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
1853         struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
1854 {
1855     struct d3d10_device *device = device_from_wined3d_device_parent(device_parent);
1856     IWineDXGIDevice *wine_device;
1857     HRESULT hr;
1858
1859     TRACE("device_parent %p, desc %p, swapchain %p\n", device_parent, desc, swapchain);
1860
1861     hr = d3d10_device_QueryInterface(&device->ID3D10Device_iface, &IID_IWineDXGIDevice,
1862             (void **)&wine_device);
1863     if (FAILED(hr))
1864     {
1865         ERR("Device should implement IWineDXGIDevice\n");
1866         return E_FAIL;
1867     }
1868
1869     hr = IWineDXGIDevice_create_swapchain(wine_device, desc, swapchain);
1870     IWineDXGIDevice_Release(wine_device);
1871     if (FAILED(hr))
1872     {
1873         ERR("Failed to create DXGI swapchain, returning %#x\n", hr);
1874         return hr;
1875     }
1876
1877     return S_OK;
1878 }
1879
1880 static const struct wined3d_device_parent_ops d3d10_wined3d_device_parent_ops =
1881 {
1882     device_parent_wined3d_device_created,
1883     device_parent_mode_changed,
1884     device_parent_create_swapchain_surface,
1885     device_parent_create_texture_surface,
1886     device_parent_create_volume,
1887     device_parent_create_swapchain,
1888 };
1889
1890 void d3d10_device_init(struct d3d10_device *device, void *outer_unknown)
1891 {
1892     device->ID3D10Device_iface.lpVtbl = &d3d10_device_vtbl;
1893     device->IUnknown_inner.lpVtbl = &d3d10_device_inner_unknown_vtbl;
1894     device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d10_dxgi_device_parent_vtbl;
1895     device->device_parent.ops = &d3d10_wined3d_device_parent_ops;
1896     device->refcount = 1;
1897     /* COM aggregation always takes place */
1898     device->outer_unk = outer_unknown;
1899 }