Transform.hpp

Go to the documentation of this file.

// Copyright (c) 2023 Sapphire Development Team. All Rights Reserved.
 
#pragma once
 
#ifndef SAPPHIRE_MATHS_TRANSFORM_GUARD
#define SAPPHIRE_MATHS_TRANSFORM_GUARD
 
#include <SA/Maths/Debug.hpp>
 
#include <SA/Maths/Transform/Functors/TransformTRSMatrixFunctor.hpp>
#include <SA/Maths/Transform/Functors/TransformRotateAxisFunctor.hpp>
 
namespace SA
{
    template <typename T, template <typename> typename... Args>
    struct Tr : public Args<T>...
    {
        using Type = T;
 
 
        template <template <typename> typename Comp>
        static constexpr bool HasComponent() noexcept;
 
 
    //{ Equals
 
        bool IsZero() const noexcept;
 
        bool IsIdentity() const noexcept;
 
        bool Equals(const Tr& _other, T _epsilon = std::numeric_limits<T>::epsilon()) const noexcept;
 
 
        bool operator==(const Tr& _rhs) const noexcept;
 
        bool operator!=(const Tr& _rhs) const noexcept;
 
    //}
 
 
    //{ Transformation
 
        template <typename TrFunc = TrRotateAxisFunctor>
        Vec3<T> Right(TrFunc _functor = TrFunc()) const;
 
        template <typename TrFunc = TrRotateAxisFunctor>
        Vec3<T> Up(TrFunc _functor = TrFunc()) const;
 
        template <typename TrFunc = TrRotateAxisFunctor>
        Vec3<T> Forward(TrFunc _functor = TrFunc()) const;
 
 
        template <typename TrFunc = TrTRSMatrixFunctor>
        Mat4<T> Matrix(TrFunc _functor = TrFunc()) const noexcept;
 
    //}
 
 
    //{ Lerp
 
        static Tr Lerp(const Tr& _start, const Tr& _end, float _alpha) noexcept;
 
        static Tr LerpUnclamped(const Tr& _start, const Tr& _end, float _alpha) noexcept;
 
    //}
 
 
    //{ Operators
 
        template <template <typename> typename... InArgs>
        Tr operator*(const Tr<T, InArgs...>& _rhs) const;
 
        template <template <typename> typename... InArgs>
        Tr operator/(const Tr<T, InArgs...>& _rhs) const;
 
        template <template <typename> typename... InArgs>
        Tr& operator*=(const Tr<T, InArgs...>& _rhs);
 
        template <template <typename> typename... InArgs>
        Tr& operator/=(const Tr<T, InArgs...>& _rhs);
 
    //}
 
 
    //{ Cast
 
        template <typename TOut, template <typename> typename... ArgsOut>
        operator Tr<TOut, ArgsOut...>() const noexcept;
 
    //}
 
    private:
 
    //{ Packed
 
        template <typename CurrT, typename... PArgs>
        bool IsZeroPacked() const noexcept;
 
        template <typename CurrT, typename... PArgs>
        bool IsIdentityPacked() const noexcept;
 
        template <typename CurrT, typename... PArgs>
        bool EqualsPacked(const Tr& _other, T _epsilon) const noexcept;
 
 
        template <typename CurrT, typename... PArgs>
        void LerpUnclampedPacked(const Tr& _start, const Tr& _end, float _alpha) noexcept;
 
 
        template <typename TrIn, typename CurrT, typename... PArgs>
        void MultiplyPacked(const Tr& _lhs, const TrIn& _rhs) noexcept;
 
        template <typename TrIn, typename CurrT, typename... PArgs>
        void DividePacked(const Tr& _lhs, const TrIn& _rhs) noexcept;
 
    //}
 
 
    #if SA_LOGGER_IMPL
 
        template <typename CurrT, typename... PArgs>
        std::string ToStringPacked() const noexcept;
 
    public:
 
        std::string ToString() const noexcept;
 
    #endif
    };
 
 
#if SA_LOGGER_IMPL
 
    template <typename T, template <typename> typename... Args>
    std::string ToString(const Tr<T, Args...>& _tr) { return _tr.ToString(); }
 
#endif
 
 
//{ Aliases
 
//{ Tr aliases
 
    template <typename T>
    using TrP = Tr<T, TrPosition>;
 
    template <typename T>
    using TrR = Tr<T, TrRotation>;
 
    template <typename T>
    using TrS = Tr<T, TrScale>;
 
    template <typename T>
    using TrUS = Tr<T, TrUScale>;
 
    template <typename T>
    using TrPR = Tr<T, TrPosition, TrRotation>;
 
    template <typename T>
    using TrPRS = Tr<T, TrPosition, TrRotation, TrScale>;
 
    template <typename T>
    using TrPRUS = Tr<T, TrPosition, TrRotation, TrUScale>;
 
//{ Float
 
    using TrPf = Tr<float, TrPosition>;
 
    using TrRf = Tr<float, TrRotation>;
 
    using TrSf = Tr<float, TrScale>;
 
    using TrUSf = Tr<float, TrUScale>;
 
    using TrPRf = Tr<float, TrPosition, TrRotation>;
 
    using TrPRSf = Tr<float, TrPosition, TrRotation, TrScale>;
 
    using TrPRUSf = Tr<float, TrPosition, TrRotation, TrUScale>;
 
//}
 
 
//{ Double
 
    using TrPd = Tr<double, TrPosition>;
 
    using TrRd = Tr<double, TrRotation>;
 
    using TrSd = Tr<double, TrScale>;
 
    using TrUSd = Tr<double, TrUScale>;
 
    using TrPRd = Tr<double, TrPosition, TrRotation>;
 
    using TrPRSd = Tr<double, TrPosition, TrRotation, TrScale>;
 
    using TrPRUSd = Tr<double, TrPosition, TrRotation, TrUScale>;
 
//}
 
//}
 
 
//{ Transform aliases
 
    template <typename T, template <typename> typename... Args>
    using Transform = Tr<T, Args...>;
 
    template <typename T>
    using TransformP = Transform<T, TrPosition>;
 
    template <typename T>
    using TransformR = Transform<T, TrRotation>;
 
    template <typename T>
    using TransformS = Transform<T, TrScale>;
 
    template <typename T>
    using TransformUS = Transform<T, TrUScale>;
 
    template <typename T>
    using TransformPR = Transform<T, TrPosition, TrRotation>;
 
    template <typename T>
    using TransformPRS = Transform<T, TrPosition, TrRotation, TrScale>;
 
    template <typename T>
    using TransformPRUS = Transform<T, TrPosition, TrRotation, TrUScale>;
 
//{ Float
 
    using TransformPf = Transform<float, TrPosition>;
 
    using TransformRf = Transform<float, TrRotation>;
 
    using TransformSf = Transform<float, TrScale>;
 
    using TransformUSf = Transform<float, TrUScale>;
 
    using TransformPRf = Transform<float, TrPosition, TrRotation>;
 
    using TransformPRSf = Transform<float, TrPosition, TrRotation, TrScale>;
 
    using TransformPRUSf = Transform<float, TrPosition, TrRotation, TrUScale>;
 
//}
 
 
//{ Double
 
    using TransformPd = Transform<double, TrPosition>;
 
    using TransformRd = Transform<double, TrRotation>;
 
    using TransformSd = Transform<double, TrScale>;
 
    using TransformUSd = Transform<double, TrUScale>;
 
    using TransformPRd = Transform<double, TrPosition, TrRotation>;
 
    using TransformPRSd = Transform<double, TrPosition, TrRotation, TrScale>;
 
    using TransformPRUSd = Transform<double, TrPosition, TrRotation, TrUScale>;
 
//}
 
//}
 
//}
 
}
 
#include <SA/Maths/Transform/Transform.inl>
 
#endif // GUARD