std::optional<uint32_t> graphicsFamily;

std::optional<uint32_t> presentFamily;

bool isComplete() {

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

}

vk::SurfaceCapabilitiesKHR capabilities;

std::vector<vk::SurfaceFormatKHR> formats;

std::vector<vk::PresentModeKHR> presentModes;

glm::vec2 pos;

glm::vec3 color;

static vk::VertexInputBindingDescription getBindingDescription() {

vk::VertexInputBindingDescription bindingDescription{};

bindingDescription.binding = 0;

bindingDescription.stride = sizeof(Vertex);

bindingDescription.inputRate = vk::VertexInputRate::eVertex;

return bindingDescription;

}

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

std::array<vk::VertexInputAttributeDescription, 2> attributeDescriptions{};

attributeDescriptions[0].binding = 0;

attributeDescriptions[0].location = 0;

attributeDescriptions[0].format = vk::Format::eR32G32Sfloat;

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

attributeDescriptions[1].binding = 0;

attributeDescriptions[1].location = 1;

attributeDescriptions[1].format = vk::Format::eR32G32B32Sfloat;

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

return attributeDescriptions;

}

void operator()(GLFWwindow* window) {

glfwDestroyWindow(window);

glfwTerminate();

}

void run() {

initWindow();

initVulkan();

mainLoop();

}

// Declared first so that the window is destroyed last, after the Vulkan objects using it

std::unique_ptr<GLFWwindow, GLFWwindowDeleter> window;

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;

vk::raii::Queue graphicsQueue = nullptr;

vk::raii::Queue presentQueue = nullptr;

vk::raii::SwapchainKHR swapChain = nullptr;

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

vk::Format swapChainImageFormat;

vk::Extent2D swapChainExtent;

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

std::vector<vk::raii::Framebuffer> swapChainFramebuffers;

vk::raii::RenderPass renderPass = nullptr;

vk::raii::PipelineLayout pipelineLayout = nullptr;

vk::raii::Pipeline graphicsPipeline = nullptr;

vk::raii::CommandPool commandPool = nullptr;

vk::raii::Buffer vertexBuffer = nullptr;

vk::raii::DeviceMemory vertexBufferMemory = nullptr;

vk::raii::Buffer indexBuffer = nullptr;

vk::raii::DeviceMemory indexBufferMemory = nullptr;

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

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

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

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

uint32_t currentFrame = 0;

bool framebufferResized = false;

void initWindow() {

glfwInit();

glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);

window.reset(glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr));

glfwSetWindowUserPointer(window.get(), this);

glfwSetFramebufferSizeCallback(window.get(), 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();

createRenderPass();

createGraphicsPipeline();

createFramebuffers();

createCommandPool();

createVertexBuffer();

createIndexBuffer();

createCommandBuffers();

createSyncObjects();

}

void mainLoop() {

while (!glfwWindowShouldClose(window.get())) {

glfwPollEvents();

drawFrame();

}

device.waitIdle();

}

void cleanupSwapChain() {

// The objects that use the swap chain have to be released before a new one is created

swapChainFramebuffers.clear();

swapChainImageViews.clear();

swapChain = nullptr;

}

void recreateSwapChain() {

int width = 0, height = 0;

glfwGetFramebufferSize(window.get(), &width, &height);

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

glfwGetFramebufferSize(window.get(), &width, &height);

glfwWaitEvents();

}

device.waitIdle();

cleanupSwapChain();

createSwapChain();

createImageViews();

createFramebuffers();

createRenderFinishedSemaphores();

}

void createInstance() {

if (enableValidationLayers && !checkValidationLayerSupport()) {

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

}

vk::ApplicationInfo appInfo{};

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

vk::InstanceCreateInfo createInfo{};

createInfo.pApplicationInfo = &appInfo;

auto extensions = getRequiredExtensions();

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

createInfo.ppEnabledExtensionNames = extensions.data();

vk::DebugUtilsMessengerCreateInfoEXT debugCreateInfo{};

if (enableValidationLayers) {

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

createInfo.ppEnabledLayerNames = validationLayers.data();

populateDebugMessengerCreateInfo(debugCreateInfo);

createInfo.pNext = &debugCreateInfo;

} else {

createInfo.enabledLayerCount = 0;

createInfo.pNext = nullptr;

}

instance = context.createInstance(createInfo);

}

void populateDebugMessengerCreateInfo(vk::DebugUtilsMessengerCreateInfoEXT& createInfo) {

createInfo = vk::DebugUtilsMessengerCreateInfoEXT{};

createInfo.messageSeverity = vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning | vk::DebugUtilsMessageSeverityFlagBitsEXT::eError;

createInfo.messageType = vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral | vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation | vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance;

createInfo.pfnUserCallback = debugCallback;

}

void setupDebugMessenger() {

if (!enableValidationLayers) return;

vk::DebugUtilsMessengerCreateInfoEXT createInfo;

populateDebugMessengerCreateInfo(createInfo);

debugMessenger = instance.createDebugUtilsMessengerEXT(createInfo);

}

void createSurface() {

VkSurfaceKHR rawSurface;

if (glfwCreateWindowSurface(*instance, window.get(), nullptr, &rawSurface) != VK_SUCCESS) {

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

}

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

}

void pickPhysicalDevice() {

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

if (devices.empty()) {

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

}

for (const auto& device : devices) {

if (isDeviceSuitable(device)) {

physicalDevice = device;

break;

}

}

if (!*physicalDevice) {

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

}

}

void createLogicalDevice() {

QueueFamilyIndices indices = findQueueFamilies(physicalDevice);

std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;

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

float queuePriority = 1.0f;

for (uint32_t queueFamily : uniqueQueueFamilies) {

vk::DeviceQueueCreateInfo queueCreateInfo{};

queueCreateInfo.queueFamilyIndex = queueFamily;

queueCreateInfo.queueCount = 1;

queueCreateInfo.pQueuePriorities = &queuePriority;

queueCreateInfos.push_back(queueCreateInfo);

}

vk::PhysicalDeviceFeatures deviceFeatures{};

vk::DeviceCreateInfo createInfo{};

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

createInfo.pQueueCreateInfos = queueCreateInfos.data();

createInfo.pEnabledFeatures = &deviceFeatures;

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

createInfo.ppEnabledExtensionNames = deviceExtensions.data();

device = physicalDevice.createDevice(createInfo);

graphicsQueue = device.getQueue(indices.graphicsFamily.value(), 0);

presentQueue = device.getQueue(indices.presentFamily.value(), 0);

}

void createSwapChain() {

SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);

vk::SurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);

vk::PresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);

vk::Extent2D extent = chooseSwapExtent(swapChainSupport.capabilities);

uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;

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

imageCount = swapChainSupport.capabilities.maxImageCount;

}

vk::SwapchainCreateInfoKHR createInfo{};

createInfo.surface = *surface;

createInfo.minImageCount = imageCount;

createInfo.imageFormat = surfaceFormat.format;

createInfo.imageColorSpace = surfaceFormat.colorSpace;

createInfo.imageExtent = extent;

createInfo.imageArrayLayers = 1;

createInfo.imageUsage = vk::ImageUsageFlagBits::eColorAttachment;

QueueFamilyIndices indices = findQueueFamilies(physicalDevice);

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

if (indices.graphicsFamily != indices.presentFamily) {

createInfo.imageSharingMode = vk::SharingMode::eConcurrent;

createInfo.queueFamilyIndexCount = 2;

createInfo.pQueueFamilyIndices = queueFamilyIndices;

} else {

createInfo.imageSharingMode = vk::SharingMode::eExclusive;

}

createInfo.preTransform = chooseSwapPreTransform(swapChainSupport.capabilities);

createInfo.compositeAlpha = chooseSwapCompositeAlpha(swapChainSupport.capabilities);

createInfo.presentMode = presentMode;

createInfo.clipped = VK_TRUE;

swapChain = device.createSwapchainKHR(createInfo);

swapChainImages = swapChain.getImages();

swapChainImageFormat = surfaceFormat.format;

swapChainExtent = extent;

}

void createImageViews() {

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

vk::ImageViewCreateInfo createInfo{};

createInfo.image = swapChainImages[i];

createInfo.viewType = vk::ImageViewType::e2D;

createInfo.format = swapChainImageFormat;

createInfo.components.r = vk::ComponentSwizzle::eIdentity;

createInfo.components.g = vk::ComponentSwizzle::eIdentity;

createInfo.components.b = vk::ComponentSwizzle::eIdentity;

createInfo.components.a = vk::ComponentSwizzle::eIdentity;

createInfo.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;

createInfo.subresourceRange.baseMipLevel = 0;

createInfo.subresourceRange.levelCount = 1;

createInfo.subresourceRange.baseArrayLayer = 0;

createInfo.subresourceRange.layerCount = 1;

swapChainImageViews.push_back(device.createImageView(createInfo));

}

}

void createRenderPass() {

vk::AttachmentDescription colorAttachment{};

colorAttachment.format = swapChainImageFormat;

colorAttachment.samples = vk::SampleCountFlagBits::e1;

colorAttachment.loadOp = vk::AttachmentLoadOp::eClear;

colorAttachment.storeOp = vk::AttachmentStoreOp::eStore;

colorAttachment.stencilLoadOp = vk::AttachmentLoadOp::eDontCare;

colorAttachment.stencilStoreOp = vk::AttachmentStoreOp::eDontCare;

colorAttachment.initialLayout = vk::ImageLayout::eUndefined;

colorAttachment.finalLayout = vk::ImageLayout::ePresentSrcKHR;

vk::AttachmentReference colorAttachmentRef{};

colorAttachmentRef.attachment = 0;

colorAttachmentRef.layout = vk::ImageLayout::eColorAttachmentOptimal;

vk::SubpassDescription subpass{};

subpass.pipelineBindPoint = vk::PipelineBindPoint::eGraphics;

subpass.colorAttachmentCount = 1;

subpass.pColorAttachments = &colorAttachmentRef;

vk::SubpassDependency dependency{};

dependency.srcSubpass = VK_SUBPASS_EXTERNAL;

dependency.dstSubpass = 0;

dependency.srcStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;

dependency.srcAccessMask = vk::AccessFlags();

dependency.dstStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;

dependency.dstAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;

vk::RenderPassCreateInfo renderPassInfo{};

renderPassInfo.attachmentCount = 1;

renderPassInfo.pAttachments = &colorAttachment;

renderPassInfo.subpassCount = 1;

renderPassInfo.pSubpasses = &subpass;

renderPassInfo.dependencyCount = 1;

renderPassInfo.pDependencies = &dependency;

renderPass = device.createRenderPass(renderPassInfo);

}

void createGraphicsPipeline() {

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

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

vk::raii::ShaderModule vertShaderModule = createShaderModule(vertShaderCode);

vk::raii::ShaderModule fragShaderModule = createShaderModule(fragShaderCode);

vk::PipelineShaderStageCreateInfo vertShaderStageInfo{};

vertShaderStageInfo.stage = vk::ShaderStageFlagBits::eVertex;

vertShaderStageInfo.module = *vertShaderModule;

vertShaderStageInfo.pName = "main";

vk::PipelineShaderStageCreateInfo fragShaderStageInfo{};

fragShaderStageInfo.stage = vk::ShaderStageFlagBits::eFragment;

fragShaderStageInfo.module = *fragShaderModule;

fragShaderStageInfo.pName = "main";

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

vk::PipelineVertexInputStateCreateInfo vertexInputInfo{};

auto bindingDescription = Vertex::getBindingDescription();

auto attributeDescriptions = Vertex::getAttributeDescriptions();

vertexInputInfo.vertexBindingDescriptionCount = 1;

vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());

vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;

vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

vk::PipelineInputAssemblyStateCreateInfo inputAssembly{};

inputAssembly.topology = vk::PrimitiveTopology::eTriangleList;

inputAssembly.primitiveRestartEnable = VK_FALSE;

vk::PipelineViewportStateCreateInfo viewportState{};

viewportState.viewportCount = 1;

viewportState.scissorCount = 1;

vk::PipelineRasterizationStateCreateInfo rasterizer{};

rasterizer.depthClampEnable = VK_FALSE;

rasterizer.rasterizerDiscardEnable = VK_FALSE;

rasterizer.polygonMode = vk::PolygonMode::eFill;

rasterizer.lineWidth = 1.0f;

rasterizer.cullMode = vk::CullModeFlagBits::eBack;

rasterizer.frontFace = vk::FrontFace::eClockwise;

rasterizer.depthBiasEnable = VK_FALSE;

vk::PipelineMultisampleStateCreateInfo multisampling{};

multisampling.sampleShadingEnable = VK_FALSE;

multisampling.rasterizationSamples = vk::SampleCountFlagBits::e1;

vk::PipelineColorBlendAttachmentState colorBlendAttachment{};

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

colorBlendAttachment.blendEnable = VK_FALSE;

vk::PipelineColorBlendStateCreateInfo colorBlending{};

colorBlending.logicOpEnable = VK_FALSE;

colorBlending.logicOp = vk::LogicOp::eCopy;

colorBlending.attachmentCount = 1;

colorBlending.pAttachments = &colorBlendAttachment;

colorBlending.blendConstants[0] = 0.0f;

colorBlending.blendConstants[1] = 0.0f;

colorBlending.blendConstants[2] = 0.0f;

colorBlending.blendConstants[3] = 0.0f;

std::vector<vk::DynamicState> dynamicStates = {

vk::DynamicState::eViewport,

vk::DynamicState::eScissor

};

vk::PipelineDynamicStateCreateInfo dynamicState{};

dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());

dynamicState.pDynamicStates = dynamicStates.data();

vk::PipelineLayoutCreateInfo pipelineLayoutInfo{};

pipelineLayoutInfo.setLayoutCount = 0;

pipelineLayoutInfo.pushConstantRangeCount = 0;

pipelineLayout = device.createPipelineLayout(pipelineLayoutInfo);

vk::GraphicsPipelineCreateInfo pipelineInfo{};

pipelineInfo.stageCount = 2;

pipelineInfo.pStages = shaderStages;

pipelineInfo.pVertexInputState = &vertexInputInfo;

pipelineInfo.pInputAssemblyState = &inputAssembly;

pipelineInfo.pViewportState = &viewportState;

pipelineInfo.pRasterizationState = &rasterizer;

pipelineInfo.pMultisampleState = &multisampling;

pipelineInfo.pColorBlendState = &colorBlending;

pipelineInfo.pDynamicState = &dynamicState;

pipelineInfo.layout = *pipelineLayout;

pipelineInfo.renderPass = *renderPass;

pipelineInfo.subpass = 0;

pipelineInfo.basePipelineHandle = nullptr;

graphicsPipeline = device.createGraphicsPipeline(nullptr, pipelineInfo);

}

void createFramebuffers() {

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

vk::ImageView attachments[] = {

*swapChainImageViews[i]

};

vk::FramebufferCreateInfo framebufferInfo{};

framebufferInfo.renderPass = *renderPass;

framebufferInfo.attachmentCount = 1;

framebufferInfo.pAttachments = attachments;

framebufferInfo.width = swapChainExtent.width;

framebufferInfo.height = swapChainExtent.height;

framebufferInfo.layers = 1;

swapChainFramebuffers.push_back(device.createFramebuffer(framebufferInfo));

}

}

void createCommandPool() {

QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);

vk::CommandPoolCreateInfo poolInfo{};

poolInfo.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;

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

commandPool = device.createCommandPool(poolInfo);

}

void createVertexBuffer() {

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

vk::raii::Buffer stagingBuffer = nullptr;

vk::raii::DeviceMemory stagingBufferMemory = nullptr;

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

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

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

stagingBufferMemory.unmapMemory();

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

copyBuffer(*stagingBuffer, *vertexBuffer, bufferSize);

}

void createIndexBuffer() {

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

vk::raii::Buffer stagingBuffer = nullptr;

vk::raii::DeviceMemory stagingBufferMemory = nullptr;

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

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

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

stagingBufferMemory.unmapMemory();

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

copyBuffer(*stagingBuffer, *indexBuffer, bufferSize);

}

void createBuffer(vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::raii::Buffer& buffer, vk::raii::DeviceMemory& bufferMemory) {

vk::BufferCreateInfo bufferInfo{};

bufferInfo.size = size;

bufferInfo.usage = usage;

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

buffer = device.createBuffer(bufferInfo);

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

vk::MemoryAllocateInfo allocInfo{};

allocInfo.allocationSize = memRequirements.size;

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

bufferMemory = device.allocateMemory(allocInfo);

buffer.bindMemory(*bufferMemory, 0);

}

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

vk::CommandBufferAllocateInfo allocInfo{};

allocInfo.level = vk::CommandBufferLevel::ePrimary;

allocInfo.commandPool = *commandPool;

allocInfo.commandBufferCount = 1;

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

vk::CommandBufferBeginInfo beginInfo{};

beginInfo.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;

commandBuffer.begin(beginInfo);

vk::BufferCopy copyRegion{};

copyRegion.size = size;

commandBuffer.copyBuffer(srcBuffer, dstBuffer, copyRegion);

commandBuffer.end();

vk::SubmitInfo submitInfo{};

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &*commandBuffer;

graphicsQueue.submit(submitInfo, nullptr);

graphicsQueue.waitIdle();

}

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

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

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

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

return i;

}

}

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

}

void createCommandBuffers() {

vk::CommandBufferAllocateInfo allocInfo{};

allocInfo.commandPool = *commandPool;

allocInfo.level = vk::CommandBufferLevel::ePrimary;

allocInfo.commandBufferCount = MAX_FRAMES_IN_FLIGHT;

commandBuffers = device.allocateCommandBuffers(allocInfo);

}

void recordCommandBuffer(vk::raii::CommandBuffer& commandBuffer, uint32_t imageIndex) {

vk::CommandBufferBeginInfo beginInfo{};

commandBuffer.begin(beginInfo);

vk::RenderPassBeginInfo renderPassInfo{};

renderPassInfo.renderPass = *renderPass;

renderPassInfo.framebuffer = *swapChainFramebuffers[imageIndex];

renderPassInfo.renderArea.offset = vk::Offset2D{0, 0};

renderPassInfo.renderArea.extent = swapChainExtent;

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

renderPassInfo.clearValueCount = 1;

renderPassInfo.pClearValues = &clearColor;

commandBuffer.beginRenderPass(renderPassInfo, vk::SubpassContents::eInline);

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

vk::Viewport viewport{};

viewport.x = 0.0f;

viewport.y = 0.0f;

viewport.width = (float) swapChainExtent.width;

viewport.height = (float) swapChainExtent.height;

viewport.minDepth = 0.0f;

viewport.maxDepth = 1.0f;

commandBuffer.setViewport(0, viewport);

vk::Rect2D scissor{};

scissor.offset = vk::Offset2D{0, 0};

scissor.extent = swapChainExtent;

commandBuffer.setScissor(0, scissor);

vk::Buffer vertexBuffers[] = {*vertexBuffer};

vk::DeviceSize offsets[] = {0};

commandBuffer.bindVertexBuffers(0, vertexBuffers, offsets);

commandBuffer.bindIndexBuffer(*indexBuffer, 0, vk::IndexType::eUint16);

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

commandBuffer.endRenderPass();

commandBuffer.end();

}

void createSyncObjects() {

vk::SemaphoreCreateInfo semaphoreInfo{};

vk::FenceCreateInfo fenceInfo{};

fenceInfo.flags = vk::FenceCreateFlagBits::eSignaled;

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

imageAvailableSemaphores.push_back(device.createSemaphore(semaphoreInfo));

inFlightFences.push_back(device.createFence(fenceInfo));

}

createRenderFinishedSemaphores();

}

void createRenderFinishedSemaphores() {

// The semaphore signaled when rendering finishes is waited on by the presentation

// engine, which may still be using it when the frame slot comes around again, so

// there is one per swap chain image instead of one per frame in flight

vk::SemaphoreCreateInfo semaphoreInfo{};

renderFinishedSemaphores.clear();

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

renderFinishedSemaphores.push_back(device.createSemaphore(semaphoreInfo));

}

}

void drawFrame() {

(void) device.waitForFences(*inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);

// An out-of-date swap chain is reported with an exception, like other errors.

// VK_SUBOPTIMAL_KHR is returned in the result, and the image can still be used.

uint32_t imageIndex;

try {

imageIndex = swapChain.acquireNextImage(UINT64_MAX, *imageAvailableSemaphores[currentFrame]).second;

} catch (vk::OutOfDateKHRError&) {

recreateSwapChain();

return;

}

device.resetFences(*inFlightFences[currentFrame]);

commandBuffers[currentFrame].reset();

recordCommandBuffer(commandBuffers[currentFrame], imageIndex);

vk::SubmitInfo submitInfo{};

vk::Semaphore waitSemaphores[] = {*imageAvailableSemaphores[currentFrame]};

vk::PipelineStageFlags waitStages[] = {vk::PipelineStageFlagBits::eColorAttachmentOutput};

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = waitSemaphores;

submitInfo.pWaitDstStageMask = waitStages;

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &*commandBuffers[currentFrame];

vk::Semaphore signalSemaphores[] = {*renderFinishedSemaphores[imageIndex]};

submitInfo.signalSemaphoreCount = 1;

submitInfo.pSignalSemaphores = signalSemaphores;

graphicsQueue.submit(submitInfo, *inFlightFences[currentFrame]);

vk::PresentInfoKHR presentInfo{};

presentInfo.waitSemaphoreCount = 1;

presentInfo.pWaitSemaphores = signalSemaphores;

vk::SwapchainKHR swapChains[] = {*swapChain};

presentInfo.swapchainCount = 1;

presentInfo.pSwapchains = swapChains;

presentInfo.pImageIndices = &imageIndex;

// A suboptimal swap chain can still be presented to. Android keeps reporting it while

// the display is rotated, because we let the window system rotate the images (see

// chooseSwapPreTransform), so recreating it for that reason would never end

bool swapChainOutOfDate = false;

try {

(void) presentQueue.presentKHR(presentInfo);

} catch (vk::OutOfDateKHRError&) {

swapChainOutOfDate = true;

}

if (swapChainOutOfDate || framebufferResized) {

framebufferResized = false;

recreateSwapChain();

}

currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;

}

vk::raii::ShaderModule createShaderModule(const std::vector<char>& code) {

vk::ShaderModuleCreateInfo createInfo{};

createInfo.codeSize = code.size();

createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());

return device.createShaderModule(createInfo);

}

vk::SurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats) {

for (const auto& availableFormat : availableFormats) {

// Android usually offers RGBA rather than BGRA formats

if ((availableFormat.format == vk::Format::eB8G8R8A8Srgb || availableFormat.format == vk::Format::eR8G8B8A8Srgb) && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {

return availableFormat;

}

}

return availableFormats[0];

}

vk::PresentModeKHR chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes) {

for (const auto& availablePresentMode : availablePresentModes) {

if (availablePresentMode == vk::PresentModeKHR::eMailbox) {

return availablePresentMode;

}

}

return vk::PresentModeKHR::eFifo;

}

vk::SurfaceTransformFlagBitsKHR chooseSwapPreTransform(const vk::SurfaceCapabilitiesKHR& capabilities) {

// When the display is rotated, some platforms, like Android, report the rotation

// as the current transform. Presenting with that transform would mean rendering

// rotated images ourselves, so let the window system rotate them instead

if (capabilities.supportedTransforms & vk::SurfaceTransformFlagBitsKHR::eIdentity) {

return vk::SurfaceTransformFlagBitsKHR::eIdentity;

}

return capabilities.currentTransform;

}

vk::CompositeAlphaFlagBitsKHR chooseSwapCompositeAlpha(const vk::SurfaceCapabilitiesKHR& capabilities) {

// Some platforms, like Android, only support letting the window system decide

if (capabilities.supportedCompositeAlpha & vk::CompositeAlphaFlagBitsKHR::eOpaque) {

return vk::CompositeAlphaFlagBitsKHR::eOpaque;

}

return vk::CompositeAlphaFlagBitsKHR::eInherit;

}

vk::Extent2D chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities) {

if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {

return capabilities.currentExtent;

} else {

int width, height;

glfwGetFramebufferSize(window.get(), &width, &height);

vk::Extent2D actualExtent = {

static_cast<uint32_t>(width),

static_cast<uint32_t>(height)

};

actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);

actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);

return actualExtent;

}

}

SwapChainSupportDetails querySwapChainSupport(const vk::raii::PhysicalDevice& device) {

SwapChainSupportDetails details;

details.capabilities = device.getSurfaceCapabilitiesKHR(*surface);

details.formats = device.getSurfaceFormatsKHR(*surface);

details.presentModes = device.getSurfacePresentModesKHR(*surface);

return details;

}

bool isDeviceSuitable(const vk::raii::PhysicalDevice& device) {

QueueFamilyIndices indices = findQueueFamilies(device);

bool extensionsSupported = checkDeviceExtensionSupport(device);

bool swapChainAdequate = false;

if (extensionsSupported) {

SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);

swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();

}

return indices.isComplete() && extensionsSupported && swapChainAdequate;

}

bool checkDeviceExtensionSupport(const vk::raii::PhysicalDevice& device) {

std::vector<vk::ExtensionProperties> availableExtensions = device.enumerateDeviceExtensionProperties();

std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());

for (const auto& extension : availableExtensions) {

requiredExtensions.erase(extension.extensionName);

}

return requiredExtensions.empty();

}

QueueFamilyIndices findQueueFamilies(const vk::raii::PhysicalDevice& device) {

QueueFamilyIndices indices;

std::vector<vk::QueueFamilyProperties> queueFamilies = device.getQueueFamilyProperties();

int i = 0;

for (const auto& queueFamily : queueFamilies) {

if (queueFamily.queueFlags & vk::QueueFlagBits::eGraphics) {

indices.graphicsFamily = i;

}

if (device.getSurfaceSupportKHR(i, *surface)) {

indices.presentFamily = i;

}

if (indices.isComplete()) {

break;

}

i++;

}

return indices;

}

std::vector<const char*> getRequiredExtensions() {

uint32_t glfwExtensionCount = 0;

const char** glfwExtensions;

glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);

if (enableValidationLayers) {

extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

}

return extensions;

}

bool checkValidationLayerSupport() {

std::vector<vk::LayerProperties> availableLayers = context.enumerateInstanceLayerProperties();

for (const char* layerName : validationLayers) {

bool layerFound = false;

for (const auto& layerProperties : availableLayers) {

if (strcmp(layerName, layerProperties.layerName) == 0) {

layerFound = true;

break;

}

}

if (!layerFound) {

return false;

}

}

return true;

}

static std::vector<char> readFile(const std::string& filename) {

std::ifstream file(filename, std::ios::ate | std::ios::binary);

if (!file.is_open()) {

throw std::runtime_error("failed to open file!");

}

size_t fileSize = (size_t) file.tellg();

std::vector<char> buffer(fileSize);

file.seekg(0);

file.read(buffer.data(), fileSize);

file.close();

return buffer;

}

static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {

std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;

return VK_FALSE;

}

HelloTriangleApplication app;

try {

app.run();

} catch (const std::exception& e) {

std::cerr << e.what() << std::endl;

return EXIT_FAILURE;

}

return EXIT_SUCCESS;