QueueFamilyIndices indices = findQueueFamilies(physicalDevice);

if (!indices.graphicsFamily.has_value()) {

throw std::runtime_error("failed to find graphics queue family");

}

return indices.graphicsFamily.value();

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;

LOG_INFO("Initialising Vulkan renderer...");

// Create the Vulkan instance (entry point into the Vulkan API)

createInstance();

// Set up the debug messenger (if validation layers are enabled)

setupDebugMessenger();

// If we have a surface provider, create and attach the VK surface

if (surfaceProvider) {

surface = surfaceProvider->createSurface(instance);

if (surface != VK_NULL_HANDLE) {

LOG_DEBUG("VK surface attached. Enabling extension " +

std::string(VK_KHR_SWAPCHAIN_EXTENSION_NAME));

deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

}

}

// Pick the physical device

pickPhysicalDevice();

// Create a logical device from the physical device

createLogicalDevice();

// Create a swap chain if we have a surface attached

if (surface != VK_NULL_HANDLE) {

createSwapChain();

createImageViews();

}

// Create objects for our graphics pipeline

createRenderPass();

createGraphicsPipeline();

createFramebuffers();

// Create objects to draw our frames

createCommandPool();

createCommandBuffers();

createSyncObjects();

if (!enableValidationLayers) {

return;

}

VkDebugUtilsMessengerCreateInfoEXT createInfo = {};

populateDebugMessengerCreateInfo(createInfo);

// Create the Vulkan debug messenger extension if available

if (createDebugUtilsMessengerEXT(&createInfo, nullptr) != VK_SUCCESS) {

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

}

VkDebugUtilsMessengerCreateInfoEXT &createInfo) {

createInfo = {};

createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;

// Configure what severity levels will trigger the callback

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;

// Configure which message types will be handled

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;

createInfo.pUserData = nullptr; // Optional user-specific data

const VkAllocationCallbacks *pAllocator) {

// Query function pointer to the extension function (not loaded by default)

auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(

instance, "vkCreateDebugUtilsMessengerEXT");

if (func != nullptr) {

return func(instance, pCreateInfo, pAllocator, &debugMessenger);

} else {

return VK_ERROR_EXTENSION_NOT_PRESENT;

}

// Destroy the debug messenger via its extension

auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(

instance, "vkDestroyDebugUtilsMessengerEXT");

if (func != nullptr) {

func(instance, debugMessenger, pAllocator);

}

// Fail early if validation layers are requested but unavailable

if (enableValidationLayers && !checkValidationLayerSupport()) {

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

}

// Fill in application info (optional, but helps some drivers optimise)

VkApplicationInfo appInfo = {};

appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

appInfo.pApplicationName = "Vulkan Renderer and Encoder";

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;

// Fill in instance creation info

VkInstanceCreateInfo createInfo = {};

createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

createInfo.pApplicationInfo = &appInfo;

// Vulkan is a platform agnostic API, which means we need to pass an extension interface.

// List required extensions (e.g. from GLFW)

auto extensions = getRequiredExtensions();

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

createInfo.ppEnabledExtensionNames = extensions.data();

// Enable validation layers if requested (when running in debug mode)

VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {};

if (enableValidationLayers) {

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

createInfo.ppEnabledLayerNames = validationLayers.data();

// Hook debug messenger creation into instance creation

populateDebugMessengerCreateInfo(debugCreateInfo);

createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT *)&debugCreateInfo;

} else {

createInfo.enabledLayerCount = 0;

createInfo.pNext = nullptr;

}

// Finally, create the Vulkan instance

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

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

}

uint32_t deviceCount = 0;

vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

if (deviceCount == 0) {

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

}

// Retrieve all physical devices

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

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

// Select the first suitable physical device

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

}

// Log the selected device name

VkPhysicalDeviceProperties deviceProperties;

vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);

std::string deviceName = deviceProperties.deviceName;

LOG_INFO("Using device " + deviceName);

// Find queue family indices for the selected physical device

QueueFamilyIndices indicies = findQueueFamilies(physicalDevice);

std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;

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

// If surface is attached insert present queue family

if (surface != VK_NULL_HANDLE) {

uniqueQueueFamilies.insert(indicies.presentFamily.value());

}

// Iterate over queue families and fill queue create info

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

}

// Enable required device features (none for now)

VkPhysicalDeviceFeatures deviceFeatures = {};

// Fill in the device creation info

VkDeviceCreateInfo createInfo = {};

createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

createInfo.pQueueCreateInfos = queueCreateInfos.data();

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

createInfo.pEnabledFeatures = &deviceFeatures;

// Enable device extensions (e.g. H.264 encoding)

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

createInfo.ppEnabledExtensionNames = deviceExtensions.data();

// Enable validation layers if requested

if (enableValidationLayers) {

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

createInfo.ppEnabledLayerNames = validationLayers.data();

} else {

createInfo.enabledLayerCount = 0;

}

// Create the logical device

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

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

}

// Retrieve a handle to the graphics queue from the created device

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

// Optionally retrieve handle to the present queue from the created device

if (surface != VK_NULL_HANDLE) {

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

}

LOG_INFO("Vulkan logical device created.");

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.queueFamilyIndexCount = 0;

createInfo.pQueueFamilyIndices = nullptr;

}

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;

LOG_INFO("Vulkan swapchain created.");

vkDeviceWaitIdle(device);

cleanupSwapChain();

createSwapChain();

createImageViews();

createFramebuffers();

swapChainImageViews.resize(swapChainImages.size());

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

VkImageViewCreateInfo createInfo{};

createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;

createInfo.image = swapChainImages[i];

createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;

createInfo.format = swapChainImageFormat;

createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;

createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

createInfo.subresourceRange.baseMipLevel = 0;

createInfo.subresourceRange.levelCount = 1;

createInfo.subresourceRange.baseArrayLayer = 0;

createInfo.subresourceRange.layerCount = 1;

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

VK_SUCCESS) {

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

}

}

LOG_INFO("Vulkan image views created.");

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

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

VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);

VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);

VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};

vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;

vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;

vertShaderStageInfo.module = vertShaderModule;

vertShaderStageInfo.pName = "main";

VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};

fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;

fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;

fragShaderStageInfo.module = fragShaderModule;

fragShaderStageInfo.pName = "main";

VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};

VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};

vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;

vertexInputInfo.vertexBindingDescriptionCount = 0;

vertexInputInfo.vertexAttributeDescriptionCount = 0;

VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};

inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;

inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;

inputAssembly.primitiveRestartEnable = VK_FALSE;

VkPipelineViewportStateCreateInfo viewportState = {};

viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;

viewportState.viewportCount = 1;

viewportState.scissorCount = 1;

VkPipelineRasterizationStateCreateInfo rasterizer = {};

rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;

rasterizer.depthClampEnable = VK_FALSE;

rasterizer.rasterizerDiscardEnable = VK_FALSE;

rasterizer.polygonMode = VK_POLYGON_MODE_FILL;

rasterizer.lineWidth = 1.0f;

rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;

rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;

rasterizer.depthBiasEnable = VK_FALSE;

VkPipelineMultisampleStateCreateInfo multisampling = {};

multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;

multisampling.sampleShadingEnable = VK_FALSE;

multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;

VkPipelineColorBlendAttachmentState colorBlendAttachment = {};

colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |

VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;

colorBlendAttachment.blendEnable = VK_FALSE;

VkPipelineColorBlendStateCreateInfo colorBlending = {};

colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;

colorBlending.logicOpEnable = VK_FALSE;

colorBlending.logicOp = VK_LOGIC_OP_COPY;

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<VkDynamicState> dynamicStates = {VK_DYNAMIC_STATE_VIEWPORT,

VK_DYNAMIC_STATE_SCISSOR};

VkPipelineDynamicStateCreateInfo dynamicState = {};

dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;

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

dynamicState.pDynamicStates = dynamicStates.data();

VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};

pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;

pipelineLayoutInfo.setLayoutCount = 0;

pipelineLayoutInfo.pushConstantRangeCount = 0;

if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) !=

VK_SUCCESS) {

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

}

VkGraphicsPipelineCreateInfo pipelineInfo = {};

pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;

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

if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr,

&graphicsPipeline) != VK_SUCCESS) {

throw std::runtime_error("failed to create graphics pipeline");

}

vkDestroyShaderModule(device, fragShaderModule, nullptr);

vkDestroyShaderModule(device, vertShaderModule, nullptr);

LOG_INFO("Graphics pipeline created.");

swapChainFramebuffers.resize(swapChainImageViews.size());

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

VkImageView attachments[] = {swapChainImageViews[i]};

VkFramebufferCreateInfo framebufferInfo = {};

framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;

framebufferInfo.renderPass = renderPass;

framebufferInfo.attachmentCount = 1;

framebufferInfo.pAttachments = attachments;

framebufferInfo.width = swapChainExtent.width;

framebufferInfo.height = swapChainExtent.height;

framebufferInfo.layers = 1;

if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) !=

VK_SUCCESS) {

throw std::runtime_error("failed to create framebuffer");

}

}

LOG_INFO("Framebuffers created.");

QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);

VkCommandPoolCreateInfo poolInfo = {};

poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;

poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

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

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

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

}

LOG_INFO("Command pool created.");

commandBuffers.resize(maxFramesInFlight);

VkCommandBufferAllocateInfo allocInfo = {};

allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;

allocInfo.commandPool = commandPool;

allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;

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

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

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

}

LOG_INFO("Command buffer created.");

VkCommandBufferBeginInfo beginInfo = {};

beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

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

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

}

VkRenderPassBeginInfo renderPassInfo = {};

renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;

renderPassInfo.renderPass = renderPass;

renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];

renderPassInfo.renderArea.offset = {0, 0};

renderPassInfo.renderArea.extent = swapChainExtent;

VkClearValue clearColor = {{{0.0f, 0.0f, 0.0f, 1.0f}}};

renderPassInfo.clearValueCount = 1;

renderPassInfo.pClearValues = &clearColor;

vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);

vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);

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

vkCmdSetViewport(commandBuffer, 0, 1, &viewport);

VkRect2D scissor{};

scissor.offset = {0, 0};

scissor.extent = swapChainExtent;

vkCmdSetScissor(commandBuffer, 0, 1, &scissor);

vkCmdDraw(commandBuffer, 3, 1, 0, 0);

vkCmdEndRenderPass(commandBuffer);

if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {

throw std::runtime_error("failed to record command buffer");

}

VkAttachmentDescription colorAttachment = {};

colorAttachment.format = swapChainImageFormat;

colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;

colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;

colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;

colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;

colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;

colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

VkAttachmentReference colorAttachmentRef = {};

colorAttachmentRef.attachment = 0;

colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

VkSubpassDescription subpass = {};

subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

subpass.colorAttachmentCount = 1;

subpass.pColorAttachments = &colorAttachmentRef;

VkRenderPassCreateInfo renderPassInfo = {};

renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;

renderPassInfo.attachmentCount = 1;

renderPassInfo.pAttachments = &colorAttachment;

renderPassInfo.subpassCount = 1;

renderPassInfo.pSubpasses = &subpass;

if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {

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

}

VkShaderModuleCreateInfo createInfo{};

createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;

createInfo.codeSize = code.size();

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

VkShaderModule shaderModule;

if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {

throw std::runtime_error("failed to create shader module");

}

return shaderModule;

VkPhysicalDeviceProperties deviceProperties;

vkGetPhysicalDeviceProperties(device, &deviceProperties);

std::string deviceName = deviceProperties.deviceName;

QueueFamilyIndices indicies = findQueueFamilies(device);

bool extensionsSupported = checkDeviceExtensionSupport(device);

bool swapChainAdequate = true; // If no surface attached simply set this to true

if (surface != VK_NULL_HANDLE) {

swapChainAdequate = false;

if (extensionsSupported) {

// Swap chain support is sufficient for this tutorial if there is at least one supported

// image format and one supported presentation mode

SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);

swapChainAdequate =

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

}

}

if (!indicies.isComplete(surface)) {

LOG_WARN("Device " + std::string(deviceProperties.deviceName) +

" is missing required queue families");

}

if (!extensionsSupported) {

LOG_WARN("Device " + std::string(deviceProperties.deviceName) +

" is missing required extensions");

}

if (surface != VK_NULL_HANDLE && !swapChainAdequate) {

LOG_WARN("Device " + std::string(deviceProperties.deviceName) +

" is missing swap chain support");

}

return indicies.isComplete(surface) && extensionsSupported && swapChainAdequate;

uint32_t extensionCount;

vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);

std::vector<VkExtensionProperties> availableExtensions(extensionCount);

vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount,

availableExtensions.data());

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

for (const auto &extension : availableExtensions) {

LOG_VERBOSE("Found device extension " + std::string(extension.extensionName));

std::size_t erased = requiredExtensions.erase(extension.extensionName);

if (erased > 0) {

LOG_DEBUG("Found required device extension " + std::string(extension.extensionName));

}

}

if (!requiredExtensions.empty()) {

for (const auto &missing : requiredExtensions) {

LOG_WARN("Missing device extension: " + std::string(missing));

}

}

return requiredExtensions.empty();

QueueFamilyIndices indices;

uint32_t queueFamilyCount = 0;

vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);

std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);

vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());

for (std::size_t i = 0; i < queueFamilies.size(); ++i) {

// Look for a queue family that supports graphics commands

if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {

indices.graphicsFamily = i;

}

// Check to see if present support is available for the device.

// Only needed if we have a surface attached

if (surface != VK_NULL_HANDLE) {

VkBool32 presentSupport = false;

vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);

if (presentSupport) {

indices.presentFamily = i;

}

}

// Stop early if all required queues are found

if (indices.isComplete(surface)) {

break;

}

}

return indices;

SwapChainSupportDetails details;

if (surface != VK_NULL_HANDLE) {

vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);

uint32_t formatCount;

vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);

if (formatCount != 0) {

details.formats.resize(formatCount);

vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount,

details.formats.data());

}

uint32_t presentModeCount;

vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);

if (presentModeCount != 0) {

details.presentModes.resize(presentModeCount);

vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount,

details.presentModes.data());

}

}

return details;

for (const auto &availableFormat : availableFormats) {

if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB &&

availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {

return availableFormat;

}

}

// Typically, we should "rank" these formats if we do not find the exact one we're after. In

// this case, we're just going to return the first format that is specified.

return availableFormats[0];

for (const auto &availablePresentMode : availablePresentModes) {

if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {

return availablePresentMode;

}

}

return VK_PRESENT_MODE_FIFO_KHR;

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

return capabilities.currentExtent;

} else {

int width, height = 0;

// If we have no surface

if (surface == VK_NULL_HANDLE) {

LOG_WARN("VulkanRenderer::chooseSwapExtent called with no surface attached");

return {static_cast<uint32_t>(width), static_cast<uint32_t>(height)};

}

surfaceProvider->getFrameBufferSize(&width, &height);

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

}

// Query how many swapchain images we have

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

// Allocate per-image semaphores

imageAvailableSemaphores.resize(swapchainImageCount);

renderFinishedSemaphores.resize(swapchainImageCount);

// Per-frame fences (used for CPU-GPU synchronization)

inFlightFences.resize(maxFramesInFlight);

VkSemaphoreCreateInfo semaphoreInfo{};

semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

VkFenceCreateInfo fenceInfo{};

fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;

fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;

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

if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) !=

VK_SUCCESS ||

vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) !=

VK_SUCCESS) {

throw std::runtime_error("failed to create semaphores for swapchain images");

}

}

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

if (vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {

throw std::runtime_error("failed to create fences for frames in flight");

}

}

LOG_INFO("Synchronization objects created (per image).");

vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);

uint32_t imageIndex;

VkResult result =

vkAcquireNextImageKHR(device, swapChain, UINT64_MAX,

imageAvailableSemaphores[currentFrame], // Used only to gate rendering

VK_NULL_HANDLE, &imageIndex);

if (result == VK_ERROR_OUT_OF_DATE_KHR) {

recreateSwapChain();

return;

} else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {

throw std::runtime_error("failed to acquire swap chain image");

}

vkResetFences(device, 1, &inFlightFences[currentFrame]);

vkResetCommandBuffer(commandBuffers[currentFrame], 0);

recordCommandBuffer(commandBuffers[currentFrame], imageIndex);

VkSubmitInfo submitInfo{};

submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};

VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = waitSemaphores;

submitInfo.pWaitDstStageMask = waitStages;

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &commandBuffers[currentFrame];

VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[imageIndex]};

submitInfo.signalSemaphoreCount = 1;

submitInfo.pSignalSemaphores = signalSemaphores;

if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) {

throw std::runtime_error("failed to submit draw command buffer");

}

VkPresentInfoKHR presentInfo{};

presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;

presentInfo.waitSemaphoreCount = 1;

presentInfo.pWaitSemaphores = signalSemaphores;

VkSwapchainKHR swapChains[] = {swapChain};

presentInfo.swapchainCount = 1;

presentInfo.pSwapchains = swapChains;

presentInfo.pImageIndices = &imageIndex;

result = vkQueuePresentKHR(presentQueue, &presentInfo);

if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) {

recreateSwapChain();

} else if (result != VK_SUCCESS) {

throw std::runtime_error("failed to present swap chain image");

}

currentFrame = (currentFrame + 1) % maxFramesInFlight;

uint32_t layerCount;

vkEnumerateInstanceLayerProperties(&layerCount, nullptr);

std::vector<VkLayerProperties> availableLayers(layerCount);

vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());

// Check if all requested validation layers are available

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;

std::vector<const char *> extensions;

if (surfaceProvider) {

extensions = surfaceProvider->getRequiredInstanceExtensions();

}

// Add debug utils extension if validation is enabled

if (enableValidationLayers) {

extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

}

return extensions;

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

vkDestroyFramebuffer(device, swapChainFramebuffers[i], nullptr);

}

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

vkDestroyImageView(device, swapChainImageViews[i], nullptr);

}

if (swapChain != VK_NULL_HANDLE) {

vkDestroySwapchainKHR(device, swapChain, nullptr);

}

LOG_INFO("Shutting down Vulkan renderer.");

cleanupSwapChain();

vkDestroyPipeline(device, graphicsPipeline, nullptr);

vkDestroyPipelineLayout(device, pipelineLayout, nullptr);

vkDestroyRenderPass(device, renderPass, nullptr);

// Destroy per-image semaphores (sized by swapchain image count)

for (VkSemaphore semaphore : renderFinishedSemaphores) {

vkDestroySemaphore(device, semaphore, nullptr);

}

for (VkSemaphore semaphore : imageAvailableSemaphores) {

vkDestroySemaphore(device, semaphore, nullptr);

}

// Destroy per-frame fences (sized by maxFramesInFlight)

for (VkFence fence : inFlightFences) {

vkDestroyFence(device, fence, nullptr);

}

vkDestroyCommandPool(device, commandPool, nullptr);

vkDestroyDevice(device, nullptr);

if (enableValidationLayers) {

destroyDebugUtilsMessenger(nullptr);

}

if (surface != VK_NULL_HANDLE) {