#include "Volk/volk.h"

#define VMA_IMPLEMENTATION

#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1

#include "vma/vk_mem_alloc.h"

#define STB_IMAGE_IMPLEMENTATION

#include <stb_image.h>

#define TINYOBJLOADER_IMPLEMENTATION

#include <tiny_obj_loader.h>

#define GLFW_INCLUDE_VULKAN

#include <GLFW/glfw3.h>

#define GLM_FORCE_DEPTH_ZERO_TO_ONE

#define GLM_ENABLE_EXPERIMENTAL

#include <glm/glm.hpp>

#include <glm/ext.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <glm/gtx/hash.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>

#include <unordered_map>

const uint32_t WIDTH = 800;

const uint32_t HEIGHT = 600;

const std::string MODEL_PATH = "models/viking_room.obj";

const std::string TEXTURE_PATH = "textures/viking_room.png";

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::vec3 pos;

glm::vec3 color;

glm::vec2 texCoord;

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, 3> getAttributeDescriptions() {

std::array<VkVertexInputAttributeDescription2EXT, 3> 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_R32G32B32_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);

attributeDescriptions[2].sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;

attributeDescriptions[2].binding = 0;

attributeDescriptions[2].location = 2;

attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;

attributeDescriptions[2].offset = offsetof(Vertex, texCoord);

return attributeDescriptions;

}

bool operator==(const Vertex& other) const {

return pos == other.pos && color == other.color && texCoord == other.texCoord;

}

};

namespace std {

template<> struct hash<Vertex> {

size_t operator()(Vertex const& vertex) const {

return ((hash<glm::vec3>()(vertex.pos) ^ (hash<glm::vec3>()(vertex.color) << 1)) >> 1) ^ (hash<glm::vec2>()(vertex.texCoord) << 1);

}

};

}

struct UniformBufferObject {

glm::mat4 model;

glm::mat4 view;

glm::mat4 proj;

};

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;

VkSampleCountFlagBits msaaSamples = VK_SAMPLE_COUNT_1_BIT;

VkDevice device;

VmaAllocator allocator;

VkPhysicalDeviceDescriptorHeapPropertiesEXT descriptorHeapProperties{};

std::vector<VkBuffer> descriptorHeapResourcesBuffers;

std::vector<VmaAllocation> descriptorHeapResourcesAllocations;

VkBuffer descriptorHeapSamplerBuffer;

VmaAllocation descriptorHeapSamplerAllocation;

std::vector<VkDeviceAddress> descriptorHeapResourcesAddresses;

VkDeviceAddress descriptorHeapSamplerAddress{ 0 };

VkDeviceSize bufferDescriptorSize{ 0 };

VkDeviceSize samplerHeapOffset{ 0 };

VkDeviceSize samplerDescriptorSize{ 0 };

VkDeviceSize heapbufferSize{ 0 };

VkDeviceSize heapSamplerbufferSize{ 0 };

VkDeviceSize imageHeapOffset{ 0 };

VkDeviceSize imageDescriptorSize{ 0 };

VkQueue graphicsQueue;

VkQueue presentQueue;

VkSwapchainKHR swapChain;

std::vector<VkImage> swapChainImages;

VkFormat swapChainImageFormat;

VkExtent2D swapChainExtent;

std::vector<VkImageView> swapChainImageViews;

VkImage colorImage;

VmaAllocation colorImageAllocation;

VkImageView colorImageView;

VkImage depthImage;

VmaAllocation depthImageAllocation;

VkImageView depthImageView;

VkShaderEXT vertShader;

VkShaderEXT fragShader;

VkCommandPool commandPool;

std::vector<VkCommandBuffer> commandBuffers;

std::vector<Vertex> vertices;

std::vector<uint32_t> indices;

VkBuffer vertexBuffer;

VmaAllocation vertexAllocation;

VkBuffer indexBuffer;

VmaAllocation indexAllocation;

uint32_t mipLevels;

VkImage textureImage;

VmaAllocation textureImageAllocation;

std::vector<VkBuffer> uniformBuffers;

std::vector<VmaAllocation> uniformAllocations;

std::vector<void*> uniformBuffersMapped;

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();

createCommandPool();

createColorResources();

createDepthResources();

loadModel();

createVertexBuffer();

createIndexBuffer();

createTextureImage();

createUniformBuffers();

prepareDescriptorHeap();

prepareSamplerDescriptorHeap();

createShaderObjects();

createCommandBuffers();

createSyncObjects();

}

void mainLoop() {

while (!glfwWindowShouldClose(window)) {

glfwPollEvents();

drawFrame();

}

vkDeviceWaitIdle(device);

}

void cleanupSwapChain() {

// Depth image is sized to the swapchain extent, so it lives with the swapchain.

vkDestroyImageView(device, depthImageView, nullptr);

vmaDestroyImage(allocator, depthImage, depthImageAllocation);

vkDestroyImageView(device, colorImageView, nullptr);

vmaDestroyImage(allocator, colorImage, colorImageAllocation);

for (auto imageView : swapChainImageViews) {

vkDestroyImageView(device, imageView, nullptr);

}

vkDestroySwapchainKHR(device, swapChain, nullptr);

}

void cleanup() {

cleanupSwapChain();

vmaDestroyImage(allocator, textureImage, textureImageAllocation);

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]);

}

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

vmaDestroyBuffer(allocator, descriptorHeapResourcesBuffers[i], descriptorHeapResourcesAllocations[i]);

}

vmaDestroyBuffer(allocator, descriptorHeapSamplerBuffer, descriptorHeapSamplerAllocation);

vmaDestroyAllocator(allocator);

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

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

}

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

vkDestroySemaphore(device, renderFinishedSemaphores[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);

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();

createColorResources();

createDepthResources();

}

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;

msaaSamples = getMaxUsableSampleCount();

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.features.samplerAnisotropy = VK_TRUE;

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!");

}

// Load device-level entry points directly (skips the instance dispatch hop).

volkLoadDevice(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;

}

VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags, uint32_t mipLevels = 1) {

VkImageViewCreateInfo viewInfo{};

viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;

viewInfo.image = image;

viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;

viewInfo.format = format;

viewInfo.subresourceRange.aspectMask = aspectFlags;

viewInfo.subresourceRange.baseMipLevel = 0;

viewInfo.subresourceRange.levelCount = mipLevels;

viewInfo.subresourceRange.baseArrayLayer = 0;

viewInfo.subresourceRange.layerCount = 1;

VkImageView imageView;

if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) {

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

}

return imageView;

}

void createImageViews() {

swapChainImageViews.resize(swapChainImages.size());

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

swapChainImageViews[i] = createImageView(swapChainImages[i], swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT);

}

}

void createColorResources()

{

VkFormat colorFormat = swapChainImageFormat;

createImage(

swapChainExtent.width,

swapChainExtent.height,

1,

msaaSamples,

colorFormat,

VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,

colorImage,

colorImageAllocation

);

colorImageView = createImageView(colorImage, colorFormat, VK_IMAGE_ASPECT_COLOR_BIT);

// Dynamic rendering does not auto-transition attachments. The color image is never

// presented or sampled, so a single transition into the attachment layout suffices;

// it stays there across frames (per-frame loadOp = CLEAR resets contents, not layout).

VkCommandBuffer commandBuffer = beginSingleTimeCommands();

VkImageMemoryBarrier2 barrier{};

barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;

barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;

barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

barrier.image = colorImage;

barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

barrier.subresourceRange.baseMipLevel = 0;

barrier.subresourceRange.levelCount = 1;

barrier.subresourceRange.baseArrayLayer = 0;

barrier.subresourceRange.layerCount = 1;

barrier.srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;

barrier.srcAccessMask = 0;

barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;

barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;

VkDependencyInfo dependencyInfo{};

dependencyInfo.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;

dependencyInfo.imageMemoryBarrierCount = 1;

dependencyInfo.pImageMemoryBarriers = &barrier;

vkCmdPipelineBarrier2(commandBuffer, &dependencyInfo);

endSingleTimeCommands(commandBuffer);

}

void createDepthResources()

{

VkFormat depthFormat = findDepthFormat();

createImage(

swapChainExtent.width,

swapChainExtent.height,

1,

msaaSamples,

depthFormat,

VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,

depthImage,

depthImageAllocation

);

depthImageView = createImageView(depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);

// Dynamic rendering does not auto-transition attachments. The depth image is never

// presented or sampled, so a single transition into the attachment layout suffices;

// it stays there across frames (per-frame loadOp = CLEAR resets contents, not layout).

VkCommandBuffer commandBuffer = beginSingleTimeCommands();

VkImageMemoryBarrier2 barrier{};

barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;

barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;

barrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;

barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

barrier.image = depthImage;

barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;

barrier.subresourceRange.baseMipLevel = 0;

barrier.subresourceRange.levelCount = 1;

barrier.subresourceRange.baseArrayLayer = 0;

barrier.subresourceRange.layerCount = 1;

barrier.srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;

barrier.srcAccessMask = 0;

barrier.dstStageMask = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;

barrier.dstAccessMask = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT;

VkDependencyInfo dependencyInfo{};

dependencyInfo.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;

dependencyInfo.imageMemoryBarrierCount = 1;

dependencyInfo.pImageMemoryBarriers = &barrier;

vkCmdPipelineBarrier2(commandBuffer, &dependencyInfo);

endSingleTimeCommands(commandBuffer);

}

VkFormat findDepthFormat() {

return findSupportedFormat(

{ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT },

VK_IMAGE_TILING_OPTIMAL,

VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

);

}

bool hasStencilComponent(VkFormat format) {

return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;

}

VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) {

for (VkFormat format : candidates) {

VkFormatProperties props;

vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);

if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {

return format;

}

else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {

return format;

}

}

throw std::runtime_error("failed to find supported format!");

}

void prepareDescriptorHeap()

{

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

descriptorHeapResourcesAllocations.resize(MAX_FRAMES_IN_FLIGHT);

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!");

}

}

// Cache the per-frame heap device addresses (queried once, used every frame at bind time).

descriptorHeapResourcesAddresses.resize(MAX_FRAMES_IN_FLIGHT);

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

VkBufferDeviceAddressInfo heapAddrInfo{};

heapAddrInfo.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;

heapAddrInfo.buffer = descriptorHeapResourcesBuffers[i];

descriptorHeapResourcesAddresses[i] = vkGetBufferDeviceAddress(device, &heapAddrInfo);

}

// Image

imageHeapOffset = alignUp(uniformBuffers.size() * bufferDescriptorSize, descriptorHeapProperties.imageDescriptorAlignment);

imageDescriptorSize = alignUp(descriptorHeapProperties.imageDescriptorSize, descriptorHeapProperties.imageDescriptorAlignment);

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++) {

std::vector<VkHostAddressRangeEXT> hostAddressRangesResources;

std::vector<VkResourceDescriptorInfoEXT> resourceDescriptorInfos;

// Uniform buffer

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);

VkResourceDescriptorInfoEXT resourceDescriptorInfo = {};

resourceDescriptorInfo.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT;

resourceDescriptorInfo.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;

resourceDescriptorInfo.data = {};

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

resourceDescriptorInfos.push_back(resourceDescriptorInfo);

VkHostAddressRangeEXT hostAddressRangesResource = {};

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

hostAddressRangesResource.size = bufferDescriptorSize;

hostAddressRangesResources.push_back(hostAddressRangesResource);

// Image views

VkImageViewCreateInfo imageViewCreateInfo = {};

imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;

imageViewCreateInfo.image = textureImage;

imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;

imageViewCreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;

imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

imageViewCreateInfo.subresourceRange.baseMipLevel = 0;

imageViewCreateInfo.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;

imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;

imageViewCreateInfo.subresourceRange.layerCount = 1;

VkImageDescriptorInfoEXT imageDescriptorInfo = {};

imageDescriptorInfo.sType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT;

imageDescriptorInfo.pView = &imageViewCreateInfo;

imageDescriptorInfo.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

VkResourceDescriptorInfoEXT resourceImageDescriptorInfo = {};

resourceImageDescriptorInfo.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT;

resourceImageDescriptorInfo.type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;

resourceImageDescriptorInfo.data = {};

resourceImageDescriptorInfo.data.pImage = &imageDescriptorInfo;

resourceDescriptorInfos.push_back(resourceImageDescriptorInfo);

VkHostAddressRangeEXT hostAddressRangesResourceImage;

hostAddressRangesResourceImage = {};

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

hostAddressRangesResourceImage.size = imageDescriptorSize;

hostAddressRangesResources.push_back(hostAddressRangesResourceImage);

if (vkWriteResourceDescriptorsEXT(

device,

static_cast<uint32_t>(resourceDescriptorInfos.size()),

resourceDescriptorInfos.data(),

hostAddressRangesResources.data()

) != VK_SUCCESS) {

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

}

}

}

void prepareSamplerDescriptorHeap()

{

heapSamplerbufferSize = alignUp(2048 + descriptorHeapProperties.minSamplerHeapReservedRange, descriptorHeapProperties.samplerHeapAlignment);

samplerDescriptorSize = alignUp(descriptorHeapProperties.samplerDescriptorSize, descriptorHeapProperties.samplerDescriptorAlignment);

VkBufferCreateInfo bufferInfo{};

bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;

bufferInfo.size = heapSamplerbufferSize;

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;

VmaAllocationInfo allocResult;

if (vmaCreateBuffer(

allocator,

&bufferInfo,

&allocInfo,

&descriptorHeapSamplerBuffer,

&descriptorHeapSamplerAllocation,

&allocResult

) != VK_SUCCESS) {

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

}

// Cache the sampler heap device address (queried once, used every frame at bind time).

VkBufferDeviceAddressInfo samplerHeapAddrInfo{};

samplerHeapAddrInfo.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;

samplerHeapAddrInfo.buffer = descriptorHeapSamplerBuffer;

descriptorHeapSamplerAddress = vkGetBufferDeviceAddress(device, &samplerHeapAddrInfo);

VkSamplerCreateInfo samplerInfo{};

samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;

samplerInfo.magFilter = VK_FILTER_LINEAR;

samplerInfo.minFilter = VK_FILTER_LINEAR;

samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;

samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;

samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;

samplerInfo.anisotropyEnable = VK_TRUE;

samplerInfo.maxAnisotropy = 1.0f;

VkPhysicalDeviceProperties properties{};

vkGetPhysicalDeviceProperties(physicalDevice, &properties);

samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;

samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;

samplerInfo.unnormalizedCoordinates = VK_FALSE;

samplerInfo.compareEnable = VK_FALSE;

samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;

samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;

samplerInfo.mipLodBias = 0.0f;

samplerInfo.minLod = 0.0f;

samplerInfo.maxLod = VK_REMAINING_MIP_LEVELS;

VkHostAddressRangeEXT hostAddressRangesSamplers = {};

hostAddressRangesSamplers.address = static_cast<uint8_t*>(allocResult.pMappedData);

hostAddressRangesSamplers.size = samplerDescriptorSize;

// For multiple textures:

// hostAddressRangesSamplers.address = static_cast<uint8_t*>(allocResult.pMappedData) + samplerDescriptorSize * i

if (vkWriteSamplerDescriptorsEXT(

device,

1,

&samplerInfo,

&hostAddressRangesSamplers

) != VK_SUCCESS) {

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

}

}

void createShaderObjects() {

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 loadModel() {

tinyobj::attrib_t attrib;

std::vector<tinyobj::shape_t> shapes;

std::vector<tinyobj::material_t> materials;

std::string err;

std::string war;

if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &war, &err, MODEL_PATH.c_str())) {

throw std::runtime_error(err);