MaterialModel.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 "CeresEngine/Texture/Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include "CeresEngine/Math/Color.hpp"
#include "CeresEngine/Math/Math.hpp"
#include "CeresEngine/Math/Matrix.hpp"
#include "CeresEngine/Math/Vector.hpp"
#include "CeresEngine/RenderAPI/GPUSampler.hpp"
#include "CeresEngine/Resource/ResourceHandle.hpp"
 
#include <utility>
 
namespace CeresEngine {
 
    template<typename ValueType> struct MaterialPropertySwizzle final {
        using RawType = TVector4<ValueType>;
 
        RawType raw = {ValueType(1), ValueType(0), ValueType(0), ValueType(0)};
 
        constexpr MaterialPropertySwizzle() = default;
 
        CE_EXPLICIT(false) constexpr MaterialPropertySwizzle(RawType swizzle) : raw(swizzle) {} // NOLINT
 
        CE_EXPLICIT(false) constexpr MaterialPropertySwizzle(ValueType r, ValueType g, ValueType b, ValueType a) : raw(r, g, b, a) {}
 
        explicit operator RawType() const noexcept { return raw; }
    };
 
    template<glm::length_t D, typename ValueType> struct MaterialPropertySwizzle<TVector<D, ValueType>> final {
        using RawType = TMatrix<D, 4, ValueType>;
 
        RawType raw = identity<RawType>();
 
        constexpr MaterialPropertySwizzle() = default;
 
        CE_EXPLICIT(false) constexpr MaterialPropertySwizzle(RawType swizzle) : raw(swizzle) {} // NOLINT
 
        template<glm::length_t L = D> requires(L == 2)
        constexpr MaterialPropertySwizzle(TVector4<ValueType> x, TVector4<ValueType> y) : raw(x, y) {}
 
        template<glm::length_t L = D> requires(L == 3)
        constexpr MaterialPropertySwizzle(TVector4<ValueType> x, TVector4<ValueType> y, TVector4<ValueType> z) : raw(x, y, z) {}
 
        template<glm::length_t L = D> requires(L == 4)
        constexpr MaterialPropertySwizzle(TVector4<ValueType> x, TVector4<ValueType> y, TVector4<ValueType> z, TVector4<ValueType> w) : raw(x, y, z, w) {}
 
        explicit operator RawType() const noexcept { return raw; }
    };
 
    template<typename ValueType> struct MaterialPropertySwizzle<TColor<ValueType>> final {
        using RawType = TMatrix<4, 4, ValueType>;
 
        RawType raw = identity<RawType>();
 
        constexpr MaterialPropertySwizzle() = default;
 
        CE_EXPLICIT(false) constexpr MaterialPropertySwizzle(RawType swizzle) : raw(swizzle) {} // NOLINT
 
        constexpr MaterialPropertySwizzle(TVector4<ValueType> r, TVector4<ValueType> g, TVector4<ValueType> b, TVector4<ValueType> a) : raw(r, g, b, a) {}
 
        explicit operator RawType() const noexcept { return raw; }
    };
 
    template<typename ValueType>
    inline constexpr bool operator==(const MaterialPropertySwizzle<ValueType>& lhs, const MaterialPropertySwizzle<ValueType>& rhs) noexcept {
        return rhs.raw == lhs.raw;
    }
 
    template<typename ValueType>
    inline constexpr bool operator!=(const MaterialPropertySwizzle<ValueType>& lhs, const MaterialPropertySwizzle<ValueType>& rhs) noexcept {
        return rhs.raw != lhs.raw;
    }
 
    using FloatMaterialPropertySwizzle = MaterialPropertySwizzle<float>;
 
    using DoubleMaterialPropertySwizzle = MaterialPropertySwizzle<double>;
 
    using Vector2MaterialPropertySwizzle = MaterialPropertySwizzle<Vector2>;
 
    using Vector3MaterialPropertySwizzle = MaterialPropertySwizzle<Vector3>;
 
    using Vector4MaterialPropertySwizzle = MaterialPropertySwizzle<Vector4>;
 
    using ColorMaterialPropertySwizzle = MaterialPropertySwizzle<Color>;
 
    extern template struct MaterialPropertySwizzle<float>;
    extern template struct MaterialPropertySwizzle<double>;
    extern template struct MaterialPropertySwizzle<Vector2>;
    extern template struct MaterialPropertySwizzle<Vector3>;
    extern template struct MaterialPropertySwizzle<Vector4>;
    extern template struct MaterialPropertySwizzle<Color>;
 
    template<typename ValueType, typename TextureType = HTexture> struct MaterialProperty {
        ValueType value = ValueType(0);
 
        TextureType texture = nullptr;
 
        GPUSamplerDescriptor sampler{
            .minFilter = GPUSamplerFilter::Linear,
            .magFilter = GPUSamplerFilter::Linear,
            .mipMapFilter = GPUSamplerFilter::Linear,
            .mipMapping = true,
        };
 
        MaterialPropertySwizzle<ValueType> swizzle = {};
 
        MaterialProperty() = default;
 
        CE_EXPLICIT(false) MaterialProperty(ValueType value) : value(value) {} // NOLINT
 
        CE_EXPLICIT(false) MaterialProperty(TextureType texture, MaterialPropertySwizzle<ValueType> swizzle = {}) // NOLINT
                : texture(texture), swizzle(swizzle) {}
 
        explicit MaterialProperty(ValueType value, TextureType texture, MaterialPropertySwizzle<ValueType> swizzle = {})
                : value(value), texture(texture), swizzle(swizzle) {}
 
        MaterialProperty(const MaterialProperty&) = default;
        MaterialProperty& operator=(const MaterialProperty&) = default;
 
        MaterialProperty(MaterialProperty&&) noexcept = default;
        MaterialProperty& operator=(MaterialProperty&&) noexcept = default;
    };
 
    template<typename ValueType, typename TextureType>
    inline constexpr bool operator==(const MaterialProperty<ValueType, TextureType>& lhs, const MaterialProperty<ValueType, TextureType>& rhs) noexcept {
        return lhs.value == rhs.value && lhs.texture == rhs.texture && lhs.sampler == rhs.sampler && lhs.value == rhs.value;
    }
 
    template<typename ValueType, typename TextureType>
    inline constexpr bool operator!=(const MaterialProperty<ValueType, TextureType>& lhs, const MaterialProperty<ValueType, TextureType>& rhs) noexcept {
        return !(lhs == rhs);
    }
 
    using FloatMaterialProperty = MaterialProperty<float>;
 
    using DoubleMaterialProperty = MaterialProperty<double>;
 
    using Vector2MaterialProperty = MaterialProperty<Vector2>;
 
    using Vector3MaterialProperty = MaterialProperty<Vector3>;
 
    using Vector4MaterialProperty = MaterialProperty<Vector4>;
 
    using ColorMaterialProperty = MaterialProperty<Color>;
 
    extern template struct MaterialProperty<float>;
    extern template struct MaterialProperty<double>;
    extern template struct MaterialProperty<Vector2>;
    extern template struct MaterialProperty<Vector3>;
    extern template struct MaterialProperty<Vector4>;
    extern template struct MaterialProperty<Color>;
 
    // ---------------------------------------------------------------------------------------------
 
    enum class MaterialNormalMapSpace {
        Tangent,
 
        Object,
 
        World,
    };
 
    struct PBRMaterialModel final {
        ColorMaterialProperty baseColor = Color::zero;
 
        DoubleMaterialProperty roughness = 1.0;
 
        DoubleMaterialProperty metallic = 0.0;
 
        Vector3MaterialProperty normal = Vector3(0, 0, 0);
 
        ColorMaterialProperty emission = Color::zero;
 
        Vector3MaterialProperty displacement = Vector3(0.0);
 
        DoubleMaterialProperty ambientOcclusion = 1.0;
 
        MaterialNormalMapSpace normalMapSpace = MaterialNormalMapSpace::Tangent;
    };
 
    inline constexpr bool operator==(const PBRMaterialModel& lhs, const PBRMaterialModel& rhs) noexcept {
        return lhs.baseColor == rhs.baseColor && lhs.roughness == rhs.roughness && lhs.metallic == rhs.metallic && lhs.normal == rhs.normal &&
            lhs.emission == rhs.emission && lhs.displacement == rhs.displacement && lhs.ambientOcclusion == rhs.ambientOcclusion;
    }
 
    inline constexpr bool operator!=(const PBRMaterialModel& lhs, const PBRMaterialModel& rhs) noexcept { return !(lhs == rhs); }
 
} // namespace CeresEngine
 
template<typename ValueType> struct std::hash<CeresEngine::MaterialPropertySwizzle<ValueType>> {
    using Type = CeresEngine::MaterialPropertySwizzle<ValueType>;
    size_t operator()(const Type& swizzle) const {
        using namespace CeresEngine;
        return CeresEngine::hash(swizzle.raw);
    }
};
 
template<typename ValueType, typename TextureType> struct std::hash<CeresEngine::MaterialProperty<ValueType, TextureType>> {
    using Type = CeresEngine::MaterialProperty<ValueType, TextureType>;
    size_t operator()(const Type& property) const {
        using namespace CeresEngine;
        return CeresEngine::hash(property.value, property.texture, property.sampler, property.swizzle);
    }
};
 
template<> struct std::hash<CeresEngine::PBRMaterialModel> {
    size_t operator()(const CeresEngine::PBRMaterialModel& model) const {
        using namespace CeresEngine;
        return CeresEngine::hash(model.baseColor, model.roughness, model.metallic, model.normal, model.emission, model.displacement, model.ambientOcclusion);
    }
};