Transform.h

Go to the documentation of this file.

// File: Transform.h
// Description: Component that handles kinematics of the object. Updates its position + rotation every frame
// Author(s): Ori Balashov (ori.balashov@digipen.edu) Base foundation
//            Aidan Hartman (aidan.hartman@digipen.edu) Inherited parent functionality 
//            Marcelo Escamilla(marcelo.escamilla@digipen.edu) JSON serialization, and ImGui implementation
// 2025 / 09 / 17
// (C) Digipen 2025
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
 
#include "Framework/Component.h"
#include "Utility/Math/AffineMatrix.h"
#include "Utility/Math/Vector4D.h"
 
using Point2D = Vector4D;
 
 
// This class' implementation is partly inspired by Doug Schilling's CS 230 Engine
 
class Transform final : public Component
{
public:
    Transform();
    Transform(const Transform&);
    Transform(Transform&&) noexcept;
    auto operator=(const Transform& rhs) -> Transform& = default;
    ~Transform() override                              = default;
 
    auto parentTo(GameObject* newParent) -> bool override;
 
    auto clone() const -> std::unique_ptr<GameObject> override;
    auto componentShowMenu() -> void override;
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override
    {
    }; // for debug ImGUI
    auto onRender() -> void override;
    auto load(const Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;
 
    auto move(float x, float y) -> void;
    auto move(const Vector4D& vec) -> void;
    
    auto setX(float x) -> void;
    auto setY(float y) -> void;

    auto scale() const -> const Vector4D&;
    auto scale(const Vector4D& scale) -> void;

    auto worldScale() -> Vector4D;
    auto worldScale(const Vector4D& scale) -> void;

    auto translation() const -> const Point2D&;
    auto translation(const Vector4D& translation) -> void;
    auto worldTranslation() -> Point2D;
    auto worldTranslation(const Point2D& translation) -> void;

    auto rotation() const -> float;
    auto rotation(float rotation) -> void;
    auto worldRotation() -> float;
    auto worldRotation(float rotation) -> void;

    auto matrix() -> AffineMatrix&;
 
 
    auto setMatrix(AffineMatrix& newMat) -> void;
    auto makeMat3Rotation(float rotation) -> Eigen::Matrix3f;
 
    auto setRotationViaMatrix(AffineMatrix& newMat) -> void;
 
    friend auto to_json(json& j, const Transform& p) -> void;
    friend auto from_json(const json& j, Transform& p) -> void;
 
private:
    Vector4D _scale;
    float _rotation;
    Point2D _translation;
 
 
    // The isDirty & AffineMatrix idea is directly taken from Doug Schilling's 230 Engine
 
    // True if the transformation matrix needs to be recalculated.
    bool isDirty;
 
    // The transformation matrix resulting from concatenating the matrices
    // Formed by scale*rotation*translation matrices
    AffineMatrix _matrix;
    AffineMatrix _absoluteMatrix;

    auto recalculateMatrix() -> void;
    auto internalMatrix() -> const AffineMatrix&;

    auto getParentTransform() const -> Transform*;

    auto calculateAbsoluteMatrix() -> bool;

    auto getWorldRotationAndScale() -> Eigen::Matrix3f;

    auto setGlobalRotationAndScale(const Eigen::Matrix3f&) -> void;
 
};