Shader.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 "Forward.hpp"
 
#include "ShaderSource.hpp"
#include "ShaderType.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/URI.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/SmallFlatMap.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
 
#include "CeresEngine/Mesh/VertexLayout.hpp"
#include "CeresEngine/Resource/Resource.hpp"
 
namespace CeresEngine {
 
    class ShaderSpecializationConstant : private Variant<String, Int64, bool> {
    private:
        template<typename U> friend struct std::hash;
        using super = Variant<String, Int64, bool>;
 
    public:
        ShaderSpecializationConstant() : super(Int64(0)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(String string) : super(std::move(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const StringView string) : super(String(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const bool string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const UInt8 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const UInt16 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const UInt32 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const Int8 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const Int16 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const Int32 string) : super(Int64(string)) {}
 
        CE_EXPLICIT(false) ShaderSpecializationConstant(const Int64 string) : super(Int64(string)) {}
 
        ShaderSpecializationConstant(const ShaderSpecializationConstant&) = default;
        ShaderSpecializationConstant& operator=(const ShaderSpecializationConstant&) = default;
 
        ShaderSpecializationConstant(ShaderSpecializationConstant&&) = default;
        ShaderSpecializationConstant& operator=(ShaderSpecializationConstant&&) = default;
 
    public:
        template<typename T> [[nodiscard]] bool is() const noexcept;
 
        template<> [[nodiscard]] bool is<String>() const noexcept { return super::is<String>(); }
 
        template<> [[nodiscard]] bool is<StringView>() const noexcept { return super::is<String>(); }
 
        template<> [[nodiscard]] bool is<bool>() const noexcept { return super::is<bool>(); }
 
        template<> [[nodiscard]] bool is<UInt8>() const noexcept { return isConvertibleAs<UInt8>(); }
 
        template<> [[nodiscard]] bool is<UInt16>() const noexcept { return isConvertibleAs<UInt16>(); }
 
        template<> [[nodiscard]] bool is<UInt32>() const noexcept { return isConvertibleAs<UInt32>(); }
 
        template<> [[nodiscard]] bool is<Int8>() const noexcept { return isConvertibleAs<Int8>(); }
 
        template<> [[nodiscard]] bool is<Int16>() const noexcept { return isConvertibleAs<Int16>(); }
 
        template<> [[nodiscard]] bool is<Int32>() const noexcept { return isConvertibleAs<Int32>(); }
 
        template<> [[nodiscard]] bool is<Int64>() const noexcept { return isConvertibleAs<Int64>(); }
 
        template<typename T> decltype(auto) as() const;
 
        template<> [[nodiscard]] decltype(auto) as<String>() const { return super::as<String>(); }
 
        template<> [[nodiscard]] decltype(auto) as<StringView>() const { return StringView(super::as<String>()); }
 
        template<> [[nodiscard]] decltype(auto) as<bool>() const { return super::as<bool>(); }
 
        template<> [[nodiscard]] decltype(auto) as<UInt8>() const { return convertAs<UInt8>(); }
 
        template<> [[nodiscard]] decltype(auto) as<UInt16>() const { return convertAs<UInt16>(); }
 
        template<> [[nodiscard]] decltype(auto) as<UInt32>() const { return convertAs<UInt32>(); }
 
        template<> [[nodiscard]] decltype(auto) as<Int8>() const { return convertAs<Int8>(); }
 
        template<> [[nodiscard]] decltype(auto) as<Int16>() const { return convertAs<Int16>(); }
 
        template<> [[nodiscard]] decltype(auto) as<Int32>() const { return convertAs<Int32>(); }
 
        template<> [[nodiscard]] decltype(auto) as<Int64>() const { return convertAs<Int64>(); }
 
        using super::visit;
 
    private:
        template<typename T> [[nodiscard]] bool isConvertibleAs() const noexcept {
            if(!super::is<Int64>()) {
                return false;
            }
 
            const Int64 value = super::as<Int64>();
            return value >= std::numeric_limits<T>::min() && value <= std::numeric_limits<T>::max();
        }
 
        template<typename T> [[nodiscard]] T convertAs() const noexcept {
            const Int64 value = super::as<Int64>();
            CE_ASSERT(value >= std::numeric_limits<T>::min() && value <= std::numeric_limits<T>::max());
            return T(value);
        }
    };
 
    using ShaderSpecializationConstants = SmallUnorderedFlatMap<String, ShaderSpecializationConstant, 5>;
 
    enum class ShadingLanguage {
        CESL,
 
        HLSL,
 
        GLSL,
 
        SPIRV,
    };
 
    class Shader : public TResource<Shader> {
        CE_META_CLASS_FRIEND(Shader);
 
    protected:
        ShaderStages mStages;
 
        ShaderSource mSource = ShaderSource(ShaderType::Undefined, "");
 
    public:
        explicit Shader() = default;
        explicit Shader(const ShaderSource& source, const ShaderStages& stage);
        ~Shader() noexcept override = default;
 
    public:
        [[nodiscard]] const ShaderSource& getSource() const noexcept { return mSource; }
 
        void setSource(const ShaderSource& source);
 
        [[nodiscard]] virtual ShadingLanguage getShadingLanguage() const noexcept = 0;
 
        [[nodiscard]] virtual Optional<ShaderBinary> compile(ShaderType type, const ShaderSpecializationConstants& specializationConstants = {}) const = 0;
 
        [[nodiscard]] Async<Optional<ShaderBinary>> compileAsync(ShaderType type, ShaderSpecializationConstants specializationConstants = {});
 
        [[nodiscard]] String getSourceName() const;
 
    protected:
        [[nodiscard]] ShaderSource preProcessShader(const ShaderSource& sourceCode, const ShaderSpecializationConstants& specializationConstants,
            const URI& includeSearchPath) const;
 
        [[nodiscard]] Optional<ShaderBinary> compileShaderInternal(const ShaderSource& sourceCode, ShadingLanguage language, const URI& includeSearchPath) const;
    };
 
    class CESLShader final : public TResource<CESLShader, Shader> {
        using super = TResource<CESLShader, Shader>;
 
    public:
        using super::super;
 
    public:
        [[nodiscard]] ShadingLanguage getShadingLanguage() const noexcept final { return ShadingLanguage::CESL; }
 
        [[nodiscard]] Optional<ShaderBinary> compile(ShaderType type, const ShaderSpecializationConstants& specializationConstants = {}) const final;
    };
 
    class HLSLShader final : public TResource<HLSLShader, Shader> {
        using super = TResource<HLSLShader, Shader>;
 
    public:
        using super::super;
 
    public:
        [[nodiscard]] ShadingLanguage getShadingLanguage() const noexcept final { return ShadingLanguage::HLSL; }
 
        [[nodiscard]] Optional<ShaderBinary> compile(ShaderType type, const ShaderSpecializationConstants& specializationConstants = {}) const final;
    };
 
    class GLSLShader final : public TResource<GLSLShader, Shader> {
        using super = TResource<GLSLShader, Shader>;
 
    public:
        using super::super;
 
    public:
        [[nodiscard]] ShadingLanguage getShadingLanguage() const noexcept final { return ShadingLanguage::GLSL; }
 
        [[nodiscard]] Optional<ShaderBinary> compile(ShaderType type, const ShaderSpecializationConstants& specializationConstants = {}) const final;
    };
 
    class SPIRVShader final : public TResource<SPIRVShader, Shader> {
        using super = TResource<SPIRVShader, Shader>;
 
    public:
        using super::super;
 
    public:
        [[nodiscard]] ShadingLanguage getShadingLanguage() const noexcept final { return ShadingLanguage::SPIRV; }
 
        [[nodiscard]] Optional<ShaderBinary> compile(ShaderType type, const ShaderSpecializationConstants& specializationConstants = {}) const final;
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::ShaderSpecializationConstant> {
    using Type = CeresEngine::ShaderSpecializationConstant;
    inline size_t operator()(const Type& object) const noexcept { return CeresEngine::hash(static_cast<const Type::super&>(object)); }
};