CQuaternion3d.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <i3d/CVector3d.h>
 
 
namespace i3d
{
 
 
class CMatrix3d;
 
 
class CQuaternion3d
{
public:
       CQuaternion3d();
       
       CQuaternion3d(double w, double x, double y, double z);
       
       static CQuaternion3d FromAxisAngle(const CVector3d& axis, double angle);
       
       static CQuaternion3d FromMatrix(const CMatrix3d& matrix);
       
       static CQuaternion3d FromEulerAngles(double roll, double pitch, double yaw);
       
       double GetW() const;
       
       void SetW(double w);
       
       double GetX() const;
       
       void SetX(double x);
       
       double GetY() const;
       
       void SetY(double y);
       
       double GetZ() const;
       
       void SetZ(double z);
       
       CVector3d GetVectorPart() const;
       
       double GetLength() const;
       
       double GetLengthSq() const;
       
       CQuaternion3d GetNormalized() const;
       
       void Normalize();
       
       CQuaternion3d GetConjugate() const;
       
       CQuaternion3d GetInverse() const;
       
       CMatrix3d ToMatrix() const;
       
       void ToAxisAngle(CVector3d& axis, double& angle) const;
       
       CVector3d Rotate(const CVector3d& vector) const;
       
       double GetDotProduct(const CQuaternion3d& other) const;
       
       static CQuaternion3d Slerp(const CQuaternion3d& q1, const CQuaternion3d& q2, double t);
       
       bool Serialize(iser::IArchive& archive);
       
       CQuaternion3d operator*(const CQuaternion3d& other) const;
       CQuaternion3d operator*(double scalar) const;
       CQuaternion3d operator+(const CQuaternion3d& other) const;
       CQuaternion3d operator-(const CQuaternion3d& other) const;
       
       CQuaternion3d& operator*=(const CQuaternion3d& other);
       CQuaternion3d& operator*=(double scalar);
       
       bool operator==(const CQuaternion3d& other) const;
       bool operator!=(const CQuaternion3d& other) const;
 
private:
       double m_w;          
       double m_x;          
       double m_y;          
       double m_z;          
};
 
 
// inline methods
 
inline CQuaternion3d::CQuaternion3d()
:      m_w(1.0)
,      m_x(0.0)
,      m_y(0.0)
,      m_z(0.0)
{
}
 
 
inline CQuaternion3d::CQuaternion3d(double w, double x, double y, double z)
:      m_w(w)
,      m_x(x)
,      m_y(y)
,      m_z(z)
{
}
 
 
inline double CQuaternion3d::GetW() const
{
       return m_w;
}
 
 
inline void CQuaternion3d::SetW(double w)
{
       m_w = w;
}
 
 
inline double CQuaternion3d::GetX() const
{
       return m_x;
}
 
 
inline void CQuaternion3d::SetX(double x)
{
       m_x = x;
}
 
 
inline double CQuaternion3d::GetY() const
{
       return m_y;
}
 
 
inline void CQuaternion3d::SetY(double y)
{
       m_y = y;
}
 
 
inline double CQuaternion3d::GetZ() const
{
       return m_z;
}
 
 
inline void CQuaternion3d::SetZ(double z)
{
       m_z = z;
}
 
 
inline CVector3d CQuaternion3d::GetVectorPart() const
{
       return CVector3d(m_x, m_y, m_z);
}
 
 
inline double CQuaternion3d::GetLengthSq() const
{
       return m_w * m_w + m_x * m_x + m_y * m_y + m_z * m_z;
}
 
 
inline double CQuaternion3d::GetLength() const
{
       return qSqrt(GetLengthSq());
}
 
 
inline CQuaternion3d CQuaternion3d::GetConjugate() const
{
       return CQuaternion3d(m_w, -m_x, -m_y, -m_z);
}
 
 
inline double CQuaternion3d::GetDotProduct(const CQuaternion3d& other) const
{
       return m_w * other.m_w + m_x * other.m_x + m_y * other.m_y + m_z * other.m_z;
}
 
 
inline bool CQuaternion3d::operator==(const CQuaternion3d& other) const
{
       return qAbs(m_w - other.m_w) < I_BIG_EPSILON &&
              qAbs(m_x - other.m_x) < I_BIG_EPSILON &&
              qAbs(m_y - other.m_y) < I_BIG_EPSILON &&
              qAbs(m_z - other.m_z) < I_BIG_EPSILON;
}
 
 
inline bool CQuaternion3d::operator!=(const CQuaternion3d& other) const
{
       return !(*this == other);
}
 
 
} // namespace i3d