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