Chronos::Engine::Device Class Reference

This initializes, manages and destroys the logical and physical devices(GPU). More...

#include <device.hpp>

Public Member Functions
void	init (VkInstance instance, VkSurfaceKHR surface)
	This is the function that initializes the devices and queues.
void	destroy ()
	This is the function that destroys the device.

Public Attributes
VkDevice	device
	This is the logical device that is used by Vulkan.
VkPhysicalDevice	physicalDevice
	This is the physical device that is used by Vulkan.
VkQueue	graphicsQueue
	This is the queue that is used for graphics rendering.
VkQueue	presentQueue
	This is the queue that is used for presentation of the rendered frames.
VkSampleCountFlagBits	msaaSamples = VK_SAMPLE_COUNT_1_BIT
	This sets the MSAA samples count.
VkSampleCountFlagBits	maxMsaaSamples = VK_SAMPLE_COUNT_1_BIT

Private Member Functions
void	pickPhysicalDevice (VkInstance instance, VkSurfaceKHR surface)
	This is the function that picks the best device based on the requirements and features that we require.
void	createLogicalDevice (VkSurfaceKHR surface)
	This creates the logical device.

Detailed Description

This initializes, manages and destroys the logical and physical devices(GPU).

It also manages the various queues that are used for rendering and presentation. MSAA is also handled here due to the fact that it is a device managed property.

Definition at line 47 of file device.hpp.

Member Function Documentation

createLogicalDevice()

void Chronos::Engine::Device::createLogicalDevice ( VkSurfaceKHR  surface )

private

This creates the logical device.

Along with creating the logical device, it creates the queues that are used for rendering and presentation. anisotropy and other features are also enabled here.

Parameters

surface

The surface that is used by the application for presenting the rendered images.

Definition at line 182 of file device.cpp.

{
    QueueFamilyIndices indices = findQueueFamilies(physicalDevice, surface);
 
    std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
    std::set<uint32_t> uniqueQueueFamilies
    = { indices.graphicsFamily.value(), indices.presentFamily.value() };
 
    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);
    }
 
    VkPhysicalDeviceFeatures deviceFeatures {};
    deviceFeatures.samplerAnisotropy = VK_TRUE;
    deviceFeatures.sampleRateShading = VK_TRUE;
 
    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;
    createInfo.enabledExtensionCount
    = static_cast<uint32_t>(deviceExtensions.size());
    createInfo.ppEnabledExtensionNames = deviceExtensions.data();
    createInfo.enabledLayerCount = 0;
#ifdef ENABLE_VALIDATION_LAYERS
    createInfo.enabledLayerCount
    = static_cast<uint32_t>(validationLayers.size());
    createInfo.ppEnabledLayerNames = validationLayers.data();
#endif
 
    if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device)
    != VK_SUCCESS) {
    LOG(1, "Failed to create logical device")
    throw std::runtime_error("Failed to create logical device");
    }
 
    LOG(3, "Logical device created")
    // get the queue handle
    vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
    vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}

References Chronos::Engine::deviceExtensions, Chronos::Engine::findQueueFamilies(), Chronos::Engine::QueueFamilyIndices::graphicsFamily, LOG, and Chronos::Engine::QueueFamilyIndices::presentFamily.

Here is the call graph for this function:

Here is the caller graph for this function:

destroy()

void Chronos::Engine::Device::destroy

(

)

This is the function that destroys the device.

We need to make sure that all the objects that are created using the device are destroyed before this is called. Else Vulkan Valiation layers will become angry at us.

Definition at line 36 of file device.cpp.

{ vkDestroyDevice(device, nullptr); }

Here is the caller graph for this function:

init()

void Chronos::Engine::Device::init	(	VkInstance	instance,
		VkSurfaceKHR	surface
	)

This is the function that initializes the devices and queues.

It picks the best device(GPU) based on the requirements and features that we require.

Parameters

instance	The Vulkan instance that is used by the application.
surface	The surface that is used by the application for presenting the rendered images.

Definition at line 28 of file device.cpp.

{
    pickPhysicalDevice(instance, surface);
    LOG(3, "Physical device picked")
    createLogicalDevice(surface);
    LOG(3, "Logical device created")
}

References createLogicalDevice(), LOG, and pickPhysicalDevice().

Here is the call graph for this function:

pickPhysicalDevice()

void Chronos::Engine::Device::pickPhysicalDevice ( VkInstance  instance, VkSurfaceKHR  surface  )

private

This is the function that picks the best device based on the requirements and features that we require.

It finds all the physical devices(GPUs) that are available and then checks if they are suitable for our application. If none of the devices are suitable then it throws an error. If there are multiple suitable devices, then it gets the first usable device. the maximum number of MSAA samples is also set here.

Parameters

instance	The Vulkan instance that is used by the application.
surface	The surface that is used by the application for presenting the rendered images.

Definition at line 142 of file device.cpp.

{
    // get the number of devices
    uint32_t deviceCount = 0;
    vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
    if (deviceCount == 0) {
    LOG(1, "Failed to find GPUs with Vulkan support")
    throw std::runtime_error("Failed to find GPUs with Vulkan support");
    }
    LOG(3, "Number of devices found: " + std::to_string(deviceCount))
    std::vector<VkPhysicalDevice> devices(deviceCount);
    vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
 
    // check if the device is suitable
    for (const auto& device : devices) {
    if (isDeviceSuitable(device, surface)) {
        physicalDevice = device;
        maxMsaaSamples = getMaxUsableSampleCount(device);
        break;
    }
    }
    if (physicalDevice == VK_NULL_HANDLE) {
    LOG(1, "Failed to find a suitable GPU")
    throw std::runtime_error("Failed to find a suitable GPU");
    }
#ifdef CHRONOS_ENABLE_LOGGING
    VkPhysicalDeviceProperties deviceProperties;
    vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
    LOG(3, "****PHYSICAL DEVICE INFORMATION*****")
    LOG(3,
    "Physical device picked: " + std::string(deviceProperties.deviceName))
    LOG(3, "Driver version: " + std::to_string(deviceProperties.driverVersion))
    LOG(3, "API version: " + std::to_string(deviceProperties.apiVersion))
    LOG(3, "Device ID: " + std::to_string(deviceProperties.deviceID))
    LOG(3, "Vendor ID: " + std::to_string(deviceProperties.vendorID))
    LOG(3, "MSAA samples: " + std::to_string(msaaSamples))
#endif
}

References getMaxUsableSampleCount(), isDeviceSuitable(), and LOG.

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

device

VkDevice Chronos::Engine::Device::device

This is the logical device that is used by Vulkan.

Definition at line 52 of file device.hpp.

graphicsQueue

VkQueue Chronos::Engine::Device::graphicsQueue

This is the queue that is used for graphics rendering.

Definition at line 65 of file device.hpp.

maxMsaaSamples

VkSampleCountFlagBits Chronos::Engine::Device::maxMsaaSamples = VK_SAMPLE_COUNT_1_BIT

Definition at line 82 of file device.hpp.

msaaSamples

VkSampleCountFlagBits Chronos::Engine::Device::msaaSamples = VK_SAMPLE_COUNT_1_BIT

This sets the MSAA samples count.

During initialization it is set to maximium number possible. This can be changed on the fly. However it requires the swapchain to be recreated along with textures and any other assosicated buffers and objects.

Definition at line 80 of file device.hpp.

physicalDevice

VkPhysicalDevice Chronos::Engine::Device::physicalDevice

This is the physical device that is used by Vulkan.

Generally used for allocating memory and buffers.

Definition at line 60 of file device.hpp.

presentQueue

VkQueue Chronos::Engine::Device::presentQueue

This is the queue that is used for presentation of the rendered frames.

Definition at line 71 of file device.hpp.

---

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

• Source/Rendering/device.hpp
• Source/Rendering/device.cpp