GPUInternal.hpp

#pragma once
 
#include "Common.hpp"
#include "graphics/GPUObjects.hpp"
#include "graphics/DescriptorAllocator.hpp"
#include "graphics/QueryAllocator.hpp"
#include "graphics/PipelineCache.hpp"
#include "graphics/SamplerLibrary.hpp"
#include "resources/Buffer.hpp"
 
#include <deque>
#include <functional>
 
 
// Forward declaration.
class Texture;
 
#ifdef DEBUG
    #define VK_RETURN_CHECK(F, L) do {\
        VkResult res = (F);\
        if(res != VK_SUCCESS){\
            Log::Error() << Log::GPU << "Vulkan return error at line " << L << std::endl;\
            VkUtils::checkResult(res);\
        }\
    } while(0);
#else
#define VK_RETURN_CHECK(F, L) (F);
#endif
 
#define VK_RET(F) VK_RETURN_CHECK((F), __LINE__)
 
struct ResourceToDelete {
    VkImageView view = VK_NULL_HANDLE; 
    VkSampler sampler = VK_NULL_HANDLE; 
    VkImage image = VK_NULL_HANDLE; 
    VkBuffer buffer = VK_NULL_HANDLE; 
    VmaAllocation data = VK_NULL_HANDLE; 
    uint64_t frame = 0; 
};
 
struct AsyncTextureTask {
    std::shared_ptr<Buffer> dstBuffer; 
    std::unique_ptr<Texture> dstTexture; 
    std::function<void(const Texture&)> callback; 
    glm::uvec2 dstImageRange{0u,0u}; 
    uint64_t frame = 0; 
    GPUAsyncTask id = 0; 
};
 
struct GPUContext {
 
    VkInstance instance = VK_NULL_HANDLE; 
    VkDebugUtilsMessengerEXT debugMessenger = VK_NULL_HANDLE; 
    VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; 
    VkDevice device = VK_NULL_HANDLE; 
    VkSurfaceKHR surface = VK_NULL_HANDLE; 
    VkCommandPool commandPool = VK_NULL_HANDLE; 
    std::vector<VkCommandBuffer> renderCommandBuffers; 
    std::vector<VkCommandBuffer> uploadCommandBuffers; 
    VkQueue graphicsQueue= VK_NULL_HANDLE; 
    VkQueue presentQueue= VK_NULL_HANDLE; 
    DescriptorAllocator descriptorAllocator; 
    std::unordered_map<GPUQuery::Type, QueryAllocator> queryAllocators; 
    PipelineCache pipelineCache; 
    SamplerLibrary samplerLibrary; 
    
    std::deque<ResourceToDelete> resourcesToDelete; 
    std::deque<AsyncTextureTask> textureTasks; 
    uint64_t tasksCount = 0; 
    
    VkPipeline graphicsPipeline = VK_NULL_HANDLE; 
    VkPipeline computePipeline = VK_NULL_HANDLE; 
 
    uint32_t graphicsId = 0; 
    uint32_t presentId = 0; 
 
    uint64_t frameIndex = 0; 
    uint32_t swapIndex = 0; 
 
    double timestep = 0.0; 
    size_t uniformAlignment = 0; 
    bool portability = false; 
    const uint frameCount = 2; 
    bool newRenderPass = true; 
    bool hadRenderPass = false; 
    bool inRenderPass = false; 
    bool markersEnabled = false; 
 
    void nextFrame(){
        ++frameIndex;
        swapIndex = (uint32_t)(frameIndex % (uint64_t)frameCount);
    }
 
    VkCommandBuffer& getRenderCommandBuffer(){
        return renderCommandBuffers[swapIndex];
    }
 
    VkCommandBuffer& getUploadCommandBuffer(){
        return uploadCommandBuffers[swapIndex];
    }
 
};
 
VKAPI_ATTR VkBool32 VKAPI_CALL vkDebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* callbackData, void* userData);
 
namespace VkUtils {
 
    bool checkLayersSupport(const std::vector<const char*> & requestedLayers);
 
    bool checkExtensionsSupport(const std::vector<const char*> & requestedExtensions);
 
    std::vector<const char *> getRequiredInstanceExtensions(bool enableDebugMarkers, bool enablePortability);
 
    bool checkDeviceExtensionsSupport(VkPhysicalDevice device, const std::vector<const char*> & requestedExtensions, bool & hasPortability);
 
    bool getQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface, int & graphicsFamily, int & presentFamily);
 
    Layout convertFormat(const VkFormat& format);
 
    Layout findSupportedFormat(const VkPhysicalDevice & physicalDevice, const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
 
    void typesFromShape(const TextureShape & shape, VkImageType & imgType, VkImageViewType & viewType);
 
    VkCommandBuffer beginSyncOperations(GPUContext & context);
 
    void endSyncOperations(VkCommandBuffer & commandBuffer, GPUContext & context);
 
    void imageLayoutBarrier(VkCommandBuffer& commandBuffer, GPUTexture& texture, VkImageLayout newLayout, uint mipStart, uint mipCount, uint layerStart, uint layerCount);
 
    void mipLayoutBarrier(VkCommandBuffer& commandBuffer, const Texture& texture, VkImageLayout newLayout, uint mip);
 
    void textureLayoutBarrier(VkCommandBuffer& commandBuffer, const Texture& texture, VkImageLayout newLayout);
 
    void createCommandBuffers(GPUContext & context, uint count);
 
    void checkResult(VkResult status);
 
    VkSamplerAddressMode getGPUWrapping(Wrap mode);
 
    void getGPUFilters(Filter filtering, VkFilter & imgFiltering, VkSamplerMipmapMode & mipFiltering);
 
    unsigned int getGPULayout(Layout typedFormat, VkFormat & format);
 
    glm::uvec2 copyTextureRegionToBuffer(VkCommandBuffer& commandBuffer, const Texture & srcTexture, std::shared_ptr<Buffer> & dstBuffer, uint mipStart, uint mipCount, uint layerStart, uint layerCount, const glm::uvec2& offset, const glm::uvec2& size);
 
    void blitTexture(VkCommandBuffer& commandBuffer, const Texture& src, const Texture& dst, uint mipStartSrc, uint mipStartDst, uint mipCount, uint layerStartSrc, uint layerStartDst, uint layerCount, const glm::uvec2& srcBaseOffset, const glm::uvec2& srcBaseSize, const glm::uvec2& dstBaseOffset, const glm::uvec2& dstBaseSize, Filter filter);
 
    void setDebugName(GPUContext& context, VkObjectType type, uint64_t handle, const char* format, ...);
 
}
 
STD_HASH(VkImageLayout);