21 if (aspect & VK_IMAGE_ASPECT_DEPTH_BIT) {
22 if (aspect & VK_IMAGE_ASPECT_STENCIL_BIT) {
23 return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
25 return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
27 if (aspect & VK_IMAGE_ASPECT_STENCIL_BIT) {
28 return VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
30 return use_local_read ? VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR :
31 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
43 groups_extract_barriers(
51 groups_build_commands(
render_graph, command_buffer, node_handles);
64 NodeHandle node_handle = node_handles[nodes_range[node_group.
size()]];
69 node_group = nodes_range.
slice(0, node_group.
size() + 1);
72 group_nodes_.append(node_group);
73 nodes_range = nodes_range.drop_front(node_group.
size());
77void VKCommandBuilder::groups_extract_barriers(
VKRenderGraph &render_graph,
78 Span<NodeHandle> node_handles,
81 barrier_list_.clear();
82 vk_buffer_memory_barriers_.clear();
83 vk_image_memory_barriers_.clear();
85 ImageTracker image_tracker(*
this);
88 group_pre_barriers_.clear();
89 group_post_barriers_.clear();
90 node_pre_barriers_.resize(node_handles.
size());
95 Vector<Barrier> post_barriers;
98 Vector<Barrier> node_pre_barriers;
101 bool rendering_active =
false;
103 for (
const int64_t group_index : group_nodes_.index_range()) {
105 Barriers group_pre_barriers(barrier_list_.size(), 0);
106 const GroupNodes &node_group = group_nodes_[group_index];
107 for (
const int64_t group_node_index : node_group) {
108 NodeHandle node_handle = node_handles[group_node_index];
109 VKRenderGraphNode &
node = render_graph.nodes_[node_handle];
111 build_pipeline_barriers(
112 render_graph, node_handle,
node.pipeline_stage_get(), image_tracker,
barrier);
115 std::cout << __func__ <<
": node_group=" << group_index
116 <<
", node_group_range=" << node_group.first() <<
"-" << node_group.last()
117 <<
", node_handle=" << node_handle <<
", node_type=" <<
node.type
118 <<
", debug_group=" << render_graph.full_debug_group(node_handle) <<
"\n";
119 std::cout << __func__ <<
": " << to_string_barrier(
barrier);
127 node.synchronization.reset_layout_to_undefined)
129 for (
const VKRenderGraphImage &link : render_graph.linked_images(node_handle)) {
130 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
131 link.resource.handle);
132 resource.barrier_state.image_layout = VK_IMAGE_LAYOUT_UNDEFINED;
144 rendering_scope = node_handle;
145 rendering_active =
true;
146 image_tracker.begin(render_graph, node_handle);
154 const NodeHandle end_rendering_scope = rendering_scope;
156 rendering_active =
false;
163 for (
const VKRenderGraphImage &link : render_graph.linked_images(end_rendering_scope)) {
164 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
165 link.resource.handle);
166 VKResourceBarrierState &
state = resource.barrier_state;
167 if (link.vk_access_flags & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) {
168 state.vk_access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
170 if (link.vk_access_flags & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) {
171 state.vk_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
179 image_tracker.end(
barrier, use_local_read);
187 for (
const VKRenderGraphImage &link : render_graph.linked_images(end_rendering_scope)) {
188 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
189 link.resource.handle);
190 if (resource.use_subresource_tracking()) {
191 VKResourceBarrierState &
state = resource.barrier_state;
199 rendering_active =
false;
205 image_tracker.suspend(
barrier, use_local_read);
211 for (
const VKRenderGraphImage &link : render_graph.linked_images(rendering_scope)) {
212 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
213 link.resource.handle);
214 if (resource.use_subresource_tracking()) {
215 VKResourceBarrierState &
state = resource.barrier_state;
223 VKRenderGraphNode &rendering_node = render_graph.nodes_[rendering_scope];
225 build_pipeline_barriers(render_graph,
227 rendering_node.pipeline_stage_get(),
237 image_tracker.resume(
barrier, use_local_read);
242 rendering_active =
true;
247 node_has_input_attachments(render_graph, node_handle))
250 build_pipeline_barriers(
251 render_graph, node_handle,
node.pipeline_stage_get(), image_tracker,
barrier,
true);
253 node_pre_barriers.append(
barrier);
257 if (rendering_active) {
265 image_tracker.suspend(
barrier, use_local_read);
271 for (
const VKRenderGraphImage &link : render_graph.linked_images(rendering_scope)) {
272 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
273 link.resource.handle);
274 if (resource.use_subresource_tracking()) {
275 VKResourceBarrierState &
state = resource.barrier_state;
280 rendering_active =
false;
288 NodeHandle first_handle = node_handles[node_group.first()];
289 VKRenderGraphNode &first_node = render_graph.nodes_[first_handle];
291 VKBeginRenderingData &begin_data =
292 render_graph.storage_.begin_rendering[first_node.storage_index];
294 for (
const VKRenderGraphImage &link : render_graph.linked_images(first_handle)) {
295 if (!(link.vk_image_aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)))
299 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
300 link.resource.handle);
301 VkImageLayout gpu_layout = resource.barrier_state.image_layout;
304 if (gpu_layout == optimal_layout) {
309 if (link.vk_image_aspect & VK_IMAGE_ASPECT_DEPTH_BIT &&
310 begin_data.vk_rendering_info.pDepthAttachment !=
nullptr)
312 begin_data.depth_attachment.imageLayout = gpu_layout;
314 if (link.vk_image_aspect & VK_IMAGE_ASPECT_STENCIL_BIT &&
315 begin_data.vk_rendering_info.pStencilAttachment !=
nullptr)
317 begin_data.stencil_attachment.imageLayout = gpu_layout;
323 bool depth_load = (link.vk_image_aspect & VK_IMAGE_ASPECT_DEPTH_BIT) &&
324 begin_data.vk_rendering_info.pDepthAttachment !=
nullptr &&
325 begin_data.depth_attachment.loadOp == VK_ATTACHMENT_LOAD_OP_LOAD;
326 bool stencil_load = (link.vk_image_aspect & VK_IMAGE_ASPECT_STENCIL_BIT) &&
327 begin_data.vk_rendering_info.pStencilAttachment !=
nullptr &&
328 begin_data.stencil_attachment.loadOp == VK_ATTACHMENT_LOAD_OP_LOAD;
329 if (!depth_load && !stencil_load) {
335 barrier.src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
336 barrier.dst_stage_mask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
338 add_image_barrier(resource.image.vk_image,
340 VK_ACCESS_MEMORY_WRITE_BIT,
341 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
344 link.vk_image_aspect,
346 barrier.image_memory_barriers =
barrier.image_memory_barriers.with_new_end(
347 vk_image_memory_barriers_.size());
356 group_pre_barriers_.append(group_pre_barriers.with_new_end(barrier_list_size));
357 barrier_list_.extend(std::move(post_barriers));
359 group_post_barriers_.append(
361 if (!node_pre_barriers.is_empty()) {
362 barrier_list_size = barrier_list_.size();
363 barrier_list_.extend(std::move(node_pre_barriers));
364 node_pre_barriers = {};
366 for (
const int64_t group_node_index : node_group) {
367 NodeHandle node_handle = node_handles[group_node_index];
368 if (!node_pre_barriers_[node_handle].is_empty()) {
370 node_pre_barriers_[node_handle].start() + barrier_list_size, 1);
376 BLI_assert(group_pre_barriers_.size() == group_nodes_.size());
377 BLI_assert(group_post_barriers_.size() == group_nodes_.size());
380void VKCommandBuilder::groups_build_commands(
VKRenderGraph &render_graph,
382 Span<NodeHandle> node_handles)
384 DebugGroups debug_groups = {};
385 VKBoundPipelines active_pipelines = {};
388 bool rendering_active =
false;
390 for (
int64_t group_index : group_nodes_.index_range()) {
391 IndexRange group_nodes = group_nodes_[group_index];
392 Span<NodeHandle> group_node_handles = node_handles.
slice(group_nodes);
395 for (BarrierIndex barrier_index : group_pre_barriers_[group_index]) {
397 "Pre group barriers must be executed outside a rendering scope.");
398 Barrier &
barrier = barrier_list_[barrier_index];
400 std::cout << __func__ <<
": node_group=" << group_index
401 <<
", node_group_range=" << group_node_handles.
first() <<
"-"
402 << group_node_handles.
last() <<
", pre_barrier=(" << to_string_barrier(
barrier)
405 send_pipeline_barriers(command_buffer,
barrier,
false);
409 for (
NodeHandle node_handle : group_node_handles) {
410 VKRenderGraphNode &
node = render_graph.nodes_[node_handle];
413 activate_debug_group(render_graph, command_buffer, debug_groups, node_handle);
417 rendering_scope = node_handle;
418 rendering_active =
true;
422 rendering_active =
false;
425 if (!rendering_active) {
427 VKRenderGraphNode &rendering_node = render_graph.nodes_[rendering_scope];
429 render_graph.storage_.begin_rendering[rendering_node.storage_index]);
430 rendering_node.build_commands(command_buffer, render_graph.storage_, active_pipelines);
431 rendering_active =
true;
436 for (BarrierIndex node_pre_barrier_index : node_pre_barriers_[node_handle]) {
437 Barrier &
barrier = barrier_list_[node_pre_barrier_index];
439 std::cout << __func__ <<
": node_group=" << group_index
440 <<
", node_group_range=" << group_node_handles.first() <<
"-"
441 << group_node_handles.last() <<
", node_pre_barrier=(" << to_string_barrier(
barrier)
445 send_pipeline_barriers(command_buffer,
barrier,
true);
449 std::cout << __func__ <<
": node_group=" << group_index
450 <<
", node_group_range=" << group_node_handles.first() <<
"-"
451 << group_node_handles.last() <<
", node_handle=" << node_handle
452 <<
", node_type=" <<
node.type
453 <<
", debug group=" << render_graph.full_debug_group(node_handle) <<
"\n";
455 node.build_commands(command_buffer, render_graph.storage_, active_pipelines);
458 if (rendering_active) {
461 rendering_active =
false;
462 command_buffer.end_rendering();
466 for (BarrierIndex barrier_index : group_post_barriers_[group_index]) {
468 "Post group barriers must be executed outside a rendering scope.");
469 Barrier &
barrier = barrier_list_[barrier_index];
471 std::cout << __func__ <<
": node_group=" << group_index
472 <<
", node_group_range=" << group_node_handles.first() <<
"-"
473 << group_node_handles.last() <<
", post_barrier=(" << to_string_barrier(
barrier)
476 send_pipeline_barriers(command_buffer,
barrier,
false);
480 finish_debug_groups(command_buffer, debug_groups);
483bool VKCommandBuilder::node_has_input_attachments(
const VKRenderGraph &render_graph,
486 const Span<VKRenderGraphImage> images = render_graph.linked_images(node_handle);
487 return std::ranges::any_of(images.
begin(), images.
end(), [](
const VKRenderGraphImage &input) {
488 return input.vk_access_flags & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
492void VKCommandBuilder::activate_debug_group(
VKRenderGraph &render_graph,
494 DebugGroups &debug_groups,
497 VKRenderGraph::DebugGroupID debug_group = render_graph.debug_.node_group_map[node_handle];
498 if (debug_group == debug_groups.active_debug_group_id) {
506 if (debug_group == -1) {
507 num_ends = debug_groups.debug_level;
510 Vector<VKRenderGraph::DebugGroupNameID> &to_group =
511 render_graph.debug_.used_groups[debug_group];
512 if (debug_groups.active_debug_group_id != -1) {
513 Vector<VKRenderGraph::DebugGroupNameID> &from_group =
514 render_graph.debug_.used_groups[debug_groups.active_debug_group_id];
516 num_ends =
max_ii(from_group.size() - to_group.size(), 0);
517 int num_checks =
min_ii(from_group.size(), to_group.size());
519 if (from_group[index] != to_group[index]) {
520 num_ends += num_checks -
index;
526 num_begins = to_group.size() - (debug_groups.debug_level - num_ends);
530 for (
int index = 0;
index < num_ends;
index++) {
531 command_buffer.end_debug_utils_label();
533 debug_groups.debug_level -= num_ends;
536 if (num_begins > 0) {
537 Vector<VKRenderGraph::DebugGroupNameID> &to_group =
538 render_graph.debug_.used_groups[debug_group];
539 VkDebugUtilsLabelEXT debug_utils_label = {};
540 debug_utils_label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
541 for (
int index :
IndexRange(debug_groups.debug_level, num_begins)) {
542 const VKRenderGraph::DebugGroup &debug_group = render_graph.debug_.groups[to_group[
index]];
543 debug_utils_label.pLabelName = debug_group.name.c_str();
544 copy_v4_v4(debug_utils_label.color, debug_group.color);
545 command_buffer.begin_debug_utils_label(&debug_utils_label);
549 debug_groups.debug_level += num_begins;
550 debug_groups.active_debug_group_id = debug_group;
554 DebugGroups &debug_groups)
556 for (
int i = 0; i < debug_groups.debug_level; i++) {
557 command_buffer.end_debug_utils_label();
559 debug_groups.debug_level = 0;
562void VKCommandBuilder::build_pipeline_barriers(
VKRenderGraph &render_graph,
564 VkPipelineStageFlags pipeline_stage,
565 ImageTracker &image_tracker,
567 bool within_rendering)
569 reset_barriers(r_barrier);
571 render_graph, node_handle, pipeline_stage, image_tracker, r_barrier, within_rendering);
572 add_buffer_barriers(render_graph, node_handle, pipeline_stage, r_barrier);
581void VKCommandBuilder::reset_barriers(Barrier &r_barrier)
583 r_barrier.dst_stage_mask = r_barrier.src_stage_mask = VK_PIPELINE_STAGE_NONE;
588 bool within_rendering)
599 VkPipelineStageFlags src_stage_mask = (
barrier.src_stage_mask == VK_PIPELINE_STAGE_NONE) ?
600 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :
601 VkPipelineStageFlagBits(
barrier.src_stage_mask);
603 VkPipelineStageFlags dst_stage_mask =
barrier.dst_stage_mask;
605 if (within_rendering) {
610 src_stage_mask = dst_stage_mask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
611 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
612 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
613 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
616 Span<VkBufferMemoryBarrier> buffer_barriers = vk_buffer_memory_barriers_.as_span().slice(
617 barrier.buffer_memory_barriers);
618 Span<VkImageMemoryBarrier> image_barriers = vk_image_memory_barriers_.as_span().slice(
619 barrier.image_memory_barriers);
621 command_buffer.pipeline_barrier(src_stage_mask,
623 VK_DEPENDENCY_BY_REGION_BIT,
626 buffer_barriers.
size(),
627 buffer_barriers.
data(),
628 image_barriers.size(),
629 image_barriers.data());
632void VKCommandBuilder::add_buffer_barriers(
VKRenderGraph &render_graph,
634 VkPipelineStageFlags node_stages,
637 r_barrier.buffer_memory_barriers =
IndexRange(vk_buffer_memory_barriers_.size(), 0);
638 add_buffer_read_barriers(render_graph, node_handle, node_stages, r_barrier);
639 add_buffer_write_barriers(render_graph, node_handle, node_stages, r_barrier);
640 r_barrier.buffer_memory_barriers = r_barrier.buffer_memory_barriers.with_new_end(
641 vk_buffer_memory_barriers_.size());
644void VKCommandBuilder::add_buffer_read_barriers(
VKRenderGraph &render_graph,
646 VkPipelineStageFlags node_stages,
649 for (
const VKRenderGraphBuffer &link : render_graph.linked_buffers(node_handle)) {
650 if (link.has_write_access()) {
653 const ResourceWithStamp &versioned_resource = link.resource;
654 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_buffer_resource(
655 versioned_resource.handle);
656 VKResourceBarrierState &resource_state = resource.barrier_state;
657 const bool is_first_read = resource_state.is_new_stamp();
658 if (!is_first_read &&
659 (resource_state.vk_access & link.vk_access_flags) == link.vk_access_flags &&
660 (resource_state.vk_pipeline_stages & node_stages) == node_stages)
666 const VkAccessFlags wait_access = resource_state.vk_access;
668 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
669 r_barrier.dst_stage_mask |= node_stages;
672 resource_state.vk_access = link.vk_access_flags;
673 resource_state.vk_pipeline_stages = node_stages;
676 resource_state.vk_access |= link.vk_access_flags;
677 resource_state.vk_pipeline_stages |= node_stages;
680 if (wait_access != VK_ACCESS_NONE) {
681 add_buffer_barrier(resource.buffer.vk_buffer, r_barrier, wait_access, link.vk_access_flags);
686void VKCommandBuilder::add_buffer_write_barriers(
VKRenderGraph &render_graph,
688 VkPipelineStageFlags node_stages,
691 for (
const VKRenderGraphBuffer &link : render_graph.linked_buffers(node_handle)) {
692 if (!link.has_write_access()) {
695 const ResourceWithStamp &versioned_resource = link.resource;
696 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_buffer_resource(
697 versioned_resource.handle);
698 VKResourceBarrierState &resource_state = resource.barrier_state;
699 const VkAccessFlags wait_access = resource_state.vk_access;
701 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
702 r_barrier.dst_stage_mask |= node_stages;
704 resource_state.vk_access = link.vk_access_flags;
705 resource_state.vk_pipeline_stages = node_stages;
707 if (wait_access != VK_ACCESS_NONE) {
708 add_buffer_barrier(resource.buffer.vk_buffer, r_barrier, wait_access, link.vk_access_flags);
713void VKCommandBuilder::add_buffer_barrier(VkBuffer vk_buffer,
715 VkAccessFlags src_access_mask,
716 VkAccessFlags dst_access_mask)
718 for (VkBufferMemoryBarrier &vk_buffer_memory_barrier :
719 vk_buffer_memory_barriers_.as_mutable_span().drop_front(
720 r_barrier.buffer_memory_barriers.start()))
722 if (vk_buffer_memory_barrier.buffer == vk_buffer) {
725 if ((vk_buffer_memory_barrier.dstAccessMask & src_access_mask) == src_access_mask) {
726 vk_buffer_memory_barrier.dstAccessMask |= dst_access_mask;
731 if ((vk_buffer_memory_barrier.dstAccessMask & dst_access_mask) == dst_access_mask &&
732 (vk_buffer_memory_barrier.srcAccessMask & src_access_mask) == src_access_mask)
739 vk_buffer_memory_barriers_.append({VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
743 VK_QUEUE_FAMILY_IGNORED,
744 VK_QUEUE_FAMILY_IGNORED,
750void VKCommandBuilder::add_image_barriers(
VKRenderGraph &render_graph,
752 VkPipelineStageFlags node_stages,
753 ImageTracker &image_tracker,
755 bool within_rendering)
757 r_barrier.image_memory_barriers =
IndexRange(vk_image_memory_barriers_.size(), 0);
758 add_image_read_barriers(
759 render_graph, node_handle, node_stages, image_tracker, r_barrier, within_rendering);
760 add_image_write_barriers(
761 render_graph, node_handle, node_stages, image_tracker, r_barrier, within_rendering);
762 r_barrier.image_memory_barriers = r_barrier.image_memory_barriers.with_new_end(
763 vk_image_memory_barriers_.size());
766void VKCommandBuilder::add_image_read_barriers(
VKRenderGraph &render_graph,
768 VkPipelineStageFlags node_stages,
769 ImageTracker &image_tracker,
771 bool within_rendering)
773 for (
const VKRenderGraphImage &link : render_graph.linked_images(node_handle)) {
774 if (link.has_write_access()) {
777 const ResourceWithStamp &versioned_resource = link.resource;
778 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
779 versioned_resource.handle);
780 VKResourceBarrierState &resource_state = resource.barrier_state;
781 const bool is_first_read = resource_state.is_new_stamp();
782 if ((!is_first_read) &&
783 (resource_state.vk_access & link.vk_access_flags) == link.vk_access_flags &&
784 (resource_state.vk_pipeline_stages & node_stages) == node_stages &&
785 resource_state.image_layout == link.vk_image_layout)
790 if (within_rendering && link.vk_image_layout != VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR) {
797 if (image_tracker.contains(resource.image.vk_image)) {
798 if (resource_state.image_layout != link.vk_image_layout) {
799 image_tracker.update(resource.image.vk_image,
801 resource_state.image_layout,
802 link.vk_image_layout,
803 link.vk_image_aspect,
805 resource_state.image_layout = link.vk_image_layout;
809 VkAccessFlags wait_access = resource_state.vk_access;
810 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
811 r_barrier.dst_stage_mask |= node_stages;
813 resource_state.vk_access = link.vk_access_flags;
814 resource_state.vk_pipeline_stages = node_stages;
817 resource_state.vk_access |= link.vk_access_flags;
818 resource_state.vk_pipeline_stages |= node_stages;
820 if (wait_access != VK_ACCESS_NONE && (wait_access & ~link.vk_access_flags) != 0) {
821 add_image_barrier(resource.image.vk_image,
824 link.vk_access_flags,
825 resource_state.image_layout,
826 link.vk_image_layout,
827 link.vk_image_aspect,
833 VkAccessFlags wait_access = resource_state.vk_access;
835 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
836 r_barrier.dst_stage_mask |= node_stages;
839 resource_state.vk_access = link.vk_access_flags;
840 resource_state.vk_pipeline_stages = node_stages;
843 resource_state.vk_access |= link.vk_access_flags;
844 resource_state.vk_pipeline_stages |= node_stages;
847 if (wait_access != VK_ACCESS_NONE || link.vk_image_layout != resource_state.image_layout) {
848 add_image_barrier(resource.image.vk_image,
851 link.vk_access_flags,
852 resource_state.image_layout,
853 link.vk_image_layout,
854 link.vk_image_aspect,
856 resource_state.image_layout = link.vk_image_layout;
861void VKCommandBuilder::add_image_write_barriers(
VKRenderGraph &render_graph,
863 VkPipelineStageFlags node_stages,
864 ImageTracker &image_tracker,
866 bool within_rendering)
868 for (
const VKRenderGraphImage &link : render_graph.linked_images(node_handle)) {
869 if (!link.has_write_access()) {
872 const ResourceWithStamp &versioned_resource = link.resource;
873 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
874 versioned_resource.handle);
875 VKResourceBarrierState &resource_state = resource.barrier_state;
876 const VkAccessFlags wait_access = resource_state.vk_access;
877 if (within_rendering && link.vk_image_layout != VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR) {
884 if (image_tracker.contains(resource.image.vk_image)) {
885 if (resource_state.image_layout != link.vk_image_layout) {
886 image_tracker.update(resource.image.vk_image,
888 resource_state.image_layout,
889 link.vk_image_layout,
890 link.vk_image_aspect,
892 resource_state.image_layout = link.vk_image_layout;
896 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
897 r_barrier.dst_stage_mask |= node_stages;
898 resource_state.vk_access = link.vk_access_flags;
899 resource_state.vk_pipeline_stages = node_stages;
900 if (wait_access != VK_ACCESS_NONE && (wait_access & ~link.vk_access_flags) != 0) {
901 add_image_barrier(resource.image.vk_image,
904 link.vk_access_flags,
905 resource_state.image_layout,
906 link.vk_image_layout,
907 link.vk_image_aspect,
913 r_barrier.src_stage_mask |= resource_state.vk_pipeline_stages;
914 r_barrier.dst_stage_mask |= node_stages;
916 resource_state.vk_access = link.vk_access_flags;
917 resource_state.vk_pipeline_stages = node_stages;
919 if (wait_access != VK_ACCESS_NONE || link.vk_image_layout != resource_state.image_layout) {
920 add_image_barrier(resource.image.vk_image,
923 link.vk_access_flags,
924 resource_state.image_layout,
925 link.vk_image_layout,
926 link.vk_image_aspect,
928 resource_state.image_layout = link.vk_image_layout;
933void VKCommandBuilder::add_image_barrier(VkImage vk_image,
935 VkAccessFlags src_access_mask,
936 VkAccessFlags dst_access_mask,
937 VkImageLayout old_image_layout,
938 VkImageLayout new_image_layout,
939 VkImageAspectFlags aspect_mask,
940 const VKSubImageRange &subimage)
942 BLI_assert(aspect_mask != VK_IMAGE_ASPECT_NONE);
943 for (VkImageMemoryBarrier &vk_image_memory_barrier :
944 vk_image_memory_barriers_.as_mutable_span().drop_front(
945 r_barrier.image_memory_barriers.start()))
947 if (vk_image_memory_barrier.image == vk_image) {
951 if ((vk_image_memory_barrier.dstAccessMask & src_access_mask) == src_access_mask) {
952 vk_image_memory_barrier.dstAccessMask |= dst_access_mask;
953 vk_image_memory_barrier.srcAccessMask |= src_access_mask;
958 if (old_image_layout == vk_image_memory_barrier.newLayout) {
959 vk_image_memory_barrier.newLayout = new_image_layout;
965 if ((vk_image_memory_barrier.dstAccessMask & dst_access_mask) == dst_access_mask &&
966 (vk_image_memory_barrier.srcAccessMask & src_access_mask) == src_access_mask &&
967 old_image_layout == new_image_layout)
974 vk_image_memory_barriers_.append({VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
980 VK_QUEUE_FAMILY_IGNORED,
981 VK_QUEUE_FAMILY_IGNORED,
984 subimage.mipmap_level,
985 subimage.mipmap_count,
987 subimage.layer_count}});
996void VKCommandBuilder::ImageTracker::begin(
const VKRenderGraph &render_graph,
1000 tracked_attachments.clear();
1003 for (
const VKRenderGraphImage &link : render_graph.linked_images(node_handle)) {
1004 VKResourceStateTracker::Resource &resource = render_graph.resources_.get_image_resource(
1005 link.resource.handle);
1006 if (resource.use_subresource_tracking()) {
1007 tracked_attachments.add(resource.image.vk_image);
1012void VKCommandBuilder::ImageTracker::update(VkImage vk_image,
1013 const VKSubImageRange &subimage,
1014 VkImageLayout old_layout,
1015 VkImageLayout new_layout,
1016 VkImageAspectFlags aspect,
1019 for (
const SubImageChange &change : changes) {
1020 if (change.vk_image == vk_image && ((subimage.layer_count != VK_REMAINING_ARRAY_LAYERS &&
1021 change.subimage.layer_base == subimage.layer_base) ||
1022 (subimage.mipmap_count != VK_REMAINING_MIP_LEVELS &&
1023 change.subimage.mipmap_level == subimage.mipmap_level)))
1026 change.vk_image_layout == new_layout,
1027 "We don't support more that one change of the same subimage multiple times during a "
1028 "rendering scope.");
1035 changes.append({vk_image, new_layout, aspect, subimage});
1038 r_barrier.src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1039 r_barrier.dst_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1040 VkAccessFlags dst_access_mask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
1041 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
1042 if (aspect & VK_IMAGE_ASPECT_COLOR_BIT) {
1043 dst_access_mask |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
1045 if (aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
1046 dst_access_mask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
1047 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
1055 command_builder.add_image_barrier(vk_image,
1057 VK_ACCESS_TRANSFER_WRITE_BIT,
1065void VKCommandBuilder::ImageTracker::end(Barrier &r_barrier,
bool use_local_read)
1067 suspend(r_barrier, use_local_read);
1068 tracked_attachments.clear();
1072void VKCommandBuilder::ImageTracker::suspend(Barrier &r_barrier,
bool use_local_read)
1075 if (changes.is_empty()) {
1079 command_builder.reset_barriers(r_barrier);
1081 r_barrier.src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1082 r_barrier.dst_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1083 int64_t start_index = command_builder.vk_image_memory_barriers_.size();
1085 for (
const SubImageChange &change : changes) {
1086 command_builder.add_image_barrier(
1089 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
1090 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1091 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
1092 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
1093 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1094 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
1095 change.vk_image_layout,
1097 change.vk_image_aspect,
1099 r_barrier.image_memory_barriers = r_barrier.image_memory_barriers.with_new_end(
1100 command_builder.vk_image_memory_barriers_.size());
1103 std::cout << __func__ <<
": transition layout image=" << change.vk_image
1104 <<
", layer=" << change.subimage.layer_base
1105 <<
", count=" << change.subimage.layer_count
1106 <<
", from_layout=" <<
to_string(change.vk_image_layout)
1114void VKCommandBuilder::ImageTracker::resume(Barrier &r_barrier,
bool use_local_read)
1116 if (changes.is_empty()) {
1120 command_builder.reset_barriers(r_barrier);
1122 r_barrier.src_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1123 r_barrier.dst_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1124 int64_t start_index = command_builder.vk_image_memory_barriers_.size();
1127 for (
const SubImageChange &change : changes) {
1128 command_builder.add_image_barrier(
1131 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
1132 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1133 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
1134 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
1135 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
1136 VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
1138 change.vk_image_layout,
1139 change.vk_image_aspect,
1142 std::cout << __func__ <<
": transition layout image=" << change.vk_image
1143 <<
", layer=" << change.subimage.layer_base
1144 <<
", count=" << change.subimage.layer_count
1147 <<
", to_layout=" <<
to_string(change.vk_image_layout) <<
"\n";
1157std::string VKCommandBuilder::to_string_barrier(
const Barrier &
barrier)
1159 std::stringstream ss;
1162 for (
const VkBufferMemoryBarrier &buffer_memory_barrier :
1163 vk_buffer_memory_barriers_.as_span().slice(
barrier.buffer_memory_barriers))
1167 <<
", vk_buffer=" <<
to_string(buffer_memory_barrier.buffer) <<
"\n";
1170 for (
const VkImageMemoryBarrier &image_memory_barrier :
1171 vk_image_memory_barriers_.as_span().slice(
barrier.image_memory_barriers))
1175 <<
", vk_image=" <<
to_string(image_memory_barrier.image)
1176 <<
", old_layout=" <<
to_string(image_memory_barrier.oldLayout)
1177 <<
", new_layout=" <<
to_string(image_memory_barrier.newLayout)
1178 <<
", subresource_range=" <<
to_string(image_memory_barrier.subresourceRange, 2) <<
"\n";
#define BLI_assert_msg(a, msg)
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T * data() const
constexpr const T & first() const
constexpr int64_t size() const
constexpr const T & last(const int64_t n=0) const
constexpr const T * end() const
constexpr const T * begin() const
constexpr int64_t first() const
constexpr int64_t size() const
constexpr bool is_empty() const
static constexpr IndexRange from_begin_end(const int64_t begin, const int64_t end)
constexpr IndexRange()=default
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
constexpr IndexRange slice(int64_t start, int64_t size) const
constexpr IndexRange index_range() const
static void reconfigure_for_restart(VKBeginRenderingData &begin_rendering_data)
bool use_dynamic_rendering_local_read
void record_commands(VKRenderGraph &render_graph, VKCommandBufferInterface &command_buffer, Span< NodeHandle > node_handles)
void build_nodes(VKRenderGraph &render_graph, VKCommandBufferInterface &command_buffer, Span< NodeHandle > node_handles)
BLI_INLINE bool node_type_is_rendering(VKNodeType node_type)
BLI_INLINE bool node_type_is_within_rendering(VKNodeType node_type)
static VkImageLayout to_default_image_layout(VkImageAspectFlags aspect, bool use_local_read)
const char * to_string(ShaderStage stage)
std::string to_string_vk_pipeline_stage_flags(const VkPipelineStageFlags vk_pipeline_stage_flags)
std::string to_string_vk_access_flags(const VkAccessFlags vk_access_flags)
MINLINE int max_ii(int a, int b)
MINLINE void copy_v4_v4(float r[4], const float a[4])
MINLINE int min_ii(int a, int b)