mirror of
https://github.com/UberGames/EF2GameSource.git
synced 2024-11-10 06:31:42 +00:00
776 lines
24 KiB
C++
776 lines
24 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Quaternion.h
|
|
//
|
|
// Author: Squirrel Eiserloh
|
|
//
|
|
// Copyright (C) 1997 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source is may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
// DESCRIPTION:
|
|
// Header for (and inline implementation of) a basic Quaternion class.
|
|
// This should ultimately be part of a yet-to-be-written general-purpose
|
|
// Rotation class at some point, time-permitting.
|
|
//
|
|
#ifndef _QUATERNION_H_
|
|
#define _QUATERNION_H_
|
|
|
|
#include <math.h>
|
|
#include "vector.h"
|
|
//#include "Matrix.h"
|
|
|
|
#define UNUSED_ARG (void)
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Quaternion
|
|
//
|
|
// ...in the form (x, y, z, w) such that q = xi + yj + zk + w, where:
|
|
//
|
|
// i x i = -1 i x j = k j x i = -k
|
|
// j x j = -1 and j x k = i and k x j = -i
|
|
// k = k = -1 k x i = j i x k = -j
|
|
//
|
|
// Note that i, j, and k are each imaginary numbers of different "flavors"
|
|
// representing mutually perpendicular unit vectors defining 3 of the
|
|
// 4 axes in quaternion 4-space. (The fourth axis is the real unit, 1.)
|
|
//
|
|
// In vector form, the quaternion would look like (s, v), where s is a
|
|
// scalar (equal to w) and v is a vector (x, y, z) in quaternion 4-space
|
|
// (giving position along the base unit axis vectors i, j, and k,
|
|
// respectively).
|
|
//
|
|
// The most useful quaternions are those that are of unit length
|
|
// (|q| = 1, or x*x + y*y + z*z + w*w = 1). This defines a set
|
|
// of points which make up a 4-dimensional "unit hypersphere",
|
|
// across the surface of which we will be interpolating.
|
|
//
|
|
// Note that Quaternion multiplication involves the vector cross
|
|
// product (v1 x v2), so it is NOT COMMUTATIVE. This means that
|
|
// q1 x q2 != q2 x q1. (Then again, matrix multiplication isn't
|
|
// commutative either, so suck it down.)
|
|
//
|
|
// "lhs" and "rhs" mean "left hand side" and "right hand side" for
|
|
// operator arguments, respectively.
|
|
//---------------------------------------------------------------------------
|
|
class Quaternion
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
// Member variables
|
|
//---------------------------------------------------------------------------
|
|
private:
|
|
float _x; // coefficient for the i imaginary term
|
|
float _y; // coefficient for the j imaginary term
|
|
float _z; // coefficient for the k imaginary term
|
|
float _w; // coefficient for the real term
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Accessors / Mutators
|
|
//---------------------------------------------------------------------------
|
|
protected:
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Implementation Methods
|
|
//---------------------------------------------------------------------------
|
|
private:
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Construction / Destruction
|
|
//---------------------------------------------------------------------------
|
|
public:
|
|
~Quaternion();
|
|
explicit Quaternion(); // default constructor
|
|
Quaternion( const Quaternion& rhs ); // copy constructor
|
|
explicit Quaternion( const float x, const float y, const float z, const float w );
|
|
explicit Quaternion( const float w, const Vector& vec );
|
|
explicit Quaternion( const Vector& eulerAngles );
|
|
// explicit Quaternion( const Matrix3x3& rotationMatrix );
|
|
// explicit Quaternion( const Matrix4x4& transformMatrix );
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Interface Methods
|
|
//---------------------------------------------------------------------------
|
|
public:
|
|
float CalcLength( void ) const;
|
|
float CalcLengthSquared( void ) const;
|
|
float Normalize( void );
|
|
|
|
void SetFromSV( const float w, const Vector& vec );
|
|
void SetFromXYZW( const float x, const float y, const float z, const float w );
|
|
void SetFromEuler( const Vector& eulerAngles );
|
|
// void SetFromMatrix3x3( const Matrix3x3& rotationMatrix );
|
|
// void SetFromMatrix4x4( const Matrix4x4& transformMatrix );
|
|
|
|
void GetToSV( float& w, Vector& vec ) const;
|
|
void GetToXYZW( float& x, float& y, float& z, float& w ) const;
|
|
void GetToEuler( Vector& eulerAngles ) const;
|
|
// void GetToMatrix3x3( Matrix3x3& rotationMatrix ) const;
|
|
// void GetToMatrix4x4( Matrix4x4& transformMatrix ) const;
|
|
|
|
/// Self-modifying operators
|
|
const Quaternion& operator = ( const Quaternion& rhs );
|
|
const Quaternion& operator += ( const Quaternion& rhs );
|
|
const Quaternion& operator -= ( const Quaternion& rhs );
|
|
const Quaternion& operator *= ( const float scale );
|
|
const Quaternion& operator *= ( const Quaternion& rhs );
|
|
const Quaternion& operator /= ( const float invScale );
|
|
const Quaternion operator - () const;
|
|
|
|
/// Construction operators
|
|
const Quaternion operator + ( const Quaternion& rhs ) const;
|
|
const Quaternion operator - ( const Quaternion& rhs ) const;
|
|
|
|
bool operator == ( const Quaternion& rhs ) const;
|
|
bool operator != ( const Quaternion& rhs ) const;
|
|
|
|
private:
|
|
const Quaternion operator * ( const float scale ) const; // multiply-by-right-scalar forbidden; use (float, Quaternion&) version instead
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
// External Operators & Functions
|
|
//---------------------------------------------------------------------------
|
|
const Quaternion operator * ( const Quaternion& lhs, const Quaternion& rhs );
|
|
const Quaternion operator * ( const float scale, const Quaternion& rhs );
|
|
const Quaternion operator / ( const Quaternion& lhs, const float invScale );
|
|
const Quaternion CalcSlerp( const Quaternion& q1, const Quaternion& q2, const float fraction );
|
|
const Quaternion CalcLerp( const Quaternion& q1, const Quaternion& q2, const float q2Fraction );
|
|
const Quaternion CalcNoLerp( const Quaternion& q1, const Quaternion& q2, const float q2Fraction );
|
|
float QuaternionDotProduct( const Quaternion& q1, const Quaternion& q2 );
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Destructor
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::~Quaternion()
|
|
{
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Default constructor
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::Quaternion()
|
|
{
|
|
// Do nothing; this should be used only by static array declarations
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Copy Constructor( Quaternion )
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::Quaternion( const Quaternion& rhs )
|
|
{
|
|
SetFromXYZW( rhs._x, rhs._y, rhs._z, rhs._w );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Constructor( float, float, float, float )
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::Quaternion( const float x, const float y, const float z, const float w )
|
|
{
|
|
SetFromXYZW( x, y, z, w );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Constructor( float, Vector )
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::Quaternion( const float w, const Vector& vec )
|
|
{
|
|
SetFromSV( w, vec );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Constructor( Vector )
|
|
//---------------------------------------------------------------------------
|
|
inline Quaternion::Quaternion( const Vector& eulerAngles )
|
|
{
|
|
SetFromEuler( eulerAngles );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Constructor( Matrix3x3 )
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline Quaternion::Quaternion( const Matrix3x3& rotationMatrix )
|
|
{
|
|
SetFromMatrix3x3( rotationMatrix );
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Constructor( Matrix4x4 )
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline Quaternion::Quaternion( const Matrix4x4& transformMatrix )
|
|
{
|
|
SetFromMatrix4x4( transformMatrix );
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// CalcLength()
|
|
//---------------------------------------------------------------------------
|
|
inline float Quaternion::CalcLength( void ) const
|
|
{
|
|
float length = (float) sqrt( CalcLengthSquared() );
|
|
return( length );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// CalcLengthSquared()
|
|
//---------------------------------------------------------------------------
|
|
inline float Quaternion::CalcLengthSquared( void ) const
|
|
{
|
|
float lengthSquared;
|
|
lengthSquared = (_x * _x) + (_y * _y) + (_z * _z) + (_w * _w);
|
|
return( lengthSquared );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Normalize
|
|
//---------------------------------------------------------------------------
|
|
inline float Quaternion::Normalize( void )
|
|
{
|
|
/// Get the length of the quaternion 4d vector
|
|
float length = CalcLength();
|
|
if( !length )
|
|
return( 0.0f );
|
|
|
|
/// Divide each component by <length>
|
|
*this /= length;
|
|
return( length );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// SetFromSV
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::SetFromSV( const float w, const Vector& vec )
|
|
{
|
|
SetFromXYZW( vec.x, vec.y, vec.z, w );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// SetFromXYZW
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::SetFromXYZW( const float x, const float y, const float z, const float w )
|
|
{
|
|
_x = x;
|
|
_y = y;
|
|
_z = z;
|
|
_w = w;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// SetFromEuler
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::SetFromEuler( const Vector& eulerAngles )
|
|
{
|
|
// FIXME: THIS IS TEMPORARY HACKED STUFF FOR PROOF OF CONCEPT ONLY!!!
|
|
float quat[ 4 ];
|
|
vec3_t eulerAng;
|
|
|
|
eulerAngles.copyTo( eulerAng );
|
|
EulerToQuat( eulerAng, quat );
|
|
|
|
_x = quat[ 0 ];
|
|
_y = quat[ 1 ];
|
|
_z = quat[ 2 ];
|
|
_w = quat[ 3 ];
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// SetFromMatrix3x3
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline void Quaternion::SetFromMatrix3x3( const Matrix3x3& rotationMatrix )
|
|
{
|
|
// FIXME: stub
|
|
UNUSED_ARG rotationMatrix;
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// SetFromMatrix4x4
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline void Quaternion::SetFromMatrix4x4( const Matrix4x4& transformMatrix )
|
|
{
|
|
// FIXME: stub
|
|
UNUSED_ARG transformMatrix;
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// GetToSV
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::GetToSV( float& w, Vector& vec ) const
|
|
{
|
|
GetToXYZW( vec.x, vec.y, vec.z, w );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// GetToXYZW
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::GetToXYZW( float& x, float& y, float& z, float& w ) const
|
|
{
|
|
x = _x;
|
|
y = _y;
|
|
z = _z;
|
|
w = _w;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// GetToEuler
|
|
//---------------------------------------------------------------------------
|
|
inline void Quaternion::GetToEuler( Vector& eulerAngles ) const
|
|
{
|
|
// FIXME: THIS IS TEMPORARY HACKED STUFF FOR PROOF OF CONCEPT ONLY!!!
|
|
float matrix[ 3 ][ 3 ];
|
|
float quat[ 4 ];
|
|
vec3_t eulerAng;
|
|
|
|
quat[ 0 ] = _x;
|
|
quat[ 1 ] = _y;
|
|
quat[ 2 ] = _z;
|
|
quat[ 3 ] = _w;
|
|
|
|
QuatToMat( quat, matrix );
|
|
MatrixToEulerAngles( matrix, eulerAng );
|
|
eulerAngles.setXYZ( eulerAng[0], eulerAng[1], eulerAng[2] );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// GetToMatrix3x3
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline void Quaternion::GetToMatrix3x3( Matrix3x3& rotationMatrix ) const
|
|
{
|
|
// FIXME: stub
|
|
UNUSED_ARG rotationMatrix;
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// GetToMatrix4x4
|
|
//---------------------------------------------------------------------------
|
|
/*
|
|
inline void Quaternion::GetToMatrix4x4( Matrix4x4& transformMatrix ) const
|
|
{
|
|
// FIXME: stub
|
|
UNUSED_ARG transformMatrix;
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator = (Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator = ( const Quaternion& rhs )
|
|
{
|
|
if( this == &rhs )
|
|
return *this;
|
|
|
|
_x = rhs._x;
|
|
_y = rhs._y;
|
|
_z = rhs._z;
|
|
_w = rhs._w;
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator += (Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator += ( const Quaternion& rhs )
|
|
{
|
|
_x += rhs._x;
|
|
_y += rhs._y;
|
|
_z += rhs._z;
|
|
_w += rhs._w;
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator -= (Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator -= ( const Quaternion& rhs )
|
|
{
|
|
_x -= rhs._x;
|
|
_y -= rhs._y;
|
|
_z -= rhs._z;
|
|
_w -= rhs._w;
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator *= (float)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator *= ( const float scale )
|
|
{
|
|
_x *= scale;
|
|
_y *= scale;
|
|
_z *= scale;
|
|
_w *= scale;
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator *= (Quaternion)
|
|
//
|
|
// Quaternion multiplication is NOT COMMUTATIVE, and is defined as
|
|
// follows, where "s" is the scalar component (w) and "v" is the vector
|
|
// component (x,y,z) (and 'x' means "3d vector cross product", '|' means
|
|
// "3d vector dot product"):
|
|
//
|
|
// q1 * q2 = q3 = (s3, v3) != q2 * q1
|
|
//
|
|
// s3 = (s1 * s2) - (v1 | v2)
|
|
// v3 = (s1 * v2) + (s2 * v1) + (v1 x v2)
|
|
//
|
|
// i.e. Q(s1, v1) * Q(s2, v2) = Q(s3, v3)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator *= ( const Quaternion& rhs )
|
|
{
|
|
float s1, s2, s3; // see above comment
|
|
Vector v1, v2, v3; // see above comment
|
|
|
|
/// Get both quaternions into (s,v) form
|
|
GetToSV( s1, v1 );
|
|
rhs.GetToSV( s2, v2 );
|
|
|
|
/// Calculate the new scalar term (s3)
|
|
s3 = (s1 * s2) - Vector::Dot( v1, v2 );
|
|
|
|
/// Calculate the new vector term (v3)
|
|
Vector v1CrossV2; // temp variable for cross-product result, since our Vector class sucks
|
|
v1CrossV2.CrossProduct( v1, v2 ); // our vector class sucks
|
|
v3 = (s1 * v2) + (s2 * v1) + v1CrossV2;
|
|
|
|
/// Set the new scalar and vector terms and return this
|
|
SetFromSV( s3, v3 );
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator /= (float)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion& Quaternion::operator /= ( const float invScale )
|
|
{
|
|
if( invScale )
|
|
{
|
|
_x /= invScale;
|
|
_y /= invScale;
|
|
_z /= invScale;
|
|
_w /= invScale;
|
|
}
|
|
else
|
|
{
|
|
SetFromXYZW( 0.0f, 0.0f, 0.0f, 0.0f );
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator - (Quaternion) : unary minus
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion Quaternion::operator - () const
|
|
{
|
|
return Quaternion( -_x, -_y, -_z, -_w );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator == (Quaternion, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
//inline bool operator == ( const Quaternion& lhs, const Quaternion& rhs )
|
|
inline bool Quaternion::operator == ( const Quaternion& rhs ) const
|
|
{
|
|
if( _x != rhs._x )
|
|
return false;
|
|
|
|
if( _y != rhs._y )
|
|
return false;
|
|
|
|
if( _z != rhs._z )
|
|
return false;
|
|
|
|
if( _w != rhs._w )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator != (Quaternion, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline bool Quaternion::operator != ( const Quaternion& rhs ) const
|
|
{
|
|
return( !(*this == rhs) );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator - (Quaternion, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion Quaternion::operator - ( const Quaternion& rhs ) const
|
|
{
|
|
Quaternion difference( *this );
|
|
difference -= rhs;
|
|
return( difference );
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// operator + (Quaternion, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion Quaternion::operator + ( const Quaternion& rhs ) const
|
|
//Quaternion Quaternion::operator + ( const Quaternion& rhs ) const
|
|
{
|
|
Quaternion sum( *this );
|
|
sum += rhs;
|
|
return( sum );
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general operator * (Quaternion, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion operator * ( const Quaternion& lhs, const Quaternion& rhs )
|
|
{
|
|
Quaternion product( lhs );
|
|
product *= rhs;
|
|
return product;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general operator * (float, Quaternion)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion operator * ( const float scale, const Quaternion& rhs )
|
|
{
|
|
Quaternion scaled( rhs );
|
|
scaled *= scale;
|
|
return scaled;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general operator / (Quaternion, float)
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion operator / ( const Quaternion& lhs, const float invScale )
|
|
{
|
|
Quaternion scaled( lhs );
|
|
if( invScale )
|
|
{
|
|
scaled /= invScale;
|
|
}
|
|
else
|
|
{
|
|
scaled *= 0.0f;
|
|
}
|
|
return scaled;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general CalcLerp (Quaternion, Quaternion, float)
|
|
//
|
|
// Performs a hypervector linear interpolation - or "lerp" - of two
|
|
// Quaternions and returns the resulting (newly constructed) Quaternion.
|
|
//
|
|
// <q2Fraction> is a value in the range [0,1] representing how much of
|
|
// <q2> to use in the interpolation; q1Fraction = 1-<q2Fraction> is the
|
|
// weighting given to <q1>.
|
|
//
|
|
// NOTE: This interpolation is faster, but less accurate, than CalcSlerp().
|
|
// Use CalcSlerp() if the error incurred from CalcLerp() is noticeable.
|
|
//
|
|
// For optimization purposes, CalcLerp() assumes <q1> and <q2> are
|
|
// already normalized.
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion CalcLerp( const Quaternion& q1, const Quaternion& q2, const float q2Fraction )
|
|
{
|
|
const float q1Fraction = 1.0f - q2Fraction;
|
|
|
|
/// Check if <q1> and <q2> are the same quaternion
|
|
if( &q1 == &q2 )
|
|
return Quaternion( q1 );
|
|
|
|
/// Check if <q1> and <q2> are data-identical
|
|
if( q1 == q2 )
|
|
return Quaternion( q1 );
|
|
|
|
/// Check if <q2Fraction> is at (or beyond) a boundary condition
|
|
if( q2Fraction <= 0.0f )
|
|
return Quaternion( q1 );
|
|
if( q2Fraction >= 1.0f )
|
|
return Quaternion( q2 );
|
|
|
|
/// Create a new quaternion which represents the weighted average of <q1> and <q2>
|
|
Quaternion lerped( (q1Fraction * q1) + (q2Fraction * q2) );
|
|
float lerpedLength = lerped.Normalize();
|
|
|
|
/// Check if the 4d vectors added up to 0.0 (degenerate case!)
|
|
if( !lerpedLength )
|
|
{
|
|
/// Return whichever of <q1> or <q2> the parameter is currently closest to
|
|
return CalcNoLerp( q1, q2, q2Fraction );
|
|
}
|
|
|
|
return lerped;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general CalcSlerp (Quaternion, Quaternion, float)
|
|
//
|
|
// Performs a (hyper)spherical linear interpolation - or "slerp" - of two
|
|
// Quaternions and returns the resulting (newly constructed) Quaternion.
|
|
//
|
|
// <q2Fraction> is a value in the range [0,1] representing how much of
|
|
// <q2> to use in the interpolation; q1Fraction = 1-<q2Fraction> is the
|
|
// weighting given to <q1>.
|
|
//
|
|
// For optimization purposes, CalcSlerp() assumes <q1> and <q2> are
|
|
// already normalized.
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion CalcSlerp( const Quaternion& q1, const Quaternion& q2, const float q2Fraction )
|
|
{
|
|
static const float SIN_OMEGA_EPSILON = 0.00001f;
|
|
const float q1Fraction = 1.0f - q2Fraction;
|
|
|
|
/// Check if <q1> and <q2> are one and the same
|
|
if( &q1 == &q2 )
|
|
return Quaternion( q1 );
|
|
|
|
/// Check if <q1> and <q2> are data-identical
|
|
if( q1 == q2 )
|
|
return Quaternion( q1 );
|
|
|
|
/// Check if <q2Fraction> is at (or beyond) a boundary condition
|
|
if( q2Fraction <= 0.0f )
|
|
return Quaternion( q1 );
|
|
if( q2Fraction >= 1.0f )
|
|
return Quaternion( q2 );
|
|
|
|
/// Calculate <cosOmega>, the dot product (cosine) of the angle between the two 4d hypervectors
|
|
float cosOmega = QuaternionDotProduct( q1, q2 );
|
|
|
|
/// Create a copy of q2 and invert it if <cosOmega> is negative (i.e. it's on the opposite side of the hypersphere)
|
|
Quaternion q2copy( q2 );
|
|
if( cosOmega < 0.0f )
|
|
{
|
|
/// Mirror the hypervector (and, therefore, the dot product) to be on the same side of the hypersphere as <q1>
|
|
cosOmega = -cosOmega;
|
|
q2copy *= -1.0f;
|
|
}
|
|
|
|
/// Check if either <q1> or <q2> was not normalized
|
|
if( cosOmega > 1.0f )
|
|
{
|
|
/// FIXME: One or both of <q1> or <q2> were evidently not normalized; this should be an error condition!
|
|
/// Return whichever of <q1> or <q2> the parameter is currently closest to
|
|
return CalcNoLerp( q1, q2, q2Fraction );
|
|
}
|
|
|
|
/// Check if <q1> and <q2> are close enough to use linear interpolation instead
|
|
if( (1.0f - cosOmega) > SIN_OMEGA_EPSILON )
|
|
{
|
|
return CalcLerp( q1, q2, q2Fraction );
|
|
}
|
|
|
|
/// Check if <q1> and <q2> are nearly opposite on the hypersphere
|
|
if( (cosOmega + 1.0) < SIN_OMEGA_EPSILON )
|
|
{
|
|
// FIXME: how should this case be handled?
|
|
// Watt & Watt does some voodoo-math which is clearly incorrect...
|
|
return CalcNoLerp( q1, q2, q2Fraction );
|
|
}
|
|
|
|
/// Calculate <omega>, the angle between <q1> and <q2>, based on the dot product (cosine) between <q1> and <q2>
|
|
const float omega = acos( cosOmega );
|
|
const float sinOmega = sin( omega );
|
|
|
|
/// Check if <sinOmega> is prohibitively small (since it will end up in the denominator later)
|
|
if( (sinOmega > -SIN_OMEGA_EPSILON) && (sinOmega < SIN_OMEGA_EPSILON) )
|
|
{
|
|
/// Return whichever of <q1> or <q2> the parameter is currently closest to
|
|
return CalcNoLerp( q1, q2, q2Fraction );
|
|
}
|
|
|
|
/// Build a new quaternion, <slerped>, which uses normal (hyper)spherical linear interpolation
|
|
Quaternion slerped;
|
|
float scale1 = sin( q1Fraction * omega ) / sinOmega;
|
|
float scale2 = sin( q2Fraction * omega ) / sinOmega;
|
|
slerped = (scale1 * q1) + (scale2 * q2);
|
|
|
|
// FIXME: does <slerped> need to be renormalized at this point??
|
|
// (yes, but only because of floating-point drift, and it's the caller's reponsibility to do this)
|
|
|
|
return slerped;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// general CalcNoLerp (Quaternion, Quaternion, float)
|
|
//
|
|
// This is a fake / stub quaternion interpolation function; it simply
|
|
// returns a copy of <q1> or <q2> based on which one <q2Fraction>
|
|
// indicates it is closer to.
|
|
//---------------------------------------------------------------------------
|
|
inline const Quaternion CalcNoLerp( const Quaternion& q1, const Quaternion& q2, const float q2Fraction )
|
|
{
|
|
if( q2Fraction < 0.5f )
|
|
{
|
|
return Quaternion( q1 );
|
|
}
|
|
else
|
|
{
|
|
return Quaternion( q2 );
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// QuaternionDotProduct
|
|
//
|
|
// Calculates the dot product of <q1> and <q2> where both quaternions are
|
|
// taken as (probably unit) vectors in fourspace.
|
|
//---------------------------------------------------------------------------
|
|
inline float QuaternionDotProduct( const Quaternion& q1, const Quaternion& q2 )
|
|
{
|
|
float x1, y1, z1, w1;
|
|
float x2, y2, z2, w2;
|
|
|
|
q1.GetToXYZW( x1, y1, z1, w1 );
|
|
q2.GetToXYZW( x2, y2, z2, w2 );
|
|
|
|
float dotProduct = (x1*x2) + (y1*y2) + (z1*z2) + (w1*w1);
|
|
return dotProduct;
|
|
}
|
|
|
|
|
|
|
|
#endif // _QUATERNION_H_
|