MayaFlux 0.3.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
BackendResoureManager.cpp
Go to the documentation of this file.
1#include "BackendResoureManager.hpp"
2
3#include "MayaFlux/Core/Backends/Graphics/Vulkan/VKCommandManager.hpp"
4#include "MayaFlux/Core/Backends/Graphics/Vulkan/VKContext.hpp"
5#include "MayaFlux/Core/Backends/Graphics/Vulkan/VKImage.hpp"
6
7#include "MayaFlux/Buffers/VKBuffer.hpp"
8#include "MayaFlux/Journal/Archivist.hpp"
9#include "MayaFlux/Registry/Service/BufferService.hpp"
10
11namespace MayaFlux::Core {
12
13BackendResourceManager::BackendResourceManager(VKContext& context, VKCommandManager& command_manager)
14 : m_context(context)
15 , m_command_manager(command_manager)
16{
17}
18
19void BackendResourceManager::setup_backend_service(const std::shared_ptr<Registry::Service::BufferService>& buffer_service)
20{
21 buffer_service->initialize_buffer = [this](const std::shared_ptr<void>& vk_buf) -> void {
22 auto buffer = std::static_pointer_cast<Buffers::VKBuffer>(vk_buf);
23 this->initialize_buffer(buffer);
24 };
25
26 buffer_service->destroy_buffer = [this](const std::shared_ptr<void>& vk_buf) {
27 auto buffer = std::static_pointer_cast<Buffers::VKBuffer>(vk_buf);
28 this->cleanup_buffer(buffer);
29 };
30
31 buffer_service->execute_immediate = [this](const std::function<void(void*)>& recorder) {
32 this->execute_immediate_commands([recorder](vk::CommandBuffer cmd) {
33 recorder(static_cast<void*>(cmd));
34 });
35 };
36
37 buffer_service->record_deferred = [this](const std::function<void(void*)>& recorder) {
38 this->record_deferred_commands([recorder](vk::CommandBuffer cmd) {
39 recorder(static_cast<void*>(cmd));
40 });
41 };
42
43 buffer_service->flush_range = [this](void* memory, size_t offset, size_t size) {
44 vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
45 vk::MappedMemoryRange range { mem, offset, size == 0 ? VK_WHOLE_SIZE : size };
46 if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
47 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
48 "Failed to flush mapped memory range: {}", vk::to_string(result));
49 }
50 };
51
52 buffer_service->invalidate_range = [this](void* memory, size_t offset, size_t size) {
53 vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
54 vk::MappedMemoryRange range { mem, offset, size == 0 ? VK_WHOLE_SIZE : size };
55 if (auto result = m_context.get_device().invalidateMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
56 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
57 "Failed to invalidate mapped memory range: {}", vk::to_string(result));
58 }
59 };
60
61 buffer_service->map_buffer = [this](void* memory, size_t offset, size_t size) -> void* {
62 vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
63 return m_context.get_device().mapMemory(mem, offset, size == 0 ? VK_WHOLE_SIZE : size);
64 };
65
66 buffer_service->unmap_buffer = [this](void* memory) {
67 vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
68 m_context.get_device().unmapMemory(mem);
69 };
70}
71
72void BackendResourceManager::initialize_buffer(const std::shared_ptr<Buffers::VKBuffer>& buffer)
73{
74 if (!buffer) {
75 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
76 "Attempted to initialize null VulkanBuffer");
77 return;
78 }
79
80 if (buffer->is_initialized()) {
81 MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
82 "VulkanBuffer already initialized, skipping");
83 return;
84 }
85
86 vk::BufferCreateInfo buffer_info {};
87 buffer_info.size = buffer->get_size_bytes();
88 buffer_info.usage = buffer->get_usage_flags();
89 buffer_info.sharingMode = vk::SharingMode::eExclusive;
90
91 vk::Buffer vk_buffer;
92 try {
93 vk_buffer = m_context.get_device().createBuffer(buffer_info);
94 } catch (const vk::SystemError& e) {
95 error_rethrow(
96 Journal::Component::Core,
97 Journal::Context::GraphicsBackend,
98 std::source_location::current(),
99 "Failed to create VkBuffer: " + std::string(e.what()));
100 }
101
102 vk::MemoryRequirements mem_requirements;
103 mem_requirements = m_context.get_device().getBufferMemoryRequirements(vk_buffer);
104
105 vk::MemoryAllocateInfo alloc_info;
106 alloc_info.allocationSize = mem_requirements.size;
107
108 alloc_info.memoryTypeIndex = find_memory_type(
109 mem_requirements.memoryTypeBits,
110 vk::MemoryPropertyFlags(buffer->get_memory_properties()));
111
112 vk::DeviceMemory memory;
113 try {
114 memory = m_context.get_device().allocateMemory(alloc_info);
115 } catch (const vk::SystemError& e) {
116 m_context.get_device().destroyBuffer(vk_buffer);
117 error_rethrow(
118 Journal::Component::Core,
119 Journal::Context::GraphicsBackend,
120 std::source_location::current(),
121 "Failed to allocate VkDeviceMemory: " + std::string(e.what()));
122 }
123
124 try {
125 m_context.get_device().bindBufferMemory(vk_buffer, memory, 0);
126 } catch (const vk::SystemError& e) {
127 m_context.get_device().freeMemory(memory);
128 m_context.get_device().destroyBuffer(vk_buffer);
129
130 error_rethrow(
131 Journal::Component::Core,
132 Journal::Context::GraphicsBackend,
133 std::source_location::current(),
134 "Failed to bind buffer memory: " + std::string(e.what()));
135 }
136
137 void* mapped_ptr = nullptr;
138 if (buffer->is_host_visible()) {
139 try {
140 mapped_ptr = m_context.get_device().mapMemory(memory, 0, buffer->get_size_bytes());
141 } catch (const vk::SystemError& e) {
142 m_context.get_device().freeMemory(memory);
143 m_context.get_device().destroyBuffer(vk_buffer);
144
145 error_rethrow(
146 Journal::Component::Core,
147 Journal::Context::GraphicsBackend,
148 std::source_location::current(),
149 "Failed to map buffer memory: " + std::string(e.what()));
150 }
151 }
152
153 Buffers::VKBufferResources resources { .buffer = vk_buffer, .memory = memory, .mapped_ptr = mapped_ptr };
154 buffer->set_buffer_resources(resources);
155 m_managed_buffers.push_back(buffer);
156
157 MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
158 "VulkanBuffer initialized: {} bytes, modality: {}, VkBuffer: {:p}",
159 buffer->get_size_bytes(),
160 Kakshya::modality_to_string(buffer->get_modality()),
161 (void*)buffer->get_buffer());
162}
163
164void BackendResourceManager::cleanup_buffer(const std::shared_ptr<Buffers::VKBuffer>& buffer)
165{
166 if (!buffer) {
167 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
168 "Attempted to cleanup null VulkanBuffer");
169 return;
170 }
171
172 auto it = std::ranges::find(m_managed_buffers, buffer);
173 if (it == m_managed_buffers.end()) {
174 return;
175 }
176
177 auto& [vk_buffer, memory, mapped_ptr] = it->get()->get_buffer_resources();
178
179 if (mapped_ptr) {
180 m_context.get_device().unmapMemory(memory);
181 }
182
183 if (vk_buffer) {
184 m_context.get_device().destroyBuffer(vk_buffer);
185 }
186
187 if (memory) {
188 m_context.get_device().freeMemory(memory);
189 }
190
191 m_managed_buffers.erase(it);
192
193 MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
194 "VulkanBuffer cleaned up: {:p}", (void*)vk_buffer);
195}
196
197void BackendResourceManager::flush_pending_buffer_operations()
198{
199 for (auto& buffer_wrapper : m_managed_buffers) {
200 auto& resources = buffer_wrapper->get_buffer_resources();
201 auto dirty_ranges = buffer_wrapper->get_and_clear_dirty_ranges();
202 if (!dirty_ranges.empty()) {
203 for (auto [offset, size] : dirty_ranges) {
204 vk::MappedMemoryRange range;
205 range.memory = resources.memory;
206 range.offset = offset;
207 range.size = size;
208 if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
209 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
210 "Failed to flush mapped memory range: {}", vk::to_string(result));
211 }
212 }
213 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
214 "Flushed {} dirty ranges for buffer {:p}", dirty_ranges.size(),
215 (void*)buffer_wrapper->get_buffer());
216 }
217
218 auto invalid_ranges = buffer_wrapper->get_and_clear_invalid_ranges();
219 if (!invalid_ranges.empty()) {
220 for (auto [offset, size] : invalid_ranges) {
221 vk::MappedMemoryRange range;
222 range.memory = buffer_wrapper->get_buffer_resources().memory;
223 range.offset = offset;
224 range.size = size;
225 if (auto result = m_context.get_device().invalidateMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
226 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
227 "Failed to invalidate mapped memory range: {}", vk::to_string(result));
228 }
229 }
230 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
231 "Invalidated {} ranges for buffer {:p}", invalid_ranges.size(),
232 (void*)buffer_wrapper->get_buffer());
233 }
234 }
235}
236
237void BackendResourceManager::initialize_image(const std::shared_ptr<VKImage>& image)
238{
239 if (!image) {
240 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
241 "Attempted to initialize null VKImage");
242 return;
243 }
244
245 if (image->is_initialized()) {
246 MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
247 "VKImage already initialized, skipping");
248 return;
249 }
250
251 // ========================================================================
252 // Step 1: Create VkImage
253 // ========================================================================
254
255 vk::ImageCreateInfo image_info {};
256
257 switch (image->get_type()) {
258 case VKImage::Type::TYPE_1D:
259 image_info.imageType = vk::ImageType::e1D;
260 break;
261 case VKImage::Type::TYPE_2D:
262 case VKImage::Type::TYPE_CUBE:
263 image_info.imageType = vk::ImageType::e2D;
264 break;
265 case VKImage::Type::TYPE_3D:
266 image_info.imageType = vk::ImageType::e3D;
267 break;
268 }
269
270 image_info.extent.width = image->get_width();
271 image_info.extent.height = image->get_height();
272 image_info.extent.depth = image->get_depth();
273 image_info.mipLevels = image->get_mip_levels();
274 image_info.arrayLayers = image->get_array_layers();
275 image_info.format = image->get_format();
276 image_info.tiling = vk::ImageTiling::eOptimal;
277 image_info.initialLayout = vk::ImageLayout::eUndefined;
278 image_info.usage = image->get_usage_flags();
279 image_info.sharingMode = vk::SharingMode::eExclusive;
280 image_info.samples = vk::SampleCountFlagBits::e1; // No MSAA for now
281 image_info.flags = (image->get_type() == VKImage::Type::TYPE_CUBE)
282 ? vk::ImageCreateFlagBits::eCubeCompatible
283 : vk::ImageCreateFlags {};
284
285 vk::Image vk_image;
286 try {
287 vk_image = m_context.get_device().createImage(image_info);
288 } catch (const vk::SystemError& e) {
289 error_rethrow(
290 Journal::Component::Core,
291 Journal::Context::GraphicsBackend,
292 std::source_location::current(),
293 "Failed to create VkImage: " + std::string(e.what()));
294 }
295
296 // ========================================================================
297 // Step 2: Allocate memory
298 // ========================================================================
299
300 vk::MemoryRequirements mem_requirements;
301 mem_requirements = m_context.get_device().getImageMemoryRequirements(vk_image);
302
303 vk::MemoryAllocateInfo alloc_info {};
304 alloc_info.allocationSize = mem_requirements.size;
305 alloc_info.memoryTypeIndex = find_memory_type(
306 mem_requirements.memoryTypeBits,
307 image->get_memory_properties());
308
309 vk::DeviceMemory memory;
310 try {
311 memory = m_context.get_device().allocateMemory(alloc_info);
312 } catch (const vk::SystemError& e) {
313 m_context.get_device().destroyImage(vk_image);
314 error_rethrow(
315 Journal::Component::Core,
316 Journal::Context::GraphicsBackend,
317 std::source_location::current(),
318 "Failed to allocate VkDeviceMemory for image: " + std::string(e.what()));
319 }
320
321 // ========================================================================
322 // Step 3: Bind memory to image
323 // ========================================================================
324
325 try {
326 m_context.get_device().bindImageMemory(vk_image, memory, 0);
327 } catch (const vk::SystemError& e) {
328 m_context.get_device().freeMemory(memory);
329 m_context.get_device().destroyImage(vk_image);
330 error_rethrow(
331 Journal::Component::Core,
332 Journal::Context::GraphicsBackend,
333 std::source_location::current(),
334 "Failed to bind memory to VkImage: " + std::string(e.what()));
335 }
336
337 // ========================================================================
338 // Step 4: Create image view
339 // ========================================================================
340
341 vk::ImageViewCreateInfo view_info {};
342
343 switch (image->get_type()) {
344 case VKImage::Type::TYPE_1D:
345 view_info.viewType = (image->get_array_layers() > 1)
346 ? vk::ImageViewType::e1DArray
347 : vk::ImageViewType::e1D;
348 break;
349 case VKImage::Type::TYPE_2D:
350 view_info.viewType = (image->get_array_layers() > 1)
351 ? vk::ImageViewType::e2DArray
352 : vk::ImageViewType::e2D;
353 break;
354 case VKImage::Type::TYPE_3D:
355 view_info.viewType = vk::ImageViewType::e3D;
356 break;
357 case VKImage::Type::TYPE_CUBE:
358 view_info.viewType = vk::ImageViewType::eCube;
359 break;
360 }
361
362 view_info.image = vk_image;
363 view_info.format = image->get_format();
364 view_info.subresourceRange.aspectMask = image->get_aspect_flags();
365 view_info.subresourceRange.baseMipLevel = 0;
366 view_info.subresourceRange.levelCount = image->get_mip_levels();
367 view_info.subresourceRange.baseArrayLayer = 0;
368 view_info.subresourceRange.layerCount = image->get_array_layers();
369
370 view_info.components.r = vk::ComponentSwizzle::eIdentity;
371 view_info.components.g = vk::ComponentSwizzle::eIdentity;
372 view_info.components.b = vk::ComponentSwizzle::eIdentity;
373 view_info.components.a = vk::ComponentSwizzle::eIdentity;
374
375 vk::ImageView image_view;
376 try {
377 image_view = m_context.get_device().createImageView(view_info);
378 } catch (const vk::SystemError& e) {
379 m_context.get_device().freeMemory(memory);
380 m_context.get_device().destroyImage(vk_image);
381 error_rethrow(
382 Journal::Component::Core,
383 Journal::Context::GraphicsBackend,
384 std::source_location::current(),
385 "Failed to create VkImageView: " + std::string(e.what()));
386 }
387
388 // ========================================================================
389 // Step 5: Store handles in VKImage
390 // ========================================================================
391
392 VKImageResources resources {};
393 resources.image = vk_image;
394 resources.image_view = image_view;
395 resources.memory = memory;
396 resources.sampler = nullptr;
397
398 image->set_image_resources(resources);
399 image->set_current_layout(vk::ImageLayout::eUndefined);
400
401 MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
402 "VKImage initialized: {}x{}x{}, format: {}, {} mips, {} layers",
403 image->get_width(), image->get_height(), image->get_depth(),
404 vk::to_string(image->get_format()),
405 image->get_mip_levels(), image->get_array_layers());
406}
407
408void BackendResourceManager::cleanup_image(const std::shared_ptr<VKImage>& image)
409{
410 if (!image || !image->is_initialized()) {
411 return;
412 }
413
414 const auto& resources = image->get_image_resources();
415
416 if (resources.image_view) {
417 m_context.get_device().destroyImageView(resources.image_view);
418 }
419
420 if (resources.image) {
421 m_context.get_device().destroyImage(resources.image);
422 }
423
424 if (resources.memory) {
425 m_context.get_device().freeMemory(resources.memory);
426 }
427
428 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
429 "VKImage cleaned up");
430}
431
432void BackendResourceManager::transition_image_layout(
433 vk::Image image,
434 vk::ImageLayout old_layout,
435 vk::ImageLayout new_layout,
436 uint32_t mip_levels,
437 uint32_t array_layers,
438 vk::ImageAspectFlags aspect_flags)
439{
440 execute_immediate_commands([&](vk::CommandBuffer cmd) {
441 vk::ImageMemoryBarrier barrier {};
442 barrier.oldLayout = old_layout;
443 barrier.newLayout = new_layout;
444 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
445 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
446 barrier.image = image;
447 barrier.subresourceRange.aspectMask = aspect_flags;
448 barrier.subresourceRange.baseMipLevel = 0;
449 barrier.subresourceRange.levelCount = mip_levels;
450 barrier.subresourceRange.baseArrayLayer = 0;
451 barrier.subresourceRange.layerCount = array_layers;
452
453 vk::PipelineStageFlags src_stage;
454 vk::PipelineStageFlags dst_stage;
455
456 if (old_layout == vk::ImageLayout::eUndefined && new_layout == vk::ImageLayout::eTransferDstOptimal) {
457 barrier.srcAccessMask = vk::AccessFlags {};
458 barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
459 src_stage = vk::PipelineStageFlagBits::eTopOfPipe;
460 dst_stage = vk::PipelineStageFlagBits::eTransfer;
461 } else if (old_layout == vk::ImageLayout::eTransferDstOptimal && new_layout == vk::ImageLayout::eShaderReadOnlyOptimal) {
462 barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
463 barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
464 src_stage = vk::PipelineStageFlagBits::eTransfer;
465 dst_stage = vk::PipelineStageFlagBits::eFragmentShader;
466 } else if (old_layout == vk::ImageLayout::eUndefined && new_layout == vk::ImageLayout::eShaderReadOnlyOptimal) {
467 barrier.srcAccessMask = vk::AccessFlags {};
468 barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
469 src_stage = vk::PipelineStageFlagBits::eTopOfPipe;
470 dst_stage = vk::PipelineStageFlagBits::eFragmentShader;
471 } else if (old_layout == vk::ImageLayout::eUndefined && new_layout == vk::ImageLayout::eColorAttachmentOptimal) {
472 barrier.srcAccessMask = vk::AccessFlags {};
473 barrier.dstAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
474 src_stage = vk::PipelineStageFlagBits::eTopOfPipe;
475 dst_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput;
476 } else if (old_layout == vk::ImageLayout::eUndefined && new_layout == vk::ImageLayout::eDepthStencilAttachmentOptimal) {
477 barrier.srcAccessMask = vk::AccessFlags {};
478 barrier.dstAccessMask = vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite;
479 src_stage = vk::PipelineStageFlagBits::eTopOfPipe;
480 dst_stage = vk::PipelineStageFlagBits::eEarlyFragmentTests;
481 } else if (old_layout == vk::ImageLayout::eUndefined && new_layout == vk::ImageLayout::eGeneral) {
482 barrier.srcAccessMask = vk::AccessFlags {};
483 barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
484 src_stage = vk::PipelineStageFlagBits::eTopOfPipe;
485 dst_stage = vk::PipelineStageFlagBits::eComputeShader;
486 } else {
487 barrier.srcAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
488 barrier.dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
489 src_stage = vk::PipelineStageFlagBits::eAllCommands;
490 dst_stage = vk::PipelineStageFlagBits::eAllCommands;
491
492 MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
493 "Using generic image layout transition");
494 }
495
496 cmd.pipelineBarrier(
497 src_stage, dst_stage,
498 vk::DependencyFlags {},
499 0, nullptr, // Memory barriers
500 0, nullptr, // Buffer barriers
501 1, &barrier // Image barriers
502 );
503 });
504
505 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
506 "Image layout transitioned: {} -> {}",
507 vk::to_string(old_layout), vk::to_string(new_layout));
508}
509
510void BackendResourceManager::upload_image_data(
511 std::shared_ptr<VKImage> image,
512 const void* data,
513 size_t size)
514{
515 if (!image || !data) {
516 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
517 "Invalid parameters for upload_image_data");
518 return;
519 }
520
521 auto staging = std::make_shared<Buffers::VKBuffer>(
522 size,
523 Buffers::VKBuffer::Usage::STAGING,
524 Kakshya::DataModality::IMAGE_COLOR);
525
526 initialize_buffer(staging);
527
528 void* mapped = staging->get_mapped_ptr();
529 if (!mapped) {
530 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
531 "Failed to map staging buffer for image upload");
532 cleanup_buffer(staging);
533 return;
534 }
535
536 std::memcpy(mapped, data, size);
537 staging->mark_dirty_range(0, size);
538
539 auto& resources = staging->get_buffer_resources();
540 vk::MappedMemoryRange range { resources.memory, 0, VK_WHOLE_SIZE };
541
542 if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
543 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
544 "Failed to flush mapped memory range: {}", vk::to_string(result));
545 }
546
547 execute_immediate_commands([&](vk::CommandBuffer cmd) {
548 vk::ImageMemoryBarrier barrier {};
549 barrier.oldLayout = image->get_current_layout();
550 barrier.newLayout = vk::ImageLayout::eTransferDstOptimal;
551 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
552 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
553 barrier.image = image->get_image();
554 barrier.subresourceRange.aspectMask = image->get_aspect_flags();
555 barrier.subresourceRange.baseMipLevel = 0;
556 barrier.subresourceRange.levelCount = image->get_mip_levels();
557 barrier.subresourceRange.baseArrayLayer = 0;
558 barrier.subresourceRange.layerCount = image->get_array_layers();
559 barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead;
560 barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
561
562 cmd.pipelineBarrier(
563 vk::PipelineStageFlagBits::eFragmentShader,
564 vk::PipelineStageFlagBits::eTransfer,
565 vk::DependencyFlags {},
566 0, nullptr, 0, nullptr, 1, &barrier);
567
568 vk::BufferImageCopy region {};
569 region.bufferOffset = 0;
570 region.bufferRowLength = 0;
571 region.bufferImageHeight = 0;
572 region.imageSubresource.aspectMask = image->get_aspect_flags();
573 region.imageSubresource.mipLevel = 0;
574 region.imageSubresource.baseArrayLayer = 0;
575 region.imageSubresource.layerCount = image->get_array_layers();
576 region.imageOffset = vk::Offset3D { 0, 0, 0 };
577 region.imageExtent = vk::Extent3D {
578 image->get_width(),
579 image->get_height(),
580 image->get_depth()
581 };
582
583 cmd.copyBufferToImage(
584 staging->get_buffer(),
585 image->get_image(),
586 vk::ImageLayout::eTransferDstOptimal,
587 1, &region);
588
589 barrier.oldLayout = vk::ImageLayout::eTransferDstOptimal;
590 barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
591 barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
592 barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
593
594 cmd.pipelineBarrier(
595 vk::PipelineStageFlagBits::eTransfer,
596 vk::PipelineStageFlagBits::eFragmentShader,
597 vk::DependencyFlags {},
598 0, nullptr, 0, nullptr, 1, &barrier);
599 });
600
601 image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
602
603 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
604 "Uploaded {} bytes to image {}x{}",
605 size, image->get_width(), image->get_height());
606}
607
608void BackendResourceManager::upload_image_data_with_staging(
609 std::shared_ptr<VKImage> image,
610 const void* data,
611 size_t size,
612 const std::shared_ptr<Buffers::VKBuffer>& staging)
613{
614 if (!image || !data || !staging) {
615 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
616 "Invalid parameters for upload_image_data_with_staging");
617 return;
618 }
619
620 void* mapped = staging->get_mapped_ptr();
621 if (!mapped) {
622 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
623 "upload_image_data_with_staging: staging buffer has no mapped pointer");
624 return;
625 }
626
627 std::memcpy(mapped, data, size);
628 staging->mark_dirty_range(0, size);
629
630 auto& resources = staging->get_buffer_resources();
631 vk::MappedMemoryRange range { resources.memory, 0, VK_WHOLE_SIZE };
632
633 if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range);
634 result != vk::Result::eSuccess) {
635 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
636 "upload_image_data_with_staging: flush failed: {}", vk::to_string(result));
637 }
638
639 execute_immediate_commands([&](vk::CommandBuffer cmd) {
640 vk::ImageMemoryBarrier barrier {};
641 barrier.oldLayout = image->get_current_layout();
642 barrier.newLayout = vk::ImageLayout::eTransferDstOptimal;
643 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
644 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
645 barrier.image = image->get_image();
646 barrier.subresourceRange = {
647 image->get_aspect_flags(), 0,
648 image->get_mip_levels(), 0,
649 image->get_array_layers()
650 };
651 barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead;
652 barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
653
654 cmd.pipelineBarrier(
655 vk::PipelineStageFlagBits::eFragmentShader,
656 vk::PipelineStageFlagBits::eTransfer,
657 {}, 0, nullptr, 0, nullptr, 1, &barrier);
658
659 vk::BufferImageCopy region {};
660 region.imageSubresource.aspectMask = image->get_aspect_flags();
661 region.imageSubresource.layerCount = image->get_array_layers();
662 region.imageOffset = vk::Offset3D { 0, 0, 0 };
663 region.imageExtent = vk::Extent3D {
664 image->get_width(),
665 image->get_height(),
666 image->get_depth()
667 };
668
669 cmd.copyBufferToImage(
670 staging->get_buffer(),
671 image->get_image(),
672 vk::ImageLayout::eTransferDstOptimal,
673 1, &region);
674
675 barrier.oldLayout = vk::ImageLayout::eTransferDstOptimal;
676 barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
677 barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
678 barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
679
680 cmd.pipelineBarrier(
681 vk::PipelineStageFlagBits::eTransfer,
682 vk::PipelineStageFlagBits::eFragmentShader,
683 {}, 0, nullptr, 0, nullptr, 1, &barrier);
684 });
685
686 image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
687
688 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
689 "upload_image_data_with_staging: {} bytes to image {}x{}",
690 size, image->get_width(), image->get_height());
691}
692
693void BackendResourceManager::download_image_data(
694 std::shared_ptr<VKImage> image,
695 void* data,
696 size_t size,
697 vk::ImageLayout restore_layout,
698 vk::PipelineStageFlags restore_stage)
699{
700 if (!image || !data) {
701 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
702 "Invalid parameters for download_image_data");
703 return;
704 }
705
706 auto staging = std::make_shared<Buffers::VKBuffer>(
707 size,
708 Buffers::VKBuffer::Usage::STAGING,
709 Kakshya::DataModality::IMAGE_COLOR);
710
711 initialize_buffer(staging);
712
713 execute_immediate_commands([&](vk::CommandBuffer cmd) {
714 vk::ImageMemoryBarrier barrier {};
715 barrier.oldLayout = image->get_current_layout();
716 barrier.newLayout = vk::ImageLayout::eTransferSrcOptimal;
717 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
718 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
719 barrier.image = image->get_image();
720 barrier.subresourceRange.aspectMask = image->get_aspect_flags();
721 barrier.subresourceRange.baseMipLevel = 0;
722 barrier.subresourceRange.levelCount = image->get_mip_levels();
723 barrier.subresourceRange.baseArrayLayer = 0;
724 barrier.subresourceRange.layerCount = image->get_array_layers();
725 barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead;
726 barrier.dstAccessMask = vk::AccessFlagBits::eTransferRead;
727
728 cmd.pipelineBarrier(
729 vk::PipelineStageFlagBits::eFragmentShader,
730 vk::PipelineStageFlagBits::eTransfer,
731 vk::DependencyFlags {}, {}, {}, barrier);
732
733 vk::BufferImageCopy region {};
734 region.bufferOffset = 0;
735 region.bufferRowLength = 0;
736 region.bufferImageHeight = 0;
737 region.imageSubresource.aspectMask = image->get_aspect_flags();
738 region.imageSubresource.mipLevel = 0;
739 region.imageSubresource.baseArrayLayer = 0;
740 region.imageSubresource.layerCount = image->get_array_layers();
741 region.imageOffset = vk::Offset3D { 0, 0, 0 };
742 region.imageExtent = vk::Extent3D {
743 image->get_width(),
744 image->get_height(),
745 image->get_depth()
746 };
747
748 cmd.copyImageToBuffer(
749 image->get_image(),
750 vk::ImageLayout::eTransferSrcOptimal,
751 staging->get_buffer(),
752 1, &region);
753
754 barrier.oldLayout = vk::ImageLayout::eTransferSrcOptimal;
755 barrier.newLayout = restore_layout;
756 barrier.srcAccessMask = vk::AccessFlagBits::eTransferRead;
757 barrier.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
758
759 cmd.pipelineBarrier(
760 vk::PipelineStageFlagBits::eTransfer,
761 restore_stage,
762 vk::DependencyFlags {}, {}, {}, barrier);
763 });
764
765 staging->mark_invalid_range(0, size);
766 auto& resources = staging->get_buffer_resources();
767 vk::MappedMemoryRange range { resources.memory, 0, VK_WHOLE_SIZE };
768
769 if (auto result = m_context.get_device().invalidateMappedMemoryRanges(1, &range);
770 result != vk::Result::eSuccess) {
771 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
772 "Failed to invalidate mapped memory range: {}", vk::to_string(result));
773 }
774
775 if (void* mapped = staging->get_mapped_ptr()) {
776 std::memcpy(data, mapped, size);
777 }
778
779 cleanup_buffer(staging);
780
781 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
782 "Downloaded {} bytes from image {}x{}",
783 size, image->get_width(), image->get_height());
784}
785
786vk::Sampler BackendResourceManager::create_sampler(
787 vk::Filter filter,
788 vk::SamplerAddressMode address_mode,
789 float max_anisotropy)
790{
791 size_t hash = 0;
792 auto hash_combine = [](size_t& seed, size_t value) {
793 seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
794 };
795
796 hash_combine(hash, static_cast<size_t>(filter));
797 hash_combine(hash, static_cast<size_t>(address_mode));
798 hash_combine(hash, std::hash<float> {}(max_anisotropy));
799
800 auto it = m_sampler_cache.find(hash);
801 if (it != m_sampler_cache.end()) {
802 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
803 "Reusing cached sampler (hash: 0x{:X})", hash);
804 return it->second;
805 }
806
807 vk::SamplerCreateInfo sampler_info;
808 sampler_info.magFilter = filter;
809 sampler_info.minFilter = filter;
810 sampler_info.mipmapMode = vk::SamplerMipmapMode::eLinear;
811 sampler_info.addressModeU = address_mode;
812 sampler_info.addressModeV = address_mode;
813 sampler_info.addressModeW = address_mode;
814 sampler_info.mipLodBias = 0.0F;
815 sampler_info.anisotropyEnable = max_anisotropy > 0.0F;
816 sampler_info.maxAnisotropy = max_anisotropy;
817 sampler_info.compareEnable = VK_FALSE;
818 sampler_info.compareOp = vk::CompareOp::eAlways;
819 sampler_info.minLod = 0.0F;
820 sampler_info.maxLod = VK_LOD_CLAMP_NONE;
821 sampler_info.borderColor = vk::BorderColor::eFloatOpaqueBlack;
822 sampler_info.unnormalizedCoordinates = VK_FALSE;
823
824 vk::Sampler sampler;
825 try {
826 sampler = m_context.get_device().createSampler(sampler_info);
827 } catch (const vk::SystemError& e) {
828 MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
829 "Failed to create sampler: {}", e.what());
830 return nullptr;
831 }
832
833 m_sampler_cache[hash] = sampler;
834
835 MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
836 "Created sampler (filter: {}, address: {}, anisotropy: {}, hash: 0x{:X})",
837 vk::to_string(filter), vk::to_string(address_mode), max_anisotropy, hash);
838
839 return sampler;
840}
841
842void BackendResourceManager::destroy_sampler(vk::Sampler sampler)
843{
844 if (!sampler) {
845 return;
846 }
847
848 for (auto it = m_sampler_cache.begin(); it != m_sampler_cache.end(); ++it) {
849 if (it->second == sampler) {
850 m_sampler_cache.erase(it);
851 break;
852 }
853 }
854
855 m_context.get_device().destroySampler(sampler);
856
857 MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
858 "Destroyed sampler");
859}
860
861uint32_t BackendResourceManager::find_memory_type(uint32_t type_filter, vk::MemoryPropertyFlags properties) const
862{
863 vk::PhysicalDeviceMemoryProperties mem_properties;
864 mem_properties = m_context.get_physical_device().getMemoryProperties();
865
866 for (uint32_t i = 0; i < mem_properties.memoryTypeCount; i++) {
867 if ((type_filter & (1 << i)) && (mem_properties.memoryTypes[i].propertyFlags & properties) == properties) {
868 return i;
869 }
870 }
871
872 error<std::runtime_error>(
873 Journal::Component::Core,
874 Journal::Context::GraphicsBackend,
875 std::source_location::current(),
876 "Failed to find suitable memory type");
877
878 return 0;
879}
880
881void BackendResourceManager::execute_immediate_commands(const std::function<void(vk::CommandBuffer)>& recorder)
882{
883 vk::CommandBuffer cmd = m_command_manager.begin_single_time_commands();
884 recorder(cmd);
885 m_command_manager.end_single_time_commands(cmd, m_context.get_graphics_queue());
886}
887
888void BackendResourceManager::record_deferred_commands(const std::function<void(vk::CommandBuffer)>& recorder)
889{
890 // TODO: batch commands for later submission
891 // For now, just execute immediately
892 execute_immediate_commands(recorder);
893}
894
895void BackendResourceManager::cleanup()
896{
897 for (auto& [hash, sampler] : m_sampler_cache) {
898 if (sampler) {
899 m_context.get_device().destroySampler(sampler);
900 }
901 }
902 m_sampler_cache.clear();
903
904 for (auto& buffer : m_managed_buffers) {
905 if (buffer && buffer->is_initialized()) {
906 cleanup_buffer(buffer);
907 }
908 }
909 m_managed_buffers.clear();
910}
911
912size_t BackendResourceManager::compute_sampler_hash(vk::Filter filter, vk::SamplerAddressMode address_mode, float max_anisotropy) const
913{
914 size_t hash = 0;
915 auto hash_combine = [](size_t& seed, size_t value) {
916 seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
917 };
918
919 hash_combine(hash, static_cast<size_t>(filter));
920 hash_combine(hash, static_cast<size_t>(address_mode));
921 hash_combine(hash, std::hash<float> {}(max_anisotropy));
922
923 return hash;
924}
925
926}
MF_INFO
#define MF_INFO(comp, ctx,...)
Definition Archivist.hpp:374
MF_ERROR
#define MF_ERROR(comp, ctx,...)
Definition Archivist.hpp:382
MF_WARN
#define MF_WARN(comp, ctx,...)
Definition Archivist.hpp:378
MF_DEBUG
#define MF_DEBUG(comp, ctx,...)
Definition Archivist.hpp:370
MayaFlux::Buffers::VKBuffer::Usage::STAGING
@ STAGING
Host-visible staging buffer (CPU-writable)
MayaFlux::Core::BackendResourceManager::cleanup_image
void cleanup_image(const std::shared_ptr< VKImage > &image)
Cleanup a VKImage (destroy view, image, and free memory)
Definition BackendResoureManager.cpp:408
MayaFlux::Core::BackendResourceManager::cleanup_buffer
void cleanup_buffer(const std::shared_ptr< Buffers::VKBuffer > &buffer)
Cleanup a buffer and release associated resources.
Definition BackendResoureManager.cpp:164
MayaFlux::Core::BackendResourceManager::flush_pending_buffer_operations
void flush_pending_buffer_operations()
Flush any pending buffer operations (e.g., uploads/downloads)
Definition BackendResoureManager.cpp:197
MayaFlux::Core::BackendResourceManager::compute_sampler_hash
size_t compute_sampler_hash(vk::Filter filter, vk::SamplerAddressMode address_mode, float max_anisotropy) const
Definition BackendResoureManager.cpp:912
MayaFlux::Core::BackendResourceManager::execute_immediate_commands
void execute_immediate_commands(const std::function< void(vk::CommandBuffer)> &recorder)
Execute immediate command recording for buffer operations.
Definition BackendResoureManager.cpp:881
MayaFlux::Core::BackendResourceManager::BackendResourceManager
BackendResourceManager(VKContext &context, VKCommandManager &command_manager)
Definition BackendResoureManager.cpp:13
MayaFlux::Core::BackendResourceManager::m_sampler_cache
std::unordered_map< size_t, vk::Sampler > m_sampler_cache
Definition BackendResoureManager.hpp:204
MayaFlux::Core::BackendResourceManager::initialize_image
void initialize_image(const std::shared_ptr< VKImage > &image)
Initialize a VKImage (allocate VkImage, memory, and create image view)
Definition BackendResoureManager.cpp:237
MayaFlux::Core::BackendResourceManager::destroy_sampler
void destroy_sampler(vk::Sampler sampler)
Destroy sampler.
Definition BackendResoureManager.cpp:842
MayaFlux::Core::BackendResourceManager::create_sampler
vk::Sampler create_sampler(vk::Filter filter=vk::Filter::eLinear, vk::SamplerAddressMode address_mode=vk::SamplerAddressMode::eRepeat, float max_anisotropy=0.0F)
Create sampler.
Definition BackendResoureManager.cpp:786
MayaFlux::Core::BackendResourceManager::download_image_data
void download_image_data(std::shared_ptr< VKImage > image, void *data, size_t size, vk::ImageLayout restore_layout=vk::ImageLayout::eShaderReadOnlyOptimal, vk::PipelineStageFlags restore_stage=vk::PipelineStageFlagBits::eFragmentShader)
Download data from an image into a caller-supplied buffer.
Definition BackendResoureManager.cpp:693
MayaFlux::Core::BackendResourceManager::find_memory_type
uint32_t find_memory_type(uint32_t type_filter, vk::MemoryPropertyFlags properties) const
Find a suitable memory type for Vulkan buffer allocation.
Definition BackendResoureManager.cpp:861
MayaFlux::Core::BackendResourceManager::transition_image_layout
void transition_image_layout(vk::Image image, vk::ImageLayout old_layout, vk::ImageLayout new_layout, uint32_t mip_levels=1, uint32_t array_layers=1, vk::ImageAspectFlags aspect_flags=vk::ImageAspectFlagBits::eColor)
Transition image layout using a pipeline barrier.
Definition BackendResoureManager.cpp:432
MayaFlux::Core::BackendResourceManager::upload_image_data_with_staging
void upload_image_data_with_staging(std::shared_ptr< VKImage > image, const void *data, size_t size, const std::shared_ptr< Buffers::VKBuffer > &staging)
Upload image data using a caller-supplied persistent staging buffer.
Definition BackendResoureManager.cpp:608
MayaFlux::Core::BackendResourceManager::initialize_buffer
void initialize_buffer(const std::shared_ptr< Buffers::VKBuffer > &buffer)
Initialize a buffer for use with the graphics backend.
Definition BackendResoureManager.cpp:72
MayaFlux::Core::BackendResourceManager::setup_backend_service
void setup_backend_service(const std::shared_ptr< Registry::Service::BufferService > &buffer_service)
Definition BackendResoureManager.cpp:19
MayaFlux::Core::BackendResourceManager::record_deferred_commands
void record_deferred_commands(const std::function< void(vk::CommandBuffer)> &recorder)
Record deferred command recording for buffer operations.
Definition BackendResoureManager.cpp:888
MayaFlux::Core::BackendResourceManager::upload_image_data
void upload_image_data(std::shared_ptr< VKImage > image, const void *data, size_t size)
Upload data to an image (creates staging buffer internally)
Definition BackendResoureManager.cpp:510
MayaFlux::Core::BackendResourceManager::m_managed_buffers
std::vector< std::shared_ptr< Buffers::VKBuffer > > m_managed_buffers
Definition BackendResoureManager.hpp:203
MayaFlux::Core::VKCommandManager::end_single_time_commands
void end_single_time_commands(vk::CommandBuffer command_buffer, vk::Queue queue)
End and submit single-time command.
Definition VKCommandManager.cpp:143
MayaFlux::Core::VKCommandManager::begin_single_time_commands
vk::CommandBuffer begin_single_time_commands()
Begin single-time command (for transfers, etc.)
Definition VKCommandManager.cpp:115
MayaFlux::Core::VKCommandManager
Manages Vulkan command pools and command buffers.
Definition VKCommandManager.hpp:14
MayaFlux::Core::VKContext::get_device
vk::Device get_device() const
Get logical device.
Definition VKContext.hpp:49
MayaFlux::Core::VKContext::get_graphics_queue
vk::Queue get_graphics_queue() const
Get graphics queue.
Definition VKContext.hpp:54
MayaFlux::Core::VKContext::get_physical_device
vk::PhysicalDevice get_physical_device() const
Get physical device.
Definition VKContext.hpp:44
MayaFlux::Core::VKContext
High-level wrapper for Vulkan instance and device.
Definition VKContext.hpp:16
MayaFlux::Journal::Context::GraphicsBackend
@ GraphicsBackend
Graphics/visual rendering backend (Vulkan, OpenGL)
MayaFlux::Journal::Component::Core
@ Core
Core engine, backend, subsystems.
MayaFlux::Kakshya::DataModality::IMAGE_COLOR
@ IMAGE_COLOR
2D RGB/RGBA image
MayaFlux::Kakshya::modality_to_string
std::string_view modality_to_string(DataModality modality)
Convert DataModality enum to string representation.
Definition NDData.cpp:83
MayaFlux::Core::VKImageResources
Vulkan image resource handles.
Definition VKImage.hpp:15