Chronos::Engine::SwapChain Class Reference

#include <swapchain.hpp>

Collaboration diagram for Chronos::Engine::SwapChain:

Public Member Functions
void	init (Chronos::Engine::Device *device, VkSurfaceKHR surface, GLFWwindow *window)
	Initilize the swapchain.
void	recreate ()
	When the swapchain is rendered invalid, recreate it.
void	cleanup ()
	Cleans up the assets that are rendered invalid during MSAA changes or swapchain.
void	changeMsaa ()
	Changes the MSAA count of the swapchain images.

Public Attributes
VkExtent2D	swapChainExtent
	Dimenisons of the current swapchain.
VkSwapchainKHR	swapChain
	Vulkan swapchain object.
VkSurfaceKHR	surface
	Surface to which we need to present the swapchain images.
std::vector< VkImageView >	swapChainImageViews
	Image views of the swapchain textures(images, aka window)
VkImageView	colorImageView
	image view of the color attachement
VkFormat	swapChainImageFormat
	Chosen swapchain image format.
VkPresentModeKHR	preferredPresentMode = VK_PRESENT_MODE_MAILBOX_KHR
	Preferred present mode for the swapchain.
bool	changePresentMode = false

Private Member Functions
void	create ()
	Creates the swapchain image resources and chooses the optimal settings for given hardware.
void	createImageViews ()
	Creates the image views of the swapchain images.
void	createColorResources ()
	Creates the color images along with the associated objects.
VkPresentModeKHR	chooseSwapPresentMode (const std::vector< VkPresentModeKHR > &availablePresentModes)
	From the available present mode, this chooses the the best present mode.

Private Attributes
Chronos::Engine::Device *	device
	Device to which swapchain needs to be created.
GLFWwindow *	window
	The window to present the surface to.
VkImage	colorImage
	The color image.
VkDeviceMemory	colorImageMemory
	Memory to store the color image.
std::vector< VkImage >	swapChainImages
	Swapchaim images to render and present to.

Detailed Description

/brief Responsible for initializing, managing, recreating and presenting the swapchain images.

In Vulkan, we render to images(texture). These images are then present to the GLFW window. Since there will be multiple images in flight, along with multiple other assets for this, we need to manage these assets.

Definition at line 99 of file swapchain.hpp.

Member Function Documentation

changeMsaa()

void Chronos::Engine::SwapChain::changeMsaa

(

)

Changes the MSAA count of the swapchain images.

When the user decides to change the MSAA, we need to recreate the swapchain. This does it.

Definition at line 223 of file swapchain.cpp.

{
    // if we want to change msaa, we need to recreate the swapchain
    vkDeviceWaitIdle(device->device);
    cleanup();
    create();
    createImageViews();
    createColorResources();
}

chooseSwapPresentMode()

VkPresentModeKHR Chronos::Engine::SwapChain::chooseSwapPresentMode ( const std::vector< VkPresentModeKHR > &  availablePresentModes )

private

From the available present mode, this chooses the the best present mode.

If available VK_PRESENT_MODE_MAILBOX_KHR will be chosen.

Some of the presentation modes available are:

• VK_PRESENT_MODE_IMMEDIATE_KHR: Images submitted by your application are transferred to the screen right away, which may result in tearing.
• VK_PRESENT_MODE_FIFO_KHR : The swap chain is a queue where the display takes an image from the front of the queue when the display is refreshed and the program inserts rendered images at the back of the queue.If the queue is full then the program has to wait. This is most similar to vertical sync as found in modern games.The moment that the display is refreshed is known as "vertical blank".
• VK_PRESENT_MODE_FIFO_RELAXED_KHR : This mode only differs from the previous one if the application is late and the queue was empty at the last vertical blank. Instead of waiting for the next vertical blank, the image is transferred right away when it finally arrives.This may result in visible tearing.
• VK_PRESENT_MODE_MAILBOX_KHR : This is another variation of the second mode.Instead of blocking the application when the queue is full, the images that are already queued are simply replaced with the newer ones.This mode can be used to render frames as fast as possible while still avoiding tearing, resulting in fewer latency issues than standard vertical sync.This is commonly known as "triple buffering", although the existence of three buffers alone does not necessarily mean that the framerate

Parameters

availablePresentModes

The available present modes to choose from.

Returns

The best present mode based on availability and preference.

Definition at line 233 of file swapchain.cpp.

{
    // The presentation modes available
    // VK_PRESENT_MODE_IMMEDIATE_KHR: Images submitted by your application are
    // transferred to the screen right away, which may result in tearing.
    // VK_PRESENT_MODE_FIFO_KHR : The swap chain is a queue where the display
    // takes an image from the front of the queue when the display is refreshed
    //                          and the program inserts
    // rendered images at the
    // back of the queue.If the queue is full then the program has to wait.
    // This is most similar to vertical sync as found in modern games.The moment
    // that the display is refreshed is known as
    // "vertical blank". VK_PRESENT_MODE_FIFO_RELAXED_KHR : This mode only
    // differs from the previous one if the application is late and the queue
    // was empty at the last
    // vertical blank.Instead of waiting for the next vertical blank, the image
    // is transferred right away when it
    // finally arrives.This may result in visible tearing.
    // VK_PRESENT_MODE_MAILBOX_KHR : This is another variation of the second
    // mode.Instead of blocking the application when the queue is full, the
    // images                           that are already
    // queued are simply replaced with the newer ones.This mode can be used to
    // render frames as fast as
    // possible while still avoiding tearing, resulting in fewer latency issues
    // than standard vertical sync.This is commonly
    // known as "triple buffering", although the existence of three buffers
    // alone does not necessarily mean that the framerate
    // is unlocked.
 
    // try to select mailbox mode, else select the default FIFO mode
    for (const auto& availablePresentMode : availablePresentModes) {
    if (availablePresentMode == this->preferredPresentMode) {
        return availablePresentMode;
    }
    }
 
    return VK_PRESENT_MODE_FIFO_KHR;
}

cleanup()

void Chronos::Engine::SwapChain::cleanup

(

)

Cleans up the assets that are rendered invalid during MSAA changes or swapchain.

Definition at line 193 of file swapchain.cpp.

{
    vkDestroyImageView(device->device, colorImageView, nullptr);
    vkDestroyImage(device->device, colorImage, nullptr);
    vkFreeMemory(device->device, colorImageMemory, nullptr);
    // destroy the image views
    for (auto imageView : swapChainImageViews) {
    vkDestroyImageView(device->device, imageView, nullptr);
    }
    // destroy the swap chain
    vkDestroySwapchainKHR(device->device, swapChain, nullptr);
}

create()

void Chronos::Engine::SwapChain::create ( )

private

Creates the swapchain image resources and chooses the optimal settings for given hardware.

Definition at line 105 of file swapchain.cpp.

{
    // create the swapchain
    SwapChainSupportDetails swapChainSupport
    = Chronos::Engine::querySwapChainSupport(
        (*device).physicalDevice, surface);
    VkSurfaceFormatKHR surfaceFormat
    = Chronos::Engine::chooseSwapSurfaceFormat(swapChainSupport.formats);
    VkPresentModeKHR presentMode
    = this->chooseSwapPresentMode(swapChainSupport.presentModes);
    VkExtent2D extent = Chronos::Engine::chooseSwapExtent(
    swapChainSupport.capabilities, window);
 
    // set the number of images in the swap chain
    uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
 
    // check if the number of images exceeds the maximum possible images
    // supprted
    if (swapChainSupport.capabilities.maxImageCount > 0
    && imageCount > swapChainSupport.capabilities.maxImageCount) {
    imageCount = swapChainSupport.capabilities.maxImageCount;
    }
 
    VkSwapchainCreateInfoKHR createInfo {};
    createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
    createInfo.surface = surface;
    createInfo.minImageCount = imageCount;
    createInfo.imageFormat = surfaceFormat.format;
    createInfo.imageColorSpace = surfaceFormat.colorSpace;
    createInfo.imageExtent = extent;
    createInfo.imageArrayLayers = 1;
    createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
    Chronos::Engine::QueueFamilyIndices indices
    = Chronos::Engine::findQueueFamilies(device->physicalDevice, surface);
    uint32_t queueFamilyIndices[]
    = { indices.graphicsFamily.value(), indices.presentFamily.value() };
 
    if (indices.graphicsFamily != indices.presentFamily) {
    createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
    createInfo.queueFamilyIndexCount = 2;
    createInfo.pQueueFamilyIndices = queueFamilyIndices;
    } else {
    createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
    createInfo.queueFamilyIndexCount = 0; // Optional
    createInfo.pQueueFamilyIndices = nullptr; // Optional
    }
    createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
    createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
    createInfo.presentMode = presentMode;
    createInfo.clipped = VK_TRUE;
    createInfo.oldSwapchain = NULL;
 
    if (vkCreateSwapchainKHR(device->device, &createInfo, nullptr, &swapChain)
    != VK_SUCCESS) {
    throw std::runtime_error("Failed to create swap chain");
    }
    vkGetSwapchainImagesKHR(device->device, swapChain, &imageCount, nullptr);
    swapChainImages.resize(imageCount);
    vkGetSwapchainImagesKHR(
    device->device, swapChain, &imageCount, swapChainImages.data());
    swapChainImageFormat = surfaceFormat.format;
    swapChainExtent = extent;
}

References Chronos::Engine::SwapChainSupportDetails::capabilities, Chronos::Engine::chooseSwapExtent(), Chronos::Engine::chooseSwapSurfaceFormat(), Chronos::Engine::findQueueFamilies(), Chronos::Engine::SwapChainSupportDetails::formats, Chronos::Engine::QueueFamilyIndices::graphicsFamily, Chronos::Engine::QueueFamilyIndices::presentFamily, Chronos::Engine::SwapChainSupportDetails::presentModes, and Chronos::Engine::querySwapChainSupport().

Here is the call graph for this function:

Here is the caller graph for this function:

createColorResources()

void Chronos::Engine::SwapChain::createColorResources ( )

private

Creates the color images along with the associated objects.

Definition at line 179 of file swapchain.cpp.

{
    VkFormat colorFormat = swapChainImageFormat;
    createImage(*device, swapChainExtent.width, swapChainExtent.height,
    colorFormat, VK_IMAGE_TILING_OPTIMAL,
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
        | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &colorImage, &colorImageMemory,
    device->msaaSamples);
 
    colorImageView
    = Chronos::Engine::createImageView(*device, colorFormat, colorImage);
}

References Chronos::Engine::createImage(), and Chronos::Engine::createImageView().

Here is the call graph for this function:

Here is the caller graph for this function:

createImageViews()

void Chronos::Engine::SwapChain::createImageViews ( )

private

Creates the image views of the swapchain images.

Definition at line 170 of file swapchain.cpp.

{
    swapChainImageViews.resize(swapChainImages.size());
    for (size_t i = 0; i < swapChainImages.size(); i++) {
    swapChainImageViews[i] = Chronos::Engine::createImageView(
        *device, swapChainImageFormat, swapChainImages[i]);
    }
}

References Chronos::Engine::createImageView().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Chronos::Engine::SwapChain::init	(	Chronos::Engine::Device *	device,
		VkSurfaceKHR	surface,
		GLFWwindow *	window
	)

Initilize the swapchain.

The swapchain is an insanely complicated process to setup. We need to create multiple textures, along with their memory and views. We also need to select the format to render to. Along with that we need the color rendering texture attachment, which has its own texture, memory and view.

Parameters

device	The device to create the swapchain on
surface	The surface(VK version of window texture) to render to
window	Thw window to display the image on.

Definition at line 94 of file swapchain.cpp.

{
    this->device = device;
    this->surface = surface;
    this->window = window;
    create();
    createImageViews();
    createColorResources();
}

References create(), createColorResources(), createImageViews(), device, surface, and window.

Here is the call graph for this function:

recreate()

void Chronos::Engine::SwapChain::recreate

(

)

When the swapchain is rendered invalid, recreate it.

Due to various user activities such as window resizing and minimization, the swapchain can become invalid. At that point, we need to recreate the assets based on the new dimensions.

Definition at line 206 of file swapchain.cpp.

{
    int width = 0, height = 0;
    glfwGetFramebufferSize(window, &width, &height);
    while (width == 0 || height == 0) {
    glfwGetFramebufferSize(window, &width, &height);
    glfwWaitEvents();
    }
 
    vkDeviceWaitIdle(device->device);
 
    cleanup();
    create();
    createImageViews();
    createColorResources();
}

Member Data Documentation

changePresentMode

bool Chronos::Engine::SwapChain::changePresentMode = false

Definition at line 175 of file swapchain.hpp.

colorImage

VkImage Chronos::Engine::SwapChain::colorImage

private

The color image.

Definition at line 191 of file swapchain.hpp.

colorImageMemory

VkDeviceMemory Chronos::Engine::SwapChain::colorImageMemory

private

Memory to store the color image.

Definition at line 196 of file swapchain.hpp.

colorImageView

VkImageView Chronos::Engine::SwapChain::colorImageView

image view of the color attachement

Definition at line 163 of file swapchain.hpp.

device

Chronos::Engine::Device* Chronos::Engine::SwapChain::device

private

Device to which swapchain needs to be created.

Definition at line 181 of file swapchain.hpp.

preferredPresentMode

VkPresentModeKHR Chronos::Engine::SwapChain::preferredPresentMode = VK_PRESENT_MODE_MAILBOX_KHR

Preferred present mode for the swapchain.

Definition at line 173 of file swapchain.hpp.

surface

VkSurfaceKHR Chronos::Engine::SwapChain::surface

Surface to which we need to present the swapchain images.

Definition at line 153 of file swapchain.hpp.

swapChain

VkSwapchainKHR Chronos::Engine::SwapChain::swapChain

Vulkan swapchain object.

Definition at line 148 of file swapchain.hpp.

swapChainExtent

VkExtent2D Chronos::Engine::SwapChain::swapChainExtent

Dimenisons of the current swapchain.

Definition at line 143 of file swapchain.hpp.

swapChainImageFormat

VkFormat Chronos::Engine::SwapChain::swapChainImageFormat

Chosen swapchain image format.

Definition at line 168 of file swapchain.hpp.

swapChainImages

std::vector<VkImage> Chronos::Engine::SwapChain::swapChainImages

private

Swapchaim images to render and present to.

Definition at line 201 of file swapchain.hpp.

swapChainImageViews

std::vector<VkImageView> Chronos::Engine::SwapChain::swapChainImageViews

Image views of the swapchain textures(images, aka window)

Definition at line 158 of file swapchain.hpp.

window

GLFWwindow* Chronos::Engine::SwapChain::window

private

The window to present the surface to.

Definition at line 186 of file swapchain.hpp.

---

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

• Source/Rendering/swapchain.hpp
• Source/Rendering/swapchain.cpp