vulkan_display::VulkanInstance Class Reference

#include <vulkan_context.hpp>

Collaboration diagram for vulkan_display::VulkanInstance:

Public Member Functions
	VulkanInstance ()=default
	VulkanInstance (const VulkanInstance &other)=delete
	VulkanInstance (VulkanInstance &&other)=delete
	~VulkanInstance ()
void	destroy ()
void	get_available_gpus (std::vector< std::pair< std::string, bool > > &gpus)
	returns all available grafhics cards first parameter is gpu name, second parameter is true only if the gpu is suitable for vulkan_display
vk::Instance &	get_instance ()
void	init (std::vector< const char * > &required_extensions, bool enable_validation, std::function< void(LogLevel, std::string_view)> logging_function=cout_msg)
VulkanInstance &	operator= (const VulkanInstance &other)=delete
VulkanInstance &	operator= (VulkanInstance &&other)=delete

Private Member Functions
void	init_validation_layers_error_messenger ()

Private Attributes
std::unique_ptr< vk::DispatchLoaderDynamic >	dynamic_dispatcher = nullptr
vk::Instance	instance {}
vk::DebugUtilsMessengerEXT	messenger {}
uint32_t	vulkan_version = VK_API_VERSION_1_1

Friends
void	vulkan_display_detail::VulkanContext::init (VulkanInstance &&, vk::SurfaceKHR, vulkan_display::WindowParameters, uint32_t, vk::PresentModeKHR)

Detailed Description

Definition at line 222 of file vulkan_context.hpp.

Constructor & Destructor Documentation

VulkanInstance() [1/3]

vulkan_display::VulkanInstance::VulkanInstance ( )

default

VulkanInstance() [2/3]

vulkan_display::VulkanInstance::VulkanInstance ( const VulkanInstance & other )

delete

VulkanInstance() [3/3]

vulkan_display::VulkanInstance::VulkanInstance ( VulkanInstance && other )

delete

~VulkanInstance()

vulkan_display::VulkanInstance::~VulkanInstance ( )

inline

Definition at line 239 of file vulkan_context.hpp.

                          {
                destroy();
        }

References destroy().

Here is the call graph for this function:

Member Function Documentation

destroy()

void vulkan_display::VulkanInstance::destroy

(

)

Definition at line 361 of file vulkan_context.cpp.

                             {
        if (instance) {
                instance.destroy();
                if (messenger) {
                        instance.destroy(messenger, nullptr, *dynamic_dispatcher);
                }
                dynamic_dispatcher = nullptr;
                instance = nullptr;
        }
}

References dynamic_dispatcher, instance, and messenger.

Referenced by ~VulkanInstance().

get_available_gpus()

void vulkan_display::VulkanInstance::get_available_gpus

(

std::vector< std::pair< std::string, bool > > &

gpus

)

returns all available grafhics cards first parameter is gpu name, second parameter is true only if the gpu is suitable for vulkan_display

Definition at line 348 of file vulkan_context.cpp.

                                                                                 {
        assert(instance);
 
        std::vector<vk::PhysicalDevice> physical_devices = instance.enumeratePhysicalDevices();
        gpus.clear();
        gpus.reserve(physical_devices.size());
        for (const auto& gpu : physical_devices) {
                auto properties = gpu.getProperties();
                gpus.emplace_back(properties.deviceName, true);
        }
        std::sort(gpus.begin(), gpus.end());
}

References instance.

get_instance()

vk::Instance & vulkan_display::VulkanInstance::get_instance ( )

inline

Definition at line 257 of file vulkan_context.hpp.

                                   {
                return instance;
        }

References instance.

init()

void vulkan_display::VulkanInstance::init	(	std::vector< const char * > &	required_extensions,
		bool	enable_validation,
		std::function< void(LogLevel, std::string_view)>	logging_function = cout_msg )

Parameters

required_extensions	Vulkan instance extensions requested by aplication, usually needed for creating vulkan surface
enable_validation	Enable vulkan validation layers, they should be disabled in release build.

Definition at line 289 of file vulkan_context.cpp.

                                                                                                                                                              {
        vulkan_log_msg = std::move(logging_function);
        std::vector<const char*> validation_layers{};
        if (enable_validation) {
                validation_layers.push_back("VK_LAYER_KHRONOS_validation");
                check_validation_layers(validation_layers);
 
                const char* debug_extension = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
                required_extensions.push_back(debug_extension);
        }
 
        check_instance_extensions(required_extensions);
 
        vk::ApplicationInfo app_info{};
        app_info.setApiVersion(VK_API_VERSION_1_1);
        vulkan_version = VK_API_VERSION_1_1;
 
        vk::InstanceCreateInfo instance_info{};
        instance_info
                .setPApplicationInfo(&app_info)
                .setEnabledLayerCount(static_cast<uint32_t>(validation_layers.size()))
                .setPpEnabledLayerNames(validation_layers.data())
                .setEnabledExtensionCount(static_cast<uint32_t>(required_extensions.size()))
                .setPpEnabledExtensionNames(required_extensions.data());
        auto result = vk::createInstance(&instance_info, nullptr, &instance);
        
        switch (result) {
                case vk::Result::eSuccess:
                        break;
                case vk::Result::eErrorIncompatibleDriver:
                        app_info.apiVersion = VK_API_VERSION_1_0;
                        vulkan_version = VK_API_VERSION_1_0;
                        result = vk::createInstance(&instance_info, nullptr, &instance);
                        if(result != vk::Result::eSuccess){
                            throw VulkanError{"Vulkan instance cannot be created: "s + vk::to_string(result)};
                        }
                        break;
                default:
                        throw VulkanError{"Vulkan instance cannot be created: "s + vk::to_string(result)};
        }
 
        if (enable_validation) {
                dynamic_dispatcher = std::make_unique<vk::DispatchLoaderDynamic>((VkInstance) instance, vkGetInstanceProcAddr);
                init_validation_layers_error_messenger();
        }
}

References dynamic_dispatcher, init_validation_layers_error_messenger(), instance, vulkan_display_detail::vulkan_log_msg, and vulkan_version.

Here is the call graph for this function:

init_validation_layers_error_messenger()

void vulkan_display::VulkanInstance::init_validation_layers_error_messenger ( )

private

Definition at line 336 of file vulkan_context.cpp.

                                                            {
        vk::DebugUtilsMessengerCreateInfoEXT messenger_info{};
        using Severity = vk::DebugUtilsMessageSeverityFlagBitsEXT;
        using Type = vk::DebugUtilsMessageTypeFlagBitsEXT;
        messenger_info
                .setMessageSeverity(Severity::eError | Severity::eInfo | Severity::eWarning) // severity::eInfo |
                .setMessageType(Type::eGeneral | Type::ePerformance | Type::eValidation)
                .setPfnUserCallback(debug_callback)
                .setPUserData(nullptr);
        messenger = instance.createDebugUtilsMessengerEXT(messenger_info, nullptr, *dynamic_dispatcher);
}

References dynamic_dispatcher, instance, and messenger.

Referenced by init().

operator=() [1/2]

VulkanInstance & vulkan_display::VulkanInstance::operator= ( const VulkanInstance & other )

delete

operator=() [2/2]

VulkanInstance & vulkan_display::VulkanInstance::operator= ( VulkanInstance && other )

delete

Friends And Related Symbol Documentation

vulkan_display_detail::VulkanContext::init

void vulkan_display_detail::VulkanContext::init ( VulkanInstance && , vk::SurfaceKHR , vulkan_display::WindowParameters , uint32_t , vk::PresentModeKHR  )

friend

Member Data Documentation

dynamic_dispatcher

std::unique_ptr<vk::DispatchLoaderDynamic> vulkan_display::VulkanInstance::dynamic_dispatcher = nullptr

private

Definition at line 224 of file vulkan_context.hpp.

Referenced by destroy(), init(), and init_validation_layers_error_messenger().

instance

vk::Instance vulkan_display::VulkanInstance::instance {}

private

Definition at line 223 of file vulkan_context.hpp.

{};

Referenced by destroy(), get_available_gpus(), get_instance(), init(), and init_validation_layers_error_messenger().

messenger

vk::DebugUtilsMessengerEXT vulkan_display::VulkanInstance::messenger {}

private

Definition at line 225 of file vulkan_context.hpp.

{};

Referenced by destroy(), and init_validation_layers_error_messenger().

vulkan_version

uint32_t vulkan_display::VulkanInstance::vulkan_version = VK_API_VERSION_1_1

private

Definition at line 226 of file vulkan_context.hpp.

Referenced by init().

---

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

• src/video_display/vulkan/vulkan_context.hpp
• src/video_display/vulkan/vulkan_context.cpp