Transform.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef CUBBYFLOW_TRANSFORM_HPP
#define CUBBYFLOW_TRANSFORM_HPP

#include <Core/Geometry/BoundingBox.hpp>
#include <Core/Geometry/Ray.hpp>
#include <Core/Math/Quaternion.hpp>
#include <Core/Matrix/Matrix.hpp>

namespace CubbyFlow
{
template <size_t N>
class Orientation
{
    // Do nothing
};

template <>
class Orientation<2>
{
 public:
    Orientation();

    Orientation(double angleInRadian);

    [[nodiscard]] double GetRotation() const;

    void SetRotation(double angleInRadian);

    [[nodiscard]] Vector2D ToLocal(const Vector2D& pointInWorld) const;

    [[nodiscard]] Vector2D ToWorld(const Vector2D& pointInLocal) const;

 private:
    double m_angle = 0.0;
    double m_cosAngle = 1.0;
    double m_sinAngle = 0.0;
};

template <>
class Orientation<3>
{
 public:
    Orientation();

    Orientation(const QuaternionD& quat);

    [[nodiscard]] const QuaternionD& GetRotation() const;

    void SetRotation(const QuaternionD& quat);

    [[nodiscard]] Vector3D ToLocal(const Vector3D& pointInWorld) const;

    [[nodiscard]] Vector3D ToWorld(const Vector3D& pointInLocal) const;

 private:
    QuaternionD m_quat;
    Matrix3x3D m_rotationMat3 = Matrix3x3D::MakeIdentity();
    Matrix3x3D m_inverseRotationMat3 = Matrix3x3D::MakeIdentity();
};

using Orientation2 = Orientation<2>;
using Orientation3 = Orientation<3>;

template <size_t N>
class Transform
{
 public:
    Transform() = default;

    Transform(const Vector<double, N>& translation,
              const Orientation<N>& orientation);

    [[nodiscard]] const Vector<double, N>& GetTranslation() const;

    void SetTranslation(const Vector<double, N>& translation);

    [[nodiscard]] const Orientation<N>& GetOrientation() const;

    void SetOrientation(const Orientation<N>& orientation);

    [[nodiscard]] Vector<double, N> ToLocal(
        const Vector<double, N>& pointInWorld) const;

    [[nodiscard]] Vector<double, N> ToLocalDirection(
        const Vector<double, N>& dirInWorld) const;

    [[nodiscard]] Ray<double, N> ToLocal(
        const Ray<double, N>& rayInWorld) const;

    [[nodiscard]] BoundingBox<double, N> ToLocal(
        const BoundingBox<double, N>& bboxInWorld) const;

    [[nodiscard]] Vector<double, N> ToWorld(
        const Vector<double, N>& pointInLocal) const;

    [[nodiscard]] Vector<double, N> ToWorldDirection(
        const Vector<double, N>& dirInLocal) const;

    [[nodiscard]] Ray<double, N> ToWorld(
        const Ray<double, N>& rayInLocal) const;

    [[nodiscard]] BoundingBox<double, N> ToWorld(
        const BoundingBox<double, N>& bboxInLocal) const;

 private:
    Vector<double, N> m_translation;
    Orientation<N> m_orientation;
};

using Transform2 = Transform<2>;
using Transform3 = Transform<3>;
}  // namespace CubbyFlow

#endif