ShaderSource.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 "ShaderType.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/StructEnum.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() ShaderSourceType {
        Source,
 
        Binary,
    };
 
    class CE_SCRIPT_EXPORT() ShaderBinary final {
    public:
        using BinaryBuffer = Vector<char>;
 
    public:
        CE_SCRIPT_EXPORT()
        ShaderType type = ShaderType::Undefined;
 
        BinaryBuffer data;
 
    public:
        CE_SCRIPT_EXPORT()
        ShaderBinary() noexcept;
 
        explicit ShaderBinary(ShaderType shaderType, BinaryBuffer binary) noexcept;
 
        ShaderBinary(ShaderType shaderType, const unsigned char* binary, size_t length);
 
        CE_SCRIPT_EXPORT()
        ShaderBinary(const ShaderBinary& other);
 
        ShaderBinary& operator=(const ShaderBinary& other);
 
        ShaderBinary(ShaderBinary&& other) noexcept;
 
        ShaderBinary& operator=(ShaderBinary&& other) noexcept;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool isValid() const noexcept;
 
        explicit operator bool() const noexcept;
 
    public:
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(data);
        }
    };
 
    class CE_SCRIPT_EXPORT() ShaderSource final {
    public:
        CE_SCRIPT_EXPORT()
        ShaderType type = ShaderType::Undefined;
 
        CE_SCRIPT_EXPORT()
        String source;
 
    public:
        CE_SCRIPT_EXPORT()
        explicit ShaderSource(ShaderType type, String source) noexcept;
 
        explicit ShaderSource(ShaderType type, const char* source);
 
        CE_SCRIPT_EXPORT()
        ShaderSource(const ShaderSource& other);
 
        ShaderSource& operator=(const ShaderSource& other);
 
        ShaderSource(ShaderSource&& other) noexcept;
 
        ShaderSource& operator=(ShaderSource&& other) noexcept;
 
    public:
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(source);
        }
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::ShaderType> {
    inline size_t operator()(const CeresEngine::ShaderType object) const noexcept { return CeresEngine::hash(object.raw); }
};