1186 lines
48 KiB
C++
1186 lines
48 KiB
C++
#include <cassert>
|
|
#include <cstring>
|
|
#include <glm/trigonometric.hpp>
|
|
#include <random>
|
|
#include <tuple>
|
|
#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 STB_IMAGE_IMPLEMENTATION
|
|
#include <stb_image.h>
|
|
#define TINYOBJLOADER_IMPLEMENTATION
|
|
#include <tiny_obj_loader.h>
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
// The perspective projection matrix generated by GLM will use the OpenGL depth range of -1.0 to 1.0
|
|
// by default. We need to configure it to use the Vulkan range of 0.0 to 1.0 using the
|
|
// GLM_FORCE_DEPTH_ZERO_TO_ONE definition.
|
|
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
|
#define GLM_ENABLE_EXPERIMENTAL
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
#include <glm/gtx/hash.hpp>
|
|
#include <ios>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <array>
|
|
#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 uint32_t PARTICLE_COUNT = 8192;
|
|
constexpr int32_t MAX_FRAMES_IN_FLIGHT = 2;
|
|
const std::string SHADER_FILE = "shaders/31_shader_compute.spv";
|
|
|
|
const std::vector<char const *> validationLayers = {
|
|
"VK_LAYER_KHRONOS_validation"
|
|
};
|
|
|
|
#ifdef NDEBUG
|
|
constexpr bool enableValidationLayers = false;
|
|
#else
|
|
constexpr bool enableValidationLayers = true;
|
|
#endif
|
|
|
|
struct UniformBufferObject {
|
|
float deltaTime = 1.0f;
|
|
};
|
|
|
|
struct Particle {
|
|
glm::vec2 position;
|
|
glm::vec2 velocity;
|
|
glm::vec4 color;
|
|
|
|
static vk::VertexInputBindingDescription getBindingDescription() {
|
|
return {0, sizeof(Particle), vk::VertexInputRate::eVertex};
|
|
}
|
|
|
|
static std::array<vk::VertexInputAttributeDescription, 2> getAttributeDescriptions() {
|
|
return {
|
|
vk::VertexInputAttributeDescription{0, 0, vk::Format::eR32G32Sfloat, offsetof(Particle, position)},
|
|
vk::VertexInputAttributeDescription{1, 0, vk::Format::eR32G32B32A32Sfloat, offsetof(Particle, color)},
|
|
};
|
|
}
|
|
};
|
|
|
|
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 ComputeShaderApplication {
|
|
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_TRUE);
|
|
window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
|
|
glfwSetWindowUserPointer(window, this);
|
|
glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);
|
|
lastTime = glfwGetTime();
|
|
}
|
|
static void framebufferResizeCallback(GLFWwindow *window, int width, int height) {
|
|
auto app = reinterpret_cast<ComputeShaderApplication*>(glfwGetWindowUserPointer(window));
|
|
app->framebufferResized = true;
|
|
}
|
|
void initVulkan() {
|
|
createInstance();
|
|
createSurface();
|
|
pickPhysicalDevice();
|
|
createLogicalDevice();
|
|
createSwapChain();
|
|
createImageViews();
|
|
createComputeDescriptorSetLayout();
|
|
createGraphicsPipeline();
|
|
createComputePipeline();
|
|
createCommandPool();
|
|
createShaderStorageBuffers();
|
|
createUniformBuffers();
|
|
createDescriptorPool();
|
|
createComputeDescriptorSets();
|
|
createCommandBuffers();
|
|
createComputeCommandBuffers();
|
|
createSyncObjects();
|
|
}
|
|
void mainLoop() {
|
|
while (!glfwWindowShouldClose(window)) {
|
|
glfwPollEvents();
|
|
drawFrame();
|
|
// We want to animate the particle system using the last frames time to get smooth, frame-rate independent animation
|
|
double currentTime = glfwGetTime();
|
|
lastFrameTime = (currentTime - lastTime) * 1000.0;
|
|
lastTime = currentTime;
|
|
}
|
|
|
|
device.waitIdle();
|
|
}
|
|
void drawFrame() {
|
|
vk::Result result;
|
|
uint32_t imageIndex;
|
|
try {
|
|
std::tie(result, imageIndex) = swapChain.acquireNextImage(UINT64_MAX, nullptr, *drawFences[frameIndex]);
|
|
|
|
if (result == vk::Result::eErrorOutOfDateKHR) {
|
|
recreateSwapChain();
|
|
return;
|
|
}
|
|
if (result != vk::Result::eSuccess && result != vk::Result::eSuboptimalKHR) {
|
|
throw std::runtime_error("failed to acquire swap chain image!");
|
|
}
|
|
|
|
auto fenceResult = device.waitForFences(*drawFences[frameIndex], vk::True, UINT64_MAX);
|
|
if (fenceResult != vk::Result::eSuccess) {
|
|
throw std::runtime_error("failed to wait for fence!");
|
|
}
|
|
} catch (const vk::SystemError &e) {
|
|
if (e.code().value() == static_cast<int>(vk::Result::eErrorOutOfDateKHR)) {
|
|
recreateSwapChain();
|
|
return;
|
|
} else {
|
|
throw;
|
|
}
|
|
}
|
|
|
|
device.resetFences(*drawFences[frameIndex]);
|
|
|
|
// Update timeline value for this frame
|
|
uint64_t computeWaitValue = timelineValue;
|
|
uint64_t computeSignalValue = ++timelineValue;
|
|
uint64_t graphicsWaitValue = computeSignalValue;
|
|
uint64_t graphicsSignalValue = ++timelineValue;
|
|
|
|
updateUniformBuffer(frameIndex);
|
|
|
|
{
|
|
recordComputeCommandBuffer();
|
|
|
|
// Submit compute work
|
|
vk::TimelineSemaphoreSubmitInfo computeTimelineInfo = {
|
|
.waitSemaphoreValueCount = 1,
|
|
.pWaitSemaphoreValues = &computeWaitValue,
|
|
.signalSemaphoreValueCount = 1,
|
|
.pSignalSemaphoreValues = &computeSignalValue,
|
|
};
|
|
vk::PipelineStageFlags waitStages[] = {vk::PipelineStageFlagBits::eComputeShader};
|
|
vk::SubmitInfo computeSubmitInfo = {
|
|
.pNext = &computeTimelineInfo,
|
|
.waitSemaphoreCount = 1,
|
|
.pWaitSemaphores = &*semaphore,
|
|
.pWaitDstStageMask = waitStages,
|
|
.commandBufferCount = 1,
|
|
.pCommandBuffers = &*computeCommandBuffers[frameIndex],
|
|
.signalSemaphoreCount = 1,
|
|
.pSignalSemaphores = &*semaphore,
|
|
};
|
|
|
|
queue.submit(computeSubmitInfo, nullptr);
|
|
}
|
|
|
|
{
|
|
recordCommandBuffer(imageIndex);
|
|
|
|
// Submit graphics work (waits for compute to finish)
|
|
vk::PipelineStageFlags waitStage = vk::PipelineStageFlagBits::eVertexInput;
|
|
vk::TimelineSemaphoreSubmitInfo graphicsTimelineInfo = {
|
|
.waitSemaphoreValueCount = 1,
|
|
.pWaitSemaphoreValues = &graphicsWaitValue,
|
|
.signalSemaphoreValueCount = 1,
|
|
.pSignalSemaphoreValues = &graphicsSignalValue,
|
|
};
|
|
const vk::SubmitInfo graphicsSubmitInfo = {
|
|
.pNext = &graphicsTimelineInfo,
|
|
.waitSemaphoreCount = 1,
|
|
.pWaitSemaphores = &*semaphore,
|
|
.pWaitDstStageMask = &waitStage,
|
|
.commandBufferCount = 1,
|
|
.pCommandBuffers = &*commandBuffers[frameIndex],
|
|
.signalSemaphoreCount = 1,
|
|
.pSignalSemaphores = &*semaphore,
|
|
};
|
|
queue.submit(graphicsSubmitInfo, nullptr);
|
|
|
|
// Present the image (wait for graphics to finish)
|
|
vk::SemaphoreWaitInfo waitInfo = {
|
|
.semaphoreCount = 1,
|
|
.pSemaphores = &*semaphore,
|
|
.pValues = &graphicsSignalValue,
|
|
};
|
|
// Wait for graphics to complete before presenting
|
|
auto result = device.waitSemaphores(waitInfo, UINT64_MAX);
|
|
if (result != vk::Result::eSuccess)
|
|
{
|
|
throw std::runtime_error("failed to wait for semaphore!");
|
|
}
|
|
|
|
try {
|
|
// Presentation
|
|
vk::PresentInfoKHR presentInfoKHR = {
|
|
.waitSemaphoreCount = 0,
|
|
.pWaitSemaphores = nullptr,
|
|
.swapchainCount = 1,
|
|
.pSwapchains = &*swapChain,
|
|
.pImageIndices = &imageIndex,
|
|
};
|
|
result = queue.presentKHR(presentInfoKHR);
|
|
if (result == vk::Result::eErrorOutOfDateKHR || result == vk::Result::eSuboptimalKHR || framebufferResized) {
|
|
framebufferResized = false;
|
|
recreateSwapChain();
|
|
} else if (result != vk::Result::eSuccess) {
|
|
throw std::runtime_error("failed to present swap chain image!");
|
|
}
|
|
} catch (const vk::SystemError &e) {
|
|
if (e.code().value() == static_cast<int>(vk::Result::eErrorOutOfDateKHR)) {
|
|
recreateSwapChain();
|
|
return;
|
|
} else {
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
frameIndex = (frameIndex + 1) % MAX_FRAMES_IN_FLIGHT;
|
|
}
|
|
void cleanup() {
|
|
cleanupSwapChain();
|
|
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();
|
|
graphicsComputeQueueIndex = findQueueFamilies(physicalDevice);
|
|
float queuePriority = 0.5f;
|
|
vk::DeviceQueueCreateInfo deviceQueueCreateInfo {
|
|
.queueFamilyIndex = graphicsComputeQueueIndex,
|
|
.queueCount = 1,
|
|
.pQueuePriorities = &queuePriority,
|
|
};
|
|
|
|
// Create a chain of feature structures
|
|
vk::StructureChain<vk::PhysicalDeviceFeatures2,
|
|
vk::PhysicalDeviceVulkan13Features,
|
|
vk::PhysicalDeviceVulkan12Features,
|
|
vk::PhysicalDeviceVulkan11Features,
|
|
vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {
|
|
{.features = {
|
|
.sampleRateShading = true,
|
|
.samplerAnisotropy = true,
|
|
}}, // vk::PhysicalDeviceFeatures2
|
|
{.synchronization2 = true,
|
|
.dynamicRendering = true}, // Enable dynamic rendering and synchronization2 from Vulkan 1.3
|
|
{.timelineSemaphore = true}, // Enable timeline semaphores from Vulkan 1.2
|
|
{.shaderDrawParameters = true}, // Enable shader draw parameters from Vulkan 1.1
|
|
{.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);
|
|
queue = vk::raii::Queue(device, graphicsComputeQueueIndex, 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 = {
|
|
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
|
.baseMipLevel = 0,
|
|
.levelCount = 1,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
}
|
|
};
|
|
|
|
for (auto image : swapChainImages) {
|
|
imageViewCreateInfo.image = image;
|
|
swapChainImageViews.emplace_back(vk::raii::ImageView(device, imageViewCreateInfo));
|
|
}
|
|
}
|
|
void createComputeDescriptorSetLayout() {
|
|
std::array bindings = {
|
|
vk::DescriptorSetLayoutBinding{0, vk::DescriptorType::eUniformBuffer,
|
|
1, vk::ShaderStageFlagBits::eCompute, nullptr},
|
|
vk::DescriptorSetLayoutBinding{1, vk::DescriptorType::eStorageBuffer,
|
|
1, vk::ShaderStageFlagBits::eCompute, nullptr},
|
|
vk::DescriptorSetLayoutBinding{2, vk::DescriptorType::eStorageBuffer,
|
|
1, vk::ShaderStageFlagBits::eCompute, nullptr},
|
|
};
|
|
vk::DescriptorSetLayoutCreateInfo layoutInfo{
|
|
.bindingCount = bindings.size(),
|
|
.pBindings = bindings.data(),
|
|
};
|
|
computeDescriptorSetLayout = vk::raii::DescriptorSetLayout(device, layoutInfo);
|
|
}
|
|
void createGraphicsPipeline() {
|
|
vk::raii::ShaderModule shaderModule = createShaderModule(readFile(SHADER_FILE));
|
|
|
|
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};
|
|
|
|
// Particles input
|
|
auto bindingDescription = Particle::getBindingDescription();
|
|
auto attributeDescriptions = Particle::getAttributeDescriptions();
|
|
vk::PipelineVertexInputStateCreateInfo vertexInputInfo{
|
|
.vertexBindingDescriptionCount = 1,
|
|
.pVertexBindingDescriptions = &bindingDescription,
|
|
.vertexAttributeDescriptionCount = attributeDescriptions.size(),
|
|
.pVertexAttributeDescriptions = attributeDescriptions.data(),
|
|
};
|
|
|
|
// Input assembly
|
|
vk::PipelineInputAssemblyStateCreateInfo inputAssembly = {
|
|
.topology = vk::PrimitiveTopology::ePointList,
|
|
.primitiveRestartEnable = vk::False,
|
|
};
|
|
|
|
// 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::eCounterClockwise,
|
|
.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::True,
|
|
.srcColorBlendFactor = vk::BlendFactor::eSrcAlpha,
|
|
.dstColorBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha,
|
|
.colorBlendOp = vk::BlendOp::eAdd,
|
|
.srcAlphaBlendFactor = vk::BlendFactor::eOneMinusSrcAlpha,
|
|
.dstAlphaBlendFactor = vk::BlendFactor::eZero,
|
|
.alphaBlendOp = vk::BlendOp::eAdd,
|
|
.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{};
|
|
graphicsPipelineLayout = 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 = graphicsPipelineLayout,
|
|
.renderPass = nullptr,
|
|
};
|
|
|
|
// Create pipeline
|
|
graphicsPipeline = vk::raii::Pipeline(device, nullptr, pipelineInfo);
|
|
}
|
|
void createComputePipeline() {
|
|
vk::raii::ShaderModule shaderModule = createShaderModule(readFile(SHADER_FILE));
|
|
|
|
vk::PipelineShaderStageCreateInfo computeShaderStageInfo = {
|
|
.stage = vk::ShaderStageFlagBits::eCompute,
|
|
.module = shaderModule,
|
|
.pName = "compMain",
|
|
};
|
|
vk::PipelineLayoutCreateInfo layoutInfo = {
|
|
.setLayoutCount = 1,
|
|
.pSetLayouts = &*computeDescriptorSetLayout,
|
|
};
|
|
computePipelineLayout = vk::raii::PipelineLayout(device, layoutInfo);
|
|
|
|
vk::ComputePipelineCreateInfo pipelineInfo = {
|
|
.stage = computeShaderStageInfo,
|
|
.layout = *computePipelineLayout,
|
|
};
|
|
computePipeline = vk::raii::Pipeline(device, nullptr, pipelineInfo);
|
|
}
|
|
void createCommandPool() {
|
|
vk::CommandPoolCreateInfo poolInfo = {
|
|
.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer,
|
|
.queueFamilyIndex = graphicsComputeQueueIndex,
|
|
};
|
|
commandPool = vk::raii:: CommandPool(device, poolInfo);
|
|
}
|
|
void createShaderStorageBuffers() {
|
|
std::default_random_engine rndEngine(static_cast<uint32_t>(time(nullptr)));
|
|
std::uniform_real_distribution rndDist(0.0f, 1.0f);
|
|
|
|
// Initialise particle positions on a circle
|
|
std::vector<Particle> particles(PARTICLE_COUNT);
|
|
for (auto &particle : particles) {
|
|
float r = 0.25f * sqrtf(rndDist(rndEngine));
|
|
float theta = rndDist(rndEngine) * 2.0f * 3.14159265358979323846f;
|
|
float x = r * cosf(theta) * HEIGHT / WIDTH;
|
|
float y = r * sinf(theta);
|
|
particle.position = glm::vec2(x, y);
|
|
particle.velocity = normalize(glm::vec2(x, y)) * 0.00025f;
|
|
particle.color = glm::vec4(rndDist(rndEngine), rndDist(rndEngine), rndDist(rndEngine), 1.0f);
|
|
}
|
|
|
|
vk::DeviceSize bufferSize = sizeof(Particle) * PARTICLE_COUNT;
|
|
|
|
// Create a staging buffer used to upload data to the gpu
|
|
vk::raii::Buffer stagingBuffer({});
|
|
vk::raii::DeviceMemory stagingBufferMemory({});
|
|
createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc,
|
|
vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
|
|
stagingBuffer, stagingBufferMemory);
|
|
|
|
void *dataStaging = stagingBufferMemory.mapMemory(0, bufferSize);
|
|
memcpy(dataStaging, particles.data(), static_cast<size_t>(bufferSize));
|
|
stagingBufferMemory.unmapMemory();
|
|
|
|
shaderStorageBuffers.clear();
|
|
shaderStorageBuffersMemory.clear();
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
|
|
vk::raii::Buffer shaderStorageBufferTemp({});
|
|
vk::raii::DeviceMemory shaderStorageBufferTempMemory({});
|
|
createBuffer(bufferSize, vk::BufferUsageFlagBits::eStorageBuffer |
|
|
vk::BufferUsageFlagBits::eVertexBuffer |
|
|
vk::BufferUsageFlagBits::eTransferDst,
|
|
vk::MemoryPropertyFlagBits::eDeviceLocal, shaderStorageBufferTemp,
|
|
shaderStorageBufferTempMemory);
|
|
copyBuffer(stagingBuffer, shaderStorageBufferTemp, bufferSize);
|
|
shaderStorageBuffers.emplace_back(std::move(shaderStorageBufferTemp));
|
|
shaderStorageBuffersMemory.emplace_back(std::move(shaderStorageBufferTempMemory));
|
|
}
|
|
}
|
|
void createUniformBuffers() {
|
|
uniformBuffers.clear();
|
|
uniformBuffersMemory.clear();
|
|
unifromBuffersMapped.clear();
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
|
|
vk::DeviceSize bufferSize = sizeof(UniformBufferObject);
|
|
vk::raii::Buffer buffer({});
|
|
vk::raii::DeviceMemory bufferMem({});
|
|
createBuffer(bufferSize, vk::BufferUsageFlagBits::eUniformBuffer,
|
|
vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
|
|
buffer, bufferMem);
|
|
uniformBuffers.emplace_back(std::move(buffer));
|
|
uniformBuffersMemory.emplace_back(std::move(bufferMem));
|
|
unifromBuffersMapped.emplace_back(uniformBuffersMemory[i].mapMemory(0, bufferSize));
|
|
}
|
|
}
|
|
void createDescriptorPool() {
|
|
std::array poolSizes = {
|
|
vk::DescriptorPoolSize{vk::DescriptorType::eUniformBuffer, MAX_FRAMES_IN_FLIGHT},
|
|
vk::DescriptorPoolSize{vk::DescriptorType::eStorageBuffer, MAX_FRAMES_IN_FLIGHT * 2},
|
|
};
|
|
vk::DescriptorPoolCreateInfo poolInfo = {
|
|
.flags = vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet,
|
|
.maxSets = MAX_FRAMES_IN_FLIGHT,
|
|
.poolSizeCount = poolSizes.size(),
|
|
.pPoolSizes = poolSizes.data(),
|
|
};
|
|
descriptorPool = vk::raii::DescriptorPool(device, poolInfo);
|
|
}
|
|
void createComputeDescriptorSets() {
|
|
std::vector<vk::DescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, computeDescriptorSetLayout);
|
|
vk::DescriptorSetAllocateInfo allocInfo {
|
|
.descriptorPool = *descriptorPool,
|
|
.descriptorSetCount = MAX_FRAMES_IN_FLIGHT,
|
|
.pSetLayouts = layouts.data(),
|
|
};
|
|
computeDescriptorSets.clear();
|
|
computeDescriptorSets = device.allocateDescriptorSets(allocInfo);
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
|
|
vk::DescriptorBufferInfo bufferInfo {
|
|
.buffer = uniformBuffers[i],
|
|
.offset = 0,
|
|
.range = sizeof(UniformBufferObject),
|
|
};
|
|
vk::DescriptorBufferInfo storageBufferInfoLastFrame {
|
|
.buffer = shaderStorageBuffers[(i - 1) % MAX_FRAMES_IN_FLIGHT],
|
|
.offset = 0,
|
|
.range = sizeof(Particle) * PARTICLE_COUNT,
|
|
};
|
|
vk::DescriptorBufferInfo storageBufferInfoCurrentFrame {
|
|
.buffer = shaderStorageBuffers[i],
|
|
.offset = 0,
|
|
.range = sizeof(Particle) * PARTICLE_COUNT,
|
|
};
|
|
|
|
std::array descriptorWrites = {
|
|
vk::WriteDescriptorSet{
|
|
.dstSet = computeDescriptorSets[i],
|
|
.dstBinding = 0,
|
|
.dstArrayElement = 0,
|
|
.descriptorCount = 1,
|
|
.descriptorType = vk::DescriptorType::eUniformBuffer,
|
|
.pBufferInfo = &bufferInfo,
|
|
},
|
|
vk::WriteDescriptorSet{
|
|
.dstSet = computeDescriptorSets[i],
|
|
.dstBinding = 1,
|
|
.dstArrayElement = 0,
|
|
.descriptorCount = 1,
|
|
.descriptorType = vk::DescriptorType::eStorageBuffer,
|
|
.pBufferInfo = &storageBufferInfoLastFrame,
|
|
},
|
|
vk::WriteDescriptorSet{
|
|
.dstSet = computeDescriptorSets[i],
|
|
.dstBinding = 2,
|
|
.dstArrayElement = 0,
|
|
.descriptorCount = 1,
|
|
.descriptorType = vk::DescriptorType::eStorageBuffer,
|
|
.pBufferInfo = &storageBufferInfoCurrentFrame,
|
|
}
|
|
};
|
|
|
|
device.updateDescriptorSets(descriptorWrites, {});
|
|
}
|
|
}
|
|
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 createComputeCommandBuffers() {
|
|
computeCommandBuffers.clear();
|
|
vk::CommandBufferAllocateInfo allocInfo = {
|
|
.commandPool = commandPool,
|
|
.level = vk::CommandBufferLevel::ePrimary,
|
|
.commandBufferCount = MAX_FRAMES_IN_FLIGHT,
|
|
};
|
|
computeCommandBuffers = vk::raii::CommandBuffers(device, allocInfo);
|
|
}
|
|
void createSyncObjects() {
|
|
drawFences.clear();
|
|
|
|
vk::SemaphoreTypeCreateInfo semaphoreType {
|
|
.semaphoreType = vk::SemaphoreType::eTimeline,
|
|
.initialValue = 0,
|
|
};
|
|
semaphore = vk::raii::Semaphore(device, {.pNext = &semaphoreType});
|
|
timelineValue = 0;
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
|
|
vk::FenceCreateInfo fenceInfo {};
|
|
drawFences.emplace_back(device, fenceInfo);
|
|
}
|
|
}
|
|
void copyBufferToImage(const vk::raii::Buffer& buffer, vk::raii::Image& image, uint32_t width, uint32_t height) {
|
|
vk::raii::CommandBuffer commandBuffer = beginSingleTimeCommands();
|
|
vk::BufferImageCopy region {
|
|
.bufferOffset = 0,
|
|
.bufferRowLength = 0,
|
|
.bufferImageHeight = 0,
|
|
.imageSubresource = { vk::ImageAspectFlagBits::eColor, 0, 0, 1 },
|
|
.imageOffset = { 0, 0, 0 },
|
|
.imageExtent = { width, height, 1 }
|
|
};
|
|
commandBuffer.copyBufferToImage(buffer, image, vk::ImageLayout::eTransferDstOptimal, {region});
|
|
endSingleTimeCommands(commandBuffer);
|
|
}
|
|
void updateUniformBuffer(uint32_t currentImage) {
|
|
UniformBufferObject ubo {
|
|
.deltaTime = static_cast<float>(lastFrameTime) * 2.0f,
|
|
};
|
|
memcpy(unifromBuffersMapped[currentImage], &ubo, sizeof(ubo));
|
|
}
|
|
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
|
|
transitionRenderingImageLayout(
|
|
swapChainImages[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::ImageAspectFlagBits::eColor // aspectFlags
|
|
);
|
|
|
|
vk::ClearValue clearColor = vk::ClearColorValue(0.0f, 0.0f, 0.0f, 1.0f);
|
|
vk::RenderingAttachmentInfo colorAttachmentInfo = {
|
|
.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 = &colorAttachmentInfo,
|
|
};
|
|
|
|
commandBuffer.beginRendering(renderingInfo);
|
|
commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, graphicsPipeline);
|
|
commandBuffer.bindVertexBuffers(0, {shaderStorageBuffers[frameIndex]}, {0});
|
|
// 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(PARTICLE_COUNT, 1, 0, 0);
|
|
|
|
commandBuffer.endRendering();
|
|
|
|
// After rendering, transition the swapchain image to PRESENT_SRC
|
|
transitionRenderingImageLayout(
|
|
swapChainImages[imageIndex],
|
|
vk::ImageLayout::eColorAttachmentOptimal,
|
|
vk::ImageLayout::ePresentSrcKHR,
|
|
vk::AccessFlagBits2::eColorAttachmentWrite, // srcAccessMask
|
|
{}, // dstAccessMask
|
|
vk::PipelineStageFlagBits2::eColorAttachmentOutput, // srcStage
|
|
vk::PipelineStageFlagBits2::eBottomOfPipe, // dstStage
|
|
vk::ImageAspectFlagBits::eColor // aspectFlags
|
|
);
|
|
|
|
// Finish recording the command buffer
|
|
commandBuffer.end();
|
|
}
|
|
void recordComputeCommandBuffer() {
|
|
auto &commandBuffer = computeCommandBuffers[frameIndex];
|
|
commandBuffer.begin({});
|
|
commandBuffer.bindPipeline(vk::PipelineBindPoint::eCompute, computePipeline);
|
|
commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eCompute, computePipelineLayout,
|
|
0, {computeDescriptorSets[frameIndex]}, {});
|
|
commandBuffer.dispatch(PARTICLE_COUNT / 256, 1, 1);
|
|
commandBuffer.end();
|
|
}
|
|
void createBuffer(
|
|
vk::DeviceSize size,
|
|
vk::BufferUsageFlags usage,
|
|
vk::MemoryPropertyFlags properties,
|
|
vk::raii::Buffer &buffer,
|
|
vk::raii::DeviceMemory &bufferMemory
|
|
) {
|
|
vk::BufferCreateInfo bufferInfo = {
|
|
.size = size,
|
|
.usage = usage,
|
|
.sharingMode = vk::SharingMode::eExclusive,
|
|
};
|
|
buffer = vk::raii::Buffer(device, bufferInfo);
|
|
|
|
vk::MemoryRequirements memRequirements = buffer.getMemoryRequirements();
|
|
vk::MemoryAllocateInfo memAllocateInfo = {
|
|
.allocationSize = memRequirements.size,
|
|
.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties)
|
|
};
|
|
bufferMemory = vk::raii::DeviceMemory(device, memAllocateInfo);
|
|
buffer.bindMemory(bufferMemory, 0);
|
|
}
|
|
void copyBuffer(vk::raii::Buffer &srcBuffer, vk::raii::Buffer &dstBuffer, vk::DeviceSize size) {
|
|
vk::raii::CommandBuffer commandCopyBuffer = beginSingleTimeCommands();
|
|
commandCopyBuffer.copyBuffer(*srcBuffer, *dstBuffer, vk::BufferCopy(0, 0, size));
|
|
endSingleTimeCommands(commandCopyBuffer);
|
|
}
|
|
vk::raii::CommandBuffer beginSingleTimeCommands() {
|
|
vk::CommandBufferAllocateInfo allocInfo {
|
|
.commandPool = commandPool,
|
|
.level = vk::CommandBufferLevel::ePrimary,
|
|
.commandBufferCount = 1
|
|
};
|
|
vk::raii::CommandBuffer commandBuffer = std::move(device.allocateCommandBuffers(allocInfo).front());
|
|
|
|
vk::CommandBufferBeginInfo beginInfo{ .flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit };
|
|
commandBuffer.begin(beginInfo);
|
|
|
|
return commandBuffer;
|
|
}
|
|
bool hasStencilComponent(vk::Format format) {
|
|
return format == vk::Format::eD32SfloatS8Uint || format == vk::Format::eD24UnormS8Uint;
|
|
}
|
|
vk::Format findSupportedFormat(const std::vector<vk::Format>& candidates, vk::ImageTiling tiling,
|
|
vk::FormatFeatureFlags features) {
|
|
for (const auto format : candidates) {
|
|
vk::FormatProperties props = physicalDevice.getFormatProperties(format);
|
|
if (tiling == vk::ImageTiling::eLinear && (props.linearTilingFeatures & features) == features) {
|
|
return format;
|
|
}
|
|
if (tiling == vk::ImageTiling::eOptimal && (props.optimalTilingFeatures & features) == features) {
|
|
return format;
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("failed to find supported format!");
|
|
}
|
|
void endSingleTimeCommands(vk::raii::CommandBuffer& commandBuffer) {
|
|
commandBuffer.end();
|
|
|
|
vk::SubmitInfo submitInfo{ .commandBufferCount = 1, .pCommandBuffers = &*commandBuffer };
|
|
queue.submit(submitInfo, nullptr);
|
|
queue.waitIdle();
|
|
}
|
|
uint32_t findMemoryType(uint32_t typeFilter, vk::MemoryPropertyFlags properties) {
|
|
vk::PhysicalDeviceMemoryProperties memProperties = physicalDevice.getMemoryProperties();
|
|
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
|
|
if ((typeFilter & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("failed to find suitable memory type!");
|
|
}
|
|
void transitionImageLayout(const vk::raii::Image &image, vk::ImageLayout oldLayout,
|
|
vk::ImageLayout newLayout, uint32_t mipLevels) {
|
|
vk::raii::CommandBuffer commandBuffer = beginSingleTimeCommands();
|
|
|
|
vk::ImageMemoryBarrier barrier{
|
|
.oldLayout = oldLayout,
|
|
.newLayout = newLayout,
|
|
.image = image,
|
|
.subresourceRange = {
|
|
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
|
.baseMipLevel = 0,
|
|
.levelCount = mipLevels,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
}
|
|
};
|
|
|
|
vk::PipelineStageFlags sourceStage;
|
|
vk::PipelineStageFlags destinationStage;
|
|
|
|
if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eTransferDstOptimal)
|
|
{
|
|
barrier.srcAccessMask = {};
|
|
barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
|
|
|
|
sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;
|
|
destinationStage = vk::PipelineStageFlagBits::eTransfer;
|
|
}
|
|
else if (oldLayout == vk::ImageLayout::eTransferDstOptimal && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal)
|
|
{
|
|
barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
|
|
barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
|
|
|
|
sourceStage = vk::PipelineStageFlagBits::eTransfer;
|
|
destinationStage = vk::PipelineStageFlagBits::eFragmentShader;
|
|
}
|
|
else
|
|
{
|
|
throw std::invalid_argument("unsupported layout transition!");
|
|
}
|
|
|
|
commandBuffer.pipelineBarrier(sourceStage, destinationStage, {}, {}, nullptr, barrier);
|
|
endSingleTimeCommands(commandBuffer);
|
|
}
|
|
void transitionRenderingImageLayout(
|
|
vk::Image image,
|
|
vk::ImageLayout oldLayout,
|
|
vk::ImageLayout newLayout,
|
|
vk::AccessFlags2 srcAccessMask,
|
|
vk::AccessFlags2 dstAccessMask,
|
|
vk::PipelineStageFlags2 srcStageMask,
|
|
vk::PipelineStageFlags2 dstStageMask,
|
|
vk::ImageAspectFlags aspectFlags
|
|
) {
|
|
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 = image,
|
|
.subresourceRange = {
|
|
.aspectMask = aspectFlags,
|
|
.baseMipLevel = 0,
|
|
.levelCount = 1,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1
|
|
}
|
|
};
|
|
vk::DependencyInfo dependencyInfo = {
|
|
.dependencyFlags = {},
|
|
.imageMemoryBarrierCount = 1,
|
|
.pImageMemoryBarriers = &barrier
|
|
};
|
|
commandBuffers[frameIndex].pipelineBarrier2(dependencyInfo);
|
|
}
|
|
void cleanupSwapChain() {
|
|
swapChainImageViews.clear();
|
|
swapChain = nullptr;
|
|
}
|
|
void recreateSwapChain() {
|
|
int width = 0, height = 0;
|
|
glfwGetFramebufferSize(window, &width, &height);
|
|
while (width == 0 || height == 0) {
|
|
glfwGetFramebufferSize(window, &width, &height);
|
|
glfwWaitEvents();
|
|
}
|
|
|
|
device.waitIdle();
|
|
cleanupSwapChain();
|
|
createSwapChain();
|
|
createImageViews();
|
|
}
|
|
[[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 supports graphics, compute and present
|
|
uint32_t queueIndex = ~0;
|
|
for (uint32_t qfpIndex = 0; qfpIndex < queueFamilyProperties.size(); ++qfpIndex) {
|
|
if ((queueFamilyProperties[qfpIndex].queueFlags & vk::QueueFlagBits::eGraphics) &&
|
|
(queueFamilyProperties[qfpIndex].queueFlags & vk::QueueFlagBits::eCompute) &&
|
|
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;
|
|
}
|
|
vk::SampleCountFlagBits getMaxUsableSampleCount() {
|
|
vk::PhysicalDeviceProperties props = physicalDevice.getProperties();
|
|
vk::SampleCountFlags counts = props.limits.framebufferColorSampleCounts &
|
|
props.limits.framebufferDepthSampleCounts;
|
|
|
|
if (counts & vk::SampleCountFlagBits::e64) { return vk::SampleCountFlagBits::e64; }
|
|
if (counts & vk::SampleCountFlagBits::e32) { return vk::SampleCountFlagBits::e32; }
|
|
if (counts & vk::SampleCountFlagBits::e16) { return vk::SampleCountFlagBits::e16; }
|
|
if (counts & vk::SampleCountFlagBits::e8) { return vk::SampleCountFlagBits::e8; }
|
|
if (counts & vk::SampleCountFlagBits::e4) { return vk::SampleCountFlagBits::e4; }
|
|
if (counts & vk::SampleCountFlagBits::e2) { return vk::SampleCountFlagBits::e2; }
|
|
|
|
return vk::SampleCountFlagBits::e1;
|
|
}
|
|
|
|
uint32_t frameIndex = 0;
|
|
double lastFrameTime = 0.0;
|
|
double lastTime = 0.0;
|
|
bool framebufferResized = false;
|
|
GLFWwindow *window;
|
|
vk::raii::Context context;
|
|
vk::raii::Instance instance = nullptr;
|
|
vk::raii::PhysicalDevice physicalDevice = nullptr;
|
|
uint32_t graphicsComputeQueueIndex = ~0 ;
|
|
vk::raii::Device device = nullptr;
|
|
vk::raii::Queue queue = 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::DescriptorSetLayout computeDescriptorSetLayout = nullptr;
|
|
vk::raii::DescriptorPool descriptorPool = nullptr;
|
|
std::vector<vk::raii::DescriptorSet> computeDescriptorSets;
|
|
vk::raii::PipelineLayout graphicsPipelineLayout = nullptr;
|
|
vk::raii::Pipeline graphicsPipeline = nullptr;
|
|
vk::raii::PipelineLayout computePipelineLayout = nullptr;
|
|
vk::raii::Pipeline computePipeline = nullptr;
|
|
vk::raii::CommandPool commandPool = nullptr;
|
|
vk::raii::Semaphore semaphore = nullptr;
|
|
uint64_t timelineValue = 0;
|
|
std::vector<vk::raii::Buffer> shaderStorageBuffers;
|
|
std::vector<vk::raii::DeviceMemory> shaderStorageBuffersMemory;
|
|
std::vector<vk::raii::Buffer> uniformBuffers;
|
|
std::vector<vk::raii::DeviceMemory> uniformBuffersMemory;
|
|
std::vector<void *> unifromBuffersMapped;
|
|
std::vector<vk::raii::CommandBuffer> commandBuffers;
|
|
std::vector<vk::raii::CommandBuffer> computeCommandBuffers;
|
|
std::vector<vk::raii::Fence> drawFences;
|
|
};
|
|
|
|
int main() {
|
|
ComputeShaderApplication app;
|
|
|
|
try {
|
|
app.run();
|
|
} catch (const std::exception &e) {
|
|
std::cout << e.what() << std::endl;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|