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