VKCommon.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Material/Forward.hpp"
#include "CeresEngine/RenderAPI/Forward.hpp"
 
#include "VKLoader.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Math/Offset.hpp"
#include "CeresEngine/RenderAPI/GPUMemory.hpp"
#include "CeresEngine/Texture/TextureFormat.hpp"
 
#define CE_VK_SAFE_CAST
 
//#define CE_VK_PROFILING
#if defined(CE_VK_PROFILING)
#define CE_VK_PROFILE_FUNC CE_PROFILE_FUNC
#else
#define CE_VK_PROFILE_FUNC
#endif
 
//#define CE_VK_GPU_PROFILING
#if defined(CE_VK_GPU_PROFILING)
namespace tracy {
    using namespace CeresEngine {}
 
#include <TracyVulkan.hpp>
#endif
 
#if CE_PLATFORM_MAC || CE_PLATFORM_IOS
#define CE_VK_CHECK_PTR(P) true
#else
#define CE_VK_CHECK_PTR(P) (P != nullptr)
#endif
 
    namespace CeresEngine {
 
        //    using VKAllocator = FallbackAllocator<AllocatorReference<MemoryPoolCollection<NodePool, BucketDistribution::Log2Buckets>>, DefaultAllocator>;
        using VKAllocator = DefaultAllocator;
        VKAllocator& gVKAllocator();
 
        using VKObjectAllocator = ThreadSafeAllocator<MemoryPool<NodePool, AllocatorReference<VKAllocator>>>;
 
        template<typename T> static VKObjectAllocator VKMakeObjectAllocator(const std::size_t initialSize = 100) {
            return VKObjectAllocator{VKObjectAllocator::allocator_type{
                sizeof(T),
                sizeof(T) * initialSize,
                gVKAllocator(),
            }};
        }
 
        template<typename T> using VKVector = Vector<T, VKAllocator>;
 
#define CE_VK_RENDER_API_OBJECT_FORWARD(N) \
    class VK##N;                           \
    using VK##N##Ptr = RC<VK##N>;
        CE_RENDER_API_OBJECT_EACH(CE_VK_RENDER_API_OBJECT_FORWARD);
#undef CE_VK_RENDER_API_OBJECT_FORWARD
 
#if defined(CE_VK_SAFE_CAST)
#define CE_VK_CAST dynamic_cast
#else
#define CE_VK_CAST static_cast
#endif
 
        class VKObjectBase {
        public:
            static void* operator new(size_t size) noexcept;
            static void operator delete(void* p, std::size_t sz) noexcept;
        };
 
        template<typename ChildTypeName, typename ParentType = void> class VKObject : public VKObjectBase {
        public:
            static RC<ChildTypeName> cast(const RC<ParentType>& ptr) { return RC<ChildTypeName>(CE_VK_CAST<ChildTypeName*>(ptr.get())); }
 
            static ChildTypeName& cast(ParentType& object) { return CE_VK_CAST<ChildTypeName&>(object); }
 
            static const ChildTypeName& cast(const ParentType& object) { return CE_VK_CAST<const ChildTypeName&>(object); }
 
            static ChildTypeName* cast(ParentType* object) { return CE_VK_CAST<ChildTypeName*>(object); }
 
            static const ChildTypeName* cast(const ParentType* object) { return CE_VK_CAST<const ChildTypeName*>(object); }
        };
 
        template<typename ChildTypeName> class VKObject<ChildTypeName, void> {};
 
        class VKDeviceObjectBase {
        public:
            VKDevice& deviceVK;
 
        public:
            explicit VKDeviceObjectBase(VKDevice& device) noexcept;
 
            ~VKDeviceObjectBase() noexcept;
        };
 
        template<typename ChildTypeName, typename ParentType = void>
        class VKDeviceObject : public VKObject<ChildTypeName, ParentType>, public VKDeviceObjectBase {
        protected:
            explicit VKDeviceObject(VKDevice& device) noexcept : VKDeviceObjectBase(device) {}
        };
 
        template<typename ObjectType, typename OwnerType = VKDevice, typename DescriptorType = typename ObjectType::Descriptor> class VKObjectCache {
        public:
            using Descriptor = DescriptorType;
 
            using Object = ObjectType;
 
            using ObjectPtr = RC<Object>;
 
        private:
            OwnerType& mOwner;
 
            HashMap<UInt64, Object*> mCache;
 
        public:
            explicit VKObjectCache(OwnerType& owner);
 
            ~VKObjectCache();
 
        public:
            ObjectPtr get(const Descriptor& descriptor);
 
            ObjectPtr operator[](const Descriptor& descriptor) { return get(descriptor); }
 
            void release(Object* object);
        };
 
        [[nodiscard]] VkShaderStageFlagBits VKMap(ShaderType shaderType);
        [[nodiscard]] VkFormat VKMap(Format format);
        [[nodiscard]] VkImageViewType VKMap(GPUImageType imageType);
        [[nodiscard]] VkPrimitiveTopology VKMap(PrimitiveTopology primitiveTopology);
        [[nodiscard]] VkPolygonMode VKMap(GPUPolygonMode polygonMode);
        [[nodiscard]] VkCullModeFlags VKMap(GPUCullMode cullMode);
        [[nodiscard]] VkCompareOp VKMap(GPUCompareOp compareOp);
        [[nodiscard]] VkStencilOp VKMap(GPUStencilOp stencilOp);
        [[nodiscard]] VkLogicOp VKMap(GPULogicOp logicOp);
        [[nodiscard]] VkBlendFactor VKMap(GPUBlendOp blendOp);
        [[nodiscard]] VkBlendOp VKMap(GPUBlendArithmetic blendArithmetic);
        [[nodiscard]] VkSamplerAddressMode VKMap(GPUSamplerAddressMode addressMode);
        [[nodiscard]] VkDescriptorType VKMap(GPUDescriptorType resourceViewType);
        [[nodiscard]] VkAttachmentLoadOp VKMap(GPUAttachmentLoadOp loadOp);
        [[nodiscard]] VkAttachmentStoreOp VKMap(GPUAttachmentStoreOp storeOp);
        [[nodiscard]] VkImageLayout VKMap(GPUImageLayout layout);
        [[nodiscard]] VkIndexType VKMap(IndexType type);
        [[nodiscard]] VkMemoryPropertyFlags VKMap(const GPUMemoryProperties& memoryProperty);
        [[nodiscard]] VkComponentSwizzle VKMap(GPUImageSwizzle imageSwizzle);
        [[nodiscard]] VkVertexInputRate VKMap(GPUVertexInputRate vertexInputRate);
 
        [[nodiscard]] VkImageAspectFlags toVkImageAspectFlags(Format format);
 
        void convert(VkRect2D& dst, const Viewport& src) noexcept;
        void convert(VkViewport& dst, const Viewport& src) noexcept;
        [[nodiscard]] VkViewport convert(const Viewport& src) noexcept;
 
        void convert(VkRect2D& dst, const Scissor& src) noexcept;
        [[nodiscard]] VkRect2D convert(const Scissor& src) noexcept;
 
        void convert(VkOffset3D& dst, const TOffset3<UInt32>& src) noexcept;
        [[nodiscard]] VkOffset3D convert(const TOffset3<UInt32>& src) noexcept;
 
        void convert(VkExtent3D& dst, const TExtent3<UInt32>& src) noexcept;
        [[nodiscard]] VkExtent3D convert(const TExtent3<UInt32>& src) noexcept;
 
        [[nodiscard]] StringView VKObjectTypeString(VkObjectType objectType) noexcept;
 
        // Converts the boolean value into a VkBool32 value.
        [[nodiscard]] inline constexpr VkBool32 VKBoolean(const bool value) noexcept { return (value ? VK_TRUE : VK_FALSE); }
 
        // Throws an RuntimeError exception if 'result' is not VK_SUCCESS.
        void VKThrowIfFailed(VkResult result, const char* info);
 
        struct VKSurfaceSupportDetails {
            VkSurfaceCapabilitiesKHR capabilities;
            Vector<VkSurfaceFormatKHR> formats;
            Vector<VkPresentModeKHR> presentModes;
        };
 
        [[nodiscard]] VKSurfaceSupportDetails VKQuerySurfaceSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
 
        struct VKPickedQueueFamily {
            UInt32 familyIndex;
 
            UInt32 queueIndex;
        };
 
        struct VKQueueFamilyAssigner {
            struct FamilyInfo {
                UInt32 index;
 
                VkQueueFamilyProperties properties;
 
                UInt32 usageCount = 0;
            };
 
            Vector<FamilyInfo> families;
 
            explicit VKQueueFamilyAssigner(VkPhysicalDevice device) noexcept;
 
            [[nodiscard]] Optional<VKPickedQueueFamily> pickFamily(VkQueueFlagBits capabilities) noexcept;
 
            [[nodiscard]] Optional<VKPickedQueueFamily> pickGraphicsFamily() noexcept;
 
            [[nodiscard]] Optional<VKPickedQueueFamily> pickTransferFamily() noexcept;
 
            [[nodiscard]] Optional<VKPickedQueueFamily> pickComputeFamily() noexcept;
 
            [[nodiscard]] Optional<VKPickedQueueFamily> pickPresentFamily(VkPhysicalDevice device, VkSurfaceKHR surface) noexcept;
        };
 
        [[nodiscard]] Vector<VkLayerProperties> VKQueryInstanceLayerProperties();
 
        [[nodiscard]] Vector<VkExtensionProperties> VKQueryInstanceExtensionProperties(const char* layerName = nullptr);
 
        [[nodiscard]] Vector<VkPhysicalDevice> VKQueryPhysicalDevices(VkInstance instance);
 
        [[nodiscard]] Vector<VkExtensionProperties> VKQueryDeviceExtensionProperties(VkPhysicalDevice device);
 
        [[nodiscard]] Vector<VkQueueFamilyProperties> VKQueryQueueFamilyProperties(VkPhysicalDevice device);
 
        template<typename T> struct VKDebugMarkerTypeTrait;
 
#define DECLARE_DEBUG_MARKER_TYPE_TRAIT(T, C) \
    template<> struct VKDebugMarkerTypeTrait<T> { static const constexpr VkObjectType type = C; };
 
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkInstance, VK_OBJECT_TYPE_INSTANCE);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkBuffer, VK_OBJECT_TYPE_BUFFER);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkImage, VK_OBJECT_TYPE_IMAGE);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkImageView, VK_OBJECT_TYPE_IMAGE_VIEW);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkSampler, VK_OBJECT_TYPE_SAMPLER);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkPipeline, VK_OBJECT_TYPE_PIPELINE);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkDescriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkCommandBuffer, VK_OBJECT_TYPE_COMMAND_BUFFER);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkRenderPass, VK_OBJECT_TYPE_RENDER_PASS);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkShaderModule, VK_OBJECT_TYPE_SHADER_MODULE);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkFramebuffer, VK_OBJECT_TYPE_FRAMEBUFFER);
        DECLARE_DEBUG_MARKER_TYPE_TRAIT(VkSemaphore, VK_OBJECT_TYPE_SEMAPHORE);
 
        template<typename T> VkResult VKSetObjectName(const VkDevice device, T object, StringView name) {
            if(!CE_VK_CHECK_PTR(vkSetDebugUtilsObjectNameEXT)) {
                return VK_SUCCESS;
            }
 
            const VkDebugUtilsObjectNameInfoEXT objectNameInfo = {
                VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
                nullptr,
                VKDebugMarkerTypeTrait<T>::type,
                (UInt64)object,
                name.data(),
            };
            return vkSetDebugUtilsObjectNameEXT(device, &objectNameInfo);
        }
 
    } // namespace CeresEngine