Extent.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/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <cstdint>
 
namespace CeresEngine::inline Math {
 
    template<typename T> struct TExtent2 final {
        CE_SCRIPT_EXPORT()
        T width = 0;
 
        CE_SCRIPT_EXPORT()
        T height = 0;
 
        CE_SCRIPT_EXPORT()
        TExtent2() noexcept = default;
 
        //        CE_SCRIPT_EXPORT()
        TExtent2(const TExtent2&) noexcept = default;
        constexpr TExtent2& operator=(const TExtent2&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline TExtent2(T width, T height) noexcept : width(width), height(height) {}
 
        template<typename TT>
        explicit inline TExtent2(TExtent2<TT> other) noexcept : width(static_cast<T>(other.width)), height(static_cast<T>(other.height)) {}
    };
 
    extern template struct CE_SCRIPT_EXPORT(name = "Extent2Float") TExtent2<float>;
    extern template struct CE_SCRIPT_EXPORT(name = "Extent2") TExtent2<double>;
    extern template struct TExtent2<Int8>;
    extern template struct TExtent2<UInt8>;
    extern template struct TExtent2<Int16>;
    extern template struct TExtent2<UInt16>;
    extern template struct TExtent2<Int32>;
    extern template struct TExtent2<UInt32>;
    extern template struct CE_SCRIPT_EXPORT(name = "Extent2Integer") TExtent2<Int64>;
    extern template struct TExtent2<UInt64>;
 
    using Extent2 = TExtent2<double>;
 
    using Extent2f = TExtent2<float>;
 
    using Extent2UI = TExtent2<UInt32>;
 
    template<typename T> struct TExtent3 final {
        CE_SCRIPT_EXPORT()
        T width = 0;
 
        CE_SCRIPT_EXPORT()
        T height = 0;
 
        CE_SCRIPT_EXPORT()
        T depth = 0;
 
        CE_SCRIPT_EXPORT()
        TExtent3() noexcept = default;
 
        //        CE_SCRIPT_EXPORT()
        TExtent3(const TExtent3&) noexcept = default;
        constexpr TExtent3& operator=(const TExtent3&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline TExtent3(T width, T height, T depth) noexcept : width(width), height(height), depth(depth) {}
 
        CE_SCRIPT_EXPORT()
        inline TExtent3(const TExtent2<T>& other, T depth = T(1)) noexcept : width(other.width), height(other.height), depth(depth) {}
 
        template<typename TT>
        explicit inline TExtent3(TExtent3<TT> other) noexcept
                : width(static_cast<T>(other.width)), height(static_cast<T>(other.height)), depth(static_cast<T>(other.depth)) {}
 
        template<typename TT>
        explicit inline TExtent3(TExtent2<TT> other, T depth) noexcept requires(!std::is_same_v<T, TT>)
                : width(static_cast<T>(other.width)), height(static_cast<T>(other.height)), depth(depth) {}
    };
 
    extern template struct CE_SCRIPT_EXPORT(name = "Extent3Float") TExtent3<float>;
    extern template struct CE_SCRIPT_EXPORT(name = "Extent3") TExtent3<double>;
    extern template struct TExtent3<Int8>;
    extern template struct TExtent3<UInt8>;
    extern template struct TExtent3<Int16>;
    extern template struct TExtent3<UInt16>;
    extern template struct TExtent3<Int32>;
    extern template struct TExtent3<UInt32>;
    extern template struct CE_SCRIPT_EXPORT(name = "Extent3Integer") TExtent3<Int64>;
    extern template struct TExtent3<UInt64>;
 
    using Extent3 = TExtent3<double>;
 
    using Extent3f = TExtent3<float>;
 
    template<typename T> [[nodiscard]] constexpr TExtent2<T> operator+(const TExtent2<T>& lhs, const TExtent2<T>& rhs) noexcept {
        return TExtent2<T>{lhs.width + rhs.width, lhs.height + rhs.height};
    }
 
    template<typename T> [[nodiscard]] constexpr TExtent2<T> operator-(const TExtent2<T>& lhs, const TExtent2<T>& rhs) noexcept {
        return TExtent2<T>{lhs.width - rhs.width, lhs.height - rhs.height};
    }
 
    template<typename T> [[nodiscard]] constexpr TExtent2<T> operator*(const TExtent2<T>& lhs, T& rhs) noexcept {
        return TExtent2<T>{lhs.width * rhs, lhs.height * rhs};
    }
 
    template<typename T> [[nodiscard]] constexpr TExtent2<T> operator/(const TExtent2<T>& lhs, T& rhs) noexcept {
        return TExtent2<T>{lhs.width / rhs, lhs.height / rhs};
    }
 
    template<typename T> constexpr TExtent2<T>& operator*=(TExtent2<T>& lhs, T rhs) noexcept {
        lhs = lhs * rhs;
        return lhs;
    }
 
    template<typename T> constexpr TExtent2<T>& operator/=(TExtent2<T>& lhs, T rhs) noexcept {
        lhs = lhs / rhs;
        return lhs;
    }
 
    template<typename T> [[nodiscard]] constexpr TExtent3<T> operator+(const TExtent3<T>& lhs, const TExtent3<T>& rhs) noexcept {
        return TExtent3<T>{lhs.width + rhs.width, lhs.height + rhs.height, lhs.depth + rhs.depth};
    }
 
    template<typename T> [[nodiscard]] constexpr TExtent3<T> operator-(const TExtent3<T>& lhs, const TExtent3<T>& rhs) noexcept {
        return TExtent3<T>{lhs.width - rhs.width, lhs.height - rhs.height, lhs.depth - rhs.depth};
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator==(const TExtent2<T>& lhs, const TExtent2<T>& rhs) noexcept {
        return (lhs.width == rhs.width && lhs.height == rhs.height);
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator!=(const TExtent2<T>& lhs, const TExtent2<T>& rhs) noexcept { return !(lhs == rhs); }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator==(const TExtent3<T>& lhs, const TExtent3<T>& rhs) noexcept {
        return (lhs.width == rhs.width && lhs.height == rhs.height && lhs.depth == rhs.depth);
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator!=(const TExtent3<T>& lhs, const TExtent3<T>& rhs) noexcept { return !(lhs == rhs); }
 
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::Math::TExtent2<T>> {
    using Type = CeresEngine::Math::TExtent2<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.width, obj.height); }
};
 
template<typename T> struct std::hash<CeresEngine::Math::TExtent3<T>> {
    using Type = CeresEngine::Math::TExtent3<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.width, obj.height, obj.depth); }
};