vulkan-project/src/utility/vulkan_util.hpp

#pragma once

#include "vertex.hpp"

#include <optional>
#include <set>
#include <unordered_map>
#define VULKAN_HPP_NO_CONSTRUCTORS
#define VULKAN_HPP_NO_EXCEPTIONS
#include <vulkan/vulkan.hpp>

#ifdef GZ_UTIL_STRING_CONCEPTS
    static_assert(false, "gz-util/util/string_conversion.hpp is included before vulkan_util.hpp!");
#endif

template<typename T>
concept VkToString = requires(const T& t) {
    { vk::to_string(t) };
};

template<VkToString T>
inline std::string toString(const T& t) {
    return vk::to_string(t);
}

namespace gz::vlk {
    /**
     * @name Convenience structs
     * @details
     *  Structures and functionas making usiing the vulkan api more convenient
     * @{
     */
    /**
     * @brief Struct containing all physical device features structs
     * @details
     *  Make sure to call vkGetPhysicalDeviceFeatures2 with the f member, not this struct itself
     * @todo Redo with vulkan.hpp and vk::StructureChain
     */
    struct PhysicalDeviceFeatures {
        /**
         * @brief Initialize the structs with sType and pNext chain f -> f11 -> f12 -> f13
         */
        PhysicalDeviceFeatures();
        VkPhysicalDeviceFeatures2 f {};
        VkPhysicalDeviceVulkan11Features f11{};
        VkPhysicalDeviceVulkan12Features f12{};
        VkPhysicalDeviceVulkan13Features f13{};
        /**
         * @brief Check if all features enabled in requiredFeatures are enabled in this
         */
        bool requiredFeaturesAvailable(const PhysicalDeviceFeatures& requiredFeatures) const;
    };

    enum PipelineT {
        PL_3D, PL_2D
    };
    struct Pipeline {
        vk::Pipeline pipeline;
        vk::PipelineLayout layout;
        void operator=(const Pipeline& other) = delete;
    };

    /**
     * @brief Map holding pipelines
     */
    class PipelineContainer {
        public:
            using iterator = std::unordered_map<PipelineT, Pipeline>::iterator;
            Pipeline& operator[](const PipelineT& key) { return pipelines[key]; }
            /**
             * @brief Destroy the pipeline+layout and then remove the handles from the underlying map
             */
            void erase(const PipelineT& key, const vk::Device& device, const vk::AllocationCallbacks* pAllocator=nullptr);
            /**
             * @brief Destroy the pipeline+layout and then remove the handles from the underlying map
             */
            iterator erase(const iterator& it, const vk::Device& device, const vk::AllocationCallbacks* pAllocator=nullptr);
            /**
             * @brief Destroy all pipelines#layouts and then remove the handles from the underlying map
             */
            void destroy(const vk::Device& device, const vk::AllocationCallbacks* pAllocator=nullptr);
            iterator begin() { return pipelines.begin(); }
            iterator end() { return pipelines.end(); }
            size_t size() const { return pipelines.size(); }
        private:
            std::unordered_map<PipelineT, Pipeline> pipelines;

    };

    struct SwapChainSupport {
        vk::SurfaceCapabilities2KHR capabilities;
        std::vector<vk::SurfaceFormat2KHR> formats;
        std::vector<vk::PresentModeKHR> presentModes;
    };


    template<typename T>
    concept SupportedIndexType = std::same_as<T, uint16_t> or std::same_as<T, uint32_t>;

    template<SupportedIndexType T>
    struct VerticesAndIndices {
        std::vector<Vertex3D> vertices;
        std::vector<T> indices;
        constexpr vk::IndexType getIndexType() const {
            if (std::same_as<T, uint16_t>) {
                return vk::IndexType::eUint16;
            }
            else if (std::same_as<T, uint32_t>) {
                return vk::IndexType::eUint32;
            }
        }
    };


    struct QueueFamilyIndices {
        std::optional<uint32_t> graphicsFamily;
        std::optional<uint32_t> presentFamily;
        std::optional<uint32_t> transferFamily;

        bool hasNecessaryValues() {
            return graphicsFamily.has_value() && presentFamily.has_value();
        }
        bool hasAllValues() {
            return graphicsFamily.has_value() && presentFamily.has_value() && transferFamily.has_value();
        }

        std::string toString() const {
            std::string s = "[ ";
            s += "graphicsFamily: ";
            if (graphicsFamily.has_value()) { s += std::to_string(graphicsFamily.value()); }
            else { s += "not set"; }
            s += ", presentFamily: ";
            if (presentFamily.has_value()) { s += std::to_string(presentFamily.value()); }
            else { s += "not set"; }
            s += ", transferFamily: ";
            if (transferFamily.has_value()) { s += std::to_string(transferFamily.value()); }
            else { s += "not set"; }
            return s + " ]";
        }
    };


    /**
     * @brief Get a vk::DependencyInfo struct for a single image memory barrier
     */
    vk::DependencyInfo getDepInfo(const vk::ImageMemoryBarrier2& barrier);

    /**
     * @brief Fill bufMeqReq and memReq 
     * @details
     *  Fill the structs and call vkGetBufferMemoryRequirements2()
     */
    /* void getBufferMemoryRequirements(const vk::Device& device, const vk::Buffer& buffer, vk::BufferMemoryRequirementsInfo2& bufMemReq, vk::MemoryRequirements2& memReq); */

    /**
     * @brief Fill imMemReq and memReq 
     * @details
     *  Fill the structs and call vkGetImageMemoryRequirements2()
     */
    /* void getImageMemoryRequirements(const vk::Device& device, const vk::Image& image, vk::ImageMemoryRequirementsInfo2& imMemReq, vk::MemoryRequirements2& memReq); */
    /// @}

    /**
     * @brief Used for debugging
     * @see VulkanInstance::debugLog
     * @details
     *  Handles like vk::Device are pointers to the actual handle.
     *  Register the handle to a vulkan object with this struct and call updateHandles().
     *  The handles set will then contain the actual address of the handle, as printed by the validation layers.
     *  That means you can check a handle returned by a validation layer 
     *  with this struct and see if this handle belongs to object that created this struct.
     * @warning 
     *  Every pointer you submit to this must stay valid!
     *  Use this struct only when debugging!
     */  
    struct ObjectUsingVulkan {
        ObjectUsingVulkan(std::string&& name, std::vector<void*>&& ptrsToHandles, std::vector<void*>&& vectorWithPtrsToHandles);
        std::string objectName;
        std::vector<void*> ptrToHandle;
        std::vector<std::vector<void*>*> vectorWithPtrToHandle;
        std::set<uint64_t> handles;
        /**
         * @brief Update the handles map with the current handle (aka segfault generator)
         */
        void updateHandles();
        
    };


    /**
     * @brief Check if all required extensions are available
     */
    template<std::ranges::forward_range RE, std::ranges::forward_range AE>
    bool areExtensionsAvailable(const RE& requiredExtensions, const AE& availableExtensions) 
        requires std::same_as<std::ranges::range_reference_t<RE>, const char*&> and std::same_as<std::ranges::range_reference_t<AE>, vk::ExtensionProperties&> 
    {
        bool extensionAvailable;
        for (const auto& requiredExtension : requiredExtensions) {
            extensionAvailable = false;
            for (const auto& extension : availableExtensions) {
                if (strcmp(requiredExtension, extension.extensionName) == 0) {
                    extensionAvailable = true;
                    break;
                }
            }
            if (!extensionAvailable) {
                return false;
            }
        }
        return true;
    }

    /**
     * @file 
     * @brief Various utility structs and functions, as well as toString() overload for vk objects
     */

} // namespace gz::vlk