{

glm::vec3 pos;

glm::vec3 color;

glm::vec2 texCoord;

static vk::VertexInputBindingDescription getBindingDescription()

{

return {.binding = 0, .stride = sizeof(Vertex), .inputRate = vk::VertexInputRate::eVertex};

}

static std::array<vk::VertexInputAttributeDescription, 3> getAttributeDescriptions()

{

return {{{.location = 0, .binding = 0, .format = vk::Format::eR32G32B32Sfloat, .offset = offsetof(Vertex, pos)},

{.location = 1, .binding = 0, .format = vk::Format::eR32G32B32Sfloat, .offset = offsetof(Vertex, color)},

{.location = 2, .binding = 0, .format = vk::Format::eR32G32Sfloat, .offset = offsetof(Vertex, texCoord)}}};

}

bool operator==(const Vertex &other) const

{

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

}

{

alignas(16) glm::mat4 model;

alignas(16) glm::mat4 view;

alignas(16) glm::mat4 proj;

{

public:

void run()

{

initWindow();

initVulkan();

mainLoop();

cleanup();

}

private:

GLFWwindow *window = nullptr;

vk::raii::Context context;

vk::raii::Instance instance = nullptr;

vk::raii::DebugUtilsMessengerEXT debugMessenger = nullptr;

vk::raii::SurfaceKHR surface = nullptr;

vk::raii::PhysicalDevice physicalDevice = nullptr;

vk::raii::Device device = nullptr;

uint32_t queueIndex = ~0;

vk::raii::Queue queue = nullptr;

vk::raii::SwapchainKHR swapChain = nullptr;

std::vector<vk::Image> swapChainImages;

vk::SurfaceFormatKHR swapChainSurfaceFormat;

vk::Extent2D swapChainExtent;

std::vector<vk::raii::ImageView> swapChainImageViews;

vk::raii::DescriptorSetLayout descriptorSetLayout = nullptr;

vk::raii::PipelineLayout pipelineLayout = nullptr;

vk::raii::Pipeline graphicsPipeline = nullptr;

vk::raii::Image depthImage = nullptr;

vk::raii::DeviceMemory depthImageMemory = nullptr;

vk::raii::ImageView depthImageView = nullptr;

vk::raii::Image textureImage = nullptr;

vk::raii::DeviceMemory textureImageMemory = nullptr;

vk::raii::ImageView textureImageView = nullptr;

vk::raii::Sampler textureSampler = nullptr;

std::vector<Vertex> vertices;

std::vector<uint32_t> indices;

vk::raii::Buffer vertexBuffer = nullptr;

vk::raii::DeviceMemory vertexBufferMemory = nullptr;

vk::raii::Buffer indexBuffer = nullptr;

vk::raii::DeviceMemory indexBufferMemory = nullptr;

std::vector<vk::raii::Buffer> uniformBuffers;

std::vector<vk::raii::DeviceMemory> uniformBuffersMemory;

std::vector<void *> uniformBuffersMapped;

vk::raii::DescriptorPool descriptorPool = nullptr;

std::vector<vk::raii::DescriptorSet> descriptorSets;

vk::raii::CommandPool commandPool = nullptr;

std::vector<vk::raii::CommandBuffer> commandBuffers;

std::vector<vk::raii::Semaphore> presentCompleteSemaphores;

std::vector<vk::raii::Semaphore> renderFinishedSemaphores;

std::vector<vk::raii::Fence> inFlightFences;

uint32_t frameIndex = 0;

bool framebufferResized = false;

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

vk::KHRSwapchainExtensionName};

void initWindow()

{

glfwInit();

glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);

glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);

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

glfwSetWindowUserPointer(window, this);

glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);

}

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

createSwapChain();

createImageViews();

createDescriptorSetLayout();

createGraphicsPipeline();

createCommandPool();

createDepthResources();

createTextureImage();

createTextureImageView();

createTextureSampler();

loadModel();

createVertexBuffer();

createIndexBuffer();

createUniformBuffers();

createDescriptorPool();

createDescriptorSets();

createCommandBuffers();

createSyncObjects();

}

void mainLoop()

{

while (!glfwWindowShouldClose(window))

{

glfwPollEvents();

drawFrame();

}

device.waitIdle();

}

void cleanupSwapChain()

{

swapChainImageViews.clear();

swapChain = nullptr;

}

void cleanup()

{

glfwDestroyWindow(window);

glfwTerminate();

}

void recreateSwapChain()

{

int width = 0, height = 0;

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

{

glfwGetFramebufferSize(window, &width, &height);

glfwWaitEvents();

}

device.waitIdle();

cleanupSwapChain();

createSwapChain();

createImageViews();

createDepthResources();

}

void createInstance()

{

constexpr vk::ApplicationInfo appInfo{.pApplicationName = "Hello Triangle",

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

.pEngineName = "No Engine",

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

.apiVersion = vk::ApiVersion14};

// Get the required layers

std::vector<char const *> requiredLayers;

if (enableValidationLayers)

{

requiredLayers.assign(validationLayers.begin(), validationLayers.end());

}

// Check if the required layers are supported by the Vulkan implementation.

auto layerProperties = context.enumerateInstanceLayerProperties();

auto unsupportedLayerIt = std::ranges::find_if(requiredLayers,

[&layerProperties](auto const &requiredLayer) {

return std::ranges::none_of(layerProperties,

[requiredLayer](auto const &layerProperty) { return strcmp(layerProperty.layerName, requiredLayer) == 0; });

});

if (unsupportedLayerIt != requiredLayers.end())

{

throw std::runtime_error("Required layer not supported: " + std::string(*unsupportedLayerIt));

}

// Get the required extensions.

auto requiredExtensions = getRequiredInstanceExtensions();

// Check if the required extensions are supported by the Vulkan implementation.

auto extensionProperties = context.enumerateInstanceExtensionProperties();

auto unsupportedPropertyIt =

std::ranges::find_if(requiredExtensions,

[&extensionProperties](auto const &requiredExtension) {

return std::ranges::none_of(extensionProperties,

[requiredExtension](auto const &extensionProperty) { return strcmp(extensionProperty.extensionName, requiredExtension) == 0; });

});

if (unsupportedPropertyIt != requiredExtensions.end())

{

throw std::runtime_error("Required extension not supported: " + std::string(*unsupportedPropertyIt));

}

vk::InstanceCreateInfo createInfo{.pApplicationInfo = &appInfo,

.enabledLayerCount = static_cast<uint32_t>(requiredLayers.size()),

.ppEnabledLayerNames = requiredLayers.data(),

.enabledExtensionCount = static_cast<uint32_t>(requiredExtensions.size()),

.ppEnabledExtensionNames = requiredExtensions.data()};

instance = vk::raii::Instance(context, createInfo);

}

void setupDebugMessenger()

{

if (!enableValidationLayers)

return;

vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |

vk::DebugUtilsMessageSeverityFlagBitsEXT::eError);

vk::DebugUtilsMessageTypeFlagsEXT messageTypeFlags(

vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral | vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance | vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);

vk::DebugUtilsMessengerCreateInfoEXT debugUtilsMessengerCreateInfoEXT{.messageSeverity = severityFlags,

.messageType = messageTypeFlags,

.pfnUserCallback = &debugCallback};

debugMessenger = instance.createDebugUtilsMessengerEXT(debugUtilsMessengerCreateInfoEXT);

}

void createSurface()

{

VkSurfaceKHR _surface;

if (glfwCreateWindowSurface(*instance, window, nullptr, &_surface) != 0)

{

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

}

surface = vk::raii::SurfaceKHR(instance, _surface);

}

bool isDeviceSuitable(vk::raii::PhysicalDevice const &physicalDevice)

{

// Check if the physicalDevice supports the Vulkan 1.3 API version

bool supportsVulkan1_3 = physicalDevice.getProperties().apiVersion >= VK_API_VERSION_1_3;

// Check if any of the queue families support graphics operations

auto queueFamilies = physicalDevice.getQueueFamilyProperties();

bool supportsGraphics = std::ranges::any_of(queueFamilies, [](auto const &qfp) { return !!(qfp.queueFlags & vk::QueueFlagBits::eGraphics); });

// Check if all required physicalDevice extensions are available

auto availableDeviceExtensions = physicalDevice.enumerateDeviceExtensionProperties();

bool supportsAllRequiredExtensions =

std::ranges::all_of(requiredDeviceExtension,

[&availableDeviceExtensions](auto const &requiredDeviceExtension) {

return std::ranges::any_of(availableDeviceExtensions,

[requiredDeviceExtension](auto const &availableDeviceExtension) { return strcmp(availableDeviceExtension.extensionName, requiredDeviceExtension) == 0; });

});

// Check if the physicalDevice supports the required features

auto features = physicalDevice.template getFeatures2<vk::PhysicalDeviceFeatures2,

vk::PhysicalDeviceVulkan13Features,

vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT>();

bool supportsRequiredFeatures = features.template get<vk::PhysicalDeviceFeatures2>().features.samplerAnisotropy &&

features.template get<vk::PhysicalDeviceVulkan13Features>().dynamicRendering &&

features.template get<vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT>().extendedDynamicState;

// Return true if the physicalDevice meets all the criteria

return supportsVulkan1_3 && supportsGraphics && supportsAllRequiredExtensions && supportsRequiredFeatures;

}

void pickPhysicalDevice()

{

std::vector<vk::raii::PhysicalDevice> physicalDevices = instance.enumeratePhysicalDevices();

auto const devIter = std::ranges::find_if(physicalDevices, [&](auto const &physicalDevice) { return isDeviceSuitable(physicalDevice); });

if (devIter == physicalDevices.end())

{

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

}

physicalDevice = *devIter;

}

void createLogicalDevice()

{

std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();

// get the first index into queueFamilyProperties which supports both graphics and present

for (uint32_t qfpIndex = 0; qfpIndex < queueFamilyProperties.size(); qfpIndex++)

{

if ((queueFamilyProperties[qfpIndex].queueFlags & vk::QueueFlagBits::eGraphics) &&

physicalDevice.getSurfaceSupportKHR(qfpIndex, *surface))

{

// found a queue family that supports both graphics and present

queueIndex = qfpIndex;

break;

}

}

if (queueIndex == ~0)

{

throw std::runtime_error("Could not find a queue for graphics and present -> terminating");

}

// query for Vulkan 1.3 features

vk::StructureChain<vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceVulkan13Features, vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {

{.features = {.samplerAnisotropy = true}}, // vk::PhysicalDeviceFeatures2

{.synchronization2 = true, .dynamicRendering = true}, // vk::PhysicalDeviceVulkan13Features

{.extendedDynamicState = true} // vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT

};

// create a Device

float queuePriority = 0.5f;

vk::DeviceQueueCreateInfo deviceQueueCreateInfo{.queueFamilyIndex = queueIndex, .queueCount = 1, .pQueuePriorities = &queuePriority};

vk::DeviceCreateInfo deviceCreateInfo{.pNext = &featureChain.get<vk::PhysicalDeviceFeatures2>(),

.queueCreateInfoCount = 1,

.pQueueCreateInfos = &deviceQueueCreateInfo,

.enabledExtensionCount = static_cast<uint32_t>(requiredDeviceExtension.size()),

.ppEnabledExtensionNames = requiredDeviceExtension.data()};

device = vk::raii::Device(physicalDevice, deviceCreateInfo);

queue = vk::raii::Queue(device, queueIndex, 0);

}

void createSwapChain()

{

vk::SurfaceCapabilitiesKHR surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR(*surface);

swapChainExtent = chooseSwapExtent(surfaceCapabilities);

uint32_t minImageCount = chooseSwapMinImageCount(surfaceCapabilities);

std::vector<vk::SurfaceFormatKHR> availableFormats = physicalDevice.getSurfaceFormatsKHR(*surface);

swapChainSurfaceFormat = chooseSwapSurfaceFormat(availableFormats);

std::vector<vk::PresentModeKHR> availablePresentModes = physicalDevice.getSurfacePresentModesKHR(*surface);

vk::PresentModeKHR presentMode = chooseSwapPresentMode(availablePresentModes);

vk::SwapchainCreateInfoKHR swapChainCreateInfo{.surface = *surface,

.minImageCount = minImageCount,

.imageFormat = swapChainSurfaceFormat.format,

.imageColorSpace = swapChainSurfaceFormat.colorSpace,

.imageExtent = swapChainExtent,

.imageArrayLayers = 1,

.imageUsage = vk::ImageUsageFlagBits::eColorAttachment,

.imageSharingMode = vk::SharingMode::eExclusive,

.preTransform = surfaceCapabilities.currentTransform,

.compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque,

.presentMode = presentMode,

.clipped = true};

swapChain = vk::raii::SwapchainKHR(device, swapChainCreateInfo);

swapChainImages = swapChain.getImages();

}

void createImageViews()

{

assert(swapChainImageViews.empty());

swapChainImageViews.reserve(swapChainImages.size());

for (auto &image : swapChainImages)

{

swapChainImageViews.emplace_back(createImageView(image, swapChainSurfaceFormat.format, vk::ImageAspectFlagBits::eColor));

}

}

void createDescriptorSetLayout()

{

std::array<vk::DescriptorSetLayoutBinding, 2> bindings{

{{.binding = 0, .descriptorType = vk::DescriptorType::eUniformBuffer, .descriptorCount = 1, .stageFlags = vk::ShaderStageFlagBits::eVertex},

{.binding = 1, .descriptorType = vk::DescriptorType::eCombinedImageSampler, .descriptorCount = 1, .stageFlags = vk::ShaderStageFlagBits::eFragment}}};

vk::DescriptorSetLayoutCreateInfo layoutInfo{.bindingCount = static_cast<uint32_t>(bindings.size()), .pBindings = bindings.data()};

descriptorSetLayout = vk::raii::DescriptorSetLayout(device, layoutInfo);

}

void createGraphicsPipeline()

{

vk::raii::ShaderModule shaderModule = createShaderModule(readFile("shaders/slang.spv"));

vk::PipelineShaderStageCreateInfo vertShaderStageInfo{.stage = vk::ShaderStageFlagBits::eVertex, .module = shaderModule, .pName = "vertMain"};

vk::PipelineShaderStageCreateInfo fragShaderStageInfo{.stage = vk::ShaderStageFlagBits::eFragment, .module = shaderModule, .pName = "fragMain"};

vk::PipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};

auto bindingDescription = Vertex::getBindingDescription();

auto attributeDescriptions = Vertex::getAttributeDescriptions();

vk::PipelineVertexInputStateCreateInfo vertexInputInfo{.vertexBindingDescriptionCount = 1,

.pVertexBindingDescriptions = &bindingDescription,

.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size()),

.pVertexAttributeDescriptions = attributeDescriptions.data()};

vk::PipelineInputAssemblyStateCreateInfo inputAssembly{.topology = vk::PrimitiveTopology::eTriangleList};

vk::PipelineViewportStateCreateInfo viewportState{.viewportCount = 1, .scissorCount = 1};

vk::PipelineRasterizationStateCreateInfo rasterizer{.depthClampEnable = vk::False,

.rasterizerDiscardEnable = vk::False,

.polygonMode = vk::PolygonMode::eFill,

.cullMode = vk::CullModeFlagBits::eBack,

.frontFace = vk::FrontFace::eCounterClockwise,

.depthBiasEnable = vk::False,

.lineWidth = 1.0f};

vk::PipelineMultisampleStateCreateInfo multisampling{.rasterizationSamples = vk::SampleCountFlagBits::e1, .sampleShadingEnable = vk::False};

vk::PipelineDepthStencilStateCreateInfo depthStencil{

.depthTestEnable = vk::True,

.depthWriteEnable = vk::True,

.depthCompareOp = vk::CompareOp::eLess,

.depthBoundsTestEnable = vk::False,

.stencilTestEnable = vk::False};

vk::PipelineColorBlendAttachmentState colorBlendAttachment{

.blendEnable = vk::False,

.colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA};

vk::PipelineColorBlendStateCreateInfo colorBlending{

.logicOpEnable = vk::False, .logicOp = vk::LogicOp::eCopy, .attachmentCount = 1, .pAttachments = &colorBlendAttachment};

std::vector<vk::DynamicState> dynamicStates = {vk::DynamicState::eViewport, vk::DynamicState::eScissor};

vk::PipelineDynamicStateCreateInfo dynamicState{.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()), .pDynamicStates = dynamicStates.data()};

vk::PipelineLayoutCreateInfo pipelineLayoutInfo{.setLayoutCount = 1, .pSetLayouts = &*descriptorSetLayout, .pushConstantRangeCount = 0};

pipelineLayout = vk::raii::PipelineLayout(device, pipelineLayoutInfo);

vk::Format depthFormat = findDepthFormat();

vk::StructureChain<vk::GraphicsPipelineCreateInfo, vk::PipelineRenderingCreateInfo> pipelineCreateInfoChain = {

{.stageCount = 2,

.pStages = shaderStages,

.pVertexInputState = &vertexInputInfo,

.pInputAssemblyState = &inputAssembly,

.pViewportState = &viewportState,

.pRasterizationState = &rasterizer,

.pMultisampleState = &multisampling,

.pDepthStencilState = &depthStencil,

.pColorBlendState = &colorBlending,

.pDynamicState = &dynamicState,

.layout = pipelineLayout,

.renderPass = nullptr},

{.colorAttachmentCount = 1, .pColorAttachmentFormats = &swapChainSurfaceFormat.format, .depthAttachmentFormat = depthFormat}};

graphicsPipeline = vk::raii::Pipeline(device, nullptr, pipelineCreateInfoChain.get<vk::GraphicsPipelineCreateInfo>());

}

void createCommandPool()

{

vk::CommandPoolCreateInfo poolInfo{.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer,

.queueFamilyIndex = queueIndex};

commandPool = vk::raii::CommandPool(device, poolInfo);

}

void createDepthResources()

{

vk::Format depthFormat = findDepthFormat();

std::tie(depthImage, depthImageMemory) = createImage(swapChainExtent.width, swapChainExtent.height, depthFormat, vk::ImageTiling::eOptimal, vk::ImageUsageFlagBits::eDepthStencilAttachment, vk::MemoryPropertyFlagBits::eDeviceLocal);

depthImageView = createImageView(depthImage, depthFormat, vk::ImageAspectFlagBits::eDepth);

}

vk::Format findSupportedFormat(const std::vector<vk::Format> &candidates, vk::ImageTiling tiling, vk::FormatFeatureFlags features) const

{

for (const auto format : candidates)

{

vk::FormatProperties props = physicalDevice.getFormatProperties(format);

if (((tiling == vk::ImageTiling::eLinear) && ((props.linearTilingFeatures & features) == features)) ||

((tiling == vk::ImageTiling::eOptimal) && ((props.optimalTilingFeatures & features) == features)))

{

return format;

}

}

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

}

[[nodiscard]] vk::Format findDepthFormat() const

{

return findSupportedFormat({vk::Format::eD32Sfloat, vk::Format::eD32SfloatS8Uint, vk::Format::eD24UnormS8Uint},

vk::ImageTiling::eOptimal,

vk::FormatFeatureFlagBits::eDepthStencilAttachment);

}

void createTextureImage()

{

int texWidth, texHeight, texChannels;

stbi_uc *pixels = stbi_load(TEXTURE_PATH.c_str(), &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);

vk::DeviceSize imageSize = texWidth * texHeight * 4;

if (!pixels)

{

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

}

auto [stagingBuffer, stagingBufferMemory] =

createBuffer(imageSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);

void *data = stagingBufferMemory.mapMemory(0, imageSize);

memcpy(data, pixels, imageSize);

stagingBufferMemory.unmapMemory();

stbi_image_free(pixels);

std::tie(textureImage, textureImageMemory) = createImage(texWidth,

texHeight,

vk::Format::eR8G8B8A8Srgb,

vk::ImageTiling::eOptimal,

vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled,

vk::MemoryPropertyFlagBits::eDeviceLocal);

vk::raii::CommandBuffer commandBuffer = beginSingleTimeCommands();

transitionImageLayout(commandBuffer, textureImage, vk::ImageLayout::eUndefined, vk::ImageLayout::eTransferDstOptimal);

copyBufferToImage(commandBuffer, stagingBuffer, textureImage, static_cast<uint32_t>(texWidth), static_cast<uint32_t>(texHeight));

transitionImageLayout(commandBuffer, textureImage, vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eShaderReadOnlyOptimal);

endSingleTimeCommands(std::move(commandBuffer));

}

void createTextureImageView()

{

textureImageView = createImageView(*textureImage, vk::Format::eR8G8B8A8Srgb, vk::ImageAspectFlagBits::eColor);

}

void createTextureSampler()

{

vk::PhysicalDeviceProperties properties = physicalDevice.getProperties();

vk::SamplerCreateInfo samplerInfo{.magFilter = vk::Filter::eLinear,

.minFilter = vk::Filter::eLinear,

.mipmapMode = vk::SamplerMipmapMode::eLinear,

.addressModeU = vk::SamplerAddressMode::eRepeat,

.addressModeV = vk::SamplerAddressMode::eRepeat,

.addressModeW = vk::SamplerAddressMode::eRepeat,

.mipLodBias = 0.0f,

.anisotropyEnable = vk::True,

.maxAnisotropy = properties.limits.maxSamplerAnisotropy,

.compareEnable = vk::False,

.compareOp = vk::CompareOp::eAlways};

textureSampler = vk::raii::Sampler(device, samplerInfo);

}

vk::raii::ImageView createImageView(vk::Image const &image, vk::Format format, vk::ImageAspectFlags aspectFlags)

{

vk::ImageViewCreateInfo viewInfo{

.image = image,

.viewType = vk::ImageViewType::e2D,

.format = format,

.subresourceRange = {.aspectMask = aspectFlags, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1}};

return vk::raii::ImageView(device, viewInfo);

}

std::pair<vk::raii::Image, vk::raii::DeviceMemory> createImage(uint32_t width, uint32_t height, vk::Format format, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::MemoryPropertyFlags properties)

{

vk::ImageCreateInfo imageInfo{.imageType = vk::ImageType::e2D,

.format = format,

.extent = {width, height, 1},

.mipLevels = 1,

.arrayLayers = 1,

.samples = vk::SampleCountFlagBits::e1,

.tiling = tiling,

.usage = usage,

.sharingMode = vk::SharingMode::eExclusive};

vk::raii::Image image = vk::raii::Image(device, imageInfo);

vk::MemoryRequirements memRequirements = image.getMemoryRequirements();

vk::MemoryAllocateInfo allocInfo{.allocationSize = memRequirements.size,

.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties)};

vk::raii::DeviceMemory imageMemory = vk::raii::DeviceMemory(device, allocInfo);

image.bindMemory(imageMemory, 0);

return {std::move(image), std::move(imageMemory)};

}

void transitionImageLayout(vk::raii::CommandBuffer &commandBuffer, const vk::raii::Image &image, vk::ImageLayout oldLayout, vk::ImageLayout newLayout)

{

vk::ImageMemoryBarrier barrier{.oldLayout = oldLayout,

.newLayout = newLayout,

.srcQueueFamilyIndex = vk::QueueFamilyIgnored,

.dstQueueFamilyIndex = vk::QueueFamilyIgnored,

.image = image,

.subresourceRange = {.aspectMask = vk::ImageAspectFlagBits::eColor, .levelCount = 1, .layerCount = 1}};

vk::PipelineStageFlags sourceStage;

vk::PipelineStageFlags destinationStage;

if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eTransferDstOptimal)

{

barrier.srcAccessMask = {};

barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;

sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;

destinationStage = vk::PipelineStageFlagBits::eTransfer;

}

else if (oldLayout == vk::ImageLayout::eTransferDstOptimal && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal)

{

barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;

barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;

sourceStage = vk::PipelineStageFlagBits::eTransfer;

destinationStage = vk::PipelineStageFlagBits::eFragmentShader;

}

else

{

throw std::invalid_argument("unsupported layout transition!");

}

commandBuffer.pipelineBarrier(sourceStage, destinationStage, {}, {}, {}, barrier);

}

void copyBufferToImage(vk::raii::CommandBuffer &commandBuffer, const vk::raii::Buffer &buffer, vk::raii::Image &image, uint32_t width, uint32_t height)

{

vk::BufferImageCopy region{.bufferOffset = 0,

.bufferRowLength = 0,

.bufferImageHeight = 0,

.imageSubresource = {.aspectMask = vk::ImageAspectFlagBits::eColor, .mipLevel = 0, .baseArrayLayer = 0, .layerCount = 1},

.imageOffset = {0, 0, 0},

.imageExtent = {width, height, 1}};

commandBuffer.copyBufferToImage(buffer, image, vk::ImageLayout::eTransferDstOptimal, region);

}

void loadModel()

{

tinyobj::attrib_t attrib;

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

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

std::string warn, err;

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

{

throw std::runtime_error(warn + err);

}

std::unordered_map<Vertex, uint32_t> uniqueVertices{};

for (const auto &shape : shapes)

{

for (const auto &index : shape.mesh.indices)

{

Vertex vertex{};

vertex.pos = {

attrib.vertices[3 * index.vertex_index + 0],

attrib.vertices[3 * index.vertex_index + 1],

attrib.vertices[3 * index.vertex_index + 2]};

vertex.texCoord = {

attrib.texcoords[2 * index.texcoord_index + 0],

1.0f - attrib.texcoords[2 * index.texcoord_index + 1]};

vertex.color = {1.0f, 1.0f, 1.0f};

#if 1

auto [it, inserted] = uniqueVertices.insert({vertex, static_cast<uint32_t>(vertices.size())});

if (inserted)

{

vertices.push_back(vertex);

}

indices.push_back(it->second);

#else

#endif

}

}

}

void createVertexBuffer()

{

vk::DeviceSize bufferSize = sizeof(vertices[0]) * vertices.size();

auto [stagingBuffer, stagingBufferMemory] =

createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);

void *dataStaging = stagingBufferMemory.mapMemory(0, bufferSize);

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

stagingBufferMemory.unmapMemory();

std::tie(vertexBuffer, vertexBufferMemory) =

createBuffer(bufferSize, vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst, vk::MemoryPropertyFlagBits::eDeviceLocal);

copyBuffer(stagingBuffer, vertexBuffer, bufferSize);

}

std::pair<vk::raii::Buffer, vk::raii::DeviceMemory> createBuffer(vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties)

{

vk::BufferCreateInfo bufferInfo{.size = size, .usage = usage, .sharingMode = vk::SharingMode::eExclusive};

vk::raii::Buffer buffer = vk::raii::Buffer(device, bufferInfo);

vk::MemoryRequirements memRequirements = buffer.getMemoryRequirements();

vk::MemoryAllocateInfo allocInfo{.allocationSize = memRequirements.size, .memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties)};

vk::raii::DeviceMemory bufferMemory = vk::raii::DeviceMemory(device, allocInfo);

buffer.bindMemory(*bufferMemory, 0);

return {std::move(buffer), std::move(bufferMemory)};

}

void createIndexBuffer()

{

vk::DeviceSize bufferSize = sizeof(indices[0]) * indices.size();

auto [stagingBuffer, stagingBufferMemory] =

createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);

void *data = stagingBufferMemory.mapMemory(0, bufferSize);

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

stagingBufferMemory.unmapMemory();

std::tie(indexBuffer, indexBufferMemory) =

createBuffer(bufferSize, vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst, vk::MemoryPropertyFlagBits::eDeviceLocal);

copyBuffer(stagingBuffer, indexBuffer, bufferSize);

}

void createUniformBuffers()

{

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

{

vk::DeviceSize bufferSize = sizeof(UniformBufferObject);

auto [buffer, bufferMem] = createBuffer(

bufferSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);

uniformBuffers.emplace_back(std::move(buffer));

uniformBuffersMemory.emplace_back(std::move(bufferMem));

uniformBuffersMapped.emplace_back(uniformBuffersMemory.back().mapMemory(0, bufferSize));

}

}

void createDescriptorPool()

{

std::array<vk::DescriptorPoolSize, 2> poolSize{{{.type = vk::DescriptorType::eUniformBuffer, .descriptorCount = MAX_FRAMES_IN_FLIGHT},

{.type = vk::DescriptorType::eCombinedImageSampler, .descriptorCount = MAX_FRAMES_IN_FLIGHT}}};

vk::DescriptorPoolCreateInfo poolInfo{.flags = vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet,

.maxSets = MAX_FRAMES_IN_FLIGHT,

.poolSizeCount = static_cast<uint32_t>(poolSize.size()),

.pPoolSizes = poolSize.data()};

descriptorPool = vk::raii::DescriptorPool(device, poolInfo);

}

void createDescriptorSets()

{

std::vector<vk::DescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, descriptorSetLayout);

vk::DescriptorSetAllocateInfo allocInfo{

.descriptorPool = descriptorPool,

.descriptorSetCount = static_cast<uint32_t>(layouts.size()),

.pSetLayouts = layouts.data()};

descriptorSets.clear();

descriptorSets = device.allocateDescriptorSets(allocInfo);

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

{

vk::DescriptorBufferInfo bufferInfo{.buffer = uniformBuffers[i], .offset = 0, .range = sizeof(UniformBufferObject)};

vk::DescriptorImageInfo imageInfo{.sampler = textureSampler, .imageView = textureImageView, .imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal};

std::array<vk::WriteDescriptorSet, 2> descriptorWrites{{{.dstSet = descriptorSets[i],

.dstBinding = 0,

.dstArrayElement = 0,

.descriptorCount = 1,

.descriptorType = vk::DescriptorType::eUniformBuffer,

.pBufferInfo = &bufferInfo},

{.dstSet = descriptorSets[i],

.dstBinding = 1,

.dstArrayElement = 0,

.descriptorCount = 1,

.descriptorType = vk::DescriptorType::eCombinedImageSampler,

.pImageInfo = &imageInfo}}};

device.updateDescriptorSets(descriptorWrites, {});

}

}

vk::raii::CommandBuffer beginSingleTimeCommands()

{

vk::CommandBufferAllocateInfo allocInfo{.commandPool = commandPool, .level = vk::CommandBufferLevel::ePrimary, .commandBufferCount = 1};

vk::raii::CommandBuffer commandBuffer = std::move(vk::raii::CommandBuffers(device, allocInfo).front());

vk::CommandBufferBeginInfo beginInfo{.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit};

commandBuffer.begin(beginInfo);

return std::move(commandBuffer);

}

void endSingleTimeCommands(vk::raii::CommandBuffer &&commandBuffer)

{

commandBuffer.end();

vk::SubmitInfo submitInfo{.commandBufferCount = 1, .pCommandBuffers = &*commandBuffer};

queue.submit(submitInfo, nullptr);

queue.waitIdle();

}

void copyBuffer(vk::raii::Buffer &srcBuffer, vk::raii::Buffer &dstBuffer, vk::DeviceSize size)

{

vk::raii::CommandBuffer commandCopyBuffer = beginSingleTimeCommands();

commandCopyBuffer.copyBuffer(*srcBuffer, *dstBuffer, vk::BufferCopy{.size = size});

endSingleTimeCommands(std::move(commandCopyBuffer));

}

uint32_t findMemoryType(uint32_t typeFilter, vk::MemoryPropertyFlags properties)

{

vk::PhysicalDeviceMemoryProperties memProperties = physicalDevice.getMemoryProperties();

for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++)

{

if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)

{

return i;

}

}

throw std::runtime_error("failed to find suitable memory type!");

}

void createCommandBuffers()

{

commandBuffers.clear();

vk::CommandBufferAllocateInfo allocInfo{.commandPool = commandPool, .level = vk::CommandBufferLevel::ePrimary, .commandBufferCount = MAX_FRAMES_IN_FLIGHT};

commandBuffers = vk::raii::CommandBuffers(device, allocInfo);

}

void recordCommandBuffer(uint32_t imageIndex)

{

auto &commandBuffer = commandBuffers[frameIndex];

commandBuffer.begin({});

// Before starting rendering, transition the swapchain image to vk::ImageLayout::eColorAttachmentOptimal

transition_image_layout(

swapChainImages[imageIndex],

vk::ImageLayout::eUndefined,

vk::ImageLayout::eColorAttachmentOptimal,

{}, // srcAccessMask (no need to wait for previous operations)

vk::AccessFlagBits2::eColorAttachmentWrite, // dstAccessMask

vk::PipelineStageFlagBits2::eColorAttachmentOutput, // srcStage

vk::PipelineStageFlagBits2::eColorAttachmentOutput, // dstStage

vk::ImageAspectFlagBits::eColor);

// Transition depth image to depth attachment optimal layout

transition_image_layout(

*depthImage,

vk::ImageLayout::eUndefined,

vk::ImageLayout::eDepthAttachmentOptimal,

vk::AccessFlagBits2::eDepthStencilAttachmentWrite,

vk::AccessFlagBits2::eDepthStencilAttachmentWrite,

vk::PipelineStageFlagBits2::eEarlyFragmentTests | vk::PipelineStageFlagBits2::eLateFragmentTests,

vk::PipelineStageFlagBits2::eEarlyFragmentTests | vk::PipelineStageFlagBits2::eLateFragmentTests,

vk::ImageAspectFlagBits::eDepth);

vk::ClearValue clearColor = vk::ClearColorValue(0.0f, 0.0f, 0.0f, 1.0f);

vk::ClearValue clearDepth = vk::ClearDepthStencilValue(1.0f, 0);

vk::RenderingAttachmentInfo colorAttachmentInfo = {

.imageView = swapChainImageViews[imageIndex],

.imageLayout = vk::ImageLayout::eColorAttachmentOptimal,

.loadOp = vk::AttachmentLoadOp::eClear,

.storeOp = vk::AttachmentStoreOp::eStore,

.clearValue = clearColor};

vk::RenderingAttachmentInfo depthAttachmentInfo = {

.imageView = depthImageView,

.imageLayout = vk::ImageLayout::eDepthStencilAttachmentOptimal,

.loadOp = vk::AttachmentLoadOp::eClear,

.storeOp = vk::AttachmentStoreOp::eDontCare,

.clearValue = clearDepth};

vk::RenderingInfo renderingInfo = {

.renderArea = {.offset = {0, 0}, .extent = swapChainExtent},

.layerCount = 1,

.colorAttachmentCount = 1,

.pColorAttachments = &colorAttachmentInfo,

.pDepthAttachment = &depthAttachmentInfo};

commandBuffer.beginRendering(renderingInfo);

commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, *graphicsPipeline);

commandBuffer.setViewport(0, vk::Viewport(0.0f, 0.0f, static_cast<float>(swapChainExtent.width), static_cast<float>(swapChainExtent.height), 0.0f, 1.0f));

commandBuffer.setScissor(0, vk::Rect2D(vk::Offset2D(0, 0), swapChainExtent));

commandBuffer.bindVertexBuffers(0, *vertexBuffer, {0});

commandBuffer.bindIndexBuffer(*indexBuffer, 0, vk::IndexTypeValue<decltype(indices)::value_type>::value);

commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout, 0, *descriptorSets[frameIndex], nullptr);

commandBuffer.drawIndexed(static_cast<uint32_t>(indices.size()), 1, 0, 0, 0);

commandBuffer.endRendering();

// After rendering, transition the swapchain image to vk::ImageLayout::ePresentSrcKHR

transition_image_layout(

swapChainImages[imageIndex],

vk::ImageLayout::eColorAttachmentOptimal,

vk::ImageLayout::ePresentSrcKHR,

vk::AccessFlagBits2::eColorAttachmentWrite, // srcAccessMask

{}, // dstAccessMask

vk::PipelineStageFlagBits2::eColorAttachmentOutput, // srcStage

vk::PipelineStageFlagBits2::eBottomOfPipe, // dstStage

vk::ImageAspectFlagBits::eColor);

commandBuffer.end();

}

void transition_image_layout(

vk::Image image,

vk::ImageLayout old_layout,

vk::ImageLayout new_layout,

vk::AccessFlags2 src_access_mask,

vk::AccessFlags2 dst_access_mask,

vk::PipelineStageFlags2 src_stage_mask,

vk::PipelineStageFlags2 dst_stage_mask,

vk::ImageAspectFlags image_aspect_flags)

{

vk::ImageMemoryBarrier2 barrier = {

.srcStageMask = src_stage_mask,

.srcAccessMask = src_access_mask,

.dstStageMask = dst_stage_mask,

.dstAccessMask = dst_access_mask,

.oldLayout = old_layout,

.newLayout = new_layout,

.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,

.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,

.image = image,

.subresourceRange = {

.aspectMask = image_aspect_flags,

.baseMipLevel = 0,

.levelCount = 1,

.baseArrayLayer = 0,

.layerCount = 1}};

vk::DependencyInfo dependency_info = {

.dependencyFlags = {},

.imageMemoryBarrierCount = 1,

.pImageMemoryBarriers = &barrier};

commandBuffers[frameIndex].pipelineBarrier2(dependency_info);

}

void createSyncObjects()

{

assert(presentCompleteSemaphores.empty() && renderFinishedSemaphores.empty() && inFlightFences.empty());

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

{

renderFinishedSemaphores.emplace_back(device, vk::SemaphoreCreateInfo());

}