dodo::core::VulkanContext Class Reference

#include <VulkanContext.hpp>

Classes
struct	VulkanContextInfo
struct	VulkanDebug

Public Types
using	DebugCallback = vk::PFN_DebugUtilsMessengerCallbackEXT

Public Member Functions
	~VulkanContext ()=default
	VulkanContext (const VulkanContext &other)=delete
VulkanContext &	operator= (const VulkanContext &other)=delete
	VulkanContext (VulkanContext &&other) noexcept
VulkanContext &	operator= (VulkanContext &&other) noexcept

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

Private Member Functions
	VulkanContext ()=default

Static Private Member Functions
template<typename... Features>
static auto	createContext (const VulkanContextInfo< Features... > &ctxInfo) -> std::expected< VulkanContext, std::string >
static auto	checkRequiredLayers (const VulkanContext &vulkanContext, std::span< const char *const > validationLayers) -> std::expected< bool, std::string >
static auto	checkRequiredExtensions (const VulkanContext &vulkanContext, std::span< const char *const > glfwExtensions) -> std::expected< bool, std::string >
static void	setupDebugMessenger (VulkanContext &vulkanContext, DebugCallback debugCallback)
static auto	pickPhysicalDevice (VulkanContext &vulkanContext) -> std::expected< bool, std::string >
static bool	isDeviceSuitable (const vk::raii::PhysicalDevice &physicalDevice)
template<typename FirstFeature , typename... OtherFeatures>
static FirstFeature &	getFirstFeature (vk::StructureChain< FirstFeature, OtherFeatures... > featureChain)

Private Attributes
vk::raii::Context	_context
vk::raii::Instance	_instance = nullptr
vk::raii::PhysicalDevice	_physicalDevice = nullptr
vk::raii::DebugUtilsMessengerEXT	_debugMessenger = nullptr

Friends
class	DodoContext

Member Typedef Documentation

DebugCallback

using dodo::core::VulkanContext::DebugCallback = vk::PFN_DebugUtilsMessengerCallbackEXT

Constructor & Destructor Documentation

~VulkanContext()

dodo::core::VulkanContext::~VulkanContext ( )

default

VulkanContext() [1/3]

dodo::core::VulkanContext::VulkanContext ( const VulkanContext & other )

delete

VulkanContext() [2/3]

dodo::core::VulkanContext::VulkanContext ( VulkanContext && other )

noexcept

                                                          :
_context(std::exchange(other._context, vk::raii::Context())),
_instance(std::exchange(other._instance, nullptr)),
_physicalDevice(std::exchange(other._physicalDevice, nullptr))
{
}

VulkanContext() [3/3]

dodo::core::VulkanContext::VulkanContext ( )

privatedefault

Member Function Documentation

checkRequiredExtensions()

auto dodo::core::VulkanContext::checkRequiredExtensions ( const VulkanContext & vulkanContext, std::span< const char *const > glfwExtensions ) -> std::expected<bool, std::string>

staticprivate

                                                                                                                                                          {
    auto extensionProperties = vulkanContext._context.enumerateInstanceExtensionProperties();
 
    std::cout << "available extensions:\n";
    for (const auto &[extensionName, specVersion] : extensionProperties) {
        std::cout << '\t' << extensionName << " " << specVersion << '\n';
    }
 
    for (auto glfwExtension : glfwExtensions)
    {
        if (std::ranges::none_of(extensionProperties,
                                 [glfwExtension](auto const& extensionProperty)
                                 { return strcmp(extensionProperty.extensionName, glfwExtension) == 0; }))
        {
            return std::unexpected("Required GLFW extension not supported: " + std::string(glfwExtension));
        }
    }
    return true;
}

checkRequiredLayers()

auto dodo::core::VulkanContext::checkRequiredLayers ( const VulkanContext & vulkanContext, std::span< const char *const > validationLayers ) -> std::expected<bool, std::string>

staticprivate

                                                                                                                                                        {
    if (!validationLayers.empty()) {
        auto layerProperties = vulkanContext._context.enumerateInstanceLayerProperties();
        if (std::ranges::any_of(validationLayers, [&layerProperties](auto const &requiredLayer) {
            return std::ranges::none_of(layerProperties, [requiredLayer](auto const &layerProperty) {
                return strcmp(layerProperty.layerName, requiredLayer) == 0;
            });
        })) {
            return std::unexpected("One or more required layers are not supported!");
        }
    }
    return true;
}

References validationLayers.

createContext()

template<typename... Features>

auto dodo::core::VulkanContext::createContext ( const VulkanContextInfo< Features... > & ctxInfo ) -> std::expected<VulkanContext, std::string>

staticprivate

                                         {
    VulkanContext vulkanContext;
    VulkanDebug debugInfo = ctxInfo.debugInfo;
    if (debugInfo.debugEnabled) {
        if (auto result = checkRequiredLayers(vulkanContext, debugInfo.validationLayers); !result)
            return std::unexpected(result.error());
        // setupDebugMessenger(vulkanContext, debugInfo.debugCallback);
    }
 
    uint32_t glfwExtensionCount = 0;
    const auto glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
    if (auto result = checkRequiredExtensions(vulkanContext, std::span(glfwExtensions, glfwExtensionCount)); !result)
        return std::unexpected(result.error());
 
    const vk::InstanceCreateInfo createInfo{
        .pApplicationInfo = &ctxInfo.vkInfo,
        .enabledLayerCount = static_cast<uint32_t>(debugInfo.validationLayers.size()),
        .ppEnabledLayerNames = debugInfo.validationLayers.data(),
        .enabledExtensionCount = glfwExtensionCount,
        .ppEnabledExtensionNames = glfwExtensions,
    };
 
    vulkanContext._instance = vk::raii::Instance(vulkanContext._context, createInfo);
    return vulkanContext;
}

References _context, _instance, dodo::core::VulkanContext::VulkanDebug::debugEnabled, glfwGetRequiredInstanceExtensions(), and dodo::core::VulkanContext::VulkanDebug::validationLayers.

Referenced by dodo::core::DodoContext::createDodoContext().

Here is the call graph for this function:

Here is the caller graph for this function:

defaultDebugCallback()

VKAPI_ATTR vk::Bool32 VKAPI_CALL dodo::core::VulkanContext::defaultDebugCallback ( vk::DebugUtilsMessageSeverityFlagBitsEXT severity, vk::DebugUtilsMessageTypeFlagsEXT type, const vk::DebugUtilsMessengerCallbackDataEXT * pCallbackData, void *  )

static

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

getFirstFeature()

template<typename FirstFeature , typename... OtherFeatures>

FirstFeature & dodo::core::VulkanContext::getFirstFeature ( vk::StructureChain< FirstFeature, OtherFeatures... > featureChain )

staticprivate

                                                                                                          {
    return featureChain.template get<FirstFeature>();
}

isDeviceSuitable()

bool dodo::core::VulkanContext::isDeviceSuitable ( const vk::raii::PhysicalDevice & physicalDevice )

staticprivate

                                                                               {
    const auto deviceProperties = physicalDevice.getProperties();
    const auto deviceFeatures = physicalDevice.getFeatures();
 
    return deviceProperties.deviceType == vk::PhysicalDeviceType::eDiscreteGpu && deviceFeatures.geometryShader;
}

operator=() [1/2]

VulkanContext & dodo::core::VulkanContext::operator= ( const VulkanContext & other )

delete

operator=() [2/2]

VulkanContext & dodo::core::VulkanContext::operator= ( VulkanContext && other )

noexcept

                                                                      {
    if (this != &other) {
        _context = std::exchange(other._context, vk::raii::Context());
        _instance = std::exchange(other._instance, nullptr);
        _physicalDevice = std::exchange(other._physicalDevice, nullptr);
    }
    return *this;
}

pickPhysicalDevice()

auto dodo::core::VulkanContext::pickPhysicalDevice ( VulkanContext & vulkanContext ) -> std::expected<bool, std::string>

staticprivate

                                                                                                   {
    // auto devices = vulkanContext._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)
    //             vulkanContext._physicalDevice = device;
    //         return isSuitable;
    // });
    // if (devIter == devices.end())
    //     return std::unexpected("Failed to find a suitable GPU");
    return true;
}

setupDebugMessenger()

void dodo::core::VulkanContext::setupDebugMessenger ( VulkanContext & vulkanContext, DebugCallback debugCallback )

staticprivate

                                                                                                 {
    constexpr vk::DebugUtilsMessageSeverityFlagsEXT SEVERITY_FLAGS(vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose |
                                                    vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
                                                    vk::DebugUtilsMessageSeverityFlagBitsEXT::eError);
    constexpr vk::DebugUtilsMessageTypeFlagsEXT MESSAGE_TYPE_FLAGS(
            vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral | vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance | vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
    const vk::DebugUtilsMessengerCreateInfoEXT debugUtilsMessengerCreateInfoEXT{.messageSeverity = SEVERITY_FLAGS,
                                                                          .messageType = MESSAGE_TYPE_FLAGS,
                                                                          .pfnUserCallback = debugCallback};
    vulkanContext._debugMessenger = vulkanContext._instance.createDebugUtilsMessengerEXT(debugUtilsMessengerCreateInfoEXT);
}

References _debugMessenger, and _instance.

Friends And Related Symbol Documentation

DodoContext

friend class DodoContext

friend

Member Data Documentation

_context

vk::raii::Context dodo::core::VulkanContext::_context

private

Referenced by createContext().

_debugMessenger

vk::raii::DebugUtilsMessengerEXT dodo::core::VulkanContext::_debugMessenger = nullptr

private

Referenced by setupDebugMessenger().

_instance

vk::raii::Instance dodo::core::VulkanContext::_instance = nullptr

private

Referenced by createContext(), and setupDebugMessenger().

_physicalDevice

vk::raii::PhysicalDevice dodo::core::VulkanContext::_physicalDevice = nullptr

private

---

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

• /github/workspace/include/dodo/core/VulkanContext.hpp
• /github/workspace/src/dodo/core/VulkanContext.cpp