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