#include <engine.hpp>

Collaboration diagram for Chronos::Engine::Engine:

[legend]

Public Member Functions
	Engine ()
	Initlizes the engine.

void	drawFrame ()
	Main draw call. Its responsible for drawing frames and resizing the window. To be added to the main game loop.

void	resizeFrameBuffer ()
	Tells the engine that the window has to be resized. This is called by GLFW.

void	setPresentMode (std::string mode)
	Changes the present mode of the swapchain.

	~Engine ()
	This is the destructor of the engine.

void	changeMSAA (std::string)

std::vector< std::string >	getAvailableMSAAModes ()

Public Attributes
Chronos::Engine::ObjectManager	objectManager

Chronos::Engine::TextureManager	textureManager
	Used to create and manage textures.

int	width = 800
	This is the initial width of the window. It can be changed later just by changing this directly.

int	height = 600
	This is the initial width of the window. It can be changed later just by changing this directly.

GLFWwindow *	window
	This is the GLFW window reference that is used by the engine.

float	bgColor [3] = { 0.0f, 0.0f, 0.0f }
	This is the background color of the window.

Chronos::Engine::Device	device = Chronos::Engine::Device()
	This is the object that manages the device.

Chronos::Engine::SwapChain	swapChain = Chronos::Engine::SwapChain()
	This is the object that manages the swapchain.

VkCommandPool	commandPool
	The command Pool.

Private Member Functions
void	changeMSAASettings ()

void	initWindow ()
	This function initializes the GLFW window.

void	initVulkan ()
	The complicated process of initalizing the vulkan API is done here.

void	cleanup ()
	Cleans up vulkan objects.

void	createInstance ()
	Creates a vulkan instance.

void	createSurface ()
	Creates the surface to render to.

void	createSyncObjects ()
	Creates sync objects for rendering.

void	changePresentMode ()

Private Attributes
bool	changeMSAAFlag = false

VkSampleCountFlagBits	newMSAAMode

bool	framebufferResized = false
	Does the framebuffer need to be resized?

uint32_t	currentFrame = 0
	The current frame to be rendered to.

VkInstance	instance
	The Vulkan instance.

VkSurfaceKHR	surface
	The surface to render to.

std::vector< VkSemaphore >	imageAvailableSemaphores

std::vector< VkSemaphore >	renderFinishedSemaphores

std::vector< VkFence >	inFlightFences

Detailed Description

\brief This is the main vulkan backend for Chronos.
This is for use by the API only and should not be used for any other
purpose.

This is resposible for managing the object and shapes that related to
vulkan. It is also in charge of drawing frames and managing the window. It
automatically handles window resizing, creation and destruction of necessary
objects. Any shapes or text to be created is to be done throught the
shapeManager and textManager respectively.

In order to draw a frame, create a loop and call the drawFrame.

##Important
drawFrame will not handle inputs.
It will also draw only one frame per call.
Hence the inputs must be managed by the main loop.
This is done to allow flexibility in inputs and management of the frame
drawing.

## drawFrame() example
Suppose Engine class is initialized as engine
The following code snippet is an example of a basic rendering loop.
It also includes functionaility to close the window either when the escape
key is pressed or when the window is closed. For more on handling inputs,
please see the GLFW documentation.

~~~~~~~~~~~~~~~{.cpp}
    while (!glfwWindowShouldClose(engine.window)) {

if esc is pressed, then ask GLFW to close the window if (glfwGetKey(engine.window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { glfwSetWindowShouldClose(engine.window, true); } draw the frame engine.drawFrame(); } ~~~~~~~~~~~~~~~

Definition at line 81 of file engine.hpp.

Constructor & Destructor Documentation

◆ Engine()

Chronos::Engine::Engine::Engine ( )

Initlizes the engine.

During initialization of the engine, all the processes and calls needed to intialize vulkan and GLFW are done. No other function needs to be called to initialize the engine. During initialization the following occurs:

If the editor is enabled, then the editor(EditorRenderer) settings are initialized The window is created The vulkan API is initialized along with all the necessary objects.

Definition at line 37 of file engine.cpp.

{
#ifdef ENABLE_EDITOR
    gui = Chronos::Editor::EditorRenderer();
#endif
    // initialize the window and vulkan
    initWindow();
    LOG(3, "GLFW initialized")
    initVulkan();
    LOG(3, "Vulkan initialized")
}

References initVulkan(), initWindow(), and LOG.

Here is the call graph for this function:

◆ ~Engine()

Chronos::Engine::Engine::~Engine ( )

This is the destructor of the engine.

It basically stops the device, and runs the cleanup function. This is so that it is guranteed that Vulkan objects will be cleaned up correctly.

Definition at line 49 of file engine.cpp.

{
    vkDeviceWaitIdle(device.device);
    cleanup();
    LOG(3, "Engine cleaned up")
}

References LOG.

Member Function Documentation

◆ changeMSAA()

void Chronos::Engine::Engine::changeMSAA ( std::string mode )

Definition at line 495 of file engine.cpp.

{
    if (mode == "64") {
    this->newMSAAMode = VK_SAMPLE_COUNT_64_BIT;
    } else if (mode == "32") {
    this->newMSAAMode = VK_SAMPLE_COUNT_32_BIT;
    } else if (mode == "16") {
    this->newMSAAMode = VK_SAMPLE_COUNT_16_BIT;
    } else if (mode == "8") {
    this->newMSAAMode = VK_SAMPLE_COUNT_8_BIT;
    } else if (mode == "4") {
    this->newMSAAMode = VK_SAMPLE_COUNT_4_BIT;
    } else if (mode == "2") {
    this->newMSAAMode = VK_SAMPLE_COUNT_2_BIT;
    } else if (mode == "1") {
    this->newMSAAMode = VK_SAMPLE_COUNT_1_BIT;
    } else {
    throw std::runtime_error("Invalid MSAA mode");
    }
    if (this->newMSAAMode > device.maxMsaaSamples) {
    throw std::runtime_error("Invalid MSAA mode");
    }
    this->changeMSAAFlag = true;
    LOG(3, "MSAA to be changed to " + mode)
}

References LOG.

Here is the caller graph for this function:

◆ changeMSAASettings()

void Chronos::Engine::Engine::changeMSAASettings ( )

private

Definition at line 521 of file engine.cpp.

{
    device.msaaSamples = this->newMSAAMode;
    this->swapChain.changeMsaa();
    this->objectManager.changeMsaa();
#ifdef ENABLE_EDITOR
    this->gui.changeMsaa();
#endif
    LOG(3, "MSAA changed to " + std::to_string(device.msaaSamples))
}

References LOG.

◆ changePresentMode()

void Chronos::Engine::Engine::changePresentMode ( )

private

Definition at line 442 of file engine.cpp.

{
    vkDeviceWaitIdle(device.device);
    swapChain.recreate();
    objectManager.recreate();
#ifdef ENABLE_EDITOR
    gui.recreate();
#endif
}

◆ cleanup()

void Chronos::Engine::Engine::cleanup ( )

private

Cleans up vulkan objects.

When the engine is exited, we need to clean up the vulkan objects. If we do not do this, vulkan validation layers will throw errors. The following occurs during this function:

The device is stopped
The swapchain is cleaned up
The shape and text manager along with their objects are cleaned up
The sync objects are cleaned up
The command Pool is destroyed
The device, surface and instance are destroyed
Window is destroyed and GLFW is terminated

Definition at line 104 of file engine.cpp.

{
    // after we are done, we need to cleanup all the resources we created
    swapChain.cleanup();
    LOG(3, "Swapchain cleaned up")
    objectManager.destroy();
    LOG(3, "Object manager cleaned up")
    textureManager.destroy();
    LOG(3, "Texture manager cleaned up")
#ifdef ENABLE_EDITOR
    gui.destroy();
    LOG(3, "Editor cleaned up")
#endif
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
    vkDestroySemaphore(device.device, renderFinishedSemaphores[i], nullptr);
    vkDestroySemaphore(device.device, imageAvailableSemaphores[i], nullptr);
    vkDestroyFence(device.device, inFlightFences[i], nullptr);
    }
    vkDestroyCommandPool(device.device, commandPool, nullptr);
    LOG(3, "Command pool cleaned up")
#ifdef ENABLE_VULKAN_VALIDATION_LAYERS
    DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
    LOG(3, "Debug messenger cleaned up")
#endif
    device.destroy(); // destroy the logical device
    LOG(3, "Device cleaned up")
    vkDestroySurfaceKHR(instance, surface, nullptr);
    vkDestroyInstance(instance, nullptr);
    glfwDestroyWindow(window);
    glfwTerminate();
    LOG(3, "GLFW cleaned up")
}

References LOG, and MAX_FRAMES_IN_FLIGHT.

◆ createInstance()

void Chronos::Engine::Engine::createInstance ( )

private

Creates a vulkan instance.

This function sets some of the information about our app. It enables all the extensions and validation layers.

Definition at line 319 of file engine.cpp.

{
    VkApplicationInfo appInfo {};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName = GAME_NAME;
    appInfo.applicationVersion = VK_MAKE_VERSION(
    GAME_VERSION_MAJOR, GAME_VERSION_MINOR, GAME_VERSION_PATCH);
    appInfo.pEngineName = "Chronos";
    appInfo.engineVersion = VK_MAKE_VERSION(
    CHRONOS_VERSION_MAJOR, CHRONOS_VERSION_MINOR, CHRONOS_VERSION_PATCH);
    // using vulkan 1.3 as we need shader printf support
    appInfo.apiVersion = VK_API_VERSION_1_0;
    LOG(3,
    "engine version: " + std::to_string(CHRONOS_VERSION_MAJOR) + "."
        + std::to_string(CHRONOS_VERSION_MINOR) + "."
        + std::to_string(CHRONOS_VERSION_PATCH))
    LOG(3,
    "game version: " + std::to_string(GAME_VERSION_MAJOR) + "."
        + std::to_string(GAME_VERSION_MINOR) + "."
        + std::to_string(GAME_VERSION_PATCH))
    LOG(3, "game name: " + std::string(GAME_NAME))
 
    VkInstanceCreateInfo createInfo {};
    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.pApplicationInfo = &appInfo;
 
    // uint32_t glfwExtensionCount = 0;
    // const char** glfwExtensions;
    // glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
 
    auto extensions = getRequiredExtensions();
    createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
    createInfo.ppEnabledExtensionNames = extensions.data();
 
#ifdef ENABLE_VULKAN_VALIDATION_LAYERS
    if (!checkValidationLayerSupport()) {
    LOG(1, "Validation layers requested, but not available")
    throw std::runtime_error(
        "Validation layers requested, but not available");
    }
#endif
 
    createInfo.enabledLayerCount = 0;
    createInfo.pNext = nullptr;
 
#ifdef ENABLE_VULKAN_VALIDATION_LAYERS
    createInfo.enabledLayerCount
    = static_cast<uint32_t>(validationLayers.size());
    createInfo.ppEnabledLayerNames = validationLayers.data();
    // uncomment below if u need fine details. It just creates extra verbose
    // generally not needed
    // VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo {};
    //  populateDebugMessengerCreateInfo(debugCreateInfo);
    //  createInfo.pNext =
    //  (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo;
#endif
    if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
    LOG(1, "Failed to create instance")
    throw std::runtime_error("Failed to create instance");
    }
}

References getRequiredExtensions(), and LOG.

Here is the call graph for this function:

◆ createSurface()

void Chronos::Engine::Engine::createSurface ( )

private

Creates the surface to render to.

Definition at line 395 of file engine.cpp.

{
    if (glfwCreateWindowSurface(instance, window, nullptr, &surface)
    != VK_SUCCESS) {
    LOG(1, "Failed to create window surface")
    throw std::runtime_error("Failed to create window surface");
    }
}

References LOG.

◆ createSyncObjects()

void Chronos::Engine::Engine::createSyncObjects ( )

private

Creates sync objects for rendering.

Since Vulkan uses explict sync, we need sync objects such as fences and semaphores to maintain synchronization.

Since there are multiple frames in flight, we need multiple copies for each sync object. In particular, we need:

A semaphore to signal that an image is available for rendering
A semaphore to signal that rendering has finished for a frame
In Flight fences to ensure that the renderer is synchronized with the GPU

Definition at line 404 of file engine.cpp.

{
    imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
 
    VkSemaphoreCreateInfo semaphoreInfo {};
    semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
 
    VkFenceCreateInfo fenceInfo {};
    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
    if (vkCreateSemaphore(device.device, &semaphoreInfo, nullptr,
        &imageAvailableSemaphores[i])
        != VK_SUCCESS
        || vkCreateSemaphore(device.device, &semaphoreInfo, nullptr,
           &renderFinishedSemaphores[i])
        != VK_SUCCESS
        || vkCreateFence(
           device.device, &fenceInfo, nullptr, &inFlightFences[i])
        != VK_SUCCESS) {
        LOG(1, "Failed to create synchronization objects for a frame")
        throw std::runtime_error(
        "failed to create synchronization objects for a frame!");
    }
    }
}

References LOG, and MAX_FRAMES_IN_FLIGHT.

◆ drawFrame()

void Chronos::Engine::Engine::drawFrame ( )

Main draw call. Its responsible for drawing frames and resizing the window. To be added to the main game loop.

During this function the following occurs:

It waits for the previous frame to be drawn and presented
It acquires the next image from the swapchain
If the window is resized, then the swapchain and any framebuffers and renderpasses are recreated
It updates the values of the shapes and text
Resets the sync objects
It records the command buffers
Configures the sync objects
Submits the command buffers. Note: Only after vkQueueSubmit is called, the command buffers are executed and the frame is rendered.
Presents the image to the screen

Definition at line 137 of file engine.cpp.

{
    if (swapChain.changePresentMode) {
    changePresentMode();
    swapChain.changePresentMode = false;
    LOG(3, "Present mode changed")
    }
    if (this->changeMSAAFlag) {
    vkDeviceWaitIdle(device.device);
    changeMSAASettings();
    this->changeMSAAFlag = false;
    LOG(3, "MSAA changed")
    }
    // wait for the previous frame to finish
    glfwPollEvents();
 
#ifdef CHRONOS_PROFILING
    std::chrono::steady_clock::time_point start
    = std::chrono::steady_clock::now();
#endif
 
    vkWaitForFences(
    device.device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
 
#ifdef CHRONOS_PROFILING
    this->waitTime = std::chrono::duration_cast<std::chrono::nanoseconds>(
    std::chrono::steady_clock::now() - start)
             .count();
#endif
 
    // get the index of the next image to render to
    uint32_t imageIndex;
    VkResult result = vkAcquireNextImageKHR(device.device, swapChain.swapChain,
    UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE,
    &imageIndex);
 
    // if window has been minimized, then recreate the swap chain and other
    // things
    if (result == VK_ERROR_OUT_OF_DATE_KHR) {
    swapChain.recreate();
    LOG(3, "Swapchain recreated")
    objectManager.recreate();
    LOG(3, "Object manager recreated")
#ifdef ENABLE_EDITOR
    gui.recreate();
    LOG(3, "Editor recreated")
#endif
    return;
    } else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
    LOG(1, "Failed to acquire swap chain image")
    throw std::runtime_error("Failed to acquire swap chain image");
    }
#ifdef CHRONOS_PROFILING
    auto startUpdate = std::chrono::steady_clock::now();
#endif
    // update the shapes and text
    objectManager.update(currentFrame);
 
#ifdef ENABLE_EDITOR
    gui.update();
#endif
#ifdef CHRONOS_PROFILING
    this->updateTime = std::chrono::duration_cast<std::chrono::nanoseconds>(
    std::chrono::steady_clock::now() - startUpdate)
               .count();
#endif
    LOG(4, "Managers updated")
 
    // reset the fences
    vkResetFences(device.device, 1, &inFlightFences[currentFrame]);
 
    // record the command buffers
    objectManager.render(currentFrame, imageIndex, bgColor);
#ifdef ENABLE_EDITOR
    gui.render(currentFrame, imageIndex, bgColor);
#endif
    LOG(4, "Managers command buffers recorded")
 
    // configure the semaphores
    VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] };
    VkPipelineStageFlags waitStages[]
    = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
    VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[currentFrame] };
 
    // submit the command buffers
    std::vector<VkCommandBuffer> submitCommandBuffers
    = { objectManager.commandBuffers[currentFrame] };
 
#ifdef ENABLE_EDITOR
    submitCommandBuffers.push_back(gui.commandBuffers[currentFrame]);
#endif
    VkSubmitInfo submitInfo {};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
    submitInfo.commandBufferCount
    = static_cast<uint32_t>(submitCommandBuffers.size());
    submitInfo.pCommandBuffers = submitCommandBuffers.data();
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;
 
    if (vkQueueSubmit(
        device.graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame])
    != VK_SUCCESS) {
    LOG(1, "Failed to submit draw command buffer")
    throw std::runtime_error("failed to submit draw command buffer!");
    }
    LOG(4, "Command buffers submitted")
 
#ifdef ENABLE_EDITOR
    gui.renderAdditionalViewports();
#endif
 
#ifdef CHRONOS_PROFILING
    this->cpuTime = std::chrono::duration_cast<std::chrono::nanoseconds>(
    std::chrono::steady_clock::now() - start)
            .count();
    auto startPresent = std::chrono::steady_clock::now();
#endif
 
    // present the image
    VkPresentInfoKHR presentInfo {};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;
    VkSwapchainKHR swapChains[] = { swapChain.swapChain };
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
    presentInfo.pImageIndices = &imageIndex;
    presentInfo.pResults = nullptr;
    result = vkQueuePresentKHR(device.presentQueue, &presentInfo);
    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR
    || framebufferResized) {
    framebufferResized = false;
    swapChain.recreate();
    LOG(3, "Swapchain recreated")
    objectManager.recreate();
    LOG(3, "Object Manager recreated")
#ifdef ENABLE_EDITOR
    gui.recreate();
    LOG(3, "Editor recreated")
#endif
    } else if (result != VK_SUCCESS) {
    LOG(1, "Failed to present swap chain image")
    throw std::runtime_error("Failed to present swap chain image");
    }
#ifdef CHRONOS_PROFILING
    this->presentTime = std::chrono::duration_cast<std::chrono::nanoseconds>(
    std::chrono::steady_clock::now() - startPresent)
                .count();
    this->totalTime = std::chrono::duration_cast<std::chrono::nanoseconds>(
    std::chrono::steady_clock::now() - start)
              .count();
#endif
    // update the current frame
    currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
    LOG(4, "Current frame is " + std::to_string(currentFrame))
}

References LOG, and MAX_FRAMES_IN_FLIGHT.

◆ getAvailableMSAAModes()

std::vector< std::string > Chronos::Engine::Engine::getAvailableMSAAModes ( )

Definition at line 469 of file engine.cpp.

{
    VkSampleCountFlagBits maxSample = device.maxMsaaSamples;
    std::vector<std::string> modes;
    if (VK_SAMPLE_COUNT_64_BIT <= maxSample) {
    modes.push_back("64");
    }
    if (VK_SAMPLE_COUNT_32_BIT <= maxSample) {
    modes.push_back("32");
    }
    if (VK_SAMPLE_COUNT_16_BIT <= maxSample) {
    modes.push_back("16");
    }
    if (VK_SAMPLE_COUNT_8_BIT <= maxSample) {
    modes.push_back("8");
    }
    if (VK_SAMPLE_COUNT_4_BIT <= maxSample) {
    modes.push_back("4");
    }
    if (VK_SAMPLE_COUNT_2_BIT <= maxSample) {
    modes.push_back("2");
    }
    modes.push_back("1");
    return modes;
}

Here is the caller graph for this function:

◆ initVulkan()

void Chronos::Engine::Engine::initVulkan ( )

private

The complicated process of initalizing the vulkan API is done here.

The following occurs during this function:

The vulkan instance is created
The validation layers are setup
The surface is created
The device is initialized
The swapchain is initialized
The command pool is created
The shape and text managers are initialized

Also the objects needed for the editor are also created here

Definition at line 74 of file engine.cpp.

{
    // create the basic objects
    createInstance();
 
#ifdef ENABLE_VULKAN_VALIDATION_LAYERS
    setupDebugMessenger();
#endif
    createSurface();
    device.init(instance, surface);
    LOG(3, "Device initialized")
    swapChain.init(&device, surface, window);
    LOG(3, "Swapchain initialized")
    commandPool = createCommandPool(device, swapChain.surface);
    LOG(3, "Command pool initialized")
 
    // initalize the object manager
    objectManager.init(&device, &swapChain, commandPool);
 
    textureManager.init(&device, commandPool);
    LOG(3, "Texture manager initialized")
 
    createSyncObjects();
 
#ifdef ENABLE_EDITOR
    gui.init(&device, window, &swapChain, instance, surface);
    LOG(3, "Editor initialized")
#endif
}

References Chronos::Engine::createCommandPool(), and LOG.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initWindow()

void Chronos::Engine::Engine::initWindow ( )

private

This function initializes the GLFW window.

It creates a GLFWwindow* and stores it in the window variable. It also sets the window hints sets the framebuffer callback.

Definition at line 58 of file engine.cpp.

{
    // initialize glfw with a resizeable window
    glfwInit();
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
 
    window = glfwCreateWindow(width, height, GAME_NAME, nullptr, nullptr);
    if (window == nullptr) {
    LOG(1, "Failed to create GLFW window")
    throw std::runtime_error("Failed to create GLFW window");
    }
    glfwMakeContextCurrent(window);
    glfwSetWindowUserPointer(window, this);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
}

References framebuffer_size_callback(), and LOG.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resizeFrameBuffer()

void Chronos::Engine::Engine::resizeFrameBuffer ( )

Tells the engine that the window has to be resized. This is called by GLFW.

It sets the flag that window has to be resized. Later during the drawFrame function, the swapchain is recreated and resets the flag. This tells Vulkan that the swapChain has to be recreated.

Definition at line 56 of file engine.cpp.

56{ framebufferResized = true; }

Here is the caller graph for this function:

◆ setPresentMode()

void Chronos::Engine::Engine::setPresentMode ( std::string mode )

Changes the present mode of the swapchain.

The present mode is the mode in which the images are presented to the screen. There are various methods available. this can be used to cap or unlock the framerate, control tearing etc. Some of the presentation modes available are:

immediate: Images submitted by your application are transferred to the screen right away, which may result in tearing.
fifo : 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".
fifo_relaxed : 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.
mailbox : 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

mode	The mode to change to. It can be one of the following: immediate fifo fifo_relaxed mailbox

Definition at line 452 of file engine.cpp.

{
    if (mode == "immediate") {
    this->swapChain.preferredPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
    } else if (mode == "fifo") {
    this->swapChain.preferredPresentMode = VK_PRESENT_MODE_FIFO_KHR;
    } else if (mode == "fifo_relaxed") {
    this->swapChain.preferredPresentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
    } else if (mode == "mailbox") {
    this->swapChain.preferredPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
    } else {
    throw std::runtime_error("Invalid present mode");
    }
    this->swapChain.changePresentMode = true;
    LOG(3, "Present mode set to " + mode)
}

References LOG.

Here is the caller graph for this function:

Member Data Documentation

◆ bgColor

float Chronos::Engine::Engine::bgColor[3] = { 0.0f, 0.0f, 0.0f }

This is the background color of the window.

It can be changed by changing the values inside this float. The values should be in the range of 0 to 1.

Definition at line 132 of file engine.hpp.

132{ 0.0f, 0.0f, 0.0f };

◆ changeMSAAFlag

bool Chronos::Engine::Engine::changeMSAAFlag = false

private

Definition at line 254 of file engine.hpp.

◆ commandPool

VkCommandPool Chronos::Engine::Engine::commandPool

The command Pool.

All command buffers are allocated from a command pool. This is where the command pool is stored.

Definition at line 251 of file engine.hpp.

◆ currentFrame

uint32_t Chronos::Engine::Engine::currentFrame = 0

private

The current frame to be rendered to.

Since there will be multiple frames in flight, we need to keep track of which frame is currently being rendered.

Definition at line 276 of file engine.hpp.

◆ device

Chronos::Engine::Device Chronos::Engine::Engine::device = Chronos::Engine::Device()

This is the object that manages the device.

This is due to the fact that device initialization and management is a complicated process. Also there are multiple variables that are needed for this. Hence for simplicity, a class was created for this purpose.

Definition at line 233 of file engine.hpp.

◆ framebufferResized

bool Chronos::Engine::Engine::framebufferResized = false

private

Does the framebuffer need to be resized?

When the window is resized, or minimized, the swapchain needs to be recreated. GLFW will tell us that this needs to happen, and when it does, this flag is set to true. The next time the drawFrame function is called, the swapchain will be recreated. During that time, this flag will be set to false.

Definition at line 268 of file engine.hpp.

◆ height

int Chronos::Engine::Engine::height = 600

This is the initial width of the window. It can be changed later just by changing this directly.

Definition at line 119 of file engine.hpp.

◆ imageAvailableSemaphores

std::vector<VkSemaphore> Chronos::Engine::Engine::imageAvailableSemaphores

private

Definition at line 306 of file engine.hpp.

◆ inFlightFences

std::vector<VkFence> Chronos::Engine::Engine::inFlightFences

private

Definition at line 308 of file engine.hpp.

◆ instance

VkInstance Chronos::Engine::Engine::instance

private

The Vulkan instance.

When initializing Vulkan, the first thing we create is an instance. This is where is it stored. We need this during cleanup

Definition at line 284 of file engine.hpp.

◆ newMSAAMode

VkSampleCountFlagBits Chronos::Engine::Engine::newMSAAMode

private

Definition at line 255 of file engine.hpp.

◆ objectManager

Chronos::Engine::ObjectManager Chronos::Engine::Engine::objectManager

Definition at line 99 of file engine.hpp.

◆ renderFinishedSemaphores

std::vector<VkSemaphore> Chronos::Engine::Engine::renderFinishedSemaphores

private

Definition at line 307 of file engine.hpp.

◆ surface

VkSurfaceKHR Chronos::Engine::Engine::surface

private

The surface to render to.

For rendering to the window from the Vulkan framebuffer, we need a surface.

Definition at line 304 of file engine.hpp.

◆ swapChain

Chronos::Engine::SwapChain Chronos::Engine::Engine::swapChain = Chronos::Engine::SwapChain()

This is the object that manages the swapchain.

All the swapchain related functions are handled by this object. This is due to the fact that swapChain needs to be constantly mananged and recreated due to various conditions.

Definition at line 243 of file engine.hpp.

◆ textureManager

Chronos::Engine::TextureManager Chronos::Engine::Engine::textureManager

Used to create and manage textures.

To add or remove textures, one may call the necessary methods in this class.

Definition at line 107 of file engine.hpp.

◆ width

int Chronos::Engine::Engine::width = 800

This is the initial width of the window. It can be changed later just by changing this directly.

Definition at line 113 of file engine.hpp.

◆ window

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

This is the GLFW window reference that is used by the engine.

Definition at line 124 of file engine.hpp.

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

Source/Rendering/engine.hpp
Source/Rendering/engine.cpp

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Engine()

◆ ~Engine()

Member Function Documentation

◆ changeMSAA()

◆ changeMSAASettings()

◆ changePresentMode()

◆ cleanup()

◆ createInstance()

◆ createSurface()

◆ createSyncObjects()

◆ drawFrame()

◆ getAvailableMSAAModes()

◆ initVulkan()

◆ initWindow()

◆ resizeFrameBuffer()

◆ setPresentMode()

Member Data Documentation

◆ bgColor

◆ changeMSAAFlag

◆ commandPool

◆ currentFrame

◆ device

◆ framebufferResized

◆ height

◆ imageAvailableSemaphores

◆ inFlightFences

◆ instance

◆ newMSAAMode

◆ objectManager

◆ renderFinishedSemaphores

◆ surface

◆ swapChain

◆ textureManager

◆ width

◆ window