Transform.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 "Angle.hpp"
#include "Math.hpp"
#include "Matrix.hpp"
#include "Quaternion.hpp"
#include "Vector.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
namespace CeresEngine::inline Math {
 
    template<typename T> struct TFacing {
        TVector3<T> front;
 
        TVector3<T> back;
 
        TVector3<T> up;
 
        TVector3<T> down;
 
        TVector3<T> right;
 
        TVector3<T> left;
    };
 
    template<typename T>
    static inline const constexpr TFacing<T> facingConvention{
        .front = TVector3<T>(0.0, 0.0, -1.0),
        .back = TVector3<T>(0.0, 0.0, 1.0),
        .up = TVector3<T>(0.0, 1.0, 0.0),
        .down = TVector3<T>(0.0, -1.0, 0.0),
        .right = TVector3<T>(1.0, 0.0, 0.0),
        .left = TVector3<T>(-1.0, 0.0, 0.0),
    };
 
    using Facing = TFacing<double>;
 
    using Facingf = TFacing<float>;
 
    template<typename T> struct TTransform {
        TVector3<T> position = TVector3<T>(0.0);
 
        TQuaternion<T> rotation = TQuaternion<T>(TVector3<T>(0.0));
 
        TVector3<T> scale = TVector3<T>(1.0);
 
        explicit constexpr TTransform() noexcept = default;
 
        explicit constexpr TTransform(const TMatrix4<T>& matrix) noexcept {
            TVector3<T> skew;
            TVector4<T> perspective;
            Math::decompose(matrix, scale, rotation, position, skew, perspective);
//            CE_ASSERT(Math::nearZero(skew.x, 1.0e-4));
//            CE_ASSERT(Math::nearZero(skew.y, 1.0e-4));
//            CE_ASSERT(Math::nearZero(skew.z, 1.0e-4));
//            CE_ASSERT(Math::nearZero(perspective.x, 1.0e-4));
//            CE_ASSERT(Math::nearZero(perspective.y, 1.0e-4));
//            CE_ASSERT(Math::nearZero(perspective.z, 1.0e-4));
//            CE_ASSERT(Math::approxEquals(perspective.w, 1.0, 1.0e-4));
        }
 
        constexpr TTransform(const TVector3<T>& position, const TQuaternion<T>& rotation, const TVector3<T>& scale)
                : position(position), rotation(rotation), scale(scale) {}
 
        constexpr TTransform(const TTransform&) noexcept = default;
        constexpr TTransform& operator=(const TTransform&) noexcept = default;
 
        [[nodiscard]] constexpr TMatrix4<T> getMatrix() const noexcept {
//            TMatrix4<T> matrix = identity<TMatrix4<T>>();
 
            const Matrix4 translationMatrix = Math::translate(identity<TMatrix4<T>>(), position);
            const Matrix4 rotationMatrix = TMatrix4<T>(rotation);
            const Matrix4 scaleMatrix = Math::scale(identity<TMatrix4<T>>(), scale);
 
            return translationMatrix * rotationMatrix * scaleMatrix;
//
//            matrix = Math::translate(matrix, position);
//            matrix = matrix * TMatrix4<T>(rotation);
//            matrix = Math::scale(matrix, scale);
//
//            return matrix;
        }
 
        [[nodiscard]] constexpr explicit operator TMatrix4<T>() const noexcept { return getMatrix(); }
 
        [[nodiscard]] constexpr TVector4<T> transform(const TVector4<T>& input) const noexcept { return getMatrix() * input; }
 
        [[nodiscard]] constexpr TVector4<T> operator()(const TVector4<T>& input) const noexcept { return transform(input); }
 
        [[nodiscard]] constexpr TVector3<T> transform(const TVector3<T>& input) const noexcept { return TVector3<T>(transform(TVector4<T>(input, T(1)))); }
 
        [[nodiscard]] constexpr TVector3<T> operator()(const TVector3<T>& input) const noexcept { return transform(input); }
 
    public:
        [[nodiscard]] constexpr TVector3<T> getDirection() const noexcept {
            const TMatrix3<T> rotationMatrix = TMatrix3<T>(transpose(inverse(getMatrix())));
            return normalize(rotationMatrix[2]);
        }
 
        [[nodiscard]] constexpr TFacing<T> getFacing() const noexcept {
            TFacing<T> facing;
            {
                const TMatrix3<T> rotationMatrix = transpose(inverse(TMatrix3<T>(rotation)));
 
                facing.front = rotationMatrix[2];
                facing.back = -facing.front;
 
                facing.up = rotationMatrix[1];
                facing.down = -facing.up;
 
                facing.right = rotationMatrix[0];
                facing.left = -facing.right;
            }
            return facing;
        }
 
        [[nodiscard]] constexpr TVector3<T> getFront() const noexcept {
            const TMatrix3<T> rotationMatrix = transpose(inverse(TMatrix3<T>(rotation)));
            return normalize(rotationMatrix[2]);
        }
 
        [[nodiscard]] constexpr TVector3<T> getBack() const noexcept { return -getFront(); }
 
        [[nodiscard]] constexpr TVector3<T> getUp() const noexcept {
            const TMatrix3<T> rotationMatrix = transpose(inverse(TMatrix3<T>(rotation)));
            return normalize(rotationMatrix[1]);
        }
 
        [[nodiscard]] constexpr TVector3<T> getDown() const noexcept { return -getUp(); }
 
        [[nodiscard]] constexpr TVector3<T> getRight() const noexcept {
            const TMatrix3<T> rotationMatrix = transpose(inverse(TMatrix3<T>(rotation)));
            return normalize(rotationMatrix[0]);
        }
 
        [[nodiscard]] constexpr TVector3<T> getLeft() const noexcept { return -getRight(); }
 
    public:
        [[nodiscard]] constexpr TTransform moving(const TVector3<T>& distance) const noexcept { return TTransform(position + distance, rotation, scale); }
 
        [[nodiscard]] constexpr TTransform moving(const TVector3<T>& direction, T distance) const noexcept { return moving(normalize(direction) * distance); }
 
        [[nodiscard]] constexpr TTransform rotating(const TQuaternion<T>& quaternion) const noexcept {
            return TTransform(position, quaternion * rotation, scale);
        }
 
        [[nodiscard]] constexpr TTransform rotating(const TVector3<T>& axis, const TRadian<T>& angle) const noexcept {
            return rotating(angleAxis(angle.raw, axis));
        }
 
        [[nodiscard]] constexpr TTransform rolling(const TRadian<T>& angle) const noexcept { return rotating(Vector3(0.0, 0.0, 1.0), angle); }
 
        [[nodiscard]] constexpr TTransform yawing(const TRadian<T>& angle) const noexcept { return rotating(Vector3(0.0, 1.0, 0.0), angle); }
 
        [[nodiscard]] constexpr TTransform pitching(const TRadian<T>& angle) const noexcept { return rotating(Vector3(1.0, 0.0, 0.0), angle); }
 
        [[nodiscard]] constexpr TTransform scaling(const TVector3<T>& factor) const noexcept { return TTransform(position, rotation, scale * factor); }
 
        [[nodiscard]] constexpr TTransform scaling(T factor) const noexcept { return scaling(TVector3<T>(factor)); }
 
    public:
        [[nodiscard]] friend TVector3<T> operator*(const TTransform& transform, const TVector3<T>& input) noexcept { return transform(input); }
 
        [[nodiscard]] friend TVector4<T> operator*(const TTransform& transform, const TVector4<T>& input) noexcept { return transform(input); }
 
        [[nodiscard]] friend TTransform operator*(const TTransform& lhs, const TTransform& rhs) noexcept {
            return TTransform(lhs.getMatrix() * rhs.getMatrix());
        }
 
        [[nodiscard]] friend TTransform inverse(const TTransform& transform) noexcept { return TTransform(inverse(transform.getMatrix())); }
 
        [[nodiscard]] friend TTransform transpose(const TTransform& transform) noexcept { return TTransform(transpose(transform.getMatrix())); }
    };
 
    using Transform = TTransform<double>;
 
    using Transformf = TTransform<float>;
 
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::Math::TTransform<T>> {
    using O = CeresEngine::Math::TTransform<T>;
    size_t operator()(const O& transform) const {
        using CeresEngine::hash;
        return hash(transform.position.x, transform.position.y, transform.position.z, transform.rotation.x, transform.rotation.y, transform.rotation.z,
            transform.rotation.w, transform.scale.x, transform.scale.y, transform.scale.z);
    }
};