HlslShader.h

#pragma once
 
// Standard.
#include <mutex>
#include <set>
 
// Custom.
#include "shader/general/Shader.h"
#include "render/RenderSettings.h"
#include "shader/hlsl/RootSignatureGenerator.h"
 
// External.
#include "directx/d3dx12.h"
#include "DirectXShaderCompiler/inc/dxcapi.h"
 
// OS.
#include <wrl.h>
 
namespace ne {
    using namespace Microsoft::WRL;
 
    class Renderer;
 
    class HlslShader : public Shader {
    public:
        HlslShader(
            Renderer* pRenderer,
            std::filesystem::path pathToCompiledShader,
            const std::string& sShaderName,
            ShaderType shaderType,
            const std::optional<VertexFormat>& vertexFormat,
            const std::string& sSourceFileHash);
 
        HlslShader() = delete;
        HlslShader(const HlslShader&) = delete;
        HlslShader& operator=(const HlslShader&) = delete;
 
        virtual ~HlslShader() override = default;
 
        static constexpr std::string_view getVertexShaderModel() { return sVertexShaderModel; }
 
        static constexpr std::string_view getPixelShaderModel() { return sPixelShaderModel; }
 
        static constexpr std::string_view getComputeShaderModel() { return sComputeShaderModel; }
 
        static std::variant<std::string, Error> getShaderCompilerVersion();
 
        static std::variant<ComPtr<IDxcResult>, std::string, Error> compileShaderToBytecode(
            const ShaderDescription& shaderDescription,
            const std::optional<std::filesystem::path>& pathToPdb);
 
        static std::variant<std::shared_ptr<Shader>, std::string, Error> compileShader(
            Renderer* pRenderer,
            const std::filesystem::path& cacheDirectory,
            const std::string& sConfiguration,
            const ShaderDescription& shaderDescription);
 
        std::variant<ComPtr<IDxcBlob>, Error> getCompiledBlob();
 
        std::pair<std::mutex, std::optional<RootSignatureGenerator::CollectedInfo>>* getRootSignatureInfo();
 
        std::string getShaderSourceFileHash() const;
 
        virtual bool releaseShaderDataFromMemoryIfLoaded() override;
 
    protected:
        [[nodiscard]] virtual std::optional<Error>
        saveAdditionalCompilationResultsInfo(ConfigManager& cacheMetadataConfigManager) override;
 
        [[nodiscard]] virtual std::optional<Error> checkCachedAdditionalCompilationResultsInfo(
            ConfigManager& cacheMetadataConfigManager,
            std::optional<ShaderCacheInvalidationReason>& cacheInvalidationReason) override;
 
    private:
        static std::variant<ComPtr<IDxcBlob>, Error>
        readBlobFromDisk(const std::filesystem::path& pathToFile);
 
        std::variant<std::string, Error> calculateReflectionFileHash();
 
        [[nodiscard]] std::optional<Error> loadShaderDataFromDiskIfNotLoaded();
 
        std::pair<std::recursive_mutex, ComPtr<IDxcBlob>> mtxCompiledBytecode;
 
        std::pair<std::mutex, std::optional<RootSignatureGenerator::CollectedInfo>> mtxRootSignatureInfo;
 
        std::string sSourceFileHash;
 
        static inline UINT iShaderFileCodepage = DXC_CP_ACP;
 
        static inline auto sShaderReflectionFileExtension = ".reflection";
 
        static inline const auto sReflectionFileHashKeyName = "reflection_file_hash";
 
        static inline const auto sHlslSectionName = "HLSL";
 
        // -------------------------------------------------------------------------
        // ! if adding new shader models add them to cache config in ShaderManager !
        // -------------------------------------------------------------------------
        static constexpr std::string_view sVertexShaderModel = "vs_6_0";
        static constexpr std::string_view sPixelShaderModel = "ps_6_0";
        static constexpr std::string_view sComputeShaderModel = "cs_6_0";
        // -------------------------------------------------------------------------
        // ! if adding new shader models add them to cache config in ShaderManager !
        // -------------------------------------------------------------------------
    };
} // namespace ne