?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mountmgr: Name DosDevices constants consistently.
[wine.git] / dlls / d3d11 / device.c
blob81da77be0a6068649137ba6d88fa641306471daf
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 static 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 struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
113
114 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
115
116 return d3d_get_private_data(&context->private_store, guid, data_size, data);
117 }
118
119 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_SetPrivateData(ID3D11DeviceContext *iface, REFGUID guid,
120 UINT data_size, const void *data)
121 {
122 struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
123
124 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
125
126 return d3d_set_private_data(&context->private_store, guid, data_size, data);
127 }
128
129 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_SetPrivateDataInterface(ID3D11DeviceContext *iface,
130 REFGUID guid, const IUnknown *data)
131 {
132 struct d3d11_immediate_context *context = impl_from_ID3D11DeviceContext(iface);
133
134 TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
135
136 return d3d_set_private_data_interface(&context->private_store, guid, data);
137 }
138
139 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetConstantBuffers(ID3D11DeviceContext *iface,
140 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
141 {
142 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
143 unsigned int i;
144
145 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
146 iface, start_slot, buffer_count, buffers);
147
148 wined3d_mutex_lock();
149 for (i = 0; i < buffer_count; ++i)
150 {
151 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
152
153 wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
154 buffer ? buffer->wined3d_buffer : NULL);
155 }
156 wined3d_mutex_unlock();
157 }
158
159 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetShaderResources(ID3D11DeviceContext *iface,
160 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
161 {
162 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
163 unsigned int i;
164
165 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
166 iface, start_slot, view_count, views);
167
168 wined3d_mutex_lock();
169 for (i = 0; i < view_count; ++i)
170 {
171 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
172
173 wined3d_device_set_ps_resource_view(device->wined3d_device, start_slot + i,
174 view ? view->wined3d_view : NULL);
175 }
176 wined3d_mutex_unlock();
177 }
178
179 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetShader(ID3D11DeviceContext *iface,
180 ID3D11PixelShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
181 {
182 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
183 struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D11PixelShader(shader);
184
185 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
186 iface, shader, class_instances, class_instance_count);
187
188 if (class_instances)
189 FIXME("Dynamic linking is not implemented yet.\n");
190
191 wined3d_mutex_lock();
192 wined3d_device_set_pixel_shader(device->wined3d_device, ps ? ps->wined3d_shader : NULL);
193 wined3d_mutex_unlock();
194 }
195
196 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetSamplers(ID3D11DeviceContext *iface,
197 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
198 {
199 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
200 unsigned int i;
201
202 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
203 iface, start_slot, sampler_count, samplers);
204
205 wined3d_mutex_lock();
206 for (i = 0; i < sampler_count; ++i)
207 {
208 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
209
210 wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
211 sampler ? sampler->wined3d_sampler : NULL);
212 }
213 wined3d_mutex_unlock();
214 }
215
216 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetShader(ID3D11DeviceContext *iface,
217 ID3D11VertexShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
218 {
219 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
220 struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D11VertexShader(shader);
221
222 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
223 iface, shader, class_instances, class_instance_count);
224
225 if (class_instances)
226 FIXME("Dynamic linking is not implemented yet.\n");
227
228 wined3d_mutex_lock();
229 wined3d_device_set_vertex_shader(device->wined3d_device, vs ? vs->wined3d_shader : NULL);
230 wined3d_mutex_unlock();
231 }
232
233 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexed(ID3D11DeviceContext *iface,
234 UINT index_count, UINT start_index_location, INT base_vertex_location)
235 {
236 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
237
238 TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
239 iface, index_count, start_index_location, base_vertex_location);
240
241 wined3d_mutex_lock();
242 wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
243 wined3d_device_draw_indexed_primitive(device->wined3d_device, start_index_location, index_count);
244 wined3d_mutex_unlock();
245 }
246
247 static void STDMETHODCALLTYPE d3d11_immediate_context_Draw(ID3D11DeviceContext *iface,
248 UINT vertex_count, UINT start_vertex_location)
249 {
250 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
251
252 TRACE("iface %p, vertex_count %u, start_vertex_location %u.\n",
253 iface, vertex_count, start_vertex_location);
254
255 wined3d_mutex_lock();
256 wined3d_device_draw_primitive(device->wined3d_device, start_vertex_location, vertex_count);
257 wined3d_mutex_unlock();
258 }
259
260 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_Map(ID3D11DeviceContext *iface, ID3D11Resource *resource,
261 UINT subresource_idx, D3D11_MAP map_type, UINT map_flags, D3D11_MAPPED_SUBRESOURCE *mapped_subresource)
262 {
263 struct wined3d_resource *wined3d_resource;
264 struct wined3d_map_desc map_desc;
265 HRESULT hr;
266
267 TRACE("iface %p, resource %p, subresource_idx %u, map_type %u, map_flags %#x, mapped_subresource %p.\n",
268 iface, resource, subresource_idx, map_type, map_flags, mapped_subresource);
269
270 if (map_flags)
271 FIXME("Ignoring map_flags %#x.\n", map_flags);
272
273 wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
274
275 wined3d_mutex_lock();
276 hr = wined3d_resource_map(wined3d_resource, subresource_idx,
277 &map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type));
278 wined3d_mutex_unlock();
279
280 mapped_subresource->pData = map_desc.data;
281 mapped_subresource->RowPitch = map_desc.row_pitch;
282 mapped_subresource->DepthPitch = map_desc.slice_pitch;
283
284 return hr;
285 }
286
287 static void STDMETHODCALLTYPE d3d11_immediate_context_Unmap(ID3D11DeviceContext *iface, ID3D11Resource *resource,
288 UINT subresource_idx)
289 {
290 struct wined3d_resource *wined3d_resource;
291
292 TRACE("iface %p, resource %p, subresource_idx %u.\n", iface, resource, subresource_idx);
293
294 wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
295
296 wined3d_mutex_lock();
297 wined3d_resource_unmap(wined3d_resource, subresource_idx);
298 wined3d_mutex_unlock();
299 }
300
301 static void STDMETHODCALLTYPE d3d11_immediate_context_PSSetConstantBuffers(ID3D11DeviceContext *iface,
302 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
303 {
304 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
305 unsigned int i;
306
307 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
308 iface, start_slot, buffer_count, buffers);
309
310 wined3d_mutex_lock();
311 for (i = 0; i < buffer_count; ++i)
312 {
313 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
314
315 wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
316 buffer ? buffer->wined3d_buffer : NULL);
317 }
318 wined3d_mutex_unlock();
319 }
320
321 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetInputLayout(ID3D11DeviceContext *iface,
322 ID3D11InputLayout *input_layout)
323 {
324 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
325 struct d3d_input_layout *layout = unsafe_impl_from_ID3D11InputLayout(input_layout);
326
327 TRACE("iface %p, input_layout %p.\n", iface, input_layout);
328
329 wined3d_mutex_lock();
330 wined3d_device_set_vertex_declaration(device->wined3d_device, layout ? layout->wined3d_decl : NULL);
331 wined3d_mutex_unlock();
332 }
333
334 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetVertexBuffers(ID3D11DeviceContext *iface,
335 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers, const UINT *strides, const UINT *offsets)
336 {
337 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
338 unsigned int i;
339
340 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
341 iface, start_slot, buffer_count, buffers, strides, offsets);
342
343 wined3d_mutex_lock();
344 for (i = 0; i < buffer_count; ++i)
345 {
346 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
347
348 wined3d_device_set_stream_source(device->wined3d_device, start_slot + i,
349 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
350 }
351 wined3d_mutex_unlock();
352 }
353
354 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetIndexBuffer(ID3D11DeviceContext *iface,
355 ID3D11Buffer *buffer, DXGI_FORMAT format, UINT offset)
356 {
357 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
358 struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D11Buffer(buffer);
359
360 TRACE("iface %p, buffer %p, format %s, offset %u.\n",
361 iface, buffer, debug_dxgi_format(format), offset);
362
363 wined3d_mutex_lock();
364 wined3d_device_set_index_buffer(device->wined3d_device,
365 buffer_impl ? buffer_impl->wined3d_buffer : NULL,
366 wined3dformat_from_dxgi_format(format), offset);
367 wined3d_mutex_unlock();
368 }
369
370 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexedInstanced(ID3D11DeviceContext *iface,
371 UINT instance_index_count, UINT instance_count, UINT start_index_location, INT base_vertex_location,
372 UINT start_instance_location)
373 {
374 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
375
376 TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
377 "base_vertex_location %d, start_instance_location %u.\n",
378 iface, instance_index_count, instance_count, start_index_location,
379 base_vertex_location, start_instance_location);
380
381 wined3d_mutex_lock();
382 wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
383 wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
384 instance_index_count, start_instance_location, instance_count);
385 wined3d_mutex_unlock();
386 }
387
388 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawInstanced(ID3D11DeviceContext *iface,
389 UINT instance_vertex_count, UINT instance_count, UINT start_vertex_location, UINT start_instance_location)
390 {
391 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
392
393 TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
394 "start_instance_location %u.\n",
395 iface, instance_vertex_count, instance_count, start_vertex_location,
396 start_instance_location);
397
398 wined3d_mutex_lock();
399 wined3d_device_draw_primitive_instanced(device->wined3d_device, start_vertex_location,
400 instance_vertex_count, start_instance_location, instance_count);
401 wined3d_mutex_unlock();
402 }
403
404 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetConstantBuffers(ID3D11DeviceContext *iface,
405 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
406 {
407 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
408 unsigned int i;
409
410 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
411 iface, start_slot, buffer_count, buffers);
412
413 wined3d_mutex_lock();
414 for (i = 0; i < buffer_count; ++i)
415 {
416 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
417
418 wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
419 buffer ? buffer->wined3d_buffer : NULL);
420 }
421 wined3d_mutex_unlock();
422 }
423
424 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetShader(ID3D11DeviceContext *iface,
425 ID3D11GeometryShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
426 {
427 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
428 struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D11GeometryShader(shader);
429
430 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
431 iface, shader, class_instances, class_instance_count);
432
433 if (class_instances)
434 FIXME("Dynamic linking is not implemented yet.\n");
435
436 wined3d_mutex_lock();
437 wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
438 wined3d_mutex_unlock();
439 }
440
441 static void STDMETHODCALLTYPE d3d11_immediate_context_IASetPrimitiveTopology(ID3D11DeviceContext *iface,
442 D3D11_PRIMITIVE_TOPOLOGY topology)
443 {
444 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
445
446 TRACE("iface %p, topology %u.\n", iface, topology);
447
448 wined3d_mutex_lock();
449 wined3d_device_set_primitive_type(device->wined3d_device, (enum wined3d_primitive_type)topology);
450 wined3d_mutex_unlock();
451 }
452
453 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetShaderResources(ID3D11DeviceContext *iface,
454 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
455 {
456 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
457 unsigned int i;
458
459 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
460
461 wined3d_mutex_lock();
462 for (i = 0; i < view_count; ++i)
463 {
464 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
465
466 wined3d_device_set_vs_resource_view(device->wined3d_device, start_slot + i,
467 view ? view->wined3d_view : NULL);
468 }
469 wined3d_mutex_unlock();
470 }
471
472 static void STDMETHODCALLTYPE d3d11_immediate_context_VSSetSamplers(ID3D11DeviceContext *iface,
473 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
474 {
475 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
476 unsigned int i;
477
478 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
479 iface, start_slot, sampler_count, samplers);
480
481 wined3d_mutex_lock();
482 for (i = 0; i < sampler_count; ++i)
483 {
484 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
485
486 wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
487 sampler ? sampler->wined3d_sampler : NULL);
488 }
489 wined3d_mutex_unlock();
490 }
491
492 static void STDMETHODCALLTYPE d3d11_immediate_context_Begin(ID3D11DeviceContext *iface,
493 ID3D11Asynchronous *asynchronous)
494 {
495 struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
496 HRESULT hr;
497
498 TRACE("iface %p, asynchronous %p.\n", iface, asynchronous);
499
500 wined3d_mutex_lock();
501 if (FAILED(hr = wined3d_query_issue(query->wined3d_query, WINED3DISSUE_BEGIN)))
502 ERR("Failed to issue query, hr %#x.\n", hr);
503 wined3d_mutex_unlock();
504 }
505
506 static void STDMETHODCALLTYPE d3d11_immediate_context_End(ID3D11DeviceContext *iface,
507 ID3D11Asynchronous *asynchronous)
508 {
509 struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
510 HRESULT hr;
511
512 TRACE("iface %p, asynchronous %p.\n", iface, asynchronous);
513
514 wined3d_mutex_lock();
515 if (FAILED(hr = wined3d_query_issue(query->wined3d_query, WINED3DISSUE_END)))
516 ERR("Failed to issue query, hr %#x.\n", hr);
517 wined3d_mutex_unlock();
518 }
519
520 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_GetData(ID3D11DeviceContext *iface,
521 ID3D11Asynchronous *asynchronous, void *data, UINT data_size, UINT data_flags)
522 {
523 struct d3d_query *query = unsafe_impl_from_ID3D11Asynchronous(asynchronous);
524 unsigned int wined3d_flags;
525 HRESULT hr;
526
527 TRACE("iface %p, asynchronous %p, data %p, data_size %u, data_flags %#x.\n",
528 iface, asynchronous, data, data_size, data_flags);
529
530 if (!data && data_size)
531 return E_INVALIDARG;
532
533 wined3d_flags = wined3d_getdata_flags_from_d3d11_async_getdata_flags(data_flags);
534
535 wined3d_mutex_lock();
536 if (!data_size || wined3d_query_get_data_size(query->wined3d_query) == data_size)
537 {
538 hr = wined3d_query_get_data(query->wined3d_query, data, data_size, wined3d_flags);
539 if (hr == WINED3DERR_INVALIDCALL)
540 hr = DXGI_ERROR_INVALID_CALL;
541 }
542 else
543 {
544 WARN("Invalid data size %u.\n", data_size);
545 hr = E_INVALIDARG;
546 }
547 wined3d_mutex_unlock();
548
549 return hr;
550 }
551
552 static void STDMETHODCALLTYPE d3d11_immediate_context_SetPredication(ID3D11DeviceContext *iface,
553 ID3D11Predicate *predicate, BOOL value)
554 {
555 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
556 struct d3d_query *query;
557
558 TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
559
560 query = unsafe_impl_from_ID3D11Query((ID3D11Query *)predicate);
561
562 wined3d_mutex_lock();
563 wined3d_device_set_predication(device->wined3d_device, query ? query->wined3d_query : NULL, value);
564 wined3d_mutex_unlock();
565 }
566
567 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetShaderResources(ID3D11DeviceContext *iface,
568 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
569 {
570 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
571 unsigned int i;
572
573 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
574
575 wined3d_mutex_lock();
576 for (i = 0; i < view_count; ++i)
577 {
578 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
579
580 wined3d_device_set_gs_resource_view(device->wined3d_device, start_slot + i,
581 view ? view->wined3d_view : NULL);
582 }
583 wined3d_mutex_unlock();
584 }
585
586 static void STDMETHODCALLTYPE d3d11_immediate_context_GSSetSamplers(ID3D11DeviceContext *iface,
587 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
588 {
589 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
590 unsigned int i;
591
592 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
593 iface, start_slot, sampler_count, samplers);
594
595 wined3d_mutex_lock();
596 for (i = 0; i < sampler_count; ++i)
597 {
598 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
599
600 wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
601 sampler ? sampler->wined3d_sampler : NULL);
602 }
603 wined3d_mutex_unlock();
604 }
605
606 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetRenderTargets(ID3D11DeviceContext *iface,
607 UINT render_target_view_count, ID3D11RenderTargetView *const *render_target_views,
608 ID3D11DepthStencilView *depth_stencil_view)
609 {
610 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
611 struct d3d_depthstencil_view *dsv;
612 unsigned int i;
613
614 TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
615 iface, render_target_view_count, render_target_views, depth_stencil_view);
616
617 wined3d_mutex_lock();
618 for (i = 0; i < render_target_view_count; ++i)
619 {
620 struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D11RenderTargetView(render_target_views[i]);
621 wined3d_device_set_rendertarget_view(device->wined3d_device, i, rtv ? rtv->wined3d_view : NULL, FALSE);
622 }
623 for (; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
624 {
625 wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
626 }
627
628 dsv = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
629 wined3d_device_set_depth_stencil_view(device->wined3d_device, dsv ? dsv->wined3d_view : NULL);
630 wined3d_mutex_unlock();
631 }
632
633 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetRenderTargetsAndUnorderedAccessViews(
634 ID3D11DeviceContext *iface, UINT render_target_view_count,
635 ID3D11RenderTargetView *const *render_target_views, ID3D11DepthStencilView *depth_stencil_view,
636 UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
637 ID3D11UnorderedAccessView *const *unordered_access_views, const UINT *initial_counts)
638 {
639 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
640 unsigned int i;
641
642 TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
643 "unordered_access_view_start_slot %u, unordered_access_view_count %u, unordered_access_views %p, "
644 "initial_counts %p.\n",
645 iface, render_target_view_count, render_target_views, depth_stencil_view,
646 unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views,
647 initial_counts);
648
649 if (render_target_view_count != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL)
650 {
651 d3d11_immediate_context_OMSetRenderTargets(iface, render_target_view_count, render_target_views,
652 depth_stencil_view);
653 }
654
655 if (unordered_access_view_count != D3D11_KEEP_UNORDERED_ACCESS_VIEWS)
656 {
657 wined3d_mutex_lock();
658 for (i = 0; i < unordered_access_view_start_slot; ++i)
659 {
660 wined3d_device_set_unordered_access_view(device->wined3d_device, i, NULL);
661 }
662 for (i = 0; i < unordered_access_view_count; ++i)
663 {
664 struct d3d11_unordered_access_view *view
665 = unsafe_impl_from_ID3D11UnorderedAccessView(unordered_access_views[i]);
666
667 if (initial_counts && view && view->desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER
668 && (view->desc.u.Buffer.Flags & (D3D11_BUFFER_UAV_FLAG_APPEND | D3D11_BUFFER_UAV_FLAG_COUNTER))
669 && initial_counts[i] != ~(UINT)0)
670 FIXME("Ignoring initial count %u for slot %u.\n",
671 initial_counts[i], unordered_access_view_start_slot + i);
672
673 wined3d_device_set_unordered_access_view(device->wined3d_device,
674 unordered_access_view_start_slot + i,
675 view ? view->wined3d_view : NULL);
676 }
677 for (; unordered_access_view_start_slot + i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i)
678 {
679 wined3d_device_set_unordered_access_view(device->wined3d_device,
680 unordered_access_view_start_slot + i, NULL);
681 }
682 wined3d_mutex_unlock();
683 }
684 }
685
686 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetBlendState(ID3D11DeviceContext *iface,
687 ID3D11BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
688 {
689 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
690 static const float default_blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
691 const D3D11_BLEND_DESC *desc;
692
693 TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
694 iface, blend_state, debug_float4(blend_factor), sample_mask);
695
696 if (!blend_factor)
697 blend_factor = default_blend_factor;
698
699 wined3d_mutex_lock();
700 memcpy(device->blend_factor, blend_factor, 4 * sizeof(*blend_factor));
701 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK, sample_mask);
702 if (!(device->blend_state = unsafe_impl_from_ID3D11BlendState(blend_state)))
703 {
704 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE, FALSE);
705 wined3d_device_set_render_state(device->wined3d_device,
706 WINED3D_RS_COLORWRITEENABLE, D3D11_COLOR_WRITE_ENABLE_ALL);
707 wined3d_device_set_render_state(device->wined3d_device,
708 WINED3D_RS_COLORWRITEENABLE1, D3D11_COLOR_WRITE_ENABLE_ALL);
709 wined3d_device_set_render_state(device->wined3d_device,
710 WINED3D_RS_COLORWRITEENABLE2, D3D11_COLOR_WRITE_ENABLE_ALL);
711 wined3d_device_set_render_state(device->wined3d_device,
712 WINED3D_RS_COLORWRITEENABLE3, D3D11_COLOR_WRITE_ENABLE_ALL);
713 wined3d_mutex_unlock();
714 return;
715 }
716
717 desc = &device->blend_state->desc;
718 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ALPHABLENDENABLE,
719 desc->RenderTarget[0].BlendEnable);
720 if (desc->RenderTarget[0].BlendEnable)
721 {
722 const D3D11_RENDER_TARGET_BLEND_DESC *d = &desc->RenderTarget[0];
723
724 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLEND, d->SrcBlend);
725 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLEND, d->DestBlend);
726 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOP, d->BlendOp);
727 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SEPARATEALPHABLENDENABLE, TRUE);
728 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SRCBLENDALPHA, d->SrcBlendAlpha);
729 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DESTBLENDALPHA, d->DestBlendAlpha);
730 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BLENDOPALPHA, d->BlendOpAlpha);
731
732 if (memcmp(blend_factor, default_blend_factor, sizeof(default_blend_factor))
733 && (d->SrcBlend == D3D11_BLEND_BLEND_FACTOR || d->SrcBlend == D3D11_BLEND_INV_BLEND_FACTOR
734 || d->DestBlend == D3D11_BLEND_BLEND_FACTOR || d->DestBlend == D3D11_BLEND_INV_BLEND_FACTOR
735 || d->SrcBlendAlpha == D3D11_BLEND_BLEND_FACTOR || d->SrcBlendAlpha == D3D11_BLEND_INV_BLEND_FACTOR
736 || d->DestBlendAlpha == D3D11_BLEND_BLEND_FACTOR || d->DestBlendAlpha == D3D11_BLEND_INV_BLEND_FACTOR))
737 FIXME("Ignoring blend factor %s.\n", debug_float4(blend_factor));
738 }
739 wined3d_device_set_render_state(device->wined3d_device,
740 WINED3D_RS_COLORWRITEENABLE, desc->RenderTarget[0].RenderTargetWriteMask);
741 wined3d_device_set_render_state(device->wined3d_device,
742 WINED3D_RS_COLORWRITEENABLE1, desc->RenderTarget[1].RenderTargetWriteMask);
743 wined3d_device_set_render_state(device->wined3d_device,
744 WINED3D_RS_COLORWRITEENABLE2, desc->RenderTarget[2].RenderTargetWriteMask);
745 wined3d_device_set_render_state(device->wined3d_device,
746 WINED3D_RS_COLORWRITEENABLE3, desc->RenderTarget[3].RenderTargetWriteMask);
747 wined3d_mutex_unlock();
748 }
749
750 static void STDMETHODCALLTYPE d3d11_immediate_context_OMSetDepthStencilState(ID3D11DeviceContext *iface,
751 ID3D11DepthStencilState *depth_stencil_state, UINT stencil_ref)
752 {
753 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
754 const D3D11_DEPTH_STENCILOP_DESC *front, *back;
755 const D3D11_DEPTH_STENCIL_DESC *desc;
756
757 TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
758 iface, depth_stencil_state, stencil_ref);
759
760 wined3d_mutex_lock();
761 device->stencil_ref = stencil_ref;
762 if (!(device->depth_stencil_state = unsafe_impl_from_ID3D11DepthStencilState(depth_stencil_state)))
763 {
764 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, TRUE);
765 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZWRITEENABLE, D3D11_DEPTH_WRITE_MASK_ALL);
766 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZFUNC, D3D11_COMPARISON_LESS);
767 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILENABLE, FALSE);
768 wined3d_mutex_unlock();
769 return;
770 }
771
772 desc = &device->depth_stencil_state->desc;
773
774 front = &desc->FrontFace;
775 back = &desc->BackFace;
776
777 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, desc->DepthEnable);
778 if (desc->DepthEnable)
779 {
780 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZWRITEENABLE, desc->DepthWriteMask);
781 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZFUNC, desc->DepthFunc);
782 }
783
784 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILENABLE, desc->StencilEnable);
785 if (desc->StencilEnable)
786 {
787 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILMASK, desc->StencilReadMask);
788 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILWRITEMASK, desc->StencilWriteMask);
789 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILREF, stencil_ref);
790
791 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILFAIL, front->StencilFailOp);
792 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILZFAIL, front->StencilDepthFailOp);
793 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILPASS, front->StencilPassOp);
794 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_STENCILFUNC, front->StencilFunc);
795 if (front->StencilFailOp != back->StencilFailOp
796 || front->StencilDepthFailOp != back->StencilDepthFailOp
797 || front->StencilPassOp != back->StencilPassOp
798 || front->StencilFunc != back->StencilFunc)
799 {
800 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_TWOSIDEDSTENCILMODE, TRUE);
801 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BACK_STENCILFAIL, back->StencilFailOp);
802 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BACK_STENCILZFAIL,
803 back->StencilDepthFailOp);
804 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BACK_STENCILPASS, back->StencilPassOp);
805 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_BACK_STENCILFUNC, back->StencilFunc);
806 }
807 else
808 {
809 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_TWOSIDEDSTENCILMODE, FALSE);
810 }
811 }
812 wined3d_mutex_unlock();
813 }
814
815 static void STDMETHODCALLTYPE d3d11_immediate_context_SOSetTargets(ID3D11DeviceContext *iface, UINT buffer_count,
816 ID3D11Buffer *const *buffers, const UINT *offsets)
817 {
818 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
819 unsigned int count, i;
820
821 TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n", iface, buffer_count, buffers, offsets);
822
823 count = min(buffer_count, D3D11_SO_BUFFER_SLOT_COUNT);
824 wined3d_mutex_lock();
825 for (i = 0; i < count; ++i)
826 {
827 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
828
829 wined3d_device_set_stream_output(device->wined3d_device, i,
830 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
831 }
832 for (; i < D3D11_SO_BUFFER_SLOT_COUNT; ++i)
833 {
834 wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
835 }
836 wined3d_mutex_unlock();
837 }
838
839 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawAuto(ID3D11DeviceContext *iface)
840 {
841 FIXME("iface %p stub!\n", iface);
842 }
843
844 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawIndexedInstancedIndirect(ID3D11DeviceContext *iface,
845 ID3D11Buffer *buffer, UINT offset)
846 {
847 FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
848 }
849
850 static void STDMETHODCALLTYPE d3d11_immediate_context_DrawInstancedIndirect(ID3D11DeviceContext *iface,
851 ID3D11Buffer *buffer, UINT offset)
852 {
853 FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
854 }
855
856 static void STDMETHODCALLTYPE d3d11_immediate_context_Dispatch(ID3D11DeviceContext *iface,
857 UINT thread_group_count_x, UINT thread_group_count_y, UINT thread_group_count_z)
858 {
859 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
860
861 TRACE("iface %p, thread_group_count_x %u, thread_group_count_y %u, thread_group_count_z %u.\n",
862 iface, thread_group_count_x, thread_group_count_y, thread_group_count_z);
863
864 wined3d_mutex_lock();
865 wined3d_device_dispatch_compute(device->wined3d_device,
866 thread_group_count_x, thread_group_count_y, thread_group_count_z);
867 wined3d_mutex_unlock();
868 }
869
870 static void STDMETHODCALLTYPE d3d11_immediate_context_DispatchIndirect(ID3D11DeviceContext *iface,
871 ID3D11Buffer *buffer, UINT offset)
872 {
873 FIXME("iface %p, buffer %p, offset %u stub!\n", iface, buffer, offset);
874 }
875
876 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetState(ID3D11DeviceContext *iface,
877 ID3D11RasterizerState *rasterizer_state)
878 {
879 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
880 struct d3d_rasterizer_state *rasterizer_state_impl;
881 const D3D11_RASTERIZER_DESC *desc;
882
883 TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
884
885 wined3d_mutex_lock();
886 if (!(rasterizer_state_impl = unsafe_impl_from_ID3D11RasterizerState(rasterizer_state)))
887 {
888 wined3d_device_set_rasterizer_state(device->wined3d_device, NULL);
889 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, WINED3D_FILL_SOLID);
890 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, WINED3D_CULL_BACK);
891 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, FALSE);
892 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, FALSE);
893 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ANTIALIASEDLINEENABLE, FALSE);
894 wined3d_mutex_unlock();
895 return;
896 }
897
898 wined3d_device_set_rasterizer_state(device->wined3d_device, rasterizer_state_impl->wined3d_state);
899
900 desc = &rasterizer_state_impl->desc;
901 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_FILLMODE, desc->FillMode);
902 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, desc->CullMode);
903 /* OpenGL style depth bias. */
904 if (desc->DepthBias || desc->SlopeScaledDepthBias)
905 FIXME("Ignoring depth bias.\n");
906 /* GL_DEPTH_CLAMP */
907 if (!desc->DepthClipEnable)
908 FIXME("Ignoring DepthClipEnable %#x.\n", desc->DepthClipEnable);
909 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, desc->ScissorEnable);
910 wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, desc->MultisampleEnable);
911 wined3d_device_set_render_state(device->wined3d_device,
912 WINED3D_RS_ANTIALIASEDLINEENABLE, desc->AntialiasedLineEnable);
913 wined3d_mutex_unlock();
914 }
915
916 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetViewports(ID3D11DeviceContext *iface,
917 UINT viewport_count, const D3D11_VIEWPORT *viewports)
918 {
919 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
920 struct wined3d_viewport wined3d_vp;
921
922 TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
923
924 if (viewport_count > 1)
925 FIXME("Multiple viewports not implemented.\n");
926
927 if (!viewport_count)
928 return;
929
930 wined3d_vp.x = viewports[0].TopLeftX;
931 wined3d_vp.y = viewports[0].TopLeftY;
932 wined3d_vp.width = viewports[0].Width;
933 wined3d_vp.height = viewports[0].Height;
934 wined3d_vp.min_z = viewports[0].MinDepth;
935 wined3d_vp.max_z = viewports[0].MaxDepth;
936
937 wined3d_mutex_lock();
938 wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
939 wined3d_mutex_unlock();
940 }
941
942 static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetScissorRects(ID3D11DeviceContext *iface,
943 UINT rect_count, const D3D11_RECT *rects)
944 {
945 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
946
947 TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
948
949 if (rect_count > 1)
950 FIXME("Multiple scissor rects not implemented.\n");
951
952 if (!rect_count)
953 return;
954
955 wined3d_mutex_lock();
956 wined3d_device_set_scissor_rect(device->wined3d_device, rects);
957 wined3d_mutex_unlock();
958 }
959
960 static void STDMETHODCALLTYPE d3d11_immediate_context_CopySubresourceRegion(ID3D11DeviceContext *iface,
961 ID3D11Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
962 ID3D11Resource *src_resource, UINT src_subresource_idx, const D3D11_BOX *src_box)
963 {
964 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
965 struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
966 struct wined3d_box wined3d_src_box;
967
968 TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
969 "src_resource %p, src_subresource_idx %u, src_box %p.\n",
970 iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
971 src_resource, src_subresource_idx, src_box);
972
973 if (src_box)
974 wined3d_box_set(&wined3d_src_box, src_box->left, src_box->top,
975 src_box->right, src_box->bottom, src_box->front, src_box->back);
976
977 wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
978 wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
979 wined3d_mutex_lock();
980 wined3d_device_copy_sub_resource_region(device->wined3d_device, wined3d_dst_resource, dst_subresource_idx,
981 dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL);
982 wined3d_mutex_unlock();
983 }
984
985 static void STDMETHODCALLTYPE d3d11_immediate_context_CopyResource(ID3D11DeviceContext *iface,
986 ID3D11Resource *dst_resource, ID3D11Resource *src_resource)
987 {
988 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
989 struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
990
991 TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
992
993 wined3d_dst_resource = wined3d_resource_from_d3d11_resource(dst_resource);
994 wined3d_src_resource = wined3d_resource_from_d3d11_resource(src_resource);
995 wined3d_mutex_lock();
996 wined3d_device_copy_resource(device->wined3d_device, wined3d_dst_resource, wined3d_src_resource);
997 wined3d_mutex_unlock();
998 }
999
1000 static void STDMETHODCALLTYPE d3d11_immediate_context_UpdateSubresource(ID3D11DeviceContext *iface,
1001 ID3D11Resource *resource, UINT subresource_idx, const D3D11_BOX *box,
1002 const void *data, UINT row_pitch, UINT depth_pitch)
1003 {
1004 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1005 struct wined3d_resource *wined3d_resource;
1006 struct wined3d_box wined3d_box;
1007
1008 TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
1009 iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
1010
1011 if (box)
1012 wined3d_box_set(&wined3d_box, box->left, box->top, box->right, box->bottom, box->front, box->back);
1013
1014 wined3d_resource = wined3d_resource_from_d3d11_resource(resource);
1015 wined3d_mutex_lock();
1016 wined3d_device_update_sub_resource(device->wined3d_device, wined3d_resource,
1017 subresource_idx, box ? &wined3d_box : NULL, data, row_pitch, depth_pitch);
1018 wined3d_mutex_unlock();
1019 }
1020
1021 static void STDMETHODCALLTYPE d3d11_immediate_context_CopyStructureCount(ID3D11DeviceContext *iface,
1022 ID3D11Buffer *dst_buffer, UINT dst_offset, ID3D11UnorderedAccessView *src_view)
1023 {
1024 FIXME("iface %p, dst_buffer %p, dst_offset %u, src_view %p stub!\n",
1025 iface, dst_buffer, dst_offset, src_view);
1026 }
1027
1028 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearRenderTargetView(ID3D11DeviceContext *iface,
1029 ID3D11RenderTargetView *render_target_view, const float color_rgba[4])
1030 {
1031 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1032 struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D11RenderTargetView(render_target_view);
1033 const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
1034 HRESULT hr;
1035
1036 TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
1037 iface, render_target_view, debug_float4(color_rgba));
1038
1039 if (!view)
1040 return;
1041
1042 wined3d_mutex_lock();
1043 if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
1044 WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
1045 ERR("Failed to clear view, hr %#x.\n", hr);
1046 wined3d_mutex_unlock();
1047 }
1048
1049 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearUnorderedAccessViewUint(ID3D11DeviceContext *iface,
1050 ID3D11UnorderedAccessView *unordered_access_view, const UINT values[4])
1051 {
1052 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1053 struct d3d11_unordered_access_view *view;
1054
1055 TRACE("iface %p, unordered_access_view %p, values {%u, %u, %u, %u}.\n",
1056 iface, unordered_access_view, values[0], values[1], values[2], values[3]);
1057
1058 view = unsafe_impl_from_ID3D11UnorderedAccessView(unordered_access_view);
1059 wined3d_mutex_lock();
1060 wined3d_device_clear_unordered_access_view_uint(device->wined3d_device,
1061 view->wined3d_view, (const struct wined3d_uvec4 *)values);
1062 wined3d_mutex_unlock();
1063 }
1064
1065 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearUnorderedAccessViewFloat(ID3D11DeviceContext *iface,
1066 ID3D11UnorderedAccessView *unordered_access_view, const float values[4])
1067 {
1068 FIXME("iface %p, unordered_access_view %p, values %s stub!\n",
1069 iface, unordered_access_view, debug_float4(values));
1070 }
1071
1072 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearDepthStencilView(ID3D11DeviceContext *iface,
1073 ID3D11DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
1074 {
1075 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1076 struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D11DepthStencilView(depth_stencil_view);
1077 DWORD wined3d_flags;
1078 HRESULT hr;
1079
1080 TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
1081 iface, depth_stencil_view, flags, depth, stencil);
1082
1083 if (!view)
1084 return;
1085
1086 wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
1087
1088 wined3d_mutex_lock();
1089 if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
1090 wined3d_flags, NULL, depth, stencil)))
1091 ERR("Failed to clear view, hr %#x.\n", hr);
1092 wined3d_mutex_unlock();
1093 }
1094
1095 static void STDMETHODCALLTYPE d3d11_immediate_context_GenerateMips(ID3D11DeviceContext *iface,
1096 ID3D11ShaderResourceView *view)
1097 {
1098 FIXME("iface %p, view %p stub!\n", iface, view);
1099 }
1100
1101 static void STDMETHODCALLTYPE d3d11_immediate_context_SetResourceMinLOD(ID3D11DeviceContext *iface,
1102 ID3D11Resource *resource, FLOAT min_lod)
1103 {
1104 FIXME("iface %p, resource %p, min_lod %f stub!\n", iface, resource, min_lod);
1105 }
1106
1107 static FLOAT STDMETHODCALLTYPE d3d11_immediate_context_GetResourceMinLOD(ID3D11DeviceContext *iface,
1108 ID3D11Resource *resource)
1109 {
1110 FIXME("iface %p, resource %p stub!\n", iface, resource);
1111
1112 return 0.0f;
1113 }
1114
1115 static void STDMETHODCALLTYPE d3d11_immediate_context_ResolveSubresource(ID3D11DeviceContext *iface,
1116 ID3D11Resource *dst_resource, UINT dst_subresource_idx,
1117 ID3D11Resource *src_resource, UINT src_subresource_idx,
1118 DXGI_FORMAT format)
1119 {
1120 FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, src_resource %p, src_subresource_idx %u, "
1121 "format %s stub!\n",
1122 iface, dst_resource, dst_subresource_idx, src_resource, src_subresource_idx,
1123 debug_dxgi_format(format));
1124 }
1125
1126 static void STDMETHODCALLTYPE d3d11_immediate_context_ExecuteCommandList(ID3D11DeviceContext *iface,
1127 ID3D11CommandList *command_list, BOOL restore_state)
1128 {
1129 FIXME("iface %p, command_list %p, restore_state %#x stub!\n", iface, command_list, restore_state);
1130 }
1131
1132 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetShaderResources(ID3D11DeviceContext *iface,
1133 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1134 {
1135 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1136 unsigned int i;
1137
1138 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1139 iface, start_slot, view_count, views);
1140
1141 wined3d_mutex_lock();
1142 for (i = 0; i < view_count; ++i)
1143 {
1144 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1145
1146 wined3d_device_set_hs_resource_view(device->wined3d_device, start_slot + i,
1147 view ? view->wined3d_view : NULL);
1148 }
1149 wined3d_mutex_unlock();
1150 }
1151
1152 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetShader(ID3D11DeviceContext *iface,
1153 ID3D11HullShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1154 {
1155 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1156 struct d3d11_hull_shader *hs = unsafe_impl_from_ID3D11HullShader(shader);
1157
1158 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1159 iface, shader, class_instances, class_instance_count);
1160
1161 if (class_instances)
1162 FIXME("Dynamic linking is not implemented yet.\n");
1163
1164 wined3d_mutex_lock();
1165 wined3d_device_set_hull_shader(device->wined3d_device, hs ? hs->wined3d_shader : NULL);
1166 wined3d_mutex_unlock();
1167 }
1168
1169 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetSamplers(ID3D11DeviceContext *iface,
1170 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1171 {
1172 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1173 unsigned int i;
1174
1175 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1176 iface, start_slot, sampler_count, samplers);
1177
1178 wined3d_mutex_lock();
1179 for (i = 0; i < sampler_count; ++i)
1180 {
1181 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1182
1183 wined3d_device_set_hs_sampler(device->wined3d_device, start_slot + i,
1184 sampler ? sampler->wined3d_sampler : NULL);
1185 }
1186 wined3d_mutex_unlock();
1187 }
1188
1189 static void STDMETHODCALLTYPE d3d11_immediate_context_HSSetConstantBuffers(ID3D11DeviceContext *iface,
1190 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1191 {
1192 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1193 unsigned int i;
1194
1195 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1196 iface, start_slot, buffer_count, buffers);
1197
1198 wined3d_mutex_lock();
1199 for (i = 0; i < buffer_count; ++i)
1200 {
1201 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
1202
1203 wined3d_device_set_hs_cb(device->wined3d_device, start_slot + i,
1204 buffer ? buffer->wined3d_buffer : NULL);
1205 }
1206 wined3d_mutex_unlock();
1207 }
1208
1209 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetShaderResources(ID3D11DeviceContext *iface,
1210 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1211 {
1212 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1213 unsigned int i;
1214
1215 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1216 iface, start_slot, view_count, views);
1217
1218 wined3d_mutex_lock();
1219 for (i = 0; i < view_count; ++i)
1220 {
1221 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1222
1223 wined3d_device_set_ds_resource_view(device->wined3d_device, start_slot + i,
1224 view ? view->wined3d_view : NULL);
1225 }
1226 wined3d_mutex_unlock();
1227 }
1228
1229 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetShader(ID3D11DeviceContext *iface,
1230 ID3D11DomainShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1231 {
1232 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1233 struct d3d11_domain_shader *ds = unsafe_impl_from_ID3D11DomainShader(shader);
1234
1235 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1236 iface, shader, class_instances, class_instance_count);
1237
1238 if (class_instances)
1239 FIXME("Dynamic linking is not implemented yet.\n");
1240
1241 wined3d_mutex_lock();
1242 wined3d_device_set_domain_shader(device->wined3d_device, ds ? ds->wined3d_shader : NULL);
1243 wined3d_mutex_unlock();
1244 }
1245
1246 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetSamplers(ID3D11DeviceContext *iface,
1247 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1248 {
1249 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1250 unsigned int i;
1251
1252 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1253 iface, start_slot, sampler_count, samplers);
1254
1255 wined3d_mutex_lock();
1256 for (i = 0; i < sampler_count; ++i)
1257 {
1258 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1259
1260 wined3d_device_set_ds_sampler(device->wined3d_device, start_slot + i,
1261 sampler ? sampler->wined3d_sampler : NULL);
1262 }
1263 wined3d_mutex_unlock();
1264 }
1265
1266 static void STDMETHODCALLTYPE d3d11_immediate_context_DSSetConstantBuffers(ID3D11DeviceContext *iface,
1267 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1268 {
1269 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1270 unsigned int i;
1271
1272 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1273 iface, start_slot, buffer_count, buffers);
1274
1275 wined3d_mutex_lock();
1276 for (i = 0; i < buffer_count; ++i)
1277 {
1278 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
1279
1280 wined3d_device_set_ds_cb(device->wined3d_device, start_slot + i,
1281 buffer ? buffer->wined3d_buffer : NULL);
1282 }
1283 wined3d_mutex_unlock();
1284 }
1285
1286 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetShaderResources(ID3D11DeviceContext *iface,
1287 UINT start_slot, UINT view_count, ID3D11ShaderResourceView *const *views)
1288 {
1289 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1290 unsigned int i;
1291
1292 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1293 iface, start_slot, view_count, views);
1294
1295 wined3d_mutex_lock();
1296 for (i = 0; i < view_count; ++i)
1297 {
1298 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D11ShaderResourceView(views[i]);
1299
1300 wined3d_device_set_cs_resource_view(device->wined3d_device, start_slot + i,
1301 view ? view->wined3d_view : NULL);
1302 }
1303 wined3d_mutex_unlock();
1304 }
1305
1306 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetUnorderedAccessViews(ID3D11DeviceContext *iface,
1307 UINT start_slot, UINT view_count, ID3D11UnorderedAccessView *const *views, const UINT *initial_counts)
1308 {
1309 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1310 unsigned int i;
1311
1312 TRACE("iface %p, start_slot %u, view_count %u, views %p, initial_counts %p.\n",
1313 iface, start_slot, view_count, views, initial_counts);
1314
1315 wined3d_mutex_lock();
1316 for (i = 0; i < view_count; ++i)
1317 {
1318 struct d3d11_unordered_access_view *view = unsafe_impl_from_ID3D11UnorderedAccessView(views[i]);
1319
1320 if (initial_counts && view && view->desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER
1321 && (view->desc.u.Buffer.Flags & (D3D11_BUFFER_UAV_FLAG_APPEND | D3D11_BUFFER_UAV_FLAG_COUNTER))
1322 && initial_counts[i] != ~(UINT)0)
1323 FIXME("Ignoring initial count %u for slot %u.\n", initial_counts[i], start_slot + i);
1324
1325 wined3d_device_set_cs_uav(device->wined3d_device, start_slot + i,
1326 view ? view->wined3d_view : NULL);
1327 }
1328 wined3d_mutex_unlock();
1329 }
1330
1331 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetShader(ID3D11DeviceContext *iface,
1332 ID3D11ComputeShader *shader, ID3D11ClassInstance *const *class_instances, UINT class_instance_count)
1333 {
1334 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1335 struct d3d11_compute_shader *cs = unsafe_impl_from_ID3D11ComputeShader(shader);
1336
1337 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %u.\n",
1338 iface, shader, class_instances, class_instance_count);
1339
1340 if (class_instances)
1341 FIXME("Dynamic linking is not implemented yet.\n");
1342
1343 wined3d_mutex_lock();
1344 wined3d_device_set_compute_shader(device->wined3d_device, cs ? cs->wined3d_shader : NULL);
1345 wined3d_mutex_unlock();
1346 }
1347
1348 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetSamplers(ID3D11DeviceContext *iface,
1349 UINT start_slot, UINT sampler_count, ID3D11SamplerState *const *samplers)
1350 {
1351 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1352 unsigned int i;
1353
1354 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1355 iface, start_slot, sampler_count, samplers);
1356
1357 wined3d_mutex_lock();
1358 for (i = 0; i < sampler_count; ++i)
1359 {
1360 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D11SamplerState(samplers[i]);
1361
1362 wined3d_device_set_cs_sampler(device->wined3d_device, start_slot + i,
1363 sampler ? sampler->wined3d_sampler : NULL);
1364 }
1365 wined3d_mutex_unlock();
1366 }
1367
1368 static void STDMETHODCALLTYPE d3d11_immediate_context_CSSetConstantBuffers(ID3D11DeviceContext *iface,
1369 UINT start_slot, UINT buffer_count, ID3D11Buffer *const *buffers)
1370 {
1371 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1372 unsigned int i;
1373
1374 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1375 iface, start_slot, buffer_count, buffers);
1376
1377 wined3d_mutex_lock();
1378 for (i = 0; i < buffer_count; ++i)
1379 {
1380 struct d3d_buffer *buffer = unsafe_impl_from_ID3D11Buffer(buffers[i]);
1381
1382 wined3d_device_set_cs_cb(device->wined3d_device, start_slot + i,
1383 buffer ? buffer->wined3d_buffer : NULL);
1384 }
1385 wined3d_mutex_unlock();
1386 }
1387
1388 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetConstantBuffers(ID3D11DeviceContext *iface,
1389 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1390 {
1391 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1392 unsigned int i;
1393
1394 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1395 iface, start_slot, buffer_count, buffers);
1396
1397 wined3d_mutex_lock();
1398 for (i = 0; i < buffer_count; ++i)
1399 {
1400 struct wined3d_buffer *wined3d_buffer;
1401 struct d3d_buffer *buffer_impl;
1402
1403 if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
1404 {
1405 buffers[i] = NULL;
1406 continue;
1407 }
1408
1409 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1410 buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1411 ID3D11Buffer_AddRef(buffers[i]);
1412 }
1413 wined3d_mutex_unlock();
1414 }
1415
1416 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetShaderResources(ID3D11DeviceContext *iface,
1417 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1418 {
1419 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1420 unsigned int i;
1421
1422 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
1423 iface, start_slot, view_count, views);
1424
1425 wined3d_mutex_lock();
1426 for (i = 0; i < view_count; ++i)
1427 {
1428 struct wined3d_shader_resource_view *wined3d_view;
1429 struct d3d_shader_resource_view *view_impl;
1430
1431 if (!(wined3d_view = wined3d_device_get_ps_resource_view(device->wined3d_device, start_slot + i)))
1432 {
1433 views[i] = NULL;
1434 continue;
1435 }
1436
1437 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1438 views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1439 ID3D11ShaderResourceView_AddRef(views[i]);
1440 }
1441 wined3d_mutex_unlock();
1442 }
1443
1444 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetShader(ID3D11DeviceContext *iface,
1445 ID3D11PixelShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1446 {
1447 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1448 struct wined3d_shader *wined3d_shader;
1449 struct d3d_pixel_shader *shader_impl;
1450
1451 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1452 iface, shader, class_instances, class_instance_count);
1453
1454 if (class_instances || class_instance_count)
1455 FIXME("Dynamic linking not implemented yet.\n");
1456
1457 wined3d_mutex_lock();
1458 if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
1459 {
1460 wined3d_mutex_unlock();
1461 *shader = NULL;
1462 return;
1463 }
1464
1465 shader_impl = wined3d_shader_get_parent(wined3d_shader);
1466 wined3d_mutex_unlock();
1467 *shader = &shader_impl->ID3D11PixelShader_iface;
1468 ID3D11PixelShader_AddRef(*shader);
1469 }
1470
1471 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetSamplers(ID3D11DeviceContext *iface,
1472 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1473 {
1474 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1475 unsigned int i;
1476
1477 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1478 iface, start_slot, sampler_count, samplers);
1479
1480 wined3d_mutex_lock();
1481 for (i = 0; i < sampler_count; ++i)
1482 {
1483 struct wined3d_sampler *wined3d_sampler;
1484 struct d3d_sampler_state *sampler_impl;
1485
1486 if (!(wined3d_sampler = wined3d_device_get_ps_sampler(device->wined3d_device, start_slot + i)))
1487 {
1488 samplers[i] = NULL;
1489 continue;
1490 }
1491
1492 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1493 samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1494 ID3D11SamplerState_AddRef(samplers[i]);
1495 }
1496 wined3d_mutex_unlock();
1497 }
1498
1499 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetShader(ID3D11DeviceContext *iface,
1500 ID3D11VertexShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1501 {
1502 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1503 struct d3d_vertex_shader *shader_impl;
1504 struct wined3d_shader *wined3d_shader;
1505
1506 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1507 iface, shader, class_instances, class_instance_count);
1508
1509 if (class_instances || class_instance_count)
1510 FIXME("Dynamic linking not implemented yet.\n");
1511
1512 wined3d_mutex_lock();
1513 if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
1514 {
1515 wined3d_mutex_unlock();
1516 *shader = NULL;
1517 return;
1518 }
1519
1520 shader_impl = wined3d_shader_get_parent(wined3d_shader);
1521 wined3d_mutex_unlock();
1522 *shader = &shader_impl->ID3D11VertexShader_iface;
1523 ID3D11VertexShader_AddRef(*shader);
1524 }
1525
1526 static void STDMETHODCALLTYPE d3d11_immediate_context_PSGetConstantBuffers(ID3D11DeviceContext *iface,
1527 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1528 {
1529 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1530 unsigned int i;
1531
1532 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1533 iface, start_slot, buffer_count, buffers);
1534
1535 wined3d_mutex_lock();
1536 for (i = 0; i < buffer_count; ++i)
1537 {
1538 struct wined3d_buffer *wined3d_buffer;
1539 struct d3d_buffer *buffer_impl;
1540
1541 if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
1542 {
1543 buffers[i] = NULL;
1544 continue;
1545 }
1546
1547 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1548 buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1549 ID3D11Buffer_AddRef(buffers[i]);
1550 }
1551 wined3d_mutex_unlock();
1552 }
1553
1554 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetInputLayout(ID3D11DeviceContext *iface,
1555 ID3D11InputLayout **input_layout)
1556 {
1557 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1558 struct wined3d_vertex_declaration *wined3d_declaration;
1559 struct d3d_input_layout *input_layout_impl;
1560
1561 TRACE("iface %p, input_layout %p.\n", iface, input_layout);
1562
1563 wined3d_mutex_lock();
1564 if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
1565 {
1566 wined3d_mutex_unlock();
1567 *input_layout = NULL;
1568 return;
1569 }
1570
1571 input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
1572 wined3d_mutex_unlock();
1573 *input_layout = &input_layout_impl->ID3D11InputLayout_iface;
1574 ID3D11InputLayout_AddRef(*input_layout);
1575 }
1576
1577 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetVertexBuffers(ID3D11DeviceContext *iface,
1578 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers, UINT *strides, UINT *offsets)
1579 {
1580 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1581 unsigned int i;
1582
1583 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
1584 iface, start_slot, buffer_count, buffers, strides, offsets);
1585
1586 wined3d_mutex_lock();
1587 for (i = 0; i < buffer_count; ++i)
1588 {
1589 struct wined3d_buffer *wined3d_buffer = NULL;
1590 struct d3d_buffer *buffer_impl;
1591
1592 if (FAILED(wined3d_device_get_stream_source(device->wined3d_device, start_slot + i,
1593 &wined3d_buffer, &offsets[i], &strides[i])))
1594 {
1595 FIXME("Failed to get vertex buffer %u.\n", start_slot + i);
1596 if (strides)
1597 strides[i] = 0;
1598 if (offsets)
1599 offsets[i] = 0;
1600 }
1601
1602 if (!wined3d_buffer)
1603 {
1604 buffers[i] = NULL;
1605 continue;
1606 }
1607
1608 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1609 ID3D11Buffer_AddRef(buffers[i] = &buffer_impl->ID3D11Buffer_iface);
1610 }
1611 wined3d_mutex_unlock();
1612 }
1613
1614 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetIndexBuffer(ID3D11DeviceContext *iface,
1615 ID3D11Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
1616 {
1617 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1618 enum wined3d_format_id wined3d_format;
1619 struct wined3d_buffer *wined3d_buffer;
1620 struct d3d_buffer *buffer_impl;
1621
1622 TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
1623
1624 wined3d_mutex_lock();
1625 wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format, offset);
1626 *format = dxgi_format_from_wined3dformat(wined3d_format);
1627 if (!wined3d_buffer)
1628 {
1629 wined3d_mutex_unlock();
1630 *buffer = NULL;
1631 return;
1632 }
1633
1634 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1635 wined3d_mutex_unlock();
1636 ID3D11Buffer_AddRef(*buffer = &buffer_impl->ID3D11Buffer_iface);
1637 }
1638
1639 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetConstantBuffers(ID3D11DeviceContext *iface,
1640 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
1641 {
1642 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1643 unsigned int i;
1644
1645 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
1646 iface, start_slot, buffer_count, buffers);
1647
1648 wined3d_mutex_lock();
1649 for (i = 0; i < buffer_count; ++i)
1650 {
1651 struct wined3d_buffer *wined3d_buffer;
1652 struct d3d_buffer *buffer_impl;
1653
1654 if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
1655 {
1656 buffers[i] = NULL;
1657 continue;
1658 }
1659
1660 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1661 buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1662 ID3D11Buffer_AddRef(buffers[i]);
1663 }
1664 wined3d_mutex_unlock();
1665 }
1666
1667 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetShader(ID3D11DeviceContext *iface,
1668 ID3D11GeometryShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
1669 {
1670 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1671 struct d3d_geometry_shader *shader_impl;
1672 struct wined3d_shader *wined3d_shader;
1673
1674 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
1675 iface, shader, class_instances, class_instance_count);
1676
1677 if (class_instances || class_instance_count)
1678 FIXME("Dynamic linking not implemented yet.\n");
1679
1680 wined3d_mutex_lock();
1681 if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
1682 {
1683 wined3d_mutex_unlock();
1684 *shader = NULL;
1685 return;
1686 }
1687
1688 shader_impl = wined3d_shader_get_parent(wined3d_shader);
1689 wined3d_mutex_unlock();
1690 *shader = &shader_impl->ID3D11GeometryShader_iface;
1691 ID3D11GeometryShader_AddRef(*shader);
1692 }
1693
1694 static void STDMETHODCALLTYPE d3d11_immediate_context_IAGetPrimitiveTopology(ID3D11DeviceContext *iface,
1695 D3D11_PRIMITIVE_TOPOLOGY *topology)
1696 {
1697 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1698
1699 TRACE("iface %p, topology %p.\n", iface, topology);
1700
1701 wined3d_mutex_lock();
1702 wined3d_device_get_primitive_type(device->wined3d_device, (enum wined3d_primitive_type *)topology);
1703 wined3d_mutex_unlock();
1704 }
1705
1706 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetShaderResources(ID3D11DeviceContext *iface,
1707 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1708 {
1709 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1710 unsigned int i;
1711
1712 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
1713
1714 wined3d_mutex_lock();
1715 for (i = 0; i < view_count; ++i)
1716 {
1717 struct wined3d_shader_resource_view *wined3d_view;
1718 struct d3d_shader_resource_view *view_impl;
1719
1720 if (!(wined3d_view = wined3d_device_get_vs_resource_view(device->wined3d_device, start_slot + i)))
1721 {
1722 views[i] = NULL;
1723 continue;
1724 }
1725
1726 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1727 views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1728 ID3D11ShaderResourceView_AddRef(views[i]);
1729 }
1730 wined3d_mutex_unlock();
1731 }
1732
1733 static void STDMETHODCALLTYPE d3d11_immediate_context_VSGetSamplers(ID3D11DeviceContext *iface,
1734 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1735 {
1736 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1737 unsigned int i;
1738
1739 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1740 iface, start_slot, sampler_count, samplers);
1741
1742 wined3d_mutex_lock();
1743 for (i = 0; i < sampler_count; ++i)
1744 {
1745 struct wined3d_sampler *wined3d_sampler;
1746 struct d3d_sampler_state *sampler_impl;
1747
1748 if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
1749 {
1750 samplers[i] = NULL;
1751 continue;
1752 }
1753
1754 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1755 samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1756 ID3D11SamplerState_AddRef(samplers[i]);
1757 }
1758 wined3d_mutex_unlock();
1759 }
1760
1761 static void STDMETHODCALLTYPE d3d11_immediate_context_GetPredication(ID3D11DeviceContext *iface,
1762 ID3D11Predicate **predicate, BOOL *value)
1763 {
1764 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1765 struct wined3d_query *wined3d_predicate;
1766 struct d3d_query *predicate_impl;
1767
1768 TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
1769
1770 wined3d_mutex_lock();
1771 if (!(wined3d_predicate = wined3d_device_get_predication(device->wined3d_device, value)))
1772 {
1773 wined3d_mutex_unlock();
1774 *predicate = NULL;
1775 return;
1776 }
1777
1778 predicate_impl = wined3d_query_get_parent(wined3d_predicate);
1779 wined3d_mutex_unlock();
1780 *predicate = (ID3D11Predicate *)&predicate_impl->ID3D11Query_iface;
1781 ID3D11Predicate_AddRef(*predicate);
1782 }
1783
1784 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetShaderResources(ID3D11DeviceContext *iface,
1785 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
1786 {
1787 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1788 unsigned int i;
1789
1790 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
1791
1792 wined3d_mutex_lock();
1793 for (i = 0; i < view_count; ++i)
1794 {
1795 struct wined3d_shader_resource_view *wined3d_view;
1796 struct d3d_shader_resource_view *view_impl;
1797
1798 if (!(wined3d_view = wined3d_device_get_gs_resource_view(device->wined3d_device, start_slot + i)))
1799 {
1800 views[i] = NULL;
1801 continue;
1802 }
1803
1804 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
1805 views[i] = &view_impl->ID3D11ShaderResourceView_iface;
1806 ID3D11ShaderResourceView_AddRef(views[i]);
1807 }
1808 wined3d_mutex_unlock();
1809 }
1810
1811 static void STDMETHODCALLTYPE d3d11_immediate_context_GSGetSamplers(ID3D11DeviceContext *iface,
1812 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
1813 {
1814 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1815 unsigned int i;
1816
1817 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
1818 iface, start_slot, sampler_count, samplers);
1819
1820 wined3d_mutex_lock();
1821 for (i = 0; i < sampler_count; ++i)
1822 {
1823 struct d3d_sampler_state *sampler_impl;
1824 struct wined3d_sampler *wined3d_sampler;
1825
1826 if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
1827 {
1828 samplers[i] = NULL;
1829 continue;
1830 }
1831
1832 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
1833 samplers[i] = &sampler_impl->ID3D11SamplerState_iface;
1834 ID3D11SamplerState_AddRef(samplers[i]);
1835 }
1836 wined3d_mutex_unlock();
1837 }
1838
1839 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetRenderTargets(ID3D11DeviceContext *iface,
1840 UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
1841 ID3D11DepthStencilView **depth_stencil_view)
1842 {
1843 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1844 struct wined3d_rendertarget_view *wined3d_view;
1845
1846 TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
1847 iface, render_target_view_count, render_target_views, depth_stencil_view);
1848
1849 wined3d_mutex_lock();
1850 if (render_target_views)
1851 {
1852 struct d3d_rendertarget_view *view_impl;
1853 unsigned int i;
1854
1855 for (i = 0; i < render_target_view_count; ++i)
1856 {
1857 if (!(wined3d_view = wined3d_device_get_rendertarget_view(device->wined3d_device, i))
1858 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1859 {
1860 render_target_views[i] = NULL;
1861 continue;
1862 }
1863
1864 render_target_views[i] = &view_impl->ID3D11RenderTargetView_iface;
1865 ID3D11RenderTargetView_AddRef(render_target_views[i]);
1866 }
1867 }
1868
1869 if (depth_stencil_view)
1870 {
1871 struct d3d_depthstencil_view *view_impl;
1872
1873 if (!(wined3d_view = wined3d_device_get_depth_stencil_view(device->wined3d_device))
1874 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
1875 {
1876 *depth_stencil_view = NULL;
1877 }
1878 else
1879 {
1880 *depth_stencil_view = &view_impl->ID3D11DepthStencilView_iface;
1881 ID3D11DepthStencilView_AddRef(*depth_stencil_view);
1882 }
1883 }
1884 wined3d_mutex_unlock();
1885 }
1886
1887 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetRenderTargetsAndUnorderedAccessViews(
1888 ID3D11DeviceContext *iface,
1889 UINT render_target_view_count, ID3D11RenderTargetView **render_target_views,
1890 ID3D11DepthStencilView **depth_stencil_view,
1891 UINT unordered_access_view_start_slot, UINT unordered_access_view_count,
1892 ID3D11UnorderedAccessView **unordered_access_views)
1893 {
1894 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1895 struct wined3d_unordered_access_view *wined3d_view;
1896 struct d3d11_unordered_access_view *view_impl;
1897 unsigned int i;
1898
1899 TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p, "
1900 "unordered_access_view_start_slot %u, unordered_access_view_count %u, "
1901 "unordered_access_views %p.\n",
1902 iface, render_target_view_count, render_target_views, depth_stencil_view,
1903 unordered_access_view_start_slot, unordered_access_view_count, unordered_access_views);
1904
1905 if (render_target_views || depth_stencil_view)
1906 d3d11_immediate_context_OMGetRenderTargets(iface, render_target_view_count,
1907 render_target_views, depth_stencil_view);
1908
1909 if (unordered_access_views)
1910 {
1911 wined3d_mutex_lock();
1912 for (i = 0; i < unordered_access_view_count; ++i)
1913 {
1914 if (!(wined3d_view = wined3d_device_get_unordered_access_view(device->wined3d_device,
1915 unordered_access_view_start_slot + i)))
1916 {
1917 unordered_access_views[i] = NULL;
1918 continue;
1919 }
1920
1921 view_impl = wined3d_unordered_access_view_get_parent(wined3d_view);
1922 unordered_access_views[i] = &view_impl->ID3D11UnorderedAccessView_iface;
1923 ID3D11UnorderedAccessView_AddRef(unordered_access_views[i]);
1924 }
1925 wined3d_mutex_unlock();
1926 }
1927 }
1928
1929 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetBlendState(ID3D11DeviceContext *iface,
1930 ID3D11BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
1931 {
1932 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1933
1934 TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
1935 iface, blend_state, blend_factor, sample_mask);
1936
1937 if ((*blend_state = device->blend_state ? &device->blend_state->ID3D11BlendState_iface : NULL))
1938 ID3D11BlendState_AddRef(*blend_state);
1939 wined3d_mutex_lock();
1940 memcpy(blend_factor, device->blend_factor, 4 * sizeof(*blend_factor));
1941 *sample_mask = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEMASK);
1942 wined3d_mutex_unlock();
1943 }
1944
1945 static void STDMETHODCALLTYPE d3d11_immediate_context_OMGetDepthStencilState(ID3D11DeviceContext *iface,
1946 ID3D11DepthStencilState **depth_stencil_state, UINT *stencil_ref)
1947 {
1948 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1949
1950 TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
1951 iface, depth_stencil_state, stencil_ref);
1952
1953 if ((*depth_stencil_state = device->depth_stencil_state
1954 ? &device->depth_stencil_state->ID3D11DepthStencilState_iface : NULL))
1955 ID3D11DepthStencilState_AddRef(*depth_stencil_state);
1956 *stencil_ref = device->stencil_ref;
1957 }
1958
1959 static void STDMETHODCALLTYPE d3d11_immediate_context_SOGetTargets(ID3D11DeviceContext *iface,
1960 UINT buffer_count, ID3D11Buffer **buffers)
1961 {
1962 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1963 unsigned int i;
1964
1965 TRACE("iface %p, buffer_count %u, buffers %p.\n", iface, buffer_count, buffers);
1966
1967 wined3d_mutex_lock();
1968 for (i = 0; i < buffer_count; ++i)
1969 {
1970 struct wined3d_buffer *wined3d_buffer;
1971 struct d3d_buffer *buffer_impl;
1972
1973 if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, NULL)))
1974 {
1975 buffers[i] = NULL;
1976 continue;
1977 }
1978
1979 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
1980 buffers[i] = &buffer_impl->ID3D11Buffer_iface;
1981 ID3D11Buffer_AddRef(buffers[i]);
1982 }
1983 wined3d_mutex_unlock();
1984 }
1985
1986 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetState(ID3D11DeviceContext *iface,
1987 ID3D11RasterizerState **rasterizer_state)
1988 {
1989 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
1990 struct d3d_rasterizer_state *rasterizer_state_impl;
1991 struct wined3d_rasterizer_state *wined3d_state;
1992
1993 TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
1994
1995 wined3d_mutex_lock();
1996 if ((wined3d_state = wined3d_device_get_rasterizer_state(device->wined3d_device)))
1997 {
1998 rasterizer_state_impl = wined3d_rasterizer_state_get_parent(wined3d_state);
1999 ID3D11RasterizerState_AddRef(*rasterizer_state = &rasterizer_state_impl->ID3D11RasterizerState_iface);
2000 }
2001 else
2002 {
2003 *rasterizer_state = NULL;
2004 }
2005 wined3d_mutex_unlock();
2006 }
2007
2008 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetViewports(ID3D11DeviceContext *iface,
2009 UINT *viewport_count, D3D11_VIEWPORT *viewports)
2010 {
2011 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2012 struct wined3d_viewport wined3d_vp;
2013
2014 TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
2015
2016 if (!viewports)
2017 {
2018 *viewport_count = 1;
2019 return;
2020 }
2021
2022 if (!*viewport_count)
2023 return;
2024
2025 wined3d_mutex_lock();
2026 wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
2027 wined3d_mutex_unlock();
2028
2029 viewports[0].TopLeftX = wined3d_vp.x;
2030 viewports[0].TopLeftY = wined3d_vp.y;
2031 viewports[0].Width = wined3d_vp.width;
2032 viewports[0].Height = wined3d_vp.height;
2033 viewports[0].MinDepth = wined3d_vp.min_z;
2034 viewports[0].MaxDepth = wined3d_vp.max_z;
2035
2036 if (*viewport_count > 1)
2037 memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
2038 }
2039
2040 static void STDMETHODCALLTYPE d3d11_immediate_context_RSGetScissorRects(ID3D11DeviceContext *iface,
2041 UINT *rect_count, D3D11_RECT *rects)
2042 {
2043 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2044
2045 TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
2046
2047 if (!rects)
2048 {
2049 *rect_count = 1;
2050 return;
2051 }
2052
2053 if (!*rect_count)
2054 return;
2055
2056 wined3d_mutex_lock();
2057 wined3d_device_get_scissor_rect(device->wined3d_device, rects);
2058 wined3d_mutex_unlock();
2059 if (*rect_count > 1)
2060 memset(&rects[1], 0, (*rect_count - 1) * sizeof(*rects));
2061 }
2062
2063 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetShaderResources(ID3D11DeviceContext *iface,
2064 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2065 {
2066 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2067 unsigned int i;
2068
2069 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2070
2071 wined3d_mutex_lock();
2072 for (i = 0; i < view_count; ++i)
2073 {
2074 struct wined3d_shader_resource_view *wined3d_view;
2075 struct d3d_shader_resource_view *view_impl;
2076
2077 if (!(wined3d_view = wined3d_device_get_hs_resource_view(device->wined3d_device, start_slot + i)))
2078 {
2079 views[i] = NULL;
2080 continue;
2081 }
2082
2083 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2084 ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2085 }
2086 wined3d_mutex_unlock();
2087 }
2088
2089 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetShader(ID3D11DeviceContext *iface,
2090 ID3D11HullShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2091 {
2092 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2093 struct d3d11_hull_shader *shader_impl;
2094 struct wined3d_shader *wined3d_shader;
2095
2096 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2097 iface, shader, class_instances, class_instance_count);
2098
2099 if (class_instances || class_instance_count)
2100 FIXME("Dynamic linking not implemented yet.\n");
2101
2102 wined3d_mutex_lock();
2103 if (!(wined3d_shader = wined3d_device_get_hull_shader(device->wined3d_device)))
2104 {
2105 wined3d_mutex_unlock();
2106 *shader = NULL;
2107 return;
2108 }
2109
2110 shader_impl = wined3d_shader_get_parent(wined3d_shader);
2111 wined3d_mutex_unlock();
2112 ID3D11HullShader_AddRef(*shader = &shader_impl->ID3D11HullShader_iface);
2113 }
2114
2115 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetSamplers(ID3D11DeviceContext *iface,
2116 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2117 {
2118 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2119 unsigned int i;
2120
2121 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2122 iface, start_slot, sampler_count, samplers);
2123
2124 wined3d_mutex_lock();
2125 for (i = 0; i < sampler_count; ++i)
2126 {
2127 struct wined3d_sampler *wined3d_sampler;
2128 struct d3d_sampler_state *sampler_impl;
2129
2130 if (!(wined3d_sampler = wined3d_device_get_hs_sampler(device->wined3d_device, start_slot + i)))
2131 {
2132 samplers[i] = NULL;
2133 continue;
2134 }
2135
2136 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2137 ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2138 }
2139 wined3d_mutex_unlock();
2140 }
2141
2142 static void STDMETHODCALLTYPE d3d11_immediate_context_HSGetConstantBuffers(ID3D11DeviceContext *iface,
2143 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2144 {
2145 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2146 unsigned int i;
2147
2148 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2149 iface, start_slot, buffer_count, buffers);
2150
2151 wined3d_mutex_lock();
2152 for (i = 0; i < buffer_count; ++i)
2153 {
2154 struct wined3d_buffer *wined3d_buffer;
2155 struct d3d_buffer *buffer_impl;
2156
2157 if (!(wined3d_buffer = wined3d_device_get_hs_cb(device->wined3d_device, start_slot + i)))
2158 {
2159 buffers[i] = NULL;
2160 continue;
2161 }
2162
2163 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
2164 ID3D11Buffer_AddRef(buffers[i] = &buffer_impl->ID3D11Buffer_iface);
2165 }
2166 wined3d_mutex_unlock();
2167 }
2168
2169 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetShaderResources(ID3D11DeviceContext *iface,
2170 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2171 {
2172 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2173 unsigned int i;
2174
2175 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
2176 iface, start_slot, view_count, views);
2177
2178 wined3d_mutex_lock();
2179 for (i = 0; i < view_count; ++i)
2180 {
2181 struct wined3d_shader_resource_view *wined3d_view;
2182 struct d3d_shader_resource_view *view_impl;
2183
2184 if (!(wined3d_view = wined3d_device_get_ds_resource_view(device->wined3d_device, start_slot + i)))
2185 {
2186 views[i] = NULL;
2187 continue;
2188 }
2189
2190 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2191 ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2192 }
2193 wined3d_mutex_unlock();
2194 }
2195
2196 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetShader(ID3D11DeviceContext *iface,
2197 ID3D11DomainShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2198 {
2199 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2200 struct d3d11_domain_shader *shader_impl;
2201 struct wined3d_shader *wined3d_shader;
2202
2203 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2204 iface, shader, class_instances, class_instance_count);
2205
2206 if (class_instances || class_instance_count)
2207 FIXME("Dynamic linking not implemented yet.\n");
2208
2209 wined3d_mutex_lock();
2210 if (!(wined3d_shader = wined3d_device_get_domain_shader(device->wined3d_device)))
2211 {
2212 wined3d_mutex_unlock();
2213 *shader = NULL;
2214 return;
2215 }
2216
2217 shader_impl = wined3d_shader_get_parent(wined3d_shader);
2218 wined3d_mutex_unlock();
2219 ID3D11DomainShader_AddRef(*shader = &shader_impl->ID3D11DomainShader_iface);
2220 }
2221
2222 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetSamplers(ID3D11DeviceContext *iface,
2223 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2224 {
2225 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2226 unsigned int i;
2227
2228 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2229 iface, start_slot, sampler_count, samplers);
2230
2231 wined3d_mutex_lock();
2232 for (i = 0; i < sampler_count; ++i)
2233 {
2234 struct wined3d_sampler *wined3d_sampler;
2235 struct d3d_sampler_state *sampler_impl;
2236
2237 if (!(wined3d_sampler = wined3d_device_get_ds_sampler(device->wined3d_device, start_slot + i)))
2238 {
2239 samplers[i] = NULL;
2240 continue;
2241 }
2242
2243 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2244 ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2245 }
2246 wined3d_mutex_unlock();
2247 }
2248
2249 static void STDMETHODCALLTYPE d3d11_immediate_context_DSGetConstantBuffers(ID3D11DeviceContext *iface,
2250 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2251 {
2252 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2253 unsigned int i;
2254
2255 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2256 iface, start_slot, buffer_count, buffers);
2257
2258 wined3d_mutex_lock();
2259 for (i = 0; i < buffer_count; ++i)
2260 {
2261 struct wined3d_buffer *wined3d_buffer;
2262 struct d3d_buffer *buffer_impl;
2263
2264 if (!(wined3d_buffer = wined3d_device_get_ds_cb(device->wined3d_device, start_slot + i)))
2265 {
2266 buffers[i] = NULL;
2267 continue;
2268 }
2269
2270 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
2271 ID3D11Buffer_AddRef(buffers[i] = &buffer_impl->ID3D11Buffer_iface);
2272 }
2273 wined3d_mutex_unlock();
2274 }
2275
2276 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetShaderResources(ID3D11DeviceContext *iface,
2277 UINT start_slot, UINT view_count, ID3D11ShaderResourceView **views)
2278 {
2279 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2280 unsigned int i;
2281
2282 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2283
2284 wined3d_mutex_lock();
2285 for (i = 0; i < view_count; ++i)
2286 {
2287 struct wined3d_shader_resource_view *wined3d_view;
2288 struct d3d_shader_resource_view *view_impl;
2289
2290 if (!(wined3d_view = wined3d_device_get_cs_resource_view(device->wined3d_device, start_slot + i)))
2291 {
2292 views[i] = NULL;
2293 continue;
2294 }
2295
2296 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
2297 ID3D11ShaderResourceView_AddRef(views[i] = &view_impl->ID3D11ShaderResourceView_iface);
2298 }
2299 wined3d_mutex_unlock();
2300 }
2301
2302 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetUnorderedAccessViews(ID3D11DeviceContext *iface,
2303 UINT start_slot, UINT view_count, ID3D11UnorderedAccessView **views)
2304 {
2305 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2306 unsigned int i;
2307
2308 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n", iface, start_slot, view_count, views);
2309
2310 wined3d_mutex_lock();
2311 for (i = 0; i < view_count; ++i)
2312 {
2313 struct wined3d_unordered_access_view *wined3d_view;
2314 struct d3d11_unordered_access_view *view_impl;
2315
2316 if (!(wined3d_view = wined3d_device_get_cs_uav(device->wined3d_device, start_slot + i)))
2317 {
2318 views[i] = NULL;
2319 continue;
2320 }
2321
2322 view_impl = wined3d_unordered_access_view_get_parent(wined3d_view);
2323 ID3D11UnorderedAccessView_AddRef(views[i] = &view_impl->ID3D11UnorderedAccessView_iface);
2324 }
2325 wined3d_mutex_unlock();
2326 }
2327
2328 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetShader(ID3D11DeviceContext *iface,
2329 ID3D11ComputeShader **shader, ID3D11ClassInstance **class_instances, UINT *class_instance_count)
2330 {
2331 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2332 struct d3d11_compute_shader *shader_impl;
2333 struct wined3d_shader *wined3d_shader;
2334
2335 TRACE("iface %p, shader %p, class_instances %p, class_instance_count %p.\n",
2336 iface, shader, class_instances, class_instance_count);
2337
2338 if (class_instances || class_instance_count)
2339 FIXME("Dynamic linking not implemented yet.\n");
2340
2341 wined3d_mutex_lock();
2342 if (!(wined3d_shader = wined3d_device_get_compute_shader(device->wined3d_device)))
2343 {
2344 wined3d_mutex_unlock();
2345 *shader = NULL;
2346 return;
2347 }
2348
2349 shader_impl = wined3d_shader_get_parent(wined3d_shader);
2350 wined3d_mutex_unlock();
2351 ID3D11ComputeShader_AddRef(*shader = &shader_impl->ID3D11ComputeShader_iface);
2352 }
2353
2354 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetSamplers(ID3D11DeviceContext *iface,
2355 UINT start_slot, UINT sampler_count, ID3D11SamplerState **samplers)
2356 {
2357 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2358 unsigned int i;
2359
2360 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
2361 iface, start_slot, sampler_count, samplers);
2362
2363 wined3d_mutex_lock();
2364 for (i = 0; i < sampler_count; ++i)
2365 {
2366 struct wined3d_sampler *wined3d_sampler;
2367 struct d3d_sampler_state *sampler_impl;
2368
2369 if (!(wined3d_sampler = wined3d_device_get_cs_sampler(device->wined3d_device, start_slot + i)))
2370 {
2371 samplers[i] = NULL;
2372 continue;
2373 }
2374
2375 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
2376 ID3D11SamplerState_AddRef(samplers[i] = &sampler_impl->ID3D11SamplerState_iface);
2377 }
2378 wined3d_mutex_unlock();
2379 }
2380
2381 static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetConstantBuffers(ID3D11DeviceContext *iface,
2382 UINT start_slot, UINT buffer_count, ID3D11Buffer **buffers)
2383 {
2384 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2385 unsigned int i;
2386
2387 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
2388 iface, start_slot, buffer_count, buffers);
2389
2390 wined3d_mutex_lock();
2391 for (i = 0; i < buffer_count; ++i)
2392 {
2393 struct wined3d_buffer *wined3d_buffer;
2394 struct d3d_buffer *buffer_impl;
2395
2396 if (!(wined3d_buffer = wined3d_device_get_cs_cb(device->wined3d_device, start_slot + i)))
2397 {
2398 buffers[i] = NULL;
2399 continue;
2400 }
2401
2402 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
2403 ID3D11Buffer_AddRef(buffers[i] = &buffer_impl->ID3D11Buffer_iface);
2404 }
2405 wined3d_mutex_unlock();
2406 }
2407
2408 static void STDMETHODCALLTYPE d3d11_immediate_context_ClearState(ID3D11DeviceContext *iface)
2409 {
2410 struct d3d_device *device = device_from_immediate_ID3D11DeviceContext(iface);
2411 static const float blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
2412 unsigned int i;
2413
2414 TRACE("iface %p.\n", iface);
2415
2416 wined3d_mutex_lock();
2417 wined3d_device_set_vertex_shader(device->wined3d_device, NULL);
2418 wined3d_device_set_hull_shader(device->wined3d_device, NULL);
2419 wined3d_device_set_domain_shader(device->wined3d_device, NULL);
2420 wined3d_device_set_geometry_shader(device->wined3d_device, NULL);
2421 wined3d_device_set_pixel_shader(device->wined3d_device, NULL);
2422 wined3d_device_set_compute_shader(device->wined3d_device, NULL);
2423 for (i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i)
2424 {
2425 wined3d_device_set_vs_sampler(device->wined3d_device, i, NULL);
2426 wined3d_device_set_hs_sampler(device->wined3d_device, i, NULL);
2427 wined3d_device_set_ds_sampler(device->wined3d_device, i, NULL);
2428 wined3d_device_set_gs_sampler(device->wined3d_device, i, NULL);
2429 wined3d_device_set_ps_sampler(device->wined3d_device, i, NULL);
2430 wined3d_device_set_cs_sampler(device->wined3d_device, i, NULL);
2431 }
2432 for (i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i)
2433 {
2434 wined3d_device_set_vs_resource_view(device->wined3d_device, i, NULL);
2435 wined3d_device_set_hs_resource_view(device->wined3d_device, i, NULL);
2436 wined3d_device_set_ds_resource_view(device->wined3d_device, i, NULL);
2437 wined3d_device_set_gs_resource_view(device->wined3d_device, i, NULL);
2438 wined3d_device_set_ps_resource_view(device->wined3d_device, i, NULL);
2439 wined3d_device_set_cs_resource_view(device->wined3d_device, i, NULL);
2440 }
2441 for (i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; ++i)
2442 {
2443 wined3d_device_set_vs_cb(device->wined3d_device, i, NULL);
2444 wined3d_device_set_hs_cb(device->wined3d_device, i, NULL);
2445 wined3d_device_set_ds_cb(device->wined3d_device, i, NULL);
2446 wined3d_device_set_gs_cb(device->wined3d_device, i, NULL);
2447 wined3d_device_set_ps_cb(device->wined3d_device, i, NULL);
2448 wined3d_device_set_cs_cb(device->wined3d_device, i, NULL);
2449 }
2450 for (i = 0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i)
2451 {
2452 wined3d_device_set_stream_source(device->wined3d_device, i, NULL, 0, 0);
2453 }
2454 wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN, 0);
2455 wined3d_device_set_vertex_declaration(device->wined3d_device, NULL);
2456 wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_UNDEFINED);
2457 for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
2458 {
2459 wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
2460 }
2461 wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
2462 for (i = 0; i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i)
2463 {
2464 wined3d_device_set_unordered_access_view(device->wined3d_device, i, NULL);
2465 wined3d_device_set_cs_uav(device->wined3d_device, i, NULL);
2466 }
2467 ID3D11DeviceContext_OMSetDepthStencilState(iface, NULL, 0);
2468 ID3D11DeviceContext_OMSetBlendState(iface, NULL, blend_factor, D3D11_DEFAULT_SAMPLE_MASK);
2469 ID3D11DeviceContext_RSSetViewports(iface, 0, NULL);
2470 ID3D11DeviceContext_RSSetScissorRects(iface, 0, NULL);
2471 ID3D11DeviceContext_RSSetState(iface, NULL);
2472 for (i = 0; i < D3D11_SO_BUFFER_SLOT_COUNT; ++i)
2473 {
2474 wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
2475 }
2476 wined3d_device_set_predication(device->wined3d_device, NULL, FALSE);
2477 wined3d_mutex_unlock();
2478 }
2479
2480 static void STDMETHODCALLTYPE d3d11_immediate_context_Flush(ID3D11DeviceContext *iface)
2481 {
2482 FIXME("iface %p stub!\n", iface);
2483 }
2484
2485 static D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE d3d11_immediate_context_GetType(ID3D11DeviceContext *iface)
2486 {
2487 TRACE("iface %p.\n", iface);
2488
2489 return D3D11_DEVICE_CONTEXT_IMMEDIATE;
2490 }
2491
2492 static UINT STDMETHODCALLTYPE d3d11_immediate_context_GetContextFlags(ID3D11DeviceContext *iface)
2493 {
2494 FIXME("iface %p stub!\n", iface);
2495
2496 return 0;
2497 }
2498
2499 static HRESULT STDMETHODCALLTYPE d3d11_immediate_context_FinishCommandList(ID3D11DeviceContext *iface,
2500 BOOL restore, ID3D11CommandList **command_list)
2501 {
2502 FIXME("iface %p, restore %#x, command_list %p stub!\n", iface, restore, command_list);
2503
2504 return E_NOTIMPL;
2505 }
2506
2507 static const struct ID3D11DeviceContextVtbl d3d11_immediate_context_vtbl =
2508 {
2509 /* IUnknown methods */
2510 d3d11_immediate_context_QueryInterface,
2511 d3d11_immediate_context_AddRef,
2512 d3d11_immediate_context_Release,
2513 /* ID3D11DeviceChild methods */
2514 d3d11_immediate_context_GetDevice,
2515 d3d11_immediate_context_GetPrivateData,
2516 d3d11_immediate_context_SetPrivateData,
2517 d3d11_immediate_context_SetPrivateDataInterface,
2518 /* ID3D11DeviceContext methods */
2519 d3d11_immediate_context_VSSetConstantBuffers,
2520 d3d11_immediate_context_PSSetShaderResources,
2521 d3d11_immediate_context_PSSetShader,
2522 d3d11_immediate_context_PSSetSamplers,
2523 d3d11_immediate_context_VSSetShader,
2524 d3d11_immediate_context_DrawIndexed,
2525 d3d11_immediate_context_Draw,
2526 d3d11_immediate_context_Map,
2527 d3d11_immediate_context_Unmap,
2528 d3d11_immediate_context_PSSetConstantBuffers,
2529 d3d11_immediate_context_IASetInputLayout,
2530 d3d11_immediate_context_IASetVertexBuffers,
2531 d3d11_immediate_context_IASetIndexBuffer,
2532 d3d11_immediate_context_DrawIndexedInstanced,
2533 d3d11_immediate_context_DrawInstanced,
2534 d3d11_immediate_context_GSSetConstantBuffers,
2535 d3d11_immediate_context_GSSetShader,
2536 d3d11_immediate_context_IASetPrimitiveTopology,
2537 d3d11_immediate_context_VSSetShaderResources,
2538 d3d11_immediate_context_VSSetSamplers,
2539 d3d11_immediate_context_Begin,
2540 d3d11_immediate_context_End,
2541 d3d11_immediate_context_GetData,
2542 d3d11_immediate_context_SetPredication,
2543 d3d11_immediate_context_GSSetShaderResources,
2544 d3d11_immediate_context_GSSetSamplers,
2545 d3d11_immediate_context_OMSetRenderTargets,
2546 d3d11_immediate_context_OMSetRenderTargetsAndUnorderedAccessViews,
2547 d3d11_immediate_context_OMSetBlendState,
2548 d3d11_immediate_context_OMSetDepthStencilState,
2549 d3d11_immediate_context_SOSetTargets,
2550 d3d11_immediate_context_DrawAuto,
2551 d3d11_immediate_context_DrawIndexedInstancedIndirect,
2552 d3d11_immediate_context_DrawInstancedIndirect,
2553 d3d11_immediate_context_Dispatch,
2554 d3d11_immediate_context_DispatchIndirect,
2555 d3d11_immediate_context_RSSetState,
2556 d3d11_immediate_context_RSSetViewports,
2557 d3d11_immediate_context_RSSetScissorRects,
2558 d3d11_immediate_context_CopySubresourceRegion,
2559 d3d11_immediate_context_CopyResource,
2560 d3d11_immediate_context_UpdateSubresource,
2561 d3d11_immediate_context_CopyStructureCount,
2562 d3d11_immediate_context_ClearRenderTargetView,
2563 d3d11_immediate_context_ClearUnorderedAccessViewUint,
2564 d3d11_immediate_context_ClearUnorderedAccessViewFloat,
2565 d3d11_immediate_context_ClearDepthStencilView,
2566 d3d11_immediate_context_GenerateMips,
2567 d3d11_immediate_context_SetResourceMinLOD,
2568 d3d11_immediate_context_GetResourceMinLOD,
2569 d3d11_immediate_context_ResolveSubresource,
2570 d3d11_immediate_context_ExecuteCommandList,
2571 d3d11_immediate_context_HSSetShaderResources,
2572 d3d11_immediate_context_HSSetShader,
2573 d3d11_immediate_context_HSSetSamplers,
2574 d3d11_immediate_context_HSSetConstantBuffers,
2575 d3d11_immediate_context_DSSetShaderResources,
2576 d3d11_immediate_context_DSSetShader,
2577 d3d11_immediate_context_DSSetSamplers,
2578 d3d11_immediate_context_DSSetConstantBuffers,
2579 d3d11_immediate_context_CSSetShaderResources,
2580 d3d11_immediate_context_CSSetUnorderedAccessViews,
2581 d3d11_immediate_context_CSSetShader,
2582 d3d11_immediate_context_CSSetSamplers,
2583 d3d11_immediate_context_CSSetConstantBuffers,
2584 d3d11_immediate_context_VSGetConstantBuffers,
2585 d3d11_immediate_context_PSGetShaderResources,
2586 d3d11_immediate_context_PSGetShader,
2587 d3d11_immediate_context_PSGetSamplers,
2588 d3d11_immediate_context_VSGetShader,
2589 d3d11_immediate_context_PSGetConstantBuffers,
2590 d3d11_immediate_context_IAGetInputLayout,
2591 d3d11_immediate_context_IAGetVertexBuffers,
2592 d3d11_immediate_context_IAGetIndexBuffer,
2593 d3d11_immediate_context_GSGetConstantBuffers,
2594 d3d11_immediate_context_GSGetShader,
2595 d3d11_immediate_context_IAGetPrimitiveTopology,
2596 d3d11_immediate_context_VSGetShaderResources,
2597 d3d11_immediate_context_VSGetSamplers,
2598 d3d11_immediate_context_GetPredication,
2599 d3d11_immediate_context_GSGetShaderResources,
2600 d3d11_immediate_context_GSGetSamplers,
2601 d3d11_immediate_context_OMGetRenderTargets,
2602 d3d11_immediate_context_OMGetRenderTargetsAndUnorderedAccessViews,
2603 d3d11_immediate_context_OMGetBlendState,
2604 d3d11_immediate_context_OMGetDepthStencilState,
2605 d3d11_immediate_context_SOGetTargets,
2606 d3d11_immediate_context_RSGetState,
2607 d3d11_immediate_context_RSGetViewports,
2608 d3d11_immediate_context_RSGetScissorRects,
2609 d3d11_immediate_context_HSGetShaderResources,
2610 d3d11_immediate_context_HSGetShader,
2611 d3d11_immediate_context_HSGetSamplers,
2612 d3d11_immediate_context_HSGetConstantBuffers,
2613 d3d11_immediate_context_DSGetShaderResources,
2614 d3d11_immediate_context_DSGetShader,
2615 d3d11_immediate_context_DSGetSamplers,
2616 d3d11_immediate_context_DSGetConstantBuffers,
2617 d3d11_immediate_context_CSGetShaderResources,
2618 d3d11_immediate_context_CSGetUnorderedAccessViews,
2619 d3d11_immediate_context_CSGetShader,
2620 d3d11_immediate_context_CSGetSamplers,
2621 d3d11_immediate_context_CSGetConstantBuffers,
2622 d3d11_immediate_context_ClearState,
2623 d3d11_immediate_context_Flush,
2624 d3d11_immediate_context_GetType,
2625 d3d11_immediate_context_GetContextFlags,
2626 d3d11_immediate_context_FinishCommandList,
2627 };
2628
2629 static void d3d11_immediate_context_init(struct d3d11_immediate_context *context, struct d3d_device *device)
2630 {
2631 context->ID3D11DeviceContext_iface.lpVtbl = &d3d11_immediate_context_vtbl;
2632 context->refcount = 1;
2633
2634 ID3D11Device_AddRef(&device->ID3D11Device_iface);
2635
2636 wined3d_private_store_init(&context->private_store);
2637 }
2638
2639 static void d3d11_immediate_context_destroy(struct d3d11_immediate_context *context)
2640 {
2641 wined3d_private_store_cleanup(&context->private_store);
2642 }
2643
2644 /* ID3D11Device methods */
2645
2646 static HRESULT STDMETHODCALLTYPE d3d11_device_QueryInterface(ID3D11Device *iface, REFIID riid, void **out)
2647 {
2648 struct d3d_device *device = impl_from_ID3D11Device(iface);
2649 return IUnknown_QueryInterface(device->outer_unk, riid, out);
2650 }
2651
2652 static ULONG STDMETHODCALLTYPE d3d11_device_AddRef(ID3D11Device *iface)
2653 {
2654 struct d3d_device *device = impl_from_ID3D11Device(iface);
2655 return IUnknown_AddRef(device->outer_unk);
2656 }
2657
2658 static ULONG STDMETHODCALLTYPE d3d11_device_Release(ID3D11Device *iface)
2659 {
2660 struct d3d_device *device = impl_from_ID3D11Device(iface);
2661 return IUnknown_Release(device->outer_unk);
2662 }
2663
2664 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBuffer(ID3D11Device *iface, const D3D11_BUFFER_DESC *desc,
2665 const D3D11_SUBRESOURCE_DATA *data, ID3D11Buffer **buffer)
2666 {
2667 struct d3d_device *device = impl_from_ID3D11Device(iface);
2668 struct d3d_buffer *object;
2669 HRESULT hr;
2670
2671 TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
2672
2673 if (FAILED(hr = d3d_buffer_create(device, desc, data, &object)))
2674 return hr;
2675
2676 *buffer = &object->ID3D11Buffer_iface;
2677
2678 return S_OK;
2679 }
2680
2681 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture1D(ID3D11Device *iface,
2682 const D3D11_TEXTURE1D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture1D **texture)
2683 {
2684 FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
2685
2686 return E_NOTIMPL;
2687 }
2688
2689 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture2D(ID3D11Device *iface,
2690 const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture2D **texture)
2691 {
2692 struct d3d_device *device = impl_from_ID3D11Device(iface);
2693 struct d3d_texture2d *object;
2694 HRESULT hr;
2695
2696 TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
2697
2698 if (FAILED(hr = d3d_texture2d_create(device, desc, data, &object)))
2699 return hr;
2700
2701 *texture = &object->ID3D11Texture2D_iface;
2702
2703 return S_OK;
2704 }
2705
2706 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture3D(ID3D11Device *iface,
2707 const D3D11_TEXTURE3D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data, ID3D11Texture3D **texture)
2708 {
2709 struct d3d_device *device = impl_from_ID3D11Device(iface);
2710 struct d3d_texture3d *object;
2711 HRESULT hr;
2712
2713 TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
2714
2715 if (FAILED(hr = d3d_texture3d_create(device, desc, data, &object)))
2716 return hr;
2717
2718 *texture = &object->ID3D11Texture3D_iface;
2719
2720 return S_OK;
2721 }
2722
2723 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateShaderResourceView(ID3D11Device *iface,
2724 ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11ShaderResourceView **view)
2725 {
2726 struct d3d_device *device = impl_from_ID3D11Device(iface);
2727 struct d3d_shader_resource_view *object;
2728 HRESULT hr;
2729
2730 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2731
2732 if (!resource)
2733 return E_INVALIDARG;
2734
2735 if (FAILED(hr = d3d_shader_resource_view_create(device, resource, desc, &object)))
2736 return hr;
2737
2738 *view = &object->ID3D11ShaderResourceView_iface;
2739
2740 return S_OK;
2741 }
2742
2743 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateUnorderedAccessView(ID3D11Device *iface,
2744 ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11UnorderedAccessView **view)
2745 {
2746 struct d3d_device *device = impl_from_ID3D11Device(iface);
2747 struct d3d11_unordered_access_view *object;
2748 HRESULT hr;
2749
2750 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2751
2752 if (FAILED(hr = d3d11_unordered_access_view_create(device, resource, desc, &object)))
2753 return hr;
2754
2755 *view = &object->ID3D11UnorderedAccessView_iface;
2756
2757 return S_OK;
2758 }
2759
2760 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRenderTargetView(ID3D11Device *iface,
2761 ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11RenderTargetView **view)
2762 {
2763 struct d3d_device *device = impl_from_ID3D11Device(iface);
2764 struct d3d_rendertarget_view *object;
2765 HRESULT hr;
2766
2767 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2768
2769 if (!resource)
2770 return E_INVALIDARG;
2771
2772 if (FAILED(hr = d3d_rendertarget_view_create(device, resource, desc, &object)))
2773 return hr;
2774
2775 *view = &object->ID3D11RenderTargetView_iface;
2776
2777 return S_OK;
2778 }
2779
2780 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilView(ID3D11Device *iface,
2781 ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11DepthStencilView **view)
2782 {
2783 struct d3d_device *device = impl_from_ID3D11Device(iface);
2784 struct d3d_depthstencil_view *object;
2785 HRESULT hr;
2786
2787 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
2788
2789 if (FAILED(hr = d3d_depthstencil_view_create(device, resource, desc, &object)))
2790 return hr;
2791
2792 *view = &object->ID3D11DepthStencilView_iface;
2793
2794 return S_OK;
2795 }
2796
2797 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateInputLayout(ID3D11Device *iface,
2798 const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count, const void *shader_byte_code,
2799 SIZE_T shader_byte_code_length, ID3D11InputLayout **input_layout)
2800 {
2801 struct d3d_device *device = impl_from_ID3D11Device(iface);
2802 struct d3d_input_layout *object;
2803 HRESULT hr;
2804
2805 TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, shader_byte_code_length %lu, "
2806 "input_layout %p.\n", iface, element_descs, element_count, shader_byte_code,
2807 shader_byte_code_length, input_layout);
2808
2809 if (FAILED(hr = d3d_input_layout_create(device, element_descs, element_count,
2810 shader_byte_code, shader_byte_code_length, &object)))
2811 return hr;
2812
2813 *input_layout = &object->ID3D11InputLayout_iface;
2814
2815 return S_OK;
2816 }
2817
2818 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateVertexShader(ID3D11Device *iface, const void *byte_code,
2819 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11VertexShader **shader)
2820 {
2821 struct d3d_device *device = impl_from_ID3D11Device(iface);
2822 struct d3d_vertex_shader *object;
2823 HRESULT hr;
2824
2825 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2826 iface, byte_code, byte_code_length, class_linkage, shader);
2827
2828 if (class_linkage)
2829 FIXME("Class linkage is not implemented yet.\n");
2830
2831 if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
2832 return hr;
2833
2834 *shader = &object->ID3D11VertexShader_iface;
2835
2836 return S_OK;
2837 }
2838
2839 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShader(ID3D11Device *iface, const void *byte_code,
2840 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
2841 {
2842 struct d3d_device *device = impl_from_ID3D11Device(iface);
2843 struct d3d_geometry_shader *object;
2844 HRESULT hr;
2845
2846 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2847 iface, byte_code, byte_code_length, class_linkage, shader);
2848
2849 if (class_linkage)
2850 FIXME("Class linkage is not implemented yet.\n");
2851
2852 if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
2853 NULL, 0, NULL, 0, 0, &object)))
2854 return hr;
2855
2856 *shader = &object->ID3D11GeometryShader_iface;
2857
2858 return S_OK;
2859 }
2860
2861 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateGeometryShaderWithStreamOutput(ID3D11Device *iface,
2862 const void *byte_code, SIZE_T byte_code_length, const D3D11_SO_DECLARATION_ENTRY *so_entries,
2863 UINT entry_count, const UINT *buffer_strides, UINT strides_count, UINT rasterizer_stream,
2864 ID3D11ClassLinkage *class_linkage, ID3D11GeometryShader **shader)
2865 {
2866 struct d3d_device *device = impl_from_ID3D11Device(iface);
2867 struct d3d_geometry_shader *object;
2868 HRESULT hr;
2869
2870 TRACE("iface %p, byte_code %p, byte_code_length %lu, so_entries %p, entry_count %u, "
2871 "buffer_strides %p, strides_count %u, rasterizer_stream %u, class_linkage %p, shader %p.\n",
2872 iface, byte_code, byte_code_length, so_entries, entry_count, buffer_strides, strides_count,
2873 rasterizer_stream, class_linkage, shader);
2874
2875 if (class_linkage)
2876 FIXME("Class linkage is not implemented yet.\n");
2877
2878 if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
2879 so_entries, entry_count, buffer_strides, strides_count, rasterizer_stream, &object)))
2880 {
2881 *shader = NULL;
2882 return hr;
2883 }
2884
2885 *shader = &object->ID3D11GeometryShader_iface;
2886
2887 return hr;
2888 }
2889
2890 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePixelShader(ID3D11Device *iface, const void *byte_code,
2891 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11PixelShader **shader)
2892 {
2893 struct d3d_device *device = impl_from_ID3D11Device(iface);
2894 struct d3d_pixel_shader *object;
2895 HRESULT hr;
2896
2897 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2898 iface, byte_code, byte_code_length, class_linkage, shader);
2899
2900 if (class_linkage)
2901 FIXME("Class linkage is not implemented yet.\n");
2902
2903 if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
2904 return hr;
2905
2906 *shader = &object->ID3D11PixelShader_iface;
2907
2908 return S_OK;
2909 }
2910
2911 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateHullShader(ID3D11Device *iface, const void *byte_code,
2912 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11HullShader **shader)
2913 {
2914 struct d3d_device *device = impl_from_ID3D11Device(iface);
2915 struct d3d11_hull_shader *object;
2916 HRESULT hr;
2917
2918 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2919 iface, byte_code, byte_code_length, class_linkage, shader);
2920
2921 if (class_linkage)
2922 FIXME("Class linkage is not implemented yet.\n");
2923
2924 if (FAILED(hr = d3d11_hull_shader_create(device, byte_code, byte_code_length, &object)))
2925 return hr;
2926
2927 *shader = &object->ID3D11HullShader_iface;
2928
2929 return S_OK;
2930 }
2931
2932 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDomainShader(ID3D11Device *iface, const void *byte_code,
2933 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11DomainShader **shader)
2934 {
2935 struct d3d_device *device = impl_from_ID3D11Device(iface);
2936 struct d3d11_domain_shader *object;
2937 HRESULT hr;
2938
2939 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2940 iface, byte_code, byte_code_length, class_linkage, shader);
2941
2942 if (class_linkage)
2943 FIXME("Class linkage is not implemented yet.\n");
2944
2945 if (FAILED(hr = d3d11_domain_shader_create(device, byte_code, byte_code_length, &object)))
2946 return hr;
2947
2948 *shader = &object->ID3D11DomainShader_iface;
2949
2950 return S_OK;
2951 }
2952
2953 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateComputeShader(ID3D11Device *iface, const void *byte_code,
2954 SIZE_T byte_code_length, ID3D11ClassLinkage *class_linkage, ID3D11ComputeShader **shader)
2955 {
2956 struct d3d_device *device = impl_from_ID3D11Device(iface);
2957 struct d3d11_compute_shader *object;
2958 HRESULT hr;
2959
2960 TRACE("iface %p, byte_code %p, byte_code_length %lu, class_linkage %p, shader %p.\n",
2961 iface, byte_code, byte_code_length, class_linkage, shader);
2962
2963 if (class_linkage)
2964 FIXME("Class linkage is not implemented yet.\n");
2965
2966 if (FAILED(hr = d3d11_compute_shader_create(device, byte_code, byte_code_length, &object)))
2967 return hr;
2968
2969 *shader = &object->ID3D11ComputeShader_iface;
2970
2971 return S_OK;
2972 }
2973
2974 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateClassLinkage(ID3D11Device *iface,
2975 ID3D11ClassLinkage **class_linkage)
2976 {
2977 struct d3d_device *device = impl_from_ID3D11Device(iface);
2978 struct d3d11_class_linkage *object;
2979 HRESULT hr;
2980
2981 TRACE("iface %p, class_linkage %p.\n", iface, class_linkage);
2982
2983 if (FAILED(hr = d3d11_class_linkage_create(device, &object)))
2984 return hr;
2985
2986 *class_linkage = &object->ID3D11ClassLinkage_iface;
2987
2988 return S_OK;
2989 }
2990
2991 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateBlendState(ID3D11Device *iface,
2992 const D3D11_BLEND_DESC *desc, ID3D11BlendState **blend_state)
2993 {
2994 struct d3d_device *device = impl_from_ID3D11Device(iface);
2995 struct d3d_blend_state *object;
2996 struct wine_rb_entry *entry;
2997 D3D11_BLEND_DESC tmp_desc;
2998 unsigned int i, j;
2999 HRESULT hr;
3000
3001 TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
3002
3003 if (!desc)
3004 return E_INVALIDARG;
3005
3006 /* D3D11_RENDER_TARGET_BLEND_DESC has a hole, which is a problem because we use
3007 * D3D11_BLEND_DESC as a key in the rbtree. */
3008 memset(&tmp_desc, 0, sizeof(tmp_desc));
3009 tmp_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
3010 tmp_desc.IndependentBlendEnable = desc->IndependentBlendEnable;
3011 for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
3012 {
3013 j = desc->IndependentBlendEnable ? i : 0;
3014 tmp_desc.RenderTarget[i].BlendEnable = desc->RenderTarget[j].BlendEnable;
3015 tmp_desc.RenderTarget[i].SrcBlend = desc->RenderTarget[j].SrcBlend;
3016 tmp_desc.RenderTarget[i].DestBlend = desc->RenderTarget[j].DestBlend;
3017 tmp_desc.RenderTarget[i].BlendOp = desc->RenderTarget[j].BlendOp;
3018 tmp_desc.RenderTarget[i].SrcBlendAlpha = desc->RenderTarget[j].SrcBlendAlpha;
3019 tmp_desc.RenderTarget[i].DestBlendAlpha = desc->RenderTarget[j].DestBlendAlpha;
3020 tmp_desc.RenderTarget[i].BlendOpAlpha = desc->RenderTarget[j].BlendOpAlpha;
3021 tmp_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTarget[j].RenderTargetWriteMask;
3022
3023 if (i > 3 && tmp_desc.RenderTarget[i].RenderTargetWriteMask != D3D11_COLOR_WRITE_ENABLE_ALL)
3024 FIXME("Color mask %#x not supported for render target %u.\n",
3025 tmp_desc.RenderTarget[i].RenderTargetWriteMask, i);
3026 }
3027
3028 /* glSampleCoverage() */
3029 if (tmp_desc.AlphaToCoverageEnable)
3030 FIXME("Ignoring AlphaToCoverageEnable %#x.\n", tmp_desc.AlphaToCoverageEnable);
3031 /* glEnableIndexedEXT(GL_BLEND, ...) */
3032 if (tmp_desc.IndependentBlendEnable)
3033 FIXME("Per-rendertarget blend not implemented.\n");
3034
3035 wined3d_mutex_lock();
3036 if ((entry = wine_rb_get(&device->blend_states, &tmp_desc)))
3037 {
3038 object = WINE_RB_ENTRY_VALUE(entry, struct d3d_blend_state, entry);
3039
3040 TRACE("Returning existing blend state %p.\n", object);
3041 *blend_state = &object->ID3D11BlendState_iface;
3042 ID3D11BlendState_AddRef(*blend_state);
3043 wined3d_mutex_unlock();
3044
3045 return S_OK;
3046 }
3047 wined3d_mutex_unlock();
3048
3049 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3050 return E_OUTOFMEMORY;
3051
3052 if (FAILED(hr = d3d_blend_state_init(object, device, &tmp_desc)))
3053 {
3054 WARN("Failed to initialize blend state, hr %#x.\n", hr);
3055 HeapFree(GetProcessHeap(), 0, object);
3056 return hr;
3057 }
3058
3059 TRACE("Created blend state %p.\n", object);
3060 *blend_state = &object->ID3D11BlendState_iface;
3061
3062 return S_OK;
3063 }
3064
3065 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDepthStencilState(ID3D11Device *iface,
3066 const D3D11_DEPTH_STENCIL_DESC *desc, ID3D11DepthStencilState **depth_stencil_state)
3067 {
3068 struct d3d_device *device = impl_from_ID3D11Device(iface);
3069 struct d3d_depthstencil_state *object;
3070 D3D11_DEPTH_STENCIL_DESC tmp_desc;
3071 struct wine_rb_entry *entry;
3072 HRESULT hr;
3073
3074 TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
3075
3076 if (!desc)
3077 return E_INVALIDARG;
3078
3079 /* D3D11_DEPTH_STENCIL_DESC has a hole, which is a problem because we use
3080 * it as a key in the rbtree. */
3081 memset(&tmp_desc, 0, sizeof(tmp_desc));
3082 tmp_desc.DepthEnable = desc->DepthEnable;
3083 if (desc->DepthEnable)
3084 {
3085 tmp_desc.DepthWriteMask = desc->DepthWriteMask;
3086 tmp_desc.DepthFunc = desc->DepthFunc;
3087 }
3088 else
3089 {
3090 tmp_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
3091 tmp_desc.DepthFunc = D3D11_COMPARISON_LESS;
3092 }
3093 tmp_desc.StencilEnable = desc->StencilEnable;
3094 if (desc->StencilEnable)
3095 {
3096 tmp_desc.StencilReadMask = desc->StencilReadMask;
3097 tmp_desc.StencilWriteMask = desc->StencilWriteMask;
3098 tmp_desc.FrontFace = desc->FrontFace;
3099 tmp_desc.BackFace = desc->BackFace;
3100 }
3101 else
3102 {
3103 tmp_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
3104 tmp_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
3105 tmp_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
3106 tmp_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
3107 tmp_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
3108 tmp_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
3109 tmp_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
3110 tmp_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
3111 tmp_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
3112 tmp_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
3113 }
3114
3115 wined3d_mutex_lock();
3116 if ((entry = wine_rb_get(&device->depthstencil_states, &tmp_desc)))
3117 {
3118 object = WINE_RB_ENTRY_VALUE(entry, struct d3d_depthstencil_state, entry);
3119
3120 TRACE("Returning existing depthstencil state %p.\n", object);
3121 *depth_stencil_state = &object->ID3D11DepthStencilState_iface;
3122 ID3D11DepthStencilState_AddRef(*depth_stencil_state);
3123 wined3d_mutex_unlock();
3124
3125 return S_OK;
3126 }
3127 wined3d_mutex_unlock();
3128
3129 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3130 return E_OUTOFMEMORY;
3131
3132 if (FAILED(hr = d3d_depthstencil_state_init(object, device, &tmp_desc)))
3133 {
3134 WARN("Failed to initialize depthstencil state, hr %#x.\n", hr);
3135 HeapFree(GetProcessHeap(), 0, object);
3136 return hr;
3137 }
3138
3139 TRACE("Created depthstencil state %p.\n", object);
3140 *depth_stencil_state = &object->ID3D11DepthStencilState_iface;
3141
3142 return S_OK;
3143 }
3144
3145 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device *iface,
3146 const D3D11_RASTERIZER_DESC *desc, ID3D11RasterizerState **rasterizer_state)
3147 {
3148 struct d3d_device *device = impl_from_ID3D11Device(iface);
3149 struct d3d_rasterizer_state *object;
3150 struct wine_rb_entry *entry;
3151 HRESULT hr;
3152
3153 TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
3154
3155 if (!desc)
3156 return E_INVALIDARG;
3157
3158 wined3d_mutex_lock();
3159 if ((entry = wine_rb_get(&device->rasterizer_states, desc)))
3160 {
3161 object = WINE_RB_ENTRY_VALUE(entry, struct d3d_rasterizer_state, entry);
3162
3163 TRACE("Returning existing rasterizer state %p.\n", object);
3164 *rasterizer_state = &object->ID3D11RasterizerState_iface;
3165 ID3D11RasterizerState_AddRef(*rasterizer_state);
3166 wined3d_mutex_unlock();
3167
3168 return S_OK;
3169 }
3170 wined3d_mutex_unlock();
3171
3172 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3173 return E_OUTOFMEMORY;
3174
3175 if (FAILED(hr = d3d_rasterizer_state_init(object, device, desc)))
3176 {
3177 WARN("Failed to initialize rasterizer state, hr %#x.\n", hr);
3178 HeapFree(GetProcessHeap(), 0, object);
3179 return hr;
3180 }
3181
3182 TRACE("Created rasterizer state %p.\n", object);
3183 *rasterizer_state = &object->ID3D11RasterizerState_iface;
3184
3185 return S_OK;
3186 }
3187
3188 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateSamplerState(ID3D11Device *iface,
3189 const D3D11_SAMPLER_DESC *desc, ID3D11SamplerState **sampler_state)
3190 {
3191 struct d3d_device *device = impl_from_ID3D11Device(iface);
3192 D3D11_SAMPLER_DESC normalized_desc;
3193 struct d3d_sampler_state *object;
3194 struct wine_rb_entry *entry;
3195 HRESULT hr;
3196
3197 TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
3198
3199 if (!desc)
3200 return E_INVALIDARG;
3201
3202 normalized_desc = *desc;
3203 if (!D3D11_DECODE_IS_ANISOTROPIC_FILTER(normalized_desc.Filter))
3204 normalized_desc.MaxAnisotropy = 0;
3205 if (!D3D11_DECODE_IS_COMPARISON_FILTER(normalized_desc.Filter))
3206 normalized_desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
3207 if (normalized_desc.AddressU != D3D11_TEXTURE_ADDRESS_BORDER
3208 && normalized_desc.AddressV != D3D11_TEXTURE_ADDRESS_BORDER
3209 && normalized_desc.AddressW != D3D11_TEXTURE_ADDRESS_BORDER)
3210 memset(&normalized_desc.BorderColor, 0, sizeof(normalized_desc.BorderColor));
3211
3212 wined3d_mutex_lock();
3213 if ((entry = wine_rb_get(&device->sampler_states, &normalized_desc)))
3214 {
3215 object = WINE_RB_ENTRY_VALUE(entry, struct d3d_sampler_state, entry);
3216
3217 TRACE("Returning existing sampler state %p.\n", object);
3218 *sampler_state = &object->ID3D11SamplerState_iface;
3219 ID3D11SamplerState_AddRef(*sampler_state);
3220 wined3d_mutex_unlock();
3221
3222 return S_OK;
3223 }
3224 wined3d_mutex_unlock();
3225
3226 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3227 return E_OUTOFMEMORY;
3228
3229 if (FAILED(hr = d3d_sampler_state_init(object, device, &normalized_desc)))
3230 {
3231 WARN("Failed to initialize sampler state, hr %#x.\n", hr);
3232 HeapFree(GetProcessHeap(), 0, object);
3233 return hr;
3234 }
3235
3236 TRACE("Created sampler state %p.\n", object);
3237 *sampler_state = &object->ID3D11SamplerState_iface;
3238
3239 return S_OK;
3240 }
3241
3242 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateQuery(ID3D11Device *iface,
3243 const D3D11_QUERY_DESC *desc, ID3D11Query **query)
3244 {
3245 struct d3d_device *device = impl_from_ID3D11Device(iface);
3246 struct d3d_query *object;
3247 HRESULT hr;
3248
3249 TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
3250
3251 if (FAILED(hr = d3d_query_create(device, desc, FALSE, &object)))
3252 return hr;
3253
3254 if (query)
3255 {
3256 *query = &object->ID3D11Query_iface;
3257 return S_OK;
3258 }
3259
3260 ID3D11Query_Release(&object->ID3D11Query_iface);
3261 return S_FALSE;
3262 }
3263
3264 static HRESULT STDMETHODCALLTYPE d3d11_device_CreatePredicate(ID3D11Device *iface, const D3D11_QUERY_DESC *desc,
3265 ID3D11Predicate **predicate)
3266 {
3267 struct d3d_device *device = impl_from_ID3D11Device(iface);
3268 struct d3d_query *object;
3269 HRESULT hr;
3270
3271 TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
3272
3273 if (FAILED(hr = d3d_query_create(device, desc, TRUE, &object)))
3274 return hr;
3275
3276 if (predicate)
3277 {
3278 *predicate = (ID3D11Predicate *)&object->ID3D11Query_iface;
3279 return S_OK;
3280 }
3281
3282 ID3D11Query_Release(&object->ID3D11Query_iface);
3283 return S_FALSE;
3284 }
3285
3286 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
3287 ID3D11Counter **counter)
3288 {
3289 FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
3290
3291 return E_NOTIMPL;
3292 }
3293
3294 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeferredContext(ID3D11Device *iface, UINT flags,
3295 ID3D11DeviceContext **context)
3296 {
3297 FIXME("iface %p, flags %#x, context %p stub!\n", iface, flags, context);
3298
3299 return E_NOTIMPL;
3300 }
3301
3302 static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource(ID3D11Device *iface, HANDLE resource, REFIID riid,
3303 void **out)
3304 {
3305 FIXME("iface %p, resource %p, riid %s, out %p stub!\n", iface, resource, debugstr_guid(riid), out);
3306
3307 return E_NOTIMPL;
3308 }
3309
3310 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device *iface, DXGI_FORMAT format,
3311 UINT *format_support)
3312 {
3313 FIXME("iface %p, format %u, format_support %p stub!\n", iface, format, format_support);
3314
3315 return E_NOTIMPL;
3316 }
3317
3318 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckMultisampleQualityLevels(ID3D11Device *iface,
3319 DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
3320 {
3321 struct d3d_device *device = impl_from_ID3D11Device(iface);
3322 struct wined3d_device_creation_parameters params;
3323 struct wined3d *wined3d;
3324 HRESULT hr;
3325
3326 TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
3327 iface, debug_dxgi_format(format), sample_count, quality_level_count);
3328
3329 if (!quality_level_count)
3330 return E_INVALIDARG;
3331
3332 *quality_level_count = 0;
3333
3334 if (!sample_count)
3335 return E_FAIL;
3336 if (sample_count == 1)
3337 {
3338 *quality_level_count = 1;
3339 return S_OK;
3340 }
3341 if (sample_count > D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT)
3342 return E_FAIL;
3343
3344 wined3d_mutex_lock();
3345 wined3d = wined3d_device_get_wined3d(device->wined3d_device);
3346 wined3d_device_get_creation_parameters(device->wined3d_device, &params);
3347 hr = wined3d_check_device_multisample_type(wined3d, params.adapter_idx, params.device_type,
3348 wined3dformat_from_dxgi_format(format), TRUE, sample_count, quality_level_count);
3349 wined3d_mutex_unlock();
3350
3351 if (hr == WINED3DERR_INVALIDCALL)
3352 return E_INVALIDARG;
3353 if (hr == WINED3DERR_NOTAVAILABLE)
3354 return S_OK;
3355 return hr;
3356 }
3357
3358 static void STDMETHODCALLTYPE d3d11_device_CheckCounterInfo(ID3D11Device *iface, D3D11_COUNTER_INFO *info)
3359 {
3360 FIXME("iface %p, info %p stub!\n", iface, info);
3361 }
3362
3363 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckCounter(ID3D11Device *iface, const D3D11_COUNTER_DESC *desc,
3364 D3D11_COUNTER_TYPE *type, UINT *active_counter_count, char *name, UINT *name_length,
3365 char *units, UINT *units_length, char *description, UINT *description_length)
3366 {
3367 FIXME("iface %p, desc %p, type %p, active_counter_count %p, name %p, name_length %p, "
3368 "units %p, units_length %p, description %p, description_length %p stub!\n",
3369 iface, desc, type, active_counter_count, name, name_length,
3370 units, units_length, description, description_length);
3371
3372 return E_NOTIMPL;
3373 }
3374
3375 static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFeatureSupport(ID3D11Device *iface, D3D11_FEATURE feature,
3376 void *feature_support_data, UINT feature_support_data_size)
3377 {
3378 struct d3d_device *device = impl_from_ID3D11Device(iface);
3379 WINED3DCAPS wined3d_caps;
3380 HRESULT hr;
3381
3382 TRACE("iface %p, feature %u, feature_support_data %p, feature_support_data_size %u.\n",
3383 iface, feature, feature_support_data, feature_support_data_size);
3384
3385 switch (feature)
3386 {
3387 case D3D11_FEATURE_THREADING:
3388 {
3389 D3D11_FEATURE_DATA_THREADING *threading_data = feature_support_data;
3390 if (feature_support_data_size != sizeof(*threading_data))
3391 {
3392 WARN("Invalid data size.\n");
3393 return E_INVALIDARG;
3394 }
3395
3396 /* We lie about the threading support to make Tomb Raider 2013 and
3397 * Deus Ex: Human Revolution happy. */
3398 FIXME("Returning fake threading support data.\n");
3399 threading_data->DriverConcurrentCreates = TRUE;
3400 threading_data->DriverCommandLists = TRUE;
3401 return S_OK;
3402 }
3403
3404 case D3D11_FEATURE_DOUBLES:
3405 {
3406 D3D11_FEATURE_DATA_DOUBLES *doubles_data = feature_support_data;
3407 if (feature_support_data_size != sizeof(*doubles_data))
3408 {
3409 WARN("Invalid data size.\n");
3410 return E_INVALIDARG;
3411 }
3412
3413 wined3d_mutex_lock();
3414 hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
3415 wined3d_mutex_unlock();
3416 if (FAILED(hr))
3417 {
3418 WARN("Failed to get device caps, hr %#x.\n", hr);
3419 return hr;
3420 }
3421
3422 doubles_data->DoublePrecisionFloatShaderOps = wined3d_caps.shader_double_precision;
3423 return S_OK;
3424 }
3425
3426 case D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS:
3427 {
3428 D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS *options = feature_support_data;
3429 if (feature_support_data_size != sizeof(*options))
3430 {
3431 WARN("Invalid data size.\n");
3432 return E_INVALIDARG;
3433 }
3434
3435 options->ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x = FALSE;
3436 return S_OK;
3437 }
3438
3439 default:
3440 FIXME("Unhandled feature %#x.\n", feature);
3441 return E_NOTIMPL;
3442 }
3443 }
3444
3445 static HRESULT STDMETHODCALLTYPE d3d11_device_GetPrivateData(ID3D11Device *iface, REFGUID guid,
3446 UINT *data_size, void *data)
3447 {
3448 IDXGIDevice *dxgi_device;
3449 HRESULT hr;
3450
3451 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
3452
3453 if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
3454 return hr;
3455 hr = IDXGIDevice_GetPrivateData(dxgi_device, guid, data_size, data);
3456 IDXGIDevice_Release(dxgi_device);
3457
3458 return hr;
3459 }
3460
3461 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateData(ID3D11Device *iface, REFGUID guid,
3462 UINT data_size, const void *data)
3463 {
3464 IDXGIDevice *dxgi_device;
3465 HRESULT hr;
3466
3467 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
3468
3469 if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
3470 return hr;
3471 hr = IDXGIDevice_SetPrivateData(dxgi_device, guid, data_size, data);
3472 IDXGIDevice_Release(dxgi_device);
3473
3474 return hr;
3475 }
3476
3477 static HRESULT STDMETHODCALLTYPE d3d11_device_SetPrivateDataInterface(ID3D11Device *iface, REFGUID guid,
3478 const IUnknown *data)
3479 {
3480 IDXGIDevice *dxgi_device;
3481 HRESULT hr;
3482
3483 TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
3484
3485 if (FAILED(hr = ID3D11Device_QueryInterface(iface, &IID_IDXGIDevice, (void **)&dxgi_device)))
3486 return hr;
3487 hr = IDXGIDevice_SetPrivateDataInterface(dxgi_device, guid, data);
3488 IDXGIDevice_Release(dxgi_device);
3489
3490 return hr;
3491 }
3492
3493 static D3D_FEATURE_LEVEL STDMETHODCALLTYPE d3d11_device_GetFeatureLevel(ID3D11Device *iface)
3494 {
3495 struct d3d_device *device = impl_from_ID3D11Device(iface);
3496
3497 TRACE("iface %p.\n", iface);
3498
3499 return device->feature_level;
3500 }
3501
3502 static UINT STDMETHODCALLTYPE d3d11_device_GetCreationFlags(ID3D11Device *iface)
3503 {
3504 FIXME("iface %p stub!\n", iface);
3505
3506 return 0;
3507 }
3508
3509 static HRESULT STDMETHODCALLTYPE d3d11_device_GetDeviceRemovedReason(ID3D11Device *iface)
3510 {
3511 FIXME("iface %p stub!\n", iface);
3512
3513 return S_OK;
3514 }
3515
3516 static void STDMETHODCALLTYPE d3d11_device_GetImmediateContext(ID3D11Device *iface,
3517 ID3D11DeviceContext **immediate_context)
3518 {
3519 struct d3d_device *device = impl_from_ID3D11Device(iface);
3520
3521 TRACE("iface %p, immediate_context %p.\n", iface, immediate_context);
3522
3523 *immediate_context = &device->immediate_context.ID3D11DeviceContext_iface;
3524 ID3D11DeviceContext_AddRef(*immediate_context);
3525 }
3526
3527 static HRESULT STDMETHODCALLTYPE d3d11_device_SetExceptionMode(ID3D11Device *iface, UINT flags)
3528 {
3529 FIXME("iface %p, flags %#x stub!\n", iface, flags);
3530
3531 return E_NOTIMPL;
3532 }
3533
3534 static UINT STDMETHODCALLTYPE d3d11_device_GetExceptionMode(ID3D11Device *iface)
3535 {
3536 FIXME("iface %p stub!\n", iface);
3537
3538 return 0;
3539 }
3540
3541 static const struct ID3D11DeviceVtbl d3d11_device_vtbl =
3542 {
3543 /* IUnknown methods */
3544 d3d11_device_QueryInterface,
3545 d3d11_device_AddRef,
3546 d3d11_device_Release,
3547 /* ID3D11Device methods */
3548 d3d11_device_CreateBuffer,
3549 d3d11_device_CreateTexture1D,
3550 d3d11_device_CreateTexture2D,
3551 d3d11_device_CreateTexture3D,
3552 d3d11_device_CreateShaderResourceView,
3553 d3d11_device_CreateUnorderedAccessView,
3554 d3d11_device_CreateRenderTargetView,
3555 d3d11_device_CreateDepthStencilView,
3556 d3d11_device_CreateInputLayout,
3557 d3d11_device_CreateVertexShader,
3558 d3d11_device_CreateGeometryShader,
3559 d3d11_device_CreateGeometryShaderWithStreamOutput,
3560 d3d11_device_CreatePixelShader,
3561 d3d11_device_CreateHullShader,
3562 d3d11_device_CreateDomainShader,
3563 d3d11_device_CreateComputeShader,
3564 d3d11_device_CreateClassLinkage,
3565 d3d11_device_CreateBlendState,
3566 d3d11_device_CreateDepthStencilState,
3567 d3d11_device_CreateRasterizerState,
3568 d3d11_device_CreateSamplerState,
3569 d3d11_device_CreateQuery,
3570 d3d11_device_CreatePredicate,
3571 d3d11_device_CreateCounter,
3572 d3d11_device_CreateDeferredContext,
3573 d3d11_device_OpenSharedResource,
3574 d3d11_device_CheckFormatSupport,
3575 d3d11_device_CheckMultisampleQualityLevels,
3576 d3d11_device_CheckCounterInfo,
3577 d3d11_device_CheckCounter,
3578 d3d11_device_CheckFeatureSupport,
3579 d3d11_device_GetPrivateData,
3580 d3d11_device_SetPrivateData,
3581 d3d11_device_SetPrivateDataInterface,
3582 d3d11_device_GetFeatureLevel,
3583 d3d11_device_GetCreationFlags,
3584 d3d11_device_GetDeviceRemovedReason,
3585 d3d11_device_GetImmediateContext,
3586 d3d11_device_SetExceptionMode,
3587 d3d11_device_GetExceptionMode,
3588 };
3589
3590 /* Inner IUnknown methods */
3591
3592 static inline struct d3d_device *impl_from_IUnknown(IUnknown *iface)
3593 {
3594 return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
3595 }
3596
3597 static HRESULT STDMETHODCALLTYPE d3d_device_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out)
3598 {
3599 struct d3d_device *device = impl_from_IUnknown(iface);
3600
3601 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3602
3603 if (IsEqualGUID(riid, &IID_ID3D11Device)
3604 || IsEqualGUID(riid, &IID_IUnknown))
3605 {
3606 *out = &device->ID3D11Device_iface;
3607 }
3608 else if (IsEqualGUID(riid, &IID_ID3D10Device1)
3609 || IsEqualGUID(riid, &IID_ID3D10Device))
3610 {
3611 *out = &device->ID3D10Device1_iface;
3612 }
3613 else if (IsEqualGUID(riid, &IID_ID3D10Multithread))
3614 {
3615 *out = &device->ID3D10Multithread_iface;
3616 }
3617 else if (IsEqualGUID(riid, &IID_IWineDXGIDeviceParent))
3618 {
3619 *out = &device->IWineDXGIDeviceParent_iface;
3620 }
3621 else
3622 {
3623 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
3624 *out = NULL;
3625 return E_NOINTERFACE;
3626 }
3627
3628 IUnknown_AddRef((IUnknown *)*out);
3629 return S_OK;
3630 }
3631
3632 static ULONG STDMETHODCALLTYPE d3d_device_inner_AddRef(IUnknown *iface)
3633 {
3634 struct d3d_device *device = impl_from_IUnknown(iface);
3635 ULONG refcount = InterlockedIncrement(&device->refcount);
3636
3637 TRACE("%p increasing refcount to %u.\n", device, refcount);
3638
3639 return refcount;
3640 }
3641
3642 static ULONG STDMETHODCALLTYPE d3d_device_inner_Release(IUnknown *iface)
3643 {
3644 struct d3d_device *device = impl_from_IUnknown(iface);
3645 ULONG refcount = InterlockedDecrement(&device->refcount);
3646
3647 TRACE("%p decreasing refcount to %u.\n", device, refcount);
3648
3649 if (!refcount)
3650 {
3651 d3d11_immediate_context_destroy(&device->immediate_context);
3652 if (device->wined3d_device)
3653 {
3654 wined3d_mutex_lock();
3655 wined3d_device_decref(device->wined3d_device);
3656 wined3d_mutex_unlock();
3657 }
3658 wine_rb_destroy(&device->sampler_states, NULL, NULL);
3659 wine_rb_destroy(&device->rasterizer_states, NULL, NULL);
3660 wine_rb_destroy(&device->depthstencil_states, NULL, NULL);
3661 wine_rb_destroy(&device->blend_states, NULL, NULL);
3662 }
3663
3664 return refcount;
3665 }
3666
3667 /* IUnknown methods */
3668
3669 static HRESULT STDMETHODCALLTYPE d3d10_device_QueryInterface(ID3D10Device1 *iface, REFIID riid,
3670 void **ppv)
3671 {
3672 struct d3d_device *device = impl_from_ID3D10Device(iface);
3673 return IUnknown_QueryInterface(device->outer_unk, riid, ppv);
3674 }
3675
3676 static ULONG STDMETHODCALLTYPE d3d10_device_AddRef(ID3D10Device1 *iface)
3677 {
3678 struct d3d_device *device = impl_from_ID3D10Device(iface);
3679 return IUnknown_AddRef(device->outer_unk);
3680 }
3681
3682 static ULONG STDMETHODCALLTYPE d3d10_device_Release(ID3D10Device1 *iface)
3683 {
3684 struct d3d_device *device = impl_from_ID3D10Device(iface);
3685 return IUnknown_Release(device->outer_unk);
3686 }
3687
3688 /* ID3D10Device methods */
3689
3690 static void STDMETHODCALLTYPE d3d10_device_VSSetConstantBuffers(ID3D10Device1 *iface,
3691 UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
3692 {
3693 struct d3d_device *device = impl_from_ID3D10Device(iface);
3694 unsigned int i;
3695
3696 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3697 iface, start_slot, buffer_count, buffers);
3698
3699 wined3d_mutex_lock();
3700 for (i = 0; i < buffer_count; ++i)
3701 {
3702 struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3703
3704 wined3d_device_set_vs_cb(device->wined3d_device, start_slot + i,
3705 buffer ? buffer->wined3d_buffer : NULL);
3706 }
3707 wined3d_mutex_unlock();
3708 }
3709
3710 static void STDMETHODCALLTYPE d3d10_device_PSSetShaderResources(ID3D10Device1 *iface,
3711 UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
3712 {
3713 struct d3d_device *device = impl_from_ID3D10Device(iface);
3714 unsigned int i;
3715
3716 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3717 iface, start_slot, view_count, views);
3718
3719 wined3d_mutex_lock();
3720 for (i = 0; i < view_count; ++i)
3721 {
3722 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
3723
3724 wined3d_device_set_ps_resource_view(device->wined3d_device, start_slot + i,
3725 view ? view->wined3d_view : NULL);
3726 }
3727 wined3d_mutex_unlock();
3728 }
3729
3730 static void STDMETHODCALLTYPE d3d10_device_PSSetShader(ID3D10Device1 *iface,
3731 ID3D10PixelShader *shader)
3732 {
3733 struct d3d_device *device = impl_from_ID3D10Device(iface);
3734 struct d3d_pixel_shader *ps = unsafe_impl_from_ID3D10PixelShader(shader);
3735
3736 TRACE("iface %p, shader %p\n", iface, shader);
3737
3738 wined3d_mutex_lock();
3739 wined3d_device_set_pixel_shader(device->wined3d_device, ps ? ps->wined3d_shader : NULL);
3740 wined3d_mutex_unlock();
3741 }
3742
3743 static void STDMETHODCALLTYPE d3d10_device_PSSetSamplers(ID3D10Device1 *iface,
3744 UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
3745 {
3746 struct d3d_device *device = impl_from_ID3D10Device(iface);
3747 unsigned int i;
3748
3749 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3750 iface, start_slot, sampler_count, samplers);
3751
3752 wined3d_mutex_lock();
3753 for (i = 0; i < sampler_count; ++i)
3754 {
3755 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
3756
3757 wined3d_device_set_ps_sampler(device->wined3d_device, start_slot + i,
3758 sampler ? sampler->wined3d_sampler : NULL);
3759 }
3760 wined3d_mutex_unlock();
3761 }
3762
3763 static void STDMETHODCALLTYPE d3d10_device_VSSetShader(ID3D10Device1 *iface,
3764 ID3D10VertexShader *shader)
3765 {
3766 struct d3d_device *device = impl_from_ID3D10Device(iface);
3767 struct d3d_vertex_shader *vs = unsafe_impl_from_ID3D10VertexShader(shader);
3768
3769 TRACE("iface %p, shader %p\n", iface, shader);
3770
3771 wined3d_mutex_lock();
3772 wined3d_device_set_vertex_shader(device->wined3d_device, vs ? vs->wined3d_shader : NULL);
3773 wined3d_mutex_unlock();
3774 }
3775
3776 static void STDMETHODCALLTYPE d3d10_device_DrawIndexed(ID3D10Device1 *iface, UINT index_count,
3777 UINT start_index_location, INT base_vertex_location)
3778 {
3779 struct d3d_device *device = impl_from_ID3D10Device(iface);
3780
3781 TRACE("iface %p, index_count %u, start_index_location %u, base_vertex_location %d.\n",
3782 iface, index_count, start_index_location, base_vertex_location);
3783
3784 wined3d_mutex_lock();
3785 wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
3786 wined3d_device_draw_indexed_primitive(device->wined3d_device, start_index_location, index_count);
3787 wined3d_mutex_unlock();
3788 }
3789
3790 static void STDMETHODCALLTYPE d3d10_device_Draw(ID3D10Device1 *iface, UINT vertex_count,
3791 UINT start_vertex_location)
3792 {
3793 struct d3d_device *device = impl_from_ID3D10Device(iface);
3794
3795 TRACE("iface %p, vertex_count %u, start_vertex_location %u\n",
3796 iface, vertex_count, start_vertex_location);
3797
3798 wined3d_mutex_lock();
3799 wined3d_device_draw_primitive(device->wined3d_device, start_vertex_location, vertex_count);
3800 wined3d_mutex_unlock();
3801 }
3802
3803 static void STDMETHODCALLTYPE d3d10_device_PSSetConstantBuffers(ID3D10Device1 *iface,
3804 UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
3805 {
3806 struct d3d_device *device = impl_from_ID3D10Device(iface);
3807 unsigned int i;
3808
3809 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3810 iface, start_slot, buffer_count, buffers);
3811
3812 wined3d_mutex_lock();
3813 for (i = 0; i < buffer_count; ++i)
3814 {
3815 struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3816
3817 wined3d_device_set_ps_cb(device->wined3d_device, start_slot + i,
3818 buffer ? buffer->wined3d_buffer : NULL);
3819 }
3820 wined3d_mutex_unlock();
3821 }
3822
3823 static void STDMETHODCALLTYPE d3d10_device_IASetInputLayout(ID3D10Device1 *iface,
3824 ID3D10InputLayout *input_layout)
3825 {
3826 struct d3d_device *device = impl_from_ID3D10Device(iface);
3827 struct d3d_input_layout *layout = unsafe_impl_from_ID3D10InputLayout(input_layout);
3828
3829 TRACE("iface %p, input_layout %p\n", iface, input_layout);
3830
3831 wined3d_mutex_lock();
3832 wined3d_device_set_vertex_declaration(device->wined3d_device,
3833 layout ? layout->wined3d_decl : NULL);
3834 wined3d_mutex_unlock();
3835 }
3836
3837 static void STDMETHODCALLTYPE d3d10_device_IASetVertexBuffers(ID3D10Device1 *iface, UINT start_slot,
3838 UINT buffer_count, ID3D10Buffer *const *buffers, const UINT *strides, const UINT *offsets)
3839 {
3840 struct d3d_device *device = impl_from_ID3D10Device(iface);
3841 unsigned int i;
3842
3843 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p\n",
3844 iface, start_slot, buffer_count, buffers, strides, offsets);
3845
3846 wined3d_mutex_lock();
3847 for (i = 0; i < buffer_count; ++i)
3848 {
3849 struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3850
3851 wined3d_device_set_stream_source(device->wined3d_device, start_slot + i,
3852 buffer ? buffer->wined3d_buffer : NULL, offsets[i], strides[i]);
3853 }
3854 wined3d_mutex_unlock();
3855 }
3856
3857 static void STDMETHODCALLTYPE d3d10_device_IASetIndexBuffer(ID3D10Device1 *iface,
3858 ID3D10Buffer *buffer, DXGI_FORMAT format, UINT offset)
3859 {
3860 struct d3d_device *device = impl_from_ID3D10Device(iface);
3861 struct d3d_buffer *buffer_impl = unsafe_impl_from_ID3D10Buffer(buffer);
3862
3863 TRACE("iface %p, buffer %p, format %s, offset %u.\n",
3864 iface, buffer, debug_dxgi_format(format), offset);
3865
3866 wined3d_mutex_lock();
3867 wined3d_device_set_index_buffer(device->wined3d_device,
3868 buffer_impl ? buffer_impl->wined3d_buffer : NULL,
3869 wined3dformat_from_dxgi_format(format), offset);
3870 wined3d_mutex_unlock();
3871 }
3872
3873 static void STDMETHODCALLTYPE d3d10_device_DrawIndexedInstanced(ID3D10Device1 *iface,
3874 UINT instance_index_count, UINT instance_count, UINT start_index_location,
3875 INT base_vertex_location, UINT start_instance_location)
3876 {
3877 struct d3d_device *device = impl_from_ID3D10Device(iface);
3878
3879 TRACE("iface %p, instance_index_count %u, instance_count %u, start_index_location %u, "
3880 "base_vertex_location %d, start_instance_location %u.\n",
3881 iface, instance_index_count, instance_count, start_index_location,
3882 base_vertex_location, start_instance_location);
3883
3884 wined3d_mutex_lock();
3885 wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_location);
3886 wined3d_device_draw_indexed_primitive_instanced(device->wined3d_device, start_index_location,
3887 instance_index_count, start_instance_location, instance_count);
3888 wined3d_mutex_unlock();
3889 }
3890
3891 static void STDMETHODCALLTYPE d3d10_device_DrawInstanced(ID3D10Device1 *iface,
3892 UINT instance_vertex_count, UINT instance_count,
3893 UINT start_vertex_location, UINT start_instance_location)
3894 {
3895 struct d3d_device *device = impl_from_ID3D10Device(iface);
3896
3897 TRACE("iface %p, instance_vertex_count %u, instance_count %u, start_vertex_location %u, "
3898 "start_instance_location %u.\n", iface, instance_vertex_count, instance_count,
3899 start_vertex_location, start_instance_location);
3900
3901 wined3d_mutex_lock();
3902 wined3d_device_draw_primitive_instanced(device->wined3d_device, start_vertex_location,
3903 instance_vertex_count, start_instance_location, instance_count);
3904 wined3d_mutex_unlock();
3905 }
3906
3907 static void STDMETHODCALLTYPE d3d10_device_GSSetConstantBuffers(ID3D10Device1 *iface,
3908 UINT start_slot, UINT buffer_count, ID3D10Buffer *const *buffers)
3909 {
3910 struct d3d_device *device = impl_from_ID3D10Device(iface);
3911 unsigned int i;
3912
3913 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
3914 iface, start_slot, buffer_count, buffers);
3915
3916 wined3d_mutex_lock();
3917 for (i = 0; i < buffer_count; ++i)
3918 {
3919 struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(buffers[i]);
3920
3921 wined3d_device_set_gs_cb(device->wined3d_device, start_slot + i,
3922 buffer ? buffer->wined3d_buffer : NULL);
3923 }
3924 wined3d_mutex_unlock();
3925 }
3926
3927 static void STDMETHODCALLTYPE d3d10_device_GSSetShader(ID3D10Device1 *iface, ID3D10GeometryShader *shader)
3928 {
3929 struct d3d_device *device = impl_from_ID3D10Device(iface);
3930 struct d3d_geometry_shader *gs = unsafe_impl_from_ID3D10GeometryShader(shader);
3931
3932 TRACE("iface %p, shader %p.\n", iface, shader);
3933
3934 wined3d_mutex_lock();
3935 wined3d_device_set_geometry_shader(device->wined3d_device, gs ? gs->wined3d_shader : NULL);
3936 wined3d_mutex_unlock();
3937 }
3938
3939 static void STDMETHODCALLTYPE d3d10_device_IASetPrimitiveTopology(ID3D10Device1 *iface,
3940 D3D10_PRIMITIVE_TOPOLOGY topology)
3941 {
3942 struct d3d_device *device = impl_from_ID3D10Device(iface);
3943
3944 TRACE("iface %p, topology %s\n", iface, debug_d3d10_primitive_topology(topology));
3945
3946 wined3d_mutex_lock();
3947 wined3d_device_set_primitive_type(device->wined3d_device, (enum wined3d_primitive_type)topology);
3948 wined3d_mutex_unlock();
3949 }
3950
3951 static void STDMETHODCALLTYPE d3d10_device_VSSetShaderResources(ID3D10Device1 *iface,
3952 UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
3953 {
3954 struct d3d_device *device = impl_from_ID3D10Device(iface);
3955 unsigned int i;
3956
3957 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
3958 iface, start_slot, view_count, views);
3959
3960 wined3d_mutex_lock();
3961 for (i = 0; i < view_count; ++i)
3962 {
3963 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
3964
3965 wined3d_device_set_vs_resource_view(device->wined3d_device, start_slot + i,
3966 view ? view->wined3d_view : NULL);
3967 }
3968 wined3d_mutex_unlock();
3969 }
3970
3971 static void STDMETHODCALLTYPE d3d10_device_VSSetSamplers(ID3D10Device1 *iface,
3972 UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
3973 {
3974 struct d3d_device *device = impl_from_ID3D10Device(iface);
3975 unsigned int i;
3976
3977 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
3978 iface, start_slot, sampler_count, samplers);
3979
3980 wined3d_mutex_lock();
3981 for (i = 0; i < sampler_count; ++i)
3982 {
3983 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
3984
3985 wined3d_device_set_vs_sampler(device->wined3d_device, start_slot + i,
3986 sampler ? sampler->wined3d_sampler : NULL);
3987 }
3988 wined3d_mutex_unlock();
3989 }
3990
3991 static void STDMETHODCALLTYPE d3d10_device_SetPredication(ID3D10Device1 *iface, ID3D10Predicate *predicate, BOOL value)
3992 {
3993 struct d3d_device *device = impl_from_ID3D10Device(iface);
3994 struct d3d_query *query;
3995
3996 TRACE("iface %p, predicate %p, value %#x.\n", iface, predicate, value);
3997
3998 query = unsafe_impl_from_ID3D10Query((ID3D10Query *)predicate);
3999 wined3d_mutex_lock();
4000 wined3d_device_set_predication(device->wined3d_device, query ? query->wined3d_query : NULL, value);
4001 wined3d_mutex_unlock();
4002 }
4003
4004 static void STDMETHODCALLTYPE d3d10_device_GSSetShaderResources(ID3D10Device1 *iface,
4005 UINT start_slot, UINT view_count, ID3D10ShaderResourceView *const *views)
4006 {
4007 struct d3d_device *device = impl_from_ID3D10Device(iface);
4008 unsigned int i;
4009
4010 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4011 iface, start_slot, view_count, views);
4012
4013 wined3d_mutex_lock();
4014 for (i = 0; i < view_count; ++i)
4015 {
4016 struct d3d_shader_resource_view *view = unsafe_impl_from_ID3D10ShaderResourceView(views[i]);
4017
4018 wined3d_device_set_gs_resource_view(device->wined3d_device, start_slot + i,
4019 view ? view->wined3d_view : NULL);
4020 }
4021 wined3d_mutex_unlock();
4022 }
4023
4024 static void STDMETHODCALLTYPE d3d10_device_GSSetSamplers(ID3D10Device1 *iface,
4025 UINT start_slot, UINT sampler_count, ID3D10SamplerState *const *samplers)
4026 {
4027 struct d3d_device *device = impl_from_ID3D10Device(iface);
4028 unsigned int i;
4029
4030 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4031 iface, start_slot, sampler_count, samplers);
4032
4033 wined3d_mutex_lock();
4034 for (i = 0; i < sampler_count; ++i)
4035 {
4036 struct d3d_sampler_state *sampler = unsafe_impl_from_ID3D10SamplerState(samplers[i]);
4037
4038 wined3d_device_set_gs_sampler(device->wined3d_device, start_slot + i,
4039 sampler ? sampler->wined3d_sampler : NULL);
4040 }
4041 wined3d_mutex_unlock();
4042 }
4043
4044 static void STDMETHODCALLTYPE d3d10_device_OMSetRenderTargets(ID3D10Device1 *iface,
4045 UINT render_target_view_count, ID3D10RenderTargetView *const *render_target_views,
4046 ID3D10DepthStencilView *depth_stencil_view)
4047 {
4048 struct d3d_device *device = impl_from_ID3D10Device(iface);
4049 struct d3d_depthstencil_view *dsv;
4050 unsigned int i;
4051
4052 TRACE("iface %p, render_target_view_count %u, render_target_views %p, depth_stencil_view %p.\n",
4053 iface, render_target_view_count, render_target_views, depth_stencil_view);
4054
4055 wined3d_mutex_lock();
4056 for (i = 0; i < render_target_view_count; ++i)
4057 {
4058 struct d3d_rendertarget_view *rtv = unsafe_impl_from_ID3D10RenderTargetView(render_target_views[i]);
4059
4060 wined3d_device_set_rendertarget_view(device->wined3d_device, i,
4061 rtv ? rtv->wined3d_view : NULL, FALSE);
4062 }
4063 for (; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
4064 {
4065 wined3d_device_set_rendertarget_view(device->wined3d_device, i, NULL, FALSE);
4066 }
4067
4068 dsv = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
4069 wined3d_device_set_depth_stencil_view(device->wined3d_device,
4070 dsv ? dsv->wined3d_view : NULL);
4071 wined3d_mutex_unlock();
4072 }
4073
4074 static void STDMETHODCALLTYPE d3d10_device_OMSetBlendState(ID3D10Device1 *iface,
4075 ID3D10BlendState *blend_state, const float blend_factor[4], UINT sample_mask)
4076 {
4077 struct d3d_device *device = impl_from_ID3D10Device(iface);
4078 struct d3d_blend_state *blend_state_object;
4079
4080 TRACE("iface %p, blend_state %p, blend_factor %s, sample_mask 0x%08x.\n",
4081 iface, blend_state, debug_float4(blend_factor), sample_mask);
4082
4083 blend_state_object = unsafe_impl_from_ID3D10BlendState(blend_state);
4084 d3d11_immediate_context_OMSetBlendState(&device->immediate_context.ID3D11DeviceContext_iface,
4085 blend_state_object ? &blend_state_object->ID3D11BlendState_iface : NULL, blend_factor, sample_mask);
4086 }
4087
4088 static void STDMETHODCALLTYPE d3d10_device_OMSetDepthStencilState(ID3D10Device1 *iface,
4089 ID3D10DepthStencilState *depth_stencil_state, UINT stencil_ref)
4090 {
4091 struct d3d_device *device = impl_from_ID3D10Device(iface);
4092 struct d3d_depthstencil_state *ds_state_object;
4093
4094 TRACE("iface %p, depth_stencil_state %p, stencil_ref %u.\n",
4095 iface, depth_stencil_state, stencil_ref);
4096
4097 ds_state_object = unsafe_impl_from_ID3D10DepthStencilState(depth_stencil_state);
4098 d3d11_immediate_context_OMSetDepthStencilState(&device->immediate_context.ID3D11DeviceContext_iface,
4099 ds_state_object ? &ds_state_object->ID3D11DepthStencilState_iface : NULL, stencil_ref);
4100 }
4101
4102 static void STDMETHODCALLTYPE d3d10_device_SOSetTargets(ID3D10Device1 *iface,
4103 UINT target_count, ID3D10Buffer *const *targets, const UINT *offsets)
4104 {
4105 struct d3d_device *device = impl_from_ID3D10Device(iface);
4106 unsigned int count, i;
4107
4108 TRACE("iface %p, target_count %u, targets %p, offsets %p.\n", iface, target_count, targets, offsets);
4109
4110 count = min(target_count, D3D10_SO_BUFFER_SLOT_COUNT);
4111 wined3d_mutex_lock();
4112 for (i = 0; i < count; ++i)
4113 {
4114 struct d3d_buffer *buffer = unsafe_impl_from_ID3D10Buffer(targets[i]);
4115
4116 wined3d_device_set_stream_output(device->wined3d_device, i,
4117 buffer ? buffer->wined3d_buffer : NULL, offsets[i]);
4118 }
4119
4120 for (i = count; i < D3D10_SO_BUFFER_SLOT_COUNT; ++i)
4121 {
4122 wined3d_device_set_stream_output(device->wined3d_device, i, NULL, 0);
4123 }
4124 wined3d_mutex_unlock();
4125 }
4126
4127 static void STDMETHODCALLTYPE d3d10_device_DrawAuto(ID3D10Device1 *iface)
4128 {
4129 FIXME("iface %p stub!\n", iface);
4130 }
4131
4132 static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device1 *iface, ID3D10RasterizerState *rasterizer_state)
4133 {
4134 struct d3d_device *device = impl_from_ID3D10Device(iface);
4135 struct d3d_rasterizer_state *rasterizer_state_object;
4136
4137 TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
4138
4139 rasterizer_state_object = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state);
4140 d3d11_immediate_context_RSSetState(&device->immediate_context.ID3D11DeviceContext_iface,
4141 rasterizer_state_object ? &rasterizer_state_object->ID3D11RasterizerState_iface : NULL);
4142 }
4143
4144 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device1 *iface,
4145 UINT viewport_count, const D3D10_VIEWPORT *viewports)
4146 {
4147 struct d3d_device *device = impl_from_ID3D10Device(iface);
4148 struct wined3d_viewport wined3d_vp;
4149
4150 TRACE("iface %p, viewport_count %u, viewports %p.\n", iface, viewport_count, viewports);
4151
4152 if (viewport_count > 1)
4153 FIXME("Multiple viewports not implemented.\n");
4154
4155 if (!viewport_count)
4156 return;
4157
4158 wined3d_vp.x = viewports[0].TopLeftX;
4159 wined3d_vp.y = viewports[0].TopLeftY;
4160 wined3d_vp.width = viewports[0].Width;
4161 wined3d_vp.height = viewports[0].Height;
4162 wined3d_vp.min_z = viewports[0].MinDepth;
4163 wined3d_vp.max_z = viewports[0].MaxDepth;
4164
4165 wined3d_mutex_lock();
4166 wined3d_device_set_viewport(device->wined3d_device, &wined3d_vp);
4167 wined3d_mutex_unlock();
4168 }
4169
4170 static void STDMETHODCALLTYPE d3d10_device_RSSetScissorRects(ID3D10Device1 *iface,
4171 UINT rect_count, const D3D10_RECT *rects)
4172 {
4173 struct d3d_device *device = impl_from_ID3D10Device(iface);
4174
4175 TRACE("iface %p, rect_count %u, rects %p.\n", iface, rect_count, rects);
4176
4177 if (rect_count > 1)
4178 FIXME("Multiple scissor rects not implemented.\n");
4179
4180 if (!rect_count)
4181 return;
4182
4183 wined3d_mutex_lock();
4184 wined3d_device_set_scissor_rect(device->wined3d_device, rects);
4185 wined3d_mutex_unlock();
4186 }
4187
4188 static void STDMETHODCALLTYPE d3d10_device_CopySubresourceRegion(ID3D10Device1 *iface,
4189 ID3D10Resource *dst_resource, UINT dst_subresource_idx, UINT dst_x, UINT dst_y, UINT dst_z,
4190 ID3D10Resource *src_resource, UINT src_subresource_idx, const D3D10_BOX *src_box)
4191 {
4192 struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
4193 struct d3d_device *device = impl_from_ID3D10Device(iface);
4194 struct wined3d_box wined3d_src_box;
4195
4196 TRACE("iface %p, dst_resource %p, dst_subresource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
4197 "src_resource %p, src_subresource_idx %u, src_box %p.\n",
4198 iface, dst_resource, dst_subresource_idx, dst_x, dst_y, dst_z,
4199 src_resource, src_subresource_idx, src_box);
4200
4201 if (src_box)
4202 wined3d_box_set(&wined3d_src_box, src_box->left, src_box->top,
4203 src_box->right, src_box->bottom, src_box->front, src_box->back);
4204
4205 wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
4206 wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
4207 wined3d_mutex_lock();
4208 wined3d_device_copy_sub_resource_region(device->wined3d_device, wined3d_dst_resource, dst_subresource_idx,
4209 dst_x, dst_y, dst_z, wined3d_src_resource, src_subresource_idx, src_box ? &wined3d_src_box : NULL);
4210 wined3d_mutex_unlock();
4211 }
4212
4213 static void STDMETHODCALLTYPE d3d10_device_CopyResource(ID3D10Device1 *iface,
4214 ID3D10Resource *dst_resource, ID3D10Resource *src_resource)
4215 {
4216 struct wined3d_resource *wined3d_dst_resource, *wined3d_src_resource;
4217 struct d3d_device *device = impl_from_ID3D10Device(iface);
4218
4219 TRACE("iface %p, dst_resource %p, src_resource %p.\n", iface, dst_resource, src_resource);
4220
4221 wined3d_dst_resource = wined3d_resource_from_d3d10_resource(dst_resource);
4222 wined3d_src_resource = wined3d_resource_from_d3d10_resource(src_resource);
4223 wined3d_mutex_lock();
4224 wined3d_device_copy_resource(device->wined3d_device, wined3d_dst_resource, wined3d_src_resource);
4225 wined3d_mutex_unlock();
4226 }
4227
4228 static void STDMETHODCALLTYPE d3d10_device_UpdateSubresource(ID3D10Device1 *iface,
4229 ID3D10Resource *resource, UINT subresource_idx, const D3D10_BOX *box,
4230 const void *data, UINT row_pitch, UINT depth_pitch)
4231 {
4232 struct d3d_device *device = impl_from_ID3D10Device(iface);
4233 ID3D11Resource *d3d11_resource;
4234
4235 TRACE("iface %p, resource %p, subresource_idx %u, box %p, data %p, row_pitch %u, depth_pitch %u.\n",
4236 iface, resource, subresource_idx, box, data, row_pitch, depth_pitch);
4237
4238 ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource);
4239 d3d11_immediate_context_UpdateSubresource(&device->immediate_context.ID3D11DeviceContext_iface,
4240 d3d11_resource, subresource_idx, (const D3D11_BOX *)box, data, row_pitch, depth_pitch);
4241 ID3D11Resource_Release(d3d11_resource);
4242 }
4243
4244 static void STDMETHODCALLTYPE d3d10_device_ClearRenderTargetView(ID3D10Device1 *iface,
4245 ID3D10RenderTargetView *render_target_view, const float color_rgba[4])
4246 {
4247 struct d3d_device *device = impl_from_ID3D10Device(iface);
4248 struct d3d_rendertarget_view *view = unsafe_impl_from_ID3D10RenderTargetView(render_target_view);
4249 const struct wined3d_color color = {color_rgba[0], color_rgba[1], color_rgba[2], color_rgba[3]};
4250 HRESULT hr;
4251
4252 TRACE("iface %p, render_target_view %p, color_rgba %s.\n",
4253 iface, render_target_view, debug_float4(color_rgba));
4254
4255 if (!view)
4256 return;
4257
4258 wined3d_mutex_lock();
4259 if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
4260 WINED3DCLEAR_TARGET, &color, 0.0f, 0)))
4261 ERR("Failed to clear view, hr %#x.\n", hr);
4262 wined3d_mutex_unlock();
4263 }
4264
4265 static void STDMETHODCALLTYPE d3d10_device_ClearDepthStencilView(ID3D10Device1 *iface,
4266 ID3D10DepthStencilView *depth_stencil_view, UINT flags, FLOAT depth, UINT8 stencil)
4267 {
4268 struct d3d_device *device = impl_from_ID3D10Device(iface);
4269 struct d3d_depthstencil_view *view = unsafe_impl_from_ID3D10DepthStencilView(depth_stencil_view);
4270 DWORD wined3d_flags;
4271 HRESULT hr;
4272
4273 TRACE("iface %p, depth_stencil_view %p, flags %#x, depth %.8e, stencil %u.\n",
4274 iface, depth_stencil_view, flags, depth, stencil);
4275
4276 if (!view)
4277 return;
4278
4279 wined3d_flags = wined3d_clear_flags_from_d3d11_clear_flags(flags);
4280
4281 wined3d_mutex_lock();
4282 if (FAILED(hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, view->wined3d_view, NULL,
4283 wined3d_flags, NULL, depth, stencil)))
4284 ERR("Failed to clear view, hr %#x.\n", hr);
4285 wined3d_mutex_unlock();
4286 }
4287
4288 static void STDMETHODCALLTYPE d3d10_device_GenerateMips(ID3D10Device1 *iface,
4289 ID3D10ShaderResourceView *shader_resource_view)
4290 {
4291 FIXME("iface %p, shader_resource_view %p stub!\n", iface, shader_resource_view);
4292 }
4293
4294 static void STDMETHODCALLTYPE d3d10_device_ResolveSubresource(ID3D10Device1 *iface,
4295 ID3D10Resource *dst_resource, UINT dst_subresource_idx,
4296 ID3D10Resource *src_resource, UINT src_subresource_idx, DXGI_FORMAT format)
4297 {
4298 FIXME("iface %p, dst_resource %p, dst_subresource_idx %u, "
4299 "src_resource %p, src_subresource_idx %u, format %s stub!\n",
4300 iface, dst_resource, dst_subresource_idx,
4301 src_resource, src_subresource_idx, debug_dxgi_format(format));
4302 }
4303
4304 static void STDMETHODCALLTYPE d3d10_device_VSGetConstantBuffers(ID3D10Device1 *iface,
4305 UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
4306 {
4307 struct d3d_device *device = impl_from_ID3D10Device(iface);
4308 unsigned int i;
4309
4310 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4311 iface, start_slot, buffer_count, buffers);
4312
4313 wined3d_mutex_lock();
4314 for (i = 0; i < buffer_count; ++i)
4315 {
4316 struct wined3d_buffer *wined3d_buffer;
4317 struct d3d_buffer *buffer_impl;
4318
4319 if (!(wined3d_buffer = wined3d_device_get_vs_cb(device->wined3d_device, start_slot + i)))
4320 {
4321 buffers[i] = NULL;
4322 continue;
4323 }
4324
4325 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4326 buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4327 ID3D10Buffer_AddRef(buffers[i]);
4328 }
4329 wined3d_mutex_unlock();
4330 }
4331
4332 static void STDMETHODCALLTYPE d3d10_device_PSGetShaderResources(ID3D10Device1 *iface,
4333 UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
4334 {
4335 struct d3d_device *device = impl_from_ID3D10Device(iface);
4336 unsigned int i;
4337
4338 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4339 iface, start_slot, view_count, views);
4340
4341 wined3d_mutex_lock();
4342 for (i = 0; i < view_count; ++i)
4343 {
4344 struct wined3d_shader_resource_view *wined3d_view;
4345 struct d3d_shader_resource_view *view_impl;
4346
4347 if (!(wined3d_view = wined3d_device_get_ps_resource_view(device->wined3d_device, start_slot + i)))
4348 {
4349 views[i] = NULL;
4350 continue;
4351 }
4352
4353 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
4354 views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
4355 ID3D10ShaderResourceView_AddRef(views[i]);
4356 }
4357 wined3d_mutex_unlock();
4358 }
4359
4360 static void STDMETHODCALLTYPE d3d10_device_PSGetShader(ID3D10Device1 *iface, ID3D10PixelShader **shader)
4361 {
4362 struct d3d_device *device = impl_from_ID3D10Device(iface);
4363 struct d3d_pixel_shader *shader_impl;
4364 struct wined3d_shader *wined3d_shader;
4365
4366 TRACE("iface %p, shader %p.\n", iface, shader);
4367
4368 wined3d_mutex_lock();
4369 if (!(wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device)))
4370 {
4371 wined3d_mutex_unlock();
4372 *shader = NULL;
4373 return;
4374 }
4375
4376 shader_impl = wined3d_shader_get_parent(wined3d_shader);
4377 wined3d_mutex_unlock();
4378 *shader = &shader_impl->ID3D10PixelShader_iface;
4379 ID3D10PixelShader_AddRef(*shader);
4380 }
4381
4382 static void STDMETHODCALLTYPE d3d10_device_PSGetSamplers(ID3D10Device1 *iface,
4383 UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
4384 {
4385 struct d3d_device *device = impl_from_ID3D10Device(iface);
4386 unsigned int i;
4387
4388 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4389 iface, start_slot, sampler_count, samplers);
4390
4391 wined3d_mutex_lock();
4392 for (i = 0; i < sampler_count; ++i)
4393 {
4394 struct d3d_sampler_state *sampler_impl;
4395 struct wined3d_sampler *wined3d_sampler;
4396
4397 if (!(wined3d_sampler = wined3d_device_get_ps_sampler(device->wined3d_device, start_slot + i)))
4398 {
4399 samplers[i] = NULL;
4400 continue;
4401 }
4402
4403 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
4404 samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
4405 ID3D10SamplerState_AddRef(samplers[i]);
4406 }
4407 wined3d_mutex_unlock();
4408 }
4409
4410 static void STDMETHODCALLTYPE d3d10_device_VSGetShader(ID3D10Device1 *iface, ID3D10VertexShader **shader)
4411 {
4412 struct d3d_device *device = impl_from_ID3D10Device(iface);
4413 struct d3d_vertex_shader *shader_impl;
4414 struct wined3d_shader *wined3d_shader;
4415
4416 TRACE("iface %p, shader %p.\n", iface, shader);
4417
4418 wined3d_mutex_lock();
4419 if (!(wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device)))
4420 {
4421 wined3d_mutex_unlock();
4422 *shader = NULL;
4423 return;
4424 }
4425
4426 shader_impl = wined3d_shader_get_parent(wined3d_shader);
4427 wined3d_mutex_unlock();
4428 *shader = &shader_impl->ID3D10VertexShader_iface;
4429 ID3D10VertexShader_AddRef(*shader);
4430 }
4431
4432 static void STDMETHODCALLTYPE d3d10_device_PSGetConstantBuffers(ID3D10Device1 *iface,
4433 UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
4434 {
4435 struct d3d_device *device = impl_from_ID3D10Device(iface);
4436 unsigned int i;
4437
4438 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4439 iface, start_slot, buffer_count, buffers);
4440
4441 wined3d_mutex_lock();
4442 for (i = 0; i < buffer_count; ++i)
4443 {
4444 struct wined3d_buffer *wined3d_buffer;
4445 struct d3d_buffer *buffer_impl;
4446
4447 if (!(wined3d_buffer = wined3d_device_get_ps_cb(device->wined3d_device, start_slot + i)))
4448 {
4449 buffers[i] = NULL;
4450 continue;
4451 }
4452
4453 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4454 buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4455 ID3D10Buffer_AddRef(buffers[i]);
4456 }
4457 wined3d_mutex_unlock();
4458 }
4459
4460 static void STDMETHODCALLTYPE d3d10_device_IAGetInputLayout(ID3D10Device1 *iface, ID3D10InputLayout **input_layout)
4461 {
4462 struct d3d_device *device = impl_from_ID3D10Device(iface);
4463 struct wined3d_vertex_declaration *wined3d_declaration;
4464 struct d3d_input_layout *input_layout_impl;
4465
4466 TRACE("iface %p, input_layout %p.\n", iface, input_layout);
4467
4468 wined3d_mutex_lock();
4469 if (!(wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
4470 {
4471 wined3d_mutex_unlock();
4472 *input_layout = NULL;
4473 return;
4474 }
4475
4476 input_layout_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration);
4477 wined3d_mutex_unlock();
4478 *input_layout = &input_layout_impl->ID3D10InputLayout_iface;
4479 ID3D10InputLayout_AddRef(*input_layout);
4480 }
4481
4482 static void STDMETHODCALLTYPE d3d10_device_IAGetVertexBuffers(ID3D10Device1 *iface,
4483 UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers, UINT *strides, UINT *offsets)
4484 {
4485 struct d3d_device *device = impl_from_ID3D10Device(iface);
4486 unsigned int i;
4487
4488 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p, strides %p, offsets %p.\n",
4489 iface, start_slot, buffer_count, buffers, strides, offsets);
4490
4491 wined3d_mutex_lock();
4492 for (i = 0; i < buffer_count; ++i)
4493 {
4494 struct wined3d_buffer *wined3d_buffer = NULL;
4495 struct d3d_buffer *buffer_impl;
4496
4497 if (FAILED(wined3d_device_get_stream_source(device->wined3d_device, start_slot + i,
4498 &wined3d_buffer, &offsets[i], &strides[i])))
4499 ERR("Failed to get vertex buffer.\n");
4500
4501 if (!wined3d_buffer)
4502 {
4503 buffers[i] = NULL;
4504 continue;
4505 }
4506
4507 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4508 buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4509 ID3D10Buffer_AddRef(buffers[i]);
4510 }
4511 wined3d_mutex_unlock();
4512 }
4513
4514 static void STDMETHODCALLTYPE d3d10_device_IAGetIndexBuffer(ID3D10Device1 *iface,
4515 ID3D10Buffer **buffer, DXGI_FORMAT *format, UINT *offset)
4516 {
4517 struct d3d_device *device = impl_from_ID3D10Device(iface);
4518 enum wined3d_format_id wined3d_format;
4519 struct wined3d_buffer *wined3d_buffer;
4520 struct d3d_buffer *buffer_impl;
4521
4522 TRACE("iface %p, buffer %p, format %p, offset %p.\n", iface, buffer, format, offset);
4523
4524 wined3d_mutex_lock();
4525 wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format, offset);
4526 *format = dxgi_format_from_wined3dformat(wined3d_format);
4527 if (!wined3d_buffer)
4528 {
4529 wined3d_mutex_unlock();
4530 *buffer = NULL;
4531 return;
4532 }
4533
4534 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4535 wined3d_mutex_unlock();
4536 *buffer = &buffer_impl->ID3D10Buffer_iface;
4537 ID3D10Buffer_AddRef(*buffer);
4538 }
4539
4540 static void STDMETHODCALLTYPE d3d10_device_GSGetConstantBuffers(ID3D10Device1 *iface,
4541 UINT start_slot, UINT buffer_count, ID3D10Buffer **buffers)
4542 {
4543 struct d3d_device *device = impl_from_ID3D10Device(iface);
4544 unsigned int i;
4545
4546 TRACE("iface %p, start_slot %u, buffer_count %u, buffers %p.\n",
4547 iface, start_slot, buffer_count, buffers);
4548
4549 wined3d_mutex_lock();
4550 for (i = 0; i < buffer_count; ++i)
4551 {
4552 struct wined3d_buffer *wined3d_buffer;
4553 struct d3d_buffer *buffer_impl;
4554
4555 if (!(wined3d_buffer = wined3d_device_get_gs_cb(device->wined3d_device, start_slot + i)))
4556 {
4557 buffers[i] = NULL;
4558 continue;
4559 }
4560
4561 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4562 buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4563 ID3D10Buffer_AddRef(buffers[i]);
4564 }
4565 wined3d_mutex_unlock();
4566 }
4567
4568 static void STDMETHODCALLTYPE d3d10_device_GSGetShader(ID3D10Device1 *iface, ID3D10GeometryShader **shader)
4569 {
4570 struct d3d_device *device = impl_from_ID3D10Device(iface);
4571 struct d3d_geometry_shader *shader_impl;
4572 struct wined3d_shader *wined3d_shader;
4573
4574 TRACE("iface %p, shader %p.\n", iface, shader);
4575
4576 wined3d_mutex_lock();
4577 if (!(wined3d_shader = wined3d_device_get_geometry_shader(device->wined3d_device)))
4578 {
4579 wined3d_mutex_unlock();
4580 *shader = NULL;
4581 return;
4582 }
4583
4584 shader_impl = wined3d_shader_get_parent(wined3d_shader);
4585 wined3d_mutex_unlock();
4586 *shader = &shader_impl->ID3D10GeometryShader_iface;
4587 ID3D10GeometryShader_AddRef(*shader);
4588 }
4589
4590 static void STDMETHODCALLTYPE d3d10_device_IAGetPrimitiveTopology(ID3D10Device1 *iface,
4591 D3D10_PRIMITIVE_TOPOLOGY *topology)
4592 {
4593 struct d3d_device *device = impl_from_ID3D10Device(iface);
4594
4595 TRACE("iface %p, topology %p\n", iface, topology);
4596
4597 wined3d_mutex_lock();
4598 wined3d_device_get_primitive_type(device->wined3d_device, (enum wined3d_primitive_type *)topology);
4599 wined3d_mutex_unlock();
4600 }
4601
4602 static void STDMETHODCALLTYPE d3d10_device_VSGetShaderResources(ID3D10Device1 *iface,
4603 UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
4604 {
4605 struct d3d_device *device = impl_from_ID3D10Device(iface);
4606 unsigned int i;
4607
4608 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4609 iface, start_slot, view_count, views);
4610
4611 wined3d_mutex_lock();
4612 for (i = 0; i < view_count; ++i)
4613 {
4614 struct wined3d_shader_resource_view *wined3d_view;
4615 struct d3d_shader_resource_view *view_impl;
4616
4617 if (!(wined3d_view = wined3d_device_get_vs_resource_view(device->wined3d_device, start_slot + i)))
4618 {
4619 views[i] = NULL;
4620 continue;
4621 }
4622
4623 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
4624 views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
4625 ID3D10ShaderResourceView_AddRef(views[i]);
4626 }
4627 wined3d_mutex_unlock();
4628 }
4629
4630 static void STDMETHODCALLTYPE d3d10_device_VSGetSamplers(ID3D10Device1 *iface,
4631 UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
4632 {
4633 struct d3d_device *device = impl_from_ID3D10Device(iface);
4634 unsigned int i;
4635
4636 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4637 iface, start_slot, sampler_count, samplers);
4638
4639 wined3d_mutex_lock();
4640 for (i = 0; i < sampler_count; ++i)
4641 {
4642 struct d3d_sampler_state *sampler_impl;
4643 struct wined3d_sampler *wined3d_sampler;
4644
4645 if (!(wined3d_sampler = wined3d_device_get_vs_sampler(device->wined3d_device, start_slot + i)))
4646 {
4647 samplers[i] = NULL;
4648 continue;
4649 }
4650
4651 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
4652 samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
4653 ID3D10SamplerState_AddRef(samplers[i]);
4654 }
4655 wined3d_mutex_unlock();
4656 }
4657
4658 static void STDMETHODCALLTYPE d3d10_device_GetPredication(ID3D10Device1 *iface,
4659 ID3D10Predicate **predicate, BOOL *value)
4660 {
4661 struct d3d_device *device = impl_from_ID3D10Device(iface);
4662 struct wined3d_query *wined3d_predicate;
4663 struct d3d_query *predicate_impl;
4664
4665 TRACE("iface %p, predicate %p, value %p.\n", iface, predicate, value);
4666
4667 wined3d_mutex_lock();
4668 if (!(wined3d_predicate = wined3d_device_get_predication(device->wined3d_device, value)))
4669 {
4670 wined3d_mutex_unlock();
4671 *predicate = NULL;
4672 return;
4673 }
4674
4675 predicate_impl = wined3d_query_get_parent(wined3d_predicate);
4676 wined3d_mutex_unlock();
4677 *predicate = (ID3D10Predicate *)&predicate_impl->ID3D10Query_iface;
4678 ID3D10Predicate_AddRef(*predicate);
4679 }
4680
4681 static void STDMETHODCALLTYPE d3d10_device_GSGetShaderResources(ID3D10Device1 *iface,
4682 UINT start_slot, UINT view_count, ID3D10ShaderResourceView **views)
4683 {
4684 struct d3d_device *device = impl_from_ID3D10Device(iface);
4685 unsigned int i;
4686
4687 TRACE("iface %p, start_slot %u, view_count %u, views %p.\n",
4688 iface, start_slot, view_count, views);
4689
4690 wined3d_mutex_lock();
4691 for (i = 0; i < view_count; ++i)
4692 {
4693 struct wined3d_shader_resource_view *wined3d_view;
4694 struct d3d_shader_resource_view *view_impl;
4695
4696 if (!(wined3d_view = wined3d_device_get_gs_resource_view(device->wined3d_device, start_slot + i)))
4697 {
4698 views[i] = NULL;
4699 continue;
4700 }
4701
4702 view_impl = wined3d_shader_resource_view_get_parent(wined3d_view);
4703 views[i] = (ID3D10ShaderResourceView *)&view_impl->ID3D10ShaderResourceView1_iface;
4704 ID3D10ShaderResourceView_AddRef(views[i]);
4705 }
4706 wined3d_mutex_unlock();
4707 }
4708
4709 static void STDMETHODCALLTYPE d3d10_device_GSGetSamplers(ID3D10Device1 *iface,
4710 UINT start_slot, UINT sampler_count, ID3D10SamplerState **samplers)
4711 {
4712 struct d3d_device *device = impl_from_ID3D10Device(iface);
4713 unsigned int i;
4714
4715 TRACE("iface %p, start_slot %u, sampler_count %u, samplers %p.\n",
4716 iface, start_slot, sampler_count, samplers);
4717
4718 wined3d_mutex_lock();
4719 for (i = 0; i < sampler_count; ++i)
4720 {
4721 struct d3d_sampler_state *sampler_impl;
4722 struct wined3d_sampler *wined3d_sampler;
4723
4724 if (!(wined3d_sampler = wined3d_device_get_gs_sampler(device->wined3d_device, start_slot + i)))
4725 {
4726 samplers[i] = NULL;
4727 continue;
4728 }
4729
4730 sampler_impl = wined3d_sampler_get_parent(wined3d_sampler);
4731 samplers[i] = &sampler_impl->ID3D10SamplerState_iface;
4732 ID3D10SamplerState_AddRef(samplers[i]);
4733 }
4734 wined3d_mutex_unlock();
4735 }
4736
4737 static void STDMETHODCALLTYPE d3d10_device_OMGetRenderTargets(ID3D10Device1 *iface,
4738 UINT view_count, ID3D10RenderTargetView **render_target_views, ID3D10DepthStencilView **depth_stencil_view)
4739 {
4740 struct d3d_device *device = impl_from_ID3D10Device(iface);
4741 struct wined3d_rendertarget_view *wined3d_view;
4742
4743 TRACE("iface %p, view_count %u, render_target_views %p, depth_stencil_view %p.\n",
4744 iface, view_count, render_target_views, depth_stencil_view);
4745
4746 wined3d_mutex_lock();
4747 if (render_target_views)
4748 {
4749 struct d3d_rendertarget_view *view_impl;
4750 unsigned int i;
4751
4752 for (i = 0; i < view_count; ++i)
4753 {
4754 if (!(wined3d_view = wined3d_device_get_rendertarget_view(device->wined3d_device, i))
4755 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
4756 {
4757 render_target_views[i] = NULL;
4758 continue;
4759 }
4760
4761 render_target_views[i] = &view_impl->ID3D10RenderTargetView_iface;
4762 ID3D10RenderTargetView_AddRef(render_target_views[i]);
4763 }
4764 }
4765
4766 if (depth_stencil_view)
4767 {
4768 struct d3d_depthstencil_view *view_impl;
4769
4770 if (!(wined3d_view = wined3d_device_get_depth_stencil_view(device->wined3d_device))
4771 || !(view_impl = wined3d_rendertarget_view_get_parent(wined3d_view)))
4772 {
4773 *depth_stencil_view = NULL;
4774 }
4775 else
4776 {
4777 *depth_stencil_view = &view_impl->ID3D10DepthStencilView_iface;
4778 ID3D10DepthStencilView_AddRef(*depth_stencil_view);
4779 }
4780 }
4781 wined3d_mutex_unlock();
4782 }
4783
4784 static void STDMETHODCALLTYPE d3d10_device_OMGetBlendState(ID3D10Device1 *iface,
4785 ID3D10BlendState **blend_state, FLOAT blend_factor[4], UINT *sample_mask)
4786 {
4787 struct d3d_device *device = impl_from_ID3D10Device(iface);
4788 ID3D11BlendState *d3d11_blend_state;
4789
4790 TRACE("iface %p, blend_state %p, blend_factor %p, sample_mask %p.\n",
4791 iface, blend_state, blend_factor, sample_mask);
4792
4793 d3d11_immediate_context_OMGetBlendState(&device->immediate_context.ID3D11DeviceContext_iface,
4794 &d3d11_blend_state, blend_factor, sample_mask);
4795
4796 if (d3d11_blend_state)
4797 *blend_state = (ID3D10BlendState *)&impl_from_ID3D11BlendState(d3d11_blend_state)->ID3D10BlendState1_iface;
4798 else
4799 *blend_state = NULL;
4800 }
4801
4802 static void STDMETHODCALLTYPE d3d10_device_OMGetDepthStencilState(ID3D10Device1 *iface,
4803 ID3D10DepthStencilState **depth_stencil_state, UINT *stencil_ref)
4804 {
4805 struct d3d_device *device = impl_from_ID3D10Device(iface);
4806 ID3D11DepthStencilState *d3d11_iface;
4807
4808 TRACE("iface %p, depth_stencil_state %p, stencil_ref %p.\n",
4809 iface, depth_stencil_state, stencil_ref);
4810
4811 d3d11_immediate_context_OMGetDepthStencilState(&device->immediate_context.ID3D11DeviceContext_iface,
4812 &d3d11_iface, stencil_ref);
4813
4814 if (d3d11_iface)
4815 *depth_stencil_state = &impl_from_ID3D11DepthStencilState(d3d11_iface)->ID3D10DepthStencilState_iface;
4816 else
4817 *depth_stencil_state = NULL;
4818 }
4819
4820 static void STDMETHODCALLTYPE d3d10_device_SOGetTargets(ID3D10Device1 *iface,
4821 UINT buffer_count, ID3D10Buffer **buffers, UINT *offsets)
4822 {
4823 struct d3d_device *device = impl_from_ID3D10Device(iface);
4824 unsigned int i;
4825
4826 TRACE("iface %p, buffer_count %u, buffers %p, offsets %p.\n",
4827 iface, buffer_count, buffers, offsets);
4828
4829 wined3d_mutex_lock();
4830 for (i = 0; i < buffer_count; ++i)
4831 {
4832 struct wined3d_buffer *wined3d_buffer;
4833 struct d3d_buffer *buffer_impl;
4834
4835 if (!(wined3d_buffer = wined3d_device_get_stream_output(device->wined3d_device, i, &offsets[i])))
4836 {
4837 buffers[i] = NULL;
4838 continue;
4839 }
4840
4841 buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
4842 buffers[i] = &buffer_impl->ID3D10Buffer_iface;
4843 ID3D10Buffer_AddRef(buffers[i]);
4844 }
4845 wined3d_mutex_unlock();
4846 }
4847
4848 static void STDMETHODCALLTYPE d3d10_device_RSGetState(ID3D10Device1 *iface, ID3D10RasterizerState **rasterizer_state)
4849 {
4850 struct d3d_device *device = impl_from_ID3D10Device(iface);
4851 struct d3d_rasterizer_state *rasterizer_state_impl;
4852 struct wined3d_rasterizer_state *wined3d_state;
4853
4854 TRACE("iface %p, rasterizer_state %p.\n", iface, rasterizer_state);
4855
4856 wined3d_mutex_lock();
4857 if ((wined3d_state = wined3d_device_get_rasterizer_state(device->wined3d_device)))
4858 {
4859 rasterizer_state_impl = wined3d_rasterizer_state_get_parent(wined3d_state);
4860 ID3D10RasterizerState_AddRef(*rasterizer_state = &rasterizer_state_impl->ID3D10RasterizerState_iface);
4861 }
4862 else
4863 {
4864 *rasterizer_state = NULL;
4865 }
4866 wined3d_mutex_unlock();
4867 }
4868
4869 static void STDMETHODCALLTYPE d3d10_device_RSGetViewports(ID3D10Device1 *iface,
4870 UINT *viewport_count, D3D10_VIEWPORT *viewports)
4871 {
4872 struct d3d_device *device = impl_from_ID3D10Device(iface);
4873 struct wined3d_viewport wined3d_vp;
4874
4875 TRACE("iface %p, viewport_count %p, viewports %p.\n", iface, viewport_count, viewports);
4876
4877 if (!viewports)
4878 {
4879 *viewport_count = 1;
4880 return;
4881 }
4882
4883 if (!*viewport_count)
4884 return;
4885
4886 wined3d_mutex_lock();
4887 wined3d_device_get_viewport(device->wined3d_device, &wined3d_vp);
4888 wined3d_mutex_unlock();
4889
4890 viewports[0].TopLeftX = wined3d_vp.x;
4891 viewports[0].TopLeftY = wined3d_vp.y;
4892 viewports[0].Width = wined3d_vp.width;
4893 viewports[0].Height = wined3d_vp.height;
4894 viewports[0].MinDepth = wined3d_vp.min_z;
4895 viewports[0].MaxDepth = wined3d_vp.max_z;
4896
4897 if (*viewport_count > 1)
4898 memset(&viewports[1], 0, (*viewport_count - 1) * sizeof(*viewports));
4899 }
4900
4901 static void STDMETHODCALLTYPE d3d10_device_RSGetScissorRects(ID3D10Device1 *iface, UINT *rect_count, D3D10_RECT *rects)
4902 {
4903 struct d3d_device *device = impl_from_ID3D10Device(iface);
4904
4905 TRACE("iface %p, rect_count %p, rects %p.\n", iface, rect_count, rects);
4906
4907 if (!rects)
4908 {
4909 *rect_count = 1;
4910 return;
4911 }
4912
4913 if (!*rect_count)
4914 return;
4915
4916 wined3d_mutex_lock();
4917 wined3d_device_get_scissor_rect(device->wined3d_device, rects);
4918 wined3d_mutex_unlock();
4919 if (*rect_count > 1)
4920 memset(&rects[1], 0, (*rect_count - 1) * sizeof(*rects));
4921 }
4922
4923 static HRESULT STDMETHODCALLTYPE d3d10_device_GetDeviceRemovedReason(ID3D10Device1 *iface)
4924 {
4925 TRACE("iface %p.\n", iface);
4926
4927 /* In the current implementation the device is never removed, so we can
4928 * just return S_OK here. */
4929
4930 return S_OK;
4931 }
4932
4933 static HRESULT STDMETHODCALLTYPE d3d10_device_SetExceptionMode(ID3D10Device1 *iface, UINT flags)
4934 {
4935 FIXME("iface %p, flags %#x stub!\n", iface, flags);
4936
4937 return E_NOTIMPL;
4938 }
4939
4940 static UINT STDMETHODCALLTYPE d3d10_device_GetExceptionMode(ID3D10Device1 *iface)
4941 {
4942 FIXME("iface %p stub!\n", iface);
4943
4944 return 0;
4945 }
4946
4947 static HRESULT STDMETHODCALLTYPE d3d10_device_GetPrivateData(ID3D10Device1 *iface,
4948 REFGUID guid, UINT *data_size, void *data)
4949 {
4950 struct d3d_device *device = impl_from_ID3D10Device(iface);
4951
4952 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4953
4954 return d3d11_device_GetPrivateData(&device->ID3D11Device_iface, guid, data_size, data);
4955 }
4956
4957 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateData(ID3D10Device1 *iface,
4958 REFGUID guid, UINT data_size, const void *data)
4959 {
4960 struct d3d_device *device = impl_from_ID3D10Device(iface);
4961
4962 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
4963
4964 return d3d11_device_SetPrivateData(&device->ID3D11Device_iface, guid, data_size, data);
4965 }
4966
4967 static HRESULT STDMETHODCALLTYPE d3d10_device_SetPrivateDataInterface(ID3D10Device1 *iface,
4968 REFGUID guid, const IUnknown *data)
4969 {
4970 struct d3d_device *device = impl_from_ID3D10Device(iface);
4971
4972 TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
4973
4974 return d3d11_device_SetPrivateDataInterface(&device->ID3D11Device_iface, guid, data);
4975 }
4976
4977 static void STDMETHODCALLTYPE d3d10_device_ClearState(ID3D10Device1 *iface)
4978 {
4979 struct d3d_device *device = impl_from_ID3D10Device(iface);
4980
4981 TRACE("iface %p.\n", iface);
4982
4983 d3d11_immediate_context_ClearState(&device->immediate_context.ID3D11DeviceContext_iface);
4984 }
4985
4986 static void STDMETHODCALLTYPE d3d10_device_Flush(ID3D10Device1 *iface)
4987 {
4988 FIXME("iface %p stub!\n", iface);
4989 }
4990
4991 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBuffer(ID3D10Device1 *iface,
4992 const D3D10_BUFFER_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Buffer **buffer)
4993 {
4994 struct d3d_device *device = impl_from_ID3D10Device(iface);
4995 D3D11_BUFFER_DESC d3d11_desc;
4996 struct d3d_buffer *object;
4997 HRESULT hr;
4998
4999 TRACE("iface %p, desc %p, data %p, buffer %p.\n", iface, desc, data, buffer);
5000
5001 d3d11_desc.ByteWidth = desc->ByteWidth;
5002 d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5003 d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5004 d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5005 d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5006 d3d11_desc.StructureByteStride = 0;
5007
5008 if (FAILED(hr = d3d_buffer_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5009 return hr;
5010
5011 *buffer = &object->ID3D10Buffer_iface;
5012
5013 return S_OK;
5014 }
5015
5016 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture1D(ID3D10Device1 *iface,
5017 const D3D10_TEXTURE1D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data, ID3D10Texture1D **texture)
5018 {
5019 FIXME("iface %p, desc %p, data %p, texture %p stub!\n", iface, desc, data, texture);
5020
5021 return E_NOTIMPL;
5022 }
5023
5024 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture2D(ID3D10Device1 *iface,
5025 const D3D10_TEXTURE2D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
5026 ID3D10Texture2D **texture)
5027 {
5028 struct d3d_device *device = impl_from_ID3D10Device(iface);
5029 D3D11_TEXTURE2D_DESC d3d11_desc;
5030 struct d3d_texture2d *object;
5031 HRESULT hr;
5032
5033 TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
5034
5035 d3d11_desc.Width = desc->Width;
5036 d3d11_desc.Height = desc->Height;
5037 d3d11_desc.MipLevels = desc->MipLevels;
5038 d3d11_desc.ArraySize = desc->ArraySize;
5039 d3d11_desc.Format = desc->Format;
5040 d3d11_desc.SampleDesc = desc->SampleDesc;
5041 d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5042 d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5043 d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5044 d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5045
5046 if (FAILED(hr = d3d_texture2d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5047 return hr;
5048
5049 *texture = &object->ID3D10Texture2D_iface;
5050
5051 return S_OK;
5052 }
5053
5054 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateTexture3D(ID3D10Device1 *iface,
5055 const D3D10_TEXTURE3D_DESC *desc, const D3D10_SUBRESOURCE_DATA *data,
5056 ID3D10Texture3D **texture)
5057 {
5058 struct d3d_device *device = impl_from_ID3D10Device(iface);
5059 D3D11_TEXTURE3D_DESC d3d11_desc;
5060 struct d3d_texture3d *object;
5061 HRESULT hr;
5062
5063 TRACE("iface %p, desc %p, data %p, texture %p.\n", iface, desc, data, texture);
5064
5065 d3d11_desc.Width = desc->Width;
5066 d3d11_desc.Height = desc->Height;
5067 d3d11_desc.Depth = desc->Depth;
5068 d3d11_desc.MipLevels = desc->MipLevels;
5069 d3d11_desc.Format = desc->Format;
5070 d3d11_desc.Usage = d3d11_usage_from_d3d10_usage(desc->Usage);
5071 d3d11_desc.BindFlags = d3d11_bind_flags_from_d3d10_bind_flags(desc->BindFlags);
5072 d3d11_desc.CPUAccessFlags = d3d11_cpu_access_flags_from_d3d10_cpu_access_flags(desc->CPUAccessFlags);
5073 d3d11_desc.MiscFlags = d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(desc->MiscFlags);
5074
5075 if (FAILED(hr = d3d_texture3d_create(device, &d3d11_desc, (const D3D11_SUBRESOURCE_DATA *)data, &object)))
5076 return hr;
5077
5078 *texture = &object->ID3D10Texture3D_iface;
5079
5080 return S_OK;
5081 }
5082
5083 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView1(ID3D10Device1 *iface,
5084 ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc, ID3D10ShaderResourceView1 **view)
5085 {
5086 struct d3d_device *device = impl_from_ID3D10Device(iface);
5087 struct d3d_shader_resource_view *object;
5088 ID3D11Resource *d3d11_resource;
5089 HRESULT hr;
5090
5091 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5092
5093 if (!resource)
5094 return E_INVALIDARG;
5095
5096 if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
5097 {
5098 ERR("Resource does not implement ID3D11Resource.\n");
5099 return E_FAIL;
5100 }
5101
5102 hr = d3d_shader_resource_view_create(device, d3d11_resource, (const D3D11_SHADER_RESOURCE_VIEW_DESC *)desc,
5103 &object);
5104 ID3D11Resource_Release(d3d11_resource);
5105 if (FAILED(hr))
5106 return hr;
5107
5108 *view = &object->ID3D10ShaderResourceView1_iface;
5109
5110 return S_OK;
5111 }
5112
5113 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateShaderResourceView(ID3D10Device1 *iface,
5114 ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10ShaderResourceView **view)
5115 {
5116 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5117
5118 return d3d10_device_CreateShaderResourceView1(iface, resource,
5119 (const D3D10_SHADER_RESOURCE_VIEW_DESC1 *)desc, (ID3D10ShaderResourceView1 **)view);
5120 }
5121
5122 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRenderTargetView(ID3D10Device1 *iface,
5123 ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10RenderTargetView **view)
5124 {
5125 struct d3d_device *device = impl_from_ID3D10Device(iface);
5126 struct d3d_rendertarget_view *object;
5127 ID3D11Resource *d3d11_resource;
5128 HRESULT hr;
5129
5130 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5131
5132 if (!resource)
5133 return E_INVALIDARG;
5134
5135 if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
5136 {
5137 ERR("Resource does not implement ID3D11Resource.\n");
5138 return E_FAIL;
5139 }
5140
5141 hr = d3d_rendertarget_view_create(device, d3d11_resource, (const D3D11_RENDER_TARGET_VIEW_DESC *)desc, &object);
5142 ID3D11Resource_Release(d3d11_resource);
5143 if (FAILED(hr))
5144 return hr;
5145
5146 *view = &object->ID3D10RenderTargetView_iface;
5147
5148 return S_OK;
5149 }
5150
5151 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilView(ID3D10Device1 *iface,
5152 ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10DepthStencilView **view)
5153 {
5154 struct d3d_device *device = impl_from_ID3D10Device(iface);
5155 D3D11_DEPTH_STENCIL_VIEW_DESC d3d11_desc;
5156 struct d3d_depthstencil_view *object;
5157 ID3D11Resource *d3d11_resource;
5158 HRESULT hr;
5159
5160 TRACE("iface %p, resource %p, desc %p, view %p.\n", iface, resource, desc, view);
5161
5162 if (desc)
5163 {
5164 d3d11_desc.Format = desc->Format;
5165 d3d11_desc.ViewDimension = desc->ViewDimension;
5166 d3d11_desc.Flags = 0;
5167 memcpy(&d3d11_desc.u, &desc->u, sizeof(d3d11_desc.u));
5168 }
5169
5170 if (FAILED(hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D11Resource, (void **)&d3d11_resource)))
5171 {
5172 ERR("Resource does not implement ID3D11Resource.\n");
5173 return E_FAIL;
5174 }
5175
5176 hr = d3d_depthstencil_view_create(device, d3d11_resource, desc ? &d3d11_desc : NULL, &object);
5177 ID3D11Resource_Release(d3d11_resource);
5178 if (FAILED(hr))
5179 return hr;
5180
5181 *view = &object->ID3D10DepthStencilView_iface;
5182
5183 return S_OK;
5184 }
5185
5186 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateInputLayout(ID3D10Device1 *iface,
5187 const D3D10_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
5188 const void *shader_byte_code, SIZE_T shader_byte_code_length,
5189 ID3D10InputLayout **input_layout)
5190 {
5191 struct d3d_device *device = impl_from_ID3D10Device(iface);
5192 struct d3d_input_layout *object;
5193 HRESULT hr;
5194
5195 TRACE("iface %p, element_descs %p, element_count %u, shader_byte_code %p, "
5196 "shader_byte_code_length %lu, input_layout %p\n",
5197 iface, element_descs, element_count, shader_byte_code,
5198 shader_byte_code_length, input_layout);
5199
5200 if (FAILED(hr = d3d_input_layout_create(device, (const D3D11_INPUT_ELEMENT_DESC *)element_descs, element_count,
5201 shader_byte_code, shader_byte_code_length, &object)))
5202 return hr;
5203
5204 *input_layout = &object->ID3D10InputLayout_iface;
5205
5206 return S_OK;
5207 }
5208
5209 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateVertexShader(ID3D10Device1 *iface,
5210 const void *byte_code, SIZE_T byte_code_length, ID3D10VertexShader **shader)
5211 {
5212 struct d3d_device *device = impl_from_ID3D10Device(iface);
5213 struct d3d_vertex_shader *object;
5214 HRESULT hr;
5215
5216 TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
5217 iface, byte_code, byte_code_length, shader);
5218
5219 if (FAILED(hr = d3d_vertex_shader_create(device, byte_code, byte_code_length, &object)))
5220 return hr;
5221
5222 *shader = &object->ID3D10VertexShader_iface;
5223
5224 return S_OK;
5225 }
5226
5227 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShader(ID3D10Device1 *iface,
5228 const void *byte_code, SIZE_T byte_code_length, ID3D10GeometryShader **shader)
5229 {
5230 struct d3d_device *device = impl_from_ID3D10Device(iface);
5231 struct d3d_geometry_shader *object;
5232 HRESULT hr;
5233
5234 TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
5235 iface, byte_code, byte_code_length, shader);
5236
5237 if (FAILED(hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
5238 NULL, 0, NULL, 0, 0, &object)))
5239 return hr;
5240
5241 *shader = &object->ID3D10GeometryShader_iface;
5242
5243 return S_OK;
5244 }
5245
5246 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateGeometryShaderWithStreamOutput(ID3D10Device1 *iface,
5247 const void *byte_code, SIZE_T byte_code_length, const D3D10_SO_DECLARATION_ENTRY *output_stream_decls,
5248 UINT output_stream_decl_count, UINT output_stream_stride, ID3D10GeometryShader **shader)
5249 {
5250 struct d3d_device *device = impl_from_ID3D10Device(iface);
5251 D3D11_SO_DECLARATION_ENTRY *so_entries = NULL;
5252 struct d3d_geometry_shader *object;
5253 unsigned int i, stride_count = 1;
5254 HRESULT hr;
5255
5256 TRACE("iface %p, byte_code %p, byte_code_length %lu, output_stream_decls %p, "
5257 "output_stream_decl_count %u, output_stream_stride %u, shader %p.\n",
5258 iface, byte_code, byte_code_length, output_stream_decls,
5259 output_stream_decl_count, output_stream_stride, shader);
5260
5261 if (!output_stream_decl_count && output_stream_stride)
5262 {
5263 WARN("Stride must be 0 when declaration entry count is 0.\n");
5264 *shader = NULL;
5265 return E_INVALIDARG;
5266 }
5267
5268 if (output_stream_decl_count
5269 && !(so_entries = d3d11_calloc(output_stream_decl_count, sizeof(*so_entries))))
5270 {
5271 ERR("Failed to allocate D3D11 SO declaration array memory.\n");
5272 *shader = NULL;
5273 return E_OUTOFMEMORY;
5274 }
5275
5276 for (i = 0; i < output_stream_decl_count; ++i)
5277 {
5278 so_entries[i].Stream = 0;
5279 so_entries[i].SemanticName = output_stream_decls[i].SemanticName;
5280 so_entries[i].SemanticIndex = output_stream_decls[i].SemanticIndex;
5281 so_entries[i].StartComponent = output_stream_decls[i].StartComponent;
5282 so_entries[i].ComponentCount = output_stream_decls[i].ComponentCount;
5283 so_entries[i].OutputSlot = output_stream_decls[i].OutputSlot;
5284
5285 if (output_stream_decls[i].OutputSlot)
5286 {
5287 stride_count = 0;
5288 if (output_stream_stride)
5289 {
5290 WARN("Stride must be 0 when multiple output slots are used.\n");
5291 HeapFree(GetProcessHeap(), 0, so_entries);
5292 *shader = NULL;
5293 return E_INVALIDARG;
5294 }
5295 }
5296 }
5297
5298 hr = d3d_geometry_shader_create(device, byte_code, byte_code_length,
5299 so_entries, output_stream_decl_count, &output_stream_stride, stride_count, 0, &object);
5300 HeapFree(GetProcessHeap(), 0, so_entries);
5301 if (FAILED(hr))
5302 {
5303 *shader = NULL;
5304 return hr;
5305 }
5306
5307 *shader = &object->ID3D10GeometryShader_iface;
5308
5309 return hr;
5310 }
5311
5312 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePixelShader(ID3D10Device1 *iface,
5313 const void *byte_code, SIZE_T byte_code_length, ID3D10PixelShader **shader)
5314 {
5315 struct d3d_device *device = impl_from_ID3D10Device(iface);
5316 struct d3d_pixel_shader *object;
5317 HRESULT hr;
5318
5319 TRACE("iface %p, byte_code %p, byte_code_length %lu, shader %p.\n",
5320 iface, byte_code, byte_code_length, shader);
5321
5322 if (FAILED(hr = d3d_pixel_shader_create(device, byte_code, byte_code_length, &object)))
5323 return hr;
5324
5325 *shader = &object->ID3D10PixelShader_iface;
5326
5327 return S_OK;
5328 }
5329
5330 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState1(ID3D10Device1 *iface,
5331 const D3D10_BLEND_DESC1 *desc, ID3D10BlendState1 **blend_state)
5332 {
5333 struct d3d_device *device = impl_from_ID3D10Device(iface);
5334 ID3D11BlendState *d3d11_blend_state;
5335 HRESULT hr;
5336
5337 TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
5338
5339 if (FAILED(hr = d3d11_device_CreateBlendState(&device->ID3D11Device_iface, (D3D11_BLEND_DESC *)desc,
5340 &d3d11_blend_state)))
5341 return hr;
5342
5343 hr = ID3D11BlendState_QueryInterface(d3d11_blend_state, &IID_ID3D10BlendState1, (void **)blend_state);
5344 ID3D11BlendState_Release(d3d11_blend_state);
5345 return hr;
5346 }
5347
5348 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateBlendState(ID3D10Device1 *iface,
5349 const D3D10_BLEND_DESC *desc, ID3D10BlendState **blend_state)
5350 {
5351 D3D10_BLEND_DESC1 d3d10_1_desc;
5352 unsigned int i;
5353
5354 TRACE("iface %p, desc %p, blend_state %p.\n", iface, desc, blend_state);
5355
5356 if (!desc)
5357 return E_INVALIDARG;
5358
5359 d3d10_1_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
5360 d3d10_1_desc.IndependentBlendEnable = FALSE;
5361 for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT - 1; ++i)
5362 {
5363 if (desc->BlendEnable[i] != desc->BlendEnable[i + 1]
5364 || desc->RenderTargetWriteMask[i] != desc->RenderTargetWriteMask[i + 1])
5365 d3d10_1_desc.IndependentBlendEnable = TRUE;
5366 }
5367
5368 for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
5369 {
5370 d3d10_1_desc.RenderTarget[i].BlendEnable = desc->BlendEnable[i];
5371 d3d10_1_desc.RenderTarget[i].SrcBlend = desc->SrcBlend;
5372 d3d10_1_desc.RenderTarget[i].DestBlend = desc->DestBlend;
5373 d3d10_1_desc.RenderTarget[i].BlendOp = desc->BlendOp;
5374 d3d10_1_desc.RenderTarget[i].SrcBlendAlpha = desc->SrcBlendAlpha;
5375 d3d10_1_desc.RenderTarget[i].DestBlendAlpha = desc->DestBlendAlpha;
5376 d3d10_1_desc.RenderTarget[i].BlendOpAlpha = desc->BlendOpAlpha;
5377 d3d10_1_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTargetWriteMask[i];
5378 }
5379
5380 return d3d10_device_CreateBlendState1(iface, &d3d10_1_desc, (ID3D10BlendState1 **)blend_state);
5381 }
5382
5383 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateDepthStencilState(ID3D10Device1 *iface,
5384 const D3D10_DEPTH_STENCIL_DESC *desc, ID3D10DepthStencilState **depth_stencil_state)
5385 {
5386 struct d3d_device *device = impl_from_ID3D10Device(iface);
5387 ID3D11DepthStencilState *d3d11_depth_stencil_state;
5388 HRESULT hr;
5389
5390 TRACE("iface %p, desc %p, depth_stencil_state %p.\n", iface, desc, depth_stencil_state);
5391
5392 if (FAILED(hr = d3d11_device_CreateDepthStencilState(&device->ID3D11Device_iface,
5393 (const D3D11_DEPTH_STENCIL_DESC *)desc, &d3d11_depth_stencil_state)))
5394 return hr;
5395
5396 hr = ID3D11DepthStencilState_QueryInterface(d3d11_depth_stencil_state, &IID_ID3D10DepthStencilState,
5397 (void **)depth_stencil_state);
5398 ID3D11DepthStencilState_Release(d3d11_depth_stencil_state);
5399 return hr;
5400 }
5401
5402 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device1 *iface,
5403 const D3D10_RASTERIZER_DESC *desc, ID3D10RasterizerState **rasterizer_state)
5404 {
5405 struct d3d_device *device = impl_from_ID3D10Device(iface);
5406 ID3D11RasterizerState *d3d11_rasterizer_state;
5407 HRESULT hr;
5408
5409 TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
5410
5411 if (FAILED(hr = d3d11_device_CreateRasterizerState(&device->ID3D11Device_iface,
5412 (const D3D11_RASTERIZER_DESC *)desc, &d3d11_rasterizer_state)))
5413 return hr;
5414
5415 hr = ID3D11RasterizerState_QueryInterface(d3d11_rasterizer_state,
5416 &IID_ID3D10RasterizerState, (void **)rasterizer_state);
5417 ID3D11RasterizerState_Release(d3d11_rasterizer_state);
5418 return hr;
5419 }
5420
5421 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateSamplerState(ID3D10Device1 *iface,
5422 const D3D10_SAMPLER_DESC *desc, ID3D10SamplerState **sampler_state)
5423 {
5424 struct d3d_device *device = impl_from_ID3D10Device(iface);
5425 ID3D11SamplerState *d3d11_sampler_state;
5426 HRESULT hr;
5427
5428 TRACE("iface %p, desc %p, sampler_state %p.\n", iface, desc, sampler_state);
5429
5430 if (FAILED(hr = d3d11_device_CreateSamplerState(&device->ID3D11Device_iface,
5431 (const D3D11_SAMPLER_DESC *)desc, &d3d11_sampler_state)))
5432 return hr;
5433
5434 hr = ID3D11SamplerState_QueryInterface(d3d11_sampler_state, &IID_ID3D10SamplerState, (void **)sampler_state);
5435 ID3D11SamplerState_Release(d3d11_sampler_state);
5436 return hr;
5437 }
5438
5439 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateQuery(ID3D10Device1 *iface,
5440 const D3D10_QUERY_DESC *desc, ID3D10Query **query)
5441 {
5442 struct d3d_device *device = impl_from_ID3D10Device(iface);
5443 struct d3d_query *object;
5444 HRESULT hr;
5445
5446 TRACE("iface %p, desc %p, query %p.\n", iface, desc, query);
5447
5448 if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, FALSE, &object)))
5449 return hr;
5450
5451 if (query)
5452 {
5453 *query = &object->ID3D10Query_iface;
5454 return S_OK;
5455 }
5456
5457 ID3D10Query_Release(&object->ID3D10Query_iface);
5458 return S_FALSE;
5459 }
5460
5461 static HRESULT STDMETHODCALLTYPE d3d10_device_CreatePredicate(ID3D10Device1 *iface,
5462 const D3D10_QUERY_DESC *desc, ID3D10Predicate **predicate)
5463 {
5464 struct d3d_device *device = impl_from_ID3D10Device(iface);
5465 struct d3d_query *object;
5466 HRESULT hr;
5467
5468 TRACE("iface %p, desc %p, predicate %p.\n", iface, desc, predicate);
5469
5470 if (FAILED(hr = d3d_query_create(device, (const D3D11_QUERY_DESC *)desc, TRUE, &object)))
5471 return hr;
5472
5473 if (predicate)
5474 {
5475 *predicate = (ID3D10Predicate *)&object->ID3D10Query_iface;
5476 return S_OK;
5477 }
5478
5479 ID3D10Query_Release(&object->ID3D10Query_iface);
5480 return S_FALSE;
5481 }
5482
5483 static HRESULT STDMETHODCALLTYPE d3d10_device_CreateCounter(ID3D10Device1 *iface,
5484 const D3D10_COUNTER_DESC *desc, ID3D10Counter **counter)
5485 {
5486 FIXME("iface %p, desc %p, counter %p stub!\n", iface, desc, counter);
5487
5488 return E_NOTIMPL;
5489 }
5490
5491 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckFormatSupport(ID3D10Device1 *iface,
5492 DXGI_FORMAT format, UINT *format_support)
5493 {
5494 FIXME("iface %p, format %s, format_support %p stub!\n",
5495 iface, debug_dxgi_format(format), format_support);
5496
5497 return E_NOTIMPL;
5498 }
5499
5500 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckMultisampleQualityLevels(ID3D10Device1 *iface,
5501 DXGI_FORMAT format, UINT sample_count, UINT *quality_level_count)
5502 {
5503 struct d3d_device *device = impl_from_ID3D10Device(iface);
5504
5505 TRACE("iface %p, format %s, sample_count %u, quality_level_count %p.\n",
5506 iface, debug_dxgi_format(format), sample_count, quality_level_count);
5507
5508 return d3d11_device_CheckMultisampleQualityLevels(&device->ID3D11Device_iface, format,
5509 sample_count, quality_level_count);
5510 }
5511
5512 static void STDMETHODCALLTYPE d3d10_device_CheckCounterInfo(ID3D10Device1 *iface, D3D10_COUNTER_INFO *counter_info)
5513 {
5514 FIXME("iface %p, counter_info %p stub!\n", iface, counter_info);
5515 }
5516
5517 static HRESULT STDMETHODCALLTYPE d3d10_device_CheckCounter(ID3D10Device1 *iface,
5518 const D3D10_COUNTER_DESC *desc, D3D10_COUNTER_TYPE *type, UINT *active_counters, char *name,
5519 UINT *name_length, char *units, UINT *units_length, char *description, UINT *description_length)
5520 {
5521 FIXME("iface %p, desc %p, type %p, active_counters %p, name %p, name_length %p, "
5522 "units %p, units_length %p, description %p, description_length %p stub!\n",
5523 iface, desc, type, active_counters, name, name_length,
5524 units, units_length, description, description_length);
5525
5526 return E_NOTIMPL;
5527 }
5528
5529 static UINT STDMETHODCALLTYPE d3d10_device_GetCreationFlags(ID3D10Device1 *iface)
5530 {
5531 FIXME("iface %p stub!\n", iface);
5532
5533 return 0;
5534 }
5535
5536 static HRESULT STDMETHODCALLTYPE d3d10_device_OpenSharedResource(ID3D10Device1 *iface,
5537 HANDLE resource_handle, REFIID guid, void **resource)
5538 {
5539 FIXME("iface %p, resource_handle %p, guid %s, resource %p stub!\n",
5540 iface, resource_handle, debugstr_guid(guid), resource);
5541
5542 return E_NOTIMPL;
5543 }
5544
5545 static void STDMETHODCALLTYPE d3d10_device_SetTextFilterSize(ID3D10Device1 *iface, UINT width, UINT height)
5546 {
5547 FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
5548 }
5549
5550 static void STDMETHODCALLTYPE d3d10_device_GetTextFilterSize(ID3D10Device1 *iface, UINT *width, UINT *height)
5551 {
5552 FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
5553 }
5554
5555 static D3D10_FEATURE_LEVEL1 STDMETHODCALLTYPE d3d10_device_GetFeatureLevel(ID3D10Device1 *iface)
5556 {
5557 struct d3d_device *device = impl_from_ID3D10Device(iface);
5558
5559 TRACE("iface %p.\n", iface);
5560
5561 return device->feature_level;
5562 }
5563
5564 static const struct ID3D10Device1Vtbl d3d10_device1_vtbl =
5565 {
5566 /* IUnknown methods */
5567 d3d10_device_QueryInterface,
5568 d3d10_device_AddRef,
5569 d3d10_device_Release,
5570 /* ID3D10Device methods */
5571 d3d10_device_VSSetConstantBuffers,
5572 d3d10_device_PSSetShaderResources,
5573 d3d10_device_PSSetShader,
5574 d3d10_device_PSSetSamplers,
5575 d3d10_device_VSSetShader,
5576 d3d10_device_DrawIndexed,
5577 d3d10_device_Draw,
5578 d3d10_device_PSSetConstantBuffers,
5579 d3d10_device_IASetInputLayout,
5580 d3d10_device_IASetVertexBuffers,
5581 d3d10_device_IASetIndexBuffer,
5582 d3d10_device_DrawIndexedInstanced,
5583 d3d10_device_DrawInstanced,
5584 d3d10_device_GSSetConstantBuffers,
5585 d3d10_device_GSSetShader,
5586 d3d10_device_IASetPrimitiveTopology,
5587 d3d10_device_VSSetShaderResources,
5588 d3d10_device_VSSetSamplers,
5589 d3d10_device_SetPredication,
5590 d3d10_device_GSSetShaderResources,
5591 d3d10_device_GSSetSamplers,
5592 d3d10_device_OMSetRenderTargets,
5593 d3d10_device_OMSetBlendState,
5594 d3d10_device_OMSetDepthStencilState,
5595 d3d10_device_SOSetTargets,
5596 d3d10_device_DrawAuto,
5597 d3d10_device_RSSetState,
5598 d3d10_device_RSSetViewports,
5599 d3d10_device_RSSetScissorRects,
5600 d3d10_device_CopySubresourceRegion,
5601 d3d10_device_CopyResource,
5602 d3d10_device_UpdateSubresource,
5603 d3d10_device_ClearRenderTargetView,
5604 d3d10_device_ClearDepthStencilView,
5605 d3d10_device_GenerateMips,
5606 d3d10_device_ResolveSubresource,
5607 d3d10_device_VSGetConstantBuffers,
5608 d3d10_device_PSGetShaderResources,
5609 d3d10_device_PSGetShader,
5610 d3d10_device_PSGetSamplers,
5611 d3d10_device_VSGetShader,
5612 d3d10_device_PSGetConstantBuffers,
5613 d3d10_device_IAGetInputLayout,
5614 d3d10_device_IAGetVertexBuffers,
5615 d3d10_device_IAGetIndexBuffer,
5616 d3d10_device_GSGetConstantBuffers,
5617 d3d10_device_GSGetShader,
5618 d3d10_device_IAGetPrimitiveTopology,
5619 d3d10_device_VSGetShaderResources,
5620 d3d10_device_VSGetSamplers,
5621 d3d10_device_GetPredication,
5622 d3d10_device_GSGetShaderResources,
5623 d3d10_device_GSGetSamplers,
5624 d3d10_device_OMGetRenderTargets,
5625 d3d10_device_OMGetBlendState,
5626 d3d10_device_OMGetDepthStencilState,
5627 d3d10_device_SOGetTargets,
5628 d3d10_device_RSGetState,
5629 d3d10_device_RSGetViewports,
5630 d3d10_device_RSGetScissorRects,
5631 d3d10_device_GetDeviceRemovedReason,
5632 d3d10_device_SetExceptionMode,
5633 d3d10_device_GetExceptionMode,
5634 d3d10_device_GetPrivateData,
5635 d3d10_device_SetPrivateData,
5636 d3d10_device_SetPrivateDataInterface,
5637 d3d10_device_ClearState,
5638 d3d10_device_Flush,
5639 d3d10_device_CreateBuffer,
5640 d3d10_device_CreateTexture1D,
5641 d3d10_device_CreateTexture2D,
5642 d3d10_device_CreateTexture3D,
5643 d3d10_device_CreateShaderResourceView,
5644 d3d10_device_CreateRenderTargetView,
5645 d3d10_device_CreateDepthStencilView,
5646 d3d10_device_CreateInputLayout,
5647 d3d10_device_CreateVertexShader,
5648 d3d10_device_CreateGeometryShader,
5649 d3d10_device_CreateGeometryShaderWithStreamOutput,
5650 d3d10_device_CreatePixelShader,
5651 d3d10_device_CreateBlendState,
5652 d3d10_device_CreateDepthStencilState,
5653 d3d10_device_CreateRasterizerState,
5654 d3d10_device_CreateSamplerState,
5655 d3d10_device_CreateQuery,
5656 d3d10_device_CreatePredicate,
5657 d3d10_device_CreateCounter,
5658 d3d10_device_CheckFormatSupport,
5659 d3d10_device_CheckMultisampleQualityLevels,
5660 d3d10_device_CheckCounterInfo,
5661 d3d10_device_CheckCounter,
5662 d3d10_device_GetCreationFlags,
5663 d3d10_device_OpenSharedResource,
5664 d3d10_device_SetTextFilterSize,
5665 d3d10_device_GetTextFilterSize,
5666 d3d10_device_CreateShaderResourceView1,
5667 d3d10_device_CreateBlendState1,
5668 d3d10_device_GetFeatureLevel,
5669 };
5670
5671 static const struct IUnknownVtbl d3d_device_inner_unknown_vtbl =
5672 {
5673 /* IUnknown methods */
5674 d3d_device_inner_QueryInterface,
5675 d3d_device_inner_AddRef,
5676 d3d_device_inner_Release,
5677 };
5678
5679 /* ID3D10Multithread methods */
5680
5681 static inline struct d3d_device *impl_from_ID3D10Multithread(ID3D10Multithread *iface)
5682 {
5683 return CONTAINING_RECORD(iface, struct d3d_device, ID3D10Multithread_iface);
5684 }
5685
5686 static HRESULT STDMETHODCALLTYPE d3d10_multithread_QueryInterface(ID3D10Multithread *iface, REFIID iid, void **out)
5687 {
5688 struct d3d_device *device = impl_from_ID3D10Multithread(iface);
5689
5690 TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
5691
5692 return IUnknown_QueryInterface(device->outer_unk, iid, out);
5693 }
5694
5695 static ULONG STDMETHODCALLTYPE d3d10_multithread_AddRef(ID3D10Multithread *iface)
5696 {
5697 struct d3d_device *device = impl_from_ID3D10Multithread(iface);
5698
5699 TRACE("iface %p.\n", iface);
5700
5701 return IUnknown_AddRef(device->outer_unk);
5702 }
5703
5704 static ULONG STDMETHODCALLTYPE d3d10_multithread_Release(ID3D10Multithread *iface)
5705 {
5706 struct d3d_device *device = impl_from_ID3D10Multithread(iface);
5707
5708 TRACE("iface %p.\n", iface);
5709
5710 return IUnknown_Release(device->outer_unk);
5711 }
5712
5713 static void STDMETHODCALLTYPE d3d10_multithread_Enter(ID3D10Multithread *iface)
5714 {
5715 TRACE("iface %p.\n", iface);
5716
5717 wined3d_mutex_lock();
5718 }
5719
5720 static void STDMETHODCALLTYPE d3d10_multithread_Leave(ID3D10Multithread *iface)
5721 {
5722 TRACE("iface %p.\n", iface);
5723
5724 wined3d_mutex_unlock();
5725 }
5726
5727 static BOOL STDMETHODCALLTYPE d3d10_multithread_SetMultithreadProtected(ID3D10Multithread *iface, BOOL protect)
5728 {
5729 FIXME("iface %p, protect %#x stub!\n", iface, protect);
5730
5731 return TRUE;
5732 }
5733
5734 static BOOL STDMETHODCALLTYPE d3d10_multithread_GetMultithreadProtected(ID3D10Multithread *iface)
5735 {
5736 FIXME("iface %p stub!\n", iface);
5737
5738 return TRUE;
5739 }
5740
5741 static const struct ID3D10MultithreadVtbl d3d10_multithread_vtbl =
5742 {
5743 d3d10_multithread_QueryInterface,
5744 d3d10_multithread_AddRef,
5745 d3d10_multithread_Release,
5746 d3d10_multithread_Enter,
5747 d3d10_multithread_Leave,
5748 d3d10_multithread_SetMultithreadProtected,
5749 d3d10_multithread_GetMultithreadProtected,
5750 };
5751
5752 /* IWineDXGIDeviceParent IUnknown methods */
5753
5754 static inline struct d3d_device *device_from_dxgi_device_parent(IWineDXGIDeviceParent *iface)
5755 {
5756 return CONTAINING_RECORD(iface, struct d3d_device, IWineDXGIDeviceParent_iface);
5757 }
5758
5759 static HRESULT STDMETHODCALLTYPE dxgi_device_parent_QueryInterface(IWineDXGIDeviceParent *iface,
5760 REFIID riid, void **ppv)
5761 {
5762 struct d3d_device *device = device_from_dxgi_device_parent(iface);
5763 return IUnknown_QueryInterface(device->outer_unk, riid, ppv);
5764 }
5765
5766 static ULONG STDMETHODCALLTYPE dxgi_device_parent_AddRef(IWineDXGIDeviceParent *iface)
5767 {
5768 struct d3d_device *device = device_from_dxgi_device_parent(iface);
5769 return IUnknown_AddRef(device->outer_unk);
5770 }
5771
5772 static ULONG STDMETHODCALLTYPE dxgi_device_parent_Release(IWineDXGIDeviceParent *iface)
5773 {
5774 struct d3d_device *device = device_from_dxgi_device_parent(iface);
5775 return IUnknown_Release(device->outer_unk);
5776 }
5777
5778 static struct wined3d_device_parent * STDMETHODCALLTYPE dxgi_device_parent_get_wined3d_device_parent(
5779 IWineDXGIDeviceParent *iface)
5780 {
5781 struct d3d_device *device = device_from_dxgi_device_parent(iface);
5782 return &device->device_parent;
5783 }
5784
5785 static const struct IWineDXGIDeviceParentVtbl d3d_dxgi_device_parent_vtbl =
5786 {
5787 /* IUnknown methods */
5788 dxgi_device_parent_QueryInterface,
5789 dxgi_device_parent_AddRef,
5790 dxgi_device_parent_Release,
5791 /* IWineDXGIDeviceParent methods */
5792 dxgi_device_parent_get_wined3d_device_parent,
5793 };
5794
5795 static inline struct d3d_device *device_from_wined3d_device_parent(struct wined3d_device_parent *device_parent)
5796 {
5797 return CONTAINING_RECORD(device_parent, struct d3d_device, device_parent);
5798 }
5799
5800 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
5801 struct wined3d_device *wined3d_device)
5802 {
5803 struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
5804
5805 TRACE("device_parent %p, wined3d_device %p.\n", device_parent, wined3d_device);
5806
5807 wined3d_device_incref(wined3d_device);
5808 device->wined3d_device = wined3d_device;
5809 }
5810
5811 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
5812 {
5813 TRACE("device_parent %p.\n", device_parent);
5814 }
5815
5816 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
5817 {
5818 TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
5819 }
5820
5821 static HRESULT CDECL device_parent_sub_resource_created(struct wined3d_device_parent *device_parent,
5822 struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, void **parent,
5823 const struct wined3d_parent_ops **parent_ops)
5824 {
5825 TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
5826 device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
5827
5828 *parent = NULL;
5829 *parent_ops = &d3d_null_wined3d_parent_ops;
5830
5831 return S_OK;
5832 }
5833
5834 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
5835 void *container_parent, const struct wined3d_resource_desc *wined3d_desc, DWORD texture_flags,
5836 struct wined3d_texture **wined3d_texture)
5837 {
5838 struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
5839 struct d3d_texture2d *texture;
5840 ID3D10Texture2D *texture_iface;
5841 D3D10_TEXTURE2D_DESC desc;
5842 HRESULT hr;
5843
5844 FIXME("device_parent %p, container_parent %p, wined3d_desc %p, texture flags %#x, "
5845 "wined3d_texture %p partial stub!\n", device_parent, container_parent,
5846 wined3d_desc, texture_flags, wined3d_texture);
5847
5848 FIXME("Implement DXGI<->wined3d usage conversion.\n");
5849
5850 desc.Width = wined3d_desc->width;
5851 desc.Height = wined3d_desc->height;
5852 desc.MipLevels = 1;
5853 desc.ArraySize = 1;
5854 desc.Format = dxgi_format_from_wined3dformat(wined3d_desc->format);
5855 desc.SampleDesc.Count = wined3d_desc->multisample_type ? wined3d_desc->multisample_type : 1;
5856 desc.SampleDesc.Quality = wined3d_desc->multisample_quality;
5857 desc.Usage = D3D10_USAGE_DEFAULT;
5858 desc.BindFlags = D3D10_BIND_RENDER_TARGET;
5859 desc.CPUAccessFlags = 0;
5860 desc.MiscFlags = 0;
5861
5862 if (texture_flags & WINED3D_TEXTURE_CREATE_GET_DC)
5863 {
5864 desc.MiscFlags |= D3D10_RESOURCE_MISC_GDI_COMPATIBLE;
5865 texture_flags &= ~WINED3D_TEXTURE_CREATE_GET_DC;
5866 }
5867
5868 if (texture_flags)
5869 FIXME("Unhandled flags %#x.\n", texture_flags);
5870
5871 if (FAILED(hr = d3d10_device_CreateTexture2D(&device->ID3D10Device1_iface,
5872 &desc, NULL, &texture_iface)))
5873 {
5874 WARN("CreateTexture2D failed, returning %#x.\n", hr);
5875 return hr;
5876 }
5877
5878 texture = impl_from_ID3D10Texture2D(texture_iface);
5879
5880 *wined3d_texture = texture->wined3d_texture;
5881 wined3d_texture_incref(*wined3d_texture);
5882 ID3D10Texture2D_Release(&texture->ID3D10Texture2D_iface);
5883
5884 return S_OK;
5885 }
5886
5887 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
5888 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
5889 {
5890 struct d3d_device *device = device_from_wined3d_device_parent(device_parent);
5891 IWineDXGIDevice *wine_device;
5892 HRESULT hr;
5893
5894 TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
5895
5896 if (FAILED(hr = d3d10_device_QueryInterface(&device->ID3D10Device1_iface,
5897 &IID_IWineDXGIDevice, (void **)&wine_device)))
5898 {
5899 ERR("Device should implement IWineDXGIDevice.\n");
5900 return E_FAIL;
5901 }
5902
5903 hr = IWineDXGIDevice_create_swapchain(wine_device, desc, TRUE, swapchain);
5904 IWineDXGIDevice_Release(wine_device);
5905 if (FAILED(hr))
5906 {
5907 ERR("Failed to create DXGI swapchain, returning %#x\n", hr);
5908 return hr;
5909 }
5910
5911 return S_OK;
5912 }
5913
5914 static const struct wined3d_device_parent_ops d3d_wined3d_device_parent_ops =
5915 {
5916 device_parent_wined3d_device_created,
5917 device_parent_mode_changed,
5918 device_parent_activate,
5919 device_parent_sub_resource_created,
5920 device_parent_sub_resource_created,
5921 device_parent_create_swapchain_texture,
5922 device_parent_create_swapchain,
5923 };
5924
5925 static int d3d_sampler_state_compare(const void *key, const struct wine_rb_entry *entry)
5926 {
5927 const D3D11_SAMPLER_DESC *ka = key;
5928 const D3D11_SAMPLER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_sampler_state, entry)->desc;
5929
5930 return memcmp(ka, kb, sizeof(*ka));
5931 }
5932
5933 static int d3d_blend_state_compare(const void *key, const struct wine_rb_entry *entry)
5934 {
5935 const D3D11_BLEND_DESC *ka = key;
5936 const D3D11_BLEND_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_blend_state, entry)->desc;
5937
5938 return memcmp(ka, kb, sizeof(*ka));
5939 }
5940
5941 static int d3d_depthstencil_state_compare(const void *key, const struct wine_rb_entry *entry)
5942 {
5943 const D3D11_DEPTH_STENCIL_DESC *ka = key;
5944 const D3D11_DEPTH_STENCIL_DESC *kb = &WINE_RB_ENTRY_VALUE(entry,
5945 const struct d3d_depthstencil_state, entry)->desc;
5946
5947 return memcmp(ka, kb, sizeof(*ka));
5948 }
5949
5950 static int d3d_rasterizer_state_compare(const void *key, const struct wine_rb_entry *entry)
5951 {
5952 const D3D11_RASTERIZER_DESC *ka = key;
5953 const D3D11_RASTERIZER_DESC *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_rasterizer_state, entry)->desc;
5954
5955 return memcmp(ka, kb, sizeof(*ka));
5956 }
5957
5958 void d3d_device_init(struct d3d_device *device, void *outer_unknown)
5959 {
5960 device->IUnknown_inner.lpVtbl = &d3d_device_inner_unknown_vtbl;
5961 device->ID3D11Device_iface.lpVtbl = &d3d11_device_vtbl;
5962 device->ID3D10Device1_iface.lpVtbl = &d3d10_device1_vtbl;
5963 device->ID3D10Multithread_iface.lpVtbl = &d3d10_multithread_vtbl;
5964 device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d_dxgi_device_parent_vtbl;
5965 device->device_parent.ops = &d3d_wined3d_device_parent_ops;
5966 device->refcount = 1;
5967 /* COM aggregation always takes place */
5968 device->outer_unk = outer_unknown;
5969
5970 d3d11_immediate_context_init(&device->immediate_context, device);
5971 ID3D11DeviceContext_Release(&device->immediate_context.ID3D11DeviceContext_iface);
5972
5973 device->blend_factor[0] = 1.0f;
5974 device->blend_factor[1] = 1.0f;
5975 device->blend_factor[2] = 1.0f;
5976 device->blend_factor[3] = 1.0f;
5977
5978 wine_rb_init(&device->blend_states, d3d_blend_state_compare);
5979 wine_rb_init(&device->depthstencil_states, d3d_depthstencil_state_compare);
5980 wine_rb_init(&device->rasterizer_states, d3d_rasterizer_state_compare);
5981 wine_rb_init(&device->sampler_states, d3d_sampler_state_compare);
5982 }
Windows API implementation