1
void VulkanEngine::create_instance_raii() {
2
    glfwInit();
3
    check_validation_layers_support(this->context, this->info.required_layers);
4
    auto requiredExtensions = check_extensions_support(this->context);
5

6
    const ApplicationInfo appInfo{
7
        .pApplicationName   = this->info.app_name.c_str(),
8
        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
9
        .pEngineName        = this->info.engine_name.c_str(),
10
        .engineVersion      = VK_MAKE_VERSION(1, 0, 0),
11
        .apiVersion         = ApiVersion14,
12
    };
13
    const InstanceCreateInfo createInfo{
14
        .pApplicationInfo        = &appInfo,
15
        .enabledLayerCount       = static_cast<uint32_t>(this->info.required_layers.size()),
16
        .ppEnabledLayerNames     = this->info.required_layers.data(),
17
        .enabledExtensionCount   = static_cast<uint32_t>(requiredExtensions.size()),
18
        .ppEnabledExtensionNames = requiredExtensions.data(),
19
    };
20
    this->instance = raii::Instance(context, createInfo);
21
}

1
void VulkanEngine::create_debug_messenger_raii() {
2
    constexpr DebugUtilsMessageSeverityFlagsEXT severityFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | DebugUtilsMessageSeverityFlagBitsEXT::eWarning | DebugUtilsMessageSeverityFlagBitsEXT::eError);
3
    constexpr DebugUtilsMessageTypeFlagsEXT messageTypeFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral | DebugUtilsMessageTypeFlagBitsEXT::ePerformance | DebugUtilsMessageTypeFlagBitsEXT::eValidation);
4
    constexpr DebugUtilsMessengerCreateInfoEXT debugUtilsMessengerCreateInfoEXT{.messageSeverity = severityFlags, .messageType = messageTypeFlags, .pfnUserCallback = &debugCallback};
5
    this->debug_messenger = this->instance.createDebugUtilsMessengerEXT(debugUtilsMessengerCreateInfoEXT);
6
}

1
void VulkanEngine::create_surface_raii() {
2
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
3
    glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
4
    this->window = std::shared_ptr<GLFWwindow>(glfwCreateWindow(1920, 1080, "Vulkan Engine Window", nullptr, nullptr), [](GLFWwindow* ptr) {
5
        glfwDestroyWindow(ptr);
6
        glfwTerminate();
7
    });
8
    glfwSetWindowUserPointer(this->window.get(), this);
9
    glfwSetFramebufferSizeCallback(this->window.get(), framebufferResizeCallback);
10
    VkSurfaceKHR _surface;
11
    if (glfwCreateWindowSurface(*this->instance, this->window.get(), nullptr, &_surface) != 0) throw std::runtime_error("failed to create window surface!");
12
    this->surface = raii::SurfaceKHR(this->instance, _surface);
13
}

1
void VulkanEngine::pick_physical_device_raii() {
2
    std::vector<raii::PhysicalDevice> devices = instance.enumeratePhysicalDevices();
3
    const auto devIter                        = std::ranges::find_if(devices, [&](auto const& device) {
4
        // Check if the device supports the Vulkan 1.3 API version
5
        const bool supportsVulkan1_3 = device.getProperties().apiVersion >= VK_API_VERSION_1_3;
6

7
        // Check if any of the queue families support graphics operations
8
        auto queueFamilies          = device.getQueueFamilyProperties();
9
        const bool supportsGraphics = std::ranges::any_of(queueFamilies, [](auto const& qfp) { return !!(qfp.queueFlags & QueueFlagBits::eGraphics); });
10

11
        // Check if all required device extensions are available
12
        auto availableDeviceExtensions = device.enumerateDeviceExtensionProperties();
13
        const bool supportsAllRequiredExtensions =
14
            std::ranges::all_of(this->info.required_device_extensions, [&availableDeviceExtensions](auto const& requiredDeviceExtension) { return std::ranges::any_of(availableDeviceExtensions, [requiredDeviceExtension](auto const& availableDeviceExtension) { return strcmp(availableDeviceExtension.extensionName, requiredDeviceExtension) == 0; }); });
15

16
        auto features = device.template getFeatures2<PhysicalDeviceFeatures2, PhysicalDeviceVulkan11Features, PhysicalDeviceVulkan13Features, PhysicalDeviceExtendedDynamicStateFeaturesEXT>();
17
        const bool supportsRequiredFeatures =
18
            features.template get<PhysicalDeviceVulkan11Features>().shaderDrawParameters && features.template get<PhysicalDeviceVulkan13Features>().synchronization2 && features.template get<PhysicalDeviceVulkan13Features>().dynamicRendering && features.template get<PhysicalDeviceExtendedDynamicStateFeaturesEXT>().extendedDynamicState;
19

20
        return supportsVulkan1_3 && supportsGraphics && supportsAllRequiredExtensions && supportsRequiredFeatures;
21
    });
22
    if (devIter != devices.end()) {
23
        this->physical_device = *devIter;
24
    } else {
25
        throw std::runtime_error("failed to find a suitable GPU!");
26
    }
27
}

1
void VulkanEngine::create_logical_device_raii() {
2
    std::vector<QueueFamilyProperties> queueFamilyProperties = this->physical_device.getQueueFamilyProperties();
3

4
    // get the first index into queueFamilyProperties which supports both graphics and present
5
    for (uint32_t qfpIndex = 0; qfpIndex < queueFamilyProperties.size(); qfpIndex++) {
6
        if (queueFamilyProperties[qfpIndex].queueFlags & QueueFlagBits::eGraphics && this->physical_device.getSurfaceSupportKHR(qfpIndex, *this->surface)) {
7
            // found a queue family that supports both graphics and present
8
            this->queueIndex = qfpIndex;
9
            break;
10
        }
11
    }
12
    if (this->queueIndex == ~0) throw std::runtime_error("Could not find a queue for graphics and present -> terminating");
13

14
    // query for Vulkan 1.3 features
15
    StructureChain<PhysicalDeviceFeatures2, PhysicalDeviceVulkan11Features, PhysicalDeviceVulkan13Features, PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {
16
        {}, // vk::PhysicalDeviceFeatures2
17
        {.shaderDrawParameters = true}, // vk::PhysicalDeviceVulkan11Features
18
        {.synchronization2 = true, .dynamicRendering = true}, // vk::PhysicalDeviceVulkan13Features
19
        {.extendedDynamicState = true}, // vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT
20
    };
21

22
    // create a Device
23
    float queuePriority = 0.5f;
24
    DeviceQueueCreateInfo deviceQueueCreateInfo{
25
        .queueFamilyIndex = this->queueIndex,
26
        .queueCount       = 1,
27
        .pQueuePriorities = &queuePriority,
28
    };
29
    DeviceCreateInfo deviceCreateInfo{
30
        .pNext                   = &featureChain.get<PhysicalDeviceFeatures2>(),
31
        .queueCreateInfoCount    = 1,
32
        .pQueueCreateInfos       = &deviceQueueCreateInfo,
33
        .enabledExtensionCount   = static_cast<uint32_t>(this->info.required_device_extensions.size()),
34
        .ppEnabledExtensionNames = this->info.required_device_extensions.data(),
35
    };
36

37
    this->device = raii::Device(this->physical_device, deviceCreateInfo);
38
    this->queue  = raii::Queue(this->device, this->queueIndex, 0);
39
}

1
void VulkanEngine::create_swapchain_raii() {
2
    auto surfaceCapabilities = this->physical_device.getSurfaceCapabilitiesKHR(*this->surface);
3

4
    int width, height;
5
    glfwGetFramebufferSize(window.get(), &width, &height);
6
    this->swapchain_extent = surfaceCapabilities.currentExtent.width == 0xFFFFFFFF ? Extent2D{
7
                                                                                         std::clamp<uint32_t>(width, surfaceCapabilities.minImageExtent.width, surfaceCapabilities.maxImageExtent.width),
8
                                                                                         std::clamp<uint32_t>(height, surfaceCapabilities.minImageExtent.height, surfaceCapabilities.maxImageExtent.height),
9
                                                                                     }:surfaceCapabilities.currentExtent;
10

11
    const std::vector<SurfaceFormatKHR>& availableFormats = this->physical_device.getSurfaceFormatsKHR(*this->surface);
12
    const auto formatIt                                   = std::ranges::find_if(availableFormats, [](const auto& format) { return format.format == Format::eB8G8R8A8Srgb && format.colorSpace == ColorSpaceKHR::eSrgbNonlinear; });
13
    this->swapchain_surface_format                        = formatIt != availableFormats.end() ? *formatIt : availableFormats[0];
14

15
    auto minImageCount = std::max(3u, surfaceCapabilities.minImageCount);
16
    if (0 < surfaceCapabilities.maxImageCount && surfaceCapabilities.maxImageCount < minImageCount) minImageCount = surfaceCapabilities.maxImageCount;
17

18
    const SwapchainCreateInfoKHR swapChainCreateInfo{.surface = *this->surface,
19
        .minImageCount                                        = minImageCount,
20
        .imageFormat                                          = this->swapchain_surface_format.format,
21
        .imageColorSpace                                      = this->swapchain_surface_format.colorSpace,
22
        .imageExtent                                          = this->swapchain_extent,
23
        .imageArrayLayers                                     = 1,
24
        .imageUsage                                           = ImageUsageFlagBits::eColorAttachment,
25
        .imageSharingMode                                     = SharingMode::eExclusive,
26
        .preTransform                                         = surfaceCapabilities.currentTransform,
27
        .compositeAlpha                                       = CompositeAlphaFlagBitsKHR::eOpaque,
28
        .presentMode                                          = std::ranges::any_of(this->physical_device.getSurfacePresentModesKHR(*this->surface), [](const PresentModeKHR value) { return PresentModeKHR::eMailbox == value; }) ? PresentModeKHR::eMailbox : PresentModeKHR::eFifo,
29
        .clipped                                              = true};
30

31
    this->swapchain        = raii::SwapchainKHR(device, swapChainCreateInfo);
32
    this->swapchain_images = this->swapchain.getImages();
33
}

1
void VulkanEngine::create_graphics_pipeline_raii() {
2
    raii::ShaderModule shaderModule = create_shader_module(readFile("shaders/shader1.spv"));
3

4
    PipelineShaderStageCreateInfo vertShaderStageInfo{.stage = ShaderStageFlagBits::eVertex, .module = shaderModule, .pName = "vertMain"};
5
    PipelineShaderStageCreateInfo fragShaderStageInfo{.stage = ShaderStageFlagBits::eFragment, .module = shaderModule, .pName = "fragMain"};
6
    PipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
7

8
    PipelineVertexInputStateCreateInfo vertexInputInfo;
9
    PipelineInputAssemblyStateCreateInfo inputAssembly{.topology = PrimitiveTopology::eTriangleList};
10
    PipelineViewportStateCreateInfo viewportState{.viewportCount = 1, .scissorCount = 1};
11

12
    PipelineRasterizationStateCreateInfo rasterizer{.depthClampEnable = False, .rasterizerDiscardEnable = False, .polygonMode = PolygonMode::eFill, .cullMode = CullModeFlagBits::eBack, .frontFace = FrontFace::eClockwise, .depthBiasEnable = False, .depthBiasSlopeFactor = 1.0f, .lineWidth = 1.0f};
13

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

16
    PipelineColorBlendAttachmentState colorBlendAttachment{.blendEnable = False, .colorWriteMask = ColorComponentFlagBits::eR | ColorComponentFlagBits::eG | ColorComponentFlagBits::eB | ColorComponentFlagBits::eA};
17

18
    PipelineColorBlendStateCreateInfo colorBlending{.logicOpEnable = False, .logicOp = LogicOp::eCopy, .attachmentCount = 1, .pAttachments = &colorBlendAttachment};
19

20
    std::vector dynamicStates = {DynamicState::eViewport, DynamicState::eScissor};
21
    PipelineDynamicStateCreateInfo dynamicState{.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()), .pDynamicStates = dynamicStates.data()};
22

23
    PipelineLayoutCreateInfo pipelineLayoutInfo{.setLayoutCount = 0, .pushConstantRangeCount = 0};
24

25
    this->pipeline_layout = raii::PipelineLayout(device, pipelineLayoutInfo);
26

27
    StructureChain<GraphicsPipelineCreateInfo, PipelineRenderingCreateInfo> pipelineCreateInfoChain = {{
28
                                                                                                           .stageCount          = 2,
29
                                                                                                           .pStages             = shaderStages,
30
                                                                                                           .pVertexInputState   = &vertexInputInfo,
31
                                                                                                           .pInputAssemblyState = &inputAssembly,
32
                                                                                                           .pViewportState      = &viewportState,
33
                                                                                                           .pRasterizationState = &rasterizer,
34
                                                                                                           .pMultisampleState   = &multisampling,
35
                                                                                                           .pColorBlendState    = &colorBlending,
36
                                                                                                           .pDynamicState       = &dynamicState,
37
                                                                                                           .layout              = this->pipeline_layout,
38
                                                                                                           .renderPass          = nullptr,
39
                                                                                                       },
40
        {
41
            .colorAttachmentCount    = 1,
42
            .pColorAttachmentFormats = &this->swapchain_surface_format.format,
43
        }};
44

45
    this->graphics_pipeline = raii::Pipeline(device, nullptr, pipelineCreateInfoChain.get<GraphicsPipelineCreateInfo>());
46
}