HelloTriangleApplication Class Reference

Public Member Functions
void	run ()

Private Member Functions
void	initVulkan ()
void	initWindow ()
void	mainLoop ()
void	cleanup ()
void	createInstance ()
void	setupDebugMessenger ()
void	pickPhysicalDevice ()
uint32_t	findQueueFamilies (vk::raii::PhysicalDevice physicalDevice)
void	createLogicalDevice ()
void	createSurface ()

Static Private Member Functions
static VKAPI_ATTR vk::Bool32 VKAPI_CALL	debugCallback (vk::DebugUtilsMessageSeverityFlagBitsEXT severity, vk::DebugUtilsMessageTypeFlagsEXT type, const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData, void *)

Private Attributes
GLFWwindow *	_window = nullptr
vk::raii::Context	_context
vk::raii::Instance	_instance = nullptr
vk::raii::PhysicalDevice	_physicalDevice = nullptr
vk::raii::DebugUtilsMessengerEXT	_debugMessenger = nullptr
vk::raii::Device	_device = nullptr
vk::raii::Queue	_graphicsQueue = nullptr
vk::raii::SurfaceKHR	surface = nullptr
vk::raii::Queue	_presentQueue = nullptr
std::vector< const char * >	deviceExtensions

Member Function Documentation

cleanup()

void HelloTriangleApplication::cleanup ( )

inlineprivate

                   {
        glfwDestroyWindow(_window);
        glfwTerminate();
    }

References _window, glfwDestroyWindow(), and glfwTerminate().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

createInstance()

void HelloTriangleApplication::createInstance ( )

inlineprivate

                          {
        // Some elements are optional, replace by builder pattern
        constexpr vk::ApplicationInfo APP_INFO{
            .pApplicationName   = "Hello Triangle",
            .applicationVersion = VK_MAKE_VERSION( 1, 0, 0 ),
            .pEngineName        = "No Engine",
            .engineVersion      = VK_MAKE_VERSION( 1, 0, 0 ),
            .apiVersion         = vk::ApiVersion13
        };
 
 
        // 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();
        if (std::ranges::any_of(requiredLayers, [&layerProperties](auto const& requiredLayer) {
            return std::ranges::none_of(layerProperties,
                                       [requiredLayer](auto const& layerProperty)
                                       { return strcmp(layerProperty.layerName, requiredLayer) == 0; });
        }))
        {
            throw std::runtime_error("One or more required layers are not supported!");
        }
 
        for (auto layer: requiredLayers) {
            std::cout << layer << std::endl;
        }
 
        // Get the required instance extensions from GLFW.
        uint32_t glfwExtensionCount = 0;
        auto glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
 
        auto extensions = _context.enumerateInstanceExtensionProperties();
        std::cout << "available extensions:\n";
 
        for (const auto& extension : extensions) {
            std::cout << '\t' << extension.extensionName << '\n';
        }
 
        // Check if the required GLFW extensions are supported by the Vulkan implementation.
        auto extensionProperties = _context.enumerateInstanceExtensionProperties();
        for (uint32_t i = 0; i < glfwExtensionCount; ++i)
        {
            if (std::ranges::none_of(extensionProperties,
                                     [glfwExtension = glfwExtensions[i]](auto const& extensionProperty)
                                     { return strcmp(extensionProperty.extensionName, glfwExtension) == 0; }))
            {
                throw std::runtime_error("Required GLFW extension not supported: " + std::string(glfwExtensions[i]));
            }
        }
 
        vk::InstanceCreateInfo createInfo{
            .pApplicationInfo = &APP_INFO,
            .enabledLayerCount = static_cast<uint32_t>(requiredLayers.size()),
            .ppEnabledLayerNames     = requiredLayers.data(),
            .enabledExtensionCount = glfwExtensionCount,
            .ppEnabledExtensionNames = glfwExtensions,
        };
 
        _instance = vk::raii::Instance(_context, createInfo);
    }

References _context, _instance, enableValidationLayers, glfwGetRequiredInstanceExtensions(), and validationLayers.

Referenced by initVulkan().

Here is the call graph for this function:

Here is the caller graph for this function:

createLogicalDevice()

void HelloTriangleApplication::createLogicalDevice ( )

inlineprivate

                               {
        std::vector<vk::QueueFamilyProperties> queueFamilyProperties = _physicalDevice.getQueueFamilyProperties();
        uint32_t graphicsIndex = findQueueFamilies(_physicalDevice);
 
        // determine a queueFamilyIndex that supports present
        // first check if the graphicsIndex is good enough
        auto presentIndex = _physicalDevice.getSurfaceSupportKHR(graphicsIndex, *surface )
                                           ? graphicsIndex : static_cast<uint32_t>(queueFamilyProperties.size());
 
        if ( presentIndex == queueFamilyProperties.size() )
        {
            // the graphicsIndex doesn't support present -> look for another family index that supports both
            // graphics and present
            for ( size_t i = 0; i < queueFamilyProperties.size(); i++ )
            {
                if ( ( queueFamilyProperties[i].queueFlags & vk::QueueFlagBits::eGraphics ) &&
                     _physicalDevice.getSurfaceSupportKHR( static_cast<uint32_t>( i ), *surface ) )
                {
                    graphicsIndex = static_cast<uint32_t>( i );
                    presentIndex  = graphicsIndex;
                    break;
                }
            }
            if ( presentIndex == queueFamilyProperties.size() )
            {
                // there's nothing like a single family index that supports both graphics and present -> look for another
                // family index that supports present
                for ( size_t i = 0; i < queueFamilyProperties.size(); i++ )
                {
                    if ( _physicalDevice.getSurfaceSupportKHR( static_cast<uint32_t>( i ), *surface ) )
                    {
                        presentIndex = static_cast<uint32_t>( i );
                        break;
                    }
                }
            }
        }
        if ( ( graphicsIndex == queueFamilyProperties.size() ) || ( presentIndex == queueFamilyProperties.size() ) )
        {
            throw std::runtime_error( "Could not find a queue for graphics or present -> terminating" );
        }
 
 
 
        float queuePriority = 1.0f; // Vulkan lets you assign priorities to queues to influence the scheduling of command buffer execution using floating point numbers between 0.0 and 1.0
        //The currently available drivers will only allow you to create a small number of queues for each queue family, and you don’t really need more than one
        vk::DeviceQueueCreateInfo deviceQueueCreateInfo { .queueFamilyIndex = graphicsIndex, .queueCount = 1, .pQueuePriorities = &queuePriority };
        vk::PhysicalDeviceFeatures deviceFeatures;
 
 
 
        // Here maybe use a builder to add features to pnext
        // Create a chain of feature structures
        vk::StructureChain<vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceVulkan13Features, vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT> featureChain = {
            {},                               // vk::PhysicalDeviceFeatures2 (empty for now)
            {.dynamicRendering = true },      // Enable dynamic rendering from Vulkan 1.3
            {.extendedDynamicState = true },   // Enable extended dynamic state from the extension
        };
 
        vk::DeviceCreateInfo deviceCreateInfo{
            .pNext = &featureChain.get<vk::PhysicalDeviceFeatures2>(),
            .queueCreateInfoCount = 1,
            .pQueueCreateInfos = &deviceQueueCreateInfo,
            .enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()),
            .ppEnabledExtensionNames = deviceExtensions.data()
        };
 
        _device = vk::raii::Device(_physicalDevice, deviceCreateInfo);
        _graphicsQueue = vk::raii::Queue( _device, graphicsIndex, 0 );
        _presentQueue = vk::raii::Queue( _device, presentIndex, 0 );
    }

References _device, _graphicsQueue, _physicalDevice, _presentQueue, deviceExtensions, findQueueFamilies(), and surface.

Here is the call graph for this function:

createSurface()

void HelloTriangleApplication::createSurface ( )

inlineprivate

                         {
        VkSurfaceKHR _surface;
        if (glfwCreateWindowSurface(*_instance, _window, nullptr, &_surface) != 0) {
            throw std::runtime_error("failed to create window surface!");
        }
        surface = vk::raii::SurfaceKHR(_instance, _surface);
    }

References _instance, _window, and surface.

debugCallback()

static VKAPI_ATTR vk::Bool32 VKAPI_CALL HelloTriangleApplication::debugCallback ( vk::DebugUtilsMessageSeverityFlagBitsEXT severity, vk::DebugUtilsMessageTypeFlagsEXT type, const vk::DebugUtilsMessengerCallbackDataEXT * pCallbackData, void *  )

inlinestaticprivate

    {
        if (severity >= vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning)
            std::cerr << "validation layer: type " << to_string(type) << " msg: " << pCallbackData->pMessage << std::endl;
        return vk::False;
    }

Referenced by setupDebugMessenger().

Here is the caller graph for this function:

findQueueFamilies()

uint32_t HelloTriangleApplication::findQueueFamilies ( vk::raii::PhysicalDevice physicalDevice )

inlineprivate

                                                                    {
        // find the index of the first queue family that supports graphics
        std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
 
        // get the first index into queueFamilyProperties which supports graphics
        auto graphicsQueueFamilyProperty =
          std::find_if( queueFamilyProperties.begin(),
                        queueFamilyProperties.end(),
                        []( vk::QueueFamilyProperties const & qfp ) { return qfp.queueFlags & vk::QueueFlagBits::eGraphics; } );
 
        return static_cast<uint32_t>(std::distance(queueFamilyProperties.begin(), graphicsQueueFamilyProperty));
    }

Referenced by createLogicalDevice().

Here is the caller graph for this function:

initVulkan()

void HelloTriangleApplication::initVulkan ( )

inlineprivate

                      {
        createInstance();
        // setupDebugMessenger();
        pickPhysicalDevice();
    }

References createInstance(), and pickPhysicalDevice().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

initWindow()

void HelloTriangleApplication::initWindow ( )

inlineprivate

                      {
        glfwInit(); // Init glfw
        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); // No API beceause OpenGL by default
        glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Disable resizing because more work
 
        constexpr int HEIGHT = 800;
        constexpr int WIDTH = 600;
        const std::string TITLE = "Vulkan";
        // Pass parameters by a WindowInfo struct to avoid errors like inverting width and height
        _window = glfwCreateWindow(WIDTH, HEIGHT, TITLE.c_str(), nullptr, nullptr);
 
    }

References _window, GLFW_CLIENT_API, GLFW_FALSE, GLFW_NO_API, GLFW_RESIZABLE, glfwCreateWindow(), glfwInit(), and glfwWindowHint().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

mainLoop()

void HelloTriangleApplication::mainLoop ( )

inlineprivate

                    {
        while (!glfwWindowShouldClose(_window)) {
            glfwPollEvents();
        }
    }

References _window, glfwPollEvents(), and glfwWindowShouldClose().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

pickPhysicalDevice()

void HelloTriangleApplication::pickPhysicalDevice ( )

inlineprivate

                              {
        std::vector<vk::raii::PhysicalDevice> devices = _instance.enumeratePhysicalDevices();
        const auto devIter = std::ranges::find_if(devices,
        [&](auto const & device) {
                auto queueFamilies = device.getQueueFamilyProperties();
                bool isSuitable = device.getProperties().apiVersion >= VK_API_VERSION_1_3;
                const auto qfpIter = std::ranges::find_if(queueFamilies,
                []( vk::QueueFamilyProperties const & qfp )
                        {
                            return (qfp.queueFlags & vk::QueueFlagBits::eGraphics) != static_cast<vk::QueueFlags>(0);
                        } );
                isSuitable = isSuitable && ( qfpIter != queueFamilies.end() );
                auto extensions = device.enumerateDeviceExtensionProperties( );
                bool found = true;
                for (auto const & extension : deviceExtensions) {
                    auto extensionIter = std::ranges::find_if(extensions, [extension](auto const & ext) {return strcmp(ext.extensionName, extension) == 0;});
                    found = found &&  extensionIter != extensions.end();
                }
                isSuitable = isSuitable && found;
                if (isSuitable) {
                    _physicalDevice = device;
                }
                return isSuitable;
        });
        if (devIter == devices.end()) {
            throw std::runtime_error("failed to find a suitable GPU!");
        }
    }

References _instance, _physicalDevice, and deviceExtensions.

Referenced by initVulkan().

Here is the caller graph for this function:

run()

void HelloTriangleApplication::run ( )

inline

               {
        initVulkan();
        initWindow();
        mainLoop();
        cleanup();
    }

References cleanup(), initVulkan(), initWindow(), and mainLoop().

Here is the call graph for this function:

setupDebugMessenger()

void HelloTriangleApplication::setupDebugMessenger ( )

inlineprivate

    {
        vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose |
                                                            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);
    }

References _debugMessenger, _instance, and debugCallback().

Here is the call graph for this function:

Member Data Documentation

_context

vk::raii::Context HelloTriangleApplication::_context

private

Referenced by createInstance().

_debugMessenger

vk::raii::DebugUtilsMessengerEXT HelloTriangleApplication::_debugMessenger = nullptr

private

Referenced by setupDebugMessenger().

_device

vk::raii::Device HelloTriangleApplication::_device = nullptr

private

Referenced by createLogicalDevice().

_graphicsQueue

vk::raii::Queue HelloTriangleApplication::_graphicsQueue = nullptr

private

Referenced by createLogicalDevice().

_instance

vk::raii::Instance HelloTriangleApplication::_instance = nullptr

private

Referenced by createInstance(), createSurface(), pickPhysicalDevice(), and setupDebugMessenger().

_physicalDevice

vk::raii::PhysicalDevice HelloTriangleApplication::_physicalDevice = nullptr

private

Referenced by createLogicalDevice(), and pickPhysicalDevice().

_presentQueue

vk::raii::Queue HelloTriangleApplication::_presentQueue = nullptr

private

Referenced by createLogicalDevice().

_window

GLFWwindow* HelloTriangleApplication::_window = nullptr

private

Referenced by cleanup(), createSurface(), initWindow(), and mainLoop().

deviceExtensions

std::vector<const char*> HelloTriangleApplication::deviceExtensions

private

Initial value:

= {
        vk::KHRSwapchainExtensionName
    }

                                              {
        vk::KHRSwapchainExtensionName
    };

Referenced by createLogicalDevice(), and pickPhysicalDevice().

surface

vk::raii::SurfaceKHR HelloTriangleApplication::surface = nullptr

private

Referenced by createLogicalDevice(), and createSurface().

---

The documentation for this class was generated from the following file:

• /github/workspace/main.cpp