2 * Copyright 2013 Henri Verbeet for CodeWeavers
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.
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.
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
20 #include "wine/port.h"
21 #include "wined3d_private.h"
23 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
24 WINE_DECLARE_DEBUG_CHANNEL(d3d_sync
);
25 WINE_DECLARE_DEBUG_CHANNEL(fps
);
27 #define WINED3D_INITIAL_CS_SIZE 4096
32 WINED3D_CS_OP_PRESENT
,
34 WINED3D_CS_OP_DISPATCH
,
37 WINED3D_CS_OP_SET_PREDICATION
,
38 WINED3D_CS_OP_SET_VIEWPORTS
,
39 WINED3D_CS_OP_SET_SCISSOR_RECTS
,
40 WINED3D_CS_OP_SET_RENDERTARGET_VIEW
,
41 WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
,
42 WINED3D_CS_OP_SET_VERTEX_DECLARATION
,
43 WINED3D_CS_OP_SET_STREAM_SOURCE
,
44 WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
,
45 WINED3D_CS_OP_SET_STREAM_OUTPUT
,
46 WINED3D_CS_OP_SET_INDEX_BUFFER
,
47 WINED3D_CS_OP_SET_CONSTANT_BUFFER
,
48 WINED3D_CS_OP_SET_TEXTURE
,
49 WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
,
50 WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
,
51 WINED3D_CS_OP_SET_SAMPLER
,
52 WINED3D_CS_OP_SET_SHADER
,
53 WINED3D_CS_OP_SET_BLEND_STATE
,
54 WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE
,
55 WINED3D_CS_OP_SET_RASTERIZER_STATE
,
56 WINED3D_CS_OP_SET_RENDER_STATE
,
57 WINED3D_CS_OP_SET_TEXTURE_STATE
,
58 WINED3D_CS_OP_SET_SAMPLER_STATE
,
59 WINED3D_CS_OP_SET_TRANSFORM
,
60 WINED3D_CS_OP_SET_CLIP_PLANE
,
61 WINED3D_CS_OP_SET_COLOR_KEY
,
62 WINED3D_CS_OP_SET_MATERIAL
,
63 WINED3D_CS_OP_SET_LIGHT
,
64 WINED3D_CS_OP_SET_LIGHT_ENABLE
,
65 WINED3D_CS_OP_SET_FEATURE_LEVEL
,
66 WINED3D_CS_OP_PUSH_CONSTANTS
,
67 WINED3D_CS_OP_RESET_STATE
,
68 WINED3D_CS_OP_CALLBACK
,
69 WINED3D_CS_OP_QUERY_ISSUE
,
70 WINED3D_CS_OP_PRELOAD_RESOURCE
,
71 WINED3D_CS_OP_UNLOAD_RESOURCE
,
74 WINED3D_CS_OP_BLT_SUB_RESOURCE
,
75 WINED3D_CS_OP_UPDATE_SUB_RESOURCE
,
76 WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
,
77 WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
,
78 WINED3D_CS_OP_COPY_UAV_COUNTER
,
79 WINED3D_CS_OP_GENERATE_MIPMAPS
,
83 struct wined3d_cs_packet
91 enum wined3d_cs_op opcode
;
94 struct wined3d_cs_present
96 enum wined3d_cs_op opcode
;
97 HWND dst_window_override
;
98 struct wined3d_swapchain
*swapchain
;
101 unsigned int swap_interval
;
105 struct wined3d_cs_clear
107 enum wined3d_cs_op opcode
;
109 unsigned int rt_count
;
110 struct wined3d_fb_state
*fb
;
112 struct wined3d_color color
;
115 unsigned int rect_count
;
119 struct wined3d_cs_dispatch
121 enum wined3d_cs_op opcode
;
122 struct wined3d_dispatch_parameters parameters
;
125 struct wined3d_cs_draw
127 enum wined3d_cs_op opcode
;
128 enum wined3d_primitive_type primitive_type
;
129 GLint patch_vertex_count
;
130 struct wined3d_draw_parameters parameters
;
133 struct wined3d_cs_flush
135 enum wined3d_cs_op opcode
;
138 struct wined3d_cs_set_predication
140 enum wined3d_cs_op opcode
;
141 struct wined3d_query
*predicate
;
145 struct wined3d_cs_set_viewports
147 enum wined3d_cs_op opcode
;
148 unsigned int viewport_count
;
149 struct wined3d_viewport viewports
[1];
152 struct wined3d_cs_set_scissor_rects
154 enum wined3d_cs_op opcode
;
155 unsigned int rect_count
;
159 struct wined3d_cs_set_rendertarget_view
161 enum wined3d_cs_op opcode
;
162 unsigned int view_idx
;
163 struct wined3d_rendertarget_view
*view
;
166 struct wined3d_cs_set_depth_stencil_view
168 enum wined3d_cs_op opcode
;
169 struct wined3d_rendertarget_view
*view
;
172 struct wined3d_cs_set_vertex_declaration
174 enum wined3d_cs_op opcode
;
175 struct wined3d_vertex_declaration
*declaration
;
178 struct wined3d_cs_set_stream_source
180 enum wined3d_cs_op opcode
;
182 struct wined3d_buffer
*buffer
;
187 struct wined3d_cs_set_stream_source_freq
189 enum wined3d_cs_op opcode
;
195 struct wined3d_cs_set_stream_output
197 enum wined3d_cs_op opcode
;
199 struct wined3d_buffer
*buffer
;
203 struct wined3d_cs_set_index_buffer
205 enum wined3d_cs_op opcode
;
206 struct wined3d_buffer
*buffer
;
207 enum wined3d_format_id format_id
;
211 struct wined3d_cs_set_constant_buffer
213 enum wined3d_cs_op opcode
;
214 enum wined3d_shader_type type
;
216 struct wined3d_buffer
*buffer
;
219 struct wined3d_cs_set_texture
221 enum wined3d_cs_op opcode
;
223 struct wined3d_texture
*texture
;
226 struct wined3d_cs_set_color_key
228 enum wined3d_cs_op opcode
;
229 struct wined3d_texture
*texture
;
232 struct wined3d_color_key color_key
;
235 struct wined3d_cs_set_shader_resource_view
237 enum wined3d_cs_op opcode
;
238 enum wined3d_shader_type type
;
240 struct wined3d_shader_resource_view
*view
;
243 struct wined3d_cs_set_unordered_access_view
245 enum wined3d_cs_op opcode
;
246 enum wined3d_pipeline pipeline
;
247 unsigned int view_idx
;
248 struct wined3d_unordered_access_view
*view
;
249 unsigned int initial_count
;
252 struct wined3d_cs_set_sampler
254 enum wined3d_cs_op opcode
;
255 enum wined3d_shader_type type
;
257 struct wined3d_sampler
*sampler
;
260 struct wined3d_cs_set_shader
262 enum wined3d_cs_op opcode
;
263 enum wined3d_shader_type type
;
264 struct wined3d_shader
*shader
;
267 struct wined3d_cs_set_blend_state
269 enum wined3d_cs_op opcode
;
270 struct wined3d_blend_state
*state
;
271 struct wined3d_color factor
;
272 unsigned int sample_mask
;
275 struct wined3d_cs_set_depth_stencil_state
277 enum wined3d_cs_op opcode
;
278 struct wined3d_depth_stencil_state
*state
;
279 unsigned int stencil_ref
;
282 struct wined3d_cs_set_rasterizer_state
284 enum wined3d_cs_op opcode
;
285 struct wined3d_rasterizer_state
*state
;
288 struct wined3d_cs_set_render_state
290 enum wined3d_cs_op opcode
;
291 enum wined3d_render_state state
;
295 struct wined3d_cs_set_texture_state
297 enum wined3d_cs_op opcode
;
299 enum wined3d_texture_stage_state state
;
303 struct wined3d_cs_set_sampler_state
305 enum wined3d_cs_op opcode
;
307 enum wined3d_sampler_state state
;
311 struct wined3d_cs_set_transform
313 enum wined3d_cs_op opcode
;
314 enum wined3d_transform_state state
;
315 struct wined3d_matrix matrix
;
318 struct wined3d_cs_set_clip_plane
320 enum wined3d_cs_op opcode
;
322 struct wined3d_vec4 plane
;
325 struct wined3d_cs_set_material
327 enum wined3d_cs_op opcode
;
328 struct wined3d_material material
;
331 struct wined3d_cs_set_light
333 enum wined3d_cs_op opcode
;
334 struct wined3d_light_info light
;
337 struct wined3d_cs_set_light_enable
339 enum wined3d_cs_op opcode
;
344 struct wined3d_cs_set_feature_level
346 enum wined3d_cs_op opcode
;
347 enum wined3d_feature_level level
;
350 struct wined3d_cs_push_constants
352 enum wined3d_cs_op opcode
;
353 enum wined3d_push_constants type
;
354 unsigned int start_idx
;
359 struct wined3d_cs_reset_state
361 enum wined3d_cs_op opcode
;
364 struct wined3d_cs_callback
366 enum wined3d_cs_op opcode
;
367 void (*callback
)(void *object
);
371 struct wined3d_cs_query_issue
373 enum wined3d_cs_op opcode
;
374 struct wined3d_query
*query
;
378 struct wined3d_cs_preload_resource
380 enum wined3d_cs_op opcode
;
381 struct wined3d_resource
*resource
;
384 struct wined3d_cs_unload_resource
386 enum wined3d_cs_op opcode
;
387 struct wined3d_resource
*resource
;
390 struct wined3d_cs_map
392 enum wined3d_cs_op opcode
;
393 struct wined3d_resource
*resource
;
394 unsigned int sub_resource_idx
;
395 struct wined3d_map_desc
*map_desc
;
396 const struct wined3d_box
*box
;
401 struct wined3d_cs_unmap
403 enum wined3d_cs_op opcode
;
404 struct wined3d_resource
*resource
;
405 unsigned int sub_resource_idx
;
409 struct wined3d_cs_blt_sub_resource
411 enum wined3d_cs_op opcode
;
412 struct wined3d_resource
*dst_resource
;
413 unsigned int dst_sub_resource_idx
;
414 struct wined3d_box dst_box
;
415 struct wined3d_resource
*src_resource
;
416 unsigned int src_sub_resource_idx
;
417 struct wined3d_box src_box
;
419 struct wined3d_blt_fx fx
;
420 enum wined3d_texture_filter_type filter
;
423 struct wined3d_cs_update_sub_resource
425 enum wined3d_cs_op opcode
;
426 struct wined3d_resource
*resource
;
427 unsigned int sub_resource_idx
;
428 struct wined3d_box box
;
429 struct wined3d_sub_resource_data data
;
432 struct wined3d_cs_add_dirty_texture_region
434 enum wined3d_cs_op opcode
;
435 struct wined3d_texture
*texture
;
439 struct wined3d_cs_clear_unordered_access_view
441 enum wined3d_cs_op opcode
;
442 struct wined3d_unordered_access_view
*view
;
443 struct wined3d_uvec4 clear_value
;
446 struct wined3d_cs_copy_uav_counter
448 enum wined3d_cs_op opcode
;
449 struct wined3d_buffer
*buffer
;
451 struct wined3d_unordered_access_view
*view
;
454 struct wined3d_cs_generate_mipmaps
456 enum wined3d_cs_op opcode
;
457 struct wined3d_shader_resource_view
*view
;
460 struct wined3d_cs_stop
462 enum wined3d_cs_op opcode
;
465 static inline void *wined3d_device_context_require_space(struct wined3d_device_context
*context
,
466 size_t size
, enum wined3d_cs_queue_id queue_id
)
468 return context
->ops
->require_space(context
, size
, queue_id
);
471 static inline void wined3d_device_context_submit(struct wined3d_device_context
*context
,
472 enum wined3d_cs_queue_id queue_id
)
474 context
->ops
->submit(context
, queue_id
);
477 static const char *debug_cs_op(enum wined3d_cs_op op
)
481 #define WINED3D_TO_STR(type) case type: return #type
482 WINED3D_TO_STR(WINED3D_CS_OP_NOP
);
483 WINED3D_TO_STR(WINED3D_CS_OP_PRESENT
);
484 WINED3D_TO_STR(WINED3D_CS_OP_CLEAR
);
485 WINED3D_TO_STR(WINED3D_CS_OP_DISPATCH
);
486 WINED3D_TO_STR(WINED3D_CS_OP_DRAW
);
487 WINED3D_TO_STR(WINED3D_CS_OP_FLUSH
);
488 WINED3D_TO_STR(WINED3D_CS_OP_SET_PREDICATION
);
489 WINED3D_TO_STR(WINED3D_CS_OP_SET_VIEWPORTS
);
490 WINED3D_TO_STR(WINED3D_CS_OP_SET_SCISSOR_RECTS
);
491 WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDERTARGET_VIEW
);
492 WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
);
493 WINED3D_TO_STR(WINED3D_CS_OP_SET_VERTEX_DECLARATION
);
494 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_SOURCE
);
495 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
);
496 WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_OUTPUT
);
497 WINED3D_TO_STR(WINED3D_CS_OP_SET_INDEX_BUFFER
);
498 WINED3D_TO_STR(WINED3D_CS_OP_SET_CONSTANT_BUFFER
);
499 WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE
);
500 WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
);
501 WINED3D_TO_STR(WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
);
502 WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLER
);
503 WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER
);
504 WINED3D_TO_STR(WINED3D_CS_OP_SET_BLEND_STATE
);
505 WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE
);
506 WINED3D_TO_STR(WINED3D_CS_OP_SET_RASTERIZER_STATE
);
507 WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDER_STATE
);
508 WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE_STATE
);
509 WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLER_STATE
);
510 WINED3D_TO_STR(WINED3D_CS_OP_SET_TRANSFORM
);
511 WINED3D_TO_STR(WINED3D_CS_OP_SET_CLIP_PLANE
);
512 WINED3D_TO_STR(WINED3D_CS_OP_SET_COLOR_KEY
);
513 WINED3D_TO_STR(WINED3D_CS_OP_SET_MATERIAL
);
514 WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT
);
515 WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT_ENABLE
);
516 WINED3D_TO_STR(WINED3D_CS_OP_SET_FEATURE_LEVEL
);
517 WINED3D_TO_STR(WINED3D_CS_OP_PUSH_CONSTANTS
);
518 WINED3D_TO_STR(WINED3D_CS_OP_RESET_STATE
);
519 WINED3D_TO_STR(WINED3D_CS_OP_CALLBACK
);
520 WINED3D_TO_STR(WINED3D_CS_OP_QUERY_ISSUE
);
521 WINED3D_TO_STR(WINED3D_CS_OP_PRELOAD_RESOURCE
);
522 WINED3D_TO_STR(WINED3D_CS_OP_UNLOAD_RESOURCE
);
523 WINED3D_TO_STR(WINED3D_CS_OP_MAP
);
524 WINED3D_TO_STR(WINED3D_CS_OP_UNMAP
);
525 WINED3D_TO_STR(WINED3D_CS_OP_BLT_SUB_RESOURCE
);
526 WINED3D_TO_STR(WINED3D_CS_OP_UPDATE_SUB_RESOURCE
);
527 WINED3D_TO_STR(WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
);
528 WINED3D_TO_STR(WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
);
529 WINED3D_TO_STR(WINED3D_CS_OP_COPY_UAV_COUNTER
);
530 WINED3D_TO_STR(WINED3D_CS_OP_GENERATE_MIPMAPS
);
531 WINED3D_TO_STR(WINED3D_CS_OP_STOP
);
532 #undef WINED3D_TO_STR
534 return wine_dbg_sprintf("UNKNOWN_OP(%#x)", op
);
537 static void wined3d_cs_exec_nop(struct wined3d_cs
*cs
, const void *data
)
541 static void wined3d_cs_exec_present(struct wined3d_cs
*cs
, const void *data
)
543 struct wined3d_texture
*logo_texture
, *cursor_texture
, *back_buffer
;
544 struct wined3d_rendertarget_view
*dsv
= cs
->state
.fb
.depth_stencil
;
545 const struct wined3d_cs_present
*op
= data
;
546 const struct wined3d_swapchain_desc
*desc
;
547 struct wined3d_swapchain
*swapchain
;
550 swapchain
= op
->swapchain
;
551 desc
= &swapchain
->state
.desc
;
552 back_buffer
= swapchain
->back_buffers
[0];
553 wined3d_swapchain_set_window(swapchain
, op
->dst_window_override
);
555 if ((logo_texture
= swapchain
->device
->logo_texture
))
557 RECT rect
= {0, 0, logo_texture
->resource
.width
, logo_texture
->resource
.height
};
559 /* Blit the logo into the upper left corner of the back-buffer. */
560 wined3d_texture_blt(back_buffer
, 0, &rect
, logo_texture
, 0,
561 &rect
, WINED3D_BLT_SRC_CKEY
, NULL
, WINED3D_TEXF_POINT
);
564 if ((cursor_texture
= swapchain
->device
->cursor_texture
)
565 && swapchain
->device
->bCursorVisible
&& !swapchain
->device
->hardwareCursor
)
569 swapchain
->device
->xScreenSpace
- swapchain
->device
->xHotSpot
,
570 swapchain
->device
->yScreenSpace
- swapchain
->device
->yHotSpot
,
571 swapchain
->device
->xScreenSpace
+ swapchain
->device
->cursorWidth
- swapchain
->device
->xHotSpot
,
572 swapchain
->device
->yScreenSpace
+ swapchain
->device
->cursorHeight
- swapchain
->device
->yHotSpot
,
576 0, 0, cursor_texture
->resource
.width
, cursor_texture
->resource
.height
578 const RECT clip_rect
= {0, 0, back_buffer
->resource
.width
, back_buffer
->resource
.height
};
580 TRACE("Rendering the software cursor.\n");
583 MapWindowPoints(NULL
, swapchain
->win_handle
, (POINT
*)&dst_rect
, 2);
584 if (wined3d_clip_blit(&clip_rect
, &dst_rect
, &src_rect
))
585 wined3d_texture_blt(back_buffer
, 0, &dst_rect
, cursor_texture
, 0,
586 &src_rect
, WINED3D_BLT_ALPHA_TEST
, NULL
, WINED3D_TEXF_POINT
);
589 swapchain
->swapchain_ops
->swapchain_present(swapchain
, &op
->src_rect
, &op
->dst_rect
, op
->swap_interval
, op
->flags
);
591 /* Discard buffers if the swap effect allows it. */
592 back_buffer
= swapchain
->back_buffers
[desc
->backbuffer_count
- 1];
593 if (desc
->swap_effect
== WINED3D_SWAP_EFFECT_DISCARD
|| desc
->swap_effect
== WINED3D_SWAP_EFFECT_FLIP_DISCARD
)
594 wined3d_texture_validate_location(back_buffer
, 0, WINED3D_LOCATION_DISCARDED
);
596 if (dsv
&& dsv
->resource
->type
!= WINED3D_RTYPE_BUFFER
)
598 struct wined3d_texture
*ds
= texture_from_resource(dsv
->resource
);
600 if ((desc
->flags
& WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
|| ds
->flags
& WINED3D_TEXTURE_DISCARD
))
601 wined3d_rendertarget_view_validate_location(dsv
, WINED3D_LOCATION_DISCARDED
);
606 DWORD time
= GetTickCount();
609 /* every 1.5 seconds */
610 if (time
- swapchain
->prev_time
> 1500)
612 TRACE_(fps
)("%p @ approx %.2ffps\n",
613 swapchain
, 1000.0 * swapchain
->frames
/ (time
- swapchain
->prev_time
));
614 swapchain
->prev_time
= time
;
615 swapchain
->frames
= 0;
619 wined3d_resource_release(&swapchain
->front_buffer
->resource
);
620 for (i
= 0; i
< desc
->backbuffer_count
; ++i
)
622 wined3d_resource_release(&swapchain
->back_buffers
[i
]->resource
);
625 InterlockedDecrement(&cs
->pending_presents
);
628 void wined3d_cs_emit_present(struct wined3d_cs
*cs
, struct wined3d_swapchain
*swapchain
,
629 const RECT
*src_rect
, const RECT
*dst_rect
, HWND dst_window_override
,
630 unsigned int swap_interval
, DWORD flags
)
632 struct wined3d_cs_present
*op
;
636 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
637 op
->opcode
= WINED3D_CS_OP_PRESENT
;
638 op
->dst_window_override
= dst_window_override
;
639 op
->swapchain
= swapchain
;
640 op
->src_rect
= *src_rect
;
641 op
->dst_rect
= *dst_rect
;
642 op
->swap_interval
= swap_interval
;
645 pending
= InterlockedIncrement(&cs
->pending_presents
);
647 wined3d_resource_acquire(&swapchain
->front_buffer
->resource
);
648 for (i
= 0; i
< swapchain
->state
.desc
.backbuffer_count
; ++i
)
650 wined3d_resource_acquire(&swapchain
->back_buffers
[i
]->resource
);
653 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
655 /* Limit input latency by limiting the number of presents that we can get
656 * ahead of the worker thread. */
657 while (pending
>= swapchain
->max_frame_latency
)
660 pending
= InterlockedCompareExchange(&cs
->pending_presents
, 0, 0);
664 static void wined3d_cs_exec_clear(struct wined3d_cs
*cs
, const void *data
)
666 struct wined3d_device
*device
= cs
->c
.device
;
667 const struct wined3d_cs_clear
*op
= data
;
670 device
->blitter
->ops
->blitter_clear(device
->blitter
, device
, op
->rt_count
, op
->fb
,
671 op
->rect_count
, op
->rects
, &op
->draw_rect
, op
->flags
, &op
->color
, op
->depth
, op
->stencil
);
673 if (op
->flags
& WINED3DCLEAR_TARGET
)
675 for (i
= 0; i
< op
->rt_count
; ++i
)
677 if (op
->fb
->render_targets
[i
])
678 wined3d_resource_release(op
->fb
->render_targets
[i
]->resource
);
681 if (op
->flags
& (WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
))
682 wined3d_resource_release(op
->fb
->depth_stencil
->resource
);
685 void wined3d_cs_emit_clear(struct wined3d_cs
*cs
, DWORD rect_count
, const RECT
*rects
,
686 DWORD flags
, const struct wined3d_color
*color
, float depth
, DWORD stencil
)
688 const struct wined3d_state
*state
= cs
->c
.state
;
689 const struct wined3d_viewport
*vp
= &state
->viewports
[0];
690 struct wined3d_rendertarget_view
*view
;
691 struct wined3d_cs_clear
*op
;
692 unsigned int rt_count
, i
;
694 rt_count
= flags
& WINED3DCLEAR_TARGET
? cs
->c
.device
->adapter
->d3d_info
.limits
.max_rt_count
: 0;
696 op
= wined3d_device_context_require_space(&cs
->c
, FIELD_OFFSET(struct wined3d_cs_clear
, rects
[rect_count
]),
697 WINED3D_CS_QUEUE_DEFAULT
);
698 op
->opcode
= WINED3D_CS_OP_CLEAR
;
699 op
->flags
= flags
& (WINED3DCLEAR_TARGET
| WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
);
700 op
->rt_count
= rt_count
;
701 op
->fb
= &cs
->state
.fb
;
702 SetRect(&op
->draw_rect
, vp
->x
, vp
->y
, vp
->x
+ vp
->width
, vp
->y
+ vp
->height
);
703 if (state
->rasterizer_state
&& state
->rasterizer_state
->desc
.scissor
)
704 IntersectRect(&op
->draw_rect
, &op
->draw_rect
, &state
->scissor_rects
[0]);
707 op
->stencil
= stencil
;
708 op
->rect_count
= rect_count
;
709 memcpy(op
->rects
, rects
, sizeof(*rects
) * rect_count
);
711 for (i
= 0; i
< rt_count
; ++i
)
713 if ((view
= state
->fb
.render_targets
[i
]))
714 wined3d_resource_acquire(view
->resource
);
716 if (flags
& (WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
))
718 view
= state
->fb
.depth_stencil
;
719 wined3d_resource_acquire(view
->resource
);
722 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
725 void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs
*cs
, struct wined3d_rendertarget_view
*view
,
726 const RECT
*rect
, DWORD flags
, const struct wined3d_color
*color
, float depth
, DWORD stencil
)
728 struct wined3d_cs_clear
*op
;
731 size
= FIELD_OFFSET(struct wined3d_cs_clear
, rects
[1]) + sizeof(struct wined3d_fb_state
);
732 op
= wined3d_device_context_require_space(&cs
->c
, size
, WINED3D_CS_QUEUE_DEFAULT
);
733 op
->fb
= (void *)&op
->rects
[1];
735 op
->opcode
= WINED3D_CS_OP_CLEAR
;
736 op
->flags
= flags
& (WINED3DCLEAR_TARGET
| WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
);
737 if (flags
& WINED3DCLEAR_TARGET
)
740 op
->fb
->render_targets
[0] = view
;
741 op
->fb
->depth_stencil
= NULL
;
747 op
->fb
->render_targets
[0] = NULL
;
748 op
->fb
->depth_stencil
= view
;
750 op
->stencil
= stencil
;
752 SetRect(&op
->draw_rect
, 0, 0, view
->width
, view
->height
);
754 op
->rects
[0] = *rect
;
756 wined3d_resource_acquire(view
->resource
);
758 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
759 if (flags
& WINED3DCLEAR_SYNCHRONOUS
)
760 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_DEFAULT
);
763 static void acquire_shader_resources(const struct wined3d_state
*state
, unsigned int shader_mask
)
765 struct wined3d_shader_sampler_map_entry
*entry
;
766 struct wined3d_shader_resource_view
*view
;
767 struct wined3d_shader
*shader
;
770 for (i
= 0; i
< WINED3D_SHADER_TYPE_COUNT
; ++i
)
772 if (!(shader_mask
& (1u << i
)))
775 if (!(shader
= state
->shader
[i
]))
778 for (j
= 0; j
< WINED3D_MAX_CBS
; ++j
)
781 wined3d_resource_acquire(&state
->cb
[i
][j
]->resource
);
784 for (j
= 0; j
< shader
->reg_maps
.sampler_map
.count
; ++j
)
786 entry
= &shader
->reg_maps
.sampler_map
.entries
[j
];
788 if (!(view
= state
->shader_resource_view
[i
][entry
->resource_idx
]))
791 wined3d_resource_acquire(view
->resource
);
796 static void release_shader_resources(const struct wined3d_state
*state
, unsigned int shader_mask
)
798 struct wined3d_shader_sampler_map_entry
*entry
;
799 struct wined3d_shader_resource_view
*view
;
800 struct wined3d_shader
*shader
;
803 for (i
= 0; i
< WINED3D_SHADER_TYPE_COUNT
; ++i
)
805 if (!(shader_mask
& (1u << i
)))
808 if (!(shader
= state
->shader
[i
]))
811 for (j
= 0; j
< WINED3D_MAX_CBS
; ++j
)
814 wined3d_resource_release(&state
->cb
[i
][j
]->resource
);
817 for (j
= 0; j
< shader
->reg_maps
.sampler_map
.count
; ++j
)
819 entry
= &shader
->reg_maps
.sampler_map
.entries
[j
];
821 if (!(view
= state
->shader_resource_view
[i
][entry
->resource_idx
]))
824 wined3d_resource_release(view
->resource
);
829 static void acquire_unordered_access_resources(const struct wined3d_shader
*shader
,
830 struct wined3d_unordered_access_view
* const *views
)
837 for (i
= 0; i
< MAX_UNORDERED_ACCESS_VIEWS
; ++i
)
839 if (!shader
->reg_maps
.uav_resource_info
[i
].type
)
845 wined3d_resource_acquire(views
[i
]->resource
);
849 static void release_unordered_access_resources(const struct wined3d_shader
*shader
,
850 struct wined3d_unordered_access_view
* const *views
)
857 for (i
= 0; i
< MAX_UNORDERED_ACCESS_VIEWS
; ++i
)
859 if (!shader
->reg_maps
.uav_resource_info
[i
].type
)
865 wined3d_resource_release(views
[i
]->resource
);
869 static void wined3d_cs_exec_dispatch(struct wined3d_cs
*cs
, const void *data
)
871 const struct wined3d_cs_dispatch
*op
= data
;
872 struct wined3d_state
*state
= &cs
->state
;
874 if (!state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
])
875 WARN("No compute shader bound, skipping dispatch.\n");
877 cs
->c
.device
->adapter
->adapter_ops
->adapter_dispatch_compute(cs
->c
.device
, state
, &op
->parameters
);
879 if (op
->parameters
.indirect
)
880 wined3d_resource_release(&op
->parameters
.u
.indirect
.buffer
->resource
);
882 release_shader_resources(state
, 1u << WINED3D_SHADER_TYPE_COMPUTE
);
883 release_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
],
884 state
->unordered_access_view
[WINED3D_PIPELINE_COMPUTE
]);
887 static void acquire_compute_pipeline_resources(const struct wined3d_state
*state
)
889 acquire_shader_resources(state
, 1u << WINED3D_SHADER_TYPE_COMPUTE
);
890 acquire_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
],
891 state
->unordered_access_view
[WINED3D_PIPELINE_COMPUTE
]);
894 void CDECL
wined3d_device_context_dispatch(struct wined3d_device_context
*context
,
895 unsigned int group_count_x
, unsigned int group_count_y
, unsigned int group_count_z
)
897 struct wined3d_cs_dispatch
*op
;
899 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
900 op
->opcode
= WINED3D_CS_OP_DISPATCH
;
901 op
->parameters
.indirect
= FALSE
;
902 op
->parameters
.u
.direct
.group_count_x
= group_count_x
;
903 op
->parameters
.u
.direct
.group_count_y
= group_count_y
;
904 op
->parameters
.u
.direct
.group_count_z
= group_count_z
;
906 acquire_compute_pipeline_resources(context
->state
);
908 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
911 void CDECL
wined3d_device_context_dispatch_indirect(struct wined3d_device_context
*context
,
912 struct wined3d_buffer
*buffer
, unsigned int offset
)
914 struct wined3d_cs_dispatch
*op
;
916 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
917 op
->opcode
= WINED3D_CS_OP_DISPATCH
;
918 op
->parameters
.indirect
= TRUE
;
919 op
->parameters
.u
.indirect
.buffer
= buffer
;
920 op
->parameters
.u
.indirect
.offset
= offset
;
922 acquire_compute_pipeline_resources(context
->state
);
923 wined3d_resource_acquire(&buffer
->resource
);
925 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
928 static void wined3d_cs_exec_draw(struct wined3d_cs
*cs
, const void *data
)
930 const struct wined3d_d3d_info
*d3d_info
= &cs
->c
.device
->adapter
->d3d_info
;
931 const struct wined3d_shader
*geometry_shader
;
932 struct wined3d_device
*device
= cs
->c
.device
;
933 int base_vertex_idx
, load_base_vertex_idx
;
934 struct wined3d_state
*state
= &cs
->state
;
935 const struct wined3d_cs_draw
*op
= data
;
939 if (!op
->parameters
.indirect
)
941 const struct wined3d_direct_draw_parameters
*direct
= &op
->parameters
.u
.direct
;
943 if (op
->parameters
.indexed
&& d3d_info
->draw_base_vertex_offset
)
944 base_vertex_idx
= direct
->base_vertex_idx
;
945 else if (!op
->parameters
.indexed
)
946 base_vertex_idx
= direct
->start_idx
;
949 /* ARB_draw_indirect always supports a base vertex offset. */
950 if (!op
->parameters
.indirect
&& !d3d_info
->draw_base_vertex_offset
)
951 load_base_vertex_idx
= op
->parameters
.u
.direct
.base_vertex_idx
;
953 load_base_vertex_idx
= 0;
955 if (state
->base_vertex_index
!= base_vertex_idx
)
957 state
->base_vertex_index
= base_vertex_idx
;
958 for (i
= 0; i
< device
->context_count
; ++i
)
959 device
->contexts
[i
]->constant_update_mask
|= WINED3D_SHADER_CONST_BASE_VERTEX_ID
;
962 if (state
->load_base_vertex_index
!= load_base_vertex_idx
)
964 state
->load_base_vertex_index
= load_base_vertex_idx
;
965 device_invalidate_state(cs
->c
.device
, STATE_BASEVERTEXINDEX
);
968 if (state
->primitive_type
!= op
->primitive_type
)
970 if ((geometry_shader
= state
->shader
[WINED3D_SHADER_TYPE_GEOMETRY
]) && !geometry_shader
->function
)
971 device_invalidate_state(cs
->c
.device
, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
));
972 if (state
->primitive_type
== WINED3D_PT_POINTLIST
|| op
->primitive_type
== WINED3D_PT_POINTLIST
)
973 device_invalidate_state(cs
->c
.device
, STATE_POINT_ENABLE
);
974 state
->primitive_type
= op
->primitive_type
;
976 state
->patch_vertex_count
= op
->patch_vertex_count
;
978 cs
->c
.device
->adapter
->adapter_ops
->adapter_draw_primitive(cs
->c
.device
, state
, &op
->parameters
);
980 if (op
->parameters
.indirect
)
982 struct wined3d_buffer
*buffer
= op
->parameters
.u
.indirect
.buffer
;
983 wined3d_resource_release(&buffer
->resource
);
986 if (op
->parameters
.indexed
)
987 wined3d_resource_release(&state
->index_buffer
->resource
);
988 for (i
= 0; i
< ARRAY_SIZE(state
->streams
); ++i
)
990 if (state
->streams
[i
].buffer
)
991 wined3d_resource_release(&state
->streams
[i
].buffer
->resource
);
993 for (i
= 0; i
< ARRAY_SIZE(state
->stream_output
); ++i
)
995 if (state
->stream_output
[i
].buffer
)
996 wined3d_resource_release(&state
->stream_output
[i
].buffer
->resource
);
998 for (i
= 0; i
< ARRAY_SIZE(state
->textures
); ++i
)
1000 if (state
->textures
[i
])
1001 wined3d_resource_release(&state
->textures
[i
]->resource
);
1003 for (i
= 0; i
< d3d_info
->limits
.max_rt_count
; ++i
)
1005 if (state
->fb
.render_targets
[i
])
1006 wined3d_resource_release(state
->fb
.render_targets
[i
]->resource
);
1008 if (state
->fb
.depth_stencil
)
1009 wined3d_resource_release(state
->fb
.depth_stencil
->resource
);
1010 release_shader_resources(state
, ~(1u << WINED3D_SHADER_TYPE_COMPUTE
));
1011 release_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_PIXEL
],
1012 state
->unordered_access_view
[WINED3D_PIPELINE_GRAPHICS
]);
1015 static void acquire_graphics_pipeline_resources(const struct wined3d_state
*state
,
1016 BOOL indexed
, const struct wined3d_d3d_info
*d3d_info
)
1021 wined3d_resource_acquire(&state
->index_buffer
->resource
);
1022 for (i
= 0; i
< ARRAY_SIZE(state
->streams
); ++i
)
1024 if (state
->streams
[i
].buffer
)
1025 wined3d_resource_acquire(&state
->streams
[i
].buffer
->resource
);
1027 for (i
= 0; i
< ARRAY_SIZE(state
->stream_output
); ++i
)
1029 if (state
->stream_output
[i
].buffer
)
1030 wined3d_resource_acquire(&state
->stream_output
[i
].buffer
->resource
);
1032 for (i
= 0; i
< ARRAY_SIZE(state
->textures
); ++i
)
1034 if (state
->textures
[i
])
1035 wined3d_resource_acquire(&state
->textures
[i
]->resource
);
1037 for (i
= 0; i
< d3d_info
->limits
.max_rt_count
; ++i
)
1039 if (state
->fb
.render_targets
[i
])
1040 wined3d_resource_acquire(state
->fb
.render_targets
[i
]->resource
);
1042 if (state
->fb
.depth_stencil
)
1043 wined3d_resource_acquire(state
->fb
.depth_stencil
->resource
);
1044 acquire_shader_resources(state
, ~(1u << WINED3D_SHADER_TYPE_COMPUTE
));
1045 acquire_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_PIXEL
],
1046 state
->unordered_access_view
[WINED3D_PIPELINE_GRAPHICS
]);
1049 void wined3d_cs_emit_draw(struct wined3d_cs
*cs
, enum wined3d_primitive_type primitive_type
,
1050 unsigned int patch_vertex_count
, int base_vertex_idx
, unsigned int start_idx
,
1051 unsigned int index_count
, unsigned int start_instance
, unsigned int instance_count
, bool indexed
)
1053 const struct wined3d_d3d_info
*d3d_info
= &cs
->c
.device
->adapter
->d3d_info
;
1054 const struct wined3d_state
*state
= cs
->c
.state
;
1055 struct wined3d_cs_draw
*op
;
1057 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1058 op
->opcode
= WINED3D_CS_OP_DRAW
;
1059 op
->primitive_type
= primitive_type
;
1060 op
->patch_vertex_count
= patch_vertex_count
;
1061 op
->parameters
.indirect
= FALSE
;
1062 op
->parameters
.u
.direct
.base_vertex_idx
= base_vertex_idx
;
1063 op
->parameters
.u
.direct
.start_idx
= start_idx
;
1064 op
->parameters
.u
.direct
.index_count
= index_count
;
1065 op
->parameters
.u
.direct
.start_instance
= start_instance
;
1066 op
->parameters
.u
.direct
.instance_count
= instance_count
;
1067 op
->parameters
.indexed
= indexed
;
1069 acquire_graphics_pipeline_resources(state
, indexed
, d3d_info
);
1071 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1074 void wined3d_cs_emit_draw_indirect(struct wined3d_cs
*cs
, enum wined3d_primitive_type primitive_type
,
1075 unsigned int patch_vertex_count
, struct wined3d_buffer
*buffer
, unsigned int offset
, bool indexed
)
1077 const struct wined3d_d3d_info
*d3d_info
= &cs
->c
.device
->adapter
->d3d_info
;
1078 const struct wined3d_state
*state
= cs
->c
.state
;
1079 struct wined3d_cs_draw
*op
;
1081 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1082 op
->opcode
= WINED3D_CS_OP_DRAW
;
1083 op
->primitive_type
= primitive_type
;
1084 op
->patch_vertex_count
= patch_vertex_count
;
1085 op
->parameters
.indirect
= TRUE
;
1086 op
->parameters
.u
.indirect
.buffer
= buffer
;
1087 op
->parameters
.u
.indirect
.offset
= offset
;
1088 op
->parameters
.indexed
= indexed
;
1090 acquire_graphics_pipeline_resources(state
, indexed
, d3d_info
);
1091 wined3d_resource_acquire(&buffer
->resource
);
1093 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1096 static void wined3d_cs_exec_flush(struct wined3d_cs
*cs
, const void *data
)
1098 struct wined3d_context
*context
;
1100 context
= context_acquire(cs
->c
.device
, NULL
, 0);
1101 cs
->c
.device
->adapter
->adapter_ops
->adapter_flush_context(context
);
1102 context_release(context
);
1105 void wined3d_cs_emit_flush(struct wined3d_cs
*cs
)
1107 struct wined3d_cs_flush
*op
;
1109 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1110 op
->opcode
= WINED3D_CS_OP_FLUSH
;
1112 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1113 cs
->queries_flushed
= TRUE
;
1116 static void wined3d_cs_exec_set_predication(struct wined3d_cs
*cs
, const void *data
)
1118 const struct wined3d_cs_set_predication
*op
= data
;
1120 cs
->state
.predicate
= op
->predicate
;
1121 cs
->state
.predicate_value
= op
->value
;
1124 void wined3d_device_context_emit_set_predication(struct wined3d_device_context
*context
,
1125 struct wined3d_query
*predicate
, BOOL value
)
1127 struct wined3d_cs_set_predication
*op
;
1129 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1130 op
->opcode
= WINED3D_CS_OP_SET_PREDICATION
;
1131 op
->predicate
= predicate
;
1134 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1137 static void wined3d_cs_exec_set_viewports(struct wined3d_cs
*cs
, const void *data
)
1139 const struct wined3d_cs_set_viewports
*op
= data
;
1141 if (op
->viewport_count
)
1142 memcpy(cs
->state
.viewports
, op
->viewports
, op
->viewport_count
* sizeof(*op
->viewports
));
1144 memset(cs
->state
.viewports
, 0, sizeof(*cs
->state
.viewports
));
1145 cs
->state
.viewport_count
= op
->viewport_count
;
1146 device_invalidate_state(cs
->c
.device
, STATE_VIEWPORT
);
1149 void wined3d_device_context_emit_set_viewports(struct wined3d_device_context
*context
, unsigned int viewport_count
,
1150 const struct wined3d_viewport
*viewports
)
1152 struct wined3d_cs_set_viewports
*op
;
1154 op
= wined3d_device_context_require_space(context
,
1155 FIELD_OFFSET(struct wined3d_cs_set_viewports
,viewports
[viewport_count
]), WINED3D_CS_QUEUE_DEFAULT
);
1156 op
->opcode
= WINED3D_CS_OP_SET_VIEWPORTS
;
1157 memcpy(op
->viewports
, viewports
, viewport_count
* sizeof(*viewports
));
1158 op
->viewport_count
= viewport_count
;
1160 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1163 static void wined3d_cs_exec_set_scissor_rects(struct wined3d_cs
*cs
, const void *data
)
1165 const struct wined3d_cs_set_scissor_rects
*op
= data
;
1168 memcpy(cs
->state
.scissor_rects
, op
->rects
, op
->rect_count
* sizeof(*op
->rects
));
1170 SetRectEmpty(cs
->state
.scissor_rects
);
1171 cs
->state
.scissor_rect_count
= op
->rect_count
;
1172 device_invalidate_state(cs
->c
.device
, STATE_SCISSORRECT
);
1175 void wined3d_device_context_emit_set_scissor_rects(struct wined3d_device_context
*context
,
1176 unsigned int rect_count
, const RECT
*rects
)
1178 struct wined3d_cs_set_scissor_rects
*op
;
1180 op
= wined3d_device_context_require_space(context
, FIELD_OFFSET(struct wined3d_cs_set_scissor_rects
, rects
[rect_count
]),
1181 WINED3D_CS_QUEUE_DEFAULT
);
1182 op
->opcode
= WINED3D_CS_OP_SET_SCISSOR_RECTS
;
1183 memcpy(op
->rects
, rects
, rect_count
* sizeof(*rects
));
1184 op
->rect_count
= rect_count
;
1186 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1189 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs
*cs
, const void *data
)
1191 const struct wined3d_cs_set_rendertarget_view
*op
= data
;
1192 bool prev_alpha_swizzle
, curr_alpha_swizzle
;
1193 struct wined3d_rendertarget_view
*prev
;
1194 bool prev_srgb_write
, curr_srgb_write
;
1195 struct wined3d_device
*device
;
1197 device
= cs
->c
.device
;
1198 prev
= cs
->state
.fb
.render_targets
[op
->view_idx
];
1199 cs
->state
.fb
.render_targets
[op
->view_idx
] = op
->view
;
1200 device_invalidate_state(device
, STATE_FRAMEBUFFER
);
1202 prev_alpha_swizzle
= prev
&& prev
->format
->id
== WINED3DFMT_A8_UNORM
;
1203 curr_alpha_swizzle
= op
->view
&& op
->view
->format
->id
== WINED3DFMT_A8_UNORM
;
1204 if (prev_alpha_swizzle
!= curr_alpha_swizzle
)
1205 device_invalidate_state(device
, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
));
1207 if (!(device
->adapter
->d3d_info
.wined3d_creation_flags
& WINED3D_SRGB_READ_WRITE_CONTROL
)
1208 || cs
->state
.render_states
[WINED3D_RS_SRGBWRITEENABLE
])
1210 prev_srgb_write
= prev
&& prev
->format_flags
& WINED3DFMT_FLAG_SRGB_WRITE
;
1211 curr_srgb_write
= op
->view
&& op
->view
->format_flags
& WINED3DFMT_FLAG_SRGB_WRITE
;
1212 if (prev_srgb_write
!= curr_srgb_write
)
1213 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
));
1217 void wined3d_device_context_emit_set_rendertarget_view(struct wined3d_device_context
*context
, unsigned int view_idx
,
1218 struct wined3d_rendertarget_view
*view
)
1220 struct wined3d_cs_set_rendertarget_view
*op
;
1222 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1223 op
->opcode
= WINED3D_CS_OP_SET_RENDERTARGET_VIEW
;
1224 op
->view_idx
= view_idx
;
1227 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1230 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs
*cs
, const void *data
)
1232 const struct wined3d_cs_set_depth_stencil_view
*op
= data
;
1233 struct wined3d_device
*device
= cs
->c
.device
;
1234 struct wined3d_rendertarget_view
*prev
;
1236 if ((prev
= cs
->state
.fb
.depth_stencil
) && prev
->resource
->type
!= WINED3D_RTYPE_BUFFER
)
1238 struct wined3d_texture
*prev_texture
= texture_from_resource(prev
->resource
);
1240 if (device
->swapchains
[0]->state
.desc
.flags
& WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1241 || prev_texture
->flags
& WINED3D_TEXTURE_DISCARD
)
1242 wined3d_texture_validate_location(prev_texture
,
1243 prev
->sub_resource_idx
, WINED3D_LOCATION_DISCARDED
);
1246 cs
->state
.fb
.depth_stencil
= op
->view
;
1248 if (!prev
!= !op
->view
)
1250 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1251 device_invalidate_state(device
, STATE_DEPTH_STENCIL
);
1252 device_invalidate_state(device
, STATE_STENCIL_REF
);
1253 device_invalidate_state(device
, STATE_RASTERIZER
);
1257 if (prev
->format
->depth_bias_scale
!= op
->view
->format
->depth_bias_scale
)
1258 device_invalidate_state(device
, STATE_RASTERIZER
);
1259 if (prev
->format
->stencil_size
!= op
->view
->format
->stencil_size
)
1260 device_invalidate_state(device
, STATE_STENCIL_REF
);
1263 device_invalidate_state(device
, STATE_FRAMEBUFFER
);
1266 void wined3d_device_context_emit_set_depth_stencil_view(struct wined3d_device_context
*context
,
1267 struct wined3d_rendertarget_view
*view
)
1269 struct wined3d_cs_set_depth_stencil_view
*op
;
1271 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1272 op
->opcode
= WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
;
1275 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1278 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs
*cs
, const void *data
)
1280 const struct wined3d_cs_set_vertex_declaration
*op
= data
;
1282 cs
->state
.vertex_declaration
= op
->declaration
;
1283 device_invalidate_state(cs
->c
.device
, STATE_VDECL
);
1286 void wined3d_device_context_emit_set_vertex_declaration(struct wined3d_device_context
*context
,
1287 struct wined3d_vertex_declaration
*declaration
)
1289 struct wined3d_cs_set_vertex_declaration
*op
;
1291 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1292 op
->opcode
= WINED3D_CS_OP_SET_VERTEX_DECLARATION
;
1293 op
->declaration
= declaration
;
1295 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1298 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs
*cs
, const void *data
)
1300 const struct wined3d_cs_set_stream_source
*op
= data
;
1301 struct wined3d_stream_state
*stream
;
1302 struct wined3d_buffer
*prev
;
1304 stream
= &cs
->state
.streams
[op
->stream_idx
];
1305 prev
= stream
->buffer
;
1306 stream
->buffer
= op
->buffer
;
1307 stream
->offset
= op
->offset
;
1308 stream
->stride
= op
->stride
;
1311 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1313 InterlockedDecrement(&prev
->resource
.bind_count
);
1315 device_invalidate_state(cs
->c
.device
, STATE_STREAMSRC
);
1318 void wined3d_device_context_emit_set_stream_source(struct wined3d_device_context
*context
, unsigned int stream_idx
,
1319 struct wined3d_buffer
*buffer
, unsigned int offset
, unsigned int stride
)
1321 struct wined3d_cs_set_stream_source
*op
;
1323 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1324 op
->opcode
= WINED3D_CS_OP_SET_STREAM_SOURCE
;
1325 op
->stream_idx
= stream_idx
;
1326 op
->buffer
= buffer
;
1327 op
->offset
= offset
;
1328 op
->stride
= stride
;
1330 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1333 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs
*cs
, const void *data
)
1335 const struct wined3d_cs_set_stream_source_freq
*op
= data
;
1336 struct wined3d_stream_state
*stream
;
1338 stream
= &cs
->state
.streams
[op
->stream_idx
];
1339 stream
->frequency
= op
->frequency
;
1340 stream
->flags
= op
->flags
;
1342 device_invalidate_state(cs
->c
.device
, STATE_STREAMSRC
);
1345 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs
*cs
, UINT stream_idx
, UINT frequency
, UINT flags
)
1347 struct wined3d_cs_set_stream_source_freq
*op
;
1349 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1350 op
->opcode
= WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
;
1351 op
->stream_idx
= stream_idx
;
1352 op
->frequency
= frequency
;
1355 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1358 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs
*cs
, const void *data
)
1360 const struct wined3d_cs_set_stream_output
*op
= data
;
1361 struct wined3d_stream_output
*stream
;
1362 struct wined3d_buffer
*prev
;
1364 stream
= &cs
->state
.stream_output
[op
->stream_idx
];
1365 prev
= stream
->buffer
;
1366 stream
->buffer
= op
->buffer
;
1367 stream
->offset
= op
->offset
;
1370 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1372 InterlockedDecrement(&prev
->resource
.bind_count
);
1374 device_invalidate_state(cs
->c
.device
, STATE_STREAM_OUTPUT
);
1377 void wined3d_device_context_emit_set_stream_output(struct wined3d_device_context
*context
, unsigned int stream_idx
,
1378 struct wined3d_buffer
*buffer
, unsigned int offset
)
1380 struct wined3d_cs_set_stream_output
*op
;
1382 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1383 op
->opcode
= WINED3D_CS_OP_SET_STREAM_OUTPUT
;
1384 op
->stream_idx
= stream_idx
;
1385 op
->buffer
= buffer
;
1386 op
->offset
= offset
;
1388 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1391 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs
*cs
, const void *data
)
1393 const struct wined3d_cs_set_index_buffer
*op
= data
;
1394 struct wined3d_buffer
*prev
;
1396 prev
= cs
->state
.index_buffer
;
1397 cs
->state
.index_buffer
= op
->buffer
;
1398 cs
->state
.index_format
= op
->format_id
;
1399 cs
->state
.index_offset
= op
->offset
;
1402 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1404 InterlockedDecrement(&prev
->resource
.bind_count
);
1406 device_invalidate_state(cs
->c
.device
, STATE_INDEXBUFFER
);
1409 void wined3d_device_context_emit_set_index_buffer(struct wined3d_device_context
*context
, struct wined3d_buffer
*buffer
,
1410 enum wined3d_format_id format_id
, unsigned int offset
)
1412 struct wined3d_cs_set_index_buffer
*op
;
1414 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1415 op
->opcode
= WINED3D_CS_OP_SET_INDEX_BUFFER
;
1416 op
->buffer
= buffer
;
1417 op
->format_id
= format_id
;
1418 op
->offset
= offset
;
1420 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1423 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs
*cs
, const void *data
)
1425 const struct wined3d_cs_set_constant_buffer
*op
= data
;
1426 struct wined3d_buffer
*prev
;
1428 prev
= cs
->state
.cb
[op
->type
][op
->cb_idx
];
1429 cs
->state
.cb
[op
->type
][op
->cb_idx
] = op
->buffer
;
1432 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1434 InterlockedDecrement(&prev
->resource
.bind_count
);
1436 device_invalidate_state(cs
->c
.device
, STATE_CONSTANT_BUFFER(op
->type
));
1439 void wined3d_device_context_emit_set_constant_buffer(struct wined3d_device_context
*context
,
1440 enum wined3d_shader_type type
, UINT cb_idx
, struct wined3d_buffer
*buffer
)
1442 struct wined3d_cs_set_constant_buffer
*op
;
1444 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1445 op
->opcode
= WINED3D_CS_OP_SET_CONSTANT_BUFFER
;
1447 op
->cb_idx
= cb_idx
;
1448 op
->buffer
= buffer
;
1450 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1453 static void wined3d_cs_exec_set_texture(struct wined3d_cs
*cs
, const void *data
)
1455 const struct wined3d_d3d_info
*d3d_info
= &cs
->c
.device
->adapter
->d3d_info
;
1456 const struct wined3d_cs_set_texture
*op
= data
;
1457 struct wined3d_texture
*prev
;
1458 BOOL old_use_color_key
= FALSE
, new_use_color_key
= FALSE
;
1460 prev
= cs
->state
.textures
[op
->stage
];
1461 cs
->state
.textures
[op
->stage
] = op
->texture
;
1465 const struct wined3d_format
*new_format
= op
->texture
->resource
.format
;
1466 const struct wined3d_format
*old_format
= prev
? prev
->resource
.format
: NULL
;
1467 unsigned int old_fmt_flags
= prev
? prev
->resource
.format_flags
: 0;
1468 unsigned int new_fmt_flags
= op
->texture
->resource
.format_flags
;
1470 if (InterlockedIncrement(&op
->texture
->resource
.bind_count
) == 1)
1471 op
->texture
->sampler
= op
->stage
;
1473 if (!prev
|| wined3d_texture_gl(op
->texture
)->target
!= wined3d_texture_gl(prev
)->target
1474 || (!is_same_fixup(new_format
->color_fixup
, old_format
->color_fixup
)
1475 && !(can_use_texture_swizzle(d3d_info
, new_format
) && can_use_texture_swizzle(d3d_info
, old_format
)))
1476 || (new_fmt_flags
& WINED3DFMT_FLAG_SHADOW
) != (old_fmt_flags
& WINED3DFMT_FLAG_SHADOW
))
1477 device_invalidate_state(cs
->c
.device
, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
));
1479 if (!prev
&& op
->stage
< d3d_info
->limits
.ffp_blend_stages
)
1481 /* The source arguments for color and alpha ops have different
1482 * meanings when a NULL texture is bound, so the COLOR_OP and
1483 * ALPHA_OP have to be dirtified. */
1484 device_invalidate_state(cs
->c
.device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_COLOR_OP
));
1485 device_invalidate_state(cs
->c
.device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_ALPHA_OP
));
1488 if (!op
->stage
&& op
->texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1489 new_use_color_key
= TRUE
;
1494 if (InterlockedDecrement(&prev
->resource
.bind_count
) && prev
->sampler
== op
->stage
)
1498 /* Search for other stages the texture is bound to. Shouldn't
1499 * happen if applications bind textures to a single stage only. */
1500 TRACE("Searching for other stages the texture is bound to.\n");
1501 for (i
= 0; i
< WINED3D_MAX_COMBINED_SAMPLERS
; ++i
)
1503 if (cs
->state
.textures
[i
] == prev
)
1505 TRACE("Texture is also bound to stage %u.\n", i
);
1512 if (!op
->texture
&& op
->stage
< d3d_info
->limits
.ffp_blend_stages
)
1514 device_invalidate_state(cs
->c
.device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_COLOR_OP
));
1515 device_invalidate_state(cs
->c
.device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_ALPHA_OP
));
1518 if (!op
->stage
&& prev
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1519 old_use_color_key
= TRUE
;
1522 device_invalidate_state(cs
->c
.device
, STATE_SAMPLER(op
->stage
));
1524 if (new_use_color_key
!= old_use_color_key
)
1525 device_invalidate_state(cs
->c
.device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1527 if (new_use_color_key
)
1528 device_invalidate_state(cs
->c
.device
, STATE_COLOR_KEY
);
1531 void wined3d_cs_emit_set_texture(struct wined3d_cs
*cs
, UINT stage
, struct wined3d_texture
*texture
)
1533 struct wined3d_cs_set_texture
*op
;
1535 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1536 op
->opcode
= WINED3D_CS_OP_SET_TEXTURE
;
1538 op
->texture
= texture
;
1540 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1543 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs
*cs
, const void *data
)
1545 const struct wined3d_cs_set_shader_resource_view
*op
= data
;
1546 struct wined3d_shader_resource_view
*prev
;
1548 prev
= cs
->state
.shader_resource_view
[op
->type
][op
->view_idx
];
1549 cs
->state
.shader_resource_view
[op
->type
][op
->view_idx
] = op
->view
;
1552 InterlockedIncrement(&op
->view
->resource
->bind_count
);
1554 InterlockedDecrement(&prev
->resource
->bind_count
);
1556 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1557 device_invalidate_state(cs
->c
.device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1559 device_invalidate_state(cs
->c
.device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1562 void wined3d_device_context_emit_set_shader_resource_view(struct wined3d_device_context
*context
,
1563 enum wined3d_shader_type type
, unsigned int view_idx
, struct wined3d_shader_resource_view
*view
)
1565 struct wined3d_cs_set_shader_resource_view
*op
;
1567 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1568 op
->opcode
= WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
;
1570 op
->view_idx
= view_idx
;
1573 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1576 static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs
*cs
, const void *data
)
1578 const struct wined3d_cs_set_unordered_access_view
*op
= data
;
1579 struct wined3d_unordered_access_view
*prev
;
1581 prev
= cs
->state
.unordered_access_view
[op
->pipeline
][op
->view_idx
];
1582 cs
->state
.unordered_access_view
[op
->pipeline
][op
->view_idx
] = op
->view
;
1585 InterlockedIncrement(&op
->view
->resource
->bind_count
);
1587 InterlockedDecrement(&prev
->resource
->bind_count
);
1589 if (op
->view
&& op
->initial_count
!= ~0u)
1590 wined3d_unordered_access_view_set_counter(op
->view
, op
->initial_count
);
1592 device_invalidate_state(cs
->c
.device
, STATE_UNORDERED_ACCESS_VIEW_BINDING(op
->pipeline
));
1595 void wined3d_device_context_emit_set_unordered_access_view(struct wined3d_device_context
*context
,
1596 enum wined3d_pipeline pipeline
, unsigned int view_idx
, struct wined3d_unordered_access_view
*view
,
1597 unsigned int initial_count
)
1599 struct wined3d_cs_set_unordered_access_view
*op
;
1601 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1602 op
->opcode
= WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
;
1603 op
->pipeline
= pipeline
;
1604 op
->view_idx
= view_idx
;
1606 op
->initial_count
= initial_count
;
1608 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1611 static void wined3d_cs_exec_set_sampler(struct wined3d_cs
*cs
, const void *data
)
1613 const struct wined3d_cs_set_sampler
*op
= data
;
1615 cs
->state
.sampler
[op
->type
][op
->sampler_idx
] = op
->sampler
;
1616 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1617 device_invalidate_state(cs
->c
.device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1619 device_invalidate_state(cs
->c
.device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1622 void wined3d_device_context_emit_set_sampler(struct wined3d_device_context
*context
, enum wined3d_shader_type type
,
1623 unsigned int sampler_idx
, struct wined3d_sampler
*sampler
)
1625 struct wined3d_cs_set_sampler
*op
;
1627 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1628 op
->opcode
= WINED3D_CS_OP_SET_SAMPLER
;
1630 op
->sampler_idx
= sampler_idx
;
1631 op
->sampler
= sampler
;
1633 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1636 static void wined3d_cs_exec_set_shader(struct wined3d_cs
*cs
, const void *data
)
1638 const struct wined3d_cs_set_shader
*op
= data
;
1640 cs
->state
.shader
[op
->type
] = op
->shader
;
1641 device_invalidate_state(cs
->c
.device
, STATE_SHADER(op
->type
));
1642 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1643 device_invalidate_state(cs
->c
.device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1645 device_invalidate_state(cs
->c
.device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1648 void wined3d_device_context_emit_set_shader(struct wined3d_device_context
*context
,
1649 enum wined3d_shader_type type
, struct wined3d_shader
*shader
)
1651 struct wined3d_cs_set_shader
*op
;
1653 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1654 op
->opcode
= WINED3D_CS_OP_SET_SHADER
;
1656 op
->shader
= shader
;
1658 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1661 static void wined3d_cs_exec_set_blend_state(struct wined3d_cs
*cs
, const void *data
)
1663 const struct wined3d_cs_set_blend_state
*op
= data
;
1664 struct wined3d_state
*state
= &cs
->state
;
1666 if (state
->blend_state
!= op
->state
)
1668 state
->blend_state
= op
->state
;
1669 device_invalidate_state(cs
->c
.device
, STATE_BLEND
);
1671 state
->blend_factor
= op
->factor
;
1672 device_invalidate_state(cs
->c
.device
, STATE_BLEND_FACTOR
);
1673 state
->sample_mask
= op
->sample_mask
;
1674 device_invalidate_state(cs
->c
.device
, STATE_SAMPLE_MASK
);
1677 void wined3d_device_context_emit_set_blend_state(struct wined3d_device_context
*context
,
1678 struct wined3d_blend_state
*state
, const struct wined3d_color
*blend_factor
, unsigned int sample_mask
)
1680 struct wined3d_cs_set_blend_state
*op
;
1682 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1683 op
->opcode
= WINED3D_CS_OP_SET_BLEND_STATE
;
1685 op
->factor
= *blend_factor
;
1686 op
->sample_mask
= sample_mask
;
1688 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1691 static void wined3d_cs_exec_set_depth_stencil_state(struct wined3d_cs
*cs
, const void *data
)
1693 const struct wined3d_cs_set_depth_stencil_state
*op
= data
;
1694 struct wined3d_state
*state
= &cs
->state
;
1696 if (state
->depth_stencil_state
!= op
->state
)
1698 state
->depth_stencil_state
= op
->state
;
1699 device_invalidate_state(cs
->c
.device
, STATE_DEPTH_STENCIL
);
1701 state
->stencil_ref
= op
->stencil_ref
;
1702 device_invalidate_state(cs
->c
.device
, STATE_STENCIL_REF
);
1705 void wined3d_device_context_emit_set_depth_stencil_state(struct wined3d_device_context
*context
,
1706 struct wined3d_depth_stencil_state
*state
, unsigned int stencil_ref
)
1708 struct wined3d_cs_set_depth_stencil_state
*op
;
1710 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1711 op
->opcode
= WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE
;
1713 op
->stencil_ref
= stencil_ref
;
1715 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1718 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs
*cs
, const void *data
)
1720 const struct wined3d_cs_set_rasterizer_state
*op
= data
;
1722 cs
->state
.rasterizer_state
= op
->state
;
1723 device_invalidate_state(cs
->c
.device
, STATE_RASTERIZER
);
1726 void wined3d_device_context_emit_set_rasterizer_state(struct wined3d_device_context
*context
,
1727 struct wined3d_rasterizer_state
*rasterizer_state
)
1729 struct wined3d_cs_set_rasterizer_state
*op
;
1731 op
= wined3d_device_context_require_space(context
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1732 op
->opcode
= WINED3D_CS_OP_SET_RASTERIZER_STATE
;
1733 op
->state
= rasterizer_state
;
1735 wined3d_device_context_submit(context
, WINED3D_CS_QUEUE_DEFAULT
);
1738 static void wined3d_cs_exec_set_render_state(struct wined3d_cs
*cs
, const void *data
)
1740 const struct wined3d_cs_set_render_state
*op
= data
;
1742 cs
->state
.render_states
[op
->state
] = op
->value
;
1743 device_invalidate_state(cs
->c
.device
, STATE_RENDER(op
->state
));
1746 void wined3d_cs_emit_set_render_state(struct wined3d_cs
*cs
, enum wined3d_render_state state
, DWORD value
)
1748 struct wined3d_cs_set_render_state
*op
;
1750 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1751 op
->opcode
= WINED3D_CS_OP_SET_RENDER_STATE
;
1755 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1758 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs
*cs
, const void *data
)
1760 const struct wined3d_cs_set_texture_state
*op
= data
;
1762 cs
->state
.texture_states
[op
->stage
][op
->state
] = op
->value
;
1763 device_invalidate_state(cs
->c
.device
, STATE_TEXTURESTAGE(op
->stage
, op
->state
));
1766 void wined3d_cs_emit_set_texture_state(struct wined3d_cs
*cs
, UINT stage
,
1767 enum wined3d_texture_stage_state state
, DWORD value
)
1769 struct wined3d_cs_set_texture_state
*op
;
1771 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1772 op
->opcode
= WINED3D_CS_OP_SET_TEXTURE_STATE
;
1777 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1780 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs
*cs
, const void *data
)
1782 const struct wined3d_cs_set_sampler_state
*op
= data
;
1784 cs
->state
.sampler_states
[op
->sampler_idx
][op
->state
] = op
->value
;
1785 device_invalidate_state(cs
->c
.device
, STATE_SAMPLER(op
->sampler_idx
));
1788 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs
*cs
, UINT sampler_idx
,
1789 enum wined3d_sampler_state state
, DWORD value
)
1791 struct wined3d_cs_set_sampler_state
*op
;
1793 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1794 op
->opcode
= WINED3D_CS_OP_SET_SAMPLER_STATE
;
1795 op
->sampler_idx
= sampler_idx
;
1799 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1802 static void wined3d_cs_exec_set_transform(struct wined3d_cs
*cs
, const void *data
)
1804 const struct wined3d_cs_set_transform
*op
= data
;
1806 cs
->state
.transforms
[op
->state
] = op
->matrix
;
1807 if (op
->state
< WINED3D_TS_WORLD_MATRIX(cs
->c
.device
->adapter
->d3d_info
.limits
.ffp_vertex_blend_matrices
))
1808 device_invalidate_state(cs
->c
.device
, STATE_TRANSFORM(op
->state
));
1811 void wined3d_cs_emit_set_transform(struct wined3d_cs
*cs
, enum wined3d_transform_state state
,
1812 const struct wined3d_matrix
*matrix
)
1814 struct wined3d_cs_set_transform
*op
;
1816 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1817 op
->opcode
= WINED3D_CS_OP_SET_TRANSFORM
;
1819 op
->matrix
= *matrix
;
1821 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1824 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs
*cs
, const void *data
)
1826 const struct wined3d_cs_set_clip_plane
*op
= data
;
1828 cs
->state
.clip_planes
[op
->plane_idx
] = op
->plane
;
1829 device_invalidate_state(cs
->c
.device
, STATE_CLIPPLANE(op
->plane_idx
));
1832 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs
*cs
, UINT plane_idx
, const struct wined3d_vec4
*plane
)
1834 struct wined3d_cs_set_clip_plane
*op
;
1836 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1837 op
->opcode
= WINED3D_CS_OP_SET_CLIP_PLANE
;
1838 op
->plane_idx
= plane_idx
;
1841 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1844 static void wined3d_cs_exec_set_color_key(struct wined3d_cs
*cs
, const void *data
)
1846 const struct wined3d_cs_set_color_key
*op
= data
;
1847 struct wined3d_texture
*texture
= op
->texture
;
1853 case WINED3D_CKEY_DST_BLT
:
1854 texture
->async
.dst_blt_color_key
= op
->color_key
;
1855 texture
->async
.color_key_flags
|= WINED3D_CKEY_DST_BLT
;
1858 case WINED3D_CKEY_DST_OVERLAY
:
1859 texture
->async
.dst_overlay_color_key
= op
->color_key
;
1860 texture
->async
.color_key_flags
|= WINED3D_CKEY_DST_OVERLAY
;
1863 case WINED3D_CKEY_SRC_BLT
:
1864 if (texture
== cs
->state
.textures
[0])
1866 device_invalidate_state(cs
->c
.device
, STATE_COLOR_KEY
);
1867 if (!(texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
))
1868 device_invalidate_state(cs
->c
.device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1871 texture
->async
.src_blt_color_key
= op
->color_key
;
1872 texture
->async
.color_key_flags
|= WINED3D_CKEY_SRC_BLT
;
1875 case WINED3D_CKEY_SRC_OVERLAY
:
1876 texture
->async
.src_overlay_color_key
= op
->color_key
;
1877 texture
->async
.color_key_flags
|= WINED3D_CKEY_SRC_OVERLAY
;
1885 case WINED3D_CKEY_DST_BLT
:
1886 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_DST_BLT
;
1889 case WINED3D_CKEY_DST_OVERLAY
:
1890 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_DST_OVERLAY
;
1893 case WINED3D_CKEY_SRC_BLT
:
1894 if (texture
== cs
->state
.textures
[0] && texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1895 device_invalidate_state(cs
->c
.device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1897 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_SRC_BLT
;
1900 case WINED3D_CKEY_SRC_OVERLAY
:
1901 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_SRC_OVERLAY
;
1907 void wined3d_cs_emit_set_color_key(struct wined3d_cs
*cs
, struct wined3d_texture
*texture
,
1908 WORD flags
, const struct wined3d_color_key
*color_key
)
1910 struct wined3d_cs_set_color_key
*op
;
1912 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1913 op
->opcode
= WINED3D_CS_OP_SET_COLOR_KEY
;
1914 op
->texture
= texture
;
1918 op
->color_key
= *color_key
;
1924 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1927 static void wined3d_cs_exec_set_material(struct wined3d_cs
*cs
, const void *data
)
1929 const struct wined3d_cs_set_material
*op
= data
;
1931 cs
->state
.material
= op
->material
;
1932 device_invalidate_state(cs
->c
.device
, STATE_MATERIAL
);
1935 void wined3d_cs_emit_set_material(struct wined3d_cs
*cs
, const struct wined3d_material
*material
)
1937 struct wined3d_cs_set_material
*op
;
1939 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1940 op
->opcode
= WINED3D_CS_OP_SET_MATERIAL
;
1941 op
->material
= *material
;
1943 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1946 static void wined3d_cs_exec_set_light(struct wined3d_cs
*cs
, const void *data
)
1948 const struct wined3d_cs_set_light
*op
= data
;
1949 struct wined3d_light_info
*light_info
;
1950 unsigned int light_idx
, hash_idx
;
1952 light_idx
= op
->light
.OriginalIndex
;
1954 if (!(light_info
= wined3d_light_state_get_light(&cs
->state
.light_state
, light_idx
)))
1956 TRACE("Adding new light.\n");
1957 if (!(light_info
= heap_alloc_zero(sizeof(*light_info
))))
1959 ERR("Failed to allocate light info.\n");
1963 hash_idx
= LIGHTMAP_HASHFUNC(light_idx
);
1964 list_add_head(&cs
->state
.light_state
.light_map
[hash_idx
], &light_info
->entry
);
1965 light_info
->glIndex
= -1;
1966 light_info
->OriginalIndex
= light_idx
;
1969 if (light_info
->glIndex
!= -1)
1971 if (light_info
->OriginalParms
.type
!= op
->light
.OriginalParms
.type
)
1972 device_invalidate_state(cs
->c
.device
, STATE_LIGHT_TYPE
);
1973 device_invalidate_state(cs
->c
.device
, STATE_ACTIVELIGHT(light_info
->glIndex
));
1976 light_info
->OriginalParms
= op
->light
.OriginalParms
;
1977 light_info
->position
= op
->light
.position
;
1978 light_info
->direction
= op
->light
.direction
;
1979 light_info
->exponent
= op
->light
.exponent
;
1980 light_info
->cutoff
= op
->light
.cutoff
;
1983 void wined3d_cs_emit_set_light(struct wined3d_cs
*cs
, const struct wined3d_light_info
*light
)
1985 struct wined3d_cs_set_light
*op
;
1987 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1988 op
->opcode
= WINED3D_CS_OP_SET_LIGHT
;
1991 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
1994 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs
*cs
, const void *data
)
1996 const struct wined3d_cs_set_light_enable
*op
= data
;
1997 struct wined3d_device
*device
= cs
->c
.device
;
1998 struct wined3d_light_info
*light_info
;
2001 if (!(light_info
= wined3d_light_state_get_light(&cs
->state
.light_state
, op
->idx
)))
2003 ERR("Light doesn't exist.\n");
2007 prev_idx
= light_info
->glIndex
;
2008 wined3d_light_state_enable_light(&cs
->state
.light_state
, &device
->adapter
->d3d_info
, light_info
, op
->enable
);
2009 if (light_info
->glIndex
!= prev_idx
)
2011 device_invalidate_state(device
, STATE_LIGHT_TYPE
);
2012 device_invalidate_state(device
, STATE_ACTIVELIGHT(op
->enable
? light_info
->glIndex
: prev_idx
));
2016 void wined3d_cs_emit_set_light_enable(struct wined3d_cs
*cs
, unsigned int idx
, BOOL enable
)
2018 struct wined3d_cs_set_light_enable
*op
;
2020 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2021 op
->opcode
= WINED3D_CS_OP_SET_LIGHT_ENABLE
;
2023 op
->enable
= enable
;
2025 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2028 static void wined3d_cs_exec_set_feature_level(struct wined3d_cs
*cs
, const void *data
)
2030 const struct wined3d_cs_set_feature_level
*op
= data
;
2032 cs
->state
.feature_level
= op
->level
;
2035 void wined3d_cs_emit_set_feature_level(struct wined3d_cs
*cs
, enum wined3d_feature_level level
)
2037 struct wined3d_cs_set_feature_level
*op
;
2039 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2040 op
->opcode
= WINED3D_CS_OP_SET_FEATURE_LEVEL
;
2043 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2052 wined3d_cs_push_constant_info
[] =
2054 /* WINED3D_PUSH_CONSTANTS_VS_F */
2055 {FIELD_OFFSET(struct wined3d_state
, vs_consts_f
), sizeof(struct wined3d_vec4
), WINED3D_SHADER_CONST_VS_F
},
2056 /* WINED3D_PUSH_CONSTANTS_PS_F */
2057 {FIELD_OFFSET(struct wined3d_state
, ps_consts_f
), sizeof(struct wined3d_vec4
), WINED3D_SHADER_CONST_PS_F
},
2058 /* WINED3D_PUSH_CONSTANTS_VS_I */
2059 {FIELD_OFFSET(struct wined3d_state
, vs_consts_i
), sizeof(struct wined3d_ivec4
), WINED3D_SHADER_CONST_VS_I
},
2060 /* WINED3D_PUSH_CONSTANTS_PS_I */
2061 {FIELD_OFFSET(struct wined3d_state
, ps_consts_i
), sizeof(struct wined3d_ivec4
), WINED3D_SHADER_CONST_PS_I
},
2062 /* WINED3D_PUSH_CONSTANTS_VS_B */
2063 {FIELD_OFFSET(struct wined3d_state
, vs_consts_b
), sizeof(BOOL
), WINED3D_SHADER_CONST_VS_B
},
2064 /* WINED3D_PUSH_CONSTANTS_PS_B */
2065 {FIELD_OFFSET(struct wined3d_state
, ps_consts_b
), sizeof(BOOL
), WINED3D_SHADER_CONST_PS_B
},
2068 static struct wined3d_cs
*wined3d_cs_from_context(struct wined3d_device_context
*context
)
2070 return CONTAINING_RECORD(context
, struct wined3d_cs
, c
);
2073 static void wined3d_cs_st_push_constants(struct wined3d_device_context
*context
, enum wined3d_push_constants p
,
2074 unsigned int start_idx
, unsigned int count
, const void *constants
)
2076 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2077 struct wined3d_device
*device
= cs
->c
.device
;
2078 unsigned int context_count
;
2082 if (p
== WINED3D_PUSH_CONSTANTS_VS_F
)
2083 device
->shader_backend
->shader_update_float_vertex_constants(device
, start_idx
, count
);
2084 else if (p
== WINED3D_PUSH_CONSTANTS_PS_F
)
2085 device
->shader_backend
->shader_update_float_pixel_constants(device
, start_idx
, count
);
2087 offset
= wined3d_cs_push_constant_info
[p
].offset
+ start_idx
* wined3d_cs_push_constant_info
[p
].size
;
2088 memcpy((BYTE
*)&cs
->state
+ offset
, constants
, count
* wined3d_cs_push_constant_info
[p
].size
);
2089 for (i
= 0, context_count
= device
->context_count
; i
< context_count
; ++i
)
2091 device
->contexts
[i
]->constant_update_mask
|= wined3d_cs_push_constant_info
[p
].mask
;
2095 static void wined3d_cs_exec_push_constants(struct wined3d_cs
*cs
, const void *data
)
2097 const struct wined3d_cs_push_constants
*op
= data
;
2099 wined3d_cs_st_push_constants(&cs
->c
, op
->type
, op
->start_idx
, op
->count
, op
->constants
);
2102 static void wined3d_cs_mt_push_constants(struct wined3d_device_context
*context
, enum wined3d_push_constants p
,
2103 unsigned int start_idx
, unsigned int count
, const void *constants
)
2105 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2106 struct wined3d_cs_push_constants
*op
;
2109 size
= count
* wined3d_cs_push_constant_info
[p
].size
;
2110 op
= wined3d_device_context_require_space(&cs
->c
, FIELD_OFFSET(struct wined3d_cs_push_constants
, constants
[size
]),
2111 WINED3D_CS_QUEUE_DEFAULT
);
2112 op
->opcode
= WINED3D_CS_OP_PUSH_CONSTANTS
;
2114 op
->start_idx
= start_idx
;
2116 memcpy(op
->constants
, constants
, size
);
2118 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2121 static void wined3d_cs_exec_reset_state(struct wined3d_cs
*cs
, const void *data
)
2123 state_cleanup(&cs
->state
);
2124 wined3d_state_reset(&cs
->state
, &cs
->c
.device
->adapter
->d3d_info
);
2127 void wined3d_cs_emit_reset_state(struct wined3d_cs
*cs
)
2129 struct wined3d_cs_reset_state
*op
;
2131 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2132 op
->opcode
= WINED3D_CS_OP_RESET_STATE
;
2134 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2137 static void wined3d_cs_exec_callback(struct wined3d_cs
*cs
, const void *data
)
2139 const struct wined3d_cs_callback
*op
= data
;
2141 op
->callback(op
->object
);
2144 static void wined3d_cs_emit_callback(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
2146 struct wined3d_cs_callback
*op
;
2148 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2149 op
->opcode
= WINED3D_CS_OP_CALLBACK
;
2150 op
->callback
= callback
;
2151 op
->object
= object
;
2153 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2156 void wined3d_cs_destroy_object(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
2158 wined3d_cs_emit_callback(cs
, callback
, object
);
2161 void wined3d_cs_init_object(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
2163 wined3d_cs_emit_callback(cs
, callback
, object
);
2166 static void wined3d_cs_exec_query_issue(struct wined3d_cs
*cs
, const void *data
)
2168 const struct wined3d_cs_query_issue
*op
= data
;
2169 struct wined3d_query
*query
= op
->query
;
2172 poll
= query
->query_ops
->query_issue(query
, op
->flags
);
2177 if (poll
&& list_empty(&query
->poll_list_entry
))
2179 if (query
->buffer_object
)
2180 InterlockedIncrement(&query
->counter_retrieved
);
2182 list_add_tail(&cs
->query_poll_list
, &query
->poll_list_entry
);
2186 /* This can happen if occlusion queries are restarted. This discards the
2187 * old result, since polling it could result in a GL error. */
2188 if ((op
->flags
& WINED3DISSUE_BEGIN
) && !poll
&& !list_empty(&query
->poll_list_entry
))
2190 list_remove(&query
->poll_list_entry
);
2191 list_init(&query
->poll_list_entry
);
2192 InterlockedIncrement(&query
->counter_retrieved
);
2196 /* This can happen when an occlusion query is ended without being started,
2197 * in which case we don't want to poll, but still have to counter-balance
2198 * the increment of the main counter.
2200 * This can also happen if an event query is re-issued before the first
2201 * fence was reached. In this case the query is already in the list and
2202 * the poll function will check the new fence. We have to counter-balance
2203 * the discarded increment. */
2204 if (op
->flags
& WINED3DISSUE_END
)
2205 InterlockedIncrement(&query
->counter_retrieved
);
2208 void wined3d_cs_emit_query_issue(struct wined3d_cs
*cs
, struct wined3d_query
*query
, DWORD flags
)
2210 struct wined3d_cs_query_issue
*op
;
2212 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2213 op
->opcode
= WINED3D_CS_OP_QUERY_ISSUE
;
2217 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2218 cs
->queries_flushed
= FALSE
;
2221 static void wined3d_cs_exec_preload_resource(struct wined3d_cs
*cs
, const void *data
)
2223 const struct wined3d_cs_preload_resource
*op
= data
;
2224 struct wined3d_resource
*resource
= op
->resource
;
2226 resource
->resource_ops
->resource_preload(resource
);
2227 wined3d_resource_release(resource
);
2230 void wined3d_cs_emit_preload_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
)
2232 struct wined3d_cs_preload_resource
*op
;
2234 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2235 op
->opcode
= WINED3D_CS_OP_PRELOAD_RESOURCE
;
2236 op
->resource
= resource
;
2238 wined3d_resource_acquire(resource
);
2240 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2243 static void wined3d_cs_exec_unload_resource(struct wined3d_cs
*cs
, const void *data
)
2245 const struct wined3d_cs_unload_resource
*op
= data
;
2246 struct wined3d_resource
*resource
= op
->resource
;
2248 resource
->resource_ops
->resource_unload(resource
);
2249 wined3d_resource_release(resource
);
2252 void wined3d_cs_emit_unload_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
)
2254 struct wined3d_cs_unload_resource
*op
;
2256 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2257 op
->opcode
= WINED3D_CS_OP_UNLOAD_RESOURCE
;
2258 op
->resource
= resource
;
2260 wined3d_resource_acquire(resource
);
2262 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2265 static void wined3d_cs_exec_map(struct wined3d_cs
*cs
, const void *data
)
2267 const struct wined3d_cs_map
*op
= data
;
2268 struct wined3d_resource
*resource
= op
->resource
;
2270 *op
->hr
= resource
->resource_ops
->resource_sub_resource_map(resource
,
2271 op
->sub_resource_idx
, op
->map_desc
, op
->box
, op
->flags
);
2274 HRESULT
wined3d_cs_map(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
, unsigned int sub_resource_idx
,
2275 struct wined3d_map_desc
*map_desc
, const struct wined3d_box
*box
, unsigned int flags
)
2277 struct wined3d_cs_map
*op
;
2280 /* Mapping resources from the worker thread isn't an issue by itself, but
2281 * increasing the map count would be visible to applications. */
2282 wined3d_not_from_cs(cs
);
2284 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2285 op
->opcode
= WINED3D_CS_OP_MAP
;
2286 op
->resource
= resource
;
2287 op
->sub_resource_idx
= sub_resource_idx
;
2288 op
->map_desc
= map_desc
;
2293 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_MAP
);
2294 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_MAP
);
2299 static void wined3d_cs_exec_unmap(struct wined3d_cs
*cs
, const void *data
)
2301 const struct wined3d_cs_unmap
*op
= data
;
2302 struct wined3d_resource
*resource
= op
->resource
;
2304 *op
->hr
= resource
->resource_ops
->resource_sub_resource_unmap(resource
, op
->sub_resource_idx
);
2307 HRESULT
wined3d_cs_unmap(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
, unsigned int sub_resource_idx
)
2309 struct wined3d_cs_unmap
*op
;
2312 wined3d_not_from_cs(cs
);
2314 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2315 op
->opcode
= WINED3D_CS_OP_UNMAP
;
2316 op
->resource
= resource
;
2317 op
->sub_resource_idx
= sub_resource_idx
;
2320 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_MAP
);
2321 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_MAP
);
2326 static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs
*cs
, const void *data
)
2328 const struct wined3d_cs_blt_sub_resource
*op
= data
;
2330 if (op
->dst_resource
->type
== WINED3D_RTYPE_BUFFER
)
2332 wined3d_buffer_copy(buffer_from_resource(op
->dst_resource
), op
->dst_box
.left
,
2333 buffer_from_resource(op
->src_resource
), op
->src_box
.left
,
2334 op
->src_box
.right
- op
->src_box
.left
);
2336 else if (op
->dst_resource
->type
== WINED3D_RTYPE_TEXTURE_3D
)
2338 struct wined3d_texture
*src_texture
, *dst_texture
;
2339 unsigned int level
, update_w
, update_h
, update_d
;
2340 unsigned int row_pitch
, slice_pitch
;
2341 struct wined3d_context
*context
;
2342 struct wined3d_bo_address addr
;
2344 if (op
->flags
& ~WINED3D_BLT_RAW
)
2346 FIXME("Flags %#x not implemented for %s resources.\n",
2347 op
->flags
, debug_d3dresourcetype(op
->dst_resource
->type
));
2351 if (!(op
->flags
& WINED3D_BLT_RAW
) && op
->src_resource
->format
!= op
->dst_resource
->format
)
2353 FIXME("Format conversion not implemented for %s resources.\n",
2354 debug_d3dresourcetype(op
->dst_resource
->type
));
2358 update_w
= op
->dst_box
.right
- op
->dst_box
.left
;
2359 update_h
= op
->dst_box
.bottom
- op
->dst_box
.top
;
2360 update_d
= op
->dst_box
.back
- op
->dst_box
.front
;
2361 if (op
->src_box
.right
- op
->src_box
.left
!= update_w
2362 || op
->src_box
.bottom
- op
->src_box
.top
!= update_h
2363 || op
->src_box
.back
- op
->src_box
.front
!= update_d
)
2365 FIXME("Stretching not implemented for %s resources.\n",
2366 debug_d3dresourcetype(op
->dst_resource
->type
));
2370 dst_texture
= texture_from_resource(op
->dst_resource
);
2371 src_texture
= texture_from_resource(op
->src_resource
);
2373 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2375 if (!wined3d_texture_load_location(src_texture
, op
->src_sub_resource_idx
,
2376 context
, src_texture
->resource
.map_binding
))
2378 ERR("Failed to load source sub-resource into %s.\n",
2379 wined3d_debug_location(src_texture
->resource
.map_binding
));
2380 context_release(context
);
2384 level
= op
->dst_sub_resource_idx
% dst_texture
->level_count
;
2385 if (update_w
== wined3d_texture_get_level_width(dst_texture
, level
)
2386 && update_h
== wined3d_texture_get_level_height(dst_texture
, level
)
2387 && update_d
== wined3d_texture_get_level_depth(dst_texture
, level
))
2389 wined3d_texture_prepare_location(dst_texture
, op
->dst_sub_resource_idx
,
2390 context
, WINED3D_LOCATION_TEXTURE_RGB
);
2392 else if (!wined3d_texture_load_location(dst_texture
, op
->dst_sub_resource_idx
,
2393 context
, WINED3D_LOCATION_TEXTURE_RGB
))
2395 ERR("Failed to load destination sub-resource.\n");
2396 context_release(context
);
2400 wined3d_texture_get_memory(src_texture
, op
->src_sub_resource_idx
, &addr
, src_texture
->resource
.map_binding
);
2401 wined3d_texture_get_pitch(src_texture
, op
->src_sub_resource_idx
% src_texture
->level_count
,
2402 &row_pitch
, &slice_pitch
);
2404 dst_texture
->texture_ops
->texture_upload_data(context
, wined3d_const_bo_address(&addr
),
2405 dst_texture
->resource
.format
, &op
->src_box
, row_pitch
, slice_pitch
, dst_texture
,
2406 op
->dst_sub_resource_idx
, WINED3D_LOCATION_TEXTURE_RGB
,
2407 op
->dst_box
.left
, op
->dst_box
.top
, op
->dst_box
.front
);
2408 wined3d_texture_validate_location(dst_texture
, op
->dst_sub_resource_idx
, WINED3D_LOCATION_TEXTURE_RGB
);
2409 wined3d_texture_invalidate_location(dst_texture
, op
->dst_sub_resource_idx
, ~WINED3D_LOCATION_TEXTURE_RGB
);
2411 context_release(context
);
2415 if (FAILED(texture2d_blt(texture_from_resource(op
->dst_resource
), op
->dst_sub_resource_idx
,
2416 &op
->dst_box
, texture_from_resource(op
->src_resource
), op
->src_sub_resource_idx
,
2417 &op
->src_box
, op
->flags
, &op
->fx
, op
->filter
)))
2418 FIXME("Blit failed.\n");
2422 if (op
->src_resource
)
2423 wined3d_resource_release(op
->src_resource
);
2424 wined3d_resource_release(op
->dst_resource
);
2427 void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*dst_resource
,
2428 unsigned int dst_sub_resource_idx
, const struct wined3d_box
*dst_box
, struct wined3d_resource
*src_resource
,
2429 unsigned int src_sub_resource_idx
, const struct wined3d_box
*src_box
, DWORD flags
,
2430 const struct wined3d_blt_fx
*fx
, enum wined3d_texture_filter_type filter
)
2432 struct wined3d_cs_blt_sub_resource
*op
;
2434 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2435 op
->opcode
= WINED3D_CS_OP_BLT_SUB_RESOURCE
;
2436 op
->dst_resource
= dst_resource
;
2437 op
->dst_sub_resource_idx
= dst_sub_resource_idx
;
2438 op
->dst_box
= *dst_box
;
2439 op
->src_resource
= src_resource
;
2440 op
->src_sub_resource_idx
= src_sub_resource_idx
;
2441 op
->src_box
= *src_box
;
2446 memset(&op
->fx
, 0, sizeof(op
->fx
));
2447 op
->filter
= filter
;
2449 wined3d_resource_acquire(dst_resource
);
2451 wined3d_resource_acquire(src_resource
);
2453 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2454 if (flags
& WINED3D_BLT_SYNCHRONOUS
)
2455 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2458 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs
*cs
, const void *data
)
2460 const struct wined3d_cs_update_sub_resource
*op
= data
;
2461 struct wined3d_resource
*resource
= op
->resource
;
2462 const struct wined3d_box
*box
= &op
->box
;
2463 unsigned int width
, height
, depth
, level
;
2464 struct wined3d_const_bo_address addr
;
2465 struct wined3d_context
*context
;
2466 struct wined3d_texture
*texture
;
2467 struct wined3d_box src_box
;
2469 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2471 if (resource
->type
== WINED3D_RTYPE_BUFFER
)
2473 struct wined3d_buffer
*buffer
= buffer_from_resource(resource
);
2475 if (!wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_BUFFER
))
2477 ERR("Failed to load buffer location.\n");
2481 wined3d_buffer_upload_data(buffer
, context
, box
, op
->data
.data
);
2482 wined3d_buffer_invalidate_location(buffer
, ~WINED3D_LOCATION_BUFFER
);
2486 texture
= wined3d_texture_from_resource(resource
);
2488 level
= op
->sub_resource_idx
% texture
->level_count
;
2489 width
= wined3d_texture_get_level_width(texture
, level
);
2490 height
= wined3d_texture_get_level_height(texture
, level
);
2491 depth
= wined3d_texture_get_level_depth(texture
, level
);
2493 addr
.buffer_object
= 0;
2494 addr
.addr
= op
->data
.data
;
2496 /* Only load the sub-resource for partial updates. */
2497 if (!box
->left
&& !box
->top
&& !box
->front
2498 && box
->right
== width
&& box
->bottom
== height
&& box
->back
== depth
)
2499 wined3d_texture_prepare_location(texture
, op
->sub_resource_idx
, context
, WINED3D_LOCATION_TEXTURE_RGB
);
2501 wined3d_texture_load_location(texture
, op
->sub_resource_idx
, context
, WINED3D_LOCATION_TEXTURE_RGB
);
2503 wined3d_box_set(&src_box
, 0, 0, box
->right
- box
->left
, box
->bottom
- box
->top
, 0, box
->back
- box
->front
);
2504 texture
->texture_ops
->texture_upload_data(context
, &addr
, texture
->resource
.format
, &src_box
,
2505 op
->data
.row_pitch
, op
->data
.slice_pitch
, texture
, op
->sub_resource_idx
,
2506 WINED3D_LOCATION_TEXTURE_RGB
, box
->left
, box
->top
, box
->front
);
2508 wined3d_texture_validate_location(texture
, op
->sub_resource_idx
, WINED3D_LOCATION_TEXTURE_RGB
);
2509 wined3d_texture_invalidate_location(texture
, op
->sub_resource_idx
, ~WINED3D_LOCATION_TEXTURE_RGB
);
2512 context_release(context
);
2514 wined3d_resource_release(resource
);
2517 void wined3d_cs_emit_update_sub_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
,
2518 unsigned int sub_resource_idx
, const struct wined3d_box
*box
, const void *data
, unsigned int row_pitch
,
2519 unsigned int slice_pitch
)
2521 struct wined3d_cs_update_sub_resource
*op
;
2523 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2524 op
->opcode
= WINED3D_CS_OP_UPDATE_SUB_RESOURCE
;
2525 op
->resource
= resource
;
2526 op
->sub_resource_idx
= sub_resource_idx
;
2528 op
->data
.row_pitch
= row_pitch
;
2529 op
->data
.slice_pitch
= slice_pitch
;
2530 op
->data
.data
= data
;
2532 wined3d_resource_acquire(resource
);
2534 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_MAP
);
2535 /* The data pointer may go away, so we need to wait until it is read.
2536 * Copying the data may be faster if it's small. */
2537 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_MAP
);
2540 static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs
*cs
, const void *data
)
2542 const struct wined3d_cs_add_dirty_texture_region
*op
= data
;
2543 struct wined3d_texture
*texture
= op
->texture
;
2544 unsigned int sub_resource_idx
, i
;
2545 struct wined3d_context
*context
;
2547 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2548 sub_resource_idx
= op
->layer
* texture
->level_count
;
2549 for (i
= 0; i
< texture
->level_count
; ++i
, ++sub_resource_idx
)
2551 if (wined3d_texture_load_location(texture
, sub_resource_idx
, context
, texture
->resource
.map_binding
))
2552 wined3d_texture_invalidate_location(texture
, sub_resource_idx
, ~texture
->resource
.map_binding
);
2554 ERR("Failed to load location %s.\n", wined3d_debug_location(texture
->resource
.map_binding
));
2556 context_release(context
);
2558 wined3d_resource_release(&texture
->resource
);
2561 void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs
*cs
,
2562 struct wined3d_texture
*texture
, unsigned int layer
)
2564 struct wined3d_cs_add_dirty_texture_region
*op
;
2566 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2567 op
->opcode
= WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
;
2568 op
->texture
= texture
;
2571 wined3d_resource_acquire(&texture
->resource
);
2573 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2576 static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs
*cs
, const void *data
)
2578 const struct wined3d_cs_clear_unordered_access_view
*op
= data
;
2579 struct wined3d_unordered_access_view
*view
= op
->view
;
2580 struct wined3d_context
*context
;
2582 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2583 cs
->c
.device
->adapter
->adapter_ops
->adapter_clear_uav(context
, view
, &op
->clear_value
);
2584 context_release(context
);
2586 wined3d_resource_release(view
->resource
);
2589 void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs
*cs
,
2590 struct wined3d_unordered_access_view
*view
, const struct wined3d_uvec4
*clear_value
)
2592 struct wined3d_cs_clear_unordered_access_view
*op
;
2594 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2595 op
->opcode
= WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
;
2597 op
->clear_value
= *clear_value
;
2599 wined3d_resource_acquire(view
->resource
);
2601 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2604 static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs
*cs
, const void *data
)
2606 const struct wined3d_cs_copy_uav_counter
*op
= data
;
2607 struct wined3d_unordered_access_view
*view
= op
->view
;
2608 struct wined3d_context
*context
;
2610 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2611 wined3d_unordered_access_view_copy_counter(view
, op
->buffer
, op
->offset
, context
);
2612 context_release(context
);
2614 wined3d_resource_release(&op
->buffer
->resource
);
2617 void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs
*cs
, struct wined3d_buffer
*dst_buffer
,
2618 unsigned int offset
, struct wined3d_unordered_access_view
*uav
)
2620 struct wined3d_cs_copy_uav_counter
*op
;
2622 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2623 op
->opcode
= WINED3D_CS_OP_COPY_UAV_COUNTER
;
2624 op
->buffer
= dst_buffer
;
2625 op
->offset
= offset
;
2628 wined3d_resource_acquire(&dst_buffer
->resource
);
2630 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2633 static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs
*cs
, const void *data
)
2635 const struct wined3d_cs_generate_mipmaps
*op
= data
;
2636 struct wined3d_shader_resource_view
*view
= op
->view
;
2637 struct wined3d_context
*context
;
2639 context
= context_acquire(cs
->c
.device
, NULL
, 0);
2640 cs
->c
.device
->adapter
->adapter_ops
->adapter_generate_mipmap(context
, view
);
2641 context_release(context
);
2643 wined3d_resource_release(view
->resource
);
2646 void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs
*cs
, struct wined3d_shader_resource_view
*view
)
2648 struct wined3d_cs_generate_mipmaps
*op
;
2650 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2651 op
->opcode
= WINED3D_CS_OP_GENERATE_MIPMAPS
;
2654 wined3d_resource_acquire(view
->resource
);
2656 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2659 static void wined3d_cs_emit_stop(struct wined3d_cs
*cs
)
2661 struct wined3d_cs_stop
*op
;
2663 op
= wined3d_device_context_require_space(&cs
->c
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2664 op
->opcode
= WINED3D_CS_OP_STOP
;
2666 wined3d_device_context_submit(&cs
->c
, WINED3D_CS_QUEUE_DEFAULT
);
2667 wined3d_cs_finish(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2670 static void (* const wined3d_cs_op_handlers
[])(struct wined3d_cs
*cs
, const void *data
) =
2672 /* WINED3D_CS_OP_NOP */ wined3d_cs_exec_nop
,
2673 /* WINED3D_CS_OP_PRESENT */ wined3d_cs_exec_present
,
2674 /* WINED3D_CS_OP_CLEAR */ wined3d_cs_exec_clear
,
2675 /* WINED3D_CS_OP_DISPATCH */ wined3d_cs_exec_dispatch
,
2676 /* WINED3D_CS_OP_DRAW */ wined3d_cs_exec_draw
,
2677 /* WINED3D_CS_OP_FLUSH */ wined3d_cs_exec_flush
,
2678 /* WINED3D_CS_OP_SET_PREDICATION */ wined3d_cs_exec_set_predication
,
2679 /* WINED3D_CS_OP_SET_VIEWPORTS */ wined3d_cs_exec_set_viewports
,
2680 /* WINED3D_CS_OP_SET_SCISSOR_RECTS */ wined3d_cs_exec_set_scissor_rects
,
2681 /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW */ wined3d_cs_exec_set_rendertarget_view
,
2682 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW */ wined3d_cs_exec_set_depth_stencil_view
,
2683 /* WINED3D_CS_OP_SET_VERTEX_DECLARATION */ wined3d_cs_exec_set_vertex_declaration
,
2684 /* WINED3D_CS_OP_SET_STREAM_SOURCE */ wined3d_cs_exec_set_stream_source
,
2685 /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq
,
2686 /* WINED3D_CS_OP_SET_STREAM_OUTPUT */ wined3d_cs_exec_set_stream_output
,
2687 /* WINED3D_CS_OP_SET_INDEX_BUFFER */ wined3d_cs_exec_set_index_buffer
,
2688 /* WINED3D_CS_OP_SET_CONSTANT_BUFFER */ wined3d_cs_exec_set_constant_buffer
,
2689 /* WINED3D_CS_OP_SET_TEXTURE */ wined3d_cs_exec_set_texture
,
2690 /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW */ wined3d_cs_exec_set_shader_resource_view
,
2691 /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_set_unordered_access_view
,
2692 /* WINED3D_CS_OP_SET_SAMPLER */ wined3d_cs_exec_set_sampler
,
2693 /* WINED3D_CS_OP_SET_SHADER */ wined3d_cs_exec_set_shader
,
2694 /* WINED3D_CS_OP_SET_BLEND_STATE */ wined3d_cs_exec_set_blend_state
,
2695 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE */ wined3d_cs_exec_set_depth_stencil_state
,
2696 /* WINED3D_CS_OP_SET_RASTERIZER_STATE */ wined3d_cs_exec_set_rasterizer_state
,
2697 /* WINED3D_CS_OP_SET_RENDER_STATE */ wined3d_cs_exec_set_render_state
,
2698 /* WINED3D_CS_OP_SET_TEXTURE_STATE */ wined3d_cs_exec_set_texture_state
,
2699 /* WINED3D_CS_OP_SET_SAMPLER_STATE */ wined3d_cs_exec_set_sampler_state
,
2700 /* WINED3D_CS_OP_SET_TRANSFORM */ wined3d_cs_exec_set_transform
,
2701 /* WINED3D_CS_OP_SET_CLIP_PLANE */ wined3d_cs_exec_set_clip_plane
,
2702 /* WINED3D_CS_OP_SET_COLOR_KEY */ wined3d_cs_exec_set_color_key
,
2703 /* WINED3D_CS_OP_SET_MATERIAL */ wined3d_cs_exec_set_material
,
2704 /* WINED3D_CS_OP_SET_LIGHT */ wined3d_cs_exec_set_light
,
2705 /* WINED3D_CS_OP_SET_LIGHT_ENABLE */ wined3d_cs_exec_set_light_enable
,
2706 /* WINED3D_CS_OP_SET_FEATURE_LEVEL */ wined3d_cs_exec_set_feature_level
,
2707 /* WINED3D_CS_OP_PUSH_CONSTANTS */ wined3d_cs_exec_push_constants
,
2708 /* WINED3D_CS_OP_RESET_STATE */ wined3d_cs_exec_reset_state
,
2709 /* WINED3D_CS_OP_CALLBACK */ wined3d_cs_exec_callback
,
2710 /* WINED3D_CS_OP_QUERY_ISSUE */ wined3d_cs_exec_query_issue
,
2711 /* WINED3D_CS_OP_PRELOAD_RESOURCE */ wined3d_cs_exec_preload_resource
,
2712 /* WINED3D_CS_OP_UNLOAD_RESOURCE */ wined3d_cs_exec_unload_resource
,
2713 /* WINED3D_CS_OP_MAP */ wined3d_cs_exec_map
,
2714 /* WINED3D_CS_OP_UNMAP */ wined3d_cs_exec_unmap
,
2715 /* WINED3D_CS_OP_BLT_SUB_RESOURCE */ wined3d_cs_exec_blt_sub_resource
,
2716 /* WINED3D_CS_OP_UPDATE_SUB_RESOURCE */ wined3d_cs_exec_update_sub_resource
,
2717 /* WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION */ wined3d_cs_exec_add_dirty_texture_region
,
2718 /* WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_clear_unordered_access_view
,
2719 /* WINED3D_CS_OP_COPY_UAV_COUNTER */ wined3d_cs_exec_copy_uav_counter
,
2720 /* WINED3D_CS_OP_GENERATE_MIPMAPS */ wined3d_cs_exec_generate_mipmaps
,
2723 static void *wined3d_cs_st_require_space(struct wined3d_device_context
*context
,
2724 size_t size
, enum wined3d_cs_queue_id queue_id
)
2726 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2728 if (size
> (cs
->data_size
- cs
->end
))
2733 new_size
= max(size
, cs
->data_size
* 2);
2735 new_data
= heap_realloc(cs
->data
, new_size
);
2737 new_data
= heap_alloc(new_size
);
2741 cs
->data_size
= new_size
;
2742 cs
->start
= cs
->end
= 0;
2743 cs
->data
= new_data
;
2748 return (BYTE
*)cs
->data
+ cs
->start
;
2751 static void wined3d_cs_st_submit(struct wined3d_device_context
*context
, enum wined3d_cs_queue_id queue_id
)
2753 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2754 enum wined3d_cs_op opcode
;
2760 cs
->start
= cs
->end
;
2762 opcode
= *(const enum wined3d_cs_op
*)&data
[start
];
2763 if (opcode
>= WINED3D_CS_OP_STOP
)
2764 ERR("Invalid opcode %#x.\n", opcode
);
2766 wined3d_cs_op_handlers
[opcode
](cs
, &data
[start
]);
2768 if (cs
->data
== data
)
2769 cs
->start
= cs
->end
= start
;
2774 static void wined3d_cs_st_finish(struct wined3d_device_context
*context
, enum wined3d_cs_queue_id queue_id
)
2778 static const struct wined3d_device_context_ops wined3d_cs_st_ops
=
2780 wined3d_cs_st_require_space
,
2781 wined3d_cs_st_submit
,
2782 wined3d_cs_st_finish
,
2783 wined3d_cs_st_push_constants
,
2786 static BOOL
wined3d_cs_queue_is_empty(const struct wined3d_cs
*cs
, const struct wined3d_cs_queue
*queue
)
2788 wined3d_from_cs(cs
);
2789 return *(volatile LONG
*)&queue
->head
== queue
->tail
;
2792 static void wined3d_cs_queue_submit(struct wined3d_cs_queue
*queue
, struct wined3d_cs
*cs
)
2794 struct wined3d_cs_packet
*packet
;
2797 packet
= (struct wined3d_cs_packet
*)&queue
->data
[queue
->head
];
2798 packet_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[packet
->size
]);
2799 InterlockedExchange(&queue
->head
, (queue
->head
+ packet_size
) & (WINED3D_CS_QUEUE_SIZE
- 1));
2801 if (InterlockedCompareExchange(&cs
->waiting_for_event
, FALSE
, TRUE
))
2802 SetEvent(cs
->event
);
2805 static void wined3d_cs_mt_submit(struct wined3d_device_context
*context
, enum wined3d_cs_queue_id queue_id
)
2807 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2809 if (cs
->thread_id
== GetCurrentThreadId())
2810 return wined3d_cs_st_submit(context
, queue_id
);
2812 wined3d_cs_queue_submit(&cs
->queue
[queue_id
], cs
);
2815 static void *wined3d_cs_queue_require_space(struct wined3d_cs_queue
*queue
, size_t size
, struct wined3d_cs
*cs
)
2817 size_t queue_size
= ARRAY_SIZE(queue
->data
);
2818 size_t header_size
, packet_size
, remaining
;
2819 struct wined3d_cs_packet
*packet
;
2821 header_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[0]);
2822 packet_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[size
]);
2823 packet_size
= (packet_size
+ header_size
- 1) & ~(header_size
- 1);
2824 size
= packet_size
- header_size
;
2825 if (packet_size
>= WINED3D_CS_QUEUE_SIZE
)
2827 ERR("Packet size %lu >= queue size %u.\n",
2828 (unsigned long)packet_size
, WINED3D_CS_QUEUE_SIZE
);
2832 remaining
= queue_size
- queue
->head
;
2833 if (remaining
< packet_size
)
2835 size_t nop_size
= remaining
- header_size
;
2836 struct wined3d_cs_nop
*nop
;
2838 TRACE("Inserting a nop for %lu + %lu bytes.\n",
2839 (unsigned long)header_size
, (unsigned long)nop_size
);
2841 nop
= wined3d_cs_queue_require_space(queue
, nop_size
, cs
);
2843 nop
->opcode
= WINED3D_CS_OP_NOP
;
2845 wined3d_cs_queue_submit(queue
, cs
);
2846 assert(!queue
->head
);
2851 LONG tail
= *(volatile LONG
*)&queue
->tail
;
2852 LONG head
= queue
->head
;
2858 new_pos
= (head
+ packet_size
) & (WINED3D_CS_QUEUE_SIZE
- 1);
2859 /* Head ahead of tail. We checked the remaining size above, so we only
2860 * need to make sure we don't make head equal to tail. */
2861 if (head
> tail
&& (new_pos
!= tail
))
2863 /* Tail ahead of head. Make sure the new head is before the tail as
2864 * well. Note that new_pos is 0 when it's at the end of the queue. */
2865 if (new_pos
< tail
&& new_pos
)
2868 TRACE("Waiting for free space. Head %u, tail %u, packet size %lu.\n",
2869 head
, tail
, (unsigned long)packet_size
);
2872 packet
= (struct wined3d_cs_packet
*)&queue
->data
[queue
->head
];
2873 packet
->size
= size
;
2874 return packet
->data
;
2877 static void *wined3d_cs_mt_require_space(struct wined3d_device_context
*context
,
2878 size_t size
, enum wined3d_cs_queue_id queue_id
)
2880 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2882 if (cs
->thread_id
== GetCurrentThreadId())
2883 return wined3d_cs_st_require_space(context
, size
, queue_id
);
2885 return wined3d_cs_queue_require_space(&cs
->queue
[queue_id
], size
, cs
);
2888 static void wined3d_cs_mt_finish(struct wined3d_device_context
*context
, enum wined3d_cs_queue_id queue_id
)
2890 struct wined3d_cs
*cs
= wined3d_cs_from_context(context
);
2892 if (cs
->thread_id
== GetCurrentThreadId())
2893 return wined3d_cs_st_finish(context
, queue_id
);
2895 while (cs
->queue
[queue_id
].head
!= *(volatile LONG
*)&cs
->queue
[queue_id
].tail
)
2899 static const struct wined3d_device_context_ops wined3d_cs_mt_ops
=
2901 wined3d_cs_mt_require_space
,
2902 wined3d_cs_mt_submit
,
2903 wined3d_cs_mt_finish
,
2904 wined3d_cs_mt_push_constants
,
2907 static void poll_queries(struct wined3d_cs
*cs
)
2909 struct wined3d_query
*query
, *cursor
;
2911 LIST_FOR_EACH_ENTRY_SAFE(query
, cursor
, &cs
->query_poll_list
, struct wined3d_query
, poll_list_entry
)
2913 if (!query
->query_ops
->query_poll(query
, 0))
2916 list_remove(&query
->poll_list_entry
);
2917 list_init(&query
->poll_list_entry
);
2918 InterlockedIncrement(&query
->counter_retrieved
);
2922 static void wined3d_cs_wait_event(struct wined3d_cs
*cs
)
2924 InterlockedExchange(&cs
->waiting_for_event
, TRUE
);
2926 /* The main thread might have enqueued a command and blocked on it after
2927 * the CS thread decided to enter wined3d_cs_wait_event(), but before
2928 * "waiting_for_event" was set.
2930 * Likewise, we can race with the main thread when resetting
2931 * "waiting_for_event", in which case we would need to call
2932 * WaitForSingleObject() because the main thread called SetEvent(). */
2933 if (!(wined3d_cs_queue_is_empty(cs
, &cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
])
2934 && wined3d_cs_queue_is_empty(cs
, &cs
->queue
[WINED3D_CS_QUEUE_MAP
]))
2935 && InterlockedCompareExchange(&cs
->waiting_for_event
, FALSE
, TRUE
))
2938 WaitForSingleObject(cs
->event
, INFINITE
);
2941 static void wined3d_cs_command_lock(const struct wined3d_cs
*cs
)
2943 if (cs
->serialize_commands
)
2944 EnterCriticalSection(&wined3d_command_cs
);
2947 static void wined3d_cs_command_unlock(const struct wined3d_cs
*cs
)
2949 if (cs
->serialize_commands
)
2950 LeaveCriticalSection(&wined3d_command_cs
);
2953 static DWORD WINAPI
wined3d_cs_run(void *ctx
)
2955 struct wined3d_cs_packet
*packet
;
2956 struct wined3d_cs_queue
*queue
;
2957 unsigned int spin_count
= 0;
2958 struct wined3d_cs
*cs
= ctx
;
2959 enum wined3d_cs_op opcode
;
2960 HMODULE wined3d_module
;
2961 unsigned int poll
= 0;
2964 TRACE("Started.\n");
2966 /* Copy the module handle to a local variable to avoid racing with the
2967 * thread freeing "cs" before the FreeLibraryAndExitThread() call. */
2968 wined3d_module
= cs
->wined3d_module
;
2970 list_init(&cs
->query_poll_list
);
2971 cs
->thread_id
= GetCurrentThreadId();
2974 if (++poll
== WINED3D_CS_QUERY_POLL_INTERVAL
)
2976 wined3d_cs_command_lock(cs
);
2978 wined3d_cs_command_unlock(cs
);
2982 queue
= &cs
->queue
[WINED3D_CS_QUEUE_MAP
];
2983 if (wined3d_cs_queue_is_empty(cs
, queue
))
2985 queue
= &cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
];
2986 if (wined3d_cs_queue_is_empty(cs
, queue
))
2988 if (++spin_count
>= WINED3D_CS_SPIN_COUNT
&& list_empty(&cs
->query_poll_list
))
2989 wined3d_cs_wait_event(cs
);
2996 packet
= (struct wined3d_cs_packet
*)&queue
->data
[tail
];
2999 opcode
= *(const enum wined3d_cs_op
*)packet
->data
;
3001 TRACE("Executing %s.\n", debug_cs_op(opcode
));
3002 if (opcode
>= WINED3D_CS_OP_STOP
)
3004 if (opcode
> WINED3D_CS_OP_STOP
)
3005 ERR("Invalid opcode %#x.\n", opcode
);
3009 wined3d_cs_command_lock(cs
);
3010 wined3d_cs_op_handlers
[opcode
](cs
, packet
->data
);
3011 wined3d_cs_command_unlock(cs
);
3012 TRACE("%s executed.\n", debug_cs_op(opcode
));
3015 tail
+= FIELD_OFFSET(struct wined3d_cs_packet
, data
[packet
->size
]);
3016 tail
&= (WINED3D_CS_QUEUE_SIZE
- 1);
3017 InterlockedExchange(&queue
->tail
, tail
);
3020 cs
->queue
[WINED3D_CS_QUEUE_MAP
].tail
= cs
->queue
[WINED3D_CS_QUEUE_MAP
].head
;
3021 cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
].tail
= cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
].head
;
3022 TRACE("Stopped.\n");
3023 FreeLibraryAndExitThread(wined3d_module
, 0);
3026 struct wined3d_cs
*wined3d_cs_create(struct wined3d_device
*device
,
3027 const enum wined3d_feature_level
*levels
, unsigned int level_count
)
3029 const struct wined3d_d3d_info
*d3d_info
= &device
->adapter
->d3d_info
;
3030 struct wined3d_cs
*cs
;
3032 if (!(cs
= heap_alloc_zero(sizeof(*cs
))))
3035 if (FAILED(wined3d_state_create(device
, levels
, level_count
, &cs
->c
.state
)))
3041 cs
->c
.ops
= &wined3d_cs_st_ops
;
3042 cs
->c
.device
= device
;
3043 cs
->serialize_commands
= TRACE_ON(d3d_sync
) || wined3d_settings
.cs_multithreaded
& WINED3D_CSMT_SERIALIZE
;
3045 state_init(&cs
->state
, d3d_info
, WINED3D_STATE_NO_REF
| WINED3D_STATE_INIT_DEFAULT
, cs
->c
.state
->feature_level
);
3047 cs
->data_size
= WINED3D_INITIAL_CS_SIZE
;
3048 if (!(cs
->data
= heap_alloc(cs
->data_size
)))
3051 if (wined3d_settings
.cs_multithreaded
& WINED3D_CSMT_ENABLE
3052 && !RtlIsCriticalSectionLockedByThread(NtCurrentTeb()->Peb
->LoaderLock
))
3054 cs
->c
.ops
= &wined3d_cs_mt_ops
;
3056 if (!(cs
->event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
)))
3058 ERR("Failed to create command stream event.\n");
3059 heap_free(cs
->data
);
3063 if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
3064 (const WCHAR
*)wined3d_cs_run
, &cs
->wined3d_module
)))
3066 ERR("Failed to get wined3d module handle.\n");
3067 CloseHandle(cs
->event
);
3068 heap_free(cs
->data
);
3072 if (!(cs
->thread
= CreateThread(NULL
, 0, wined3d_cs_run
, cs
, 0, NULL
)))
3074 ERR("Failed to create wined3d command stream thread.\n");
3075 FreeLibrary(cs
->wined3d_module
);
3076 CloseHandle(cs
->event
);
3077 heap_free(cs
->data
);
3085 wined3d_state_destroy(cs
->c
.state
);
3086 state_cleanup(&cs
->state
);
3091 void wined3d_cs_destroy(struct wined3d_cs
*cs
)
3095 wined3d_cs_emit_stop(cs
);
3096 CloseHandle(cs
->thread
);
3097 if (!CloseHandle(cs
->event
))
3098 ERR("Closing event failed.\n");
3101 wined3d_state_destroy(cs
->c
.state
);
3102 state_cleanup(&cs
->state
);
3103 heap_free(cs
->data
);