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