mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
338 lines
6.3 KiB
C++
338 lines
6.3 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../precompiled.h"
|
|
|
|
/*
|
|
=====================
|
|
idQuat::ToAngles
|
|
=====================
|
|
*/
|
|
idAngles idQuat::ToAngles() const
|
|
{
|
|
return ToMat3().ToAngles();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idQuat::ToRotation
|
|
=====================
|
|
*/
|
|
idRotation idQuat::ToRotation() const
|
|
{
|
|
idVec3 vec;
|
|
float angle;
|
|
|
|
vec.x = x;
|
|
vec.y = y;
|
|
vec.z = z;
|
|
angle = idMath::ACos( w );
|
|
if( angle == 0.0f )
|
|
{
|
|
vec.Set( 0.0f, 0.0f, 1.0f );
|
|
}
|
|
else
|
|
{
|
|
//vec *= (1.0f / sin( angle ));
|
|
vec.Normalize();
|
|
vec.FixDegenerateNormal();
|
|
angle *= 2.0f * idMath::M_RAD2DEG;
|
|
}
|
|
return idRotation( vec3_origin, vec, angle );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idQuat::ToMat3
|
|
=====================
|
|
*/
|
|
idMat3 idQuat::ToMat3() const
|
|
{
|
|
idMat3 mat;
|
|
float wx, wy, wz;
|
|
float xx, yy, yz;
|
|
float xy, xz, zz;
|
|
float x2, y2, z2;
|
|
|
|
x2 = x + x;
|
|
y2 = y + y;
|
|
z2 = z + z;
|
|
|
|
xx = x * x2;
|
|
xy = x * y2;
|
|
xz = x * z2;
|
|
|
|
yy = y * y2;
|
|
yz = y * z2;
|
|
zz = z * z2;
|
|
|
|
wx = w * x2;
|
|
wy = w * y2;
|
|
wz = w * z2;
|
|
|
|
mat[ 0 ][ 0 ] = 1.0f - ( yy + zz );
|
|
mat[ 0 ][ 1 ] = xy - wz;
|
|
mat[ 0 ][ 2 ] = xz + wy;
|
|
|
|
mat[ 1 ][ 0 ] = xy + wz;
|
|
mat[ 1 ][ 1 ] = 1.0f - ( xx + zz );
|
|
mat[ 1 ][ 2 ] = yz - wx;
|
|
|
|
mat[ 2 ][ 0 ] = xz - wy;
|
|
mat[ 2 ][ 1 ] = yz + wx;
|
|
mat[ 2 ][ 2 ] = 1.0f - ( xx + yy );
|
|
|
|
return mat;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idQuat::ToMat4
|
|
=====================
|
|
*/
|
|
idMat4 idQuat::ToMat4() const
|
|
{
|
|
return ToMat3().ToMat4();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idQuat::ToCQuat
|
|
=====================
|
|
*/
|
|
idCQuat idQuat::ToCQuat() const
|
|
{
|
|
if( w < 0.0f )
|
|
{
|
|
return idCQuat( -x, -y, -z );
|
|
}
|
|
return idCQuat( x, y, z );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idQuat::ToAngularVelocity
|
|
============
|
|
*/
|
|
idVec3 idQuat::ToAngularVelocity() const
|
|
{
|
|
idVec3 vec;
|
|
|
|
vec.x = x;
|
|
vec.y = y;
|
|
vec.z = z;
|
|
vec.Normalize();
|
|
return vec * idMath::ACos( w );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idQuat::ToString
|
|
=============
|
|
*/
|
|
const char* idQuat::ToString( int precision ) const
|
|
{
|
|
return idStr::FloatArrayToString( ToFloatPtr(), GetDimension(), precision );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idQuat::Slerp
|
|
|
|
Spherical linear interpolation between two quaternions.
|
|
=====================
|
|
*/
|
|
idQuat& idQuat::Slerp( const idQuat& from, const idQuat& to, float t )
|
|
{
|
|
idQuat temp;
|
|
float omega, cosom, sinom, scale0, scale1;
|
|
|
|
if( t <= 0.0f )
|
|
{
|
|
*this = from;
|
|
return *this;
|
|
}
|
|
|
|
if( t >= 1.0f )
|
|
{
|
|
*this = to;
|
|
return *this;
|
|
}
|
|
|
|
if( from == to )
|
|
{
|
|
*this = to;
|
|
return *this;
|
|
}
|
|
|
|
cosom = from.x * to.x + from.y * to.y + from.z * to.z + from.w * to.w;
|
|
if( cosom < 0.0f )
|
|
{
|
|
temp = -to;
|
|
cosom = -cosom;
|
|
}
|
|
else
|
|
{
|
|
temp = to;
|
|
}
|
|
|
|
if( ( 1.0f - cosom ) > 1e-6f )
|
|
{
|
|
#if 0
|
|
omega = acos( cosom );
|
|
sinom = 1.0f / sin( omega );
|
|
scale0 = sin( ( 1.0f - t ) * omega ) * sinom;
|
|
scale1 = sin( t * omega ) * sinom;
|
|
#else
|
|
scale0 = 1.0f - cosom * cosom;
|
|
sinom = idMath::InvSqrt( scale0 );
|
|
omega = idMath::ATan16( scale0 * sinom, cosom );
|
|
scale0 = idMath::Sin16( ( 1.0f - t ) * omega ) * sinom;
|
|
scale1 = idMath::Sin16( t * omega ) * sinom;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
scale0 = 1.0f - t;
|
|
scale1 = t;
|
|
}
|
|
|
|
*this = ( scale0 * from ) + ( scale1 * temp );
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idQuat::Lerp
|
|
|
|
Approximation of spherical linear interpolation between two quaternions. The interpolation
|
|
traces out the exact same curve as Slerp but does not maintain a constant speed across the arc.
|
|
========================
|
|
*/
|
|
idQuat& idQuat::Lerp( const idQuat& from, const idQuat& to, const float t )
|
|
{
|
|
if( t <= 0.0f )
|
|
{
|
|
*this = from;
|
|
return *this;
|
|
}
|
|
|
|
if( t >= 1.0f )
|
|
{
|
|
*this = to;
|
|
return *this;
|
|
}
|
|
|
|
if( from == to )
|
|
{
|
|
*this = to;
|
|
return *this;
|
|
}
|
|
|
|
float cosom = from.x * to.x + from.y * to.y + from.z * to.z + from.w * to.w;
|
|
|
|
float scale0 = 1.0f - t;
|
|
float scale1 = ( cosom >= 0.0f ) ? t : -t;
|
|
|
|
x = scale0 * from.x + scale1 * to.x;
|
|
y = scale0 * from.y + scale1 * to.y;
|
|
z = scale0 * from.z + scale1 * to.z;
|
|
w = scale0 * from.w + scale1 * to.w;
|
|
|
|
float s = idMath::InvSqrt( x * x + y * y + z * z + w * w );
|
|
|
|
x *= s;
|
|
y *= s;
|
|
z *= s;
|
|
w *= s;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idCQuat::ToAngles
|
|
=============
|
|
*/
|
|
idAngles idCQuat::ToAngles() const
|
|
{
|
|
return ToQuat().ToAngles();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idCQuat::ToRotation
|
|
=============
|
|
*/
|
|
idRotation idCQuat::ToRotation() const
|
|
{
|
|
return ToQuat().ToRotation();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idCQuat::ToMat3
|
|
=============
|
|
*/
|
|
idMat3 idCQuat::ToMat3() const
|
|
{
|
|
return ToQuat().ToMat3();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idCQuat::ToMat4
|
|
=============
|
|
*/
|
|
idMat4 idCQuat::ToMat4() const
|
|
{
|
|
return ToQuat().ToMat4();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
idCQuat::ToString
|
|
=============
|
|
*/
|
|
const char* idCQuat::ToString( int precision ) const
|
|
{
|
|
return idStr::FloatArrayToString( ToFloatPtr(), GetDimension(), precision );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
Slerp
|
|
|
|
Spherical linear interpolation between two quaternions.
|
|
=====================
|
|
*/
|
|
idQuat Slerp( const idQuat& from, const idQuat& to, const float t )
|
|
{
|
|
return idQuat().Slerp( from, to, t );
|
|
}
|