268 lines
9.0 KiB
C++
268 lines
9.0 KiB
C++
/*
|
||
-----------------------------------------------------------------------------
|
||
This source file is part of OGRE
|
||
(Object-oriented Graphics Rendering Engine)
|
||
For the latest info, see http://www.ogre3d.org/
|
||
|
||
Copyright (c) 2000-2009 Torus Knot Software Ltd
|
||
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
of this software and associated documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights
|
||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
copies of the Software, and to permit persons to whom the Software is
|
||
furnished to do so, subject to the following conditions:
|
||
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
THE SOFTWARE.
|
||
-----------------------------------------------------------------------------
|
||
*/
|
||
// This file is based on material originally from:
|
||
// Geometric Tools, LLC
|
||
// Copyright (c) 1998-2010
|
||
// Distributed under the Boost Software License, Version 1.0.
|
||
// http://www.boost.org/LICENSE_1_0.txt
|
||
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
|
||
|
||
|
||
#ifndef __Quaternion_H__
|
||
#define __Quaternion_H__
|
||
|
||
#include "OgrePrerequisites.h"
|
||
#include "OgreMath.h"
|
||
|
||
namespace Ogre {
|
||
|
||
/** \addtogroup Core
|
||
* @{
|
||
*/
|
||
/** \addtogroup Math
|
||
* @{
|
||
*/
|
||
/** Implementation of a Quaternion, i.e. a rotation around an axis.
|
||
*/
|
||
class Quaternion
|
||
{
|
||
public:
|
||
inline Quaternion (
|
||
Real fW = 1.0,
|
||
Real fX = 0.0, Real fY = 0.0, Real fZ = 0.0)
|
||
{
|
||
w = fW;
|
||
x = fX;
|
||
y = fY;
|
||
z = fZ;
|
||
}
|
||
/// Construct a quaternion from a rotation matrix
|
||
inline Quaternion(const Matrix3& rot)
|
||
{
|
||
this->FromRotationMatrix(rot);
|
||
}
|
||
/// Construct a quaternion from an angle/axis
|
||
inline Quaternion(const Radian& rfAngle, const Vector3& rkAxis)
|
||
{
|
||
this->FromAngleAxis(rfAngle, rkAxis);
|
||
}
|
||
/// Construct a quaternion from 3 orthonormal local axes
|
||
inline Quaternion(const Vector3& xaxis, const Vector3& yaxis, const Vector3& zaxis)
|
||
{
|
||
this->FromAxes(xaxis, yaxis, zaxis);
|
||
}
|
||
/// Construct a quaternion from 3 orthonormal local axes
|
||
inline Quaternion(const Vector3* akAxis)
|
||
{
|
||
this->FromAxes(akAxis);
|
||
}
|
||
/// Construct a quaternion from 4 manual w/x/y/z values
|
||
inline Quaternion(Real* valptr)
|
||
{
|
||
memcpy(&w, valptr, sizeof(Real)*4);
|
||
}
|
||
|
||
/** Exchange the contents of this quaternion with another.
|
||
*/
|
||
inline void swap(Quaternion& other)
|
||
{
|
||
std::swap(w, other.w);
|
||
std::swap(x, other.x);
|
||
std::swap(y, other.y);
|
||
std::swap(z, other.z);
|
||
}
|
||
|
||
/// Array accessor operator
|
||
inline Real operator [] ( const size_t i ) const
|
||
{
|
||
assert( i < 4 );
|
||
|
||
return *(&w+i);
|
||
}
|
||
|
||
/// Array accessor operator
|
||
inline Real& operator [] ( const size_t i )
|
||
{
|
||
assert( i < 4 );
|
||
|
||
return *(&w+i);
|
||
}
|
||
|
||
/// Pointer accessor for direct copying
|
||
inline Real* ptr()
|
||
{
|
||
return &w;
|
||
}
|
||
|
||
/// Pointer accessor for direct copying
|
||
inline const Real* ptr() const
|
||
{
|
||
return &w;
|
||
}
|
||
|
||
void FromRotationMatrix (const Matrix3& kRot);
|
||
void ToRotationMatrix (Matrix3& kRot) const;
|
||
void FromAngleAxis (const Radian& rfAngle, const Vector3& rkAxis);
|
||
void ToAngleAxis (Radian& rfAngle, Vector3& rkAxis) const;
|
||
inline void ToAngleAxis (Degree& dAngle, Vector3& rkAxis) const {
|
||
Radian rAngle;
|
||
ToAngleAxis ( rAngle, rkAxis );
|
||
dAngle = rAngle;
|
||
}
|
||
void FromAxes (const Vector3* akAxis);
|
||
void FromAxes (const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);
|
||
void ToAxes (Vector3* akAxis) const;
|
||
void ToAxes (Vector3& xAxis, Vector3& yAxis, Vector3& zAxis) const;
|
||
/// Get the local x-axis
|
||
Vector3 xAxis(void) const;
|
||
/// Get the local y-axis
|
||
Vector3 yAxis(void) const;
|
||
/// Get the local z-axis
|
||
Vector3 zAxis(void) const;
|
||
|
||
Quaternion CalRollPitchYaw( float roll , float pitch , float yaw );
|
||
inline Quaternion& operator= (const Quaternion& rkQ)
|
||
{
|
||
w = rkQ.w;
|
||
x = rkQ.x;
|
||
y = rkQ.y;
|
||
z = rkQ.z;
|
||
return *this;
|
||
}
|
||
Quaternion operator+ (const Quaternion& rkQ) const;
|
||
Quaternion operator- (const Quaternion& rkQ) const;
|
||
Quaternion operator* (const Quaternion& rkQ) const;
|
||
Quaternion operator* (Real fScalar) const;
|
||
friend Quaternion operator* (Real fScalar,
|
||
const Quaternion& rkQ);
|
||
Quaternion operator- () const;
|
||
inline bool operator== (const Quaternion& rhs) const
|
||
{
|
||
return (rhs.x == x) && (rhs.y == y) &&
|
||
(rhs.z == z) && (rhs.w == w);
|
||
}
|
||
inline bool operator!= (const Quaternion& rhs) const
|
||
{
|
||
return !operator==(rhs);
|
||
}
|
||
// functions of a quaternion
|
||
Real Dot (const Quaternion& rkQ) const; // dot product
|
||
Real Norm () const; // squared-length
|
||
/// Normalises this quaternion, and returns the previous length
|
||
Real normalise(void);
|
||
Quaternion Inverse () const; // apply to non-zero quaternion
|
||
Quaternion UnitInverse () const; // apply to unit-length quaternion
|
||
Quaternion Exp () const;
|
||
Quaternion Log () const;
|
||
|
||
// rotation of a vector by a quaternion
|
||
Vector3 operator* (const Vector3& rkVector) const;
|
||
|
||
/** Calculate the local roll element of this quaternion.
|
||
@param reprojectAxis By default the method returns the 'intuitive' result
|
||
that is, if you projected the local Y of the quaternion onto the X and
|
||
Y axes, the angle between them is returned. If set to false though, the
|
||
result is the actual yaw that will be used to implement the quaternion,
|
||
which is the shortest possible path to get to the same orientation and
|
||
may involve less axial rotation.
|
||
*/
|
||
Radian getRoll(bool reprojectAxis = true) const;
|
||
/** Calculate the local pitch element of this quaternion
|
||
@param reprojectAxis By default the method returns the 'intuitive' result
|
||
that is, if you projected the local Z of the quaternion onto the X and
|
||
Y axes, the angle between them is returned. If set to true though, the
|
||
result is the actual yaw that will be used to implement the quaternion,
|
||
which is the shortest possible path to get to the same orientation and
|
||
may involve less axial rotation.
|
||
*/
|
||
Radian getPitch(bool reprojectAxis = true) const;
|
||
/** Calculate the local yaw element of this quaternion
|
||
@param reprojectAxis By default the method returns the 'intuitive' result
|
||
that is, if you projected the local Z of the quaternion onto the X and
|
||
Z axes, the angle between them is returned. If set to true though, the
|
||
result is the actual yaw that will be used to implement the quaternion,
|
||
which is the shortest possible path to get to the same orientation and
|
||
may involve less axial rotation.
|
||
*/
|
||
Radian getYaw(bool reprojectAxis = true) const;
|
||
/// Equality with tolerance (tolerance is max angle difference)
|
||
bool equals(const Quaternion& rhs, const Radian& tolerance) const;
|
||
|
||
/// get the yaw <20><>pitch <20><>roll in order XYZ
|
||
void GetYawPitchRoll(Radian& yaw, Radian& pitch, Radian& roll) const;
|
||
|
||
// spherical linear interpolation
|
||
static Quaternion Slerp (Real fT, const Quaternion& rkP,
|
||
const Quaternion& rkQ, bool shortestPath = false);
|
||
|
||
static Quaternion SlerpExtraSpins (Real fT,
|
||
const Quaternion& rkP, const Quaternion& rkQ,
|
||
int iExtraSpins);
|
||
|
||
// setup for spherical quadratic interpolation
|
||
static void Intermediate (const Quaternion& rkQ0,
|
||
const Quaternion& rkQ1, const Quaternion& rkQ2,
|
||
Quaternion& rka, Quaternion& rkB);
|
||
|
||
// spherical quadratic interpolation
|
||
static Quaternion Squad (Real fT, const Quaternion& rkP,
|
||
const Quaternion& rkA, const Quaternion& rkB,
|
||
const Quaternion& rkQ, bool shortestPath = false);
|
||
|
||
// normalised linear interpolation - faster but less accurate (non-constant rotation velocity)
|
||
static Quaternion nlerp(Real fT, const Quaternion& rkP,
|
||
const Quaternion& rkQ, bool shortestPath = false);
|
||
|
||
|
||
|
||
// cutoff for sine near zero
|
||
static const Real ms_fEpsilon;
|
||
|
||
// special values
|
||
static const Quaternion ZERO;
|
||
static const Quaternion IDENTITY;
|
||
|
||
Real w, x, y, z;
|
||
|
||
/// Check whether this quaternion contains valid values
|
||
inline bool isNaN() const
|
||
{
|
||
return Math::isNaN(x) || Math::isNaN(y) || Math::isNaN(z) || Math::isNaN(w);
|
||
}
|
||
|
||
};
|
||
/** @} */
|
||
/** @} */
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
#endif
|