PipelineCache.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** PipelineCache
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <cstddef>
#include <filesystem>
#include <vector>
 
namespace evan
{
    class PipelineCache:
        protected utility::logging::Loggable<PipelineCache,
                                             utility::logging::DefaultLogger>
    {
        public:
        PipelineCache() = default;
 
        ~PipelineCache() = default;
 
        PipelineCache(const PipelineCache &) = delete;
        PipelineCache &operator=(const PipelineCache &) = delete;
 
        [[nodiscard]] static VkPipelineCacheHeaderVersionOne
            buildHeader(const VkPhysicalDeviceProperties &properties);
 
        [[nodiscard]] static bool isBlobCompatible(
            const std::vector<std::byte> &blob,
            const VkPipelineCacheHeaderVersionOne &expected);
 
        [[nodiscard]] static bool
            readBlob(const std::filesystem::path &path,
                     std::vector<std::byte> &blob);
 
        [[nodiscard]] static bool
            writeBlob(const std::filesystem::path &path,
                      const std::vector<std::byte> &blob);
 
        void init(VkDevice device, VkPhysicalDevice physicalDevice,
                  const std::filesystem::path &path);
 
        void persist();
 
        void destroy(VkDevice device);
 
        [[nodiscard]] VkPipelineCache getHandle() const { return _handle; }
 
        [[nodiscard]] bool isPersistent() const { return !_path.empty(); }
 
        private:
        VkDevice _device = VK_NULL_HANDLE;
 
        VkPipelineCache _handle = VK_NULL_HANDLE;
 
        std::filesystem::path _path;
 
        VkPipelineCacheHeaderVersionOne _expectedHeader {};
    };
}    // namespace evan