Implement frames in flight and swap chain recreation
This commit is contained in:
647
16_frames_in_flight.cpp
Normal file
647
16_frames_in_flight.cpp
Normal file
@@ -0,0 +1,647 @@
|
||||
#include <cassert>
|
||||
#if defined(__INTELLISENSE__) || !defined(USE_CPP20_MODULES)
|
||||
#include "vulkan/vulkan.hpp"
|
||||
#include <vulkan/vulkan_raii.hpp>
|
||||
#include <vulkan/vulkan_core.h>
|
||||
#else
|
||||
import vulkan_hpp;
|
||||
#endif
|
||||
|
||||
#define GLFW_INCLUDE_VULKAN
|
||||
#include <GLFW/glfw3.h>
|
||||
#include <ios>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <cstdlib>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <algorithm>
|
||||
|
||||
constexpr uint32_t WIDTH = 800;
|
||||
constexpr uint32_t HEIGHT = 600;
|
||||
constexpr int32_t MAX_FRAMES_IN_FLIGHT = 2;
|
||||
|
||||
const std::vector<char const *> validationLayers = {
|
||||
"VK_LAYER_KHRONOS_validation"
|
||||
};
|
||||
|
||||
#ifdef NDEBUG
|
||||
constexpr bool enableValidationLayers = false;
|
||||
#else
|
||||
constexpr bool enableValidationLayers = true;
|
||||
#endif
|
||||
|
||||
static std::vector<char> readFile(const std::string &filename) {
|
||||
std::ifstream file(filename, std::ios::ate | std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
throw std::runtime_error("failed to open file!");
|
||||
}
|
||||
|
||||
std::vector<char> buffer(file.tellg());
|
||||
file.seekg(0, std::ios::beg);
|
||||
file.read(buffer.data(), static_cast<std::streamsize>(buffer.size()));
|
||||
file.close();
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
class HelloTriangleApplication {
|
||||
public:
|
||||
void run() {
|
||||
initWindow();
|
||||
initVulkan();
|
||||
mainLoop();
|
||||
cleanup();
|
||||
}
|
||||
private:
|
||||
void initWindow() {
|
||||
glfwInit();
|
||||
// Don't create an OpenGL context
|
||||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
||||
window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
|
||||
}
|
||||
void initVulkan() {
|
||||
createInstance();
|
||||
createSurface();
|
||||
pickPhysicalDevice();
|
||||
createLogicalDevice();
|
||||
createSwapChain();
|
||||
createImageViews();
|
||||
createGraphicsPipeline();
|
||||
createCommandPool();
|
||||
createCommandBuffers();
|
||||
createSyncObjects();
|
||||
}
|
||||
void mainLoop() {
|
||||
while (!glfwWindowShouldClose(window)) {
|
||||
glfwPollEvents();
|
||||
drawFrame();
|
||||
}
|
||||
|
||||
device.waitIdle();
|
||||
}
|
||||
void drawFrame() {
|
||||
// Wait till fence is signalled
|
||||
while (vk::Result::eTimeout == device.waitForFences(*drawFences[frameIndex], vk::True, UINT64_MAX)) {}
|
||||
|
||||
device.resetFences(*drawFences[frameIndex]);
|
||||
|
||||
auto [result, imageIndex] = swapChain.acquireNextImage(UINT64_MAX, *presentCompleteSemaphores[frameIndex], nullptr);
|
||||
recordCommandBuffer(imageIndex);
|
||||
|
||||
vk::PipelineStageFlags waitDestinationStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput);
|
||||
const vk::SubmitInfo submitInfo = {
|
||||
.waitSemaphoreCount = 1,
|
||||
.pWaitSemaphores = &*presentCompleteSemaphores[frameIndex],
|
||||
.pWaitDstStageMask = &waitDestinationStageMask,
|
||||
.commandBufferCount = 1,
|
||||
.pCommandBuffers = &*commandBuffers[frameIndex],
|
||||
.signalSemaphoreCount = 1,
|
||||
.pSignalSemaphores = &*renderFinishedSemaphores[imageIndex],
|
||||
};
|
||||
graphicsQueue.submit(submitInfo, *drawFences[frameIndex]);
|
||||
|
||||
// Presentation
|
||||
vk::PresentInfoKHR presentInfoKHR = {
|
||||
.waitSemaphoreCount = 1,
|
||||
.pWaitSemaphores = &*renderFinishedSemaphores[imageIndex],
|
||||
.swapchainCount = 1,
|
||||
.pSwapchains = &*swapChain,
|
||||
.pImageIndices = &imageIndex,
|
||||
};
|
||||
result = graphicsQueue.presentKHR(presentInfoKHR);
|
||||
switch (result) {
|
||||
case vk::Result::eSuccess:
|
||||
break;
|
||||
case vk::Result::eSuboptimalKHR:
|
||||
std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n";
|
||||
break;
|
||||
default:
|
||||
break; // an unexpected result is returned!
|
||||
}
|
||||
|
||||
frameIndex = (frameIndex + 1) % MAX_FRAMES_IN_FLIGHT;
|
||||
}
|
||||
void cleanup() {
|
||||
glfwDestroyWindow(window);
|
||||
glfwTerminate();
|
||||
}
|
||||
void createInstance() {
|
||||
constexpr vk::ApplicationInfo appInfo {
|
||||
.pApplicationName = "Hello Triangle",
|
||||
.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
|
||||
.pEngineName = "No Engine",
|
||||
.engineVersion = VK_MAKE_VERSION(1, 0, 0),
|
||||
.apiVersion = vk::ApiVersion14,
|
||||
};
|
||||
|
||||
// Get the required layers
|
||||
std::vector<char const*> requiredLayers;
|
||||
if (enableValidationLayers) {
|
||||
requiredLayers.assign(validationLayers.begin(), validationLayers.end());
|
||||
}
|
||||
|
||||
// Check if the required layers are supported by the Vulkan implementation.
|
||||
auto layerProperties = context.enumerateInstanceLayerProperties();
|
||||
if (std::ranges::any_of(requiredLayers, [&layerProperties](auto const& requiredLayer) {
|
||||
return std::ranges::none_of(layerProperties,
|
||||
[requiredLayer](auto const& layerProperty)
|
||||
{ return strcmp(layerProperty.layerName, requiredLayer) == 0; });
|
||||
}))
|
||||
{
|
||||
throw std::runtime_error("One or more required layers are not supported!");
|
||||
}
|
||||
|
||||
// Get the required instance extensions from GLFW.
|
||||
uint32_t glfwExtensionCount = 0;
|
||||
auto glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
|
||||
|
||||
// Check if the required GLFW extensions are supported by the Vulkan implementation.
|
||||
auto extensionProperties = context.enumerateInstanceExtensionProperties();
|
||||
for (uint32_t i = 0; i < glfwExtensionCount; ++i)
|
||||
{
|
||||
if (std::ranges::none_of(extensionProperties,
|
||||
[glfwExtension = glfwExtensions[i]](auto const& extensionProperty)
|
||||
{ return strcmp(extensionProperty.extensionName, glfwExtension) == 0; }))
|
||||
{
|
||||
throw std::runtime_error("Required GLFW extension not supported: " + std::string(glfwExtensions[i]));
|
||||
}
|
||||
}
|
||||
vk::InstanceCreateInfo createInfo {
|
||||
.pApplicationInfo = &appInfo,
|
||||
.enabledLayerCount = static_cast<uint32_t>(requiredLayers.size()),
|
||||
.ppEnabledLayerNames = requiredLayers.data(),
|
||||
.enabledExtensionCount = glfwExtensionCount,
|
||||
.ppEnabledExtensionNames = glfwExtensions,
|
||||
};
|
||||
|
||||
instance = vk::raii::Instance(context, createInfo);
|
||||
}
|
||||
void createSurface() {
|
||||
VkSurfaceKHR _surface;
|
||||
if (glfwCreateWindowSurface(*instance, window, nullptr, &_surface) != 0) {
|
||||
throw std::runtime_error("failed to create window surface!");
|
||||
}
|
||||
|
||||
surface = vk::raii::SurfaceKHR(instance, _surface);
|
||||
}
|
||||
void pickPhysicalDevice() {
|
||||
std::vector<const char*> deviceExtensions = {
|
||||
vk::KHRSwapchainExtensionName,
|
||||
vk::KHRSpirv14ExtensionName,
|
||||
vk::KHRCreateRenderpass2ExtensionName,
|
||||
};
|
||||
|
||||
auto devices = instance.enumeratePhysicalDevices();
|
||||
if (devices.empty()) {
|
||||
throw std::runtime_error("failed to find GPUs with Vulkan support!");
|
||||
}
|
||||
|
||||
for (const auto &device : devices) {
|
||||
auto deviceProperties = device.getProperties();
|
||||
auto deviceFeatures = device.getFeatures();
|
||||
auto queueFamilies = device.getQueueFamilyProperties();
|
||||
auto extensions = device.enumerateDeviceExtensionProperties();
|
||||
bool isSuitable = deviceProperties.apiVersion >= VK_API_VERSION_1_3;
|
||||
bool extensionFound = true;
|
||||
|
||||
const vk::QueueFamilyProperties *qf = nullptr;
|
||||
for (const auto &qfp : queueFamilies) {
|
||||
if ((qfp.queueFlags & vk::QueueFlagBits::eGraphics) != static_cast<vk::QueueFlags>(0)) {
|
||||
qf = &qfp;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
isSuitable = isSuitable && (qf != nullptr);
|
||||
|
||||
for (const auto &extension : deviceExtensions) {
|
||||
auto extensionIter = std::ranges::find_if(extensions, [extension](auto const & ext) {return strcmp(ext.extensionName, extension) == 0;});
|
||||
extensionFound = extensionFound && extensionIter != extensions.end();
|
||||
}
|
||||
|
||||
isSuitable = isSuitable && extensionFound;
|
||||
|
||||
if (isSuitable) {
|
||||
physicalDevice = device;
|
||||
return;
|
||||
}
|
||||
|
||||
throw std::runtime_error("failed to find a suitable GPU");
|
||||
}
|
||||
}
|
||||
void createLogicalDevice() {
|
||||
std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
|
||||
graphicsQueueIndex = findQueueFamilies(physicalDevice);
|
||||
float queuePriority = 0.5f;
|
||||
vk::DeviceQueueCreateInfo deviceQueueCreateInfo {
|
||||
.queueFamilyIndex = graphicsQueueIndex,
|
||||
.queueCount = 1,
|
||||
.pQueuePriorities = &queuePriority,
|
||||
};
|
||||
|
||||
// Create a chain of feature structures
|
||||
vk::StructureChain<vk::PhysicalDeviceFeatures2,
|
||||
vk::PhysicalDeviceVulkan13Features,
|
||||
vk::PhysicalDeviceVulkan11Features,
|
||||
vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {
|
||||
{}, // vk::PhysicalDeviceFeatures2 (empty for now)
|
||||
{.synchronization2 = true,
|
||||
.dynamicRendering = true}, // Enable dynamic rendering and synchronization2 from Vulkan 1.3
|
||||
{.shaderDrawParameters = true}, // Enable shader draw parameters from Vulkan 1.2
|
||||
{.extendedDynamicState = true} // Enable extended dynamic state from the extension
|
||||
};
|
||||
|
||||
std::vector<const char*> deviceExtensions = {
|
||||
vk::KHRSwapchainExtensionName,
|
||||
vk::KHRSpirv14ExtensionName,
|
||||
vk::KHRSynchronization2ExtensionName,
|
||||
vk::KHRCreateRenderpass2ExtensionName
|
||||
};
|
||||
|
||||
vk::DeviceCreateInfo deviceCreateInfo {
|
||||
.pNext = &featureChain.get<vk::PhysicalDeviceFeatures2>(),
|
||||
.queueCreateInfoCount = 1,
|
||||
.pQueueCreateInfos = &deviceQueueCreateInfo,
|
||||
.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()),
|
||||
.ppEnabledExtensionNames = deviceExtensions.data(),
|
||||
};
|
||||
|
||||
device = vk::raii::Device(physicalDevice, deviceCreateInfo);
|
||||
graphicsQueue = vk::raii::Queue(device, graphicsQueueIndex, 0);
|
||||
}
|
||||
void createSwapChain() {
|
||||
auto surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR(surface);
|
||||
swapChainSurfaceFormat = chooseSwapSurfaceFormat(physicalDevice.getSurfaceFormatsKHR(surface));
|
||||
swapChainExtent = chooseSwapExtent(surfaceCapabilities);
|
||||
auto minImageCount = std::max(3u, surfaceCapabilities.minImageCount);
|
||||
minImageCount = (surfaceCapabilities.maxImageCount > 0 &&
|
||||
minImageCount > surfaceCapabilities.maxImageCount) ?
|
||||
surfaceCapabilities.maxImageCount :
|
||||
minImageCount;
|
||||
|
||||
vk::SwapchainCreateInfoKHR swapChainCreateInfo {
|
||||
.flags = vk::SwapchainCreateFlagsKHR(),
|
||||
.surface = surface,
|
||||
.minImageCount = minImageCount,
|
||||
.imageFormat = swapChainSurfaceFormat.format,
|
||||
.imageColorSpace = swapChainSurfaceFormat.colorSpace,
|
||||
.imageExtent = swapChainExtent,
|
||||
.imageArrayLayers = 1,
|
||||
.imageUsage = vk::ImageUsageFlagBits::eColorAttachment,
|
||||
.imageSharingMode = vk::SharingMode::eExclusive,
|
||||
.preTransform = surfaceCapabilities.currentTransform,
|
||||
.compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque,
|
||||
.presentMode = chooseSwapPresentMode(physicalDevice.getSurfacePresentModesKHR(surface)),
|
||||
.clipped = true,
|
||||
.oldSwapchain = nullptr,
|
||||
};
|
||||
|
||||
swapChain = vk::raii::SwapchainKHR(device, swapChainCreateInfo);
|
||||
swapChainImages = swapChain.getImages();
|
||||
swapChainImageFormat = swapChainSurfaceFormat.format;
|
||||
}
|
||||
void createImageViews() {
|
||||
swapChainImageViews.clear();
|
||||
|
||||
vk::ImageViewCreateInfo imageViewCreateInfo{
|
||||
.viewType = vk::ImageViewType::e2D,
|
||||
.format = swapChainImageFormat,
|
||||
.subresourceRange = { vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1 }
|
||||
};
|
||||
|
||||
for (auto image : swapChainImages) {
|
||||
imageViewCreateInfo.image = image;
|
||||
swapChainImageViews.emplace_back(vk::raii::ImageView(device, imageViewCreateInfo));
|
||||
}
|
||||
}
|
||||
void createGraphicsPipeline() {
|
||||
vk::raii::ShaderModule shaderModule = createShaderModule(readFile("shaders/09_shader_base.spv"));
|
||||
|
||||
vk::PipelineShaderStageCreateInfo vertShaderStageInfo = {
|
||||
.stage = vk::ShaderStageFlagBits::eVertex,
|
||||
.module = shaderModule,
|
||||
.pName = "vertMain",
|
||||
};
|
||||
vk::PipelineShaderStageCreateInfo fragShaderStageInfo = {
|
||||
.stage = vk::ShaderStageFlagBits::eFragment,
|
||||
.module = shaderModule,
|
||||
.pName = "fragMain",
|
||||
};
|
||||
|
||||
vk::PipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
|
||||
|
||||
// Vertex input
|
||||
vk::PipelineVertexInputStateCreateInfo vertexInputInfo;
|
||||
|
||||
// Input assembly
|
||||
vk::PipelineInputAssemblyStateCreateInfo inputAssembly = {
|
||||
.topology = vk::PrimitiveTopology::eTriangleList,
|
||||
};
|
||||
|
||||
// Dynamic state
|
||||
std::vector<vk::DynamicState> dynamicStates = {
|
||||
vk::DynamicState::eViewport,
|
||||
vk::DynamicState::eScissor,
|
||||
};
|
||||
vk::PipelineDynamicStateCreateInfo dynamicState = {
|
||||
.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()),
|
||||
.pDynamicStates = dynamicStates.data(),
|
||||
};
|
||||
// No need to specify viewport and scissor because they will be specified dynamically
|
||||
vk::PipelineViewportStateCreateInfo viewportState = {
|
||||
.viewportCount = 1,
|
||||
.scissorCount = 1,
|
||||
};
|
||||
|
||||
// Rasterisation
|
||||
vk::PipelineRasterizationStateCreateInfo rasterizer = {
|
||||
.depthClampEnable = vk::False,
|
||||
.rasterizerDiscardEnable = vk::False,
|
||||
.polygonMode = vk::PolygonMode::eFill,
|
||||
.cullMode = vk::CullModeFlagBits::eBack,
|
||||
.frontFace = vk::FrontFace::eClockwise,
|
||||
.depthBiasEnable = vk::False,
|
||||
.depthBiasSlopeFactor = 1.0f,
|
||||
.lineWidth = 1.0f
|
||||
};
|
||||
|
||||
// Multisampling
|
||||
vk::PipelineMultisampleStateCreateInfo multisampling = {
|
||||
.rasterizationSamples = vk::SampleCountFlagBits::e1,
|
||||
.sampleShadingEnable = vk::False,
|
||||
};
|
||||
|
||||
// Color blending
|
||||
vk::PipelineColorBlendAttachmentState colorBlendAttachment = {
|
||||
.blendEnable = vk::False,
|
||||
.colorWriteMask = vk::ColorComponentFlagBits::eR |
|
||||
vk::ColorComponentFlagBits::eG |
|
||||
vk::ColorComponentFlagBits::eB |
|
||||
vk::ColorComponentFlagBits::eA,
|
||||
};
|
||||
vk::PipelineColorBlendStateCreateInfo colorBlending = {
|
||||
.logicOpEnable = vk::False,
|
||||
.logicOp = vk::LogicOp::eCopy,
|
||||
.attachmentCount = 1,
|
||||
.pAttachments = &colorBlendAttachment,
|
||||
};
|
||||
|
||||
// Pipeline layout
|
||||
vk::PipelineLayoutCreateInfo pipelineLayoutInfo = {
|
||||
.setLayoutCount = 0,
|
||||
.pushConstantRangeCount = 0,
|
||||
};
|
||||
pipelineLayout = vk::raii::PipelineLayout(device, pipelineLayoutInfo);
|
||||
|
||||
// Dynamic rendering pipeline
|
||||
vk::PipelineRenderingCreateInfo pipelineRenderingCreateInfo = {
|
||||
.colorAttachmentCount = 1,
|
||||
.pColorAttachmentFormats = &swapChainImageFormat,
|
||||
};
|
||||
vk::GraphicsPipelineCreateInfo pipelineInfo = {
|
||||
.pNext = &pipelineRenderingCreateInfo,
|
||||
.stageCount = 2,
|
||||
.pStages = shaderStages,
|
||||
.pVertexInputState = &vertexInputInfo,
|
||||
.pInputAssemblyState = &inputAssembly,
|
||||
.pViewportState = &viewportState,
|
||||
.pRasterizationState = &rasterizer,
|
||||
.pMultisampleState = &multisampling,
|
||||
.pColorBlendState = &colorBlending,
|
||||
.pDynamicState = &dynamicState,
|
||||
.layout = pipelineLayout,
|
||||
.renderPass = nullptr,
|
||||
};
|
||||
|
||||
// Create pipeline
|
||||
graphicsPipeline = vk::raii::Pipeline(device, nullptr, pipelineInfo);
|
||||
}
|
||||
void createCommandPool() {
|
||||
vk::CommandPoolCreateInfo poolInfo = {
|
||||
.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer,
|
||||
.queueFamilyIndex = graphicsQueueIndex,
|
||||
};
|
||||
commandPool = vk::raii:: CommandPool(device, poolInfo);
|
||||
}
|
||||
void createCommandBuffers() {
|
||||
commandBuffers.clear();
|
||||
vk::CommandBufferAllocateInfo allocInfo = {
|
||||
.commandPool = commandPool,
|
||||
.level = vk::CommandBufferLevel::ePrimary,
|
||||
.commandBufferCount = MAX_FRAMES_IN_FLIGHT,
|
||||
};
|
||||
commandBuffers = vk::raii::CommandBuffers(device, allocInfo);
|
||||
}
|
||||
void createSyncObjects() {
|
||||
assert(presentCompleteSemaphores.empty() && renderFinishedSemaphores.empty() && drawFences.empty());
|
||||
|
||||
for (size_t i = 0; i < swapChainImages.size(); ++i) {
|
||||
renderFinishedSemaphores.emplace_back(device, vk::SemaphoreCreateInfo());
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
|
||||
presentCompleteSemaphores.emplace_back(device, vk::SemaphoreCreateInfo());
|
||||
drawFences.emplace_back(device, vk::FenceCreateInfo{ .flags = vk::FenceCreateFlagBits::eSignaled });
|
||||
}
|
||||
}
|
||||
void recordCommandBuffer(uint32_t imageIndex) {
|
||||
auto &commandBuffer = commandBuffers[frameIndex];
|
||||
|
||||
// Begin recording the command buffer
|
||||
commandBuffer.begin({});
|
||||
|
||||
// Before starting rendering, transition the swapchain image to COLOR_ATTACHMENT_OPTIMAL
|
||||
transitionImageLayout(
|
||||
imageIndex,
|
||||
vk::ImageLayout::eUndefined,
|
||||
vk::ImageLayout::eColorAttachmentOptimal,
|
||||
{}, // srcAccessMask (no need to wait for previous operations)
|
||||
vk::AccessFlagBits2::eColorAttachmentWrite, // dstAccessMask
|
||||
vk::PipelineStageFlagBits2::eColorAttachmentOutput, // srcStage
|
||||
vk::PipelineStageFlagBits2::eColorAttachmentOutput // dstStage
|
||||
);
|
||||
|
||||
vk::ClearValue clearColor = vk::ClearColorValue(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
vk::RenderingAttachmentInfo attachmentInfo = {
|
||||
.imageView = swapChainImageViews[imageIndex],
|
||||
.imageLayout = vk::ImageLayout::eColorAttachmentOptimal,
|
||||
.loadOp = vk::AttachmentLoadOp::eClear,
|
||||
.storeOp = vk::AttachmentStoreOp::eStore,
|
||||
.clearValue = clearColor,
|
||||
};
|
||||
vk::RenderingInfo renderingInfo = {
|
||||
.renderArea = { .offset = { 0, 0 }, .extent = swapChainExtent },
|
||||
.layerCount = 1,
|
||||
.colorAttachmentCount = 1,
|
||||
.pColorAttachments = &attachmentInfo,
|
||||
};
|
||||
|
||||
commandBuffer.beginRendering(renderingInfo);
|
||||
commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, graphicsPipeline);
|
||||
// Viewport and scissor are dynamic so we need to set them
|
||||
vk::Viewport viewport = {
|
||||
.x = 0.0f,
|
||||
.y = 0.0f,
|
||||
.width = static_cast<float>(swapChainExtent.width),
|
||||
.height = static_cast<float>(swapChainExtent.height),
|
||||
.minDepth = 0.0f,
|
||||
.maxDepth = 1.0f,
|
||||
};
|
||||
commandBuffer.setViewport(0, viewport);
|
||||
commandBuffer.setScissor(0, vk::Rect2D(vk::Offset2D(0, 0), swapChainExtent));
|
||||
|
||||
// Issue the draw command
|
||||
commandBuffer.draw(3, 1, 0, 0);
|
||||
|
||||
commandBuffer.endRendering();
|
||||
|
||||
// After rendering, transition the swapchain image to PRESENT_SRC
|
||||
transitionImageLayout(
|
||||
imageIndex,
|
||||
vk::ImageLayout::eColorAttachmentOptimal,
|
||||
vk::ImageLayout::ePresentSrcKHR,
|
||||
vk::AccessFlagBits2::eColorAttachmentWrite, // srcAccessMask
|
||||
{}, // dstAccessMask
|
||||
vk::PipelineStageFlagBits2::eColorAttachmentOutput, // srcStage
|
||||
vk::PipelineStageFlagBits2::eBottomOfPipe // dstStage
|
||||
);
|
||||
|
||||
// Finish recording the command buffer
|
||||
commandBuffer.end();
|
||||
}
|
||||
void transitionImageLayout(
|
||||
uint32_t imageIndex,
|
||||
vk::ImageLayout oldLayout,
|
||||
vk::ImageLayout newLayout,
|
||||
vk::AccessFlags2 srcAccessMask,
|
||||
vk::AccessFlags2 dstAccessMask,
|
||||
vk::PipelineStageFlags2 srcStageMask,
|
||||
vk::PipelineStageFlags2 dstStageMask
|
||||
) {
|
||||
vk::ImageMemoryBarrier2 barrier = {
|
||||
.srcStageMask = srcStageMask,
|
||||
.srcAccessMask = srcAccessMask,
|
||||
.dstStageMask = dstStageMask,
|
||||
.dstAccessMask = dstAccessMask,
|
||||
.oldLayout = oldLayout,
|
||||
.newLayout = newLayout,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = swapChainImages[imageIndex],
|
||||
.subresourceRange = {
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = 1,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = 1
|
||||
}
|
||||
};
|
||||
vk::DependencyInfo dependencyInfo = {
|
||||
.dependencyFlags = {},
|
||||
.imageMemoryBarrierCount = 1,
|
||||
.pImageMemoryBarriers = &barrier
|
||||
};
|
||||
commandBuffers[frameIndex].pipelineBarrier2(dependencyInfo);
|
||||
}
|
||||
[[nodiscard]] vk::raii::ShaderModule createShaderModule(const std::vector<char> &code) const {
|
||||
vk::ShaderModuleCreateInfo createInfo {
|
||||
.codeSize = code.size() * sizeof(char),
|
||||
.pCode = reinterpret_cast<const uint32_t *>(code.data()),
|
||||
};
|
||||
|
||||
return vk::raii::ShaderModule{device, createInfo};
|
||||
}
|
||||
vk::SurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats) {
|
||||
for (const auto& availableFormat : availableFormats) {
|
||||
if (availableFormat.format == vk::Format::eB8G8R8A8Srgb && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
|
||||
return availableFormat;
|
||||
}
|
||||
}
|
||||
|
||||
return availableFormats[0];
|
||||
}
|
||||
vk::PresentModeKHR chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes) {
|
||||
for (const auto& availablePresentMode : availablePresentModes) {
|
||||
if (availablePresentMode == vk::PresentModeKHR::eMailbox) {
|
||||
return availablePresentMode;
|
||||
}
|
||||
}
|
||||
|
||||
return vk::PresentModeKHR::eFifo;
|
||||
}
|
||||
vk::Extent2D chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities) {
|
||||
if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
|
||||
return capabilities.currentExtent;
|
||||
}
|
||||
|
||||
int width, height;
|
||||
glfwGetFramebufferSize(window, &width, &height);
|
||||
|
||||
return {
|
||||
std::clamp<uint32_t>(width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width),
|
||||
std::clamp<uint32_t>(height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height),
|
||||
};
|
||||
}
|
||||
uint32_t findQueueFamilies(vk::raii::PhysicalDevice physicalDevice) {
|
||||
// find the index of the first queue family that supports graphics
|
||||
std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
|
||||
|
||||
// get the first index into queueFamilyProperties which both supports graphics and present
|
||||
uint32_t queueIndex = ~0;
|
||||
for (uint32_t qfpIndex = 0; qfpIndex < queueFamilyProperties.size(); ++qfpIndex) {
|
||||
if ((queueFamilyProperties[qfpIndex].queueFlags & vk::QueueFlagBits::eGraphics) &&
|
||||
physicalDevice.getSurfaceSupportKHR(qfpIndex, *surface)) {
|
||||
queueIndex = qfpIndex;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (queueIndex == ~0) {
|
||||
throw std::runtime_error("Could not find a queue for graphics and present -> terminating");
|
||||
}
|
||||
|
||||
return queueIndex;
|
||||
}
|
||||
|
||||
uint32_t frameIndex = 0;
|
||||
bool framebufferResized = false;
|
||||
GLFWwindow *window;
|
||||
vk::raii::Context context;
|
||||
vk::raii::Instance instance = nullptr;
|
||||
vk::raii::PhysicalDevice physicalDevice = nullptr;
|
||||
uint32_t graphicsQueueIndex;
|
||||
vk::raii::Device device = nullptr;
|
||||
vk::raii::Queue graphicsQueue = nullptr;
|
||||
vk::raii::SurfaceKHR surface = nullptr;
|
||||
vk::raii::SwapchainKHR swapChain = nullptr;
|
||||
vk::SurfaceFormatKHR swapChainSurfaceFormat;
|
||||
vk::Extent2D swapChainExtent;
|
||||
vk::Format swapChainImageFormat = vk::Format::eUndefined;
|
||||
std::vector<vk::Image> swapChainImages;
|
||||
std::vector<vk::raii::ImageView> swapChainImageViews;
|
||||
vk::raii::PipelineLayout pipelineLayout = nullptr;
|
||||
vk::raii::Pipeline graphicsPipeline = nullptr;
|
||||
vk::raii::CommandPool commandPool = nullptr;
|
||||
std::vector<vk::raii::CommandBuffer> commandBuffers;
|
||||
std::vector<vk::raii::Semaphore> presentCompleteSemaphores;
|
||||
std::vector<vk::raii::Semaphore> renderFinishedSemaphores;
|
||||
std::vector<vk::raii::Fence> drawFences;
|
||||
};
|
||||
|
||||
int main() {
|
||||
HelloTriangleApplication app;
|
||||
|
||||
try {
|
||||
app.run();
|
||||
} catch (const std::exception &e) {
|
||||
std::cout << e.what() << std::endl;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
Reference in New Issue
Block a user