2bc7fe05f2
everything now uses VulkanAllocator for allocations (through VulkanInstance::createXXX functions)
722 lines
30 KiB
C++
722 lines
30 KiB
C++
#pragma once
|
|
|
|
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
|
#include <glm/glm.hpp>
|
|
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
|
|
#include "vk_convert.hpp"
|
|
|
|
#include "vertex.hpp"
|
|
#include "shape.hpp"
|
|
#include "vulkan_util.hpp"
|
|
#include "vulkan_allocator.hpp"
|
|
|
|
|
|
#include <gz-util/log.hpp>
|
|
#include <gz-util/settings_manager.hpp>
|
|
#include <gz-util/util/string.hpp>
|
|
|
|
#include <vulkan/vulkan_core.h>
|
|
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
namespace gz::vk {
|
|
constexpr bool throwExceptionOnValidationError = true;
|
|
constexpr gz::Color VULKAN_MESSAGE_PREFIX_COLOR = gz::Color::BO_BLUE;
|
|
constexpr gz::Color VULKAN_MESSAGE_TIME_COLOR = gz::Color::BLUE;
|
|
const std::string CONFIG_FILE = "vulkan.conf";
|
|
#define SettingsTypes uint32_t, bool, float
|
|
|
|
/* const std::string MODEL_PATH = "models/gazebo-3d-model/gazebo.obj"; */
|
|
/* const std::string TEXTURE_PATH = "models/gazebo-3d-model/gazebo_diffuse.png"; */
|
|
|
|
const std::string MODEL_PATH = "models/armoire-3d-model/Armoire.obj";
|
|
const std::string TEXTURE_PATH = "models/armoire-3d-model/Armoire_diffuse.png";
|
|
|
|
const gz::util::unordered_string_map<std::string> INITIAL_SETTINGS = {
|
|
{ "framerate", "60" },
|
|
{ "anisotropy_enable", "false" },
|
|
{ "max_anisotropy", "1" },
|
|
{ "max_frames_in_flight", "3" },
|
|
/* { "", "" } */
|
|
};
|
|
|
|
|
|
constexpr VkClearColorValue missingTextureColor = { { 0.4f, 0.0f, 0.4f, 1.0f } };
|
|
const int BINDING = 0;
|
|
const uint32_t NO_FLAGS = 0;
|
|
const uint32_t NO_OFFSET = 0;
|
|
constexpr VkAllocationCallbacks* NO_ALLOC = nullptr;
|
|
const size_t VERTEX_BUFFER_SIZE = 512;
|
|
const size_t INDEX_BUFFER_SIZE = 512;
|
|
enum InstanceCommandPool {
|
|
POOL_GRAPHICS, POOL_TRANSFER
|
|
};
|
|
|
|
/**
|
|
* @nosubgrouping
|
|
*/
|
|
class VulkanInstance {
|
|
public:
|
|
/**
|
|
* @name Public Interface: For the "creator" of the instance
|
|
* @details
|
|
* These functions will probably called from your `main` function and loop.
|
|
*/
|
|
/// @{
|
|
VulkanInstance(gz::SettingsManagerCreateInfo<SettingsTypes>smCI) : settings(smCI), allocator(*this) {};
|
|
/**
|
|
* @brief Initializes the vulkan instance
|
|
* @details
|
|
* -# @ref createWindow "create a window through glfw"
|
|
* -# @ref createInstance "create the vulkan instance"
|
|
* -# @ref setupDebugMessenger "sets up the debug messenger"
|
|
* -# @ref createSurface "create a the window surface"
|
|
* -# @ref selectPhysicalDevice "select a GPU"
|
|
* -# @ref setValidSettings "set the possible settings for the SettingsManager"
|
|
* -# @ref createLogicalDevice "create a logical device"
|
|
* -# @ref createSwapChain "create the swap chain"
|
|
* -# @ref createSwapChainImageViews "create the swap chain image views"
|
|
* -# @ref createCommandPools "create the command pools"
|
|
* @todo move depth image, texture, texture samples, model stuff to renderers
|
|
* -# @ref createCommandBuffers "create command buffers for swap chain image layout transitions"
|
|
* -# @ref createSyncObjects "create synchronization objects"
|
|
*/
|
|
void init();
|
|
/**
|
|
* @brief Acquires a new frame from the swap chain and sets the image layout
|
|
* @details
|
|
* How to draw stuff right now:
|
|
* -# Call this function
|
|
* -# Call the draw functions from the renderers.
|
|
* The renderers need to put the recorded command buffers into the commandBuffersToSubmitThisFrame vector using submitThisFrame()
|
|
* -# Call endFrameDraw
|
|
*/
|
|
uint32_t beginFrameDraw();
|
|
void endFrameDraw(uint32_t imageIndex);
|
|
/**
|
|
* @brief Cleanup the instance
|
|
* @details
|
|
* -# wait for the device to idle
|
|
* -# call @ref registerCleanupCallback() "cleanup callbacks" in reverse order to the registration
|
|
* -# destroy command buffers
|
|
* -# call cleanupSwapChain()
|
|
* -# destroy @ref createSyncObjects() "synchronization objects"
|
|
* -# destroy @ref createCommandPools() "command pools"
|
|
* -# call VulkanAllocator::cleanup()
|
|
* -# destroy device
|
|
* -# destroy surface
|
|
* -# call cleanupDebugMessenger()
|
|
* -# destroy instance
|
|
* -# call glfwDestroyWindow()
|
|
* -# call glfwTerminate()
|
|
*/
|
|
void cleanup();
|
|
GLFWwindow* getWindow() { return window; }
|
|
/// @}
|
|
|
|
/**
|
|
* @name Public Interface: init and cleanup
|
|
* @details
|
|
* These functions can be used by other parts of your program that use this instance,
|
|
* like a renderer.
|
|
*/
|
|
public:
|
|
/// @{
|
|
/**
|
|
* @brief Destroys everything that was initalized in init
|
|
* @details
|
|
* -# Calls every callback registered by registerCleanupCallback() (FILO order)
|
|
* -# calls cleanupSwapChain()
|
|
* -# destroys everything initalized in init()
|
|
* -# destroys the window
|
|
* -# calls glfwTerminate()
|
|
*/
|
|
void registerCleanupCallback(std::function<void()> callbackF);
|
|
|
|
void registerSwapChainRecreateCallback(std::function<void()> callbackF);
|
|
|
|
/**
|
|
* @brief Register vulkan handles used by another object
|
|
* @details
|
|
* Use this function to register vulkan handles used by another object.
|
|
* When a @ref debugLog "validation message" contains one of these handles, the owner can
|
|
* be determined and added to the message.
|
|
* This makes the debugging process easier when multiple objects use the same type of vulkan handle.
|
|
*/
|
|
static void registerObjectUsingVulkan(const ObjectUsingVulkan& obj);
|
|
/// @}
|
|
|
|
/**
|
|
* @name Public Interface: Various utility
|
|
* @details
|
|
* These functions can be used by other parts of your program that use this instance,
|
|
* like a renderer.
|
|
*/
|
|
public:
|
|
/// @{
|
|
const VkDevice& getDevice() const { return device; }
|
|
const VkExtent2D& getScExtent() const { return scExtent; }
|
|
const std::vector<VkImage>& getScImages() const { return scImages; }
|
|
const VkFormat& getScImageFormat() const { return scImageFormat; }
|
|
|
|
SettingsManager<SettingsTypes>& getSettings() { return settings; }
|
|
|
|
/**
|
|
* @brief Get the maximum number of frames in flight
|
|
* @see MAX_FRAMES_IN_FLIGHT
|
|
*/
|
|
uint32_t getMaxFramesInFlight() const { return MAX_FRAMES_IN_FLIGHT; }
|
|
/**
|
|
* @brief Get the frame that is currently in flight
|
|
* @see currentFrame
|
|
*/
|
|
uint32_t getCurrentFrame() const { return currentFrame; }
|
|
|
|
void submitThisFrame(VkCommandBuffer& cmdBuffer);
|
|
|
|
/**
|
|
* @brief Copy from srcBuffer to dstBuffer
|
|
* @details
|
|
* Uses @ref beginSingleTimeCommands() "a single time command buffer" from commandPoolTransfer.
|
|
*/
|
|
void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size);
|
|
|
|
/**
|
|
* @brief Begin a command buffer that is going to be used once
|
|
* @param commandPool: The command pool from which the buffer should be allocated
|
|
*/
|
|
VkCommandBuffer beginSingleTimeCommands(InstanceCommandPool commandPool);
|
|
/**
|
|
* @brief Submit cmdBuffer on the queue and free it afterwards
|
|
* @param cmdBuffer: Command buffer returned by beginSingleTimeCommands()
|
|
* @param commandPool: The same pool as passed to beginSingleTimeCommands()
|
|
*/
|
|
void endSingleTimeCommands(VkCommandBuffer cmdBuffer, InstanceCommandPool commandPool);
|
|
|
|
void loadModel(VerticesAndIndices<uint32_t>& model);
|
|
/// @}
|
|
|
|
/**
|
|
* @name Public Interface: Vulkan object creation/descruction
|
|
* @details
|
|
* These functions aim at making creation and desctruction of common vulkan objects easier
|
|
* and can be used by other parts of your program that use this instance,
|
|
* like a renderer.
|
|
*/
|
|
public:
|
|
/// @{
|
|
/**
|
|
* @brief Create MAX_FRAMES_IN_FLIGHT command buffers from the commandPoolGraphics
|
|
*/
|
|
void createCommandBuffers(std::vector<VkCommandBuffer>& commandBuffers);
|
|
/**
|
|
* @brief Destroy all command buffers (must be from commandPoolGraphics)
|
|
*/
|
|
void destroyCommandBuffers(std::vector<VkCommandBuffer>& commandBuffers);
|
|
|
|
/**
|
|
* @brief Create a descriptor layout with bindings
|
|
*/
|
|
void createDescriptorSetLayout(std::vector<VkDescriptorSetLayoutBinding> bindings, VkDescriptorSetLayout& layout);
|
|
|
|
/**
|
|
* @brief Create a new graphics pipeline
|
|
* @param vertexShader Path to the SPIR-V vertex shader
|
|
* @param fragmentShader Path to the SPIR-V fragment shader
|
|
* @param useDepthStencil Wether to use depth // TODO
|
|
* @param renderPass The (already created) render pass
|
|
* @param pipelineLayout Pipeline layout handle to bind
|
|
* @param pipeline Pipeline handle to bind
|
|
* @param T the type of Vertex to use
|
|
*
|
|
* @details
|
|
* Create a pipeline with:
|
|
* - 2 shader stages: vertex and fragment shader
|
|
* - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, vertices are triangles
|
|
* - viewport viewing the whole image as described by scExtent
|
|
* - scissor with offset (0, 0)
|
|
* - rasterizer:
|
|
* - triangles are filled with the colors from the vertex (VK_POLYGON_FILL)
|
|
* - counter clockwise front face (VK_FRONT_FACE_COUNTER_CLOCKWISE)
|
|
*/
|
|
template<VertexType T>
|
|
void createGraphicsPipeline(const std::string& vertexShader, const std::string& fragmentShader, std::vector<VkDescriptorSetLayout>& descriptorSetLayouts, bool useDepthStencil, VkRenderPass& renderPass, Pipeline& pipeline);
|
|
|
|
VkShaderModule createShaderModule(const std::vector<char>& code);
|
|
|
|
/**
|
|
* @brief Allocate memory, create a buffer and bind buffer to memory
|
|
* @param size The size of the buffer
|
|
* @param buffer The (null) handle to the buffer
|
|
* @param bufferMemory Reference to an (uninitialized) MemoryInfo struct. It will be valid when the function returns
|
|
* @param properties Properties that the buffers memory needs to satisfy
|
|
* @details
|
|
* The memory the buffer will be bound to is HOST_VISIBLE and HOST_COHERENT
|
|
*
|
|
*/
|
|
void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, MemoryInfo& bufferMemory, VkSharingMode sharingMode=VK_SHARING_MODE_EXCLUSIVE, std::vector<uint32_t>* qFamiliesWithAccess=nullptr);
|
|
/**
|
|
* @brief Destroy buffer and free memory
|
|
*/
|
|
void destroyBuffer(VkBuffer& buffer, MemoryInfo& bufferMemory);
|
|
|
|
/**
|
|
* @brief Create a vertex buffer
|
|
* @param vertexCount Number of vertices the buffer should contain
|
|
* @param vertexBuffer The (null) handle to the buffer
|
|
* @param vertexBufferMemory Reference to an (uninitialized) MemoryInfo struct. It will be valid when the function returns
|
|
* @details
|
|
* The function is instantiated for Vertex2D and Vertex3D
|
|
*/
|
|
template<VertexType VertexT>
|
|
void createVertexBuffer(size_t vertexCount, VkBuffer& vertexBuffer, MemoryInfo& vertexBufferMemory, VkDeviceSize& vertexBufferSize);
|
|
|
|
/**
|
|
* @brief Create an index buffer
|
|
* @param indexCount Number of indices the buffer should contain
|
|
* @param indexBuffer The (null) handle to the buffer
|
|
* @param indexBufferMemory Reference to an (uninitialized) MemoryInfo struct. It will be valid when the function returns
|
|
* @details
|
|
* The function is instantiated for uint16_t and uint32_t
|
|
*/
|
|
template<SupportedIndexType T>
|
|
void createIndexBuffer(size_t indexCount, VkBuffer& indexBuffer, MemoryInfo& indexBufferMemory, VkDeviceSize& indexBufferSize);
|
|
|
|
/**
|
|
* @brief Create MAX_FRAMES_IN_FLIGHT uniform buffers
|
|
*/
|
|
template<typename T>
|
|
void createUniformBuffers(std::vector<VkBuffer>& uniformBuffers, std::vector<MemoryInfo>& uniformBuffersMemory);
|
|
|
|
/**
|
|
* @brief Create as many framebuffers as the swap chain has images, with the extent of the swap chain
|
|
*/
|
|
void createFramebuffers(std::vector<VkFramebuffer>& framebuffers, std::vector<VkImageView>& imageViews, VkRenderPass& renderPass);
|
|
/**
|
|
* @brief Destroy the framebuffers
|
|
*/
|
|
void destroyFramebuffers(std::vector<VkFramebuffer>& framebuffers);
|
|
|
|
/**
|
|
* @brief Create a texture sampler
|
|
* @todo add options and documentation
|
|
*/
|
|
void createTextureSampler(VkSampler& sampler);
|
|
|
|
void destroyTextureSampler(VkSampler& sampler);
|
|
|
|
/**
|
|
* @name Public Interface: Image utility
|
|
* @details
|
|
* These functions can be used by other parts of your program that use this instance,
|
|
* like a renderer.
|
|
*/
|
|
/// @{
|
|
/**
|
|
* @brief Create a 2D image, allocate the imageMemory and bind the image to it
|
|
*/
|
|
void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags memoryProperties, VkImage& image, MemoryInfo& imageMI);
|
|
void destroyImage(VkImage& image, MemoryInfo& imageMemory);
|
|
/**
|
|
* @brief Create a 2D imageView with format for image.
|
|
*/
|
|
void createImageView(VkFormat format, VkImage& image, VkImageView& imageView, VkImageAspectFlags aspectFlags);
|
|
void destroyImageView(VkImageView& imageView);
|
|
|
|
void copyBufferToImage(VkBuffer buffer, VkImage image, int32_t offsetX, int32_t offsetY, uint32_t width, uint32_t height);
|
|
/**
|
|
* @todo make a version using vkCmdResolveImage for multisampled images
|
|
* @brief Copy srcImage to dstImage
|
|
* @details
|
|
* Both images must have:
|
|
* - same extent
|
|
* - mipLevel 0
|
|
* - layerCount 1
|
|
*
|
|
* Calls vkCmdBlitImage, but does NOT submit the commandBuffer
|
|
* @param cmdBuffer The command buffer where the command will be recorded to
|
|
* @param srcImage Image with layout TRANSFER_SRC_OPTIMAL
|
|
* @param dstImage Image with layout TRANSFER_DST_OPTIMAL
|
|
*/
|
|
void copyImageToImage(VkCommandBuffer& cmdBuffer, VkImage srcImage, VkImage dstImage, VkExtent2D extent); //, VkCommandPool& commandPool=commandPoolTransfer);
|
|
/**
|
|
* @brief Transition the layout of image from oldLayout to newLayout
|
|
* @details
|
|
* Supported transitions:
|
|
* - UNDEFINED -> DEPTH_STENCIL_ATTACHMENT_OPTIMAL (graphics q)
|
|
* - UNDEFINED -> TRANSFER_DST_OPTIMAL (transfer q)
|
|
* - SHADER_READ_ONLY_OPTIMAL -> TRANSFER_DST_OPTIMAL (graphics q)
|
|
* - TRANSFER_DST_OPTIMAL -> SHADER_READ_ONLY_OPTIMAL (graphics q)
|
|
* - TRANSFER_DST_OPTIMAL -> PRESENT_SRC_KHR (graphics q)
|
|
*
|
|
* If you do not provide a command buffer, a command buffer from the indicated queue will be created and submitted.
|
|
* If you do provide a command buffer, the command is recorded but NOT submitted.
|
|
*
|
|
* The transition is done by submitting a VkImageMemoryBarrier2
|
|
*
|
|
* @param cmdBuffer [Optional] The command buffer where the command will be recorded to
|
|
* @throws VkUserError if the transition is not supported.
|
|
*/
|
|
void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, VkCommandBuffer* cmdBuffer=nullptr);
|
|
/// @}
|
|
|
|
|
|
|
|
/**
|
|
* @name Debugging (validation messages)
|
|
*/
|
|
public:
|
|
/// @{
|
|
/**
|
|
* @brief Log messages from validation layers with the Apps logger
|
|
* @details
|
|
* Using the static vLog to log vulkan messages with a prefix dependant on the messageType.
|
|
* - Validation and performace messages usually have a bracket containing a VUID,
|
|
* these brackets are printed in yellow/red when its a warning/error.
|
|
* - Handles printed by the validation layer are checked with objectsUsingVulkan, if found
|
|
* the owner of the handle is added to the message @see registerObjectUsingVulkan(), ObjectUsingVulkan
|
|
* - Different message sources (layer, shader, general...) get a prefix with a different color
|
|
*/
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL debugLog(
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverety,
|
|
VkDebugUtilsMessageTypeFlagsEXT messageType,
|
|
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
|
|
void* pUserData);
|
|
/// @}
|
|
|
|
private:
|
|
/**
|
|
* @name Settings
|
|
*/
|
|
/// @{
|
|
gz::SettingsManager<SettingsTypes> settings;
|
|
/**
|
|
* @brief Set valid values for the SettingsManager according to phDevFeatures and phDevProperties
|
|
* @details
|
|
* Must be called after selectPhysicalDevice() and before createLogicalDevice()
|
|
* Sets valid values for:
|
|
* - anisotropy_enable (bool) [features.samplerAnisotropy]
|
|
* - max_anisotropy (float) [1-limits.maxSamplerAnisotropy]
|
|
* - max_frames_in_flight (uint32_t) [1-4]
|
|
*
|
|
*/
|
|
void setValidSettings();
|
|
/**
|
|
* @brief The maximum number of frames that can be ready for presentation
|
|
* @details
|
|
* A higher number can lead to more stable frame rates, but also increases latency.
|
|
*
|
|
* This variable is assigned from setting "max_frames_in_flight".
|
|
* @warning
|
|
* Do not use the setting from the settings manager:
|
|
* A lot of resources depend on this variable and if it gets changed at runtime, the program would crash.
|
|
* Always use this variable (or the @ref getMaxFramesInFlight() "getter").
|
|
* Changes to max_frames_in_flight will take effect upon restart.
|
|
*/
|
|
uint32_t MAX_FRAMES_IN_FLIGHT;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Window
|
|
*/
|
|
/// @{
|
|
GLFWwindow* window;
|
|
void createWindow();
|
|
/// @}
|
|
|
|
/**
|
|
* @name Framebuffers
|
|
*/
|
|
/// @{
|
|
bool frameBufferResized = false;
|
|
static void frameBufferResizedCallback(GLFWwindow* window, int width, int height);
|
|
|
|
/**
|
|
* @brief The frame that is currently in flight
|
|
* @details
|
|
* The value is between 0 and MAX_FRAMES_IN_FLIGHT - 1.
|
|
* It specifies which command buffer or uniform buffer to use for drawing the current frame,
|
|
* it is not the image index for the current @ref scImages "swap chain image".
|
|
*/
|
|
uint32_t currentFrame = 0;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Cleanup
|
|
*/
|
|
/// @{
|
|
std::vector<std::function<void()>> cleanupCallbacks;
|
|
std::vector<std::function<void()>> scRecreateCallbacks;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Instance
|
|
*/
|
|
/// @{
|
|
VkInstance instance;
|
|
/**
|
|
* @brief Create the vulkan instance
|
|
* @details
|
|
* -# check if validationLayers are available (if enabled)
|
|
* -# create instance with info
|
|
* -# check if all extensions required by glfw are available
|
|
*/
|
|
void createInstance();
|
|
/// @}
|
|
|
|
/**
|
|
* @name Physical device
|
|
*/
|
|
/// @{
|
|
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
|
|
/// all the properties of the selected physcial device
|
|
VkPhysicalDeviceProperties phDevProperties;
|
|
/// all the features that the selected physical device supports
|
|
PhysicalDeviceFeatures phDevFeatures;
|
|
/**
|
|
* @brief Get the required physical device features
|
|
* @details
|
|
* The required features are:
|
|
* - synchronization2
|
|
*/
|
|
PhysicalDeviceFeatures getRequiredFeatures() const;
|
|
/**
|
|
* @brief Assign the physicalDevice handle to the @ref rateDevice "best rated" GPU
|
|
* @details
|
|
* After this method, physicalDevice, phDevProperties and phDevFeatures will be initialized
|
|
*/
|
|
void selectPhysicalDevice();
|
|
/**
|
|
* @brief Assigns a score to a physical device.
|
|
* @details
|
|
* score = GPU_TYPE_FACTOR + VRAM_SIZE (in MB) + SUPPORTED_QUEUES_FACTOR + FEATURES_FACTORS
|
|
* A GPU is unsuitable and gets score 0 if it does not:
|
|
* - have the needed queue families
|
|
* - support all necessary extensions
|
|
* - have swap chain support
|
|
*/
|
|
unsigned int rateDevice(VkPhysicalDevice device);
|
|
/**
|
|
* @brief Find the best of the supported formats
|
|
* @param candidates Candidate format, from best to worst
|
|
* @returns The first format from candidates that is supported
|
|
*/
|
|
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
|
|
/// @}
|
|
|
|
/**
|
|
* @name Memory management
|
|
*/
|
|
/// @{
|
|
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
|
|
VulkanAllocator allocator;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Queue
|
|
*/
|
|
/// @{
|
|
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
|
|
QueueFamilyIndices qFamilyIndices;
|
|
VkQueue graphicsQ;
|
|
VkQueue presentQ;
|
|
// if possible, use dedicated transferQ. if not available, transferQ = graphicsQ
|
|
VkQueue transferQ;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Logical device
|
|
*/
|
|
/// @{
|
|
VkDevice device;
|
|
/**
|
|
* @details
|
|
* request anisotropic sampling feature
|
|
*/
|
|
void createLogicalDevice();
|
|
/// @}
|
|
|
|
/**
|
|
* @name Surface
|
|
*/
|
|
/// @{
|
|
VkSurfaceKHR surface;
|
|
void createSurface();
|
|
/// @}
|
|
|
|
/**
|
|
* @name Swap chain
|
|
*/
|
|
/// @{
|
|
VkSwapchainKHR swapChain;
|
|
std::vector<VkImage> scImages;
|
|
std::vector<VkImageView> scImageViews;
|
|
VkFormat scImageFormat;
|
|
VkExtent2D scExtent;
|
|
|
|
SwapChainSupport querySwapChainSupport(VkPhysicalDevice device);
|
|
/**
|
|
* @todo Rate formats if preferred is not available
|
|
*/
|
|
VkSurfaceFormatKHR selectSwapChainSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
|
|
/**
|
|
* @todo Check settings for preferred mode
|
|
*/
|
|
VkPresentModeKHR selectSwapChainPresentMode(const std::vector<VkPresentModeKHR>& availableModes);
|
|
VkExtent2D selectSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);
|
|
void createSwapChain();
|
|
void createSwapChainImageViews();
|
|
void cleanupSwapChain();
|
|
/**
|
|
* @brief Recreate the swap chain for the current window size
|
|
* @details
|
|
* Does:
|
|
* -# get new window dimensions
|
|
* - blocks while dimensions == 0 (minimized)
|
|
* -# calls cleanupSwapChain
|
|
* -# calls createSwapChain
|
|
* -# other stuff
|
|
* -# calls all callbacks registered with registerSwapChainRecreateCallback
|
|
*/
|
|
void recreateSwapChain();
|
|
/// @}
|
|
|
|
/**
|
|
* @name Command pools
|
|
*/
|
|
/// @{
|
|
VkCommandPool commandPoolGraphics;
|
|
VkCommandPool commandPoolTransfer;
|
|
void createCommandPools();
|
|
/// @}
|
|
/**
|
|
* @name Command buffers
|
|
*/
|
|
/// @{
|
|
std::vector<VkCommandBuffer> commandBuffersBegin;
|
|
std::vector<VkCommandBuffer> commandBuffersEnd;
|
|
/**
|
|
* @brief All command buffers to submit on graphics queue for the current frame
|
|
* @details
|
|
* Use submitThisFrame() to submit a command buffer
|
|
*/
|
|
std::vector<VkCommandBuffer> commandBuffersToSubmitThisFrame;
|
|
/// @}
|
|
|
|
/**
|
|
* @name Synchronization
|
|
*/
|
|
/// @{
|
|
std::vector<VkSemaphore> imageAvailableSemaphores;
|
|
std::vector<VkSemaphore> renderFinishedSemaphores;
|
|
std::vector<VkFence> inFlightFences;
|
|
void createSyncObjects();
|
|
/// @}
|
|
|
|
|
|
/**
|
|
* @name Shaders
|
|
*/
|
|
/// @{
|
|
/**
|
|
* @brief Load a binary file into vector of bytes
|
|
* @todo Move to more generic constant, does not need to be member function
|
|
*/
|
|
static std::vector<char> readFile(const std::string& filename);
|
|
/// @}
|
|
|
|
/**
|
|
* @name Utility
|
|
*/
|
|
/// @{
|
|
template<typename T, typename... Args>
|
|
VkResult runVkResultFunction(const char* name, Args&&... args);
|
|
template<typename T, typename... Args>
|
|
void runVkVoidFunction(const char* name, Args&&... args);
|
|
|
|
/**
|
|
* @name Debugging: (log and validation debug messenger)
|
|
*/
|
|
/// @{
|
|
void setupDebugMessenger();
|
|
void cleanupDebugMessenger();
|
|
VkDebugUtilsMessengerEXT debugMessenger;
|
|
static gz::Log vLog;
|
|
/// @} /// @}
|
|
|
|
/**
|
|
* @name Debugging: (handle ownership)
|
|
*/
|
|
/// @{
|
|
static std::vector<ObjectUsingVulkan> objectsUsingVulkan;
|
|
/**
|
|
* @brief Search for handles in message and get their owners
|
|
* @details
|
|
* Searches for handles (hex numbers) in message and sets handleOwnerString.\n
|
|
* If message contains no handle, handleOwnerString will be empty.
|
|
* If message contains at least one handle, handleOwnerString will be:
|
|
* `Handle Ownerships: [ <handle> - <owner>, ...]`
|
|
*/
|
|
static void getHandleOwnerString(std::string_view message);
|
|
static std::string handleOwnerString;
|
|
/// Used for alternating the color of validation messages between grey and white
|
|
static bool lastColorWhite;
|
|
/// @}
|
|
|
|
}; // VulkanInstance
|
|
|
|
//
|
|
// IMPLEMENTATIONS
|
|
//
|
|
//
|
|
// UNIFORM BUFFERS
|
|
//
|
|
template<typename T>
|
|
void VulkanInstance::createUniformBuffers(std::vector<VkBuffer>& uniformBuffers, std::vector<MemoryInfo>& uniformBuffersMemory) {
|
|
VkDeviceSize bufferSize = sizeof(T);
|
|
|
|
uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);
|
|
uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, uniformBuffers[i], uniformBuffersMemory[i]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// UTILITY
|
|
//
|
|
template<typename T, typename... Args>
|
|
VkResult VulkanInstance::runVkResultFunction(const char* name, Args&&... args) {
|
|
auto f = reinterpret_cast<T>(vkGetInstanceProcAddr(instance, name));
|
|
if (f == nullptr) {
|
|
vLog.error("getVkFunction: Could not get function:", name);
|
|
throw std::runtime_error("getVkFunction: Could not get function.");
|
|
}
|
|
else {
|
|
return f(std::forward<Args>(args)...);
|
|
}
|
|
};
|
|
|
|
template<typename T, typename... Args>
|
|
void VulkanInstance::runVkVoidFunction(const char* name, Args&&... args) {
|
|
auto f = reinterpret_cast<T>(vkGetInstanceProcAddr(instance, name));
|
|
if (f == nullptr) {
|
|
vLog.error("getVkFunction: Could not get function:", name);
|
|
throw std::runtime_error("getVkFunction: Could not get function.");
|
|
}
|
|
else {
|
|
f(std::forward<Args>(args)...);
|
|
}
|
|
}
|
|
|
|
}
|
|
/**
|
|
* @file Vulkan instance
|
|
*/
|
|
|