Offset.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 TOffset2 final {
        CE_SCRIPT_EXPORT()
        T x = 0;
 
        CE_SCRIPT_EXPORT()
        T y = 0;
 
        CE_SCRIPT_EXPORT()
        constexpr TOffset2() noexcept = default;
        constexpr TOffset2(const TOffset2&) noexcept = default;
        constexpr TOffset2& operator=(const TOffset2&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline constexpr TOffset2(T x, T y) noexcept : x{x}, y{y} {}
 
        template<typename TT> explicit inline constexpr TOffset2(TOffset2<TT> other) noexcept : x(static_cast<T>(other.x)), y(static_cast<T>(other.y)) {}
    };
 
    extern template struct CE_SCRIPT_EXPORT(name = "Offset2Float") TOffset2<float>;
    extern template struct CE_SCRIPT_EXPORT(name = "Offset2") TOffset2<double>;
    extern template struct TOffset2<Int8>;
    extern template struct TOffset2<UInt8>;
    extern template struct TOffset2<Int16>;
    extern template struct TOffset2<UInt16>;
    extern template struct TOffset2<Int32>;
    extern template struct TOffset2<UInt32>;
    extern template struct CE_SCRIPT_EXPORT(name = "Offset2Integer") TOffset2<Int64>;
    extern template struct TOffset2<UInt64>;
 
    using Offset2 = TOffset2<double>;
 
    using Offset2f = TOffset2<float>;
 
    template<typename T> struct TOffset3 final {
        CE_SCRIPT_EXPORT()
        T x = 0;
 
        CE_SCRIPT_EXPORT()
        T y = 0;
 
        CE_SCRIPT_EXPORT()
        T z = 0;
 
        CE_SCRIPT_EXPORT()
        constexpr TOffset3() noexcept = default;
        constexpr TOffset3(const TOffset3&) noexcept = default;
        constexpr TOffset3& operator=(const TOffset3&) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        inline constexpr TOffset3(T x, T y, T z) : x{x}, y{y}, z{z} {}
 
        template<typename TT>
        explicit inline constexpr TOffset3(TOffset3<TT> other) noexcept
                : x(static_cast<T>(other.x)), y(static_cast<T>(other.y)), z(static_cast<T>(other.z)) {}
 
        template<typename TT>
        explicit inline constexpr TOffset3(TOffset2<TT> other, T z) noexcept : x(static_cast<T>(other.x)), y(static_cast<T>(other.y)), z(z) {}
    };
 
    extern template struct CE_SCRIPT_EXPORT(name = "Offset3Float") TOffset3<float>;
    extern template struct CE_SCRIPT_EXPORT(name = "Offset3") TOffset3<double>;
    extern template struct TOffset3<Int8>;
    extern template struct TOffset3<UInt8>;
    extern template struct TOffset3<Int16>;
    extern template struct TOffset3<UInt16>;
    extern template struct TOffset3<Int32>;
    extern template struct TOffset3<UInt32>;
    extern template struct CE_SCRIPT_EXPORT(name = "Offset3Integer") TOffset3<Int64>;
    extern template struct TOffset3<UInt64>;
 
    using Offset3 = TOffset3<double>;
 
    using Offset3f = TOffset3<float>;
 
    template<typename T> [[nodiscard]] constexpr TOffset2<T> operator+(const TOffset2<T>& lhs, const TOffset2<T>& rhs) noexcept {
        return TOffset2<T>{lhs.x + rhs.x, lhs.y + rhs.y};
    }
 
    template<typename T> [[nodiscard]] constexpr TOffset2<T> operator-(const TOffset2<T>& lhs, const TOffset2<T>& rhs) noexcept {
        return TOffset2<T>{lhs.x - rhs.x, lhs.y - rhs.y};
    }
 
    template<typename T> [[nodiscard]] constexpr TOffset3<T> operator+(const TOffset3<T>& lhs, const TOffset3<T>& rhs) noexcept {
        return TOffset3<T>{lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z};
    }
 
    template<typename T> [[nodiscard]] constexpr TOffset3<T> operator-(const TOffset3<T>& lhs, const TOffset3<T>& rhs) noexcept {
        return TOffset3<T>{lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z};
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator==(const TOffset2<T>& lhs, const TOffset2<T>& rhs) noexcept {
        return (lhs.x == rhs.x && lhs.y == rhs.y);
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator!=(const TOffset2<T>& lhs, const TOffset2<T>& rhs) noexcept { return !(lhs == rhs); }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator==(const TOffset3<T>& lhs, const TOffset3<T>& rhs) noexcept {
        return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
    }
 
    template<typename T> [[nodiscard]] inline constexpr bool operator!=(const TOffset3<T>& lhs, const TOffset3<T>& rhs) noexcept { return !(lhs == rhs); }
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::Math::TOffset2<T>> {
    using Type = CeresEngine::Math::TOffset2<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.x, obj.y); }
};
 
template<typename T> struct std::hash<CeresEngine::Math::TOffset3<T>> {
    using Type = CeresEngine::Math::TOffset3<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.x, obj.y, obj.z); }
};