?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Invalidate sRGB write state in wined3d_cs_exec_set_rendertarget_view() if...
[wine.git] / dlls / wined3d / cs.c
blob6bf9827d3e160ca3f06683814875d73a2043b4ae
1 /*
2 * Copyright 2013 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 #include "config.h"
20 #include "wine/port.h"
21 #include "wined3d_private.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
24 WINE_DECLARE_DEBUG_CHANNEL(d3d_sync);
25 WINE_DECLARE_DEBUG_CHANNEL(fps);
26
27 #define WINED3D_INITIAL_CS_SIZE 4096
28
29 enum wined3d_cs_op
30 {
31 WINED3D_CS_OP_NOP,
32 WINED3D_CS_OP_PRESENT,
33 WINED3D_CS_OP_CLEAR,
34 WINED3D_CS_OP_DISPATCH,
35 WINED3D_CS_OP_DRAW,
36 WINED3D_CS_OP_FLUSH,
37 WINED3D_CS_OP_SET_PREDICATION,
38 WINED3D_CS_OP_SET_VIEWPORTS,
39 WINED3D_CS_OP_SET_SCISSOR_RECTS,
40 WINED3D_CS_OP_SET_RENDERTARGET_VIEW,
41 WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
42 WINED3D_CS_OP_SET_VERTEX_DECLARATION,
43 WINED3D_CS_OP_SET_STREAM_SOURCE,
44 WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
45 WINED3D_CS_OP_SET_STREAM_OUTPUT,
46 WINED3D_CS_OP_SET_INDEX_BUFFER,
47 WINED3D_CS_OP_SET_CONSTANT_BUFFER,
48 WINED3D_CS_OP_SET_TEXTURE,
49 WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW,
50 WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW,
51 WINED3D_CS_OP_SET_SAMPLER,
52 WINED3D_CS_OP_SET_SHADER,
53 WINED3D_CS_OP_SET_BLEND_STATE,
54 WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE,
55 WINED3D_CS_OP_SET_RASTERIZER_STATE,
56 WINED3D_CS_OP_SET_RENDER_STATE,
57 WINED3D_CS_OP_SET_TEXTURE_STATE,
58 WINED3D_CS_OP_SET_SAMPLER_STATE,
59 WINED3D_CS_OP_SET_TRANSFORM,
60 WINED3D_CS_OP_SET_CLIP_PLANE,
61 WINED3D_CS_OP_SET_COLOR_KEY,
62 WINED3D_CS_OP_SET_MATERIAL,
63 WINED3D_CS_OP_SET_LIGHT,
64 WINED3D_CS_OP_SET_LIGHT_ENABLE,
65 WINED3D_CS_OP_SET_FEATURE_LEVEL,
66 WINED3D_CS_OP_PUSH_CONSTANTS,
67 WINED3D_CS_OP_RESET_STATE,
68 WINED3D_CS_OP_CALLBACK,
69 WINED3D_CS_OP_QUERY_ISSUE,
70 WINED3D_CS_OP_PRELOAD_RESOURCE,
71 WINED3D_CS_OP_UNLOAD_RESOURCE,
72 WINED3D_CS_OP_MAP,
73 WINED3D_CS_OP_UNMAP,
74 WINED3D_CS_OP_BLT_SUB_RESOURCE,
75 WINED3D_CS_OP_UPDATE_SUB_RESOURCE,
76 WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION,
77 WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW,
78 WINED3D_CS_OP_COPY_UAV_COUNTER,
79 WINED3D_CS_OP_GENERATE_MIPMAPS,
80 WINED3D_CS_OP_STOP,
81 };
82
83 struct wined3d_cs_packet
84 {
85 size_t size;
86 BYTE data[1];
87 };
88
89 struct wined3d_cs_nop
90 {
91 enum wined3d_cs_op opcode;
92 };
93
94 struct wined3d_cs_present
95 {
96 enum wined3d_cs_op opcode;
97 HWND dst_window_override;
98 struct wined3d_swapchain *swapchain;
99 RECT src_rect;
100 RECT dst_rect;
101 unsigned int swap_interval;
102 DWORD flags;
103 };
104
105 struct wined3d_cs_clear
106 {
107 enum wined3d_cs_op opcode;
108 DWORD flags;
109 unsigned int rt_count;
110 struct wined3d_fb_state *fb;
111 RECT draw_rect;
112 struct wined3d_color color;
113 float depth;
114 DWORD stencil;
115 unsigned int rect_count;
116 RECT rects[1];
117 };
118
119 struct wined3d_cs_dispatch
120 {
121 enum wined3d_cs_op opcode;
122 struct wined3d_dispatch_parameters parameters;
123 };
124
125 struct wined3d_cs_draw
126 {
127 enum wined3d_cs_op opcode;
128 enum wined3d_primitive_type primitive_type;
129 GLint patch_vertex_count;
130 struct wined3d_draw_parameters parameters;
131 };
132
133 struct wined3d_cs_flush
134 {
135 enum wined3d_cs_op opcode;
136 };
137
138 struct wined3d_cs_set_predication
139 {
140 enum wined3d_cs_op opcode;
141 struct wined3d_query *predicate;
142 BOOL value;
143 };
144
145 struct wined3d_cs_set_viewports
146 {
147 enum wined3d_cs_op opcode;
148 unsigned int viewport_count;
149 struct wined3d_viewport viewports[1];
150 };
151
152 struct wined3d_cs_set_scissor_rects
153 {
154 enum wined3d_cs_op opcode;
155 unsigned int rect_count;
156 RECT rects[1];
157 };
158
159 struct wined3d_cs_set_rendertarget_view
160 {
161 enum wined3d_cs_op opcode;
162 unsigned int view_idx;
163 struct wined3d_rendertarget_view *view;
164 };
165
166 struct wined3d_cs_set_depth_stencil_view
167 {
168 enum wined3d_cs_op opcode;
169 struct wined3d_rendertarget_view *view;
170 };
171
172 struct wined3d_cs_set_vertex_declaration
173 {
174 enum wined3d_cs_op opcode;
175 struct wined3d_vertex_declaration *declaration;
176 };
177
178 struct wined3d_cs_set_stream_source
179 {
180 enum wined3d_cs_op opcode;
181 UINT stream_idx;
182 struct wined3d_buffer *buffer;
183 UINT offset;
184 UINT stride;
185 };
186
187 struct wined3d_cs_set_stream_source_freq
188 {
189 enum wined3d_cs_op opcode;
190 UINT stream_idx;
191 UINT frequency;
192 UINT flags;
193 };
194
195 struct wined3d_cs_set_stream_output
196 {
197 enum wined3d_cs_op opcode;
198 UINT stream_idx;
199 struct wined3d_buffer *buffer;
200 UINT offset;
201 };
202
203 struct wined3d_cs_set_index_buffer
204 {
205 enum wined3d_cs_op opcode;
206 struct wined3d_buffer *buffer;
207 enum wined3d_format_id format_id;
208 unsigned int offset;
209 };
210
211 struct wined3d_cs_set_constant_buffer
212 {
213 enum wined3d_cs_op opcode;
214 enum wined3d_shader_type type;
215 UINT cb_idx;
216 struct wined3d_buffer *buffer;
217 };
218
219 struct wined3d_cs_set_texture
220 {
221 enum wined3d_cs_op opcode;
222 UINT stage;
223 struct wined3d_texture *texture;
224 };
225
226 struct wined3d_cs_set_color_key
227 {
228 enum wined3d_cs_op opcode;
229 struct wined3d_texture *texture;
230 WORD flags;
231 WORD set;
232 struct wined3d_color_key color_key;
233 };
234
235 struct wined3d_cs_set_shader_resource_view
236 {
237 enum wined3d_cs_op opcode;
238 enum wined3d_shader_type type;
239 UINT view_idx;
240 struct wined3d_shader_resource_view *view;
241 };
242
243 struct wined3d_cs_set_unordered_access_view
244 {
245 enum wined3d_cs_op opcode;
246 enum wined3d_pipeline pipeline;
247 unsigned int view_idx;
248 struct wined3d_unordered_access_view *view;
249 unsigned int initial_count;
250 };
251
252 struct wined3d_cs_set_sampler
253 {
254 enum wined3d_cs_op opcode;
255 enum wined3d_shader_type type;
256 UINT sampler_idx;
257 struct wined3d_sampler *sampler;
258 };
259
260 struct wined3d_cs_set_shader
261 {
262 enum wined3d_cs_op opcode;
263 enum wined3d_shader_type type;
264 struct wined3d_shader *shader;
265 };
266
267 struct wined3d_cs_set_blend_state
268 {
269 enum wined3d_cs_op opcode;
270 struct wined3d_blend_state *state;
271 struct wined3d_color factor;
272 unsigned int sample_mask;
273 };
274
275 struct wined3d_cs_set_depth_stencil_state
276 {
277 enum wined3d_cs_op opcode;
278 struct wined3d_depth_stencil_state *state;
279 unsigned int stencil_ref;
280 };
281
282 struct wined3d_cs_set_rasterizer_state
283 {
284 enum wined3d_cs_op opcode;
285 struct wined3d_rasterizer_state *state;
286 };
287
288 struct wined3d_cs_set_render_state
289 {
290 enum wined3d_cs_op opcode;
291 enum wined3d_render_state state;
292 DWORD value;
293 };
294
295 struct wined3d_cs_set_texture_state
296 {
297 enum wined3d_cs_op opcode;
298 UINT stage;
299 enum wined3d_texture_stage_state state;
300 DWORD value;
301 };
302
303 struct wined3d_cs_set_sampler_state
304 {
305 enum wined3d_cs_op opcode;
306 UINT sampler_idx;
307 enum wined3d_sampler_state state;
308 DWORD value;
309 };
310
311 struct wined3d_cs_set_transform
312 {
313 enum wined3d_cs_op opcode;
314 enum wined3d_transform_state state;
315 struct wined3d_matrix matrix;
316 };
317
318 struct wined3d_cs_set_clip_plane
319 {
320 enum wined3d_cs_op opcode;
321 UINT plane_idx;
322 struct wined3d_vec4 plane;
323 };
324
325 struct wined3d_cs_set_material
326 {
327 enum wined3d_cs_op opcode;
328 struct wined3d_material material;
329 };
330
331 struct wined3d_cs_set_light
332 {
333 enum wined3d_cs_op opcode;
334 struct wined3d_light_info light;
335 };
336
337 struct wined3d_cs_set_light_enable
338 {
339 enum wined3d_cs_op opcode;
340 unsigned int idx;
341 BOOL enable;
342 };
343
344 struct wined3d_cs_set_feature_level
345 {
346 enum wined3d_cs_op opcode;
347 enum wined3d_feature_level level;
348 };
349
350 struct wined3d_cs_push_constants
351 {
352 enum wined3d_cs_op opcode;
353 enum wined3d_push_constants type;
354 unsigned int start_idx;
355 unsigned int count;
356 BYTE constants[1];
357 };
358
359 struct wined3d_cs_reset_state
360 {
361 enum wined3d_cs_op opcode;
362 };
363
364 struct wined3d_cs_callback
365 {
366 enum wined3d_cs_op opcode;
367 void (*callback)(void *object);
368 void *object;
369 };
370
371 struct wined3d_cs_query_issue
372 {
373 enum wined3d_cs_op opcode;
374 struct wined3d_query *query;
375 DWORD flags;
376 };
377
378 struct wined3d_cs_preload_resource
379 {
380 enum wined3d_cs_op opcode;
381 struct wined3d_resource *resource;
382 };
383
384 struct wined3d_cs_unload_resource
385 {
386 enum wined3d_cs_op opcode;
387 struct wined3d_resource *resource;
388 };
389
390 struct wined3d_cs_map
391 {
392 enum wined3d_cs_op opcode;
393 struct wined3d_resource *resource;
394 unsigned int sub_resource_idx;
395 struct wined3d_map_desc *map_desc;
396 const struct wined3d_box *box;
397 DWORD flags;
398 HRESULT *hr;
399 };
400
401 struct wined3d_cs_unmap
402 {
403 enum wined3d_cs_op opcode;
404 struct wined3d_resource *resource;
405 unsigned int sub_resource_idx;
406 HRESULT *hr;
407 };
408
409 struct wined3d_cs_blt_sub_resource
410 {
411 enum wined3d_cs_op opcode;
412 struct wined3d_resource *dst_resource;
413 unsigned int dst_sub_resource_idx;
414 struct wined3d_box dst_box;
415 struct wined3d_resource *src_resource;
416 unsigned int src_sub_resource_idx;
417 struct wined3d_box src_box;
418 DWORD flags;
419 struct wined3d_blt_fx fx;
420 enum wined3d_texture_filter_type filter;
421 };
422
423 struct wined3d_cs_update_sub_resource
424 {
425 enum wined3d_cs_op opcode;
426 struct wined3d_resource *resource;
427 unsigned int sub_resource_idx;
428 struct wined3d_box box;
429 struct wined3d_sub_resource_data data;
430 };
431
432 struct wined3d_cs_add_dirty_texture_region
433 {
434 enum wined3d_cs_op opcode;
435 struct wined3d_texture *texture;
436 unsigned int layer;
437 };
438
439 struct wined3d_cs_clear_unordered_access_view
440 {
441 enum wined3d_cs_op opcode;
442 struct wined3d_unordered_access_view *view;
443 struct wined3d_uvec4 clear_value;
444 };
445
446 struct wined3d_cs_copy_uav_counter
447 {
448 enum wined3d_cs_op opcode;
449 struct wined3d_buffer *buffer;
450 unsigned int offset;
451 struct wined3d_unordered_access_view *view;
452 };
453
454 struct wined3d_cs_generate_mipmaps
455 {
456 enum wined3d_cs_op opcode;
457 struct wined3d_shader_resource_view *view;
458 };
459
460 struct wined3d_cs_stop
461 {
462 enum wined3d_cs_op opcode;
463 };
464
465 static inline void *wined3d_device_context_require_space(struct wined3d_device_context *context,
466 size_t size, enum wined3d_cs_queue_id queue_id)
467 {
468 return context->ops->require_space(context, size, queue_id);
469 }
470
471 static inline void wined3d_device_context_submit(struct wined3d_device_context *context,
472 enum wined3d_cs_queue_id queue_id)
473 {
474 context->ops->submit(context, queue_id);
475 }
476
477 static const char *debug_cs_op(enum wined3d_cs_op op)
478 {
479 switch (op)
480 {
481 #define WINED3D_TO_STR(type) case type: return #type
482 WINED3D_TO_STR(WINED3D_CS_OP_NOP);
483 WINED3D_TO_STR(WINED3D_CS_OP_PRESENT);
484 WINED3D_TO_STR(WINED3D_CS_OP_CLEAR);
485 WINED3D_TO_STR(WINED3D_CS_OP_DISPATCH);
486 WINED3D_TO_STR(WINED3D_CS_OP_DRAW);
487 WINED3D_TO_STR(WINED3D_CS_OP_FLUSH);
488 WINED3D_TO_STR(WINED3D_CS_OP_SET_PREDICATION);
489 WINED3D_TO_STR(WINED3D_CS_OP_SET_VIEWPORTS);
490 WINED3D_TO_STR(WINED3D_CS_OP_SET_SCISSOR_RECTS);
491 WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDERTARGET_VIEW);
492 WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW);
493 WINED3D_TO_STR(WINED3D_CS_OP_SET_VERTEX_DECLARATION);
494 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_SOURCE);
495 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ);
496 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_OUTPUT);
497 WINED3D_TO_STR(WINED3D_CS_OP_SET_INDEX_BUFFER);
498 WINED3D_TO_STR(WINED3D_CS_OP_SET_CONSTANT_BUFFER);
499 WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE);
500 WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW);
501 WINED3D_TO_STR(WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW);
502 WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLER);
503 WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER);
504 WINED3D_TO_STR(WINED3D_CS_OP_SET_BLEND_STATE);
505 WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE);
506 WINED3D_TO_STR(WINED3D_CS_OP_SET_RASTERIZER_STATE);
507 WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDER_STATE);
508 WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE_STATE);
509 WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLER_STATE);
510 WINED3D_TO_STR(WINED3D_CS_OP_SET_TRANSFORM);
511 WINED3D_TO_STR(WINED3D_CS_OP_SET_CLIP_PLANE);
512 WINED3D_TO_STR(WINED3D_CS_OP_SET_COLOR_KEY);
513 WINED3D_TO_STR(WINED3D_CS_OP_SET_MATERIAL);
514 WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT);
515 WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT_ENABLE);
516 WINED3D_TO_STR(WINED3D_CS_OP_SET_FEATURE_LEVEL);
517 WINED3D_TO_STR(WINED3D_CS_OP_PUSH_CONSTANTS);
518 WINED3D_TO_STR(WINED3D_CS_OP_RESET_STATE);
519 WINED3D_TO_STR(WINED3D_CS_OP_CALLBACK);
520 WINED3D_TO_STR(WINED3D_CS_OP_QUERY_ISSUE);
521 WINED3D_TO_STR(WINED3D_CS_OP_PRELOAD_RESOURCE);
522 WINED3D_TO_STR(WINED3D_CS_OP_UNLOAD_RESOURCE);
523 WINED3D_TO_STR(WINED3D_CS_OP_MAP);
524 WINED3D_TO_STR(WINED3D_CS_OP_UNMAP);
525 WINED3D_TO_STR(WINED3D_CS_OP_BLT_SUB_RESOURCE);
526 WINED3D_TO_STR(WINED3D_CS_OP_UPDATE_SUB_RESOURCE);
527 WINED3D_TO_STR(WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION);
528 WINED3D_TO_STR(WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW);
529 WINED3D_TO_STR(WINED3D_CS_OP_COPY_UAV_COUNTER);
530 WINED3D_TO_STR(WINED3D_CS_OP_GENERATE_MIPMAPS);
531 WINED3D_TO_STR(WINED3D_CS_OP_STOP);
532 #undef WINED3D_TO_STR
533 }
534 return wine_dbg_sprintf("UNKNOWN_OP(%#x)", op);
535 }
536
537 static void wined3d_cs_exec_nop(struct wined3d_cs *cs, const void *data)
538 {
539 }
540
541 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
542 {
543 struct wined3d_texture *logo_texture, *cursor_texture, *back_buffer;
544 struct wined3d_rendertarget_view *dsv = cs->state.fb.depth_stencil;
545 const struct wined3d_cs_present *op = data;
546 const struct wined3d_swapchain_desc *desc;
547 struct wined3d_swapchain *swapchain;
548 unsigned int i;
549
550 swapchain = op->swapchain;
551 desc = &swapchain->state.desc;
552 back_buffer = swapchain->back_buffers[0];
553 wined3d_swapchain_set_window(swapchain, op->dst_window_override);
554
555 if ((logo_texture = swapchain->device->logo_texture))
556 {
557 RECT rect = {0, 0, logo_texture->resource.width, logo_texture->resource.height};
558
559 /* Blit the logo into the upper left corner of the back-buffer. */
560 wined3d_texture_blt(back_buffer, 0, &rect, logo_texture, 0,
561 &rect, WINED3D_BLT_SRC_CKEY, NULL, WINED3D_TEXF_POINT);
562 }
563
564 if ((cursor_texture = swapchain->device->cursor_texture)
565 && swapchain->device->bCursorVisible && !swapchain->device->hardwareCursor)
566 {
567 RECT dst_rect =
568 {
569 swapchain->device->xScreenSpace - swapchain->device->xHotSpot,
570 swapchain->device->yScreenSpace - swapchain->device->yHotSpot,
571 swapchain->device->xScreenSpace + swapchain->device->cursorWidth - swapchain->device->xHotSpot,
572 swapchain->device->yScreenSpace + swapchain->device->cursorHeight - swapchain->device->yHotSpot,
573 };
574 RECT src_rect =
575 {
576 0, 0, cursor_texture->resource.width, cursor_texture->resource.height
577 };
578 const RECT clip_rect = {0, 0, back_buffer->resource.width, back_buffer->resource.height};
579
580 TRACE("Rendering the software cursor.\n");
581
582 if (desc->windowed)
583 MapWindowPoints(NULL, swapchain->win_handle, (POINT *)&dst_rect, 2);
584 if (wined3d_clip_blit(&clip_rect, &dst_rect, &src_rect))
585 wined3d_texture_blt(back_buffer, 0, &dst_rect, cursor_texture, 0,
586 &src_rect, WINED3D_BLT_ALPHA_TEST, NULL, WINED3D_TEXF_POINT);
587 }
588
589 swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->swap_interval, op->flags);
590
591 /* Discard buffers if the swap effect allows it. */
592 back_buffer = swapchain->back_buffers[desc->backbuffer_count - 1];
593 if (desc->swap_effect == WINED3D_SWAP_EFFECT_DISCARD || desc->swap_effect == WINED3D_SWAP_EFFECT_FLIP_DISCARD)
594 wined3d_texture_validate_location(back_buffer, 0, WINED3D_LOCATION_DISCARDED);
595
596 if (dsv && dsv->resource->type != WINED3D_RTYPE_BUFFER)
597 {
598 struct wined3d_texture *ds = texture_from_resource(dsv->resource);
599
600 if ((desc->flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL || ds->flags & WINED3D_TEXTURE_DISCARD))
601 wined3d_rendertarget_view_validate_location(dsv, WINED3D_LOCATION_DISCARDED);
602 }
603
604 if (TRACE_ON(fps))
605 {
606 DWORD time = GetTickCount();
607 ++swapchain->frames;
608
609 /* every 1.5 seconds */
610 if (time - swapchain->prev_time > 1500)
611 {
612 TRACE_(fps)("%p @ approx %.2ffps\n",
613 swapchain, 1000.0 * swapchain->frames / (time - swapchain->prev_time));
614 swapchain->prev_time = time;
615 swapchain->frames = 0;
616 }
617 }
618
619 wined3d_resource_release(&swapchain->front_buffer->resource);
620 for (i = 0; i < desc->backbuffer_count; ++i)
621 {
622 wined3d_resource_release(&swapchain->back_buffers[i]->resource);
623 }
624
625 InterlockedDecrement(&cs->pending_presents);
626 }
627
628 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
629 const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override,
630 unsigned int swap_interval, DWORD flags)
631 {
632 struct wined3d_cs_present *op;
633 unsigned int i;
634 LONG pending;
635
636 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
637 op->opcode = WINED3D_CS_OP_PRESENT;
638 op->dst_window_override = dst_window_override;
639 op->swapchain = swapchain;
640 op->src_rect = *src_rect;
641 op->dst_rect = *dst_rect;
642 op->swap_interval = swap_interval;
643 op->flags = flags;
644
645 pending = InterlockedIncrement(&cs->pending_presents);
646
647 wined3d_resource_acquire(&swapchain->front_buffer->resource);
648 for (i = 0; i < swapchain->state.desc.backbuffer_count; ++i)
649 {
650 wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
651 }
652
653 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
654
655 /* Limit input latency by limiting the number of presents that we can get
656 * ahead of the worker thread. */
657 while (pending >= swapchain->max_frame_latency)
658 {
659 YieldProcessor();
660 pending = InterlockedCompareExchange(&cs->pending_presents, 0, 0);
661 }
662 }
663
664 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
665 {
666 struct wined3d_device *device = cs->c.device;
667 const struct wined3d_cs_clear *op = data;
668 unsigned int i;
669
670 device->blitter->ops->blitter_clear(device->blitter, device, op->rt_count, op->fb,
671 op->rect_count, op->rects, &op->draw_rect, op->flags, &op->color, op->depth, op->stencil);
672
673 if (op->flags & WINED3DCLEAR_TARGET)
674 {
675 for (i = 0; i < op->rt_count; ++i)
676 {
677 if (op->fb->render_targets[i])
678 wined3d_resource_release(op->fb->render_targets[i]->resource);
679 }
680 }
681 if (op->flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
682 wined3d_resource_release(op->fb->depth_stencil->resource);
683 }
684
685 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
686 DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
687 {
688 const struct wined3d_state *state = cs->c.state;
689 const struct wined3d_viewport *vp = &state->viewports[0];
690 struct wined3d_rendertarget_view *view;
691 struct wined3d_cs_clear *op;
692 unsigned int rt_count, i;
693
694 rt_count = flags & WINED3DCLEAR_TARGET ? cs->c.device->adapter->d3d_info.limits.max_rt_count : 0;
695
696 op = wined3d_device_context_require_space(&cs->c, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]),
697 WINED3D_CS_QUEUE_DEFAULT);
698 op->opcode = WINED3D_CS_OP_CLEAR;
699 op->flags = flags & (WINED3DCLEAR_TARGET | WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL);
700 op->rt_count = rt_count;
701 op->fb = &cs->state.fb;
702 SetRect(&op->draw_rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
703 if (state->rasterizer_state && state->rasterizer_state->desc.scissor)
704 IntersectRect(&op->draw_rect, &op->draw_rect, &state->scissor_rects[0]);
705 op->color = *color;
706 op->depth = depth;
707 op->stencil = stencil;
708 op->rect_count = rect_count;
709 memcpy(op->rects, rects, sizeof(*rects) * rect_count);
710
711 for (i = 0; i < rt_count; ++i)
712 {
713 if ((view = state->fb.render_targets[i]))
714 wined3d_resource_acquire(view->resource);
715 }
716 if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
717 {
718 view = state->fb.depth_stencil;
719 wined3d_resource_acquire(view->resource);
720 }
721
722 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
723 }
724
725 void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view,
726 const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
727 {
728 struct wined3d_cs_clear *op;
729 size_t size;
730
731 size = FIELD_OFFSET(struct wined3d_cs_clear, rects[1]) + sizeof(struct wined3d_fb_state);
732 op = wined3d_device_context_require_space(&cs->c, size, WINED3D_CS_QUEUE_DEFAULT);
733 op->fb = (void *)&op->rects[1];
734
735 op->opcode = WINED3D_CS_OP_CLEAR;
736 op->flags = flags & (WINED3DCLEAR_TARGET | WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL);
737 if (flags & WINED3DCLEAR_TARGET)
738 {
739 op->rt_count = 1;
740 op->fb->render_targets[0] = view;
741 op->fb->depth_stencil = NULL;
742 op->color = *color;
743 }
744 else
745 {
746 op->rt_count = 0;
747 op->fb->render_targets[0] = NULL;
748 op->fb->depth_stencil = view;
749 op->depth = depth;
750 op->stencil = stencil;
751 }
752 SetRect(&op->draw_rect, 0, 0, view->width, view->height);
753 op->rect_count = 1;
754 op->rects[0] = *rect;
755
756 wined3d_resource_acquire(view->resource);
757
758 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
759 if (flags & WINED3DCLEAR_SYNCHRONOUS)
760 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
761 }
762
763 static void acquire_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
764 {
765 struct wined3d_shader_sampler_map_entry *entry;
766 struct wined3d_shader_resource_view *view;
767 struct wined3d_shader *shader;
768 unsigned int i, j;
769
770 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
771 {
772 if (!(shader_mask & (1u << i)))
773 continue;
774
775 if (!(shader = state->shader[i]))
776 continue;
777
778 for (j = 0; j < WINED3D_MAX_CBS; ++j)
779 {
780 if (state->cb[i][j])
781 wined3d_resource_acquire(&state->cb[i][j]->resource);
782 }
783
784 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
785 {
786 entry = &shader->reg_maps.sampler_map.entries[j];
787
788 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
789 continue;
790
791 wined3d_resource_acquire(view->resource);
792 }
793 }
794 }
795
796 static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
797 {
798 struct wined3d_shader_sampler_map_entry *entry;
799 struct wined3d_shader_resource_view *view;
800 struct wined3d_shader *shader;
801 unsigned int i, j;
802
803 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
804 {
805 if (!(shader_mask & (1u << i)))
806 continue;
807
808 if (!(shader = state->shader[i]))
809 continue;
810
811 for (j = 0; j < WINED3D_MAX_CBS; ++j)
812 {
813 if (state->cb[i][j])
814 wined3d_resource_release(&state->cb[i][j]->resource);
815 }
816
817 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
818 {
819 entry = &shader->reg_maps.sampler_map.entries[j];
820
821 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
822 continue;
823
824 wined3d_resource_release(view->resource);
825 }
826 }
827 }
828
829 static void acquire_unordered_access_resources(const struct wined3d_shader *shader,
830 struct wined3d_unordered_access_view * const *views)
831 {
832 unsigned int i;
833
834 if (!shader)
835 return;
836
837 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
838 {
839 if (!shader->reg_maps.uav_resource_info[i].type)
840 continue;
841
842 if (!views[i])
843 continue;
844
845 wined3d_resource_acquire(views[i]->resource);
846 }
847 }
848
849 static void release_unordered_access_resources(const struct wined3d_shader *shader,
850 struct wined3d_unordered_access_view * const *views)
851 {
852 unsigned int i;
853
854 if (!shader)
855 return;
856
857 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
858 {
859 if (!shader->reg_maps.uav_resource_info[i].type)
860 continue;
861
862 if (!views[i])
863 continue;
864
865 wined3d_resource_release(views[i]->resource);
866 }
867 }
868
869 static void wined3d_cs_exec_dispatch(struct wined3d_cs *cs, const void *data)
870 {
871 const struct wined3d_cs_dispatch *op = data;
872 struct wined3d_state *state = &cs->state;
873
874 if (!state->shader[WINED3D_SHADER_TYPE_COMPUTE])
875 WARN("No compute shader bound, skipping dispatch.\n");
876 else
877 cs->c.device->adapter->adapter_ops->adapter_dispatch_compute(cs->c.device, state, &op->parameters);
878
879 if (op->parameters.indirect)
880 wined3d_resource_release(&op->parameters.u.indirect.buffer->resource);
881
882 release_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
883 release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
884 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
885 }
886
887 static void acquire_compute_pipeline_resources(const struct wined3d_state *state)
888 {
889 acquire_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
890 acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
891 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
892 }
893
894 void wined3d_cs_emit_dispatch(struct wined3d_cs *cs,
895 unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
896 {
897 const struct wined3d_state *state = cs->c.state;
898 struct wined3d_cs_dispatch *op;
899
900 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
901 op->opcode = WINED3D_CS_OP_DISPATCH;
902 op->parameters.indirect = FALSE;
903 op->parameters.u.direct.group_count_x = group_count_x;
904 op->parameters.u.direct.group_count_y = group_count_y;
905 op->parameters.u.direct.group_count_z = group_count_z;
906
907 acquire_compute_pipeline_resources(state);
908
909 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
910 }
911
912 void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs *cs,
913 struct wined3d_buffer *buffer, unsigned int offset)
914 {
915 const struct wined3d_state *state = cs->c.state;
916 struct wined3d_cs_dispatch *op;
917
918 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
919 op->opcode = WINED3D_CS_OP_DISPATCH;
920 op->parameters.indirect = TRUE;
921 op->parameters.u.indirect.buffer = buffer;
922 op->parameters.u.indirect.offset = offset;
923
924 acquire_compute_pipeline_resources(state);
925 wined3d_resource_acquire(&buffer->resource);
926
927 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
928 }
929
930 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
931 {
932 const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
933 const struct wined3d_shader *geometry_shader;
934 struct wined3d_device *device = cs->c.device;
935 int base_vertex_idx, load_base_vertex_idx;
936 struct wined3d_state *state = &cs->state;
937 const struct wined3d_cs_draw *op = data;
938 unsigned int i;
939
940 base_vertex_idx = 0;
941 if (!op->parameters.indirect)
942 {
943 const struct wined3d_direct_draw_parameters *direct = &op->parameters.u.direct;
944
945 if (op->parameters.indexed && d3d_info->draw_base_vertex_offset)
946 base_vertex_idx = direct->base_vertex_idx;
947 else if (!op->parameters.indexed)
948 base_vertex_idx = direct->start_idx;
949 }
950
951 /* ARB_draw_indirect always supports a base vertex offset. */
952 if (!op->parameters.indirect && !d3d_info->draw_base_vertex_offset)
953 load_base_vertex_idx = op->parameters.u.direct.base_vertex_idx;
954 else
955 load_base_vertex_idx = 0;
956
957 if (state->base_vertex_index != base_vertex_idx)
958 {
959 state->base_vertex_index = base_vertex_idx;
960 for (i = 0; i < device->context_count; ++i)
961 device->contexts[i]->constant_update_mask |= WINED3D_SHADER_CONST_BASE_VERTEX_ID;
962 }
963
964 if (state->load_base_vertex_index != load_base_vertex_idx)
965 {
966 state->load_base_vertex_index = load_base_vertex_idx;
967 device_invalidate_state(cs->c.device, STATE_BASEVERTEXINDEX);
968 }
969
970 if (state->primitive_type != op->primitive_type)
971 {
972 if ((geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY]) && !geometry_shader->function)
973 device_invalidate_state(cs->c.device, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY));
974 if (state->primitive_type == WINED3D_PT_POINTLIST || op->primitive_type == WINED3D_PT_POINTLIST)
975 device_invalidate_state(cs->c.device, STATE_POINT_ENABLE);
976 state->primitive_type = op->primitive_type;
977 }
978 state->patch_vertex_count = op->patch_vertex_count;
979
980 cs->c.device->adapter->adapter_ops->adapter_draw_primitive(cs->c.device, state, &op->parameters);
981
982 if (op->parameters.indirect)
983 {
984 struct wined3d_buffer *buffer = op->parameters.u.indirect.buffer;
985 wined3d_resource_release(&buffer->resource);
986 }
987
988 if (op->parameters.indexed)
989 wined3d_resource_release(&state->index_buffer->resource);
990 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
991 {
992 if (state->streams[i].buffer)
993 wined3d_resource_release(&state->streams[i].buffer->resource);
994 }
995 for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
996 {
997 if (state->stream_output[i].buffer)
998 wined3d_resource_release(&state->stream_output[i].buffer->resource);
999 }
1000 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
1001 {
1002 if (state->textures[i])
1003 wined3d_resource_release(&state->textures[i]->resource);
1004 }
1005 for (i = 0; i < d3d_info->limits.max_rt_count; ++i)
1006 {
1007 if (state->fb.render_targets[i])
1008 wined3d_resource_release(state->fb.render_targets[i]->resource);
1009 }
1010 if (state->fb.depth_stencil)
1011 wined3d_resource_release(state->fb.depth_stencil->resource);
1012 release_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
1013 release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
1014 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
1015 }
1016
1017 static void acquire_graphics_pipeline_resources(const struct wined3d_state *state,
1018 BOOL indexed, const struct wined3d_d3d_info *d3d_info)
1019 {
1020 unsigned int i;
1021
1022 if (indexed)
1023 wined3d_resource_acquire(&state->index_buffer->resource);
1024 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
1025 {
1026 if (state->streams[i].buffer)
1027 wined3d_resource_acquire(&state->streams[i].buffer->resource);
1028 }
1029 for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
1030 {
1031 if (state->stream_output[i].buffer)
1032 wined3d_resource_acquire(&state->stream_output[i].buffer->resource);
1033 }
1034 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
1035 {
1036 if (state->textures[i])
1037 wined3d_resource_acquire(&state->textures[i]->resource);
1038 }
1039 for (i = 0; i < d3d_info->limits.max_rt_count; ++i)
1040 {
1041 if (state->fb.render_targets[i])
1042 wined3d_resource_acquire(state->fb.render_targets[i]->resource);
1043 }
1044 if (state->fb.depth_stencil)
1045 wined3d_resource_acquire(state->fb.depth_stencil->resource);
1046 acquire_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
1047 acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
1048 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
1049 }
1050
1051 void wined3d_cs_emit_draw(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type,
1052 unsigned int patch_vertex_count, int base_vertex_idx, unsigned int start_idx,
1053 unsigned int index_count, unsigned int start_instance, unsigned int instance_count, bool indexed)
1054 {
1055 const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
1056 const struct wined3d_state *state = cs->c.state;
1057 struct wined3d_cs_draw *op;
1058
1059 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1060 op->opcode = WINED3D_CS_OP_DRAW;
1061 op->primitive_type = primitive_type;
1062 op->patch_vertex_count = patch_vertex_count;
1063 op->parameters.indirect = FALSE;
1064 op->parameters.u.direct.base_vertex_idx = base_vertex_idx;
1065 op->parameters.u.direct.start_idx = start_idx;
1066 op->parameters.u.direct.index_count = index_count;
1067 op->parameters.u.direct.start_instance = start_instance;
1068 op->parameters.u.direct.instance_count = instance_count;
1069 op->parameters.indexed = indexed;
1070
1071 acquire_graphics_pipeline_resources(state, indexed, d3d_info);
1072
1073 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1074 }
1075
1076 void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type,
1077 unsigned int patch_vertex_count, struct wined3d_buffer *buffer, unsigned int offset, bool indexed)
1078 {
1079 const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
1080 const struct wined3d_state *state = cs->c.state;
1081 struct wined3d_cs_draw *op;
1082
1083 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1084 op->opcode = WINED3D_CS_OP_DRAW;
1085 op->primitive_type = primitive_type;
1086 op->patch_vertex_count = patch_vertex_count;
1087 op->parameters.indirect = TRUE;
1088 op->parameters.u.indirect.buffer = buffer;
1089 op->parameters.u.indirect.offset = offset;
1090 op->parameters.indexed = indexed;
1091
1092 acquire_graphics_pipeline_resources(state, indexed, d3d_info);
1093 wined3d_resource_acquire(&buffer->resource);
1094
1095 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1096 }
1097
1098 static void wined3d_cs_exec_flush(struct wined3d_cs *cs, const void *data)
1099 {
1100 struct wined3d_context *context;
1101
1102 context = context_acquire(cs->c.device, NULL, 0);
1103 cs->c.device->adapter->adapter_ops->adapter_flush_context(context);
1104 context_release(context);
1105 }
1106
1107 void wined3d_cs_emit_flush(struct wined3d_cs *cs)
1108 {
1109 struct wined3d_cs_flush *op;
1110
1111 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1112 op->opcode = WINED3D_CS_OP_FLUSH;
1113
1114 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1115 cs->queries_flushed = TRUE;
1116 }
1117
1118 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
1119 {
1120 const struct wined3d_cs_set_predication *op = data;
1121
1122 cs->state.predicate = op->predicate;
1123 cs->state.predicate_value = op->value;
1124 }
1125
1126 void wined3d_device_context_emit_set_predication(struct wined3d_device_context *context,
1127 struct wined3d_query *predicate, BOOL value)
1128 {
1129 struct wined3d_cs_set_predication *op;
1130
1131 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1132 op->opcode = WINED3D_CS_OP_SET_PREDICATION;
1133 op->predicate = predicate;
1134 op->value = value;
1135
1136 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1137 }
1138
1139 static void wined3d_cs_exec_set_viewports(struct wined3d_cs *cs, const void *data)
1140 {
1141 const struct wined3d_cs_set_viewports *op = data;
1142
1143 if (op->viewport_count)
1144 memcpy(cs->state.viewports, op->viewports, op->viewport_count * sizeof(*op->viewports));
1145 else
1146 memset(cs->state.viewports, 0, sizeof(*cs->state.viewports));
1147 cs->state.viewport_count = op->viewport_count;
1148 device_invalidate_state(cs->c.device, STATE_VIEWPORT);
1149 }
1150
1151 void wined3d_device_context_emit_set_viewports(struct wined3d_device_context *context, unsigned int viewport_count,
1152 const struct wined3d_viewport *viewports)
1153 {
1154 struct wined3d_cs_set_viewports *op;
1155
1156 op = wined3d_device_context_require_space(context,
1157 FIELD_OFFSET(struct wined3d_cs_set_viewports,viewports[viewport_count]), WINED3D_CS_QUEUE_DEFAULT);
1158 op->opcode = WINED3D_CS_OP_SET_VIEWPORTS;
1159 memcpy(op->viewports, viewports, viewport_count * sizeof(*viewports));
1160 op->viewport_count = viewport_count;
1161
1162 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1163 }
1164
1165 static void wined3d_cs_exec_set_scissor_rects(struct wined3d_cs *cs, const void *data)
1166 {
1167 const struct wined3d_cs_set_scissor_rects *op = data;
1168
1169 if (op->rect_count)
1170 memcpy(cs->state.scissor_rects, op->rects, op->rect_count * sizeof(*op->rects));
1171 else
1172 SetRectEmpty(cs->state.scissor_rects);
1173 cs->state.scissor_rect_count = op->rect_count;
1174 device_invalidate_state(cs->c.device, STATE_SCISSORRECT);
1175 }
1176
1177 void wined3d_device_context_emit_set_scissor_rects(struct wined3d_device_context *context,
1178 unsigned int rect_count, const RECT *rects)
1179 {
1180 struct wined3d_cs_set_scissor_rects *op;
1181
1182 op = wined3d_device_context_require_space(context, FIELD_OFFSET(struct wined3d_cs_set_scissor_rects, rects[rect_count]),
1183 WINED3D_CS_QUEUE_DEFAULT);
1184 op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECTS;
1185 memcpy(op->rects, rects, rect_count * sizeof(*rects));
1186 op->rect_count = rect_count;
1187
1188 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1189 }
1190
1191 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
1192 {
1193 const struct wined3d_cs_set_rendertarget_view *op = data;
1194 bool prev_alpha_swizzle, curr_alpha_swizzle;
1195 struct wined3d_rendertarget_view *prev;
1196 bool prev_srgb_write, curr_srgb_write;
1197 struct wined3d_device *device;
1198
1199 device = cs->c.device;
1200 prev = cs->state.fb.render_targets[op->view_idx];
1201 cs->state.fb.render_targets[op->view_idx] = op->view;
1202 device_invalidate_state(device, STATE_FRAMEBUFFER);
1203
1204 prev_alpha_swizzle = prev && prev->format->id == WINED3DFMT_A8_UNORM;
1205 curr_alpha_swizzle = op->view && op->view->format->id == WINED3DFMT_A8_UNORM;
1206 if (prev_alpha_swizzle != curr_alpha_swizzle)
1207 device_invalidate_state(device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
1208
1209 if (!(device->adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
1210 || cs->state.render_states[WINED3D_RS_SRGBWRITEENABLE])
1211 {
1212 prev_srgb_write = prev && prev->format_flags & WINED3DFMT_FLAG_SRGB_WRITE;
1213 curr_srgb_write = op->view && op->view->format_flags & WINED3DFMT_FLAG_SRGB_WRITE;
1214 if (prev_srgb_write != curr_srgb_write)
1215 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
1216 }
1217 }
1218
1219 void wined3d_device_context_emit_set_rendertarget_view(struct wined3d_device_context *context, unsigned int view_idx,
1220 struct wined3d_rendertarget_view *view)
1221 {
1222 struct wined3d_cs_set_rendertarget_view *op;
1223
1224 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1225 op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEW;
1226 op->view_idx = view_idx;
1227 op->view = view;
1228
1229 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1230 }
1231
1232 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
1233 {
1234 const struct wined3d_cs_set_depth_stencil_view *op = data;
1235 struct wined3d_device *device = cs->c.device;
1236 struct wined3d_rendertarget_view *prev;
1237
1238 if ((prev = cs->state.fb.depth_stencil) && prev->resource->type != WINED3D_RTYPE_BUFFER)
1239 {
1240 struct wined3d_texture *prev_texture = texture_from_resource(prev->resource);
1241
1242 if (device->swapchains[0]->state.desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1243 || prev_texture->flags & WINED3D_TEXTURE_DISCARD)
1244 wined3d_texture_validate_location(prev_texture,
1245 prev->sub_resource_idx, WINED3D_LOCATION_DISCARDED);
1246 }
1247
1248 cs->state.fb.depth_stencil = op->view;
1249
1250 if (!prev != !op->view)
1251 {
1252 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1253 device_invalidate_state(device, STATE_DEPTH_STENCIL);
1254 device_invalidate_state(device, STATE_STENCIL_REF);
1255 device_invalidate_state(device, STATE_RASTERIZER);
1256 }
1257 else if (prev)
1258 {
1259 if (prev->format->depth_bias_scale != op->view->format->depth_bias_scale)
1260 device_invalidate_state(device, STATE_RASTERIZER);
1261 if (prev->format->stencil_size != op->view->format->stencil_size)
1262 device_invalidate_state(device, STATE_STENCIL_REF);
1263 }
1264
1265 device_invalidate_state(device, STATE_FRAMEBUFFER);
1266 }
1267
1268 void wined3d_device_context_emit_set_depth_stencil_view(struct wined3d_device_context *context,
1269 struct wined3d_rendertarget_view *view)
1270 {
1271 struct wined3d_cs_set_depth_stencil_view *op;
1272
1273 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1274 op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
1275 op->view = view;
1276
1277 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1278 }
1279
1280 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
1281 {
1282 const struct wined3d_cs_set_vertex_declaration *op = data;
1283
1284 cs->state.vertex_declaration = op->declaration;
1285 device_invalidate_state(cs->c.device, STATE_VDECL);
1286 }
1287
1288 void wined3d_device_context_emit_set_vertex_declaration(struct wined3d_device_context *context,
1289 struct wined3d_vertex_declaration *declaration)
1290 {
1291 struct wined3d_cs_set_vertex_declaration *op;
1292
1293 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1294 op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
1295 op->declaration = declaration;
1296
1297 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1298 }
1299
1300 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
1301 {
1302 const struct wined3d_cs_set_stream_source *op = data;
1303 struct wined3d_stream_state *stream;
1304 struct wined3d_buffer *prev;
1305
1306 stream = &cs->state.streams[op->stream_idx];
1307 prev = stream->buffer;
1308 stream->buffer = op->buffer;
1309 stream->offset = op->offset;
1310 stream->stride = op->stride;
1311
1312 if (op->buffer)
1313 InterlockedIncrement(&op->buffer->resource.bind_count);
1314 if (prev)
1315 InterlockedDecrement(&prev->resource.bind_count);
1316
1317 device_invalidate_state(cs->c.device, STATE_STREAMSRC);
1318 }
1319
1320 void wined3d_device_context_emit_set_stream_source(struct wined3d_device_context *context, unsigned int stream_idx,
1321 struct wined3d_buffer *buffer, unsigned int offset, unsigned int stride)
1322 {
1323 struct wined3d_cs_set_stream_source *op;
1324
1325 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1326 op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE;
1327 op->stream_idx = stream_idx;
1328 op->buffer = buffer;
1329 op->offset = offset;
1330 op->stride = stride;
1331
1332 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1333 }
1334
1335 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
1336 {
1337 const struct wined3d_cs_set_stream_source_freq *op = data;
1338 struct wined3d_stream_state *stream;
1339
1340 stream = &cs->state.streams[op->stream_idx];
1341 stream->frequency = op->frequency;
1342 stream->flags = op->flags;
1343
1344 device_invalidate_state(cs->c.device, STATE_STREAMSRC);
1345 }
1346
1347 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
1348 {
1349 struct wined3d_cs_set_stream_source_freq *op;
1350
1351 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1352 op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ;
1353 op->stream_idx = stream_idx;
1354 op->frequency = frequency;
1355 op->flags = flags;
1356
1357 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1358 }
1359
1360 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
1361 {
1362 const struct wined3d_cs_set_stream_output *op = data;
1363 struct wined3d_stream_output *stream;
1364 struct wined3d_buffer *prev;
1365
1366 stream = &cs->state.stream_output[op->stream_idx];
1367 prev = stream->buffer;
1368 stream->buffer = op->buffer;
1369 stream->offset = op->offset;
1370
1371 if (op->buffer)
1372 InterlockedIncrement(&op->buffer->resource.bind_count);
1373 if (prev)
1374 InterlockedDecrement(&prev->resource.bind_count);
1375
1376 device_invalidate_state(cs->c.device, STATE_STREAM_OUTPUT);
1377 }
1378
1379 void wined3d_device_context_emit_set_stream_output(struct wined3d_device_context *context, unsigned int stream_idx,
1380 struct wined3d_buffer *buffer, unsigned int offset)
1381 {
1382 struct wined3d_cs_set_stream_output *op;
1383
1384 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1385 op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUT;
1386 op->stream_idx = stream_idx;
1387 op->buffer = buffer;
1388 op->offset = offset;
1389
1390 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1391 }
1392
1393 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
1394 {
1395 const struct wined3d_cs_set_index_buffer *op = data;
1396 struct wined3d_buffer *prev;
1397
1398 prev = cs->state.index_buffer;
1399 cs->state.index_buffer = op->buffer;
1400 cs->state.index_format = op->format_id;
1401 cs->state.index_offset = op->offset;
1402
1403 if (op->buffer)
1404 InterlockedIncrement(&op->buffer->resource.bind_count);
1405 if (prev)
1406 InterlockedDecrement(&prev->resource.bind_count);
1407
1408 device_invalidate_state(cs->c.device, STATE_INDEXBUFFER);
1409 }
1410
1411 void wined3d_device_context_emit_set_index_buffer(struct wined3d_device_context *context, struct wined3d_buffer *buffer,
1412 enum wined3d_format_id format_id, unsigned int offset)
1413 {
1414 struct wined3d_cs_set_index_buffer *op;
1415
1416 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1417 op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
1418 op->buffer = buffer;
1419 op->format_id = format_id;
1420 op->offset = offset;
1421
1422 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1423 }
1424
1425 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
1426 {
1427 const struct wined3d_cs_set_constant_buffer *op = data;
1428 struct wined3d_buffer *prev;
1429
1430 prev = cs->state.cb[op->type][op->cb_idx];
1431 cs->state.cb[op->type][op->cb_idx] = op->buffer;
1432
1433 if (op->buffer)
1434 InterlockedIncrement(&op->buffer->resource.bind_count);
1435 if (prev)
1436 InterlockedDecrement(&prev->resource.bind_count);
1437
1438 device_invalidate_state(cs->c.device, STATE_CONSTANT_BUFFER(op->type));
1439 }
1440
1441 void wined3d_device_context_emit_set_constant_buffer(struct wined3d_device_context *context,
1442 enum wined3d_shader_type type, UINT cb_idx, struct wined3d_buffer *buffer)
1443 {
1444 struct wined3d_cs_set_constant_buffer *op;
1445
1446 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1447 op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFER;
1448 op->type = type;
1449 op->cb_idx = cb_idx;
1450 op->buffer = buffer;
1451
1452 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1453 }
1454
1455 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
1456 {
1457 const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
1458 const struct wined3d_cs_set_texture *op = data;
1459 struct wined3d_texture *prev;
1460 BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
1461
1462 prev = cs->state.textures[op->stage];
1463 cs->state.textures[op->stage] = op->texture;
1464
1465 if (op->texture)
1466 {
1467 const struct wined3d_format *new_format = op->texture->resource.format;
1468 const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
1469 unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
1470 unsigned int new_fmt_flags = op->texture->resource.format_flags;
1471
1472 if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
1473 op->texture->sampler = op->stage;
1474
1475 if (!prev || wined3d_texture_gl(op->texture)->target != wined3d_texture_gl(prev)->target
1476 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
1477 && !(can_use_texture_swizzle(d3d_info, new_format) && can_use_texture_swizzle(d3d_info, old_format)))
1478 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
1479 device_invalidate_state(cs->c.device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
1480
1481 if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
1482 {
1483 /* The source arguments for color and alpha ops have different
1484 * meanings when a NULL texture is bound, so the COLOR_OP and
1485 * ALPHA_OP have to be dirtified. */
1486 device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1487 device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1488 }
1489
1490 if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1491 new_use_color_key = TRUE;
1492 }
1493
1494 if (prev)
1495 {
1496 if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
1497 {
1498 unsigned int i;
1499
1500 /* Search for other stages the texture is bound to. Shouldn't
1501 * happen if applications bind textures to a single stage only. */
1502 TRACE("Searching for other stages the texture is bound to.\n");
1503 for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
1504 {
1505 if (cs->state.textures[i] == prev)
1506 {
1507 TRACE("Texture is also bound to stage %u.\n", i);
1508 prev->sampler = i;
1509 break;
1510 }
1511 }
1512 }
1513
1514 if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
1515 {
1516 device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1517 device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1518 }
1519
1520 if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1521 old_use_color_key = TRUE;
1522 }
1523
1524 device_invalidate_state(cs->c.device, STATE_SAMPLER(op->stage));
1525
1526 if (new_use_color_key != old_use_color_key)
1527 device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1528
1529 if (new_use_color_key)
1530 device_invalidate_state(cs->c.device, STATE_COLOR_KEY);
1531 }
1532
1533 void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
1534 {
1535 struct wined3d_cs_set_texture *op;
1536
1537 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1538 op->opcode = WINED3D_CS_OP_SET_TEXTURE;
1539 op->stage = stage;
1540 op->texture = texture;
1541
1542 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1543 }
1544
1545 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
1546 {
1547 const struct wined3d_cs_set_shader_resource_view *op = data;
1548 struct wined3d_shader_resource_view *prev;
1549
1550 prev = cs->state.shader_resource_view[op->type][op->view_idx];
1551 cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
1552
1553 if (op->view)
1554 InterlockedIncrement(&op->view->resource->bind_count);
1555 if (prev)
1556 InterlockedDecrement(&prev->resource->bind_count);
1557
1558 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1559 device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1560 else
1561 device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1562 }
1563
1564 void wined3d_device_context_emit_set_shader_resource_view(struct wined3d_device_context *context,
1565 enum wined3d_shader_type type, unsigned int view_idx, struct wined3d_shader_resource_view *view)
1566 {
1567 struct wined3d_cs_set_shader_resource_view *op;
1568
1569 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1570 op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW;
1571 op->type = type;
1572 op->view_idx = view_idx;
1573 op->view = view;
1574
1575 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1576 }
1577
1578 static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs *cs, const void *data)
1579 {
1580 const struct wined3d_cs_set_unordered_access_view *op = data;
1581 struct wined3d_unordered_access_view *prev;
1582
1583 prev = cs->state.unordered_access_view[op->pipeline][op->view_idx];
1584 cs->state.unordered_access_view[op->pipeline][op->view_idx] = op->view;
1585
1586 if (op->view)
1587 InterlockedIncrement(&op->view->resource->bind_count);
1588 if (prev)
1589 InterlockedDecrement(&prev->resource->bind_count);
1590
1591 if (op->view && op->initial_count != ~0u)
1592 wined3d_unordered_access_view_set_counter(op->view, op->initial_count);
1593
1594 device_invalidate_state(cs->c.device, STATE_UNORDERED_ACCESS_VIEW_BINDING(op->pipeline));
1595 }
1596
1597 void wined3d_device_context_emit_set_unordered_access_view(struct wined3d_device_context *context,
1598 enum wined3d_pipeline pipeline, unsigned int view_idx, struct wined3d_unordered_access_view *view,
1599 unsigned int initial_count)
1600 {
1601 struct wined3d_cs_set_unordered_access_view *op;
1602
1603 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1604 op->opcode = WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW;
1605 op->pipeline = pipeline;
1606 op->view_idx = view_idx;
1607 op->view = view;
1608 op->initial_count = initial_count;
1609
1610 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1611 }
1612
1613 static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
1614 {
1615 const struct wined3d_cs_set_sampler *op = data;
1616
1617 cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
1618 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1619 device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1620 else
1621 device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1622 }
1623
1624 void wined3d_device_context_emit_set_sampler(struct wined3d_device_context *context, enum wined3d_shader_type type,
1625 unsigned int sampler_idx, struct wined3d_sampler *sampler)
1626 {
1627 struct wined3d_cs_set_sampler *op;
1628
1629 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1630 op->opcode = WINED3D_CS_OP_SET_SAMPLER;
1631 op->type = type;
1632 op->sampler_idx = sampler_idx;
1633 op->sampler = sampler;
1634
1635 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1636 }
1637
1638 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
1639 {
1640 const struct wined3d_cs_set_shader *op = data;
1641
1642 cs->state.shader[op->type] = op->shader;
1643 device_invalidate_state(cs->c.device, STATE_SHADER(op->type));
1644 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1645 device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1646 else
1647 device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1648 }
1649
1650 void wined3d_device_context_emit_set_shader(struct wined3d_device_context *context,
1651 enum wined3d_shader_type type, struct wined3d_shader *shader)
1652 {
1653 struct wined3d_cs_set_shader *op;
1654
1655 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1656 op->opcode = WINED3D_CS_OP_SET_SHADER;
1657 op->type = type;
1658 op->shader = shader;
1659
1660 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1661 }
1662
1663 static void wined3d_cs_exec_set_blend_state(struct wined3d_cs *cs, const void *data)
1664 {
1665 const struct wined3d_cs_set_blend_state *op = data;
1666 struct wined3d_state *state = &cs->state;
1667
1668 if (state->blend_state != op->state)
1669 {
1670 state->blend_state = op->state;
1671 device_invalidate_state(cs->c.device, STATE_BLEND);
1672 }
1673 state->blend_factor = op->factor;
1674 device_invalidate_state(cs->c.device, STATE_BLEND_FACTOR);
1675 state->sample_mask = op->sample_mask;
1676 device_invalidate_state(cs->c.device, STATE_SAMPLE_MASK);
1677 }
1678
1679 void wined3d_device_context_emit_set_blend_state(struct wined3d_device_context *context,
1680 struct wined3d_blend_state *state, const struct wined3d_color *blend_factor, unsigned int sample_mask)
1681 {
1682 struct wined3d_cs_set_blend_state *op;
1683
1684 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1685 op->opcode = WINED3D_CS_OP_SET_BLEND_STATE;
1686 op->state = state;
1687 op->factor = *blend_factor;
1688 op->sample_mask = sample_mask;
1689
1690 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1691 }
1692
1693 static void wined3d_cs_exec_set_depth_stencil_state(struct wined3d_cs *cs, const void *data)
1694 {
1695 const struct wined3d_cs_set_depth_stencil_state *op = data;
1696 struct wined3d_state *state = &cs->state;
1697
1698 if (state->depth_stencil_state != op->state)
1699 {
1700 state->depth_stencil_state = op->state;
1701 device_invalidate_state(cs->c.device, STATE_DEPTH_STENCIL);
1702 }
1703 state->stencil_ref = op->stencil_ref;
1704 device_invalidate_state(cs->c.device, STATE_STENCIL_REF);
1705 }
1706
1707 void wined3d_device_context_emit_set_depth_stencil_state(struct wined3d_device_context *context,
1708 struct wined3d_depth_stencil_state *state, unsigned int stencil_ref)
1709 {
1710 struct wined3d_cs_set_depth_stencil_state *op;
1711
1712 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1713 op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE;
1714 op->state = state;
1715 op->stencil_ref = stencil_ref;
1716
1717 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1718 }
1719
1720 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
1721 {
1722 const struct wined3d_cs_set_rasterizer_state *op = data;
1723
1724 cs->state.rasterizer_state = op->state;
1725 device_invalidate_state(cs->c.device, STATE_RASTERIZER);
1726 }
1727
1728 void wined3d_device_context_emit_set_rasterizer_state(struct wined3d_device_context *context,
1729 struct wined3d_rasterizer_state *rasterizer_state)
1730 {
1731 struct wined3d_cs_set_rasterizer_state *op;
1732
1733 op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1734 op->opcode = WINED3D_CS_OP_SET_RASTERIZER_STATE;
1735 op->state = rasterizer_state;
1736
1737 wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1738 }
1739
1740 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
1741 {
1742 const struct wined3d_cs_set_render_state *op = data;
1743
1744 cs->state.render_states[op->state] = op->value;
1745 device_invalidate_state(cs->c.device, STATE_RENDER(op->state));
1746 }
1747
1748 void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
1749 {
1750 struct wined3d_cs_set_render_state *op;
1751
1752 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1753 op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
1754 op->state = state;
1755 op->value = value;
1756
1757 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1758 }
1759
1760 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
1761 {
1762 const struct wined3d_cs_set_texture_state *op = data;
1763
1764 cs->state.texture_states[op->stage][op->state] = op->value;
1765 device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, op->state));
1766 }
1767
1768 void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
1769 enum wined3d_texture_stage_state state, DWORD value)
1770 {
1771 struct wined3d_cs_set_texture_state *op;
1772
1773 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1774 op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
1775 op->stage = stage;
1776 op->state = state;
1777 op->value = value;
1778
1779 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1780 }
1781
1782 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
1783 {
1784 const struct wined3d_cs_set_sampler_state *op = data;
1785
1786 cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1787 device_invalidate_state(cs->c.device, STATE_SAMPLER(op->sampler_idx));
1788 }
1789
1790 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
1791 enum wined3d_sampler_state state, DWORD value)
1792 {
1793 struct wined3d_cs_set_sampler_state *op;
1794
1795 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1796 op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
1797 op->sampler_idx = sampler_idx;
1798 op->state = state;
1799 op->value = value;
1800
1801 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1802 }
1803
1804 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
1805 {
1806 const struct wined3d_cs_set_transform *op = data;
1807
1808 cs->state.transforms[op->state] = op->matrix;
1809 if (op->state < WINED3D_TS_WORLD_MATRIX(cs->c.device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1810 device_invalidate_state(cs->c.device, STATE_TRANSFORM(op->state));
1811 }
1812
1813 void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
1814 const struct wined3d_matrix *matrix)
1815 {
1816 struct wined3d_cs_set_transform *op;
1817
1818 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1819 op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
1820 op->state = state;
1821 op->matrix = *matrix;
1822
1823 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1824 }
1825
1826 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
1827 {
1828 const struct wined3d_cs_set_clip_plane *op = data;
1829
1830 cs->state.clip_planes[op->plane_idx] = op->plane;
1831 device_invalidate_state(cs->c.device, STATE_CLIPPLANE(op->plane_idx));
1832 }
1833
1834 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
1835 {
1836 struct wined3d_cs_set_clip_plane *op;
1837
1838 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1839 op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
1840 op->plane_idx = plane_idx;
1841 op->plane = *plane;
1842
1843 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1844 }
1845
1846 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
1847 {
1848 const struct wined3d_cs_set_color_key *op = data;
1849 struct wined3d_texture *texture = op->texture;
1850
1851 if (op->set)
1852 {
1853 switch (op->flags)
1854 {
1855 case WINED3D_CKEY_DST_BLT:
1856 texture->async.dst_blt_color_key = op->color_key;
1857 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1858 break;
1859
1860 case WINED3D_CKEY_DST_OVERLAY:
1861 texture->async.dst_overlay_color_key = op->color_key;
1862 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1863 break;
1864
1865 case WINED3D_CKEY_SRC_BLT:
1866 if (texture == cs->state.textures[0])
1867 {
1868 device_invalidate_state(cs->c.device, STATE_COLOR_KEY);
1869 if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1870 device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1871 }
1872
1873 texture->async.src_blt_color_key = op->color_key;
1874 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1875 break;
1876
1877 case WINED3D_CKEY_SRC_OVERLAY:
1878 texture->async.src_overlay_color_key = op->color_key;
1879 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1880 break;
1881 }
1882 }
1883 else
1884 {
1885 switch (op->flags)
1886 {
1887 case WINED3D_CKEY_DST_BLT:
1888 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1889 break;
1890
1891 case WINED3D_CKEY_DST_OVERLAY:
1892 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
1893 break;
1894
1895 case WINED3D_CKEY_SRC_BLT:
1896 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1897 device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1898
1899 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
1900 break;
1901
1902 case WINED3D_CKEY_SRC_OVERLAY:
1903 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
1904 break;
1905 }
1906 }
1907 }
1908
1909 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
1910 WORD flags, const struct wined3d_color_key *color_key)
1911 {
1912 struct wined3d_cs_set_color_key *op;
1913
1914 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1915 op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
1916 op->texture = texture;
1917 op->flags = flags;
1918 if (color_key)
1919 {
1920 op->color_key = *color_key;
1921 op->set = 1;
1922 }
1923 else
1924 op->set = 0;
1925
1926 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1927 }
1928
1929 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
1930 {
1931 const struct wined3d_cs_set_material *op = data;
1932
1933 cs->state.material = op->material;
1934 device_invalidate_state(cs->c.device, STATE_MATERIAL);
1935 }
1936
1937 void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
1938 {
1939 struct wined3d_cs_set_material *op;
1940
1941 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1942 op->opcode = WINED3D_CS_OP_SET_MATERIAL;
1943 op->material = *material;
1944
1945 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1946 }
1947
1948 static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
1949 {
1950 const struct wined3d_cs_set_light *op = data;
1951 struct wined3d_light_info *light_info;
1952 unsigned int light_idx, hash_idx;
1953
1954 light_idx = op->light.OriginalIndex;
1955
1956 if (!(light_info = wined3d_light_state_get_light(&cs->state.light_state, light_idx)))
1957 {
1958 TRACE("Adding new light.\n");
1959 if (!(light_info = heap_alloc_zero(sizeof(*light_info))))
1960 {
1961 ERR("Failed to allocate light info.\n");
1962 return;
1963 }
1964
1965 hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1966 list_add_head(&cs->state.light_state.light_map[hash_idx], &light_info->entry);
1967 light_info->glIndex = -1;
1968 light_info->OriginalIndex = light_idx;
1969 }
1970
1971 if (light_info->glIndex != -1)
1972 {
1973 if (light_info->OriginalParms.type != op->light.OriginalParms.type)
1974 device_invalidate_state(cs->c.device, STATE_LIGHT_TYPE);
1975 device_invalidate_state(cs->c.device, STATE_ACTIVELIGHT(light_info->glIndex));
1976 }
1977
1978 light_info->OriginalParms = op->light.OriginalParms;
1979 light_info->position = op->light.position;
1980 light_info->direction = op->light.direction;
1981 light_info->exponent = op->light.exponent;
1982 light_info->cutoff = op->light.cutoff;
1983 }
1984
1985 void wined3d_cs_emit_set_light(struct wined3d_cs *cs, const struct wined3d_light_info *light)
1986 {
1987 struct wined3d_cs_set_light *op;
1988
1989 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1990 op->opcode = WINED3D_CS_OP_SET_LIGHT;
1991 op->light = *light;
1992
1993 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
1994 }
1995
1996 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs *cs, const void *data)
1997 {
1998 const struct wined3d_cs_set_light_enable *op = data;
1999 struct wined3d_device *device = cs->c.device;
2000 struct wined3d_light_info *light_info;
2001 int prev_idx;
2002
2003 if (!(light_info = wined3d_light_state_get_light(&cs->state.light_state, op->idx)))
2004 {
2005 ERR("Light doesn't exist.\n");
2006 return;
2007 }
2008
2009 prev_idx = light_info->glIndex;
2010 wined3d_light_state_enable_light(&cs->state.light_state, &device->adapter->d3d_info, light_info, op->enable);
2011 if (light_info->glIndex != prev_idx)
2012 {
2013 device_invalidate_state(device, STATE_LIGHT_TYPE);
2014 device_invalidate_state(device, STATE_ACTIVELIGHT(op->enable ? light_info->glIndex : prev_idx));
2015 }
2016 }
2017
2018 void wined3d_cs_emit_set_light_enable(struct wined3d_cs *cs, unsigned int idx, BOOL enable)
2019 {
2020 struct wined3d_cs_set_light_enable *op;
2021
2022 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2023 op->opcode = WINED3D_CS_OP_SET_LIGHT_ENABLE;
2024 op->idx = idx;
2025 op->enable = enable;
2026
2027 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2028 }
2029
2030 static void wined3d_cs_exec_set_feature_level(struct wined3d_cs *cs, const void *data)
2031 {
2032 const struct wined3d_cs_set_feature_level *op = data;
2033
2034 cs->state.feature_level = op->level;
2035 }
2036
2037 void wined3d_cs_emit_set_feature_level(struct wined3d_cs *cs, enum wined3d_feature_level level)
2038 {
2039 struct wined3d_cs_set_feature_level *op;
2040
2041 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2042 op->opcode = WINED3D_CS_OP_SET_FEATURE_LEVEL;
2043 op->level = level;
2044
2045 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2046 }
2047
2048 static const struct
2049 {
2050 size_t offset;
2051 size_t size;
2052 DWORD mask;
2053 }
2054 wined3d_cs_push_constant_info[] =
2055 {
2056 /* WINED3D_PUSH_CONSTANTS_VS_F */
2057 {FIELD_OFFSET(struct wined3d_state, vs_consts_f), sizeof(struct wined3d_vec4), WINED3D_SHADER_CONST_VS_F},
2058 /* WINED3D_PUSH_CONSTANTS_PS_F */
2059 {FIELD_OFFSET(struct wined3d_state, ps_consts_f), sizeof(struct wined3d_vec4), WINED3D_SHADER_CONST_PS_F},
2060 /* WINED3D_PUSH_CONSTANTS_VS_I */
2061 {FIELD_OFFSET(struct wined3d_state, vs_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_VS_I},
2062 /* WINED3D_PUSH_CONSTANTS_PS_I */
2063 {FIELD_OFFSET(struct wined3d_state, ps_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_PS_I},
2064 /* WINED3D_PUSH_CONSTANTS_VS_B */
2065 {FIELD_OFFSET(struct wined3d_state, vs_consts_b), sizeof(BOOL), WINED3D_SHADER_CONST_VS_B},
2066 /* WINED3D_PUSH_CONSTANTS_PS_B */
2067 {FIELD_OFFSET(struct wined3d_state, ps_consts_b), sizeof(BOOL), WINED3D_SHADER_CONST_PS_B},
2068 };
2069
2070 static struct wined3d_cs *wined3d_cs_from_context(struct wined3d_device_context *context)
2071 {
2072 return CONTAINING_RECORD(context, struct wined3d_cs, c);
2073 }
2074
2075 static void wined3d_cs_st_push_constants(struct wined3d_device_context *context, enum wined3d_push_constants p,
2076 unsigned int start_idx, unsigned int count, const void *constants)
2077 {
2078 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2079 struct wined3d_device *device = cs->c.device;
2080 unsigned int context_count;
2081 unsigned int i;
2082 size_t offset;
2083
2084 if (p == WINED3D_PUSH_CONSTANTS_VS_F)
2085 device->shader_backend->shader_update_float_vertex_constants(device, start_idx, count);
2086 else if (p == WINED3D_PUSH_CONSTANTS_PS_F)
2087 device->shader_backend->shader_update_float_pixel_constants(device, start_idx, count);
2088
2089 offset = wined3d_cs_push_constant_info[p].offset + start_idx * wined3d_cs_push_constant_info[p].size;
2090 memcpy((BYTE *)&cs->state + offset, constants, count * wined3d_cs_push_constant_info[p].size);
2091 for (i = 0, context_count = device->context_count; i < context_count; ++i)
2092 {
2093 device->contexts[i]->constant_update_mask |= wined3d_cs_push_constant_info[p].mask;
2094 }
2095 }
2096
2097 static void wined3d_cs_exec_push_constants(struct wined3d_cs *cs, const void *data)
2098 {
2099 const struct wined3d_cs_push_constants *op = data;
2100
2101 wined3d_cs_st_push_constants(&cs->c, op->type, op->start_idx, op->count, op->constants);
2102 }
2103
2104 static void wined3d_cs_mt_push_constants(struct wined3d_device_context *context, enum wined3d_push_constants p,
2105 unsigned int start_idx, unsigned int count, const void *constants)
2106 {
2107 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2108 struct wined3d_cs_push_constants *op;
2109 size_t size;
2110
2111 size = count * wined3d_cs_push_constant_info[p].size;
2112 op = wined3d_device_context_require_space(&cs->c, FIELD_OFFSET(struct wined3d_cs_push_constants, constants[size]),
2113 WINED3D_CS_QUEUE_DEFAULT);
2114 op->opcode = WINED3D_CS_OP_PUSH_CONSTANTS;
2115 op->type = p;
2116 op->start_idx = start_idx;
2117 op->count = count;
2118 memcpy(op->constants, constants, size);
2119
2120 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2121 }
2122
2123 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
2124 {
2125 state_cleanup(&cs->state);
2126 wined3d_state_reset(&cs->state, &cs->c.device->adapter->d3d_info);
2127 }
2128
2129 void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
2130 {
2131 struct wined3d_cs_reset_state *op;
2132
2133 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2134 op->opcode = WINED3D_CS_OP_RESET_STATE;
2135
2136 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2137 }
2138
2139 static void wined3d_cs_exec_callback(struct wined3d_cs *cs, const void *data)
2140 {
2141 const struct wined3d_cs_callback *op = data;
2142
2143 op->callback(op->object);
2144 }
2145
2146 static void wined3d_cs_emit_callback(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2147 {
2148 struct wined3d_cs_callback *op;
2149
2150 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2151 op->opcode = WINED3D_CS_OP_CALLBACK;
2152 op->callback = callback;
2153 op->object = object;
2154
2155 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2156 }
2157
2158 void wined3d_cs_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2159 {
2160 wined3d_cs_emit_callback(cs, callback, object);
2161 }
2162
2163 void wined3d_cs_init_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2164 {
2165 wined3d_cs_emit_callback(cs, callback, object);
2166 }
2167
2168 static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
2169 {
2170 const struct wined3d_cs_query_issue *op = data;
2171 struct wined3d_query *query = op->query;
2172 BOOL poll;
2173
2174 poll = query->query_ops->query_issue(query, op->flags);
2175
2176 if (!cs->thread)
2177 return;
2178
2179 if (poll && list_empty(&query->poll_list_entry))
2180 {
2181 if (query->buffer_object)
2182 InterlockedIncrement(&query->counter_retrieved);
2183 else
2184 list_add_tail(&cs->query_poll_list, &query->poll_list_entry);
2185 return;
2186 }
2187
2188 /* This can happen if occlusion queries are restarted. This discards the
2189 * old result, since polling it could result in a GL error. */
2190 if ((op->flags & WINED3DISSUE_BEGIN) && !poll && !list_empty(&query->poll_list_entry))
2191 {
2192 list_remove(&query->poll_list_entry);
2193 list_init(&query->poll_list_entry);
2194 InterlockedIncrement(&query->counter_retrieved);
2195 return;
2196 }
2197
2198 /* This can happen when an occlusion query is ended without being started,
2199 * in which case we don't want to poll, but still have to counter-balance
2200 * the increment of the main counter.
2201 *
2202 * This can also happen if an event query is re-issued before the first
2203 * fence was reached. In this case the query is already in the list and
2204 * the poll function will check the new fence. We have to counter-balance
2205 * the discarded increment. */
2206 if (op->flags & WINED3DISSUE_END)
2207 InterlockedIncrement(&query->counter_retrieved);
2208 }
2209
2210 void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
2211 {
2212 struct wined3d_cs_query_issue *op;
2213
2214 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2215 op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
2216 op->query = query;
2217 op->flags = flags;
2218
2219 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2220 cs->queries_flushed = FALSE;
2221 }
2222
2223 static void wined3d_cs_exec_preload_resource(struct wined3d_cs *cs, const void *data)
2224 {
2225 const struct wined3d_cs_preload_resource *op = data;
2226 struct wined3d_resource *resource = op->resource;
2227
2228 resource->resource_ops->resource_preload(resource);
2229 wined3d_resource_release(resource);
2230 }
2231
2232 void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
2233 {
2234 struct wined3d_cs_preload_resource *op;
2235
2236 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2237 op->opcode = WINED3D_CS_OP_PRELOAD_RESOURCE;
2238 op->resource = resource;
2239
2240 wined3d_resource_acquire(resource);
2241
2242 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2243 }
2244
2245 static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
2246 {
2247 const struct wined3d_cs_unload_resource *op = data;
2248 struct wined3d_resource *resource = op->resource;
2249
2250 resource->resource_ops->resource_unload(resource);
2251 wined3d_resource_release(resource);
2252 }
2253
2254 void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
2255 {
2256 struct wined3d_cs_unload_resource *op;
2257
2258 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2259 op->opcode = WINED3D_CS_OP_UNLOAD_RESOURCE;
2260 op->resource = resource;
2261
2262 wined3d_resource_acquire(resource);
2263
2264 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2265 }
2266
2267 static void wined3d_cs_exec_map(struct wined3d_cs *cs, const void *data)
2268 {
2269 const struct wined3d_cs_map *op = data;
2270 struct wined3d_resource *resource = op->resource;
2271
2272 *op->hr = resource->resource_ops->resource_sub_resource_map(resource,
2273 op->sub_resource_idx, op->map_desc, op->box, op->flags);
2274 }
2275
2276 HRESULT wined3d_cs_map(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx,
2277 struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags)
2278 {
2279 struct wined3d_cs_map *op;
2280 HRESULT hr;
2281
2282 /* Mapping resources from the worker thread isn't an issue by itself, but
2283 * increasing the map count would be visible to applications. */
2284 wined3d_not_from_cs(cs);
2285
2286 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2287 op->opcode = WINED3D_CS_OP_MAP;
2288 op->resource = resource;
2289 op->sub_resource_idx = sub_resource_idx;
2290 op->map_desc = map_desc;
2291 op->box = box;
2292 op->flags = flags;
2293 op->hr = &hr;
2294
2295 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_MAP);
2296 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_MAP);
2297
2298 return hr;
2299 }
2300
2301 static void wined3d_cs_exec_unmap(struct wined3d_cs *cs, const void *data)
2302 {
2303 const struct wined3d_cs_unmap *op = data;
2304 struct wined3d_resource *resource = op->resource;
2305
2306 *op->hr = resource->resource_ops->resource_sub_resource_unmap(resource, op->sub_resource_idx);
2307 }
2308
2309 HRESULT wined3d_cs_unmap(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx)
2310 {
2311 struct wined3d_cs_unmap *op;
2312 HRESULT hr;
2313
2314 wined3d_not_from_cs(cs);
2315
2316 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2317 op->opcode = WINED3D_CS_OP_UNMAP;
2318 op->resource = resource;
2319 op->sub_resource_idx = sub_resource_idx;
2320 op->hr = &hr;
2321
2322 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_MAP);
2323 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_MAP);
2324
2325 return hr;
2326 }
2327
2328 static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs *cs, const void *data)
2329 {
2330 const struct wined3d_cs_blt_sub_resource *op = data;
2331
2332 if (op->dst_resource->type == WINED3D_RTYPE_BUFFER)
2333 {
2334 wined3d_buffer_copy(buffer_from_resource(op->dst_resource), op->dst_box.left,
2335 buffer_from_resource(op->src_resource), op->src_box.left,
2336 op->src_box.right - op->src_box.left);
2337 }
2338 else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_3D)
2339 {
2340 struct wined3d_texture *src_texture, *dst_texture;
2341 unsigned int level, update_w, update_h, update_d;
2342 unsigned int row_pitch, slice_pitch;
2343 struct wined3d_context *context;
2344 struct wined3d_bo_address addr;
2345
2346 if (op->flags & ~WINED3D_BLT_RAW)
2347 {
2348 FIXME("Flags %#x not implemented for %s resources.\n",
2349 op->flags, debug_d3dresourcetype(op->dst_resource->type));
2350 goto error;
2351 }
2352
2353 if (!(op->flags & WINED3D_BLT_RAW) && op->src_resource->format != op->dst_resource->format)
2354 {
2355 FIXME("Format conversion not implemented for %s resources.\n",
2356 debug_d3dresourcetype(op->dst_resource->type));
2357 goto error;
2358 }
2359
2360 update_w = op->dst_box.right - op->dst_box.left;
2361 update_h = op->dst_box.bottom - op->dst_box.top;
2362 update_d = op->dst_box.back - op->dst_box.front;
2363 if (op->src_box.right - op->src_box.left != update_w
2364 || op->src_box.bottom - op->src_box.top != update_h
2365 || op->src_box.back - op->src_box.front != update_d)
2366 {
2367 FIXME("Stretching not implemented for %s resources.\n",
2368 debug_d3dresourcetype(op->dst_resource->type));
2369 goto error;
2370 }
2371
2372 dst_texture = texture_from_resource(op->dst_resource);
2373 src_texture = texture_from_resource(op->src_resource);
2374
2375 context = context_acquire(cs->c.device, NULL, 0);
2376
2377 if (!wined3d_texture_load_location(src_texture, op->src_sub_resource_idx,
2378 context, src_texture->resource.map_binding))
2379 {
2380 ERR("Failed to load source sub-resource into %s.\n",
2381 wined3d_debug_location(src_texture->resource.map_binding));
2382 context_release(context);
2383 goto error;
2384 }
2385
2386 level = op->dst_sub_resource_idx % dst_texture->level_count;
2387 if (update_w == wined3d_texture_get_level_width(dst_texture, level)
2388 && update_h == wined3d_texture_get_level_height(dst_texture, level)
2389 && update_d == wined3d_texture_get_level_depth(dst_texture, level))
2390 {
2391 wined3d_texture_prepare_location(dst_texture, op->dst_sub_resource_idx,
2392 context, WINED3D_LOCATION_TEXTURE_RGB);
2393 }
2394 else if (!wined3d_texture_load_location(dst_texture, op->dst_sub_resource_idx,
2395 context, WINED3D_LOCATION_TEXTURE_RGB))
2396 {
2397 ERR("Failed to load destination sub-resource.\n");
2398 context_release(context);
2399 goto error;
2400 }
2401
2402 wined3d_texture_get_memory(src_texture, op->src_sub_resource_idx, &addr, src_texture->resource.map_binding);
2403 wined3d_texture_get_pitch(src_texture, op->src_sub_resource_idx % src_texture->level_count,
2404 &row_pitch, &slice_pitch);
2405
2406 dst_texture->texture_ops->texture_upload_data(context, wined3d_const_bo_address(&addr),
2407 dst_texture->resource.format, &op->src_box, row_pitch, slice_pitch, dst_texture,
2408 op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB,
2409 op->dst_box.left, op->dst_box.top, op->dst_box.front);
2410 wined3d_texture_validate_location(dst_texture, op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2411 wined3d_texture_invalidate_location(dst_texture, op->dst_sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2412
2413 context_release(context);
2414 }
2415 else
2416 {
2417 if (FAILED(texture2d_blt(texture_from_resource(op->dst_resource), op->dst_sub_resource_idx,
2418 &op->dst_box, texture_from_resource(op->src_resource), op->src_sub_resource_idx,
2419 &op->src_box, op->flags, &op->fx, op->filter)))
2420 FIXME("Blit failed.\n");
2421 }
2422
2423 error:
2424 if (op->src_resource)
2425 wined3d_resource_release(op->src_resource);
2426 wined3d_resource_release(op->dst_resource);
2427 }
2428
2429 void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource,
2430 unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource,
2431 unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags,
2432 const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
2433 {
2434 struct wined3d_cs_blt_sub_resource *op;
2435
2436 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2437 op->opcode = WINED3D_CS_OP_BLT_SUB_RESOURCE;
2438 op->dst_resource = dst_resource;
2439 op->dst_sub_resource_idx = dst_sub_resource_idx;
2440 op->dst_box = *dst_box;
2441 op->src_resource = src_resource;
2442 op->src_sub_resource_idx = src_sub_resource_idx;
2443 op->src_box = *src_box;
2444 op->flags = flags;
2445 if (fx)
2446 op->fx = *fx;
2447 else
2448 memset(&op->fx, 0, sizeof(op->fx));
2449 op->filter = filter;
2450
2451 wined3d_resource_acquire(dst_resource);
2452 if (src_resource)
2453 wined3d_resource_acquire(src_resource);
2454
2455 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2456 if (flags & WINED3D_BLT_SYNCHRONOUS)
2457 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2458 }
2459
2460 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data)
2461 {
2462 const struct wined3d_cs_update_sub_resource *op = data;
2463 struct wined3d_resource *resource = op->resource;
2464 const struct wined3d_box *box = &op->box;
2465 unsigned int width, height, depth, level;
2466 struct wined3d_const_bo_address addr;
2467 struct wined3d_context *context;
2468 struct wined3d_texture *texture;
2469 struct wined3d_box src_box;
2470
2471 context = context_acquire(cs->c.device, NULL, 0);
2472
2473 if (resource->type == WINED3D_RTYPE_BUFFER)
2474 {
2475 struct wined3d_buffer *buffer = buffer_from_resource(resource);
2476
2477 if (!wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER))
2478 {
2479 ERR("Failed to load buffer location.\n");
2480 goto done;
2481 }
2482
2483 wined3d_buffer_upload_data(buffer, context, box, op->data.data);
2484 wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
2485 goto done;
2486 }
2487
2488 texture = wined3d_texture_from_resource(resource);
2489
2490 level = op->sub_resource_idx % texture->level_count;
2491 width = wined3d_texture_get_level_width(texture, level);
2492 height = wined3d_texture_get_level_height(texture, level);
2493 depth = wined3d_texture_get_level_depth(texture, level);
2494
2495 addr.buffer_object = 0;
2496 addr.addr = op->data.data;
2497
2498 /* Only load the sub-resource for partial updates. */
2499 if (!box->left && !box->top && !box->front
2500 && box->right == width && box->bottom == height && box->back == depth)
2501 wined3d_texture_prepare_location(texture, op->sub_resource_idx, context, WINED3D_LOCATION_TEXTURE_RGB);
2502 else
2503 wined3d_texture_load_location(texture, op->sub_resource_idx, context, WINED3D_LOCATION_TEXTURE_RGB);
2504
2505 wined3d_box_set(&src_box, 0, 0, box->right - box->left, box->bottom - box->top, 0, box->back - box->front);
2506 texture->texture_ops->texture_upload_data(context, &addr, texture->resource.format, &src_box,
2507 op->data.row_pitch, op->data.slice_pitch, texture, op->sub_resource_idx,
2508 WINED3D_LOCATION_TEXTURE_RGB, box->left, box->top, box->front);
2509
2510 wined3d_texture_validate_location(texture, op->sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2511 wined3d_texture_invalidate_location(texture, op->sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2512
2513 done:
2514 context_release(context);
2515
2516 wined3d_resource_release(resource);
2517 }
2518
2519 void wined3d_cs_emit_update_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *resource,
2520 unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch,
2521 unsigned int slice_pitch)
2522 {
2523 struct wined3d_cs_update_sub_resource *op;
2524
2525 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2526 op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE;
2527 op->resource = resource;
2528 op->sub_resource_idx = sub_resource_idx;
2529 op->box = *box;
2530 op->data.row_pitch = row_pitch;
2531 op->data.slice_pitch = slice_pitch;
2532 op->data.data = data;
2533
2534 wined3d_resource_acquire(resource);
2535
2536 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_MAP);
2537 /* The data pointer may go away, so we need to wait until it is read.
2538 * Copying the data may be faster if it's small. */
2539 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_MAP);
2540 }
2541
2542 static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs *cs, const void *data)
2543 {
2544 const struct wined3d_cs_add_dirty_texture_region *op = data;
2545 struct wined3d_texture *texture = op->texture;
2546 unsigned int sub_resource_idx, i;
2547 struct wined3d_context *context;
2548
2549 context = context_acquire(cs->c.device, NULL, 0);
2550 sub_resource_idx = op->layer * texture->level_count;
2551 for (i = 0; i < texture->level_count; ++i, ++sub_resource_idx)
2552 {
2553 if (wined3d_texture_load_location(texture, sub_resource_idx, context, texture->resource.map_binding))
2554 wined3d_texture_invalidate_location(texture, sub_resource_idx, ~texture->resource.map_binding);
2555 else
2556 ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
2557 }
2558 context_release(context);
2559
2560 wined3d_resource_release(&texture->resource);
2561 }
2562
2563 void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs *cs,
2564 struct wined3d_texture *texture, unsigned int layer)
2565 {
2566 struct wined3d_cs_add_dirty_texture_region *op;
2567
2568 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2569 op->opcode = WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION;
2570 op->texture = texture;
2571 op->layer = layer;
2572
2573 wined3d_resource_acquire(&texture->resource);
2574
2575 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2576 }
2577
2578 static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs *cs, const void *data)
2579 {
2580 const struct wined3d_cs_clear_unordered_access_view *op = data;
2581 struct wined3d_unordered_access_view *view = op->view;
2582 struct wined3d_context *context;
2583
2584 context = context_acquire(cs->c.device, NULL, 0);
2585 cs->c.device->adapter->adapter_ops->adapter_clear_uav(context, view, &op->clear_value);
2586 context_release(context);
2587
2588 wined3d_resource_release(view->resource);
2589 }
2590
2591 void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs *cs,
2592 struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
2593 {
2594 struct wined3d_cs_clear_unordered_access_view *op;
2595
2596 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2597 op->opcode = WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW;
2598 op->view = view;
2599 op->clear_value = *clear_value;
2600
2601 wined3d_resource_acquire(view->resource);
2602
2603 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2604 }
2605
2606 static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs *cs, const void *data)
2607 {
2608 const struct wined3d_cs_copy_uav_counter *op = data;
2609 struct wined3d_unordered_access_view *view = op->view;
2610 struct wined3d_context *context;
2611
2612 context = context_acquire(cs->c.device, NULL, 0);
2613 wined3d_unordered_access_view_copy_counter(view, op->buffer, op->offset, context);
2614 context_release(context);
2615
2616 wined3d_resource_release(&op->buffer->resource);
2617 }
2618
2619 void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs *cs, struct wined3d_buffer *dst_buffer,
2620 unsigned int offset, struct wined3d_unordered_access_view *uav)
2621 {
2622 struct wined3d_cs_copy_uav_counter *op;
2623
2624 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2625 op->opcode = WINED3D_CS_OP_COPY_UAV_COUNTER;
2626 op->buffer = dst_buffer;
2627 op->offset = offset;
2628 op->view = uav;
2629
2630 wined3d_resource_acquire(&dst_buffer->resource);
2631
2632 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2633 }
2634
2635 static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs *cs, const void *data)
2636 {
2637 const struct wined3d_cs_generate_mipmaps *op = data;
2638 struct wined3d_shader_resource_view *view = op->view;
2639 struct wined3d_context *context;
2640
2641 context = context_acquire(cs->c.device, NULL, 0);
2642 cs->c.device->adapter->adapter_ops->adapter_generate_mipmap(context, view);
2643 context_release(context);
2644
2645 wined3d_resource_release(view->resource);
2646 }
2647
2648 void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs *cs, struct wined3d_shader_resource_view *view)
2649 {
2650 struct wined3d_cs_generate_mipmaps *op;
2651
2652 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2653 op->opcode = WINED3D_CS_OP_GENERATE_MIPMAPS;
2654 op->view = view;
2655
2656 wined3d_resource_acquire(view->resource);
2657
2658 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2659 }
2660
2661 static void wined3d_cs_emit_stop(struct wined3d_cs *cs)
2662 {
2663 struct wined3d_cs_stop *op;
2664
2665 op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2666 op->opcode = WINED3D_CS_OP_STOP;
2667
2668 wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2669 wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2670 }
2671
2672 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
2673 {
2674 /* WINED3D_CS_OP_NOP */ wined3d_cs_exec_nop,
2675 /* WINED3D_CS_OP_PRESENT */ wined3d_cs_exec_present,
2676 /* WINED3D_CS_OP_CLEAR */ wined3d_cs_exec_clear,
2677 /* WINED3D_CS_OP_DISPATCH */ wined3d_cs_exec_dispatch,
2678 /* WINED3D_CS_OP_DRAW */ wined3d_cs_exec_draw,
2679 /* WINED3D_CS_OP_FLUSH */ wined3d_cs_exec_flush,
2680 /* WINED3D_CS_OP_SET_PREDICATION */ wined3d_cs_exec_set_predication,
2681 /* WINED3D_CS_OP_SET_VIEWPORTS */ wined3d_cs_exec_set_viewports,
2682 /* WINED3D_CS_OP_SET_SCISSOR_RECTS */ wined3d_cs_exec_set_scissor_rects,
2683 /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW */ wined3d_cs_exec_set_rendertarget_view,
2684 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW */ wined3d_cs_exec_set_depth_stencil_view,
2685 /* WINED3D_CS_OP_SET_VERTEX_DECLARATION */ wined3d_cs_exec_set_vertex_declaration,
2686 /* WINED3D_CS_OP_SET_STREAM_SOURCE */ wined3d_cs_exec_set_stream_source,
2687 /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq,
2688 /* WINED3D_CS_OP_SET_STREAM_OUTPUT */ wined3d_cs_exec_set_stream_output,
2689 /* WINED3D_CS_OP_SET_INDEX_BUFFER */ wined3d_cs_exec_set_index_buffer,
2690 /* WINED3D_CS_OP_SET_CONSTANT_BUFFER */ wined3d_cs_exec_set_constant_buffer,
2691 /* WINED3D_CS_OP_SET_TEXTURE */ wined3d_cs_exec_set_texture,
2692 /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW */ wined3d_cs_exec_set_shader_resource_view,
2693 /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_set_unordered_access_view,
2694 /* WINED3D_CS_OP_SET_SAMPLER */ wined3d_cs_exec_set_sampler,
2695 /* WINED3D_CS_OP_SET_SHADER */ wined3d_cs_exec_set_shader,
2696 /* WINED3D_CS_OP_SET_BLEND_STATE */ wined3d_cs_exec_set_blend_state,
2697 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE */ wined3d_cs_exec_set_depth_stencil_state,
2698 /* WINED3D_CS_OP_SET_RASTERIZER_STATE */ wined3d_cs_exec_set_rasterizer_state,
2699 /* WINED3D_CS_OP_SET_RENDER_STATE */ wined3d_cs_exec_set_render_state,
2700 /* WINED3D_CS_OP_SET_TEXTURE_STATE */ wined3d_cs_exec_set_texture_state,
2701 /* WINED3D_CS_OP_SET_SAMPLER_STATE */ wined3d_cs_exec_set_sampler_state,
2702 /* WINED3D_CS_OP_SET_TRANSFORM */ wined3d_cs_exec_set_transform,
2703 /* WINED3D_CS_OP_SET_CLIP_PLANE */ wined3d_cs_exec_set_clip_plane,
2704 /* WINED3D_CS_OP_SET_COLOR_KEY */ wined3d_cs_exec_set_color_key,
2705 /* WINED3D_CS_OP_SET_MATERIAL */ wined3d_cs_exec_set_material,
2706 /* WINED3D_CS_OP_SET_LIGHT */ wined3d_cs_exec_set_light,
2707 /* WINED3D_CS_OP_SET_LIGHT_ENABLE */ wined3d_cs_exec_set_light_enable,
2708 /* WINED3D_CS_OP_SET_FEATURE_LEVEL */ wined3d_cs_exec_set_feature_level,
2709 /* WINED3D_CS_OP_PUSH_CONSTANTS */ wined3d_cs_exec_push_constants,
2710 /* WINED3D_CS_OP_RESET_STATE */ wined3d_cs_exec_reset_state,
2711 /* WINED3D_CS_OP_CALLBACK */ wined3d_cs_exec_callback,
2712 /* WINED3D_CS_OP_QUERY_ISSUE */ wined3d_cs_exec_query_issue,
2713 /* WINED3D_CS_OP_PRELOAD_RESOURCE */ wined3d_cs_exec_preload_resource,
2714 /* WINED3D_CS_OP_UNLOAD_RESOURCE */ wined3d_cs_exec_unload_resource,
2715 /* WINED3D_CS_OP_MAP */ wined3d_cs_exec_map,
2716 /* WINED3D_CS_OP_UNMAP */ wined3d_cs_exec_unmap,
2717 /* WINED3D_CS_OP_BLT_SUB_RESOURCE */ wined3d_cs_exec_blt_sub_resource,
2718 /* WINED3D_CS_OP_UPDATE_SUB_RESOURCE */ wined3d_cs_exec_update_sub_resource,
2719 /* WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION */ wined3d_cs_exec_add_dirty_texture_region,
2720 /* WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_clear_unordered_access_view,
2721 /* WINED3D_CS_OP_COPY_UAV_COUNTER */ wined3d_cs_exec_copy_uav_counter,
2722 /* WINED3D_CS_OP_GENERATE_MIPMAPS */ wined3d_cs_exec_generate_mipmaps,
2723 };
2724
2725 static void *wined3d_cs_st_require_space(struct wined3d_device_context *context,
2726 size_t size, enum wined3d_cs_queue_id queue_id)
2727 {
2728 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2729
2730 if (size > (cs->data_size - cs->end))
2731 {
2732 size_t new_size;
2733 void *new_data;
2734
2735 new_size = max(size, cs->data_size * 2);
2736 if (!cs->end)
2737 new_data = heap_realloc(cs->data, new_size);
2738 else
2739 new_data = heap_alloc(new_size);
2740 if (!new_data)
2741 return NULL;
2742
2743 cs->data_size = new_size;
2744 cs->start = cs->end = 0;
2745 cs->data = new_data;
2746 }
2747
2748 cs->end += size;
2749
2750 return (BYTE *)cs->data + cs->start;
2751 }
2752
2753 static void wined3d_cs_st_submit(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
2754 {
2755 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2756 enum wined3d_cs_op opcode;
2757 size_t start;
2758 BYTE *data;
2759
2760 data = cs->data;
2761 start = cs->start;
2762 cs->start = cs->end;
2763
2764 opcode = *(const enum wined3d_cs_op *)&data[start];
2765 if (opcode >= WINED3D_CS_OP_STOP)
2766 ERR("Invalid opcode %#x.\n", opcode);
2767 else
2768 wined3d_cs_op_handlers[opcode](cs, &data[start]);
2769
2770 if (cs->data == data)
2771 cs->start = cs->end = start;
2772 else if (!start)
2773 heap_free(data);
2774 }
2775
2776 static void wined3d_cs_st_finish(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
2777 {
2778 }
2779
2780 static const struct wined3d_device_context_ops wined3d_cs_st_ops =
2781 {
2782 wined3d_cs_st_require_space,
2783 wined3d_cs_st_submit,
2784 wined3d_cs_st_finish,
2785 wined3d_cs_st_push_constants,
2786 };
2787
2788 static BOOL wined3d_cs_queue_is_empty(const struct wined3d_cs *cs, const struct wined3d_cs_queue *queue)
2789 {
2790 wined3d_from_cs(cs);
2791 return *(volatile LONG *)&queue->head == queue->tail;
2792 }
2793
2794 static void wined3d_cs_queue_submit(struct wined3d_cs_queue *queue, struct wined3d_cs *cs)
2795 {
2796 struct wined3d_cs_packet *packet;
2797 size_t packet_size;
2798
2799 packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
2800 packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
2801 InterlockedExchange(&queue->head, (queue->head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1));
2802
2803 if (InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
2804 SetEvent(cs->event);
2805 }
2806
2807 static void wined3d_cs_mt_submit(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
2808 {
2809 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2810
2811 if (cs->thread_id == GetCurrentThreadId())
2812 return wined3d_cs_st_submit(context, queue_id);
2813
2814 wined3d_cs_queue_submit(&cs->queue[queue_id], cs);
2815 }
2816
2817 static void *wined3d_cs_queue_require_space(struct wined3d_cs_queue *queue, size_t size, struct wined3d_cs *cs)
2818 {
2819 size_t queue_size = ARRAY_SIZE(queue->data);
2820 size_t header_size, packet_size, remaining;
2821 struct wined3d_cs_packet *packet;
2822
2823 header_size = FIELD_OFFSET(struct wined3d_cs_packet, data[0]);
2824 packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[size]);
2825 packet_size = (packet_size + header_size - 1) & ~(header_size - 1);
2826 size = packet_size - header_size;
2827 if (packet_size >= WINED3D_CS_QUEUE_SIZE)
2828 {
2829 ERR("Packet size %lu >= queue size %u.\n",
2830 (unsigned long)packet_size, WINED3D_CS_QUEUE_SIZE);
2831 return NULL;
2832 }
2833
2834 remaining = queue_size - queue->head;
2835 if (remaining < packet_size)
2836 {
2837 size_t nop_size = remaining - header_size;
2838 struct wined3d_cs_nop *nop;
2839
2840 TRACE("Inserting a nop for %lu + %lu bytes.\n",
2841 (unsigned long)header_size, (unsigned long)nop_size);
2842
2843 nop = wined3d_cs_queue_require_space(queue, nop_size, cs);
2844 if (nop_size)
2845 nop->opcode = WINED3D_CS_OP_NOP;
2846
2847 wined3d_cs_queue_submit(queue, cs);
2848 assert(!queue->head);
2849 }
2850
2851 for (;;)
2852 {
2853 LONG tail = *(volatile LONG *)&queue->tail;
2854 LONG head = queue->head;
2855 LONG new_pos;
2856
2857 /* Empty. */
2858 if (head == tail)
2859 break;
2860 new_pos = (head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1);
2861 /* Head ahead of tail. We checked the remaining size above, so we only
2862 * need to make sure we don't make head equal to tail. */
2863 if (head > tail && (new_pos != tail))
2864 break;
2865 /* Tail ahead of head. Make sure the new head is before the tail as
2866 * well. Note that new_pos is 0 when it's at the end of the queue. */
2867 if (new_pos < tail && new_pos)
2868 break;
2869
2870 TRACE("Waiting for free space. Head %u, tail %u, packet size %lu.\n",
2871 head, tail, (unsigned long)packet_size);
2872 }
2873
2874 packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
2875 packet->size = size;
2876 return packet->data;
2877 }
2878
2879 static void *wined3d_cs_mt_require_space(struct wined3d_device_context *context,
2880 size_t size, enum wined3d_cs_queue_id queue_id)
2881 {
2882 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2883
2884 if (cs->thread_id == GetCurrentThreadId())
2885 return wined3d_cs_st_require_space(context, size, queue_id);
2886
2887 return wined3d_cs_queue_require_space(&cs->queue[queue_id], size, cs);
2888 }
2889
2890 static void wined3d_cs_mt_finish(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
2891 {
2892 struct wined3d_cs *cs = wined3d_cs_from_context(context);
2893
2894 if (cs->thread_id == GetCurrentThreadId())
2895 return wined3d_cs_st_finish(context, queue_id);
2896
2897 while (cs->queue[queue_id].head != *(volatile LONG *)&cs->queue[queue_id].tail)
2898 YieldProcessor();
2899 }
2900
2901 static const struct wined3d_device_context_ops wined3d_cs_mt_ops =
2902 {
2903 wined3d_cs_mt_require_space,
2904 wined3d_cs_mt_submit,
2905 wined3d_cs_mt_finish,
2906 wined3d_cs_mt_push_constants,
2907 };
2908
2909 static void poll_queries(struct wined3d_cs *cs)
2910 {
2911 struct wined3d_query *query, *cursor;
2912
2913 LIST_FOR_EACH_ENTRY_SAFE(query, cursor, &cs->query_poll_list, struct wined3d_query, poll_list_entry)
2914 {
2915 if (!query->query_ops->query_poll(query, 0))
2916 continue;
2917
2918 list_remove(&query->poll_list_entry);
2919 list_init(&query->poll_list_entry);
2920 InterlockedIncrement(&query->counter_retrieved);
2921 }
2922 }
2923
2924 static void wined3d_cs_wait_event(struct wined3d_cs *cs)
2925 {
2926 InterlockedExchange(&cs->waiting_for_event, TRUE);
2927
2928 /* The main thread might have enqueued a command and blocked on it after
2929 * the CS thread decided to enter wined3d_cs_wait_event(), but before
2930 * "waiting_for_event" was set.
2931 *
2932 * Likewise, we can race with the main thread when resetting
2933 * "waiting_for_event", in which case we would need to call
2934 * WaitForSingleObject() because the main thread called SetEvent(). */
2935 if (!(wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_DEFAULT])
2936 && wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_MAP]))
2937 && InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
2938 return;
2939
2940 WaitForSingleObject(cs->event, INFINITE);
2941 }
2942
2943 static void wined3d_cs_command_lock(const struct wined3d_cs *cs)
2944 {
2945 if (cs->serialize_commands)
2946 EnterCriticalSection(&wined3d_command_cs);
2947 }
2948
2949 static void wined3d_cs_command_unlock(const struct wined3d_cs *cs)
2950 {
2951 if (cs->serialize_commands)
2952 LeaveCriticalSection(&wined3d_command_cs);
2953 }
2954
2955 static DWORD WINAPI wined3d_cs_run(void *ctx)
2956 {
2957 struct wined3d_cs_packet *packet;
2958 struct wined3d_cs_queue *queue;
2959 unsigned int spin_count = 0;
2960 struct wined3d_cs *cs = ctx;
2961 enum wined3d_cs_op opcode;
2962 HMODULE wined3d_module;
2963 unsigned int poll = 0;
2964 LONG tail;
2965
2966 TRACE("Started.\n");
2967
2968 /* Copy the module handle to a local variable to avoid racing with the
2969 * thread freeing "cs" before the FreeLibraryAndExitThread() call. */
2970 wined3d_module = cs->wined3d_module;
2971
2972 list_init(&cs->query_poll_list);
2973 cs->thread_id = GetCurrentThreadId();
2974 for (;;)
2975 {
2976 if (++poll == WINED3D_CS_QUERY_POLL_INTERVAL)
2977 {
2978 wined3d_cs_command_lock(cs);
2979 poll_queries(cs);
2980 wined3d_cs_command_unlock(cs);
2981 poll = 0;
2982 }
2983
2984 queue = &cs->queue[WINED3D_CS_QUEUE_MAP];
2985 if (wined3d_cs_queue_is_empty(cs, queue))
2986 {
2987 queue = &cs->queue[WINED3D_CS_QUEUE_DEFAULT];
2988 if (wined3d_cs_queue_is_empty(cs, queue))
2989 {
2990 if (++spin_count >= WINED3D_CS_SPIN_COUNT && list_empty(&cs->query_poll_list))
2991 wined3d_cs_wait_event(cs);
2992 continue;
2993 }
2994 }
2995 spin_count = 0;
2996
2997 tail = queue->tail;
2998 packet = (struct wined3d_cs_packet *)&queue->data[tail];
2999 if (packet->size)
3000 {
3001 opcode = *(const enum wined3d_cs_op *)packet->data;
3002
3003 TRACE("Executing %s.\n", debug_cs_op(opcode));
3004 if (opcode >= WINED3D_CS_OP_STOP)
3005 {
3006 if (opcode > WINED3D_CS_OP_STOP)
3007 ERR("Invalid opcode %#x.\n", opcode);
3008 break;
3009 }
3010
3011 wined3d_cs_command_lock(cs);
3012 wined3d_cs_op_handlers[opcode](cs, packet->data);
3013 wined3d_cs_command_unlock(cs);
3014 TRACE("%s executed.\n", debug_cs_op(opcode));
3015 }
3016
3017 tail += FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
3018 tail &= (WINED3D_CS_QUEUE_SIZE - 1);
3019 InterlockedExchange(&queue->tail, tail);
3020 }
3021
3022 cs->queue[WINED3D_CS_QUEUE_MAP].tail = cs->queue[WINED3D_CS_QUEUE_MAP].head;
3023 cs->queue[WINED3D_CS_QUEUE_DEFAULT].tail = cs->queue[WINED3D_CS_QUEUE_DEFAULT].head;
3024 TRACE("Stopped.\n");
3025 FreeLibraryAndExitThread(wined3d_module, 0);
3026 }
3027
3028 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device,
3029 const enum wined3d_feature_level *levels, unsigned int level_count)
3030 {
3031 const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
3032 struct wined3d_cs *cs;
3033
3034 if (!(cs = heap_alloc_zero(sizeof(*cs))))
3035 return NULL;
3036
3037 if (FAILED(wined3d_state_create(device, levels, level_count, &cs->c.state)))
3038 {
3039 heap_free(cs);
3040 return NULL;
3041 }
3042
3043 cs->c.ops = &wined3d_cs_st_ops;
3044 cs->c.device = device;
3045 cs->serialize_commands = TRACE_ON(d3d_sync) || wined3d_settings.cs_multithreaded & WINED3D_CSMT_SERIALIZE;
3046
3047 state_init(&cs->state, d3d_info, WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT, cs->c.state->feature_level);
3048
3049 cs->data_size = WINED3D_INITIAL_CS_SIZE;
3050 if (!(cs->data = heap_alloc(cs->data_size)))
3051 goto fail;
3052
3053 if (wined3d_settings.cs_multithreaded & WINED3D_CSMT_ENABLE
3054 && !RtlIsCriticalSectionLockedByThread(NtCurrentTeb()->Peb->LoaderLock))
3055 {
3056 cs->c.ops = &wined3d_cs_mt_ops;
3057
3058 if (!(cs->event = CreateEventW(NULL, FALSE, FALSE, NULL)))
3059 {
3060 ERR("Failed to create command stream event.\n");
3061 heap_free(cs->data);
3062 goto fail;
3063 }
3064
3065 if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
3066 (const WCHAR *)wined3d_cs_run, &cs->wined3d_module)))
3067 {
3068 ERR("Failed to get wined3d module handle.\n");
3069 CloseHandle(cs->event);
3070 heap_free(cs->data);
3071 goto fail;
3072 }
3073
3074 if (!(cs->thread = CreateThread(NULL, 0, wined3d_cs_run, cs, 0, NULL)))
3075 {
3076 ERR("Failed to create wined3d command stream thread.\n");
3077 FreeLibrary(cs->wined3d_module);
3078 CloseHandle(cs->event);
3079 heap_free(cs->data);
3080 goto fail;
3081 }
3082 }
3083
3084 return cs;
3085
3086 fail:
3087 wined3d_state_destroy(cs->c.state);
3088 state_cleanup(&cs->state);
3089 heap_free(cs);
3090 return NULL;
3091 }
3092
3093 void wined3d_cs_destroy(struct wined3d_cs *cs)
3094 {
3095 if (cs->thread)
3096 {
3097 wined3d_cs_emit_stop(cs);
3098 CloseHandle(cs->thread);
3099 if (!CloseHandle(cs->event))
3100 ERR("Closing event failed.\n");
3101 }
3102
3103 wined3d_state_destroy(cs->c.state);
3104 state_cleanup(&cs->state);
3105 heap_free(cs->data);
3106 heap_free(cs);
3107 }
Windows API implementation