mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
487 lines
11 KiB
C++
487 lines
11 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __MATH_QUAT_H__
|
|
#define __MATH_QUAT_H__
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
Quaternion
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
#include "../containers/Array.h" // for idTupleSize
|
|
|
|
class idVec3;
|
|
class idAngles;
|
|
class idRotation;
|
|
class idMat3;
|
|
class idMat4;
|
|
class idCQuat;
|
|
|
|
class idQuat
|
|
{
|
|
public:
|
|
float x;
|
|
float y;
|
|
float z;
|
|
float w;
|
|
|
|
idQuat();
|
|
idQuat( float x, float y, float z, float w );
|
|
|
|
void Set( float x, float y, float z, float w );
|
|
|
|
float operator[]( int index ) const;
|
|
float& operator[]( int index );
|
|
idQuat operator-() const;
|
|
idQuat& operator=( const idQuat& a );
|
|
idQuat operator+( const idQuat& a ) const;
|
|
idQuat& operator+=( const idQuat& a );
|
|
idQuat operator-( const idQuat& a ) const;
|
|
idQuat& operator-=( const idQuat& a );
|
|
idQuat operator*( const idQuat& a ) const;
|
|
idVec3 operator*( const idVec3& a ) const;
|
|
idQuat operator*( float a ) const;
|
|
idQuat& operator*=( const idQuat& a );
|
|
idQuat& operator*=( float a );
|
|
|
|
friend idQuat operator*( const float a, const idQuat& b );
|
|
friend idVec3 operator*( const idVec3& a, const idQuat& b );
|
|
|
|
bool Compare( const idQuat& a ) const; // exact compare, no epsilon
|
|
bool Compare( const idQuat& a, const float epsilon ) const; // compare with epsilon
|
|
bool operator==( const idQuat& a ) const; // exact compare, no epsilon
|
|
bool operator!=( const idQuat& a ) const; // exact compare, no epsilon
|
|
|
|
idQuat Inverse() const;
|
|
float Length() const;
|
|
idQuat& Normalize();
|
|
|
|
float CalcW() const;
|
|
int GetDimension() const;
|
|
|
|
idAngles ToAngles() const;
|
|
idRotation ToRotation() const;
|
|
idMat3 ToMat3() const;
|
|
idMat4 ToMat4() const;
|
|
idCQuat ToCQuat() const;
|
|
idVec3 ToAngularVelocity() const;
|
|
const float* ToFloatPtr() const;
|
|
float* ToFloatPtr();
|
|
const char* ToString( int precision = 2 ) const;
|
|
|
|
idQuat& Slerp( const idQuat& from, const idQuat& to, float t );
|
|
idQuat& Lerp( const idQuat& from, const idQuat& to, const float t );
|
|
};
|
|
|
|
// A non-member slerp function allows constructing a const idQuat object with the result of a slerp,
|
|
// but without having to explicity create a temporary idQuat object.
|
|
idQuat Slerp( const idQuat& from, const idQuat& to, const float t );
|
|
|
|
ID_INLINE idQuat::idQuat()
|
|
{
|
|
}
|
|
|
|
ID_INLINE idQuat::idQuat( float x, float y, float z, float w )
|
|
{
|
|
this->x = x;
|
|
this->y = y;
|
|
this->z = z;
|
|
this->w = w;
|
|
}
|
|
|
|
ID_INLINE float idQuat::operator[]( int index ) const
|
|
{
|
|
assert( ( index >= 0 ) && ( index < 4 ) );
|
|
return ( &x )[ index ];
|
|
}
|
|
|
|
ID_INLINE float& idQuat::operator[]( int index )
|
|
{
|
|
assert( ( index >= 0 ) && ( index < 4 ) );
|
|
return ( &x )[ index ];
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::operator-() const
|
|
{
|
|
return idQuat( -x, -y, -z, -w );
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::operator=( const idQuat& a )
|
|
{
|
|
x = a.x;
|
|
y = a.y;
|
|
z = a.z;
|
|
w = a.w;
|
|
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::operator+( const idQuat& a ) const
|
|
{
|
|
return idQuat( x + a.x, y + a.y, z + a.z, w + a.w );
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::operator+=( const idQuat& a )
|
|
{
|
|
x += a.x;
|
|
y += a.y;
|
|
z += a.z;
|
|
w += a.w;
|
|
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::operator-( const idQuat& a ) const
|
|
{
|
|
return idQuat( x - a.x, y - a.y, z - a.z, w - a.w );
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::operator-=( const idQuat& a )
|
|
{
|
|
x -= a.x;
|
|
y -= a.y;
|
|
z -= a.z;
|
|
w -= a.w;
|
|
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::operator*( const idQuat& a ) const
|
|
{
|
|
return idQuat( w * a.x + x * a.w + y * a.z - z * a.y,
|
|
w * a.y + y * a.w + z * a.x - x * a.z,
|
|
w * a.z + z * a.w + x * a.y - y * a.x,
|
|
w * a.w - x * a.x - y * a.y - z * a.z );
|
|
}
|
|
|
|
ID_INLINE idVec3 idQuat::operator*( const idVec3& a ) const
|
|
{
|
|
#if 0
|
|
// it's faster to do the conversion to a 3x3 matrix and multiply the vector by this 3x3 matrix
|
|
return ( ToMat3() * a );
|
|
#else
|
|
// result = this->Inverse() * idQuat( a.x, a.y, a.z, 0.0f ) * (*this)
|
|
float xxzz = x * x - z * z;
|
|
float wwyy = w * w - y * y;
|
|
|
|
float xw2 = x * w * 2.0f;
|
|
float xy2 = x * y * 2.0f;
|
|
float xz2 = x * z * 2.0f;
|
|
float yw2 = y * w * 2.0f;
|
|
float yz2 = y * z * 2.0f;
|
|
float zw2 = z * w * 2.0f;
|
|
|
|
return idVec3(
|
|
( xxzz + wwyy ) * a.x + ( xy2 + zw2 ) * a.y + ( xz2 - yw2 ) * a.z,
|
|
( xy2 - zw2 ) * a.x + ( y * y + w * w - x * x - z * z ) * a.y + ( yz2 + xw2 ) * a.z,
|
|
( xz2 + yw2 ) * a.x + ( yz2 - xw2 ) * a.y + ( wwyy - xxzz ) * a.z
|
|
);
|
|
#endif
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::operator*( float a ) const
|
|
{
|
|
return idQuat( x * a, y * a, z * a, w * a );
|
|
}
|
|
|
|
ID_INLINE idQuat operator*( const float a, const idQuat& b )
|
|
{
|
|
return b * a;
|
|
}
|
|
|
|
ID_INLINE idVec3 operator*( const idVec3& a, const idQuat& b )
|
|
{
|
|
return b * a;
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::operator*=( const idQuat& a )
|
|
{
|
|
*this = *this * a;
|
|
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::operator*=( float a )
|
|
{
|
|
x *= a;
|
|
y *= a;
|
|
z *= a;
|
|
w *= a;
|
|
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE bool idQuat::Compare( const idQuat& a ) const
|
|
{
|
|
return ( ( x == a.x ) && ( y == a.y ) && ( z == a.z ) && ( w == a.w ) );
|
|
}
|
|
|
|
ID_INLINE bool idQuat::Compare( const idQuat& a, const float epsilon ) const
|
|
{
|
|
if( idMath::Fabs( x - a.x ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
if( idMath::Fabs( y - a.y ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
if( idMath::Fabs( z - a.z ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
if( idMath::Fabs( w - a.w ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ID_INLINE bool idQuat::operator==( const idQuat& a ) const
|
|
{
|
|
return Compare( a );
|
|
}
|
|
|
|
ID_INLINE bool idQuat::operator!=( const idQuat& a ) const
|
|
{
|
|
return !Compare( a );
|
|
}
|
|
|
|
ID_INLINE void idQuat::Set( float x, float y, float z, float w )
|
|
{
|
|
this->x = x;
|
|
this->y = y;
|
|
this->z = z;
|
|
this->w = w;
|
|
}
|
|
|
|
ID_INLINE idQuat idQuat::Inverse() const
|
|
{
|
|
return idQuat( -x, -y, -z, w );
|
|
}
|
|
|
|
ID_INLINE float idQuat::Length() const
|
|
{
|
|
float len;
|
|
|
|
len = x * x + y * y + z * z + w * w;
|
|
return idMath::Sqrt( len );
|
|
}
|
|
|
|
ID_INLINE idQuat& idQuat::Normalize()
|
|
{
|
|
float len;
|
|
float ilength;
|
|
|
|
len = this->Length();
|
|
if( len )
|
|
{
|
|
ilength = 1 / len;
|
|
x *= ilength;
|
|
y *= ilength;
|
|
z *= ilength;
|
|
w *= ilength;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
ID_INLINE float idQuat::CalcW() const
|
|
{
|
|
// take the absolute value because floating point rounding may cause the dot of x,y,z to be larger than 1
|
|
return sqrt( fabs( 1.0f - ( x * x + y * y + z * z ) ) );
|
|
}
|
|
|
|
ID_INLINE int idQuat::GetDimension() const
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
ID_INLINE const float* idQuat::ToFloatPtr() const
|
|
{
|
|
return &x;
|
|
}
|
|
|
|
ID_INLINE float* idQuat::ToFloatPtr()
|
|
{
|
|
return &x;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
Specialization to get size of an idQuat generically.
|
|
|
|
===============================================================================
|
|
*/
|
|
template<>
|
|
struct idTupleSize< idQuat >
|
|
{
|
|
enum { value = 4 };
|
|
};
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
Compressed quaternion
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
class idCQuat
|
|
{
|
|
public:
|
|
float x;
|
|
float y;
|
|
float z;
|
|
|
|
idCQuat();
|
|
idCQuat( float x, float y, float z );
|
|
|
|
void Set( float x, float y, float z );
|
|
|
|
float operator[]( int index ) const;
|
|
float& operator[]( int index );
|
|
|
|
bool Compare( const idCQuat& a ) const; // exact compare, no epsilon
|
|
bool Compare( const idCQuat& a, const float epsilon ) const; // compare with epsilon
|
|
bool operator==( const idCQuat& a ) const; // exact compare, no epsilon
|
|
bool operator!=( const idCQuat& a ) const; // exact compare, no epsilon
|
|
|
|
int GetDimension() const;
|
|
|
|
idAngles ToAngles() const;
|
|
idRotation ToRotation() const;
|
|
idMat3 ToMat3() const;
|
|
idMat4 ToMat4() const;
|
|
idQuat ToQuat() const;
|
|
const float* ToFloatPtr() const;
|
|
float* ToFloatPtr();
|
|
const char* ToString( int precision = 2 ) const;
|
|
};
|
|
|
|
ID_INLINE idCQuat::idCQuat()
|
|
{
|
|
}
|
|
|
|
ID_INLINE idCQuat::idCQuat( float x, float y, float z )
|
|
{
|
|
this->x = x;
|
|
this->y = y;
|
|
this->z = z;
|
|
}
|
|
|
|
ID_INLINE void idCQuat::Set( float x, float y, float z )
|
|
{
|
|
this->x = x;
|
|
this->y = y;
|
|
this->z = z;
|
|
}
|
|
|
|
ID_INLINE float idCQuat::operator[]( int index ) const
|
|
{
|
|
assert( ( index >= 0 ) && ( index < 3 ) );
|
|
return ( &x )[ index ];
|
|
}
|
|
|
|
ID_INLINE float& idCQuat::operator[]( int index )
|
|
{
|
|
assert( ( index >= 0 ) && ( index < 3 ) );
|
|
return ( &x )[ index ];
|
|
}
|
|
|
|
ID_INLINE bool idCQuat::Compare( const idCQuat& a ) const
|
|
{
|
|
return ( ( x == a.x ) && ( y == a.y ) && ( z == a.z ) );
|
|
}
|
|
|
|
ID_INLINE bool idCQuat::Compare( const idCQuat& a, const float epsilon ) const
|
|
{
|
|
if( idMath::Fabs( x - a.x ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
if( idMath::Fabs( y - a.y ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
if( idMath::Fabs( z - a.z ) > epsilon )
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ID_INLINE bool idCQuat::operator==( const idCQuat& a ) const
|
|
{
|
|
return Compare( a );
|
|
}
|
|
|
|
ID_INLINE bool idCQuat::operator!=( const idCQuat& a ) const
|
|
{
|
|
return !Compare( a );
|
|
}
|
|
|
|
ID_INLINE int idCQuat::GetDimension() const
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
ID_INLINE idQuat idCQuat::ToQuat() const
|
|
{
|
|
// take the absolute value because floating point rounding may cause the dot of x,y,z to be larger than 1
|
|
return idQuat( x, y, z, sqrt( fabs( 1.0f - ( x * x + y * y + z * z ) ) ) );
|
|
}
|
|
|
|
ID_INLINE const float* idCQuat::ToFloatPtr() const
|
|
{
|
|
return &x;
|
|
}
|
|
|
|
ID_INLINE float* idCQuat::ToFloatPtr()
|
|
{
|
|
return &x;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
Specialization to get size of an idCQuat generically.
|
|
|
|
===============================================================================
|
|
*/
|
|
template<>
|
|
struct idTupleSize< idCQuat >
|
|
{
|
|
enum { value = 3 };
|
|
};
|
|
|
|
#endif /* !__MATH_QUAT_H__ */
|