Transform.h

#pragma once
 
#include "Engine/Core/Types.h"
#include <Eigen/Geometry>
#include <numbers>
 
namespace enzo::attr {
class Attribute;
}
 
namespace enzo {
 
class Transform
{
  public:
    using Affine = Eigen::Transform<floatT, 3, Eigen::Affine>;
 
    Transform() : xform_(Affine::Identity()) {}
 
    explicit Transform(const Matrix4& matrix) : xform_(matrix) {}
 
    // Factories
 
    static Transform fromAttribute(const attr::Attribute& attribute, Offset offset);
 
    static Transform lookAt(const Vector3& translation, const Vector3& forward, const Vector3& up);
 
    // Builders compose in the current local frame, so the first call is applied
    // to a point first and later calls wrap it.
 
    Transform& translate(const Vector3& offset)
    {
        xform_.translate(offset);
        return *this;
    }
 
    Transform& rotateEuler(const Vector3& degrees)
    {
        const Vector3 radians = degrees * (std::numbers::pi / 180.0);
        xform_.rotate(
            Eigen::AngleAxis<floatT>(radians.z(), Vector3::UnitZ()) *
            Eigen::AngleAxis<floatT>(radians.y(), Vector3::UnitY()) *
            Eigen::AngleAxis<floatT>(radians.x(), Vector3::UnitX())
        );
        return *this;
    }
 
    Transform& scale(const Vector3& factors)
    {
        xform_.scale(factors);
        return *this;
    }
 
    Transform& scale(floatT uniform)
    {
        xform_.scale(uniform);
        return *this;
    }
 
    Transform& compose(const Transform& other)
    {
        xform_ = xform_ * other.xform_;
        return *this;
    }
 
    Vector3 operator*(const Vector3& point) const { return xform_ * point; }
 
    const Matrix4& getMatrix() const { return xform_.matrix(); }
 
  private:
    Affine xform_;
};
 
} // namespace enzo