BLI_math_euler_types.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <ostream>
 
#include "BLI_math_angle_types.hh"
#include "BLI_math_base.hh"
#include "BLI_math_basis_types.hh"
#include "BLI_struct_equality_utils.hh"
 
namespace blender::math {
 
/* WARNING: must match the #eRotationModes in `DNA_action_types.h`
 * order matters - types are saved to file. */
enum EulerOrder {
  XYZ = 1,
  XZY,
  YXZ,
  YZX,
  ZXY,
  ZYX,
};
 
std::ostream &operator<<(std::ostream &stream, EulerOrder order);
 
/* -------------------------------------------------------------------- */
template<typename T> struct EulerBase {
  using AngleT = AngleRadianBase<T>;
 
 protected:
  VecBase<AngleT, 3> xyz_;
 
  EulerBase() = default;
 
  EulerBase(const AngleT &x, const AngleT &y, const AngleT &z) : xyz_(x, y, z){};
 
  EulerBase(const VecBase<AngleT, 3> &vec) : xyz_(vec){};
 
  EulerBase(const VecBase<T, 3> &vec) : xyz_(vec.x, vec.y, vec.z){};
 
 public:
  explicit operator VecBase<AngleT, 3>() const
  {
    return this->xyz_;
  }
 
  explicit operator VecBase<T, 3>() const
  {
    return {T(x()), T(y()), T(z())};
  }
 
  VecBase<AngleT, 3> &xyz()
  {
    return this->xyz_;
  }
  const VecBase<AngleT, 3> &xyz() const
  {
    return this->xyz_;
  }
 
  const AngleT &x() const
  {
    return this->xyz_.x;
  }
 
  const AngleT &y() const
  {
    return this->xyz_.y;
  }
 
  const AngleT &z() const
  {
    return this->xyz_.z;
  }
 
  AngleT &x()
  {
    return this->xyz_.x;
  }
 
  AngleT &y()
  {
    return this->xyz_.y;
  }
 
  AngleT &z()
  {
    return this->xyz_.z;
  }
};
 
/* -------------------------------------------------------------------- */
template<typename T> struct EulerXYZBase : public EulerBase<T> {
  using AngleT = AngleRadianBase<T>;
 
 public:
  EulerXYZBase() = default;
 
  template<typename AngleU> EulerXYZBase(const VecBase<AngleU, 3> &vec) : EulerBase<T>(vec){};
 
  EulerXYZBase(const AngleT &x, const AngleT &y, const AngleT &z) : EulerBase<T>(x, y, z){};
 
  EulerXYZBase(const Axis axis, const AngleT &angle)
  {
    *this = identity();
    this->xyz_[axis] = angle;
  }
 
  static EulerXYZBase identity()
  {
    return {AngleRadianBase<T>::identity(),
            AngleRadianBase<T>::identity(),
            AngleRadianBase<T>::identity()};
  }
 
  EulerXYZBase wrapped() const;
 
  EulerXYZBase wrapped_around(const EulerXYZBase &reference) const;
 
  friend EulerXYZBase operator-(const EulerXYZBase &a)
  {
    return {-a.xyz_.x, -a.xyz_.y, -a.xyz_.z};
  }
 
  BLI_STRUCT_EQUALITY_OPERATORS_1(EulerXYZBase, xyz_)
 
  friend std::ostream &operator<<(std::ostream &stream, const EulerXYZBase &rot)
  {
    return stream << "EulerXYZ" << static_cast<VecBase<T, 3>>(rot);
  }
};
 
/* -------------------------------------------------------------------- */
template<typename T> struct Euler3Base : public EulerBase<T> {
  using AngleT = AngleRadianBase<T>;
 
 private:
  EulerOrder order_;
 
  class Swizzle {
   private:
    Euler3Base &eul_;
 
   public:
    explicit Swizzle(Euler3Base &eul) : eul_(eul){};
 
    Euler3Base &operator=(const VecBase<AngleT, 3> &angles)
    {
      eul_.xyz_.x = angles[eul_.i_index()];
      eul_.xyz_.y = angles[eul_.j_index()];
      eul_.xyz_.z = angles[eul_.k_index()];
      return eul_;
    }
 
    operator VecBase<AngleT, 3>() const
    {
      return {eul_.i(), eul_.j(), eul_.k()};
    }
 
    explicit operator VecBase<T, 3>() const
    {
      return {T(eul_.i()), T(eul_.j()), T(eul_.k())};
    }
  };
 
 public:
  Euler3Base() = delete;
 
  template<typename AngleU>
  Euler3Base(const VecBase<AngleU, 3> &angles_xyz, EulerOrder order)
      : EulerBase<T>(angles_xyz), order_(order){};
 
  Euler3Base(const AngleT &x, const AngleT &y, const AngleT &z, EulerOrder order)
      : EulerBase<T>(x, y, z), order_(order){};
 
  Euler3Base(const Axis axis, AngleT angle, EulerOrder order) : EulerBase<T>(), order_(order)
  {
    this->xyz_[axis] = angle;
  }
 
  Euler3Base(EulerOrder order) : order_(order){};
 
  const EulerOrder &order() const
  {
    return order_;
  }
 
  Swizzle ijk()
  {
    return Swizzle{*this};
  }
  const VecBase<AngleT, 3> ijk() const
  {
    return {i(), j(), k()};
  }
 
  const AngleT &i() const
  {
    return this->xyz_[i_index()];
  }
  const AngleT &j() const
  {
    return this->xyz_[j_index()];
  }
  const AngleT &k() const
  {
    return this->xyz_[k_index()];
  }
  AngleT &i()
  {
    return this->xyz_[i_index()];
  }
  AngleT &j()
  {
    return this->xyz_[j_index()];
  }
  AngleT &k()
  {
    return this->xyz_[k_index()];
  }
 
  Euler3Base wrapped_around(const Euler3Base &reference) const
  {
    return {VecBase<AngleT, 3>(EulerXYZBase<T>(this->xyz_).wrapped_around(reference.xyz_)),
            order_};
  }
 
  friend Euler3Base operator-(const Euler3Base &a)
  {
    return {-a.xyz_, a.order_};
  }
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(Euler3Base, xyz_, order_)
 
  friend std::ostream &operator<<(std::ostream &stream, const Euler3Base &rot)
  {
    return stream << "Euler3_" << rot.order_ << rot.xyz_;
  }
 
  /* Utilities for conversions and functions operating on Euler3.
   * This should be private in theory. */
 
  bool parity() const
  {
    switch (order_) {
      default:
        BLI_assert_unreachable();
        return false;
      case XYZ:
      case ZXY:
      case YZX:
        return false;
      case XZY:
      case YXZ:
      case ZYX:
        return true;
    }
  }
 
  int i_index() const
  {
    switch (order_) {
      default:
        BLI_assert_unreachable();
        return 0;
      case XYZ:
      case XZY:
        return 0;
      case YXZ:
      case YZX:
        return 1;
      case ZXY:
      case ZYX:
        return 2;
    }
  }
 
  int j_index() const
  {
    switch (order_) {
      default:
        BLI_assert_unreachable();
        return 0;
      case YXZ:
      case ZXY:
        return 0;
      case XYZ:
      case ZYX:
        return 1;
      case XZY:
      case YZX:
        return 2;
    }
  }
 
  int k_index() const
  {
    switch (order_) {
      default:
        BLI_assert_unreachable();
        return 0;
      case YZX:
      case ZYX:
        return 0;
      case XZY:
      case ZXY:
        return 1;
      case XYZ:
      case YXZ:
        return 2;
    }
  }
};
 
using EulerXYZ = EulerXYZBase<float>;
using Euler3 = Euler3Base<float>;
 
}  // namespace blender::math