Chronos::Engine Namespace Reference

Namespaces
namespace	FontStructs

Classes
class	Buffer
	Used to store buffers in GPU. More...
class	ColorBuffer
	This is a buffer for storing and updating the color of the shape. More...
class	ColoredRectangle
struct	ColorVertex
	This defines the position of a vertex. Used when we need a colored vertex. Does not support textures. More...
class	Device
	This initializes, manages and destroys the logical and physical devices(GPU). More...
class	Engine
struct	FontTypes
	The parameters needed for the font style. More...
class	Object
	Abstract class for creating and managing generic graphical objects. More...
class	ObjectManager
struct	PipelineAttributes
	Structure defining attributes required for creating a graphics pipeline. More...
struct	QueueFamilyIndices
	This is used to check if a given familty supports graphics and presentation. More...
class	SwapChain
struct	SwapChainSupportDetails
	Contains the fields to the support details of a physical device. More...
class	Text
	Class for creating a text object for rendering text. More...
struct	TextParams
	Parameters for rendering text. More...
class	Texture
	This class holds the Vulkan data and objects needed for a texture. More...
class	TexturedRectangle
struct	TexturedVertex
	This defines the position and texture coordinates of a vertex. Used when we need a textured vertex. More...
class	TextureManager
	This is the texture manager for Chronos. It handles creation, modification, updating and desrtuction of textures. More...
class	UniformBuffer
	This is a Uniform buffer for storing the uniform variables in the shaders. More...
struct	UniformBufferObject
	Uniform struct passed to shader. More...
struct	UniformColorBufferObject
	Uniform struct for color passed to shader. More...

Enumerations
enum	ObjectType { TypeTexturedRectangle , TypeColoredRectangle , TypeText }

Functions
VkCommandBuffer	beginSingleTimeCommands (VkCommandPool commandPool, VkDevice device)
	Begins recording of a command buffer that will be used once.
void	endSingleTimeCommands (VkCommandBuffer *commandBuffer, Chronos::Engine::Device device, VkCommandPool commandPool)
	Ends recording of single time command buffer and destroys it.
uint32_t	findMemoryType (uint32_t typeFilter, VkMemoryPropertyFlags properties, VkPhysicalDevice physicalDevice)
	Finds suitable memory type for given requrements.
void	createBuffer (Chronos::Engine::Device device, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer *buffer, VkDeviceMemory *bufferMemory)
	Creates a buffer of a given size, usage and properties.
void	copyBuffer (Chronos::Engine::Device device, VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size, VkCommandPool commandPool)
	Copies data from one buffer to another.
QueueFamilyIndices	findQueueFamilies (VkPhysicalDevice device, VkSurfaceKHR surface)
	Gets the indices of the needed queue families.
VkCommandPool	createCommandPool (Chronos::Engine::Device device, VkSurfaceKHR surface)
	Creates a command pool for a given device and surface.
VkRenderPass	createRenderPass (Chronos::Engine::Device device, Chronos::Engine::SwapChain swapChain, VkImageLayout initalLayout, VkImageLayout finalLayout, VkImageLayout msaaFinalLayout, bool msaa, bool clearFramebuffer, bool dependency)
	Creates a render pass.
std::vector< VkFramebuffer >	createFramebuffer (Chronos::Engine::Device device, Chronos::Engine::SwapChain swapChain, VkRenderPass renderPass, bool msaa)
	Creates a set of framebuffers for use.
std::vector< VkCommandBuffer >	createCommandBuffer (Chronos::Engine::Device device, Chronos::Engine::SwapChain swapChain, VkCommandPool commandPool)
	Creates a set of command buffers for use.
Chronos::Engine::FontTypes	getFontType (std::string fontType, int fontSize)
VkExtent2D	chooseSwapExtent (const VkSurfaceCapabilitiesKHR &capabilities, GLFWwindow *window)
	Gets the maximum extent of the swapchain images(framebuffer size).
VkSurfaceFormatKHR	chooseSwapSurfaceFormat (const std::vector< VkSurfaceFormatKHR > &availableFormats)
	Chooses the best present mode among the supported modes.
SwapChainSupportDetails	querySwapChainSupport (VkPhysicalDevice device, VkSurfaceKHR surface)
	For a given swapchain mode, it gets the capabilites, formats and present modes.
void	createTextureSampler (Chronos::Engine::Device device, VkSampler *textureSampler)
	Creates a VkSampler
void	createImage (Chronos::Engine::Device device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage *image, VkDeviceMemory *imageMemory, VkSampleCountFlagBits numSamples)
	For a given image dimensons, it creates a VkImage and.
void	transitionImageLayout (VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkCommandPool commandPool, Chronos::Engine::Device device)
	Transiton a VkImage from one layout to another.
void	copyBufferToImage (VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, VkCommandPool commandPool, Chronos::Engine::Device device)
	Copy data from a buffer to an image.
VkImageView	createImageView (Chronos::Engine::Device device, VkFormat format, VkImage image)
	Create a VkImageView for a given VkImage.

Variables
const std::vector< const char * >	deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }
	THis contain the device extensions that are needed to be enabled in vulkan.

Enumeration Type Documentation

ObjectType

enum Chronos::Engine::ObjectType

Enumerator
TypeTexturedRectangle
TypeColoredRectangle
TypeText

Definition at line 4 of file objectTypes.hpp.

{ TypeTexturedRectangle, TypeColoredRectangle, TypeText };

Function Documentation

beginSingleTimeCommands()

VkCommandBuffer Chronos::Engine::beginSingleTimeCommands	(	VkCommandPool	commandPool,
		VkDevice	device
	)

Begins recording of a command buffer that will be used once.

This is used to create a temporary commandBuffer for single use and starts recording. Generally used for transfering data to the GPU. After using the buffer, it must be ended and destroyed using endSingleTimeCommands.

Parameters

commandPool	The command pool to create the temporary command buffer on.
device	The device that has the command pool.

Returns

The created command buffer.

Definition at line 24 of file helper.cpp.

{
    // used for staging buffers. We need a temproary command buffer to copy the
    // data to the device buffer
    VkCommandBufferAllocateInfo allocInfo {};
    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    allocInfo.commandPool = commandPool;
    allocInfo.commandBufferCount = 1;
 
    VkCommandBuffer commandBuffer;
    vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
 
    VkCommandBufferBeginInfo beginInfo {};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
    vkBeginCommandBuffer(commandBuffer, &beginInfo);
 
    return commandBuffer;
}

Here is the caller graph for this function:

chooseSwapExtent()

VkExtent2D Chronos::Engine::chooseSwapExtent	(	const VkSurfaceCapabilitiesKHR &	capabilities,
		GLFWwindow *	window
	)

Gets the maximum extent of the swapchain images(framebuffer size).

We need to calculate the maximum extent of the swapchain. Preferably we want to support the width and height of the window. However the hardware may not support this. Hence after getting the desired height and and width, we clamp it to the hardware limits.

Parameters

capabilites	The capabailites of the hardware/surface to display the image(max/min height and width)
window	The GLFW window instance to be rendered to. This contains the desired height and width.

Returns

The chosen extent of the swapchain based on the capabilites of the hardware.

Definition at line 41 of file swapchain.cpp.

{
    if (capabilities.currentExtent.width
    != std::numeric_limits<uint32_t>::max()) {
    return capabilities.currentExtent;
    } else {
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
 
    VkExtent2D actualExtent
        = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
 
    actualExtent.width
        = std::clamp(actualExtent.width, capabilities.minImageExtent.width,
        capabilities.maxImageExtent.width);
    actualExtent.height = std::clamp(actualExtent.height,
        capabilities.minImageExtent.height,
        capabilities.maxImageExtent.height);
 
    return actualExtent;
    }
}

Here is the caller graph for this function:

chooseSwapSurfaceFormat()

VkSurfaceFormatKHR Chronos::Engine::chooseSwapSurfaceFormat

(

const std::vector< VkSurfaceFormatKHR > &

availableFormats

)

Chooses the best present mode among the supported modes.

It chooses RGBA format along with SRGB for color space. If such a format is not available then it chooses the first one that is available.

Parameters

availableFormats

The available formats available to choose from.

Returns

The best format chosen for rendering

Definition at line 26 of file swapchain.cpp.

{
    // try to choose SRBG format, else return the first available format
    for (const auto& availableFormat : availableFormats) {
    if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB
        && availableFormat.colorSpace
        == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
        return availableFormat;
    }
    }
 
    return availableFormats[0];
}

Here is the caller graph for this function:

copyBuffer()

void Chronos::Engine::copyBuffer	(	Chronos::Engine::Device	device,
		VkBuffer	srcBuffer,
		VkBuffer	dstBuffer,
		VkDeviceSize	size,
		VkCommandPool	commandPool
	)

Copies data from one buffer to another.

This is used to transfer data between host and device using staging buffers.

Parameters

device	The device that has the commandPool.
srcBuffer	The source buffer to copy from.
dstBuffer	The destination buffer to copy to.
size	The size of the buffer to copy.
commandPool	The command pool to create the temporary command buffer on.

Definition at line 111 of file helper.cpp.

{
    // copies data from a buffer to another buffer
    VkCommandBuffer commandBuffer
    = Chronos::Engine::beginSingleTimeCommands(commandPool, device.device);
    VkBufferCopy copyRegion {};
    copyRegion.srcOffset = 0;
    copyRegion.dstOffset = 0;
    copyRegion.size = size;
    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
    Chronos::Engine::endSingleTimeCommands(&commandBuffer, device, commandPool);
}

References beginSingleTimeCommands(), Chronos::Engine::Device::device, and endSingleTimeCommands().

Here is the call graph for this function:

Here is the caller graph for this function:

copyBufferToImage()

void Chronos::Engine::copyBufferToImage	(	VkBuffer	buffer,
		VkImage	image,
		uint32_t	width,
		uint32_t	height,
		VkCommandPool	commandPool,
		Chronos::Engine::Device	device
	)

Copy data from a buffer to an image.

Parameters

buffer	The buffer to copy data from.
image	The image to copy data to.
width	Width of the image.
height	Height of the image.
commandPool	The command pool to create the temporary command buffer from.
device	The device that has the image.

Definition at line 234 of file texture.cpp.

{
    VkCommandBuffer commandBuffer
    = Chronos::Engine::beginSingleTimeCommands(commandPool, device.device);
    VkBufferImageCopy region {};
    region.bufferOffset = 0;
    region.bufferRowLength = 0;
    region.bufferImageHeight = 0;
    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.mipLevel = 0;
    region.imageSubresource.baseArrayLayer = 0;
    region.imageSubresource.layerCount = 1;
    region.imageOffset = { 0, 0, 0 };
    region.imageExtent = { width, height, 1 };
    vkCmdCopyBufferToImage(commandBuffer, buffer, image,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
    Chronos::Engine::endSingleTimeCommands(&commandBuffer, device, commandPool);
}

References beginSingleTimeCommands(), Chronos::Engine::Device::device, and endSingleTimeCommands().

Here is the call graph for this function:

Here is the caller graph for this function:

createBuffer()

void Chronos::Engine::createBuffer	(	Chronos::Engine::Device	device,
		VkDeviceSize	size,
		VkBufferUsageFlags	usage,
		VkMemoryPropertyFlags	properties,
		VkBuffer *	buffer,
		VkDeviceMemory *	bufferMemory
	)

Creates a buffer of a given size, usage and properties.

This function creates a buffer of given size and usage. It then allocates the needed memory for this by finding the needed memory type using findMemoryType.

Parameters

device	The device that has the buffer.
size	The size of the buffer.
usage	The usage of the buffer.
properties	The memory property flags of the buffer.
buffer	The buffer to create.
bufferMemory	The associcated memory for the buffer.

Definition at line 78 of file helper.cpp.

{
    VkBufferCreateInfo bufferInfo {};
    bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    bufferInfo.size = size;
    bufferInfo.usage = usage;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
    if (vkCreateBuffer(device.device, &bufferInfo, nullptr, buffer)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create buffer!");
    }
 
    VkMemoryRequirements memRequirements;
    vkGetBufferMemoryRequirements(device.device, *buffer, &memRequirements);
 
    VkMemoryAllocateInfo allocInfo {};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memRequirements.size;
    allocInfo.memoryTypeIndex = findMemoryType(
    memRequirements.memoryTypeBits, properties, device.physicalDevice);
 
    if (vkAllocateMemory(device.device, &allocInfo, nullptr, bufferMemory)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to allocate buffer memory!");
    }
 
    vkBindBufferMemory(device.device, *buffer, *bufferMemory, 0);
}

References Chronos::Engine::Device::device, findMemoryType(), and Chronos::Engine::Device::physicalDevice.

Here is the call graph for this function:

Here is the caller graph for this function:

createCommandBuffer()

std::vector< VkCommandBuffer > Chronos::Engine::createCommandBuffer	(	Chronos::Engine::Device	device,
		Chronos::Engine::SwapChain	swapChain,
		VkCommandPool	commandPool
	)

Creates a set of command buffers for use.

This creates the command buffers for a given swap chain on a given command pool. It creates as many command buffers as there are images in the swap chain.

Parameters

device	The device that has the command pool.
swapChain	The swap chain to create the command buffers for.
commandPool	The command pool to create the command buffers on.

Returns

The created command buffers.

Definition at line 308 of file helper.cpp.

{
    std::vector<VkCommandBuffer> commandBuffers;
    commandBuffers.resize(swapChain.swapChainImageViews.size());
    VkCommandBufferAllocateInfo allocInfo {};
    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    allocInfo.commandPool = commandPool;
    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
    if (vkAllocateCommandBuffers(
        device.device, &allocInfo, commandBuffers.data())
    != VK_SUCCESS) {
    throw std::runtime_error("failed to allocate command buffers!");
    }
    return commandBuffers;
}

References Chronos::Engine::Device::device, and Chronos::Engine::SwapChain::swapChainImageViews.

Here is the caller graph for this function:

createCommandPool()

VkCommandPool Chronos::Engine::createCommandPool	(	Chronos::Engine::Device	device,
		VkSurfaceKHR	surface
	)

Creates a command pool for a given device and surface.

Parameters

device	The device to create the command pool on.
surface	The surface to which we are rendering.

Returns

The created command pool.

Definition at line 157 of file helper.cpp.

{
    VkCommandPool commandPool;
    QueueFamilyIndices queueFamilyIndices
    = Chronos::Engine::findQueueFamilies(device.physicalDevice, surface);
    VkCommandPoolCreateInfo poolInfo {};
    poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
    poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
    poolInfo.flags
    = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // Optional
    if (vkCreateCommandPool(device.device, &poolInfo, nullptr, &commandPool)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create command pool!");
    }
    return commandPool;
}

References Chronos::Engine::Device::device, findQueueFamilies(), Chronos::Engine::QueueFamilyIndices::graphicsFamily, and Chronos::Engine::Device::physicalDevice.

Here is the call graph for this function:

Here is the caller graph for this function:

createFramebuffer()

std::vector< VkFramebuffer > Chronos::Engine::createFramebuffer	(	Chronos::Engine::Device	device,
		Chronos::Engine::SwapChain	swapChain,
		VkRenderPass	renderPass,
		bool	msaa
	)

Creates a set of framebuffers for use.

It creates as many framebuffers as there are images in the swap chain.

Parameters

device	The device that has the swap chain.
swapChain	The swap chain to create the framebuffers for.
renderPass	The render pass that the framebuffers are going to be used for.
msaa	Whether MSAA is enabled or not. This is to attach the necessary MSAA images to the framebuffer.

Definition at line 276 of file helper.cpp.

{
    std::vector<VkFramebuffer> framebuffers;
    framebuffers.resize(swapChain.swapChainImageViews.size());
    for (size_t i = 0; i < swapChain.swapChainImageViews.size(); i++) {
    std::vector<VkImageView> attachments;
    if (msaa && device.msaaSamples != VK_SAMPLE_COUNT_1_BIT) {
        attachments = { swapChain.colorImageView,
        swapChain.swapChainImageViews[i] };
    } else {
        attachments = { swapChain.swapChainImageViews[i] };
    }
    VkFramebufferCreateInfo framebufferInfo {};
    framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
    framebufferInfo.renderPass = renderPass;
    framebufferInfo.attachmentCount
        = static_cast<uint32_t>(attachments.size());
    framebufferInfo.pAttachments = attachments.data();
    framebufferInfo.width = swapChain.swapChainExtent.width;
    framebufferInfo.height = swapChain.swapChainExtent.height;
    framebufferInfo.layers = 1;
    if (vkCreateFramebuffer(
        device.device, &framebufferInfo, nullptr, &framebuffers[i])
        != VK_SUCCESS) {
        throw std::runtime_error("failed to create framebuffer!");
    }
    }
    return framebuffers;
}

References Chronos::Engine::SwapChain::colorImageView, Chronos::Engine::Device::device, Chronos::Engine::Device::msaaSamples, Chronos::Engine::SwapChain::swapChainExtent, and Chronos::Engine::SwapChain::swapChainImageViews.

Here is the caller graph for this function:

createImage()

void Chronos::Engine::createImage	(	Chronos::Engine::Device	device,
		uint32_t	width,
		uint32_t	height,
		VkFormat	format,
		VkImageTiling	tiling,
		VkImageUsageFlags	usage,
		VkMemoryPropertyFlags	properties,
		VkImage *	image,
		VkDeviceMemory *	imageMemory,
		VkSampleCountFlagBits	numSamples
	)

For a given image dimensons, it creates a VkImage and.

for the image.

Parameters

device	Sevice to create the image on.
width	Width of the image.
height	Height of the image.
format	Format of the image. More information here.
tiling	Tiling structure of the image. Options are _IMAGE_TILING_OPTIMAL and VK_IMAGE_TILING_LINEAR
usage	The usage of the image. Common options are _IMAGE_USAGE_SAMPLED_BIT , VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, _IMAGE_USAGE_INPUT_ATTACHMENT_BIT and _IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT .
properties	The properties of the image. Common options are _MEMORY_PROPERTY_DEVICE_LOCAL_BIT , _MEMORY_PROPERTY_HOST_VISIBLE_BIT , _MEMORY_PROPERTY_HOST_COHERENT_BIT and _MEMORY_PROPERTY_HOST_CACHED_BIT .
image	The image to be created.
imageMemory	The memory for the image to be created.
numSamples	The number of samples for the image. Common options are _SAMPLE_COUNT_1_BIT , VK_SAMPLE_COUNT_2_BIT, _SAMPLE_COUNT_4_BIT and VK_SAMPLE_COUNT_8_BIT. Generally VK_SAMPLE_COUNT_1_BIT is used unless the image is used with MSAA.

Definition at line 42 of file texture.cpp.

{
    VkImageCreateInfo imageInfo {};
    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
    imageInfo.extent.width = width;
    imageInfo.extent.height = height;
    imageInfo.extent.depth = 1;
    imageInfo.mipLevels = 1;
    imageInfo.arrayLayers = 1;
    imageInfo.format = format;
    imageInfo.tiling = tiling;
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    imageInfo.usage = usage;
    imageInfo.samples = numSamples;
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
    if (vkCreateImage(device.device, &imageInfo, nullptr, image)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create image!");
    }
 
    VkMemoryRequirements memRequirements;
    vkGetImageMemoryRequirements(device.device, *image, &memRequirements);
 
    VkMemoryAllocateInfo allocInfo {};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memRequirements.size;
    allocInfo.memoryTypeIndex = Chronos::Engine::findMemoryType(
    memRequirements.memoryTypeBits, properties, device.physicalDevice);
 
    if (vkAllocateMemory(device.device, &allocInfo, nullptr, imageMemory)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to allocate image memory!");
    }
 
    vkBindImageMemory(device.device, *image, *imageMemory, 0);
}

References Chronos::Engine::Device::device, findMemoryType(), and Chronos::Engine::Device::physicalDevice.

Here is the call graph for this function:

Here is the caller graph for this function:

createImageView()

VkImageView Chronos::Engine::createImageView	(	Chronos::Engine::Device	device,
		VkFormat	format,
		VkImage	image
	)

Create a VkImageView for a given VkImage.

For each image, we need to create an image view. This is used to specify how the image is to be used.

Parameters

device	The device that has the image.
format	The format of the image.
image	The image to create the image view for.

Returns

The created image view.

Definition at line 255 of file texture.cpp.

{
    VkImageViewCreateInfo viewInfo {};
    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    viewInfo.image = image;
    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
    viewInfo.format = format;
    viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    viewInfo.subresourceRange.baseMipLevel = 0;
    viewInfo.subresourceRange.levelCount = 1;
    viewInfo.subresourceRange.baseArrayLayer = 0;
    viewInfo.subresourceRange.layerCount = 1;
 
    VkImageView imageView;
 
    if (vkCreateImageView(device.device, &viewInfo, nullptr, &imageView)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create texture image view!");
    }
    return imageView;
}

References Chronos::Engine::Device::device.

Here is the caller graph for this function:

createRenderPass()

VkRenderPass Chronos::Engine::createRenderPass	(	Chronos::Engine::Device	device,
		Chronos::Engine::SwapChain	swapChain,
		VkImageLayout	initalLayout,
		VkImageLayout	finalLayout,
		VkImageLayout	msaaFinalLayout,
		bool	msaa,
		bool	clearFramebuffer,
		bool	dependency
	)

Creates a render pass.

For a given swap chain, layouts, this creates a render pass. Please carefully read the parameters below before using this function to understand what each parameter does.

During the creation of the render pass, the render pass will transition the image from the initial layout to the final layout. If MSAA is enabled, then the render pass will also transition the image from the final layout to the msaa final layout. The other parameters are also detailed below.

Parameters

initalLayout	The initial layout of the incoming image. If this from the previous frame(no render pass before it) then this is _IMAGE_LAYOUT_UNDEFINED , else it is advised to use _IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL .
finalLayout	The final layout of the outgoing image before MSAA. If this is going to be presented to the screen, then this is _IMAGE_LAYOUT_PRESENT_SRC_KHR , else it is advised to use _IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL . If MSAA is enabled, then this is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, as then msaaFinalLayout is used for the final layout if this is the final render pass.
msaaFinalLayout	The final layout of the outgoing image if MSAA is enabled. This is due to the fact that MSAA resolves the image, hence it change the layout of the image. If this is going to be presented to the screen, then this is VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, else it is advised to use VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL.
msaa	Whether MSAA is enabled or not.
clearFramebuffer	Whether the framebuffer should be cleared or not. If this is the first render pass, then this should be true. Else it should be false, else the previous contents rendered to the framebuffer from the previous render pass will be cleared.
dependency	Whether the render pass should wait for other render passes to finish. If there are render passes before this, then this should be true. Else it should be false.

Definition at line 175 of file helper.cpp.

{
    VkRenderPass renderPass;
    VkAttachmentDescription colorAttachment {};
    colorAttachment.format = swapChain.swapChainImageFormat;
    // if using msaa, set the bits
    if (msaa && device.msaaSamples != VK_SAMPLE_COUNT_1_BIT) {
    colorAttachment.samples = device.msaaSamples;
    } else {
    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    }
    // when using multiple render passes, we dont want to clear the framebuffer
    // each pass
    if (clearFramebuffer) {
    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    } else {
    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
    }
    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    colorAttachment.initialLayout = initalLayout; // initial layout of image
    colorAttachment.finalLayout
    = finalLayout; // final layout of image if not using msaa
 
    VkAttachmentDescription colorAttachmentResolve {};
    colorAttachmentResolve.format = swapChain.swapChainImageFormat;
    colorAttachmentResolve.samples = VK_SAMPLE_COUNT_1_BIT;
    colorAttachmentResolve.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachmentResolve.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    colorAttachmentResolve.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachmentResolve.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    colorAttachmentResolve.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    colorAttachmentResolve.finalLayout
    = msaaFinalLayout; // final layout if using msaa
 
    VkAttachmentReference colorAttachmentRef {};
    colorAttachmentRef.attachment = 0;
    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
    VkAttachmentReference colorAttachmentResolveRef {};
    colorAttachmentResolveRef.attachment = 1;
    colorAttachmentResolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
    VkSubpassDescription subpass {};
    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
    subpass.colorAttachmentCount = 1;
    subpass.pColorAttachments = &colorAttachmentRef;
    if (msaa && device.msaaSamples != VK_SAMPLE_COUNT_1_BIT) {
    subpass.pResolveAttachments = &colorAttachmentResolveRef;
    } else {
    subpass.pResolveAttachments = nullptr;
    }
    // if we are using multiple render passes, then we need to wait for other
    // commands to finish
    VkSubpassDependency subpassDependencies[2];
    subpassDependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
    subpassDependencies[0].dstSubpass = 0;
    subpassDependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    subpassDependencies[0].dstStageMask
    = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    subpassDependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
    subpassDependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
    | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    subpassDependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 
    subpassDependencies[1].srcSubpass = 0;
    subpassDependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
    subpassDependencies[1].srcStageMask
    = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    subpassDependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    subpassDependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
    | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    subpassDependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
    subpassDependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 
    std::vector<VkAttachmentDescription> attachments = { colorAttachment };
    if (msaa && device.msaaSamples != VK_SAMPLE_COUNT_1_BIT) {
    attachments.push_back(colorAttachmentResolve);
    }
 
    VkRenderPassCreateInfo renderPassInfo {};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
    renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
    renderPassInfo.pAttachments = attachments.data();
    renderPassInfo.subpassCount = 1;
    renderPassInfo.pSubpasses = &subpass;
    if (dependency) {
    renderPassInfo.dependencyCount = 2;
    renderPassInfo.pDependencies = subpassDependencies;
    }
    if (vkCreateRenderPass(device.device, &renderPassInfo, nullptr, &renderPass)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create render pass!");
    }
    return renderPass;
}

References Chronos::Engine::Device::device, Chronos::Engine::Device::msaaSamples, and Chronos::Engine::SwapChain::swapChainImageFormat.

Here is the caller graph for this function:

createTextureSampler()

void Chronos::Engine::createTextureSampler	(	Chronos::Engine::Device	device,
		VkSampler *	textureSampler
	)

Creates a VkSampler

Parameters

device	Device to create the sampler on.
textureSampler	Sampler to be created.

Definition at line 278 of file texture.cpp.

{
    VkPhysicalDeviceProperties properties {};
    vkGetPhysicalDeviceProperties(device.physicalDevice, &properties);
    VkSamplerCreateInfo samplerInfo {};
    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
    samplerInfo.magFilter = VK_FILTER_LINEAR;
    samplerInfo.minFilter = VK_FILTER_LINEAR;
    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.anisotropyEnable = VK_TRUE;
    samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
    samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
    samplerInfo.unnormalizedCoordinates = VK_FALSE;
    samplerInfo.compareEnable = VK_FALSE;
    samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    samplerInfo.mipLodBias = 0.0f;
    samplerInfo.minLod = 0.0f;
    samplerInfo.maxLod = 0.0f;
    if (vkCreateSampler(device.device, &samplerInfo, nullptr, textureSampler)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to create texture sampler!");
    }
}

References Chronos::Engine::Device::device, and Chronos::Engine::Device::physicalDevice.

Here is the caller graph for this function:

endSingleTimeCommands()

void Chronos::Engine::endSingleTimeCommands	(	VkCommandBuffer *	commandBuffer,
		Chronos::Engine::Device	device,
		VkCommandPool	commandPool
	)

Ends recording of single time command buffer and destroys it.

Ends recording of the command buffer and destroys the temporary

created using beginSingleTimeCommands. Generally used for transfering data.

Parameters

commandBuffer	The command buffer created by to destroy.
device	The device that has the command pool.
commandPool	The command pool that has the command buffer.

Definition at line 47 of file helper.cpp.

{
    vkEndCommandBuffer(*commandBuffer);
 
    VkSubmitInfo submitInfo {};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = commandBuffer;
 
    vkQueueSubmit(device.graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
    vkQueueWaitIdle(device.graphicsQueue);
 
    vkFreeCommandBuffers(device.device, commandPool, 1, commandBuffer);
}

References Chronos::Engine::Device::device, and Chronos::Engine::Device::graphicsQueue.

Here is the caller graph for this function:

findMemoryType()

uint32_t Chronos::Engine::findMemoryType	(	uint32_t	typeFilter,
		VkMemoryPropertyFlags	properties,
		VkPhysicalDevice	physicalDevice
	)

Finds suitable memory type for given requrements.

This is used to find a memory type on the physical device(GPU) that is suitable for the buffer that we are creating. It takes in the

and VkMemoryPropertyFlags to find such a memory type.

Parameters

typeFilter	The filter to find the memory type.
properties	The properties of the memory type.
physicalDevice	The physical device to find the memory type on.

Returns

The index of the memory type.

Definition at line 63 of file helper.cpp.

{
    VkPhysicalDeviceMemoryProperties memProperties;
    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
    if ((typeFilter & (1 << i))
        && (memProperties.memoryTypes[i].propertyFlags & properties)
        == properties) {
        return i;
    }
    }
    throw std::runtime_error("failed to find suitable memory type!");
}

Here is the caller graph for this function:

findQueueFamilies()

Chronos::Engine::QueueFamilyIndices Chronos::Engine::findQueueFamilies	(	VkPhysicalDevice	device,
		VkSurfaceKHR	surface
	)

Gets the indices of the needed queue families.

It finds the required graphics and presentation queue families on the physical device(GPU). It checks if the given physical device is capable of rendering to the surface that we provide it.

Parameters

device	The physical device(GPU) to find the queue families on.
surface	The surface to which we are rendering.

Definition at line 126 of file helper.cpp.

{
    Chronos::Engine::QueueFamilyIndices indices;
    uint32_t queueFamilyCount = 0;
    vkGetPhysicalDeviceQueueFamilyProperties(
    device, &queueFamilyCount, nullptr);
    // get the queue families
    std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(
    device, &queueFamilyCount, queueFamilies.data());
    // check if the queue family has the required properties
    int i = 0;
    for (const auto& queueFamily : queueFamilies) {
    if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
        indices.graphicsFamily = i;
    }
    VkBool32 presentSupport = false;
    vkGetPhysicalDeviceSurfaceSupportKHR(
        device, i, surface, &presentSupport);
    if (presentSupport) {
        indices.presentFamily = i;
    }
    if (indices.isComplete()) {
        break;
    }
    i++;
    }
    return indices;
}

References Chronos::Engine::QueueFamilyIndices::graphicsFamily, Chronos::Engine::QueueFamilyIndices::isComplete(), and Chronos::Engine::QueueFamilyIndices::presentFamily.

Here is the call graph for this function:

Here is the caller graph for this function:

getFontType()

Chronos::Engine::FontTypes Chronos::Engine::getFontType	(	std::string	fontType,
		int	fontSize
	)

Definition at line 51 of file getFontType.cpp.

{
    switch (fontSize) {
    FONT_CASE(6)
    FONT_CASE(7)
    FONT_CASE(8)
    FONT_CASE(9)
    FONT_CASE(10)
    FONT_CASE(11)
    FONT_CASE(12)
    FONT_CASE(13)
    FONT_CASE(14)
    FONT_CASE(15)
    FONT_CASE(16)
    FONT_CASE(17)
    FONT_CASE(18)
    FONT_CASE(19)
    FONT_CASE(20)
    FONT_CASE(21)
    FONT_CASE(22)
    FONT_CASE(23)
    FONT_CASE(24)
    FONT_CASE(25)
    FONT_CASE(26)
    FONT_CASE(27)
    FONT_CASE(28)
    FONT_CASE(29)
    FONT_CASE(30)
    FONT_CASE(31)
    FONT_CASE(32)
    FONT_CASE(33)
    FONT_CASE(34)
    FONT_CASE(35)
    FONT_CASE(36)
    FONT_CASE(37)
    FONT_CASE(38)
    FONT_CASE(39)
    FONT_CASE(40)
    FONT_CASE(41)
    FONT_CASE(42)
    FONT_CASE(43)
    FONT_CASE(44)
    FONT_CASE(45)
    FONT_CASE(46)
    FONT_CASE(47)
    FONT_CASE(48)
    FONT_CASE(49)
    FONT_CASE(50)
    default:
    throw std::runtime_error("Font size not found");
    }
}

References FONT_CASE.

Here is the caller graph for this function:

querySwapChainSupport()

Chronos::Engine::SwapChainSupportDetails Chronos::Engine::querySwapChainSupport	(	VkPhysicalDevice	device,
		VkSurfaceKHR	surface
	)

For a given swapchain mode, it gets the capabilites, formats and present modes.

For a given device and surface, there are multiple available swapchain modes available for use. This gets those details for further use.

Parameters

device	The physical device(GPU) on which we are rendering.
surface	The rendering surface(basically a vulkan window.)

Returns

The support details of the swapchain.

Definition at line 65 of file swapchain.cpp.

{
    Chronos::Engine::SwapChainSupportDetails details;
    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    device, surface, &details.capabilities);
 
    uint32_t formatCount;
    vkGetPhysicalDeviceSurfaceFormatsKHR(
    device, surface, &formatCount, nullptr);
 
    if (formatCount != 0) {
    details.formats.resize(formatCount);
    vkGetPhysicalDeviceSurfaceFormatsKHR(
        device, surface, &formatCount, details.formats.data());
    }
 
    uint32_t presentModeCount;
    vkGetPhysicalDeviceSurfacePresentModesKHR(
    device, surface, &presentModeCount, nullptr);
 
    if (presentModeCount != 0) {
    details.presentModes.resize(presentModeCount);
    vkGetPhysicalDeviceSurfacePresentModesKHR(
        device, surface, &presentModeCount, details.presentModes.data());
    }
 
    return details;
}

References Chronos::Engine::SwapChainSupportDetails::capabilities, Chronos::Engine::SwapChainSupportDetails::formats, and Chronos::Engine::SwapChainSupportDetails::presentModes.

Here is the caller graph for this function:

transitionImageLayout()

void Chronos::Engine::transitionImageLayout	(	VkImage	image,
		VkImageLayout	oldLayout,
		VkImageLayout	newLayout,
		VkCommandPool	commandPool,
		Chronos::Engine::Device	device
	)

Transiton a VkImage from one layout to another.

Only the following transitions are supported:

• VK_IMAGE_LAYOUT_UNDEFINED to

  _IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL

• VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL to

  _IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Parameters

image	The image to be transitioned.
oldLayout	The old layout of the image(VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL).
newLayout	The new layout of the image(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL).

Definition at line 190 of file texture.cpp.

{
    VkCommandBuffer commandBuffer
    = Chronos::Engine::beginSingleTimeCommands(commandPool, device.device);
    VkImageMemoryBarrier barrier {};
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.oldLayout = oldLayout;
    barrier.newLayout = newLayout;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = image;
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrier.subresourceRange.baseMipLevel = 0;
    barrier.subresourceRange.levelCount = 1;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount = 1;
    VkPipelineStageFlags sourceStage;
    VkPipelineStageFlags destinationStage;
 
    if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED
    && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
    barrier.srcAccessMask = 0;
    barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 
    sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
    destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
    } else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
    && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
    sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
    destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else {
    throw std::invalid_argument("unsupported layout transition!");
    }
 
    vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0,
    nullptr, 0, nullptr, 1, &barrier);
    Chronos::Engine::endSingleTimeCommands(&commandBuffer, device, commandPool);
}

References beginSingleTimeCommands(), Chronos::Engine::Device::device, and endSingleTimeCommands().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

deviceExtensions

const std::vector<const char*> Chronos::Engine::deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }

THis contain the device extensions that are needed to be enabled in vulkan.

Definition at line 36 of file device.hpp.

{ VK_KHR_SWAPCHAIN_EXTENSION_NAME };