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

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

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;

}

};

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}, {1.0f, 0.0f}},

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

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

{{-0.5f, 0.5f}, {1.0f, 1.0f, 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;

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;

VkShaderEXT vertShader;

VkShaderEXT fragShader;

VkCommandPool commandPool;

std::vector<VkCommandBuffer> commandBuffers;

VkBuffer vertexBuffer;

VmaAllocation vertexAllocation;

VkBuffer indexBuffer;

VmaAllocation indexAllocation;

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

createVertexBuffer();

createIndexBuffer();

createTextureImage();

createUniformBuffers();

prepareDescriptorHeap();

prepareSamplerDescriptorHeap();

createShaderObjects();

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

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

}

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

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 = VK_IMAGE_ASPECT_COLOR_BIT;

viewInfo.subresourceRange.baseMipLevel = 0;

viewInfo.subresourceRange.levelCount = 1;

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

}

}

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 = 1;

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 = 0.0f;

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

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

);

void* data = nullptr;

vmaMapMemory(allocator, stagingAllocation, &data);

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

vmaUnmapMemory(allocator, stagingAllocation);

createBuffer(

bufferSize,

VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,

VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,

0,//VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,

0,

vertexBuffer,

vertexAllocation

);

copyBuffer(stagingBuffer, vertexBuffer, bufferSize);

vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);

}

void createIndexBuffer()

{

VkBuffer stagingBuffer;

VmaAllocation stagingAllocation;

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

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

);

void* data = nullptr;

vmaMapMemory(allocator, stagingAllocation, &data);

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

vmaUnmapMemory(allocator, stagingAllocation);

createBuffer(

bufferSize,

VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,

VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,

0,

0,

indexBuffer,

indexAllocation

);

copyBuffer(stagingBuffer, indexBuffer, bufferSize);

vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);

}

void createImage(

uint32_t width,

uint32_t height,

VkFormat format,

VkImageUsageFlags usage,

VkImage& image,

VmaAllocation& allocation

) {

VkImageCreateInfo imageInfo{};

imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;

imageInfo.imageType = VK_IMAGE_TYPE_2D;

imageInfo.extent.width = width;

imageInfo.extent.height = height;

imageInfo.extent.depth = 1;

imageInfo.mipLevels = 1;

imageInfo.arrayLayers = 1;

imageInfo.format = format;

imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;

imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

imageInfo.usage = usage;

imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;

imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

VmaAllocationCreateInfo allocInfo{};

allocInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;

if (vmaCreateImage(

allocator,

&imageInfo,

&allocInfo,

&image,

&allocation,

nullptr

) != VK_SUCCESS) {

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

}

}

void createTextureImage() {

int texWidth, texHeight, texChannels;

stbi_uc* pixels = stbi_load("textures/texture.jpg", &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);

VkDeviceSize imageSize = texWidth * texHeight * 4;

if (!pixels) {

throw std::runtime_error("failed to load texture image!");

}

VkBuffer stagingBuffer;

VmaAllocation stagingAllocation;

createBuffer(

imageSize,

VK_BUFFER_USAGE_TRANSFER_SRC_BIT,

VMA_MEMORY_USAGE_AUTO,

VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,

0,

stagingBuffer,

stagingAllocation

);

void* data = nullptr;

vmaMapMemory(allocator, stagingAllocation, &data);

memcpy(data, pixels, imageSize);

vmaUnmapMemory(allocator, stagingAllocation);