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
);
25 #define WINED3D_INITIAL_CS_SIZE 4096
30 WINED3D_CS_OP_PRESENT
,
32 WINED3D_CS_OP_DISPATCH
,
35 WINED3D_CS_OP_SET_PREDICATION
,
36 WINED3D_CS_OP_SET_VIEWPORT
,
37 WINED3D_CS_OP_SET_SCISSOR_RECT
,
38 WINED3D_CS_OP_SET_RENDERTARGET_VIEW
,
39 WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
,
40 WINED3D_CS_OP_SET_VERTEX_DECLARATION
,
41 WINED3D_CS_OP_SET_STREAM_SOURCE
,
42 WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
,
43 WINED3D_CS_OP_SET_STREAM_OUTPUT
,
44 WINED3D_CS_OP_SET_INDEX_BUFFER
,
45 WINED3D_CS_OP_SET_CONSTANT_BUFFER
,
46 WINED3D_CS_OP_SET_TEXTURE
,
47 WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
,
48 WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
,
49 WINED3D_CS_OP_SET_SAMPLER
,
50 WINED3D_CS_OP_SET_SHADER
,
51 WINED3D_CS_OP_SET_BLEND_STATE
,
52 WINED3D_CS_OP_SET_RASTERIZER_STATE
,
53 WINED3D_CS_OP_SET_RENDER_STATE
,
54 WINED3D_CS_OP_SET_TEXTURE_STATE
,
55 WINED3D_CS_OP_SET_SAMPLER_STATE
,
56 WINED3D_CS_OP_SET_TRANSFORM
,
57 WINED3D_CS_OP_SET_CLIP_PLANE
,
58 WINED3D_CS_OP_SET_COLOR_KEY
,
59 WINED3D_CS_OP_SET_MATERIAL
,
60 WINED3D_CS_OP_SET_LIGHT
,
61 WINED3D_CS_OP_SET_LIGHT_ENABLE
,
62 WINED3D_CS_OP_PUSH_CONSTANTS
,
63 WINED3D_CS_OP_RESET_STATE
,
64 WINED3D_CS_OP_CALLBACK
,
65 WINED3D_CS_OP_QUERY_ISSUE
,
66 WINED3D_CS_OP_PRELOAD_RESOURCE
,
67 WINED3D_CS_OP_UNLOAD_RESOURCE
,
70 WINED3D_CS_OP_BLT_SUB_RESOURCE
,
71 WINED3D_CS_OP_UPDATE_SUB_RESOURCE
,
72 WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
,
73 WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
,
74 WINED3D_CS_OP_COPY_UAV_COUNTER
,
75 WINED3D_CS_OP_GENERATE_MIPMAPS
,
79 struct wined3d_cs_packet
87 enum wined3d_cs_op opcode
;
90 struct wined3d_cs_present
92 enum wined3d_cs_op opcode
;
93 HWND dst_window_override
;
94 struct wined3d_swapchain
*swapchain
;
101 struct wined3d_cs_clear
103 enum wined3d_cs_op opcode
;
105 unsigned int rt_count
;
106 struct wined3d_fb_state
*fb
;
108 struct wined3d_color color
;
111 unsigned int rect_count
;
115 struct wined3d_cs_dispatch
117 enum wined3d_cs_op opcode
;
118 struct wined3d_dispatch_parameters parameters
;
121 struct wined3d_cs_draw
123 enum wined3d_cs_op opcode
;
124 GLenum primitive_type
;
125 GLint patch_vertex_count
;
126 struct wined3d_draw_parameters parameters
;
129 struct wined3d_cs_flush
131 enum wined3d_cs_op opcode
;
134 struct wined3d_cs_set_predication
136 enum wined3d_cs_op opcode
;
137 struct wined3d_query
*predicate
;
141 struct wined3d_cs_set_viewport
143 enum wined3d_cs_op opcode
;
144 struct wined3d_viewport viewport
;
147 struct wined3d_cs_set_scissor_rect
149 enum wined3d_cs_op opcode
;
153 struct wined3d_cs_set_rendertarget_view
155 enum wined3d_cs_op opcode
;
156 unsigned int view_idx
;
157 struct wined3d_rendertarget_view
*view
;
160 struct wined3d_cs_set_depth_stencil_view
162 enum wined3d_cs_op opcode
;
163 struct wined3d_rendertarget_view
*view
;
166 struct wined3d_cs_set_vertex_declaration
168 enum wined3d_cs_op opcode
;
169 struct wined3d_vertex_declaration
*declaration
;
172 struct wined3d_cs_set_stream_source
174 enum wined3d_cs_op opcode
;
176 struct wined3d_buffer
*buffer
;
181 struct wined3d_cs_set_stream_source_freq
183 enum wined3d_cs_op opcode
;
189 struct wined3d_cs_set_stream_output
191 enum wined3d_cs_op opcode
;
193 struct wined3d_buffer
*buffer
;
197 struct wined3d_cs_set_index_buffer
199 enum wined3d_cs_op opcode
;
200 struct wined3d_buffer
*buffer
;
201 enum wined3d_format_id format_id
;
205 struct wined3d_cs_set_constant_buffer
207 enum wined3d_cs_op opcode
;
208 enum wined3d_shader_type type
;
210 struct wined3d_buffer
*buffer
;
213 struct wined3d_cs_set_texture
215 enum wined3d_cs_op opcode
;
217 struct wined3d_texture
*texture
;
220 struct wined3d_cs_set_color_key
222 enum wined3d_cs_op opcode
;
223 struct wined3d_texture
*texture
;
226 struct wined3d_color_key color_key
;
229 struct wined3d_cs_set_shader_resource_view
231 enum wined3d_cs_op opcode
;
232 enum wined3d_shader_type type
;
234 struct wined3d_shader_resource_view
*view
;
237 struct wined3d_cs_set_unordered_access_view
239 enum wined3d_cs_op opcode
;
240 enum wined3d_pipeline pipeline
;
241 unsigned int view_idx
;
242 struct wined3d_unordered_access_view
*view
;
243 unsigned int initial_count
;
246 struct wined3d_cs_set_sampler
248 enum wined3d_cs_op opcode
;
249 enum wined3d_shader_type type
;
251 struct wined3d_sampler
*sampler
;
254 struct wined3d_cs_set_shader
256 enum wined3d_cs_op opcode
;
257 enum wined3d_shader_type type
;
258 struct wined3d_shader
*shader
;
261 struct wined3d_cs_set_blend_state
263 enum wined3d_cs_op opcode
;
264 struct wined3d_blend_state
*state
;
267 struct wined3d_cs_set_rasterizer_state
269 enum wined3d_cs_op opcode
;
270 struct wined3d_rasterizer_state
*state
;
273 struct wined3d_cs_set_render_state
275 enum wined3d_cs_op opcode
;
276 enum wined3d_render_state state
;
280 struct wined3d_cs_set_texture_state
282 enum wined3d_cs_op opcode
;
284 enum wined3d_texture_stage_state state
;
288 struct wined3d_cs_set_sampler_state
290 enum wined3d_cs_op opcode
;
292 enum wined3d_sampler_state state
;
296 struct wined3d_cs_set_transform
298 enum wined3d_cs_op opcode
;
299 enum wined3d_transform_state state
;
300 struct wined3d_matrix matrix
;
303 struct wined3d_cs_set_clip_plane
305 enum wined3d_cs_op opcode
;
307 struct wined3d_vec4 plane
;
310 struct wined3d_cs_set_material
312 enum wined3d_cs_op opcode
;
313 struct wined3d_material material
;
316 struct wined3d_cs_set_light
318 enum wined3d_cs_op opcode
;
319 struct wined3d_light_info light
;
322 struct wined3d_cs_set_light_enable
324 enum wined3d_cs_op opcode
;
329 struct wined3d_cs_push_constants
331 enum wined3d_cs_op opcode
;
332 enum wined3d_push_constants type
;
333 unsigned int start_idx
;
338 struct wined3d_cs_reset_state
340 enum wined3d_cs_op opcode
;
343 struct wined3d_cs_callback
345 enum wined3d_cs_op opcode
;
346 void (*callback
)(void *object
);
350 struct wined3d_cs_query_issue
352 enum wined3d_cs_op opcode
;
353 struct wined3d_query
*query
;
357 struct wined3d_cs_preload_resource
359 enum wined3d_cs_op opcode
;
360 struct wined3d_resource
*resource
;
363 struct wined3d_cs_unload_resource
365 enum wined3d_cs_op opcode
;
366 struct wined3d_resource
*resource
;
369 struct wined3d_cs_map
371 enum wined3d_cs_op opcode
;
372 struct wined3d_resource
*resource
;
373 unsigned int sub_resource_idx
;
374 struct wined3d_map_desc
*map_desc
;
375 const struct wined3d_box
*box
;
380 struct wined3d_cs_unmap
382 enum wined3d_cs_op opcode
;
383 struct wined3d_resource
*resource
;
384 unsigned int sub_resource_idx
;
388 struct wined3d_cs_blt_sub_resource
390 enum wined3d_cs_op opcode
;
391 struct wined3d_resource
*dst_resource
;
392 unsigned int dst_sub_resource_idx
;
393 struct wined3d_box dst_box
;
394 struct wined3d_resource
*src_resource
;
395 unsigned int src_sub_resource_idx
;
396 struct wined3d_box src_box
;
398 struct wined3d_blt_fx fx
;
399 enum wined3d_texture_filter_type filter
;
402 struct wined3d_cs_update_sub_resource
404 enum wined3d_cs_op opcode
;
405 struct wined3d_resource
*resource
;
406 unsigned int sub_resource_idx
;
407 struct wined3d_box box
;
408 struct wined3d_sub_resource_data data
;
409 #if defined(STAGING_CSMT)
411 #endif /* STAGING_CSMT */
414 struct wined3d_cs_add_dirty_texture_region
416 enum wined3d_cs_op opcode
;
417 struct wined3d_texture
*texture
;
421 struct wined3d_cs_clear_unordered_access_view
423 enum wined3d_cs_op opcode
;
424 struct wined3d_unordered_access_view
*view
;
425 struct wined3d_uvec4 clear_value
;
428 struct wined3d_cs_copy_uav_counter
430 enum wined3d_cs_op opcode
;
431 struct wined3d_buffer
*buffer
;
433 struct wined3d_unordered_access_view
*view
;
436 struct wined3d_cs_generate_mipmaps
438 enum wined3d_cs_op opcode
;
439 struct wined3d_shader_resource_view
*view
;
442 struct wined3d_cs_stop
444 enum wined3d_cs_op opcode
;
447 static void wined3d_cs_exec_nop(struct wined3d_cs
*cs
, const void *data
)
451 static void wined3d_cs_exec_present(struct wined3d_cs
*cs
, const void *data
)
453 const struct wined3d_cs_present
*op
= data
;
454 struct wined3d_swapchain
*swapchain
;
457 swapchain
= op
->swapchain
;
458 wined3d_swapchain_set_window(swapchain
, op
->dst_window_override
);
460 if (op
->swap_interval
&& swapchain
->desc
.swap_interval
!= op
->swap_interval
)
462 swapchain
->desc
.swap_interval
= op
->swap_interval
;
463 swapchain_update_swap_interval(swapchain
);
466 swapchain
->swapchain_ops
->swapchain_present(swapchain
, &op
->src_rect
, &op
->dst_rect
, op
->flags
);
468 wined3d_resource_release(&swapchain
->front_buffer
->resource
);
469 for (i
= 0; i
< swapchain
->desc
.backbuffer_count
; ++i
)
471 wined3d_resource_release(&swapchain
->back_buffers
[i
]->resource
);
474 InterlockedDecrement(&cs
->pending_presents
);
477 void wined3d_cs_emit_present(struct wined3d_cs
*cs
, struct wined3d_swapchain
*swapchain
,
478 const RECT
*src_rect
, const RECT
*dst_rect
, HWND dst_window_override
,
479 DWORD swap_interval
, DWORD flags
)
481 struct wined3d_cs_present
*op
;
485 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
486 op
->opcode
= WINED3D_CS_OP_PRESENT
;
487 op
->dst_window_override
= dst_window_override
;
488 op
->swapchain
= swapchain
;
489 op
->src_rect
= *src_rect
;
490 op
->dst_rect
= *dst_rect
;
491 op
->swap_interval
= swap_interval
;
494 pending
= InterlockedIncrement(&cs
->pending_presents
);
496 wined3d_resource_acquire(&swapchain
->front_buffer
->resource
);
497 for (i
= 0; i
< swapchain
->desc
.backbuffer_count
; ++i
)
499 wined3d_resource_acquire(&swapchain
->back_buffers
[i
]->resource
);
502 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
504 /* Limit input latency by limiting the number of presents that we can get
505 * ahead of the worker thread. We have a constant limit here, but
506 * IDXGIDevice1 allows tuning this. */
510 pending
= InterlockedCompareExchange(&cs
->pending_presents
, 0, 0);
514 static void wined3d_cs_exec_clear(struct wined3d_cs
*cs
, const void *data
)
516 const struct wined3d_cs_clear
*op
= data
;
517 struct wined3d_device
*device
;
521 device
->blitter
->ops
->blitter_clear(device
->blitter
, device
, op
->rt_count
, op
->fb
,
522 op
->rect_count
, op
->rects
, &op
->draw_rect
, op
->flags
, &op
->color
, op
->depth
, op
->stencil
);
524 if (op
->flags
& WINED3DCLEAR_TARGET
)
526 for (i
= 0; i
< op
->rt_count
; ++i
)
528 if (op
->fb
->render_targets
[i
])
529 wined3d_resource_release(op
->fb
->render_targets
[i
]->resource
);
532 if (op
->flags
& (WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
))
533 wined3d_resource_release(op
->fb
->depth_stencil
->resource
);
536 void wined3d_cs_emit_clear(struct wined3d_cs
*cs
, DWORD rect_count
, const RECT
*rects
,
537 DWORD flags
, const struct wined3d_color
*color
, float depth
, DWORD stencil
)
539 unsigned int rt_count
= cs
->device
->adapter
->gl_info
.limits
.buffers
;
540 const struct wined3d_state
*state
= &cs
->device
->state
;
541 const struct wined3d_viewport
*vp
= &state
->viewport
;
542 struct wined3d_cs_clear
*op
;
545 op
= cs
->ops
->require_space(cs
, FIELD_OFFSET(struct wined3d_cs_clear
, rects
[rect_count
]),
546 WINED3D_CS_QUEUE_DEFAULT
);
547 op
->opcode
= WINED3D_CS_OP_CLEAR
;
549 op
->rt_count
= rt_count
;
551 SetRect(&op
->draw_rect
, vp
->x
, vp
->y
, vp
->x
+ vp
->width
, vp
->y
+ vp
->height
);
552 if (state
->render_states
[WINED3D_RS_SCISSORTESTENABLE
])
553 IntersectRect(&op
->draw_rect
, &op
->draw_rect
, &state
->scissor_rect
);
556 op
->stencil
= stencil
;
557 op
->rect_count
= rect_count
;
558 memcpy(op
->rects
, rects
, sizeof(*rects
) * rect_count
);
560 if (flags
& WINED3DCLEAR_TARGET
)
562 for (i
= 0; i
< rt_count
; ++i
)
564 if (state
->fb
->render_targets
[i
])
565 wined3d_resource_acquire(state
->fb
->render_targets
[i
]->resource
);
568 if (flags
& (WINED3DCLEAR_ZBUFFER
| WINED3DCLEAR_STENCIL
))
569 wined3d_resource_acquire(state
->fb
->depth_stencil
->resource
);
571 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
574 void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs
*cs
, struct wined3d_rendertarget_view
*view
,
575 const RECT
*rect
, DWORD flags
, const struct wined3d_color
*color
, float depth
, DWORD stencil
)
577 struct wined3d_cs_clear
*op
;
580 size
= FIELD_OFFSET(struct wined3d_cs_clear
, rects
[1]) + sizeof(struct wined3d_fb_state
);
581 op
= cs
->ops
->require_space(cs
, size
, WINED3D_CS_QUEUE_DEFAULT
);
582 op
->fb
= (void *)&op
->rects
[1];
584 op
->opcode
= WINED3D_CS_OP_CLEAR
;
586 if (flags
& WINED3DCLEAR_TARGET
)
589 op
->fb
->render_targets
[0] = view
;
590 op
->fb
->depth_stencil
= NULL
;
596 op
->fb
->render_targets
[0] = NULL
;
597 op
->fb
->depth_stencil
= view
;
599 op
->stencil
= stencil
;
601 SetRect(&op
->draw_rect
, 0, 0, view
->width
, view
->height
);
603 op
->rects
[0] = *rect
;
605 wined3d_resource_acquire(view
->resource
);
607 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
610 static void acquire_shader_resources(const struct wined3d_state
*state
, unsigned int shader_mask
)
612 struct wined3d_shader_sampler_map_entry
*entry
;
613 struct wined3d_shader_resource_view
*view
;
614 struct wined3d_shader
*shader
;
617 for (i
= 0; i
< WINED3D_SHADER_TYPE_COUNT
; ++i
)
619 if (!(shader_mask
& (1u << i
)))
622 if (!(shader
= state
->shader
[i
]))
625 for (j
= 0; j
< WINED3D_MAX_CBS
; ++j
)
628 wined3d_resource_acquire(&state
->cb
[i
][j
]->resource
);
631 for (j
= 0; j
< shader
->reg_maps
.sampler_map
.count
; ++j
)
633 entry
= &shader
->reg_maps
.sampler_map
.entries
[j
];
635 if (!(view
= state
->shader_resource_view
[i
][entry
->resource_idx
]))
638 wined3d_resource_acquire(view
->resource
);
643 static void release_shader_resources(const struct wined3d_state
*state
, unsigned int shader_mask
)
645 struct wined3d_shader_sampler_map_entry
*entry
;
646 struct wined3d_shader_resource_view
*view
;
647 struct wined3d_shader
*shader
;
650 for (i
= 0; i
< WINED3D_SHADER_TYPE_COUNT
; ++i
)
652 if (!(shader_mask
& (1u << i
)))
655 if (!(shader
= state
->shader
[i
]))
658 for (j
= 0; j
< WINED3D_MAX_CBS
; ++j
)
661 wined3d_resource_release(&state
->cb
[i
][j
]->resource
);
664 for (j
= 0; j
< shader
->reg_maps
.sampler_map
.count
; ++j
)
666 entry
= &shader
->reg_maps
.sampler_map
.entries
[j
];
668 if (!(view
= state
->shader_resource_view
[i
][entry
->resource_idx
]))
671 wined3d_resource_release(view
->resource
);
676 static void acquire_unordered_access_resources(const struct wined3d_shader
*shader
,
677 struct wined3d_unordered_access_view
* const *views
)
684 for (i
= 0; i
< MAX_UNORDERED_ACCESS_VIEWS
; ++i
)
686 if (!shader
->reg_maps
.uav_resource_info
[i
].type
)
692 wined3d_resource_acquire(views
[i
]->resource
);
696 static void release_unordered_access_resources(const struct wined3d_shader
*shader
,
697 struct wined3d_unordered_access_view
* const *views
)
704 for (i
= 0; i
< MAX_UNORDERED_ACCESS_VIEWS
; ++i
)
706 if (!shader
->reg_maps
.uav_resource_info
[i
].type
)
712 wined3d_resource_release(views
[i
]->resource
);
716 static void wined3d_cs_exec_dispatch(struct wined3d_cs
*cs
, const void *data
)
718 const struct wined3d_cs_dispatch
*op
= data
;
719 struct wined3d_state
*state
= &cs
->state
;
721 dispatch_compute(cs
->device
, state
, &op
->parameters
);
723 if (op
->parameters
.indirect
)
724 wined3d_resource_release(&op
->parameters
.u
.indirect
.buffer
->resource
);
726 release_shader_resources(state
, 1u << WINED3D_SHADER_TYPE_COMPUTE
);
727 release_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
],
728 state
->unordered_access_view
[WINED3D_PIPELINE_COMPUTE
]);
731 static void acquire_compute_pipeline_resources(const struct wined3d_state
*state
)
733 acquire_shader_resources(state
, 1u << WINED3D_SHADER_TYPE_COMPUTE
);
734 acquire_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
],
735 state
->unordered_access_view
[WINED3D_PIPELINE_COMPUTE
]);
738 void wined3d_cs_emit_dispatch(struct wined3d_cs
*cs
,
739 unsigned int group_count_x
, unsigned int group_count_y
, unsigned int group_count_z
)
741 const struct wined3d_state
*state
= &cs
->device
->state
;
742 struct wined3d_cs_dispatch
*op
;
744 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
745 op
->opcode
= WINED3D_CS_OP_DISPATCH
;
746 op
->parameters
.indirect
= FALSE
;
747 op
->parameters
.u
.direct
.group_count_x
= group_count_x
;
748 op
->parameters
.u
.direct
.group_count_y
= group_count_y
;
749 op
->parameters
.u
.direct
.group_count_z
= group_count_z
;
751 acquire_compute_pipeline_resources(state
);
753 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
756 void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs
*cs
,
757 struct wined3d_buffer
*buffer
, unsigned int offset
)
759 const struct wined3d_state
*state
= &cs
->device
->state
;
760 struct wined3d_cs_dispatch
*op
;
762 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
763 op
->opcode
= WINED3D_CS_OP_DISPATCH
;
764 op
->parameters
.indirect
= TRUE
;
765 op
->parameters
.u
.indirect
.buffer
= buffer
;
766 op
->parameters
.u
.indirect
.offset
= offset
;
768 acquire_compute_pipeline_resources(state
);
769 wined3d_resource_acquire(&buffer
->resource
);
771 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
774 static void wined3d_cs_exec_draw(struct wined3d_cs
*cs
, const void *data
)
776 const struct wined3d_gl_info
*gl_info
= &cs
->device
->adapter
->gl_info
;
777 struct wined3d_state
*state
= &cs
->state
;
778 const struct wined3d_cs_draw
*op
= data
;
779 int load_base_vertex_idx
;
782 /* ARB_draw_indirect always supports a base vertex offset. */
783 if (!op
->parameters
.indirect
&& !gl_info
->supported
[ARB_DRAW_ELEMENTS_BASE_VERTEX
])
784 load_base_vertex_idx
= op
->parameters
.u
.direct
.base_vertex_idx
;
786 load_base_vertex_idx
= 0;
788 if (state
->load_base_vertex_index
!= load_base_vertex_idx
)
790 state
->load_base_vertex_index
= load_base_vertex_idx
;
791 device_invalidate_state(cs
->device
, STATE_BASEVERTEXINDEX
);
794 if (state
->gl_primitive_type
!= op
->primitive_type
)
796 if (state
->gl_primitive_type
== GL_POINTS
|| op
->primitive_type
== GL_POINTS
)
797 device_invalidate_state(cs
->device
, STATE_POINT_ENABLE
);
798 state
->gl_primitive_type
= op
->primitive_type
;
800 state
->gl_patch_vertices
= op
->patch_vertex_count
;
802 draw_primitive(cs
->device
, state
, &op
->parameters
);
804 if (op
->parameters
.indirect
)
806 struct wined3d_buffer
*buffer
= op
->parameters
.u
.indirect
.buffer
;
807 wined3d_resource_release(&buffer
->resource
);
810 if (op
->parameters
.indexed
)
811 wined3d_resource_release(&state
->index_buffer
->resource
);
812 for (i
= 0; i
< ARRAY_SIZE(state
->streams
); ++i
)
814 if (state
->streams
[i
].buffer
)
815 wined3d_resource_release(&state
->streams
[i
].buffer
->resource
);
817 for (i
= 0; i
< ARRAY_SIZE(state
->stream_output
); ++i
)
819 if (state
->stream_output
[i
].buffer
)
820 wined3d_resource_release(&state
->stream_output
[i
].buffer
->resource
);
822 for (i
= 0; i
< ARRAY_SIZE(state
->textures
); ++i
)
824 if (state
->textures
[i
])
825 wined3d_resource_release(&state
->textures
[i
]->resource
);
827 for (i
= 0; i
< gl_info
->limits
.buffers
; ++i
)
829 if (state
->fb
->render_targets
[i
])
830 wined3d_resource_release(state
->fb
->render_targets
[i
]->resource
);
832 if (state
->fb
->depth_stencil
)
833 wined3d_resource_release(state
->fb
->depth_stencil
->resource
);
834 release_shader_resources(state
, ~(1u << WINED3D_SHADER_TYPE_COMPUTE
));
835 release_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_PIXEL
],
836 state
->unordered_access_view
[WINED3D_PIPELINE_GRAPHICS
]);
839 static void acquire_graphics_pipeline_resources(const struct wined3d_state
*state
,
840 BOOL indexed
, const struct wined3d_gl_info
*gl_info
)
845 wined3d_resource_acquire(&state
->index_buffer
->resource
);
846 for (i
= 0; i
< ARRAY_SIZE(state
->streams
); ++i
)
848 if (state
->streams
[i
].buffer
)
849 wined3d_resource_acquire(&state
->streams
[i
].buffer
->resource
);
851 for (i
= 0; i
< ARRAY_SIZE(state
->stream_output
); ++i
)
853 if (state
->stream_output
[i
].buffer
)
854 wined3d_resource_acquire(&state
->stream_output
[i
].buffer
->resource
);
856 for (i
= 0; i
< ARRAY_SIZE(state
->textures
); ++i
)
858 if (state
->textures
[i
])
859 wined3d_resource_acquire(&state
->textures
[i
]->resource
);
861 for (i
= 0; i
< gl_info
->limits
.buffers
; ++i
)
863 if (state
->fb
->render_targets
[i
])
864 wined3d_resource_acquire(state
->fb
->render_targets
[i
]->resource
);
866 if (state
->fb
->depth_stencil
)
867 wined3d_resource_acquire(state
->fb
->depth_stencil
->resource
);
868 acquire_shader_resources(state
, ~(1u << WINED3D_SHADER_TYPE_COMPUTE
));
869 acquire_unordered_access_resources(state
->shader
[WINED3D_SHADER_TYPE_PIXEL
],
870 state
->unordered_access_view
[WINED3D_PIPELINE_GRAPHICS
]);
873 void wined3d_cs_emit_draw(struct wined3d_cs
*cs
, GLenum primitive_type
, unsigned int patch_vertex_count
,
874 int base_vertex_idx
, unsigned int start_idx
, unsigned int index_count
,
875 unsigned int start_instance
, unsigned int instance_count
, BOOL indexed
)
877 const struct wined3d_gl_info
*gl_info
= &cs
->device
->adapter
->gl_info
;
878 const struct wined3d_state
*state
= &cs
->device
->state
;
879 struct wined3d_cs_draw
*op
;
881 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
882 op
->opcode
= WINED3D_CS_OP_DRAW
;
883 op
->primitive_type
= primitive_type
;
884 op
->patch_vertex_count
= patch_vertex_count
;
885 op
->parameters
.indirect
= FALSE
;
886 op
->parameters
.u
.direct
.base_vertex_idx
= base_vertex_idx
;
887 op
->parameters
.u
.direct
.start_idx
= start_idx
;
888 op
->parameters
.u
.direct
.index_count
= index_count
;
889 op
->parameters
.u
.direct
.start_instance
= start_instance
;
890 op
->parameters
.u
.direct
.instance_count
= instance_count
;
891 op
->parameters
.indexed
= indexed
;
893 acquire_graphics_pipeline_resources(state
, indexed
, gl_info
);
895 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
898 void wined3d_cs_emit_draw_indirect(struct wined3d_cs
*cs
, GLenum primitive_type
, unsigned int patch_vertex_count
,
899 struct wined3d_buffer
*buffer
, unsigned int offset
, BOOL indexed
)
901 const struct wined3d_gl_info
*gl_info
= &cs
->device
->adapter
->gl_info
;
902 const struct wined3d_state
*state
= &cs
->device
->state
;
903 struct wined3d_cs_draw
*op
;
905 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
906 op
->opcode
= WINED3D_CS_OP_DRAW
;
907 op
->primitive_type
= primitive_type
;
908 op
->patch_vertex_count
= patch_vertex_count
;
909 op
->parameters
.indirect
= TRUE
;
910 op
->parameters
.u
.indirect
.buffer
= buffer
;
911 op
->parameters
.u
.indirect
.offset
= offset
;
912 op
->parameters
.indexed
= indexed
;
914 acquire_graphics_pipeline_resources(state
, indexed
, gl_info
);
915 wined3d_resource_acquire(&buffer
->resource
);
917 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
920 static void wined3d_cs_exec_flush(struct wined3d_cs
*cs
, const void *data
)
922 struct wined3d_context
*context
;
924 context
= context_acquire(cs
->device
, NULL
, 0);
926 context
->gl_info
->gl_ops
.gl
.p_glFlush();
927 context_release(context
);
930 void wined3d_cs_emit_flush(struct wined3d_cs
*cs
)
932 struct wined3d_cs_flush
*op
;
934 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
935 op
->opcode
= WINED3D_CS_OP_FLUSH
;
937 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
938 cs
->queries_flushed
= TRUE
;
941 static void wined3d_cs_exec_set_predication(struct wined3d_cs
*cs
, const void *data
)
943 const struct wined3d_cs_set_predication
*op
= data
;
945 cs
->state
.predicate
= op
->predicate
;
946 cs
->state
.predicate_value
= op
->value
;
949 void wined3d_cs_emit_set_predication(struct wined3d_cs
*cs
, struct wined3d_query
*predicate
, BOOL value
)
951 struct wined3d_cs_set_predication
*op
;
953 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
954 op
->opcode
= WINED3D_CS_OP_SET_PREDICATION
;
955 op
->predicate
= predicate
;
958 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
961 static void wined3d_cs_exec_set_viewport(struct wined3d_cs
*cs
, const void *data
)
963 const struct wined3d_cs_set_viewport
*op
= data
;
965 cs
->state
.viewport
= op
->viewport
;
966 device_invalidate_state(cs
->device
, STATE_VIEWPORT
);
969 void wined3d_cs_emit_set_viewport(struct wined3d_cs
*cs
, const struct wined3d_viewport
*viewport
)
971 struct wined3d_cs_set_viewport
*op
;
973 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
974 op
->opcode
= WINED3D_CS_OP_SET_VIEWPORT
;
975 op
->viewport
= *viewport
;
977 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
980 static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs
*cs
, const void *data
)
982 const struct wined3d_cs_set_scissor_rect
*op
= data
;
984 cs
->state
.scissor_rect
= op
->rect
;
985 device_invalidate_state(cs
->device
, STATE_SCISSORRECT
);
988 void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs
*cs
, const RECT
*rect
)
990 struct wined3d_cs_set_scissor_rect
*op
;
992 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
993 op
->opcode
= WINED3D_CS_OP_SET_SCISSOR_RECT
;
996 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
999 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs
*cs
, const void *data
)
1001 const struct wined3d_cs_set_rendertarget_view
*op
= data
;
1003 cs
->fb
.render_targets
[op
->view_idx
] = op
->view
;
1004 device_invalidate_state(cs
->device
, STATE_FRAMEBUFFER
);
1007 void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs
*cs
, unsigned int view_idx
,
1008 struct wined3d_rendertarget_view
*view
)
1010 struct wined3d_cs_set_rendertarget_view
*op
;
1012 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1013 op
->opcode
= WINED3D_CS_OP_SET_RENDERTARGET_VIEW
;
1014 op
->view_idx
= view_idx
;
1017 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1020 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs
*cs
, const void *data
)
1022 const struct wined3d_cs_set_depth_stencil_view
*op
= data
;
1023 struct wined3d_device
*device
= cs
->device
;
1024 struct wined3d_rendertarget_view
*prev
;
1026 if ((prev
= cs
->state
.fb
->depth_stencil
))
1028 struct wined3d_surface
*prev_surface
= wined3d_rendertarget_view_get_surface(prev
);
1030 if (prev_surface
&& (device
->swapchains
[0]->desc
.flags
& WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1031 || prev_surface
->container
->flags
& WINED3D_TEXTURE_DISCARD
))
1033 wined3d_texture_validate_location(prev_surface
->container
,
1034 prev
->sub_resource_idx
, WINED3D_LOCATION_DISCARDED
);
1038 cs
->fb
.depth_stencil
= op
->view
;
1040 if (!prev
!= !op
->view
)
1042 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1043 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_ZENABLE
));
1044 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_STENCILENABLE
));
1045 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK
));
1046 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_DEPTHBIAS
));
1047 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_DEPTHBIASCLAMP
));
1049 else if (prev
&& prev
->format
->depth_bias_scale
!= op
->view
->format
->depth_bias_scale
)
1051 device_invalidate_state(device
, STATE_RENDER(WINED3D_RS_DEPTHBIAS
));
1054 device_invalidate_state(device
, STATE_FRAMEBUFFER
);
1057 void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs
*cs
, struct wined3d_rendertarget_view
*view
)
1059 struct wined3d_cs_set_depth_stencil_view
*op
;
1061 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1062 op
->opcode
= WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
;
1065 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1068 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs
*cs
, const void *data
)
1070 const struct wined3d_cs_set_vertex_declaration
*op
= data
;
1072 cs
->state
.vertex_declaration
= op
->declaration
;
1073 device_invalidate_state(cs
->device
, STATE_VDECL
);
1076 void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs
*cs
, struct wined3d_vertex_declaration
*declaration
)
1078 struct wined3d_cs_set_vertex_declaration
*op
;
1080 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1081 op
->opcode
= WINED3D_CS_OP_SET_VERTEX_DECLARATION
;
1082 op
->declaration
= declaration
;
1084 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1087 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs
*cs
, const void *data
)
1089 const struct wined3d_cs_set_stream_source
*op
= data
;
1090 struct wined3d_stream_state
*stream
;
1091 struct wined3d_buffer
*prev
;
1093 stream
= &cs
->state
.streams
[op
->stream_idx
];
1094 prev
= stream
->buffer
;
1095 stream
->buffer
= op
->buffer
;
1096 stream
->offset
= op
->offset
;
1097 stream
->stride
= op
->stride
;
1100 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1102 InterlockedDecrement(&prev
->resource
.bind_count
);
1104 device_invalidate_state(cs
->device
, STATE_STREAMSRC
);
1107 void wined3d_cs_emit_set_stream_source(struct wined3d_cs
*cs
, UINT stream_idx
,
1108 struct wined3d_buffer
*buffer
, UINT offset
, UINT stride
)
1110 struct wined3d_cs_set_stream_source
*op
;
1112 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1113 op
->opcode
= WINED3D_CS_OP_SET_STREAM_SOURCE
;
1114 op
->stream_idx
= stream_idx
;
1115 op
->buffer
= buffer
;
1116 op
->offset
= offset
;
1117 op
->stride
= stride
;
1119 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1122 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs
*cs
, const void *data
)
1124 const struct wined3d_cs_set_stream_source_freq
*op
= data
;
1125 struct wined3d_stream_state
*stream
;
1127 stream
= &cs
->state
.streams
[op
->stream_idx
];
1128 stream
->frequency
= op
->frequency
;
1129 stream
->flags
= op
->flags
;
1131 device_invalidate_state(cs
->device
, STATE_STREAMSRC
);
1134 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs
*cs
, UINT stream_idx
, UINT frequency
, UINT flags
)
1136 struct wined3d_cs_set_stream_source_freq
*op
;
1138 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1139 op
->opcode
= WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
;
1140 op
->stream_idx
= stream_idx
;
1141 op
->frequency
= frequency
;
1144 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1147 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs
*cs
, const void *data
)
1149 const struct wined3d_cs_set_stream_output
*op
= data
;
1150 struct wined3d_stream_output
*stream
;
1151 struct wined3d_buffer
*prev
;
1153 stream
= &cs
->state
.stream_output
[op
->stream_idx
];
1154 prev
= stream
->buffer
;
1155 stream
->buffer
= op
->buffer
;
1156 stream
->offset
= op
->offset
;
1159 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1161 InterlockedDecrement(&prev
->resource
.bind_count
);
1163 device_invalidate_state(cs
->device
, STATE_STREAM_OUTPUT
);
1166 void wined3d_cs_emit_set_stream_output(struct wined3d_cs
*cs
, UINT stream_idx
,
1167 struct wined3d_buffer
*buffer
, UINT offset
)
1169 struct wined3d_cs_set_stream_output
*op
;
1171 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1172 op
->opcode
= WINED3D_CS_OP_SET_STREAM_OUTPUT
;
1173 op
->stream_idx
= stream_idx
;
1174 op
->buffer
= buffer
;
1175 op
->offset
= offset
;
1177 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1180 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs
*cs
, const void *data
)
1182 const struct wined3d_cs_set_index_buffer
*op
= data
;
1183 struct wined3d_buffer
*prev
;
1185 prev
= cs
->state
.index_buffer
;
1186 cs
->state
.index_buffer
= op
->buffer
;
1187 cs
->state
.index_format
= op
->format_id
;
1188 cs
->state
.index_offset
= op
->offset
;
1191 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1193 InterlockedDecrement(&prev
->resource
.bind_count
);
1195 device_invalidate_state(cs
->device
, STATE_INDEXBUFFER
);
1198 void wined3d_cs_emit_set_index_buffer(struct wined3d_cs
*cs
, struct wined3d_buffer
*buffer
,
1199 enum wined3d_format_id format_id
, unsigned int offset
)
1201 struct wined3d_cs_set_index_buffer
*op
;
1203 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1204 op
->opcode
= WINED3D_CS_OP_SET_INDEX_BUFFER
;
1205 op
->buffer
= buffer
;
1206 op
->format_id
= format_id
;
1207 op
->offset
= offset
;
1209 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1212 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs
*cs
, const void *data
)
1214 const struct wined3d_cs_set_constant_buffer
*op
= data
;
1215 struct wined3d_buffer
*prev
;
1217 prev
= cs
->state
.cb
[op
->type
][op
->cb_idx
];
1218 cs
->state
.cb
[op
->type
][op
->cb_idx
] = op
->buffer
;
1221 InterlockedIncrement(&op
->buffer
->resource
.bind_count
);
1223 InterlockedDecrement(&prev
->resource
.bind_count
);
1225 device_invalidate_state(cs
->device
, STATE_CONSTANT_BUFFER(op
->type
));
1228 void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs
*cs
, enum wined3d_shader_type type
,
1229 UINT cb_idx
, struct wined3d_buffer
*buffer
)
1231 struct wined3d_cs_set_constant_buffer
*op
;
1233 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1234 op
->opcode
= WINED3D_CS_OP_SET_CONSTANT_BUFFER
;
1236 op
->cb_idx
= cb_idx
;
1237 op
->buffer
= buffer
;
1239 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1242 static void wined3d_cs_exec_set_texture(struct wined3d_cs
*cs
, const void *data
)
1244 const struct wined3d_gl_info
*gl_info
= &cs
->device
->adapter
->gl_info
;
1245 const struct wined3d_d3d_info
*d3d_info
= &cs
->device
->adapter
->d3d_info
;
1246 const struct wined3d_cs_set_texture
*op
= data
;
1247 struct wined3d_texture
*prev
;
1248 BOOL old_use_color_key
= FALSE
, new_use_color_key
= FALSE
;
1250 prev
= cs
->state
.textures
[op
->stage
];
1251 cs
->state
.textures
[op
->stage
] = op
->texture
;
1255 const struct wined3d_format
*new_format
= op
->texture
->resource
.format
;
1256 const struct wined3d_format
*old_format
= prev
? prev
->resource
.format
: NULL
;
1257 unsigned int old_fmt_flags
= prev
? prev
->resource
.format_flags
: 0;
1258 unsigned int new_fmt_flags
= op
->texture
->resource
.format_flags
;
1260 if (InterlockedIncrement(&op
->texture
->resource
.bind_count
) == 1)
1261 op
->texture
->sampler
= op
->stage
;
1263 if (!prev
|| op
->texture
->target
!= prev
->target
1264 || (!is_same_fixup(new_format
->color_fixup
, old_format
->color_fixup
)
1265 && !(can_use_texture_swizzle(gl_info
, new_format
) && can_use_texture_swizzle(gl_info
, old_format
)))
1266 || (new_fmt_flags
& WINED3DFMT_FLAG_SHADOW
) != (old_fmt_flags
& WINED3DFMT_FLAG_SHADOW
))
1267 device_invalidate_state(cs
->device
, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
));
1269 if (!prev
&& op
->stage
< d3d_info
->limits
.ffp_blend_stages
)
1271 /* The source arguments for color and alpha ops have different
1272 * meanings when a NULL texture is bound, so the COLOR_OP and
1273 * ALPHA_OP have to be dirtified. */
1274 device_invalidate_state(cs
->device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_COLOR_OP
));
1275 device_invalidate_state(cs
->device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_ALPHA_OP
));
1278 if (!op
->stage
&& op
->texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1279 new_use_color_key
= TRUE
;
1284 if (InterlockedDecrement(&prev
->resource
.bind_count
) && prev
->sampler
== op
->stage
)
1288 /* Search for other stages the texture is bound to. Shouldn't
1289 * happen if applications bind textures to a single stage only. */
1290 TRACE("Searching for other stages the texture is bound to.\n");
1291 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
)
1293 if (cs
->state
.textures
[i
] == prev
)
1295 TRACE("Texture is also bound to stage %u.\n", i
);
1302 if (!op
->texture
&& op
->stage
< d3d_info
->limits
.ffp_blend_stages
)
1304 device_invalidate_state(cs
->device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_COLOR_OP
));
1305 device_invalidate_state(cs
->device
, STATE_TEXTURESTAGE(op
->stage
, WINED3D_TSS_ALPHA_OP
));
1308 if (!op
->stage
&& prev
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1309 old_use_color_key
= TRUE
;
1312 device_invalidate_state(cs
->device
, STATE_SAMPLER(op
->stage
));
1314 if (new_use_color_key
!= old_use_color_key
)
1315 device_invalidate_state(cs
->device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1317 if (new_use_color_key
)
1318 device_invalidate_state(cs
->device
, STATE_COLOR_KEY
);
1321 void wined3d_cs_emit_set_texture(struct wined3d_cs
*cs
, UINT stage
, struct wined3d_texture
*texture
)
1323 struct wined3d_cs_set_texture
*op
;
1325 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1326 op
->opcode
= WINED3D_CS_OP_SET_TEXTURE
;
1328 op
->texture
= texture
;
1330 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1333 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs
*cs
, const void *data
)
1335 const struct wined3d_cs_set_shader_resource_view
*op
= data
;
1336 struct wined3d_shader_resource_view
*prev
;
1338 prev
= cs
->state
.shader_resource_view
[op
->type
][op
->view_idx
];
1339 cs
->state
.shader_resource_view
[op
->type
][op
->view_idx
] = op
->view
;
1342 InterlockedIncrement(&op
->view
->resource
->bind_count
);
1344 InterlockedDecrement(&prev
->resource
->bind_count
);
1346 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1347 device_invalidate_state(cs
->device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1349 device_invalidate_state(cs
->device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1352 void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs
*cs
, enum wined3d_shader_type type
,
1353 UINT view_idx
, struct wined3d_shader_resource_view
*view
)
1355 struct wined3d_cs_set_shader_resource_view
*op
;
1357 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1358 op
->opcode
= WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
;
1360 op
->view_idx
= view_idx
;
1363 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1366 static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs
*cs
, const void *data
)
1368 const struct wined3d_cs_set_unordered_access_view
*op
= data
;
1369 struct wined3d_unordered_access_view
*prev
;
1371 prev
= cs
->state
.unordered_access_view
[op
->pipeline
][op
->view_idx
];
1372 cs
->state
.unordered_access_view
[op
->pipeline
][op
->view_idx
] = op
->view
;
1375 InterlockedIncrement(&op
->view
->resource
->bind_count
);
1377 InterlockedDecrement(&prev
->resource
->bind_count
);
1379 if (op
->view
&& op
->initial_count
!= ~0u)
1380 wined3d_unordered_access_view_set_counter(op
->view
, op
->initial_count
);
1382 device_invalidate_state(cs
->device
, STATE_UNORDERED_ACCESS_VIEW_BINDING(op
->pipeline
));
1385 void wined3d_cs_emit_set_unordered_access_view(struct wined3d_cs
*cs
, enum wined3d_pipeline pipeline
,
1386 unsigned int view_idx
, struct wined3d_unordered_access_view
*view
, unsigned int initial_count
)
1388 struct wined3d_cs_set_unordered_access_view
*op
;
1390 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1391 op
->opcode
= WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
;
1392 op
->pipeline
= pipeline
;
1393 op
->view_idx
= view_idx
;
1395 op
->initial_count
= initial_count
;
1397 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1400 static void wined3d_cs_exec_set_sampler(struct wined3d_cs
*cs
, const void *data
)
1402 const struct wined3d_cs_set_sampler
*op
= data
;
1404 cs
->state
.sampler
[op
->type
][op
->sampler_idx
] = op
->sampler
;
1405 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1406 device_invalidate_state(cs
->device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1408 device_invalidate_state(cs
->device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1411 void wined3d_cs_emit_set_sampler(struct wined3d_cs
*cs
, enum wined3d_shader_type type
,
1412 UINT sampler_idx
, struct wined3d_sampler
*sampler
)
1414 struct wined3d_cs_set_sampler
*op
;
1416 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1417 op
->opcode
= WINED3D_CS_OP_SET_SAMPLER
;
1419 op
->sampler_idx
= sampler_idx
;
1420 op
->sampler
= sampler
;
1422 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1425 static void wined3d_cs_exec_set_shader(struct wined3d_cs
*cs
, const void *data
)
1427 const struct wined3d_cs_set_shader
*op
= data
;
1429 cs
->state
.shader
[op
->type
] = op
->shader
;
1430 device_invalidate_state(cs
->device
, STATE_SHADER(op
->type
));
1431 if (op
->type
!= WINED3D_SHADER_TYPE_COMPUTE
)
1432 device_invalidate_state(cs
->device
, STATE_GRAPHICS_SHADER_RESOURCE_BINDING
);
1434 device_invalidate_state(cs
->device
, STATE_COMPUTE_SHADER_RESOURCE_BINDING
);
1437 void wined3d_cs_emit_set_shader(struct wined3d_cs
*cs
, enum wined3d_shader_type type
, struct wined3d_shader
*shader
)
1439 struct wined3d_cs_set_shader
*op
;
1441 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1442 op
->opcode
= WINED3D_CS_OP_SET_SHADER
;
1444 op
->shader
= shader
;
1446 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1449 static void wined3d_cs_exec_set_blend_state(struct wined3d_cs
*cs
, const void *data
)
1451 const struct wined3d_cs_set_blend_state
*op
= data
;
1453 cs
->state
.blend_state
= op
->state
;
1454 device_invalidate_state(cs
->device
, STATE_BLEND
);
1457 void wined3d_cs_emit_set_blend_state(struct wined3d_cs
*cs
, struct wined3d_blend_state
*state
)
1459 struct wined3d_cs_set_blend_state
*op
;
1461 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1462 op
->opcode
= WINED3D_CS_OP_SET_BLEND_STATE
;
1465 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1468 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs
*cs
, const void *data
)
1470 const struct wined3d_cs_set_rasterizer_state
*op
= data
;
1472 cs
->state
.rasterizer_state
= op
->state
;
1473 device_invalidate_state(cs
->device
, STATE_FRONTFACE
);
1476 void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs
*cs
,
1477 struct wined3d_rasterizer_state
*rasterizer_state
)
1479 struct wined3d_cs_set_rasterizer_state
*op
;
1481 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1482 op
->opcode
= WINED3D_CS_OP_SET_RASTERIZER_STATE
;
1483 op
->state
= rasterizer_state
;
1485 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1488 static void wined3d_cs_exec_set_render_state(struct wined3d_cs
*cs
, const void *data
)
1490 const struct wined3d_cs_set_render_state
*op
= data
;
1492 cs
->state
.render_states
[op
->state
] = op
->value
;
1493 device_invalidate_state(cs
->device
, STATE_RENDER(op
->state
));
1496 void wined3d_cs_emit_set_render_state(struct wined3d_cs
*cs
, enum wined3d_render_state state
, DWORD value
)
1498 struct wined3d_cs_set_render_state
*op
;
1500 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1501 op
->opcode
= WINED3D_CS_OP_SET_RENDER_STATE
;
1505 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1508 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs
*cs
, const void *data
)
1510 const struct wined3d_cs_set_texture_state
*op
= data
;
1512 cs
->state
.texture_states
[op
->stage
][op
->state
] = op
->value
;
1513 device_invalidate_state(cs
->device
, STATE_TEXTURESTAGE(op
->stage
, op
->state
));
1516 void wined3d_cs_emit_set_texture_state(struct wined3d_cs
*cs
, UINT stage
,
1517 enum wined3d_texture_stage_state state
, DWORD value
)
1519 struct wined3d_cs_set_texture_state
*op
;
1521 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1522 op
->opcode
= WINED3D_CS_OP_SET_TEXTURE_STATE
;
1527 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1530 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs
*cs
, const void *data
)
1532 const struct wined3d_cs_set_sampler_state
*op
= data
;
1534 cs
->state
.sampler_states
[op
->sampler_idx
][op
->state
] = op
->value
;
1535 device_invalidate_state(cs
->device
, STATE_SAMPLER(op
->sampler_idx
));
1538 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs
*cs
, UINT sampler_idx
,
1539 enum wined3d_sampler_state state
, DWORD value
)
1541 struct wined3d_cs_set_sampler_state
*op
;
1543 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1544 op
->opcode
= WINED3D_CS_OP_SET_SAMPLER_STATE
;
1545 op
->sampler_idx
= sampler_idx
;
1549 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1552 static void wined3d_cs_exec_set_transform(struct wined3d_cs
*cs
, const void *data
)
1554 const struct wined3d_cs_set_transform
*op
= data
;
1556 cs
->state
.transforms
[op
->state
] = op
->matrix
;
1557 if (op
->state
< WINED3D_TS_WORLD_MATRIX(cs
->device
->adapter
->d3d_info
.limits
.ffp_vertex_blend_matrices
))
1558 device_invalidate_state(cs
->device
, STATE_TRANSFORM(op
->state
));
1561 void wined3d_cs_emit_set_transform(struct wined3d_cs
*cs
, enum wined3d_transform_state state
,
1562 const struct wined3d_matrix
*matrix
)
1564 struct wined3d_cs_set_transform
*op
;
1566 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1567 op
->opcode
= WINED3D_CS_OP_SET_TRANSFORM
;
1569 op
->matrix
= *matrix
;
1571 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1574 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs
*cs
, const void *data
)
1576 const struct wined3d_cs_set_clip_plane
*op
= data
;
1578 cs
->state
.clip_planes
[op
->plane_idx
] = op
->plane
;
1579 device_invalidate_state(cs
->device
, STATE_CLIPPLANE(op
->plane_idx
));
1582 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs
*cs
, UINT plane_idx
, const struct wined3d_vec4
*plane
)
1584 struct wined3d_cs_set_clip_plane
*op
;
1586 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1587 op
->opcode
= WINED3D_CS_OP_SET_CLIP_PLANE
;
1588 op
->plane_idx
= plane_idx
;
1591 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1594 static void wined3d_cs_exec_set_color_key(struct wined3d_cs
*cs
, const void *data
)
1596 const struct wined3d_cs_set_color_key
*op
= data
;
1597 struct wined3d_texture
*texture
= op
->texture
;
1603 case WINED3D_CKEY_DST_BLT
:
1604 texture
->async
.dst_blt_color_key
= op
->color_key
;
1605 texture
->async
.color_key_flags
|= WINED3D_CKEY_DST_BLT
;
1608 case WINED3D_CKEY_DST_OVERLAY
:
1609 texture
->async
.dst_overlay_color_key
= op
->color_key
;
1610 texture
->async
.color_key_flags
|= WINED3D_CKEY_DST_OVERLAY
;
1613 case WINED3D_CKEY_SRC_BLT
:
1614 if (texture
== cs
->state
.textures
[0])
1616 device_invalidate_state(cs
->device
, STATE_COLOR_KEY
);
1617 if (!(texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
))
1618 device_invalidate_state(cs
->device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1621 texture
->async
.src_blt_color_key
= op
->color_key
;
1622 texture
->async
.color_key_flags
|= WINED3D_CKEY_SRC_BLT
;
1625 case WINED3D_CKEY_SRC_OVERLAY
:
1626 texture
->async
.src_overlay_color_key
= op
->color_key
;
1627 texture
->async
.color_key_flags
|= WINED3D_CKEY_SRC_OVERLAY
;
1635 case WINED3D_CKEY_DST_BLT
:
1636 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_DST_BLT
;
1639 case WINED3D_CKEY_DST_OVERLAY
:
1640 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_DST_OVERLAY
;
1643 case WINED3D_CKEY_SRC_BLT
:
1644 if (texture
== cs
->state
.textures
[0] && texture
->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
)
1645 device_invalidate_state(cs
->device
, STATE_RENDER(WINED3D_RS_COLORKEYENABLE
));
1647 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_SRC_BLT
;
1650 case WINED3D_CKEY_SRC_OVERLAY
:
1651 texture
->async
.color_key_flags
&= ~WINED3D_CKEY_SRC_OVERLAY
;
1657 void wined3d_cs_emit_set_color_key(struct wined3d_cs
*cs
, struct wined3d_texture
*texture
,
1658 WORD flags
, const struct wined3d_color_key
*color_key
)
1660 struct wined3d_cs_set_color_key
*op
;
1662 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1663 op
->opcode
= WINED3D_CS_OP_SET_COLOR_KEY
;
1664 op
->texture
= texture
;
1668 op
->color_key
= *color_key
;
1674 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1677 static void wined3d_cs_exec_set_material(struct wined3d_cs
*cs
, const void *data
)
1679 const struct wined3d_cs_set_material
*op
= data
;
1681 cs
->state
.material
= op
->material
;
1682 device_invalidate_state(cs
->device
, STATE_MATERIAL
);
1685 void wined3d_cs_emit_set_material(struct wined3d_cs
*cs
, const struct wined3d_material
*material
)
1687 struct wined3d_cs_set_material
*op
;
1689 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1690 op
->opcode
= WINED3D_CS_OP_SET_MATERIAL
;
1691 op
->material
= *material
;
1693 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1696 static void wined3d_cs_exec_set_light(struct wined3d_cs
*cs
, const void *data
)
1698 const struct wined3d_cs_set_light
*op
= data
;
1699 struct wined3d_light_info
*light_info
;
1700 unsigned int light_idx
, hash_idx
;
1702 light_idx
= op
->light
.OriginalIndex
;
1704 if (!(light_info
= wined3d_state_get_light(&cs
->state
, light_idx
)))
1706 TRACE("Adding new light.\n");
1707 if (!(light_info
= heap_alloc_zero(sizeof(*light_info
))))
1709 ERR("Failed to allocate light info.\n");
1713 hash_idx
= LIGHTMAP_HASHFUNC(light_idx
);
1714 list_add_head(&cs
->state
.light_map
[hash_idx
], &light_info
->entry
);
1715 light_info
->glIndex
= -1;
1716 light_info
->OriginalIndex
= light_idx
;
1719 if (light_info
->glIndex
!= -1)
1721 if (light_info
->OriginalParms
.type
!= op
->light
.OriginalParms
.type
)
1722 device_invalidate_state(cs
->device
, STATE_LIGHT_TYPE
);
1723 device_invalidate_state(cs
->device
, STATE_ACTIVELIGHT(light_info
->glIndex
));
1726 light_info
->OriginalParms
= op
->light
.OriginalParms
;
1727 light_info
->position
= op
->light
.position
;
1728 light_info
->direction
= op
->light
.direction
;
1729 light_info
->exponent
= op
->light
.exponent
;
1730 light_info
->cutoff
= op
->light
.cutoff
;
1733 void wined3d_cs_emit_set_light(struct wined3d_cs
*cs
, const struct wined3d_light_info
*light
)
1735 struct wined3d_cs_set_light
*op
;
1737 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1738 op
->opcode
= WINED3D_CS_OP_SET_LIGHT
;
1741 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1744 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs
*cs
, const void *data
)
1746 const struct wined3d_cs_set_light_enable
*op
= data
;
1747 struct wined3d_device
*device
= cs
->device
;
1748 struct wined3d_light_info
*light_info
;
1751 if (!(light_info
= wined3d_state_get_light(&cs
->state
, op
->idx
)))
1753 ERR("Light doesn't exist.\n");
1757 prev_idx
= light_info
->glIndex
;
1758 wined3d_state_enable_light(&cs
->state
, &device
->adapter
->d3d_info
, light_info
, op
->enable
);
1759 if (light_info
->glIndex
!= prev_idx
)
1761 device_invalidate_state(device
, STATE_LIGHT_TYPE
);
1762 device_invalidate_state(device
, STATE_ACTIVELIGHT(op
->enable
? light_info
->glIndex
: prev_idx
));
1766 void wined3d_cs_emit_set_light_enable(struct wined3d_cs
*cs
, unsigned int idx
, BOOL enable
)
1768 struct wined3d_cs_set_light_enable
*op
;
1770 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1771 op
->opcode
= WINED3D_CS_OP_SET_LIGHT_ENABLE
;
1773 op
->enable
= enable
;
1775 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1784 wined3d_cs_push_constant_info
[] =
1786 /* WINED3D_PUSH_CONSTANTS_VS_F */
1787 {FIELD_OFFSET(struct wined3d_state
, vs_consts_f
), sizeof(struct wined3d_vec4
), WINED3D_SHADER_CONST_VS_F
},
1788 /* WINED3D_PUSH_CONSTANTS_PS_F */
1789 {FIELD_OFFSET(struct wined3d_state
, ps_consts_f
), sizeof(struct wined3d_vec4
), WINED3D_SHADER_CONST_PS_F
},
1790 /* WINED3D_PUSH_CONSTANTS_VS_I */
1791 {FIELD_OFFSET(struct wined3d_state
, vs_consts_i
), sizeof(struct wined3d_ivec4
), WINED3D_SHADER_CONST_VS_I
},
1792 /* WINED3D_PUSH_CONSTANTS_PS_I */
1793 {FIELD_OFFSET(struct wined3d_state
, ps_consts_i
), sizeof(struct wined3d_ivec4
), WINED3D_SHADER_CONST_PS_I
},
1794 /* WINED3D_PUSH_CONSTANTS_VS_B */
1795 {FIELD_OFFSET(struct wined3d_state
, vs_consts_b
), sizeof(BOOL
), WINED3D_SHADER_CONST_VS_B
},
1796 /* WINED3D_PUSH_CONSTANTS_PS_B */
1797 {FIELD_OFFSET(struct wined3d_state
, ps_consts_b
), sizeof(BOOL
), WINED3D_SHADER_CONST_PS_B
},
1800 static void wined3d_cs_st_push_constants(struct wined3d_cs
*cs
, enum wined3d_push_constants p
,
1801 unsigned int start_idx
, unsigned int count
, const void *constants
)
1803 struct wined3d_device
*device
= cs
->device
;
1804 unsigned int context_count
;
1808 if (p
== WINED3D_PUSH_CONSTANTS_VS_F
)
1809 device
->shader_backend
->shader_update_float_vertex_constants(device
, start_idx
, count
);
1810 else if (p
== WINED3D_PUSH_CONSTANTS_PS_F
)
1811 device
->shader_backend
->shader_update_float_pixel_constants(device
, start_idx
, count
);
1813 offset
= wined3d_cs_push_constant_info
[p
].offset
+ start_idx
* wined3d_cs_push_constant_info
[p
].size
;
1814 memcpy((BYTE
*)&cs
->state
+ offset
, constants
, count
* wined3d_cs_push_constant_info
[p
].size
);
1815 for (i
= 0, context_count
= device
->context_count
; i
< context_count
; ++i
)
1817 device
->contexts
[i
]->constant_update_mask
|= wined3d_cs_push_constant_info
[p
].mask
;
1821 static void wined3d_cs_exec_push_constants(struct wined3d_cs
*cs
, const void *data
)
1823 const struct wined3d_cs_push_constants
*op
= data
;
1825 wined3d_cs_st_push_constants(cs
, op
->type
, op
->start_idx
, op
->count
, op
->constants
);
1828 static void wined3d_cs_mt_push_constants(struct wined3d_cs
*cs
, enum wined3d_push_constants p
,
1829 unsigned int start_idx
, unsigned int count
, const void *constants
)
1831 struct wined3d_cs_push_constants
*op
;
1834 size
= count
* wined3d_cs_push_constant_info
[p
].size
;
1835 op
= cs
->ops
->require_space(cs
, FIELD_OFFSET(struct wined3d_cs_push_constants
, constants
[size
]),
1836 WINED3D_CS_QUEUE_DEFAULT
);
1837 op
->opcode
= WINED3D_CS_OP_PUSH_CONSTANTS
;
1839 op
->start_idx
= start_idx
;
1841 memcpy(op
->constants
, constants
, size
);
1843 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1846 static void wined3d_cs_exec_reset_state(struct wined3d_cs
*cs
, const void *data
)
1848 struct wined3d_adapter
*adapter
= cs
->device
->adapter
;
1850 state_cleanup(&cs
->state
);
1851 memset(&cs
->state
, 0, sizeof(cs
->state
));
1852 state_init(&cs
->state
, &cs
->fb
, &adapter
->gl_info
, &adapter
->d3d_info
,
1853 WINED3D_STATE_NO_REF
| WINED3D_STATE_INIT_DEFAULT
);
1856 void wined3d_cs_emit_reset_state(struct wined3d_cs
*cs
)
1858 struct wined3d_cs_reset_state
*op
;
1860 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1861 op
->opcode
= WINED3D_CS_OP_RESET_STATE
;
1863 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1866 static void wined3d_cs_exec_callback(struct wined3d_cs
*cs
, const void *data
)
1868 const struct wined3d_cs_callback
*op
= data
;
1870 op
->callback(op
->object
);
1873 static void wined3d_cs_emit_callback(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
1875 struct wined3d_cs_callback
*op
;
1877 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1878 op
->opcode
= WINED3D_CS_OP_CALLBACK
;
1879 op
->callback
= callback
;
1880 op
->object
= object
;
1882 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1885 void wined3d_cs_destroy_object(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
1887 wined3d_cs_emit_callback(cs
, callback
, object
);
1890 void wined3d_cs_init_object(struct wined3d_cs
*cs
, void (*callback
)(void *object
), void *object
)
1892 wined3d_cs_emit_callback(cs
, callback
, object
);
1895 static void wined3d_cs_exec_query_issue(struct wined3d_cs
*cs
, const void *data
)
1897 const struct wined3d_cs_query_issue
*op
= data
;
1898 struct wined3d_query
*query
= op
->query
;
1901 poll
= query
->query_ops
->query_issue(query
, op
->flags
);
1906 if (poll
&& list_empty(&query
->poll_list_entry
))
1908 list_add_tail(&cs
->query_poll_list
, &query
->poll_list_entry
);
1912 /* This can happen if occlusion queries are restarted. This discards the
1913 * old result, since polling it could result in a GL error. */
1914 if ((op
->flags
& WINED3DISSUE_BEGIN
) && !poll
&& !list_empty(&query
->poll_list_entry
))
1916 list_remove(&query
->poll_list_entry
);
1917 list_init(&query
->poll_list_entry
);
1918 InterlockedIncrement(&query
->counter_retrieved
);
1922 /* This can happen when an occlusion query is ended without being started,
1923 * in which case we don't want to poll, but still have to counter-balance
1924 * the increment of the main counter.
1926 * This can also happen if an event query is re-issued before the first
1927 * fence was reached. In this case the query is already in the list and
1928 * the poll function will check the new fence. We have to counter-balance
1929 * the discarded increment. */
1930 if (op
->flags
& WINED3DISSUE_END
)
1931 InterlockedIncrement(&query
->counter_retrieved
);
1934 void wined3d_cs_emit_query_issue(struct wined3d_cs
*cs
, struct wined3d_query
*query
, DWORD flags
)
1936 struct wined3d_cs_query_issue
*op
;
1938 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1939 op
->opcode
= WINED3D_CS_OP_QUERY_ISSUE
;
1943 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1944 cs
->queries_flushed
= FALSE
;
1947 static void wined3d_cs_exec_preload_resource(struct wined3d_cs
*cs
, const void *data
)
1949 const struct wined3d_cs_preload_resource
*op
= data
;
1950 struct wined3d_resource
*resource
= op
->resource
;
1952 resource
->resource_ops
->resource_preload(resource
);
1953 wined3d_resource_release(resource
);
1956 void wined3d_cs_emit_preload_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
)
1958 struct wined3d_cs_preload_resource
*op
;
1960 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1961 op
->opcode
= WINED3D_CS_OP_PRELOAD_RESOURCE
;
1962 op
->resource
= resource
;
1964 wined3d_resource_acquire(resource
);
1966 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1969 static void wined3d_cs_exec_unload_resource(struct wined3d_cs
*cs
, const void *data
)
1971 const struct wined3d_cs_unload_resource
*op
= data
;
1972 struct wined3d_resource
*resource
= op
->resource
;
1974 resource
->resource_ops
->resource_unload(resource
);
1975 wined3d_resource_release(resource
);
1978 void wined3d_cs_emit_unload_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
)
1980 struct wined3d_cs_unload_resource
*op
;
1982 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
1983 op
->opcode
= WINED3D_CS_OP_UNLOAD_RESOURCE
;
1984 op
->resource
= resource
;
1986 wined3d_resource_acquire(resource
);
1988 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
1991 static void wined3d_cs_exec_map(struct wined3d_cs
*cs
, const void *data
)
1993 const struct wined3d_cs_map
*op
= data
;
1994 struct wined3d_resource
*resource
= op
->resource
;
1996 *op
->hr
= resource
->resource_ops
->resource_sub_resource_map(resource
,
1997 op
->sub_resource_idx
, op
->map_desc
, op
->box
, op
->flags
);
2000 HRESULT
wined3d_cs_map(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
, unsigned int sub_resource_idx
,
2001 struct wined3d_map_desc
*map_desc
, const struct wined3d_box
*box
, unsigned int flags
)
2003 struct wined3d_cs_map
*op
;
2006 /* Mapping resources from the worker thread isn't an issue by itself, but
2007 * increasing the map count would be visible to applications. */
2008 wined3d_not_from_cs(cs
);
2010 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2011 op
->opcode
= WINED3D_CS_OP_MAP
;
2012 op
->resource
= resource
;
2013 op
->sub_resource_idx
= sub_resource_idx
;
2014 op
->map_desc
= map_desc
;
2019 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_MAP
);
2020 cs
->ops
->finish(cs
, WINED3D_CS_QUEUE_MAP
);
2025 static void wined3d_cs_exec_unmap(struct wined3d_cs
*cs
, const void *data
)
2027 const struct wined3d_cs_unmap
*op
= data
;
2028 struct wined3d_resource
*resource
= op
->resource
;
2030 *op
->hr
= resource
->resource_ops
->resource_sub_resource_unmap(resource
, op
->sub_resource_idx
);
2033 HRESULT
wined3d_cs_unmap(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
, unsigned int sub_resource_idx
)
2035 struct wined3d_cs_unmap
*op
;
2038 wined3d_not_from_cs(cs
);
2040 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2041 op
->opcode
= WINED3D_CS_OP_UNMAP
;
2042 op
->resource
= resource
;
2043 op
->sub_resource_idx
= sub_resource_idx
;
2046 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_MAP
);
2047 cs
->ops
->finish(cs
, WINED3D_CS_QUEUE_MAP
);
2052 static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs
*cs
, const void *data
)
2054 const struct wined3d_cs_blt_sub_resource
*op
= data
;
2056 if (op
->dst_resource
->type
== WINED3D_RTYPE_BUFFER
)
2058 wined3d_buffer_copy(buffer_from_resource(op
->dst_resource
), op
->dst_box
.left
,
2059 buffer_from_resource(op
->src_resource
), op
->src_box
.left
,
2060 op
->src_box
.right
- op
->src_box
.left
);
2062 else if (op
->dst_resource
->type
== WINED3D_RTYPE_TEXTURE_2D
)
2064 struct wined3d_surface
*dst_surface
, *src_surface
;
2065 struct wined3d_texture
*dst_texture
, *src_texture
;
2066 RECT dst_rect
, src_rect
;
2068 dst_texture
= texture_from_resource(op
->dst_resource
);
2069 src_texture
= texture_from_resource(op
->src_resource
);
2070 dst_surface
= dst_texture
->sub_resources
[op
->dst_sub_resource_idx
].u
.surface
;
2071 src_surface
= src_texture
->sub_resources
[op
->src_sub_resource_idx
].u
.surface
;
2072 SetRect(&dst_rect
, op
->dst_box
.left
, op
->dst_box
.top
, op
->dst_box
.right
, op
->dst_box
.bottom
);
2073 SetRect(&src_rect
, op
->src_box
.left
, op
->src_box
.top
, op
->src_box
.right
, op
->src_box
.bottom
);
2075 if (FAILED(wined3d_surface_blt(dst_surface
, &dst_rect
, src_surface
,
2076 &src_rect
, op
->flags
, &op
->fx
, op
->filter
)))
2077 FIXME("Blit failed.\n");
2079 else if (op
->dst_resource
->type
== WINED3D_RTYPE_TEXTURE_3D
)
2081 struct wined3d_texture
*src_texture
, *dst_texture
;
2082 unsigned int level
, update_w
, update_h
, update_d
;
2083 unsigned int row_pitch
, slice_pitch
;
2084 struct wined3d_context
*context
;
2085 struct wined3d_bo_address addr
;
2087 if (op
->flags
& ~WINED3D_BLT_RAW
)
2089 FIXME("Flags %#x not implemented for %s resources.\n",
2090 op
->flags
, debug_d3dresourcetype(op
->dst_resource
->type
));
2094 if (!(op
->flags
& WINED3D_BLT_RAW
) && op
->src_resource
->format
!= op
->dst_resource
->format
)
2096 FIXME("Format conversion not implemented for %s resources.\n",
2097 debug_d3dresourcetype(op
->dst_resource
->type
));
2101 update_w
= op
->dst_box
.right
- op
->dst_box
.left
;
2102 update_h
= op
->dst_box
.bottom
- op
->dst_box
.top
;
2103 update_d
= op
->dst_box
.back
- op
->dst_box
.front
;
2104 if (op
->src_box
.right
- op
->src_box
.left
!= update_w
2105 || op
->src_box
.bottom
- op
->src_box
.top
!= update_h
2106 || op
->src_box
.back
- op
->src_box
.front
!= update_d
)
2108 FIXME("Stretching not implemented for %s resources.\n",
2109 debug_d3dresourcetype(op
->dst_resource
->type
));
2113 if (op
->src_box
.left
|| op
->src_box
.top
|| op
->src_box
.front
)
2115 FIXME("Source box %s not supported for %s resources.\n",
2116 debug_box(&op
->src_box
), debug_d3dresourcetype(op
->dst_resource
->type
));
2120 dst_texture
= texture_from_resource(op
->dst_resource
);
2121 src_texture
= texture_from_resource(op
->src_resource
);
2123 context
= context_acquire(cs
->device
, NULL
, 0);
2125 if (!wined3d_texture_load_location(src_texture
, op
->src_sub_resource_idx
,
2126 context
, src_texture
->resource
.map_binding
))
2128 ERR("Failed to load source sub-resource into %s.\n",
2129 wined3d_debug_location(src_texture
->resource
.map_binding
));
2130 context_release(context
);
2134 level
= op
->dst_sub_resource_idx
% dst_texture
->level_count
;
2135 if (update_w
== wined3d_texture_get_level_width(dst_texture
, level
)
2136 && update_h
== wined3d_texture_get_level_height(dst_texture
, level
)
2137 && update_d
== wined3d_texture_get_level_depth(dst_texture
, level
))
2139 wined3d_texture_prepare_texture(dst_texture
, context
, FALSE
);
2141 else if (!wined3d_texture_load_location(dst_texture
, op
->dst_sub_resource_idx
,
2142 context
, WINED3D_LOCATION_TEXTURE_RGB
))
2144 ERR("Failed to load destination sub-resource.\n");
2145 context_release(context
);
2149 wined3d_texture_get_memory(src_texture
, op
->src_sub_resource_idx
, &addr
, src_texture
->resource
.map_binding
);
2150 wined3d_texture_get_pitch(src_texture
, op
->src_sub_resource_idx
% src_texture
->level_count
,
2151 &row_pitch
, &slice_pitch
);
2153 wined3d_texture_bind_and_dirtify(dst_texture
, context
, FALSE
);
2154 wined3d_texture_upload_data(dst_texture
, op
->dst_sub_resource_idx
, context
, &op
->dst_box
,
2155 wined3d_const_bo_address(&addr
), row_pitch
, slice_pitch
);
2156 wined3d_texture_validate_location(dst_texture
, op
->dst_sub_resource_idx
, WINED3D_LOCATION_TEXTURE_RGB
);
2157 wined3d_texture_invalidate_location(dst_texture
, op
->dst_sub_resource_idx
, ~WINED3D_LOCATION_TEXTURE_RGB
);
2159 context_release(context
);
2163 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(op
->dst_resource
->type
));
2167 if (op
->src_resource
)
2168 wined3d_resource_release(op
->src_resource
);
2169 wined3d_resource_release(op
->dst_resource
);
2172 void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*dst_resource
,
2173 unsigned int dst_sub_resource_idx
, const struct wined3d_box
*dst_box
, struct wined3d_resource
*src_resource
,
2174 unsigned int src_sub_resource_idx
, const struct wined3d_box
*src_box
, DWORD flags
,
2175 const struct wined3d_blt_fx
*fx
, enum wined3d_texture_filter_type filter
)
2177 struct wined3d_cs_blt_sub_resource
*op
;
2179 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2180 op
->opcode
= WINED3D_CS_OP_BLT_SUB_RESOURCE
;
2181 op
->dst_resource
= dst_resource
;
2182 op
->dst_sub_resource_idx
= dst_sub_resource_idx
;
2183 op
->dst_box
= *dst_box
;
2184 op
->src_resource
= src_resource
;
2185 op
->src_sub_resource_idx
= src_sub_resource_idx
;
2186 op
->src_box
= *src_box
;
2191 memset(&op
->fx
, 0, sizeof(op
->fx
));
2192 op
->filter
= filter
;
2194 wined3d_resource_acquire(dst_resource
);
2196 wined3d_resource_acquire(src_resource
);
2198 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2199 if (flags
& WINED3D_BLT_SYNCHRONOUS
)
2200 cs
->ops
->finish(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2203 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs
*cs
, const void *data
)
2205 const struct wined3d_cs_update_sub_resource
*op
= data
;
2206 struct wined3d_resource
*resource
= op
->resource
;
2207 const struct wined3d_box
*box
= &op
->box
;
2208 unsigned int width
, height
, depth
, level
;
2209 struct wined3d_const_bo_address addr
;
2210 struct wined3d_context
*context
;
2211 struct wined3d_texture
*texture
;
2213 context
= context_acquire(cs
->device
, NULL
, 0);
2215 if (resource
->type
== WINED3D_RTYPE_BUFFER
)
2217 struct wined3d_buffer
*buffer
= buffer_from_resource(resource
);
2219 if (!wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_BUFFER
))
2221 ERR("Failed to load buffer location.\n");
2225 wined3d_buffer_upload_data(buffer
, context
, box
, op
->data
.data
);
2226 wined3d_buffer_invalidate_location(buffer
, ~WINED3D_LOCATION_BUFFER
);
2230 texture
= wined3d_texture_from_resource(resource
);
2232 level
= op
->sub_resource_idx
% texture
->level_count
;
2233 width
= wined3d_texture_get_level_width(texture
, level
);
2234 height
= wined3d_texture_get_level_height(texture
, level
);
2235 depth
= wined3d_texture_get_level_depth(texture
, level
);
2237 addr
.buffer_object
= 0;
2238 addr
.addr
= op
->data
.data
;
2240 /* Only load the sub-resource for partial updates. */
2241 if (!box
->left
&& !box
->top
&& !box
->front
2242 && box
->right
== width
&& box
->bottom
== height
&& box
->back
== depth
)
2243 wined3d_texture_prepare_texture(texture
, context
, FALSE
);
2245 wined3d_texture_load_location(texture
, op
->sub_resource_idx
, context
, WINED3D_LOCATION_TEXTURE_RGB
);
2246 wined3d_texture_bind_and_dirtify(texture
, context
, FALSE
);
2248 wined3d_texture_upload_data(texture
, op
->sub_resource_idx
, context
,
2249 box
, &addr
, op
->data
.row_pitch
, op
->data
.slice_pitch
);
2251 wined3d_texture_validate_location(texture
, op
->sub_resource_idx
, WINED3D_LOCATION_TEXTURE_RGB
);
2252 wined3d_texture_invalidate_location(texture
, op
->sub_resource_idx
, ~WINED3D_LOCATION_TEXTURE_RGB
);
2255 context_release(context
);
2257 wined3d_resource_release(resource
);
2260 void wined3d_cs_emit_update_sub_resource(struct wined3d_cs
*cs
, struct wined3d_resource
*resource
,
2261 unsigned int sub_resource_idx
, const struct wined3d_box
*box
, const void *data
, unsigned int row_pitch
,
2262 unsigned int slice_pitch
)
2264 struct wined3d_cs_update_sub_resource
*op
;
2265 #if defined(STAGING_CSMT)
2266 size_t data_size
, size
;
2268 if (resource
->type
!= WINED3D_RTYPE_BUFFER
&& resource
->format_flags
& WINED3DFMT_FLAG_BLOCKS
)
2272 switch (resource
->type
)
2274 case WINED3D_RTYPE_TEXTURE_3D
:
2275 data_size
+= (box
->back
- box
->front
- 1) * slice_pitch
;
2277 case WINED3D_RTYPE_TEXTURE_2D
:
2278 data_size
+= (box
->bottom
- box
->top
- 1) * row_pitch
;
2280 case WINED3D_RTYPE_TEXTURE_1D
:
2281 data_size
+= (box
->right
- box
->left
) * resource
->format
->byte_count
;
2283 case WINED3D_RTYPE_BUFFER
:
2284 data_size
= box
->right
- box
->left
;
2286 case WINED3D_RTYPE_NONE
:
2290 size
= FIELD_OFFSET(struct wined3d_cs_update_sub_resource
, copy_data
[data_size
]);
2291 if (!cs
->ops
->check_space(cs
, size
, WINED3D_CS_QUEUE_DEFAULT
))
2294 op
= cs
->ops
->require_space(cs
, size
, WINED3D_CS_QUEUE_DEFAULT
);
2295 op
->opcode
= WINED3D_CS_OP_UPDATE_SUB_RESOURCE
;
2296 op
->resource
= resource
;
2297 op
->sub_resource_idx
= sub_resource_idx
;
2299 op
->data
.row_pitch
= row_pitch
;
2300 op
->data
.slice_pitch
= slice_pitch
;
2301 op
->data
.data
= op
->copy_data
;
2302 memcpy(op
->copy_data
, data
, data_size
);
2304 wined3d_resource_acquire(resource
);
2306 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2310 wined3d_resource_wait_idle(resource
);
2311 #endif /* STAGING_CSMT */
2313 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_MAP
);
2314 op
->opcode
= WINED3D_CS_OP_UPDATE_SUB_RESOURCE
;
2315 op
->resource
= resource
;
2316 op
->sub_resource_idx
= sub_resource_idx
;
2318 op
->data
.row_pitch
= row_pitch
;
2319 op
->data
.slice_pitch
= slice_pitch
;
2320 op
->data
.data
= data
;
2322 wined3d_resource_acquire(resource
);
2324 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_MAP
);
2325 #if !defined(STAGING_CSMT)
2326 /* The data pointer may go away, so we need to wait until it is read.
2327 * Copying the data may be faster if it's small. */
2328 #endif /* STAGING_CSMT */
2329 cs
->ops
->finish(cs
, WINED3D_CS_QUEUE_MAP
);
2332 static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs
*cs
, const void *data
)
2334 const struct wined3d_cs_add_dirty_texture_region
*op
= data
;
2335 struct wined3d_texture
*texture
= op
->texture
;
2336 unsigned int sub_resource_idx
, i
;
2337 struct wined3d_context
*context
;
2339 context
= context_acquire(cs
->device
, NULL
, 0);
2340 sub_resource_idx
= op
->layer
* texture
->level_count
;
2341 for (i
= 0; i
< texture
->level_count
; ++i
, ++sub_resource_idx
)
2343 if (wined3d_texture_load_location(texture
, sub_resource_idx
, context
, texture
->resource
.map_binding
))
2344 wined3d_texture_invalidate_location(texture
, sub_resource_idx
, ~texture
->resource
.map_binding
);
2346 ERR("Failed to load location %s.\n", wined3d_debug_location(texture
->resource
.map_binding
));
2348 context_release(context
);
2350 wined3d_resource_release(&texture
->resource
);
2353 void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs
*cs
,
2354 struct wined3d_texture
*texture
, unsigned int layer
)
2356 struct wined3d_cs_add_dirty_texture_region
*op
;
2358 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2359 op
->opcode
= WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
;
2360 op
->texture
= texture
;
2363 wined3d_resource_acquire(&texture
->resource
);
2365 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2368 static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs
*cs
, const void *data
)
2370 const struct wined3d_cs_clear_unordered_access_view
*op
= data
;
2371 struct wined3d_unordered_access_view
*view
= op
->view
;
2372 struct wined3d_context
*context
;
2374 context
= context_acquire(cs
->device
, NULL
, 0);
2375 wined3d_unordered_access_view_clear_uint(view
, &op
->clear_value
, context
);
2376 context_release(context
);
2378 wined3d_resource_release(view
->resource
);
2381 void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs
*cs
,
2382 struct wined3d_unordered_access_view
*view
, const struct wined3d_uvec4
*clear_value
)
2384 struct wined3d_cs_clear_unordered_access_view
*op
;
2386 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2387 op
->opcode
= WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
;
2389 op
->clear_value
= *clear_value
;
2391 wined3d_resource_acquire(view
->resource
);
2393 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2396 static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs
*cs
, const void *data
)
2398 const struct wined3d_cs_copy_uav_counter
*op
= data
;
2399 struct wined3d_unordered_access_view
*view
= op
->view
;
2400 struct wined3d_context
*context
;
2402 context
= context_acquire(cs
->device
, NULL
, 0);
2403 wined3d_unordered_access_view_copy_counter(view
, op
->buffer
, op
->offset
, context
);
2404 context_release(context
);
2406 wined3d_resource_release(&op
->buffer
->resource
);
2407 wined3d_resource_release(view
->resource
);
2410 void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs
*cs
, struct wined3d_buffer
*dst_buffer
,
2411 unsigned int offset
, struct wined3d_unordered_access_view
*uav
)
2413 struct wined3d_cs_copy_uav_counter
*op
;
2415 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2416 op
->opcode
= WINED3D_CS_OP_COPY_UAV_COUNTER
;
2417 op
->buffer
= dst_buffer
;
2418 op
->offset
= offset
;
2421 wined3d_resource_acquire(&dst_buffer
->resource
);
2422 wined3d_resource_acquire(uav
->resource
);
2424 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2427 static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs
*cs
, const void *data
)
2429 const struct wined3d_cs_generate_mipmaps
*op
= data
;
2430 struct wined3d_shader_resource_view
*view
= op
->view
;
2432 shader_resource_view_generate_mipmaps(view
);
2433 wined3d_resource_release(view
->resource
);
2436 void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs
*cs
, struct wined3d_shader_resource_view
*view
)
2438 struct wined3d_cs_generate_mipmaps
*op
;
2440 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2441 op
->opcode
= WINED3D_CS_OP_GENERATE_MIPMAPS
;
2444 wined3d_resource_acquire(view
->resource
);
2446 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2449 static void wined3d_cs_emit_stop(struct wined3d_cs
*cs
)
2451 struct wined3d_cs_stop
*op
;
2453 op
= cs
->ops
->require_space(cs
, sizeof(*op
), WINED3D_CS_QUEUE_DEFAULT
);
2454 op
->opcode
= WINED3D_CS_OP_STOP
;
2456 cs
->ops
->submit(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2457 cs
->ops
->finish(cs
, WINED3D_CS_QUEUE_DEFAULT
);
2460 static void (* const wined3d_cs_op_handlers
[])(struct wined3d_cs
*cs
, const void *data
) =
2462 /* WINED3D_CS_OP_NOP */ wined3d_cs_exec_nop
,
2463 /* WINED3D_CS_OP_PRESENT */ wined3d_cs_exec_present
,
2464 /* WINED3D_CS_OP_CLEAR */ wined3d_cs_exec_clear
,
2465 /* WINED3D_CS_OP_DISPATCH */ wined3d_cs_exec_dispatch
,
2466 /* WINED3D_CS_OP_DRAW */ wined3d_cs_exec_draw
,
2467 /* WINED3D_CS_OP_FLUSH */ wined3d_cs_exec_flush
,
2468 /* WINED3D_CS_OP_SET_PREDICATION */ wined3d_cs_exec_set_predication
,
2469 /* WINED3D_CS_OP_SET_VIEWPORT */ wined3d_cs_exec_set_viewport
,
2470 /* WINED3D_CS_OP_SET_SCISSOR_RECT */ wined3d_cs_exec_set_scissor_rect
,
2471 /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW */ wined3d_cs_exec_set_rendertarget_view
,
2472 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW */ wined3d_cs_exec_set_depth_stencil_view
,
2473 /* WINED3D_CS_OP_SET_VERTEX_DECLARATION */ wined3d_cs_exec_set_vertex_declaration
,
2474 /* WINED3D_CS_OP_SET_STREAM_SOURCE */ wined3d_cs_exec_set_stream_source
,
2475 /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq
,
2476 /* WINED3D_CS_OP_SET_STREAM_OUTPUT */ wined3d_cs_exec_set_stream_output
,
2477 /* WINED3D_CS_OP_SET_INDEX_BUFFER */ wined3d_cs_exec_set_index_buffer
,
2478 /* WINED3D_CS_OP_SET_CONSTANT_BUFFER */ wined3d_cs_exec_set_constant_buffer
,
2479 /* WINED3D_CS_OP_SET_TEXTURE */ wined3d_cs_exec_set_texture
,
2480 /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW */ wined3d_cs_exec_set_shader_resource_view
,
2481 /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_set_unordered_access_view
,
2482 /* WINED3D_CS_OP_SET_SAMPLER */ wined3d_cs_exec_set_sampler
,
2483 /* WINED3D_CS_OP_SET_SHADER */ wined3d_cs_exec_set_shader
,
2484 /* WINED3D_CS_OP_SET_BLEND_STATE */ wined3d_cs_exec_set_blend_state
,
2485 /* WINED3D_CS_OP_SET_RASTERIZER_STATE */ wined3d_cs_exec_set_rasterizer_state
,
2486 /* WINED3D_CS_OP_SET_RENDER_STATE */ wined3d_cs_exec_set_render_state
,
2487 /* WINED3D_CS_OP_SET_TEXTURE_STATE */ wined3d_cs_exec_set_texture_state
,
2488 /* WINED3D_CS_OP_SET_SAMPLER_STATE */ wined3d_cs_exec_set_sampler_state
,
2489 /* WINED3D_CS_OP_SET_TRANSFORM */ wined3d_cs_exec_set_transform
,
2490 /* WINED3D_CS_OP_SET_CLIP_PLANE */ wined3d_cs_exec_set_clip_plane
,
2491 /* WINED3D_CS_OP_SET_COLOR_KEY */ wined3d_cs_exec_set_color_key
,
2492 /* WINED3D_CS_OP_SET_MATERIAL */ wined3d_cs_exec_set_material
,
2493 /* WINED3D_CS_OP_SET_LIGHT */ wined3d_cs_exec_set_light
,
2494 /* WINED3D_CS_OP_SET_LIGHT_ENABLE */ wined3d_cs_exec_set_light_enable
,
2495 /* WINED3D_CS_OP_PUSH_CONSTANTS */ wined3d_cs_exec_push_constants
,
2496 /* WINED3D_CS_OP_RESET_STATE */ wined3d_cs_exec_reset_state
,
2497 /* WINED3D_CS_OP_CALLBACK */ wined3d_cs_exec_callback
,
2498 /* WINED3D_CS_OP_QUERY_ISSUE */ wined3d_cs_exec_query_issue
,
2499 /* WINED3D_CS_OP_PRELOAD_RESOURCE */ wined3d_cs_exec_preload_resource
,
2500 /* WINED3D_CS_OP_UNLOAD_RESOURCE */ wined3d_cs_exec_unload_resource
,
2501 /* WINED3D_CS_OP_MAP */ wined3d_cs_exec_map
,
2502 /* WINED3D_CS_OP_UNMAP */ wined3d_cs_exec_unmap
,
2503 /* WINED3D_CS_OP_BLT_SUB_RESOURCE */ wined3d_cs_exec_blt_sub_resource
,
2504 /* WINED3D_CS_OP_UPDATE_SUB_RESOURCE */ wined3d_cs_exec_update_sub_resource
,
2505 /* WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION */ wined3d_cs_exec_add_dirty_texture_region
,
2506 /* WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_clear_unordered_access_view
,
2507 /* WINED3D_CS_OP_COPY_UAV_COUNTER */ wined3d_cs_exec_copy_uav_counter
,
2508 /* WINED3D_CS_OP_GENERATE_MIPMAPS */ wined3d_cs_exec_generate_mipmaps
,
2511 #if defined(STAGING_CSMT)
2512 static BOOL
wined3d_cs_st_check_space(struct wined3d_cs
*cs
, size_t size
, enum wined3d_cs_queue_id queue_id
)
2517 #endif /* STAGING_CSMT */
2518 static void *wined3d_cs_st_require_space(struct wined3d_cs
*cs
, size_t size
, enum wined3d_cs_queue_id queue_id
)
2520 if (size
> (cs
->data_size
- cs
->end
))
2525 new_size
= max(size
, cs
->data_size
* 2);
2527 new_data
= heap_realloc(cs
->data
, new_size
);
2529 new_data
= heap_alloc(new_size
);
2533 cs
->data_size
= new_size
;
2534 cs
->start
= cs
->end
= 0;
2535 cs
->data
= new_data
;
2540 return (BYTE
*)cs
->data
+ cs
->start
;
2543 static void wined3d_cs_st_submit(struct wined3d_cs
*cs
, enum wined3d_cs_queue_id queue_id
)
2545 enum wined3d_cs_op opcode
;
2551 cs
->start
= cs
->end
;
2553 opcode
= *(const enum wined3d_cs_op
*)&data
[start
];
2554 if (opcode
>= WINED3D_CS_OP_STOP
)
2555 ERR("Invalid opcode %#x.\n", opcode
);
2557 wined3d_cs_op_handlers
[opcode
](cs
, &data
[start
]);
2559 if (cs
->data
== data
)
2560 cs
->start
= cs
->end
= start
;
2565 static void wined3d_cs_st_finish(struct wined3d_cs
*cs
, enum wined3d_cs_queue_id queue_id
)
2569 static const struct wined3d_cs_ops wined3d_cs_st_ops
=
2571 #if defined(STAGING_CSMT)
2572 wined3d_cs_st_check_space
,
2573 #endif /* STAGING_CSMT */
2574 wined3d_cs_st_require_space
,
2575 wined3d_cs_st_submit
,
2576 wined3d_cs_st_finish
,
2577 wined3d_cs_st_push_constants
,
2580 static BOOL
wined3d_cs_queue_is_empty(const struct wined3d_cs
*cs
, const struct wined3d_cs_queue
*queue
)
2582 wined3d_from_cs(cs
);
2583 return *(volatile LONG
*)&queue
->head
== queue
->tail
;
2586 static void wined3d_cs_queue_submit(struct wined3d_cs_queue
*queue
, struct wined3d_cs
*cs
)
2588 struct wined3d_cs_packet
*packet
;
2591 packet
= (struct wined3d_cs_packet
*)&queue
->data
[queue
->head
];
2592 packet_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[packet
->size
]);
2593 InterlockedExchange(&queue
->head
, (queue
->head
+ packet_size
) & (WINED3D_CS_QUEUE_SIZE
- 1));
2595 if (InterlockedCompareExchange(&cs
->waiting_for_event
, FALSE
, TRUE
))
2596 SetEvent(cs
->event
);
2599 static void wined3d_cs_mt_submit(struct wined3d_cs
*cs
, enum wined3d_cs_queue_id queue_id
)
2601 if (cs
->thread_id
== GetCurrentThreadId())
2603 wined3d_cs_st_submit(cs
, queue_id
);
2607 wined3d_cs_queue_submit(&cs
->queue
[queue_id
], cs
);
2610 #if defined(STAGING_CSMT)
2611 static BOOL
wined3d_cs_queue_check_space(struct wined3d_cs_queue
*queue
, size_t size
)
2613 size_t queue_size
= ARRAY_SIZE(queue
->data
);
2614 size_t header_size
, packet_size
, remaining
;
2616 header_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[0]);
2617 size
= (size
+ header_size
- 1) & ~(header_size
- 1);
2618 packet_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[size
]);
2620 remaining
= queue_size
- queue
->head
;
2621 return (remaining
>= packet_size
);
2624 #endif /* STAGING_CSMT */
2625 static void *wined3d_cs_queue_require_space(struct wined3d_cs_queue
*queue
, size_t size
, struct wined3d_cs
*cs
)
2627 size_t queue_size
= ARRAY_SIZE(queue
->data
);
2628 size_t header_size
, packet_size
, remaining
;
2629 struct wined3d_cs_packet
*packet
;
2631 header_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[0]);
2632 size
= (size
+ header_size
- 1) & ~(header_size
- 1);
2633 packet_size
= FIELD_OFFSET(struct wined3d_cs_packet
, data
[size
]);
2634 if (packet_size
>= WINED3D_CS_QUEUE_SIZE
)
2636 ERR("Packet size %lu >= queue size %u.\n",
2637 (unsigned long)packet_size
, WINED3D_CS_QUEUE_SIZE
);
2641 remaining
= queue_size
- queue
->head
;
2642 if (remaining
< packet_size
)
2644 size_t nop_size
= remaining
- header_size
;
2645 struct wined3d_cs_nop
*nop
;
2647 TRACE("Inserting a nop for %lu + %lu bytes.\n",
2648 (unsigned long)header_size
, (unsigned long)nop_size
);
2650 nop
= wined3d_cs_queue_require_space(queue
, nop_size
, cs
);
2652 nop
->opcode
= WINED3D_CS_OP_NOP
;
2654 wined3d_cs_queue_submit(queue
, cs
);
2655 assert(!queue
->head
);
2660 LONG tail
= *(volatile LONG
*)&queue
->tail
;
2661 LONG head
= queue
->head
;
2667 new_pos
= (head
+ packet_size
) & (WINED3D_CS_QUEUE_SIZE
- 1);
2668 /* Head ahead of tail. We checked the remaining size above, so we only
2669 * need to make sure we don't make head equal to tail. */
2670 if (head
> tail
&& (new_pos
!= tail
))
2672 /* Tail ahead of head. Make sure the new head is before the tail as
2673 * well. Note that new_pos is 0 when it's at the end of the queue. */
2674 if (new_pos
< tail
&& new_pos
)
2677 TRACE("Waiting for free space. Head %u, tail %u, packet size %lu.\n",
2678 head
, tail
, (unsigned long)packet_size
);
2681 packet
= (struct wined3d_cs_packet
*)&queue
->data
[queue
->head
];
2682 packet
->size
= size
;
2683 return packet
->data
;
2686 #if defined(STAGING_CSMT)
2687 static BOOL
wined3d_cs_mt_check_space(struct wined3d_cs
*cs
, size_t size
, enum wined3d_cs_queue_id queue_id
)
2689 if (cs
->thread_id
== GetCurrentThreadId())
2690 return wined3d_cs_st_check_space(cs
, size
, queue_id
);
2692 return wined3d_cs_queue_check_space(&cs
->queue
[queue_id
], size
);
2695 #endif /* STAGING_CSMT */
2696 static void *wined3d_cs_mt_require_space(struct wined3d_cs
*cs
, size_t size
, enum wined3d_cs_queue_id queue_id
)
2698 if (cs
->thread_id
== GetCurrentThreadId())
2699 return wined3d_cs_st_require_space(cs
, size
, queue_id
);
2701 return wined3d_cs_queue_require_space(&cs
->queue
[queue_id
], size
, cs
);
2704 static void wined3d_cs_mt_finish(struct wined3d_cs
*cs
, enum wined3d_cs_queue_id queue_id
)
2706 if (cs
->thread_id
== GetCurrentThreadId())
2708 wined3d_cs_st_finish(cs
, queue_id
);
2712 while (cs
->queue
[queue_id
].head
!= *(volatile LONG
*)&cs
->queue
[queue_id
].tail
)
2716 static const struct wined3d_cs_ops wined3d_cs_mt_ops
=
2718 #if defined(STAGING_CSMT)
2719 wined3d_cs_mt_check_space
,
2720 #endif /* STAGING_CSMT */
2721 wined3d_cs_mt_require_space
,
2722 wined3d_cs_mt_submit
,
2723 wined3d_cs_mt_finish
,
2724 wined3d_cs_mt_push_constants
,
2727 static void poll_queries(struct wined3d_cs
*cs
)
2729 struct wined3d_query
*query
, *cursor
;
2731 LIST_FOR_EACH_ENTRY_SAFE(query
, cursor
, &cs
->query_poll_list
, struct wined3d_query
, poll_list_entry
)
2733 if (!query
->query_ops
->query_poll(query
, 0))
2736 list_remove(&query
->poll_list_entry
);
2737 list_init(&query
->poll_list_entry
);
2738 InterlockedIncrement(&query
->counter_retrieved
);
2742 static void wined3d_cs_wait_event(struct wined3d_cs
*cs
)
2744 InterlockedExchange(&cs
->waiting_for_event
, TRUE
);
2746 /* The main thread might have enqueued a command and blocked on it after
2747 * the CS thread decided to enter wined3d_cs_wait_event(), but before
2748 * "waiting_for_event" was set.
2750 * Likewise, we can race with the main thread when resetting
2751 * "waiting_for_event", in which case we would need to call
2752 * WaitForSingleObject() because the main thread called SetEvent(). */
2753 if (!(wined3d_cs_queue_is_empty(cs
, &cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
])
2754 && wined3d_cs_queue_is_empty(cs
, &cs
->queue
[WINED3D_CS_QUEUE_MAP
]))
2755 && InterlockedCompareExchange(&cs
->waiting_for_event
, FALSE
, TRUE
))
2758 WaitForSingleObject(cs
->event
, INFINITE
);
2761 static DWORD WINAPI
wined3d_cs_run(void *ctx
)
2763 struct wined3d_cs_packet
*packet
;
2764 struct wined3d_cs_queue
*queue
;
2765 unsigned int spin_count
= 0;
2766 struct wined3d_cs
*cs
= ctx
;
2767 enum wined3d_cs_op opcode
;
2768 HMODULE wined3d_module
;
2769 unsigned int poll
= 0;
2772 TRACE("Started.\n");
2774 /* Copy the module handle to a local variable to avoid racing with the
2775 * thread freeing "cs" before the FreeLibraryAndExitThread() call. */
2776 wined3d_module
= cs
->wined3d_module
;
2778 list_init(&cs
->query_poll_list
);
2779 cs
->thread_id
= GetCurrentThreadId();
2782 if (++poll
== WINED3D_CS_QUERY_POLL_INTERVAL
)
2788 queue
= &cs
->queue
[WINED3D_CS_QUEUE_MAP
];
2789 if (wined3d_cs_queue_is_empty(cs
, queue
))
2791 queue
= &cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
];
2792 if (wined3d_cs_queue_is_empty(cs
, queue
))
2794 if (++spin_count
>= WINED3D_CS_SPIN_COUNT
&& list_empty(&cs
->query_poll_list
))
2795 wined3d_cs_wait_event(cs
);
2802 packet
= (struct wined3d_cs_packet
*)&queue
->data
[tail
];
2805 opcode
= *(const enum wined3d_cs_op
*)packet
->data
;
2807 if (opcode
>= WINED3D_CS_OP_STOP
)
2809 if (opcode
> WINED3D_CS_OP_STOP
)
2810 ERR("Invalid opcode %#x.\n", opcode
);
2814 wined3d_cs_op_handlers
[opcode
](cs
, packet
->data
);
2817 tail
+= FIELD_OFFSET(struct wined3d_cs_packet
, data
[packet
->size
]);
2818 tail
&= (WINED3D_CS_QUEUE_SIZE
- 1);
2819 InterlockedExchange(&queue
->tail
, tail
);
2822 cs
->queue
[WINED3D_CS_QUEUE_MAP
].tail
= cs
->queue
[WINED3D_CS_QUEUE_MAP
].head
;
2823 cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
].tail
= cs
->queue
[WINED3D_CS_QUEUE_DEFAULT
].head
;
2824 TRACE("Stopped.\n");
2825 FreeLibraryAndExitThread(wined3d_module
, 0);
2828 struct wined3d_cs
*wined3d_cs_create(struct wined3d_device
*device
)
2830 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
2831 struct wined3d_cs
*cs
;
2833 if (!(cs
= heap_alloc_zero(sizeof(*cs
))))
2836 cs
->ops
= &wined3d_cs_st_ops
;
2837 cs
->device
= device
;
2839 state_init(&cs
->state
, &cs
->fb
, gl_info
, &device
->adapter
->d3d_info
,
2840 WINED3D_STATE_NO_REF
| WINED3D_STATE_INIT_DEFAULT
);
2842 cs
->data_size
= WINED3D_INITIAL_CS_SIZE
;
2843 if (!(cs
->data
= heap_alloc(cs
->data_size
)))
2846 if (wined3d_settings
.cs_multithreaded
2847 && !RtlIsCriticalSectionLockedByThread(NtCurrentTeb()->Peb
->LoaderLock
))
2849 cs
->ops
= &wined3d_cs_mt_ops
;
2851 if (!(cs
->event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
)))
2853 ERR("Failed to create command stream event.\n");
2854 heap_free(cs
->data
);
2858 if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
2859 (const WCHAR
*)wined3d_cs_run
, &cs
->wined3d_module
)))
2861 ERR("Failed to get wined3d module handle.\n");
2862 CloseHandle(cs
->event
);
2863 heap_free(cs
->data
);
2867 if (!(cs
->thread
= CreateThread(NULL
, 0, wined3d_cs_run
, cs
, 0, NULL
)))
2869 ERR("Failed to create wined3d command stream thread.\n");
2870 FreeLibrary(cs
->wined3d_module
);
2871 CloseHandle(cs
->event
);
2872 heap_free(cs
->data
);
2880 state_cleanup(&cs
->state
);
2885 void wined3d_cs_destroy(struct wined3d_cs
*cs
)
2889 wined3d_cs_emit_stop(cs
);
2890 CloseHandle(cs
->thread
);
2891 if (!CloseHandle(cs
->event
))
2892 ERR("Closing event failed.\n");
2895 state_cleanup(&cs
->state
);
2896 heap_free(cs
->data
);