Blender V5.3
vk_descriptor_set.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "vk_buffer.hh"
11#include "vk_index_buffer.hh"
12#include "vk_ray_tracing.hh"
13#include "vk_shader.hh"
15#include "vk_state_manager.hh"
16#include "vk_storage_buffer.hh"
17#include "vk_texture.hh"
18#include "vk_vertex_buffer.hh"
19
20#include "CLG_log.h"
21
22namespace blender::gpu {
23
24static CLG_LogRef LOG = {"gpu.vulkan"};
25
28 render_graph::VKPipelineData &r_pipeline_data)
29{
30 VKShader &shader = *unwrap(context.shader);
31 VKStateManager &state_manager = context.state_manager_get();
32
33 /* Need to know the exact buffer and offset when shader uses an uniform buffer to store push
34 * constants. */
35 VKBufferWithOffset push_constants_buffer = {};
36 /* Bind uniform push constants to descriptor set. */
37 if (shader.push_constants.layout_get().storage_type_get() ==
39 {
40 push_constants_buffer = shader.push_constants.update_uniform_buffer(context);
41 }
42
43 update_resource_access_info(context, access_info, push_constants_buffer);
44
45 /* Can we reuse previous descriptor set. */
46 const VkDescriptorSetLayout shader_descriptor_set_layout = shader.vk_descriptor_set_layout_get();
47 if (!state_manager.is_dirty && vk_descriptor_set_layout_ == shader_descriptor_set_layout &&
48 shader.push_constants.layout_get().storage_type_get() !=
50 {
52 return;
53 }
54 vk_descriptor_set_layout_ = shader_descriptor_set_layout;
55 state_manager.is_dirty = false;
56
57 VKDevice &device = VKBackend::get().device;
58 VkDescriptorSetLayout vk_descriptor_set_layout = shader.vk_descriptor_set_layout_get();
60 device, context, shader, vk_descriptor_set_layout, r_pipeline_data);
61 descriptor_sets.bind_shader_resources(device, state_manager, shader, push_constants_buffer);
62}
63
64/* -------------------------------------------------------------------- */
67
68void VKDescriptorSetTracker::update_resource_access_info_binding_uniform_buffer(
69 const VKStateManager &state_manager,
70 const VKResourceBinding &resource_binding,
72{
73 VKUniformBuffer &uniform_buffer = *state_manager.uniform_buffers_.get(resource_binding.binding);
74 uniform_buffer.ensure_updated();
75 access_info.buffers.append({uniform_buffer.resource(), resource_binding.access_mask});
76}
77
78void VKDescriptorSetTracker::update_resource_access_info_binding_storage_buffer(
79 const VKStateManager &state_manager,
80 const VKResourceBinding &resource_binding,
81 render_graph::VKResourceAccessInfo &access_info)
82{
83 const BindSpaceStorageBuffers::Elem &elem = state_manager.storage_buffers_.get(
84 resource_binding.binding);
85 VKResourceWithHandle<VkBuffer> resource = {0};
86 switch (elem.resource_type) {
88 VKIndexBuffer *index_buffer = static_cast<VKIndexBuffer *>(elem.resource);
89 index_buffer->ensure_updated();
90 resource = index_buffer->resource();
91 break;
92 }
94 VKVertexBuffer *vertex_buffer = static_cast<VKVertexBuffer *>(elem.resource);
95 vertex_buffer->ensure_updated();
96 resource = vertex_buffer->resource();
97 break;
98 }
100 VKUniformBuffer *uniform_buffer = static_cast<VKUniformBuffer *>(elem.resource);
101 uniform_buffer->ensure_updated();
102 resource = uniform_buffer->resource();
103 break;
104 }
106 VKStorageBuffer *storage_buffer = static_cast<VKStorageBuffer *>(elem.resource);
107 storage_buffer->ensure_allocated();
108 resource = storage_buffer->resource();
109 break;
110 }
112 VKBuffer *buffer = static_cast<VKBuffer *>(elem.resource);
113 resource = buffer->resource();
114 break;
115 }
118 }
119 }
120 if (resource.vk_handle != VK_NULL_HANDLE) {
121 access_info.buffers.append({resource.resource_handle, resource_binding.access_mask});
122 }
123}
124
125void VKDescriptorSetTracker::update_resource_access_info_binding_sampler(
126 const VKStateManager &state_manager,
127 const VKResourceBinding &resource_binding,
129{
130 const BindSpaceTextures::Elem *elem_ptr = state_manager.textures_.get(resource_binding.binding);
131 if (!elem_ptr || elem_ptr->resource == nullptr) {
132 /* Unbound resource. */
133 if (bool(G.debug & G_DEBUG_GPU)) {
134 VKContext &context = *VKContext::get();
135 const VKShader &shader = *static_cast<const VKShader *>(context.shader);
136 const VKShaderInterface &interface = shader.interface_get();
137 const ShaderInput &shader_input = *interface.texture_get(resource_binding.binding);
139 "Missing Texture bind at slot %d : %s > %s",
140 shader_input.binding,
141 shader.name_get().c_str(),
142 interface.input_name_get(&shader_input));
143 }
144 return;
145 }
146 const BindSpaceTextures::Elem &elem = *elem_ptr;
147 switch (elem.resource_type) {
149 VKVertexBuffer &vertex_buffer = *static_cast<VKVertexBuffer *>(elem.resource);
150 vertex_buffer.ensure_updated();
151 access_info.buffers.append({vertex_buffer.resource(), resource_binding.access_mask});
152 break;
153 }
155 VKTexture *texture = static_cast<VKTexture *>(elem.resource);
156 if (texture->type_ == GPU_TEXTURE_BUFFER) {
157 VKVertexBuffer &vertex_buffer = *texture->source_buffer_;
158 vertex_buffer.ensure_updated();
159 access_info.buffers.append({vertex_buffer.resource(), resource_binding.access_mask});
160 }
161 else {
162 VKSubImageRange subimage = {};
163 if (texture->is_texture_view()) {
164 IndexRange layer_range = texture->layer_range();
165 IndexRange mipmap_range = texture->mip_map_range();
166 subimage = {uint32_t(mipmap_range.start()),
167 uint32_t(mipmap_range.size()),
168 uint32_t(layer_range.start()),
169 uint32_t(layer_range.size())};
170 }
171 access_info.images.append({texture->vk_image_handle(),
172 resource_binding.access_mask,
173 to_vk_image_aspect_flag_bits(texture->device_format_get()),
174 subimage});
175 }
176 break;
177 }
180 }
181 }
182}
183
184void VKDescriptorSetTracker::update_resource_access_info_binding_image(
185 const VKStateManager &state_manager,
186 const VKResourceBinding &resource_binding,
188{
189 VKTexture &texture = *state_manager.images_.get(resource_binding.binding);
190 VKSubImageRange subimage = {};
191 if (texture.is_texture_view()) {
192 IndexRange layer_range = texture.layer_range();
193 IndexRange mipmap_range = texture.mip_map_range();
194 subimage = {uint32_t(mipmap_range.start()),
195 uint32_t(mipmap_range.size()),
196 uint32_t(layer_range.start()),
197 uint32_t(layer_range.size())};
198 }
199 access_info.images.append({texture.vk_image_handle(),
200 resource_binding.access_mask,
201 to_vk_image_aspect_flag_bits(texture.device_format_get()),
202 subimage});
203}
204
205void VKDescriptorSetTracker::update_resource_access_info_binding_acceleration_structure(
206 const VKStateManager &state_manager,
207 const VKResourceBinding &resource_binding,
209{
210 const VKTopLevelAS *tlas = state_manager.acceleration_structures_.get(resource_binding.binding);
211 if (tlas != nullptr) {
212 access_info.buffers.append({tlas->vk_buffer(), resource_binding.access_mask});
213 }
214}
215
216void VKDescriptorSetTracker::update_resource_access_info_binding_input_attachment(
217 const VKStateManager &state_manager,
218 const VKResourceBinding &resource_binding,
220{
221 const VKDevice &device = VKBackend::get().device;
222 VKTexture *texture = nullptr;
223 if (device.extensions_get().dynamic_rendering_local_read) {
224 texture = state_manager.images_.get(resource_binding.binding);
225 }
226 else {
227 texture = static_cast<VKTexture *>(
228 state_manager.textures_.get(resource_binding.binding)->resource);
229 }
230
232 VkImage vk_image = texture->vk_image_handle();
233 if (vk_image != VK_NULL_HANDLE) {
234 VKSubImageRange subimage = {};
235 if (texture->is_texture_view()) {
236 IndexRange layer_range = texture->layer_range();
237 IndexRange mipmap_range = texture->mip_map_range();
238 subimage = {uint32_t(mipmap_range.start()),
239 uint32_t(mipmap_range.size()),
240 uint32_t(layer_range.start()),
241 uint32_t(layer_range.size())};
242 }
243
244 access_info.images.append({texture->vk_image_handle(),
245 resource_binding.access_mask,
246 to_vk_image_aspect_flag_bits(texture->device_format_get()),
247 subimage});
248 }
249}
250
251void VKDescriptorSetTracker::update_resource_access_info_binding(
252 const VKStateManager &state_manager,
253 const VKResourceBinding &resource_binding,
255{
256 switch (resource_binding.bind_type) {
258 update_resource_access_info_binding_uniform_buffer(
259 state_manager, resource_binding, access_info);
260 break;
261 }
262
264 update_resource_access_info_binding_storage_buffer(
265 state_manager, resource_binding, access_info);
266 break;
267 }
268
269 case VKBindType::SAMPLER: {
270 update_resource_access_info_binding_sampler(state_manager, resource_binding, access_info);
271 break;
272 }
273
274 case VKBindType::IMAGE: {
275 update_resource_access_info_binding_image(state_manager, resource_binding, access_info);
276 break;
277 }
278
280 update_resource_access_info_binding_acceleration_structure(
281 state_manager, resource_binding, access_info);
282 break;
283 }
284
286 update_resource_access_info_binding_input_attachment(
287 state_manager, resource_binding, access_info);
288 break;
289 }
290 }
291}
292
293void VKDescriptorSetTracker::update_resource_access_info(
294 VKContext &context,
296 const VKBufferWithOffset &push_constants_buffer)
297{
298 VKShader &shader = *unwrap(context.shader);
299 VKStateManager &state_manager = context.state_manager_get();
300 const VKShaderInterface &shader_interface = shader.interface_get();
301
302 for (const VKResourceBinding &resource_binding : shader_interface.resource_bindings_get()) {
303 if (resource_binding.binding == -1) {
304 continue;
305 }
306 update_resource_access_info_binding(state_manager, resource_binding, access_info);
307 }
308
309 /* Bind uniform push constants to descriptor set. */
310 if (shader.push_constants.layout_get().storage_type_get() ==
312 push_constants_buffer.buffer != VK_NULL_HANDLE)
313 {
314 access_info.buffers.append({push_constants_buffer.buffer, VK_ACCESS_UNIFORM_READ_BIT});
315 }
316}
317
319
321{
323 vk_descriptor_set_layout_ = VK_NULL_HANDLE;
324}
325
326/* -------------------------------------------------------------------- */
329
330void VKDescriptorSetUpdator::bind_image_resource(const VKStateManager &state_manager,
331 const VKResourceBinding &resource_binding)
332{
333 VKTexture &texture = *state_manager.images_.get(resource_binding.binding);
334 const VKImageView &view = texture.image_view_get(resource_binding.arrayed,
337 bind_image(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
338 VK_NULL_HANDLE,
339 view.vk_handle(),
340 VK_IMAGE_LAYOUT_GENERAL,
341 resource_binding.location);
342}
343
344void VKDescriptorSetUpdator::bind_texture_resource(const VKDevice &device,
345 const VKStateManager &state_manager,
346 const VKResourceBinding &resource_binding)
347{
348 const BindSpaceTextures::Elem *elem_ptr = state_manager.textures_.get(resource_binding.binding);
349 if (!elem_ptr || elem_ptr->resource == nullptr) {
350 /* Unbound resource. */
351 return;
352 }
353 const BindSpaceTextures::Elem &elem = *elem_ptr;
354 switch (elem.resource_type) {
356 VKVertexBuffer &vertex_buffer = *static_cast<VKVertexBuffer *>(elem.resource);
357 bind_texel_buffer(vertex_buffer, resource_binding.location);
358 break;
359 }
361 VKTexture *texture = static_cast<VKTexture *>(elem.resource);
362 if (texture->type_ == GPU_TEXTURE_BUFFER) {
363 /* Texture buffers are no textures, but wrap around vertex buffers and need to be
364 * bound as texel buffers. */
365 /* TODO: Investigate if this can be improved in the API. */
366 VKVertexBuffer &vertex_buffer = *texture->source_buffer_;
367 bind_texel_buffer(vertex_buffer, resource_binding.location);
368 }
369 else {
370 const VKSampler &sampler = device.samplers().get(elem.sampler);
371 bind_image(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
372 sampler.vk_handle(),
373 texture->image_view_get(resource_binding.arrayed, VKImageViewFlags::DEFAULT)
374 .vk_handle(),
375 VK_IMAGE_LAYOUT_GENERAL,
376 resource_binding.location);
377 }
378 break;
379 }
382 }
383 }
384}
385
386void VKDescriptorSetUpdator::bind_input_attachment_resource(
387 const VKDevice &device,
388 const VKStateManager &state_manager,
389 const VKResourceBinding &resource_binding)
390{
391 const bool supports_local_read = device.extensions_get().dynamic_rendering_local_read;
392 if (supports_local_read) {
393 VKTexture *texture = state_manager.images_.get(resource_binding.binding);
395 bind_image(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
396 VK_NULL_HANDLE,
397 texture->image_view_get(resource_binding.arrayed, VKImageViewFlags::NO_SWIZZLING)
398 .vk_handle(),
399 VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR,
400 resource_binding.location);
401 }
402 else {
403 const BindSpaceTextures::Elem *elem_ptr = state_manager.textures_.get(
404 resource_binding.binding);
405 if (!elem_ptr) {
406 /* Unbound resource. */
408 return;
409 }
410 const BindSpaceTextures::Elem &elem = *elem_ptr;
411 VKTexture *texture = static_cast<VKTexture *>(elem.resource);
413 BLI_assert(elem.resource_type == BindSpaceTextures::Type::Texture);
414 const VKSampler &sampler = device.samplers().get(elem.sampler);
416 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
417 sampler.vk_handle(),
418 texture->image_view_get(resource_binding.arrayed, VKImageViewFlags::DEFAULT).vk_handle(),
419 VK_IMAGE_LAYOUT_GENERAL,
420 resource_binding.location);
421 }
422}
423
424void VKDescriptorSetUpdator::bind_storage_buffer_resource(
425 const VKStateManager &state_manager, const VKResourceBinding &resource_binding)
426{
427 const BindSpaceStorageBuffers::Elem &elem = state_manager.storage_buffers_.get(
428 resource_binding.binding);
429 VkBuffer vk_buffer = VK_NULL_HANDLE;
430 VkDeviceSize vk_device_size = 0;
431 switch (elem.resource_type) {
433 VKIndexBuffer *index_buffer = static_cast<VKIndexBuffer *>(elem.resource);
434 vk_buffer = index_buffer->vk_handle();
435 /* Using the allocated size of the buffer as conservative depth shader can read additional
436 * bytes when there are an uneven number of indices. */
437 vk_device_size = index_buffer->allocated_size_get() - elem.offset;
438 break;
439 }
441 VKVertexBuffer *vertex_buffer = static_cast<VKVertexBuffer *>(elem.resource);
442 vk_buffer = vertex_buffer->vk_handle();
443 vk_device_size = vertex_buffer->size_used_get() - elem.offset;
444 break;
445 }
447 VKUniformBuffer *uniform_buffer = static_cast<VKUniformBuffer *>(elem.resource);
448 vk_buffer = uniform_buffer->vk_handle();
449 vk_device_size = uniform_buffer->size_in_bytes() - elem.offset;
450 break;
451 }
453 VKStorageBuffer *storage_buffer = static_cast<VKStorageBuffer *>(elem.resource);
454 vk_buffer = storage_buffer->vk_handle();
455 vk_device_size = storage_buffer->usage_size_get();
456 break;
457 }
459 VKBuffer *buffer = static_cast<VKBuffer *>(elem.resource);
460 vk_buffer = buffer->vk_handle();
461 vk_device_size = buffer->size_in_bytes() - elem.offset;
462 break;
463 }
466 }
467 }
468
469 bind_buffer(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
470 vk_buffer,
471 elem.offset,
472 vk_device_size,
473 resource_binding.location);
474}
475
476void VKDescriptorSetUpdator::bind_acceleration_structure_resource(
477 const VKStateManager &state_manager, const VKResourceBinding &resource_binding)
478{
479 const VKTopLevelAS *tlas = state_manager.acceleration_structures_.get(resource_binding.binding);
480 bind_acceleration_structure(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
481 tlas != nullptr ? tlas->vk_acceleration_structure() : VK_NULL_HANDLE,
482 resource_binding.location);
483}
484
485void VKDescriptorSetUpdator::bind_uniform_buffer_resource(
486 const VKStateManager &state_manager, const VKResourceBinding &resource_binding)
487{
488 VKUniformBuffer &uniform_buffer = *state_manager.uniform_buffers_.get(resource_binding.binding);
489 bind_buffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
490 uniform_buffer.vk_handle(),
491 0,
492 uniform_buffer.size_in_bytes(),
493 resource_binding.location);
494}
495
496void VKDescriptorSetUpdator::bind_push_constants(VKPushConstants &push_constants,
497 const VKBufferWithOffset &push_constants_buffer)
498{
499 const VKPushConstants::Layout &push_constants_layout = push_constants.layout_get();
500 if (push_constants_layout.storage_type_get() != VKPushConstants::StorageType::BUFFER) {
501 return;
502 }
503 bind_buffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
504 push_constants_buffer.buffer,
505 push_constants_buffer.offset,
506 push_constants_layout.size_in_bytes(),
507 push_constants_layout.descriptor_set_location_get());
508}
509
511 const VKStateManager &state_manager,
513 const VKBufferWithOffset &push_constants_buffer)
514{
515 const VKShaderInterface &shader_interface = shader.interface_get();
516 for (const VKResourceBinding &resource_binding : shader_interface.resource_bindings_get()) {
517 if (resource_binding.binding == -1) {
518 continue;
519 }
520
521 switch (resource_binding.bind_type) {
523 bind_uniform_buffer_resource(state_manager, resource_binding);
524 break;
525
527 bind_storage_buffer_resource(state_manager, resource_binding);
528 break;
529
531 bind_texture_resource(device, state_manager, resource_binding);
532 break;
533
535 bind_image_resource(state_manager, resource_binding);
536 break;
537
539 bind_acceleration_structure_resource(state_manager, resource_binding);
540 break;
541
543 bind_input_attachment_resource(device, state_manager, resource_binding);
544 break;
545 }
546 }
547
548 /* Bind uniform push constants to descriptor set. */
549 bind_push_constants(shader.push_constants, push_constants_buffer);
550}
551
553
554/* -------------------------------------------------------------------- */
557
559 VKDevice & /*device*/,
560 VKContext &context,
562 VkDescriptorSetLayout vk_descriptor_set_layout,
563 render_graph::VKPipelineData &r_pipeline_data)
564{
565 /* Use descriptor pools/sets. */
566 vk_descriptor_set = context.descriptor_pools_get().allocate(vk_descriptor_set_layout);
567 BLI_assert(vk_descriptor_set != VK_NULL_HANDLE);
569 r_pipeline_data.vk_descriptor_set = vk_descriptor_set;
570}
571
572void VKDescriptorSetPoolUpdator::bind_buffer(VkDescriptorType vk_descriptor_type,
573 VkBuffer vk_buffer,
574 VkDeviceSize buffer_offset,
575 VkDeviceSize size_in_bytes,
577{
578 if (vk_buffer == VK_NULL_HANDLE) {
579 vk_descriptor_buffer_infos_.append({VK_NULL_HANDLE, 0, VK_WHOLE_SIZE});
580 }
581 else {
582 vk_descriptor_buffer_infos_.append({vk_buffer, buffer_offset, size_in_bytes});
583 }
584 vk_write_descriptor_sets_.append({VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
585 nullptr,
587 location,
588 0,
589 1,
590 vk_descriptor_type,
591 nullptr,
592 nullptr,
593 nullptr});
594}
595
597 const VKDescriptorSet::Location location)
598{
599 vertex_buffer.ensure_buffer_view();
600 vk_buffer_views_.append(vertex_buffer.vk_buffer_view_get());
601 vk_write_descriptor_sets_.append({VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
602 nullptr,
604 location,
605 0,
606 1,
607 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
608 nullptr,
609 nullptr,
610 nullptr});
611}
612
613void VKDescriptorSetPoolUpdator::bind_image(VkDescriptorType vk_descriptor_type,
614 VkSampler vk_sampler,
615 VkImageView vk_image_view,
616 VkImageLayout vk_image_layout,
618{
619 vk_descriptor_image_infos_.append({vk_sampler, vk_image_view, vk_image_layout});
620 vk_write_descriptor_sets_.append({VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
621 nullptr,
623 location,
624 0,
625 1,
626 vk_descriptor_type,
627 nullptr,
628 nullptr,
629 nullptr});
630}
632 VkDescriptorType vk_descriptor_type,
633 VkAccelerationStructureKHR vk_acceleration_structure,
635{
636 /* NOTE: These structures will be bound during upload_descriptor_sets, to ensure they have
637 * correct device addresses. */
638 vk_write_descriptor_sets_.append({VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
639 nullptr,
641 location,
642 0,
643 1,
644 vk_descriptor_type,
645 nullptr,
646 nullptr,
647 nullptr});
648 vk_write_descriptor_sets_acceleration_structures_.append(
649 {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, nullptr, 1, nullptr});
650 vk_acceleration_structures_.append(vk_acceleration_structure);
651}
652
654{
655 if (vk_write_descriptor_sets_.is_empty()) {
656 return;
657 }
658
659 /* Finalize pointers that could have changed due to reallocations. */
660 int buffer_index = 0;
661 int buffer_view_index = 0;
662 int image_index = 0;
663 int acceleration_structure_index = 0;
664 for (VkWriteDescriptorSet &vk_write_descriptor_set : vk_write_descriptor_sets_) {
665 switch (vk_write_descriptor_set.descriptorType) {
666 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
667 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
668 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
669 vk_write_descriptor_set.pImageInfo = &vk_descriptor_image_infos_[image_index++];
670 break;
671
672 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
673 vk_write_descriptor_set.pTexelBufferView = &vk_buffer_views_[buffer_view_index++];
674 break;
675
676 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
677 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
678 vk_write_descriptor_set.pBufferInfo = &vk_descriptor_buffer_infos_[buffer_index++];
679 break;
680
681 case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
682 vk_write_descriptor_sets_acceleration_structures_[acceleration_structure_index]
683 .pAccelerationStructures = &vk_acceleration_structures_[acceleration_structure_index];
684 vk_write_descriptor_set.pNext =
685 &vk_write_descriptor_sets_acceleration_structures_[acceleration_structure_index++];
686 break;
687
688 default:
690 break;
691 }
692 }
693
694#if 0
695 /* Uncomment this for rebalancing VKDescriptorPools::POOL_SIZE_* */
696 {
697 int storage_buffer_count = 0;
698 int storage_image_count = 0;
699 int combined_image_sampler_count = 0;
700 int uniform_buffer_count = 0;
701 int uniform_texel_buffer_count = 0;
702 int input_attachment_count = 0;
703 Set<VkDescriptorSet> descriptor_set_count;
704
705 for (VkWriteDescriptorSet &vk_write_descriptor_set : vk_write_descriptor_sets_) {
706 descriptor_set_count.add(vk_write_descriptor_set.dstSet);
707 switch (vk_write_descriptor_set.descriptorType) {
708 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
709 combined_image_sampler_count += 1;
710 break;
711 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
712 storage_image_count += 1;
713 break;
714 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
715 uniform_texel_buffer_count += 1;
716 break;
717 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
718 uniform_buffer_count += 1;
719 break;
720 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
721 storage_buffer_count += 1;
722 break;
723 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
724 input_attachment_count += 1;
725 break;
726 default:
728 }
729 }
730 std::cout << __func__ << ": "
731 << "descriptor_set=" << descriptor_set_count.size()
732 << ", combined_image_sampler=" << combined_image_sampler_count
733 << ", storage_image=" << storage_image_count
734 << ", uniform_texel_buffer=" << uniform_texel_buffer_count
735 << ", uniform_buffer=" << uniform_buffer_count
736 << ", storage_buffer=" << storage_buffer_count
737 << ", input_attachment=" << input_attachment_count << "\n";
738 }
739#endif
740
741 /* Update the descriptor set on the device. */
742 const VKDevice &device = VKBackend::get().device;
743 device.functions.vkUpdateDescriptorSets(device.vk_handle(),
744 vk_write_descriptor_sets_.size(),
745 vk_write_descriptor_sets_.data(),
746 0,
747 nullptr);
748
749 vk_descriptor_image_infos_.clear();
750 vk_descriptor_buffer_infos_.clear();
751 vk_buffer_views_.clear();
752 vk_acceleration_structures_.clear();
753 vk_write_descriptor_sets_acceleration_structures_.clear();
754 vk_write_descriptor_sets_.clear();
755}
756
758
759} // namespace blender::gpu
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define BLI_assert_unreachable()
#define BLI_assert(a)
int64_t size() const
Definition BLI_set.hh:606
bool add(const Key &key)
Definition BLI_set.hh:248
VKTexture * get(int binding) const
const Elem * get(int binding) const
VKUniformBuffer * get(int binding) const
static VKBackend & get()
static VKContext * get()
void bind_buffer(VkDescriptorType vk_descriptor_type, VkBuffer vk_buffer, VkDeviceSize buffer_offset, VkDeviceSize size_in_bytes, VKDescriptorSet::Location location) override
void allocate_new_descriptor_set(VKDevice &device, VKContext &context, VKShader &shader, VkDescriptorSetLayout vk_descriptor_set_layout, render_graph::VKPipelineData &r_pipeline_data) override
void bind_image(VkDescriptorType vk_descriptor_type, VkSampler vk_sampler, VkImageView vk_image_view, VkImageLayout vk_image_layout, VKDescriptorSet::Location location) override
void bind_texel_buffer(VKVertexBuffer &vertex_buffer, VKDescriptorSet::Location location) override
void bind_acceleration_structure(VkDescriptorType vk_descriptor_type, VkAccelerationStructureKHR vk_acceleration_structure, VKDescriptorSet::Location location) override
class VKDescriptorSetPoolUpdator descriptor_sets
void update_descriptor_set(VKContext &context, render_graph::VKResourceAccessInfo &resource_access_info, render_graph::VKPipelineData &r_pipeline_data)
virtual void bind_texel_buffer(VKVertexBuffer &vertex_buffer, VKDescriptorSet::Location location)=0
virtual void bind_buffer(VkDescriptorType vk_descriptor_type, VkBuffer vk_buffer, VkDeviceSize buffer_offset, VkDeviceSize size_in_bytes, VKDescriptorSet::Location location)=0
virtual void bind_acceleration_structure(VkDescriptorType vk_descriptor_type, VkAccelerationStructureKHR vk_acceleration_structure, VKDescriptorSet::Location location)=0
virtual void bind_image(VkDescriptorType vk_descriptor_type, VkSampler vk_sampler, VkImageView vk_image_view, VkImageLayout vk_image_layout, VKDescriptorSet::Location location)=0
void bind_shader_resources(const VKDevice &device, const VKStateManager &state_manager, VKShader &shader, const VKBufferWithOffset &push_constants_buffer)
VkDevice vk_handle() const
Definition vk_device.hh:338
const VKSamplers & samplers() const
Definition vk_device.hh:368
VolkDeviceTable functions
Definition vk_device.hh:280
VkImageView vk_handle() const
const VKSampler & get(const GPUSamplerState &sampler_state) const
const Span< VKResourceBinding > resource_bindings_get() const
const VKResourceWithHandle< VkBuffer > & resource() const
VkBufferView vk_buffer_view_get() const
#define sampler(slot)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
int context(const bContext *C, const char *member, bContextDataResult *result)
void object_label(GLenum type, GLuint object, const char *name)
Definition gl_debug.cc:331
static CLG_LogRef LOG
BLI_INLINE MTLTexture * unwrap(Texture *tex)
VkImageAspectFlags to_vk_image_aspect_flag_bits(const TextureFormat format)
Definition vk_common.cc:16
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
Global G
Definition blender.cc:57
unsigned int uint32_t
Definition BKE_text.h:81
VKDescriptorSet::Location location