#include "Volk/volk.h"

#define VMA_IMPLEMENTATION

#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1

#include "vma/vk_mem_alloc.h"

#define GLFW_INCLUDE_VULKAN

#include <GLFW/glfw3.h>

#include <glm/glm.hpp>

#include <glm/ext.hpp>

#include <iostream>

#include <fstream>

#include <stdexcept>

#include <algorithm>

#include <vector>

#include <cstring>

#include <cstdlib>

#include <cstdint>

#include <limits>

#include <array>

#include <optional>

#include <set>

#include <chrono>

const uint32_t WIDTH = 800;

const uint32_t HEIGHT = 600;

const int MAX_FRAMES_IN_FLIGHT = 2;

const std::vector<const char*> validationLayers = {

"VK_LAYER_KHRONOS_validation"

};

const std::vector<const char*> deviceExtensions = {

VK_KHR_SWAPCHAIN_EXTENSION_NAME,

VK_EXT_SHADER_OBJECT_EXTENSION_NAME,

VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME,

VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME,

VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME,

VK_KHR_MAINTENANCE_5_EXTENSION_NAME,

};

#ifdef NDEBUG

const bool enableValidationLayers = false;

#else

const bool enableValidationLayers = true;

#endif

VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {

auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");

if (func != nullptr) {

return func(instance, pCreateInfo, pAllocator, pDebugMessenger);

}

else {

return VK_ERROR_EXTENSION_NOT_PRESENT;

}

}

void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {

auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");

if (func != nullptr) {

func(instance, debugMessenger, pAllocator);

}

}

struct QueueFamilyIndices {

std::optional<uint32_t> graphicsFamily;

std::optional<uint32_t> presentFamily;

bool isComplete() {

return graphicsFamily.has_value() && presentFamily.has_value();

}

};

struct SwapChainSupportDetails {

VkSurfaceCapabilitiesKHR capabilities;

std::vector<VkSurfaceFormatKHR> formats;

std::vector<VkPresentModeKHR> presentModes;

};

struct Vertex {

glm::vec2 pos;

glm::vec3 color;

static VkVertexInputBindingDescription2EXT getBindingDescription() {

VkVertexInputBindingDescription2EXT bindingDescription{};

bindingDescription.sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT;

bindingDescription.binding = 0;

bindingDescription.stride = sizeof(Vertex);

bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;

bindingDescription.divisor = 1;

return bindingDescription;

}

static std::array<VkVertexInputAttributeDescription2EXT, 2> getAttributeDescriptions() {

std::array<VkVertexInputAttributeDescription2EXT, 2> attributeDescriptions{};

attributeDescriptions[0].sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;

attributeDescriptions[0].binding = 0;

attributeDescriptions[0].location = 0;

attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;

attributeDescriptions[0].offset = offsetof(Vertex, pos);

attributeDescriptions[1].sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;

attributeDescriptions[1].binding = 0;

attributeDescriptions[1].location = 1;

attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;

attributeDescriptions[1].offset = offsetof(Vertex, color);

return attributeDescriptions;

}

};

struct UniformBufferObject {

glm::mat4 model;

glm::mat4 view;

glm::mat4 proj;

};

const std::vector<Vertex> vertices = {

{{-0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}},

{{0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}},

{{0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}},

{{-0.5f, 0.5f}, {1.0f, 1.0f, 1.0f}}

};

const std::vector<uint16_t> indices = {

0, 1, 2, 2, 3, 0

};

inline VkDeviceSize alignUp(VkDeviceSize size, VkDeviceSize alignment) {

return (size + alignment - 1) & ~(alignment - 1);

}

class HelloTriangleApplication {

public:

void run() {

volkInitialize();

initWindow();

initVulkan();

mainLoop();

cleanup();

}

private:

GLFWwindow* window;

VkInstance instance;

VkDebugUtilsMessengerEXT debugMessenger;

VkSurfaceKHR surface;

VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;

VkDevice device;

VmaAllocator allocator;

VkPhysicalDeviceDescriptorHeapPropertiesEXT descriptorHeapProperties{};

std::vector<VkBuffer> descriptorHeapResourcesBuffers;

std::vector<VmaAllocation> descriptorHeapResourcesAllocations;

VkDeviceSize bufferHeapOffset{ 0 };

VkDeviceSize bufferDescriptorSize{ 0 };

VkDeviceSize heapbufferSize;

VkQueue graphicsQueue;

VkQueue presentQueue;

VkSwapchainKHR swapChain;

std::vector<VkImage> swapChainImages;

VkFormat swapChainImageFormat;

VkExtent2D swapChainExtent;

std::vector<VkImageView> swapChainImageViews;

VkShaderEXT vertShader;

VkShaderEXT fragShader;

VkCommandPool commandPool;

std::vector<VkCommandBuffer> commandBuffers;

VkBuffer vertexBuffer;

VmaAllocation vertexAllocation;

VkBuffer indexBuffer;

VmaAllocation indexAllocation;

std::vector<VkBuffer> uniformBuffers;

std::vector<VmaAllocation> uniformAllocations;

std::vector<VkSemaphore> imageAvailableSemaphores;

std::vector<VkSemaphore> renderFinishedSemaphores;

VkSemaphore timelineSemaphore;

uint64_t timelineValue = 0;

uint32_t currentFrame = 0;

bool framebufferResized = false;

void initWindow() {

glfwInit();

glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);

glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);

glfwSetWindowUserPointer(window, this);

glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);

}

static void framebufferResizeCallback(GLFWwindow* window, int width, int height) {

auto app = reinterpret_cast<HelloTriangleApplication*>(glfwGetWindowUserPointer(window));

app->framebufferResized = true;

}

void initVulkan() {

createInstance();

setupDebugMessenger();

createSurface();

pickPhysicalDevice();

createLogicalDevice();

createVMA();

createSwapChain();

createImageViews();

createGraphicsPipeline();

createCommandPool();

createVertexBuffer();

createIndexBuffer();

createUniformBuffers();

prepareDescriptorHeap();

createCommandBuffers();

createSyncObjects();

}

void mainLoop() {

while (!glfwWindowShouldClose(window)) {

glfwPollEvents();

drawFrame();

}

vkDeviceWaitIdle(device);

}

void cleanupSwapChain() {

for (auto imageView : swapChainImageViews) {

vkDestroyImageView(device, imageView, nullptr);

}

vkDestroySwapchainKHR(device, swapChain, nullptr);

}

void cleanup() {

cleanupSwapChain();

vmaDestroyBuffer(allocator, vertexBuffer, vertexAllocation);

vmaDestroyBuffer(allocator, indexBuffer, indexAllocation);

for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {

vmaDestroyBuffer(allocator, uniformBuffers[i], uniformAllocations[i]);

}

vmaDestroyAllocator(allocator);

for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {

vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);

vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);

}

vkDestroySemaphore(device, timelineSemaphore, nullptr);

vkDestroyCommandPool(device, commandPool, nullptr);

vkDestroyShaderEXT(device, fragShader, nullptr);

vkDestroyShaderEXT(device, vertShader, nullptr);

vkDestroyDevice(device, nullptr);

if (enableValidationLayers) {

DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);

}

vkDestroySurfaceKHR(instance, surface, nullptr);

vkDestroySurfaceKHR(instance, surface, nullptr);

vkDestroyInstance(instance, nullptr);

glfwDestroyWindow(window);

glfwTerminate();

}

void recreateSwapChain() {

int width = 0, height = 0;

glfwGetFramebufferSize(window, &width, &height);

while (width == 0 || height == 0) {

glfwGetFramebufferSize(window, &width, &height);

glfwWaitEvents();

}

vkDeviceWaitIdle(device);

cleanupSwapChain();

createSwapChain();

createImageViews();

}

void createInstance() {

if (enableValidationLayers && !checkValidationLayerSupport()) {

throw std::runtime_error("validation layers requested, but not available!");

}

VkApplicationInfo appInfo{};

appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

appInfo.pApplicationName = "Hello Triangle";

appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);

appInfo.pEngineName = "No Engine";

appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);

appInfo.apiVersion = VK_API_VERSION_1_3;

VkInstanceCreateInfo createInfo{};

createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

createInfo.pApplicationInfo = &appInfo;

auto extensions = getRequiredExtensions();

createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());

createInfo.ppEnabledExtensionNames = extensions.data();

VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};

if (enableValidationLayers) {

createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());

createInfo.ppEnabledLayerNames = validationLayers.data();

populateDebugMessengerCreateInfo(debugCreateInfo);

createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo;

}

else {

createInfo.enabledLayerCount = 0;

createInfo.pNext = nullptr;

}

if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {

throw std::runtime_error("failed to create instance!");

}

volkLoadInstance(instance);

}

void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {

createInfo = {};

createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;

createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;

createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;

createInfo.pfnUserCallback = debugCallback;

}

void setupDebugMessenger() {

if (!enableValidationLayers) return;

VkDebugUtilsMessengerCreateInfoEXT createInfo;

populateDebugMessengerCreateInfo(createInfo);

if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {

throw std::runtime_error("failed to set up debug messenger!");

}

}

void createSurface() {

if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {

throw std::runtime_error("failed to create window surface!");

}

}

void pickPhysicalDevice() {

uint32_t deviceCount = 0;

vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

if (deviceCount == 0) {

throw std::runtime_error("failed to find GPUs with Vulkan support!");

}

std::vector<VkPhysicalDevice> devices(deviceCount);

vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());

for (const auto& device : devices) {

if (isDeviceSuitable(device)) {

physicalDevice = device;

break;

}

}

if (physicalDevice == VK_NULL_HANDLE) {

throw std::runtime_error("failed to find a suitable GPU!");

}

// Get physical device properties

descriptorHeapProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT;

VkPhysicalDeviceProperties2 props{};

props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;

props.pNext = &descriptorHeapProperties;

vkGetPhysicalDeviceProperties2(physicalDevice, &props);

bufferDescriptorSize = alignUp(descriptorHeapProperties.bufferDescriptorSize, descriptorHeapProperties.bufferDescriptorAlignment);

}

void createLogicalDevice() {

QueueFamilyIndices indices = findQueueFamilies(physicalDevice);

std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;

std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };

float queuePriority = 1.0f;

for (uint32_t queueFamily : uniqueQueueFamilies) {

VkDeviceQueueCreateInfo queueCreateInfo{};

queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;

queueCreateInfo.queueFamilyIndex = queueFamily;

queueCreateInfo.queueCount = 1;

queueCreateInfo.pQueuePriorities = &queuePriority;

queueCreateInfos.push_back(queueCreateInfo);

}

VkPhysicalDeviceShaderObjectFeaturesEXT shaderObjectFeatures{};

shaderObjectFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;

shaderObjectFeatures.pNext = nullptr;

shaderObjectFeatures.shaderObject = VK_TRUE;

VkPhysicalDeviceFeatures2 deviceFeatures2{};

deviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;

deviceFeatures2.pNext = &shaderObjectFeatures;

VkPhysicalDeviceVulkan12Features vulkan12Features{};

vulkan12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;

vulkan12Features.timelineSemaphore = VK_TRUE;

vulkan12Features.bufferDeviceAddress = VK_TRUE;

vulkan12Features.pNext = &deviceFeatures2;

VkPhysicalDeviceVulkan13Features vulkan13Features{};

vulkan13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;

vulkan13Features.synchronization2 = VK_TRUE;

vulkan13Features.dynamicRendering = VK_TRUE;

vulkan13Features.pNext = &vulkan12Features;

VkPhysicalDeviceDescriptorHeapFeaturesEXT descriptorHeapFeatures{};

descriptorHeapFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT;

descriptorHeapFeatures.descriptorHeap = VK_TRUE;

descriptorHeapFeatures.pNext = &vulkan13Features;

VkPhysicalDeviceMaintenance5Features maintenance5Features{};

maintenance5Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;

maintenance5Features.maintenance5 = VK_TRUE;

maintenance5Features.pNext = &descriptorHeapFeatures;

VkPhysicalDeviceShaderUntypedPointersFeaturesKHR untypedPointersFeatures{};

untypedPointersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;

untypedPointersFeatures.pNext = &maintenance5Features;

untypedPointersFeatures.shaderUntypedPointers = VK_TRUE;

VkDeviceCreateInfo createInfo{};

createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());

createInfo.pQueueCreateInfos = queueCreateInfos.data();

createInfo.pNext = &maintenance5Features;

createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());

createInfo.ppEnabledExtensionNames = deviceExtensions.data();

if (enableValidationLayers) {

createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());

createInfo.ppEnabledLayerNames = validationLayers.data();

}

else {

createInfo.enabledLayerCount = 0;

}

if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {

throw std::runtime_error("failed to create logical device!");

}

vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);

vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);

}

void createVMA()

{

VmaVulkanFunctions funcs{};

funcs.vkGetInstanceProcAddr = vkGetInstanceProcAddr;

funcs.vkGetDeviceProcAddr = vkGetDeviceProcAddr;

VmaAllocatorCreateInfo allocatorInfo{};

allocatorInfo.physicalDevice = physicalDevice;

allocatorInfo.device = device;

allocatorInfo.instance = instance;

allocatorInfo.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;

allocatorInfo.pVulkanFunctions = &funcs;

allocatorInfo.vulkanApiVersion = VK_API_VERSION_1_3;

if (vmaCreateAllocator(&allocatorInfo, &allocator) != VK_SUCCESS) {

throw std::runtime_error("failed to create vma allocator!");

}

}

void createSwapChain() {

SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);

VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);

VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);

VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);

uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;

if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {

imageCount = swapChainSupport.capabilities.maxImageCount;

}

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 = findQueueFamilies(physicalDevice);

uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };

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 = swapChainSupport.capabilities.currentTransform;

createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

createInfo.presentMode = presentMode;

createInfo.clipped = VK_TRUE;

createInfo.oldSwapchain = VK_NULL_HANDLE;

if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {

throw std::runtime_error("failed to create swap chain!");

}

vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);

swapChainImages.resize(imageCount);

vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());

swapChainImageFormat = surfaceFormat.format;

swapChainExtent = extent;

}

void createImageViews() {

swapChainImageViews.resize(swapChainImages.size());

for (size_t i = 0; i < swapChainImages.size(); i++) {

VkImageViewCreateInfo createInfo{};

createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;

createInfo.image = swapChainImages[i];

createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;

createInfo.format = swapChainImageFormat;

createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

createInfo.subresourceRange.baseMipLevel = 0;

createInfo.subresourceRange.levelCount = 1;

createInfo.subresourceRange.baseArrayLayer = 0;

createInfo.subresourceRange.layerCount = 1;

if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) {

throw std::runtime_error("failed to create image views!");

}

}

}

void prepareDescriptorHeap()

{

heapbufferSize = alignUp(2048 + descriptorHeapProperties.minResourceHeapReservedRange, descriptorHeapProperties.resourceHeapAlignment);

descriptorHeapResourcesAllocations.resize(2);

descriptorHeapResourcesBuffers.resize(MAX_FRAMES_IN_FLIGHT);

std::vector<VmaAllocationInfo> allocResult{};

allocResult.resize(MAX_FRAMES_IN_FLIGHT);

for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)

{

VkBufferCreateInfo bufferInfo{};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = heapbufferSize;

bufferInfo.usage = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;

VmaAllocationCreateInfo allocInfo{};

allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;

allocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT;

allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&descriptorHeapResourcesBuffers[i],

&descriptorHeapResourcesAllocations[i],

&allocResult[i]

) != VK_SUCCESS) {

throw std::runtime_error("failed to create resource descriptor heap!");

}

}

size_t heapResIndex{ 0 };

std::array<VkBufferDeviceAddressInfo, MAX_FRAMES_IN_FLIGHT> addrInfo{};

std::array<VkDeviceAddressRangeEXT, MAX_FRAMES_IN_FLIGHT> deviceAddressRangesUniformBuffer{};

for (auto i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {

VkHostAddressRangeEXT hostAddressRangesResources;

VkResourceDescriptorInfoEXT resourceDescriptorInfos;

addrInfo[i].sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,

addrInfo[i].buffer = uniformBuffers[i];

deviceAddressRangesUniformBuffer[i] = {};

deviceAddressRangesUniformBuffer[i].address = vkGetBufferDeviceAddress(device, &addrInfo[i]);

deviceAddressRangesUniformBuffer[i].size = sizeof(UniformBufferObject);

resourceDescriptorInfos = {};

resourceDescriptorInfos.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT;

resourceDescriptorInfos.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;

resourceDescriptorInfos.data = {};

resourceDescriptorInfos.data.pAddressRange = &deviceAddressRangesUniformBuffer[i];

hostAddressRangesResources = {};

hostAddressRangesResources.address = static_cast<uint8_t*>(allocResult[i].pMappedData);

hostAddressRangesResources.size = bufferDescriptorSize;

heapResIndex++;

if (vkWriteResourceDescriptorsEXT(

device,

1,

&resourceDescriptorInfos,

&hostAddressRangesResources

) != VK_SUCCESS) {

throw std::runtime_error("failed to write resource descriptors!");

}

}

}

void createGraphicsPipeline() {

auto vertShaderCode = readFile("shaders/vert.spv");

auto fragShaderCode = readFile("shaders/frag.spv");

vertShader = createShaderObject(vertShaderCode, VK_SHADER_STAGE_VERTEX_BIT);

fragShader = createShaderObject(fragShaderCode, VK_SHADER_STAGE_FRAGMENT_BIT);

return;

}

void createBuffer(

VkDeviceSize size,

VkBufferUsageFlags usage,

VmaMemoryUsage vmaUsage,

VmaAllocationCreateFlags vmaFlags,

VkMemoryPropertyFlags requiredFlags,

VkBuffer& buffer,

VmaAllocation& bufferAllocation,

VmaAllocationInfo* outAllocResult = 0

) {

if (size == 0) {

throw std::runtime_error("Vertex buffer size is 0!");

}

VkBufferCreateInfo bufferInfo{};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = size;

bufferInfo.usage = usage;

VmaAllocationCreateInfo allocInfo{};

allocInfo.usage = vmaUsage;

allocInfo.flags = vmaFlags;

allocInfo.requiredFlags = requiredFlags;

VmaAllocationInfo* allocDst = outAllocResult ? outAllocResult : nullptr;

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&buffer,

&bufferAllocation,

allocDst

) != VK_SUCCESS) {

throw std::runtime_error("failed to create buffer!");

}

}

void createVertexBuffer()

{

VkBuffer stagingBuffer;

VmaAllocation stagingAllocation;

VkDeviceSize bufferSize = sizeof(Vertex) * vertices.size();

VmaAllocationInfo stagingResult{};

createBuffer(

bufferSize,

VK_BUFFER_USAGE_TRANSFER_SRC_BIT,

VMA_MEMORY_USAGE_AUTO_PREFER_HOST,

VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,

0,

stagingBuffer,

stagingAllocation,

&stagingResult

);

void* data = nullptr;

vmaMapMemory(allocator, stagingAllocation, &data);

memcpy(data, vertices.data(), bufferSize);

vmaUnmapMemory(allocator, stagingAllocation);

VmaAllocationInfo allocResult{};

createBuffer(

bufferSize,

VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,

VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,

VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,

VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

vertexBuffer,

vertexAllocation,

&allocResult

);

copyBuffer(stagingBuffer, vertexBuffer, stagingResult.size);

vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);

}

void createIndexBuffer()

{

VkBuffer stagingBuffer;

VmaAllocation stagingAllocation;

VkBufferCreateInfo bufferInfo{};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = sizeof(indices[0]) * indices.size();

bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

VmaAllocationCreateInfo allocInfo{};

allocInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_HOST;

allocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;

allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;

VmaAllocationInfo allocResult{};

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&stagingBuffer,

&stagingAllocation,

&allocResult

) != VK_SUCCESS) {

throw std::runtime_error("failed to create staging buffer!");

}

void* data = nullptr;

vmaMapMemory(allocator, stagingAllocation, &data);

memcpy(data, indices.data(), bufferInfo.size);

vmaUnmapMemory(allocator, stagingAllocation);

bufferInfo = {};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = sizeof(indices[0]) * indices.size();

bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT;

allocInfo = {};

allocInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;

allocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;

allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;

VmaAllocationInfo stagingAllocResult = {};

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&indexBuffer,

&indexAllocation,

&stagingAllocResult

) != VK_SUCCESS) {

throw std::runtime_error("failed to create index buffer!");

}

copyBuffer(stagingBuffer, indexBuffer, allocResult.size);

vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);

}

void createUniformBuffers()

{

VkBufferCreateInfo bufferInfo{};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = sizeof(UniformBufferObject);

bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |

VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;

VmaAllocationCreateInfo allocInfo{};

allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; // CPU can map and write

allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);

uniformAllocations.resize(MAX_FRAMES_IN_FLIGHT);

for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {

VmaAllocationInfo allocResult{};

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&uniformBuffers[i],

&uniformAllocations[i],

&allocResult

) != VK_SUCCESS) {

throw std::runtime_error("failed to create staging buffer!");

}

}

}

void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {

VkCommandBufferAllocateInfo allocInfo{};

allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;

allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;

allocInfo.commandPool = commandPool;

allocInfo.commandBufferCount = 1;

VkCommandBuffer commandBuffer;

vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);

VkCommandBufferBeginInfo beginInfo{};

beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;

vkBeginCommandBuffer(commandBuffer, &beginInfo);

VkBufferCopy copyRegion{};

copyRegion.size = size;

vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);

vkEndCommandBuffer(commandBuffer);

VkSubmitInfo submitInfo{};

submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &commandBuffer;

vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);

vkQueueWaitIdle(graphicsQueue);

vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);

}

void createCommandPool() {

QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);

VkCommandPoolCreateInfo poolInfo{};

poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;

poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();

if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) {

throw std::runtime_error("failed to create command pool!");

}

}

void createCommandBuffers() {

commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);

VkCommandBufferAllocateInfo allocInfo{};

allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;

allocInfo.commandPool = commandPool;

allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;

allocInfo.commandBufferCount = (uint32_t)commandBuffers.size();

if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {

throw std::runtime_error("failed to allocate command buffers!");

}

}

void setInitialRenderingState(VkCommandBuffer commandBuffer) {

vkCmdSetCullModeEXT(commandBuffer, VK_CULL_MODE_NONE);

vkCmdSetDepthWriteEnable(commandBuffer, VK_FALSE);

vkCmdSetPolygonModeEXT(commandBuffer, VK_POLYGON_MODE_FILL);

vkCmdSetStencilTestEnable(commandBuffer, VK_FALSE);

vkCmdSetDepthBiasEnable(commandBuffer, VK_FALSE);

vkCmdSetPrimitiveTopology(commandBuffer, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);

vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, VK_FALSE);

vkCmdSetRasterizationSamplesEXT(commandBuffer, VK_SAMPLE_COUNT_1_BIT);

vkCmdSetDepthTestEnable(commandBuffer, VK_TRUE);

vkCmdSetDepthCompareOp(commandBuffer, VK_COMPARE_OP_GREATER);

vkCmdSetDepthBoundsTestEnable(commandBuffer, VK_FALSE);

vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, VK_FALSE);

const VkSampleMask sample_mask = 0x1;

vkCmdSetSampleMaskEXT(commandBuffer, VK_SAMPLE_COUNT_1_BIT, &sample_mask);

vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, VK_FALSE);

VkColorComponentFlags color_component_flags[] = { VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_A_BIT };

vkCmdSetColorWriteMaskEXT(commandBuffer, 0, 1, color_component_flags);

VkBool32 color_blend_enables[] = { VK_FALSE };

vkCmdSetColorBlendEnableEXT(commandBuffer, 0, 1, color_blend_enables);

vkCmdSetVertexInputEXT(commandBuffer, 0, nullptr, 0, nullptr);

}

void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {

VkCommandBufferBeginInfo beginInfo{};

beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

beginInfo.flags = 0; // Optional

beginInfo.pInheritanceInfo = nullptr; // Optional

if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {

throw std::runtime_error("failed to begin recording command buffer!");

}

// Transition swapchain image layout for optimal drawing

VkImageMemoryBarrier2 barrier{};

barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;

barrier.srcStageMask = VK_PIPELINE_STAGE_2_NONE;

barrier.srcAccessMask = 0;

barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;

barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;

barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; // or PRESENT_SRC_KHR

barrier.newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;

barrier.image = swapChainImages[imageIndex];

barrier.subresourceRange = {

VK_IMAGE_ASPECT_COLOR_BIT,

0, 1, 0, 1

};

VkDependencyInfo dep{};

dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;

dep.imageMemoryBarrierCount = 1;

dep.pImageMemoryBarriers = &barrier;

vkCmdPipelineBarrier2(commandBuffer, &dep);

VkRenderingAttachmentInfo colorAttachment{};

colorAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;

colorAttachment.imageView = swapChainImageViews[imageIndex];

colorAttachment.imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;

colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;

colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;

colorAttachment.clearValue = { { 0.0f, 0.0f, 0.0f, 1.0f } };

VkRenderingInfo renderingInfo{};

renderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;

renderingInfo.renderArea = { {0, 0}, swapChainExtent };

renderingInfo.layerCount = 1;

renderingInfo.colorAttachmentCount = 1;

renderingInfo.pColorAttachments = &colorAttachment;

vkCmdBeginRendering(commandBuffer, &renderingInfo);

{

setInitialRenderingState(commandBuffer);

vkCmdSetVertexInputEXT(commandBuffer,

1, &Vertex::getBindingDescription(),

Vertex::getAttributeDescriptions().size(), Vertex::getAttributeDescriptions().data()

);

VkShaderStageFlagBits stages[] = {

VK_SHADER_STAGE_VERTEX_BIT,

VK_SHADER_STAGE_FRAGMENT_BIT

};

VkShaderEXT shaders[] = {

vertShader,

fragShader

};

vkCmdBindShadersEXT(commandBuffer, 2, stages, shaders);

VkBuffer vertexBuffers[] = { vertexBuffer };

VkDeviceSize offsets[] = { 0 };

vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);

vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT16);

uint32_t pushconstants = currentFrame;

VkPushDataInfoEXT pushDataInfo{};

pushDataInfo.sType = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT;

pushDataInfo.data.address = &pushconstants;

pushDataInfo.data.size = sizeof(uint32_t);