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