foray_shadermanager.hpp

Go to the documentation of this file.

#pragma once
#include "../osi/foray_env.hpp"
#include "foray_core_declares.hpp"
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace foray::core {
 
    struct ShaderCompilerConfig
    {
        std::vector<osi::Utf8Path> IncludeDirs = {};
        std::vector<std::string> Definitions = {};
        std::string EntryPoint = "";
        std::vector<std::string> AdditionalOptions = {};
    };
 
 
    class ShaderManager
    {
      public:
        inline explicit ShaderManager(core::Context* context = nullptr) : mContext(context) {}
 
        uint64_t CompileShader(osi::Utf8Path sourceFilePath, ShaderModule& shaderModule, const ShaderCompilerConfig& config = {}, core::Context* context = nullptr);
        uint64_t CompileShader(osi::Utf8Path sourceFilePath, ShaderModule* shaderModule, const ShaderCompilerConfig& config = {}, core::Context* context = nullptr);
 
        virtual bool CheckAndUpdateShaders(std::unordered_set<uint64_t>& out_recompiled);
 
        ShaderManager() = default;
 
        virtual bool CallGlslCompiler(std::string_view args);
 
      protected:
        using WriteTimeLookup = std::unordered_map<osi::Utf8Path, std::filesystem::file_time_type>;
 
        core::Context* mContext = nullptr;
 
        virtual uint64_t MakeHash(std::string_view absoluteUniqueSourceFilePath, const ShaderCompilerConfig& config);
 
        static std::filesystem::file_time_type GetWriteTime(const osi::Utf8Path& path, WriteTimeLookup& writeTimeLookup);
 
        struct IncludeFile;
 
        enum class ECompileCheckResult
        {
            UpToDate,
            MissingInput,
            NeedsRecompile
        };
 
        struct ShaderCompilation
        {
            ShaderManager* Manager = nullptr;
            osi::Utf8Path SourcePath = {};
            osi::Utf8Path SpvPath = {};
            std::filesystem::file_time_type LastCompile = std::filesystem::file_time_type::min();
            std::filesystem::file_time_type LastFailedCompile = std::filesystem::file_time_type::min();
            std::unordered_set<IncludeFile*> Includes = {};
            ShaderCompilerConfig Config = {};
            uint64_t Hash = 0;
            ShaderCompilation(ShaderManager* manager, const osi::Utf8Path& source, const ShaderCompilerConfig& config, uint64_t hash);
            void FindIncludes();
            bool Compile();
            ECompileCheckResult NeedsCompile(WriteTimeLookup& compileTimeLookup);
        };
 
        struct IncludeFile
        {
            osi::Utf8Path Path;
            std::unordered_set<ShaderCompilation*> Includers;
            std::unordered_set<IncludeFile*> Includees;
 
            inline IncludeFile(const osi::Utf8Path& path) : Path(path) {}
 
            void GetIncludesRecursively(std::unordered_set<IncludeFile*>& out);
        };
 
        std::unordered_map<uint64_t, std::unique_ptr<ShaderCompilation>> mTrackedCompilations;
        std::unordered_map<osi::Utf8Path, std::unique_ptr<IncludeFile>> mTrackedIncludeFiles;
 
        void DiscoverIncludes(ShaderCompilation* compilation);
        IncludeFile* RecursivelyProcessInclude(const osi::Utf8Path& path, const std::vector<osi::Utf8Path>& extraIncludeDirs);
    };
 
}  // namespace foray::core