git/SDL3CPlusPlus
1
0
Fork 0
mirror of https://github.com/johndoe6345789/SDL3CPlusPlus.git synced 2026-04-24 21:55:09 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
da0499a469984290f817ac1d29b9eaaca0331ee2
SDL3CPlusPlus/src/services/impl/swapchain_service.cpp

339 lines
13 KiB
C++
Raw Blame History

#include "swapchain_service.hpp"
#include <algorithm>
#include <stdexcept>
namespace sdl3cpp::services::impl {
SwapchainService::SwapchainService(std::shared_ptr<IVulkanDeviceService> deviceService,
std::shared_ptr<events::EventBus> eventBus,
std::shared_ptr<ILogger> logger)
: deviceService_(std::move(deviceService)), eventBus_(std::move(eventBus)), logger_(logger) {
// Subscribe to window resize events
eventBus_->Subscribe(events::EventType::WindowResized,
[this](const events::Event& event) { OnWindowResized(event); });
}
SwapchainService::~SwapchainService() {
if (swapchain_ != VK_NULL_HANDLE) {
Shutdown();
}
}
void SwapchainService::Initialize() {
logger_->TraceFunction(__func__);
// Initialization happens in CreateSwapchain()
}
void SwapchainService::CreateSwapchain(uint32_t width, uint32_t height) {
logger_->TraceFunction(__func__);
currentWidth_ = width;
currentHeight_ = height;
auto physicalDevice = deviceService_->GetPhysicalDevice();
auto surface = deviceService_->GetSurface();
auto device = deviceService_->GetDevice();
SwapchainSupportDetails support = QuerySwapchainSupport(physicalDevice, surface);
// Validate swap chain support
if (support.formats.empty()) {
throw std::runtime_error("No surface formats available for swap chain.\n"
"This may indicate GPU driver issues or incompatible surface.");
}
if (support.presentModes.empty()) {
throw std::runtime_error("No present modes available for swap chain.\n"
"This may indicate GPU driver issues or incompatible surface.");
}
logger_->Info("Creating swapchain with size: " + std::to_string(width) + "x" + std::to_string(height));
if (width == 0 || height == 0) {
logger_->Error("Invalid dimensions (" + std::to_string(width) + "x" + std::to_string(height) + ").");
throw std::runtime_error("Invalid dimensions (" +
std::to_string(width) + "x" + std::to_string(height) + ").\n" +
"Window may be minimized or invalid.");
}
logger_->Debug("Surface capabilities - Min extent: " + std::to_string(support.capabilities.minImageExtent.width) + "x" + std::to_string(support.capabilities.minImageExtent.height) +
", Max extent: " + std::to_string(support.capabilities.maxImageExtent.width) + "x" + std::to_string(support.capabilities.maxImageExtent.height) +
", Min images: " + std::to_string(support.capabilities.minImageCount) +
", Max images: " + std::to_string(support.capabilities.maxImageCount));
VkSurfaceFormatKHR surfaceFormat = ChooseSurfaceFormat(support.formats);
VkPresentModeKHR presentMode = ChoosePresentMode(support.presentModes);
VkExtent2D extent = ChooseExtent(support.capabilities, width, height);
uint32_t imageCount = support.capabilities.minImageCount + 1;
if (support.capabilities.maxImageCount > 0 && imageCount > support.capabilities.maxImageCount) {
imageCount = support.capabilities.maxImageCount;
}
logger_->TraceVariable("imageCount", static_cast<int>(imageCount));
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = deviceService_->GetQueueFamilies();
uint32_t queueFamilyIndices[] = {indices.graphicsFamily, indices.presentFamily};
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
} else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = support.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain_) != VK_SUCCESS) {
throw std::runtime_error("Failed to create swap chain");
}
vkGetSwapchainImagesKHR(device, swapchain_, &imageCount, nullptr);
images_.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain_, &imageCount, images_.data());
imageFormat_ = surfaceFormat.format;
extent_ = extent;
CreateImageViews();
CreateRenderPass();
CreateFramebuffers();
}
void SwapchainService::RecreateSwapchain(uint32_t width, uint32_t height) {
logger_->TraceFunction(__func__);
logger_->Info("Recreating swapchain: " + std::to_string(width) + "x" + std::to_string(height));
deviceService_->WaitIdle();
CleanupSwapchainInternal();
CreateSwapchain(width, height);
}
VkResult SwapchainService::AcquireNextImage(VkSemaphore semaphore, uint32_t& imageIndex) {
auto device = deviceService_->GetDevice();
return vkAcquireNextImageKHR(device, swapchain_, UINT64_MAX, semaphore,
VK_NULL_HANDLE, &imageIndex);
}
VkResult SwapchainService::Present(const std::vector<VkSemaphore>& waitSemaphores,
uint32_t imageIndex) {
auto presentQueue = deviceService_->GetPresentQueue();
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = static_cast<uint32_t>(waitSemaphores.size());
presentInfo.pWaitSemaphores = waitSemaphores.data();
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &swapchain_;
presentInfo.pImageIndices = &imageIndex;
return vkQueuePresentKHR(presentQueue, &presentInfo);
}
void SwapchainService::CreateImageViews() {
logger_->TraceFunction(__func__);
auto device = deviceService_->GetDevice();
imageViews_.resize(images_.size());
for (size_t i = 0; i < images_.size(); ++i) {
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = images_[i];
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = imageFormat_;
viewInfo.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.levelCount = 1;
viewInfo.subresourceRange.baseArrayLayer = 0;
viewInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(device, &viewInfo, nullptr, &imageViews_[i]) != VK_SUCCESS) {
throw std::runtime_error("Failed to create image views");
}
}
}
void SwapchainService::CreateRenderPass() {
logger_->TraceFunction(__func__);
auto device = deviceService_->GetDevice();
VkAttachmentDescription colorAttachment{};
colorAttachment.format = imageFormat_;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass_) != VK_SUCCESS) {
throw std::runtime_error("Failed to create render pass");
}
}
void SwapchainService::CreateFramebuffers() {
logger_->TraceFunction(__func__);
auto device = deviceService_->GetDevice();
framebuffers_.resize(imageViews_.size());
for (size_t i = 0; i < imageViews_.size(); ++i) {
VkImageView attachments[] = {imageViews_[i]};
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass_;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = extent_.width;
framebufferInfo.height = extent_.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers_[i]) != VK_SUCCESS) {
throw std::runtime_error("Failed to create framebuffer");
}
}
}
void SwapchainService::CleanupSwapchainInternal() {
logger_->TraceFunction(__func__);
auto device = deviceService_->GetDevice();
for (auto framebuffer : framebuffers_) {
vkDestroyFramebuffer(device, framebuffer, nullptr);
}
framebuffers_.clear();
if (renderPass_ != VK_NULL_HANDLE) {
vkDestroyRenderPass(device, renderPass_, nullptr);
renderPass_ = VK_NULL_HANDLE;
}
for (auto imageView : imageViews_) {
vkDestroyImageView(device, imageView, nullptr);
}
imageViews_.clear();
if (swapchain_ != VK_NULL_HANDLE) {
vkDestroySwapchainKHR(device, swapchain_, nullptr);
swapchain_ = VK_NULL_HANDLE;
}
}
void SwapchainService::CleanupSwapchain() {
CleanupSwapchainInternal();
}
void SwapchainService::Shutdown() noexcept {
CleanupSwapchainInternal();
}
SwapchainService::SwapchainSupportDetails SwapchainService::QuerySwapchainSupport(
VkPhysicalDevice device, VkSurfaceKHR surface) {
logger_->TraceFunction(__func__);
SwapchainSupportDetails details;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0) {
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0) {
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount,
details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR SwapchainService::ChooseSurfaceFormat(
const std::vector<VkSurfaceFormatKHR>& availableFormats) {
logger_->TraceFunction(__func__);
for (const auto& availableFormat : availableFormats) {
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB &&
availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR SwapchainService::ChoosePresentMode(
const std::vector<VkPresentModeKHR>& availablePresentModes) {
logger_->TraceFunction(__func__);
for (const auto& availablePresentMode : availablePresentModes) {
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D SwapchainService::ChooseExtent(const VkSurfaceCapabilitiesKHR& capabilities,
uint32_t width, uint32_t height) {
return VkExtent2D{
std::clamp(width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width),
std::clamp(height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height)
};
}
void SwapchainService::OnWindowResized(const events::Event& event) {
logger_->TraceFunction(__func__);
logger_->Info("Window resized event received, swapchain recreation needed");
}
} // namespace sdl3cpp::services::impl
Reference in New Issue View Git Blame Copy Permalink