From ab074726df69a50a75f58116cbf50a63d107cf91 Mon Sep 17 00:00:00 2001 From: curt Date: Wed, 18 Sep 2002 18:47:47 +0000 Subject: [PATCH] Removed unnecessary files. --- .../clouds3d/SkyRenderableInstanceGeneric.cpp | 136 --- simgear/scene/sky/clouds3d/quat.hpp | 166 ---- simgear/scene/sky/clouds3d/quatimpl.hpp | 886 ------------------ simgear/scene/sky/clouds3d/quattest.cpp | 196 ---- 4 files changed, 1384 deletions(-) delete mode 100644 simgear/scene/sky/clouds3d/SkyRenderableInstanceGeneric.cpp delete mode 100644 simgear/scene/sky/clouds3d/quat.hpp delete mode 100644 simgear/scene/sky/clouds3d/quatimpl.hpp delete mode 100644 simgear/scene/sky/clouds3d/quattest.cpp diff --git a/simgear/scene/sky/clouds3d/SkyRenderableInstanceGeneric.cpp b/simgear/scene/sky/clouds3d/SkyRenderableInstanceGeneric.cpp deleted file mode 100644 index 7a9c3bb7..00000000 --- a/simgear/scene/sky/clouds3d/SkyRenderableInstanceGeneric.cpp +++ /dev/null @@ -1,136 +0,0 @@ -//------------------------------------------------------------------------------ -// File : SkyRenderableInstanceGeneric.cpp -//------------------------------------------------------------------------------ -// SkyWorks : Copyright 2002 Mark J. Harris and -// The University of North Carolina at Chapel Hill -//------------------------------------------------------------------------------ -// Permission to use, copy, modify, distribute and sell this software and its -// documentation for any purpose is hereby granted without fee, provided that -// the above copyright notice appear in all copies and that both that copyright -// notice and this permission notice appear in supporting documentation. -// Binaries may be compiled with this software without any royalties or -// restrictions. -// -// The author(s) and The University of North Carolina at Chapel Hill make no -// representations about the suitability of this software for any purpose. -// It is provided "as is" without express or -// implied warranty. -/** - * @file SkyRenderableInstanceGeneric.cpp - * - * A basic implementation of SkyRenderableInstance - */ - -#include "glvu.hpp" -#include "SkyUtil.hpp" -#include "SkyRenderable.hpp" -#include "SkyMinMaxBox.hpp" -#include "SkyRenderableInstanceGeneric.hpp" - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric(SkyRenderable *object) - * @brief Constructor, store the renderable and set the position to identity - */ -SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric(SkyRenderable *pObject) -: SkyRenderableInstance(), - _pObj(pObject) -{ - _pBV = pObject->CopyBoundingVolume(); -} - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric(SkyRenderable *object, const Vec3f &position, const Mat33f &rotation, const float scale) - * @brief Constructor, stores the instance information given - */ -SkyRenderableInstanceGeneric::SkyRenderableInstanceGeneric(SkyRenderable *pObject, - const Vec3f &position, - const Mat33f &rotation, - const float scale) -: SkyRenderableInstance(position, rotation, scale), - _pObj(pObject) -{ - _pBV = pObject->CopyBoundingVolume(); -} - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::~SkyRenderableInstanceGeneric -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::~SkyRenderableInstanceGeneric() - * @brief Destructor - */ -SkyRenderableInstanceGeneric::~SkyRenderableInstanceGeneric() -{ - _pObj = NULL; - SAFE_DELETE(_pBV); -} - - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::SetRenderable -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::SetRenderable(SkyRenderable *pRenderable) - * @brief Set the renderable for this instance. - */ -void SkyRenderableInstanceGeneric::SetRenderable(SkyRenderable *pRenderable) -{ - _pObj = pRenderable; - SAFE_DELETE(_pBV); - _pBV = pRenderable->CopyBoundingVolume(); -} - - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::Display -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::Display() - * @brief Displays the instance by calling the renderable's display function - */ -SKYRESULT SkyRenderableInstanceGeneric::Display() -{ - // Get and set the world space transformation - Mat44f mat; - GetModelToWorldTransform(mat); - - glMatrixMode(GL_MODELVIEW); - glPushMatrix(); - glMultMatrixf(mat.M); - - //FAIL_RETURN_MSG(_pObj->Display(*(GLVU::GetCurrent()->GetCurrentCam()), this), - // "SkyRenderableInstanceGeneric:Display(), error returned from object's display"); - - glMatrixMode(GL_MODELVIEW); - glPopMatrix(); - - return SKYRESULT_OK; -} - - -//------------------------------------------------------------------------------ -// Function : SkyRenderableInstanceGeneric::ViewFrustumCull -// Description : -//------------------------------------------------------------------------------ -/** - * @fn SkyRenderableInstanceGeneric::ViewFrustumCull(const Camera &cam) - * @brief View frustum cull the object given its world position - */ -bool SkyRenderableInstanceGeneric::ViewFrustumCull(const Camera &cam) -{ - Mat44f xform; - GetModelToWorldTransform(xform); - _bCulled = (_pBV == NULL) ? false : _pBV->ViewFrustumCull(cam, xform); - return _bCulled; -} diff --git a/simgear/scene/sky/clouds3d/quat.hpp b/simgear/scene/sky/clouds3d/quat.hpp deleted file mode 100644 index 6d8098b1..00000000 --- a/simgear/scene/sky/clouds3d/quat.hpp +++ /dev/null @@ -1,166 +0,0 @@ -//------------------------------------------------------------------------------ -// File : quat.hpp -//------------------------------------------------------------------------------ -// GLVU : Copyright 1997 - 2002 -// The University of North Carolina at Chapel Hill -//------------------------------------------------------------------------------ -// Permission to use, copy, modify, distribute and sell this software and its -// documentation for any purpose is hereby granted without fee, provided that -// the above copyright notice appear in all copies and that both that copyright -// notice and this permission notice appear in supporting documentation. -// Binaries may be compiled with this software without any royalties or -// restrictions. -// -// The University of North Carolina at Chapel Hill makes no representations -// about the suitability of this software for any purpose. It is provided -// "as is" without express or implied warranty. - -/************************************************************************** - - quat.hpp - - A quaternion template class - - --------------------------------------------------------------------- - - Feb 1998, Paul Rademacher (rademach@cs.unc.edu) - - Modification History: - - Oct 2000, Bill Baxter. Adapted to GLVU coding conventions and - templetized. Also implemented many methods that were declared but - not defined. Added some methods from quatlib and other sources. - -**************************************************************************/ - -#ifndef _QUAT_H_ -#define _QUAT_H_ - -#include "vec3f.hpp" -#include "mat44.hpp" -#include "mat33.hpp" - -/**************************************************************** -* Quaternion * -****************************************************************/ - -template -class Quat -{ -public: - typedef Vec3 qvec; - - Type s; /* scalar component */ - qvec v; /* quat vector component */ - - /* Constructors */ - - Quat(void); - Quat(Type s, Type x, Type y, Type z); - Quat(Type x, Type y, Type z); // s=0 - Quat(Type s, const qvec& v); - Quat(const qvec& v, Type s = 0.0); - Quat(const Type *d); /* copy from four-element Type array s,x,y,z */ - Quat(const Quat &q); /* copy from other Quat */ - - /* Setters */ - - void Set( Type x, Type y, Type z ); - void Set( Type s, Type x, Type y, Type z ); - void Set( Type s, const qvec& v ); - void Set( const qvec& v, Type s=0 ); - - /* Operators */ - - Quat &operator = ( const Quat &v ); /* assignment of a Quat */ - Quat &operator += ( const Quat &v ); /* incrementation by a Quat */ - Quat &operator -= ( const Quat &v ); /* decrementation by a Quat */ - Quat &operator *= ( const Type d ); /* multiplication by a scalar */ - Quat &operator *= ( const Quat &v ); /* quat product (this*v) */ - Quat &operator /= ( const Type d ); /* division by a scalar */ - Type &operator [] ( int i); /* indexing s=0,x=1,y=2,z=3 */ - - /* special functions */ - - Type Length(void) const; /* length of a Quat */ - Type LengthSqr(void) const; /* squared length of a Quat */ - Type Norm(void) const; /* also squared length of a Quat */ - Quat &Normalize(void); /* normalize a Quat */ - Quat &Invert(void); /* q = q^-1 */ - Quat &Conjugate(void); /* q = q* */ - qvec Xform( const qvec &v ) const; /* q*v*q-1 */ - Quat &Log(void); /* log(q) */ - Quat &Exp(void); /* exp(q) */ - qvec GetAxis( void ) const; /* Get rot axis */ - Type GetAngle( void ) const; /* Get rot angle (radians) */ - void SetAngle( Type rad_ang ); /* set rot angle (radians) */ - void ScaleAngle( Type f ); /* scale rot angle */ - void Print( ) const; /* print Quat */ - - /* Conversions */ - Mat44& ToMat( Mat44 &dest ) const; /* to 4x4 matrix */ - Mat33& ToMat( Mat33 &dest ) const; /* to 3x3 matrix */ - Quat& FromMat( const Mat44& src ); /* from 4x4 rot matrix */ - Quat& FromMat( const Mat33& src ); /* from 3x3 rot matrix */ - - void ToAngleAxis( Type &ang, qvec &ax ) const; /* to rot angle AND axis */ - Quat& FromAngleAxis( Type ang, const qvec &ax );/*from rot angle AND axis */ - Quat& FromTwoVecs(const qvec &a, const qvec& b); /* quat from a to b */ - // to/from Euler Angles (XYZ-Fixed/ZYX-Relative, angles in radians) - // See quatimpl.hpp for more detailed comments. - Quat& FromEuler( Type yaw_Z, Type pitch_Y, Type roll_X); - void ToEuler(Type &yaw_Z, Type &pitch_Y, Type &roll_X) const; - - - // HELPERS - static Type DEG2RAD(Type d); - static Type RAD2DEG(Type d); - static Type Sin(double d); - static Type Cos(double d); - static Type ACos(double d); - static Type ASin(double d); - static Type ATan(double d); - static Type ATan2(double n, double d); - - // CONSTANTS - static Type FUDGE(); - static Quat ZERO(); - static Quat IDENTITY(); -}; - -/* Utility functions */ -template -Quat& QuatSlerp( - Quat &dest, const Quat& from, const Quat& to, Type t ); -template -Quat QuatSlerp(const Quat& from, const Quat& to, Type t ); - -/* "Friends" */ -template -Quat operator -(const Quat &v); // -q1 -template -Quat operator +(const Quat &a, const Quat &b); // q1 + q2 -template -Quat operator -(const Quat &a, const Quat &b); // q1 - q2 -template -Quat operator *(const Quat &a, const Type d); // q1 * 3.0 -template -Quat operator *(const Type d, const Quat &a); // 3.0 * q1 -template -Quat operator *(const Quat &a, const Quat &b); // q1 * q2 -template -Quat operator /(const Quat &a, const Type d); // q1 / 3.0 -template -bool operator ==(const Quat &a, const Quat &b); // q1 == q2 ? -template -bool operator !=(const Quat &a, const Quat &b); // q1 != q2 ? - - - -#include "quatimpl.hpp" - - - -typedef Quat Quatf; -typedef Quat Quatd; - -#endif diff --git a/simgear/scene/sky/clouds3d/quatimpl.hpp b/simgear/scene/sky/clouds3d/quatimpl.hpp deleted file mode 100644 index 0d6fb560..00000000 --- a/simgear/scene/sky/clouds3d/quatimpl.hpp +++ /dev/null @@ -1,886 +0,0 @@ -//------------------------------------------------------------------------------ -// File : quatimpl.hpp -//------------------------------------------------------------------------------ -// GLVU : Copyright 1997 - 2002 -// The University of North Carolina at Chapel Hill -//------------------------------------------------------------------------------ -// Permission to use, copy, modify, distribute and sell this software and its -// documentation for any purpose is hereby granted without fee, provided that -// the above copyright notice appear in all copies and that both that copyright -// notice and this permission notice appear in supporting documentation. -// Binaries may be compiled with this software without any royalties or -// restrictions. -// -// The University of North Carolina at Chapel Hill makes no representations -// about the suitability of this software for any purpose. It is provided -// "as is" without express or implied warranty. - -/*********************************************************************** - - quatimpl.hpp - - A quaternion template class - - ------------------------------------------------------------------- - - Feb 1998, Paul Rademacher (rademach@cs.unc.edu) - Oct 2000, Bill Baxter - - Modification History: - - See main header file, quat.hpp - -************************************************************************/ - -#include "quat.hpp" -#include -#include - - -//============================================================================ -// CONSTRUCTORS -//============================================================================ - -template -Quat::Quat( void ) -{ - // do nothing so default construction is fast -} - -template -Quat::Quat( Type _s, Type x, Type y, Type z ) -{ - s = _s; - v.Set( x, y, z ); -} -template -Quat::Quat( Type x, Type y, Type z ) -{ - s = 0.0; - v.Set( x, y, z ); -} - -template -Quat::Quat( const qvec& _v, Type _s ) -{ - Set( _v, _s ); -} - -template -Quat::Quat( Type _s, const qvec& _v ) -{ - Set( _v, _s ); -} - - -template -Quat::Quat( const Type *d ) -{ - s = *d++; - v.Set(d); -} - -template -Quat::Quat( const Quat &q ) -{ - s = q.s; - v = q.v; -} - -//============================================================================ -// SETTERS -//============================================================================ - -template -void Quat::Set( Type _s, Type x, Type y, Type z ) -{ - s = _s; - v.Set(x,y,z); -} -template -void Quat::Set( Type x, Type y, Type z ) -{ - s = 0.0; - v.Set(x,y,z); -} - -template -void Quat::Set( const qvec& _v, Type _s ) -{ - s = _s; - v = _v; -} -template -void Quat::Set( Type _s, const qvec& _v ) -{ - s = _s; - v = _v; -} - - -//============================================================================ -// OPERATORS -//============================================================================ - -template -Quat& Quat::operator = (const Quat& q) -{ - v = q.v; s = q.s; return *this; -} - -template -Quat& Quat::operator += ( const Quat &q ) -{ - v += q.v; s += q.s; return *this; -} - -template -Quat& Quat::operator -= ( const Quat &q ) -{ - v -= q.v; s -= q.s; return *this; -} - -template -Quat &Quat::operator *= ( const Type d ) -{ - v *= d; s *= d; return *this; -} - -template -Quat &Quat::operator *= ( const Quat& q ) -{ -#if 0 - // Quaternion multiplication with - // temporary object construction minimized (hopefully) - Type ns = s*q.s - v*q.v; - qvec nv(v^q.v); - v *= q.s; - v += nv; - nv.Set(s*q.v); - v += nv; - s = ns; - return *this; -#else - // optimized (12 mults, and no compiler-generated temp objects) - Type A, B, C, D, E, F, G, H; - - A = (s + v.x)*(q.s + q.v.x); - B = (v.z - v.y)*(q.v.y - q.v.z); - C = (s - v.x)*(q.v.y + q.v.z); - D = (v.y + v.z)*(q.s - q.v.x); - E = (v.x + v.z)*(q.v.x + q.v.y); - F = (v.x - v.z)*(q.v.x - q.v.y); - G = (s + v.y)*(q.s - q.v.z); - H = (s - v.y)*(q.s + q.v.z); - - v.x = A - (E + F + G + H) * Type(0.5); - v.y = C + (E - F + G - H) * Type(0.5); - v.z = D + (E - F - G + H) * Type(0.5); - s = B + (-E - F + G + H) * Type(0.5); - - return *this; -#endif -} - -template -Quat &Quat::operator /= ( const Type d ) -{ - Type r = Type(1.0)/d; - v *= r; - s *= r; - return *this; -} - -template -Type &Quat::operator [] ( int i) -{ - switch (i) { - case 0: return s; - case 1: return v.x; - case 2: return v.y; - case 3: return v.z; - } - assert(false); - return s; -} - -//============================================================================ -// SPECIAL FUNCTIONS -//============================================================================ -template -inline Type Quat::Length( void ) const -{ - return Type( sqrt( v*v + s*s ) ); -} - -template -inline Type Quat::LengthSqr( void ) const -{ - return Norm(); -} - -template -inline Type Quat::Norm( void ) const -{ - return v*v + s*s; -} - -template -inline Quat& Quat::Normalize( void ) -{ - *this *= Type(1.0) / Type(sqrt(v*v + s*s)); - return *this; -} - -template -inline Quat& Quat::Invert( void ) -{ - Type scale = Type(1.0)/Norm(); - v *= -scale; - s *= scale; - return *this; -} - -template -inline Quat& Quat::Conjugate( void ) -{ - v.x = -v.x; - v.y = -v.y; - v.z = -v.z; - return *this; -} - - -//---------------------------------------------------------------------------- -// Xform -//---------------------------------------------------------------------------- -// Transform a vector by this quaternion using q * v * q^-1 -//---------------------------------------------------------------------------- -template -Quat::qvec Quat::Xform( const qvec &vec ) const -{ - /* copy vector into temp quaternion for multiply */ - Quat vecQuat(vec); - /* invert multiplier */ - Quat inverse(*this); - inverse.Invert(); - - /* do q * vec * q(inv) */ - Quat tempVecQuat(*this * vecQuat); - tempVecQuat *= inverse; - - /* return vector part */ - return tempVecQuat.v; -} - -//---------------------------------------------------------------------------- -// Log -//---------------------------------------------------------------------------- -// Natural log of quat -//---------------------------------------------------------------------------- -template -Quat &Quat::Log(void) -{ - Type theta, scale; - - scale = v.Length(); - theta = ATan2(scale, s); - - if (scale > 0.0) - scale = theta/scale; - - v *= scale; - s = 0.0; - return *this; -} - -//---------------------------------------------------------------------------- -// Exp -//---------------------------------------------------------------------------- -// e to the quat: e^quat -// -- assuming scalar part 0 -//---------------------------------------------------------------------------- -template -Quat &Quat::Exp(void) -{ - Type scale; - Type theta = v.Length(); - - if (theta > FUDGE()) { - scale = Sin(theta)/theta ; - v *= scale; - } - - s = Cos(theta) ; - return *this; -} - - -//---------------------------------------------------------------------------- -// SetAngle (radians) -//---------------------------------------------------------------------------- -template -void Quat::SetAngle( Type f ) -{ - qvec axis(GetAxis()); - f *= Type(0.5); - s = Cos( f ); - v = axis * Sin( f ); -} - -//---------------------------------------------------------------------------- -// ScaleAngle -//---------------------------------------------------------------------------- -template -inline void Quat::ScaleAngle( Type f ) -{ - SetAngle( f * GetAngle() ); -} - -//---------------------------------------------------------------------------- -// GetAngle (radians) -//---------------------------------------------------------------------------- -// get rot angle in radians. Assumes s is between -1 and 1, which will always -// be the case for unit quaternions. -//---------------------------------------------------------------------------- -template -inline Type Quat::GetAngle( void ) const -{ - return ( Type(2.0) * ACos( s ) ); -} - -//---------------------------------------------------------------------------- -// GetAxis -//---------------------------------------------------------------------------- -template -Quat::qvec Quat::GetAxis( void ) const -{ - Type scale; - - scale = Sin( acos( s ) ) ; - if ( scale < FUDGE() && scale > -FUDGE() ) - return qvec( 0.0, 0.0, 0.0 ); - else - return v / scale; -} - -//---------------------------------------------------------------------------- -// Print -//---------------------------------------------------------------------------- -template -inline void Quat::Print( ) const -{ - printf( "(%3.2f, <%3.2f %3.2f %3.2f>)\n", s, v.x, v.y, v.z ); -} - - -//============================================================================ -// CONVERSIONS -//============================================================================ - -template -Mat44& Quat::ToMat( Mat44& dest ) const -{ - Type t, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz; - qvec a, c, b, d; - - t = Type(2.0) / (v*v + s*s); - const Type ONE(1.0); - - xs = v.x*t; ys = v.y*t; zs = v.z*t; - wx = s*xs; wy = s*ys; wz = s*zs; - xx = v.x*xs; xy = v.x*ys; xz = v.x*zs; - yy = v.y*ys; yz = v.y*zs; zz = v.z*zs; - - dest.Set( ONE-(yy+zz), xy-wz, xz+wy, 0.0, - xy+wz, ONE-(xx+zz), yz-wx, 0.0, - xz-wy, yz+wx, ONE-(xx+yy), 0.0, - 0.0, 0.0, 0.0, ONE ); - - return dest; -} - -template -Mat33& Quat::ToMat( Mat33& dest ) const -{ - Type t, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz; - qvec a, c, b, d; - - t = Type(2.0) / Norm(); - const Type ONE(1.0); - - xs = v.x*t; ys = v.y*t; zs = v.z*t; - wx = s*xs; wy = s*ys; wz = s*zs; - xx = v.x*xs; xy = v.x*ys; xz = v.x*zs; - yy = v.y*ys; yz = v.y*zs; zz = v.z*zs; - - dest.Set( ONE-(yy+zz), xy-wz, xz+wy, - xy+wz, ONE-(xx+zz), yz-wx, - xz-wy, yz+wx, ONE-(xx+yy) ); - - return dest; -} - -//---------------------------------------------------------------------------- -// FromMat -//---------------------------------------------------------------------------- -// Convert rotation matrix to quaternion -// Results will be bad if matrix is not (very close to) orthonormal -// Modified from gamasutra.com article: -// http://www.gamasutra.com/features/programming/19980703/quaternions_07.htm -//---------------------------------------------------------------------------- -template -Quat& Quat::FromMat( const Mat44& m ) -{ - Type tr = m.Trace(); - - // check the diagonal - if (tr > 0.0) { - Type scale = Type( sqrt (tr) ); - s = scale * Type(0.5); - scale = Type(0.5) / scale; - v.x = (m(1,2) - m(2,1)) * scale; - v.y = (m(2,0) - m(0,2)) * scale; - v.z = (m(0,1) - m(1,0)) * scale; - } else { - // diagonal is negative or zero - int i, j, k; - i = 0; - if (m(1,1) > m(0,0)) i = 1; - if (m(2,2) > m(i,i)) i = 2; - int nxt[3] = {1, 2, 0}; - j = nxt[i]; - k = nxt[j]; - - Type scale = Type( sqrt (Type(1.0) + m(i,i) - (m(j,j) + m(k,k)) ) ); - - v[i] = scale * Type(0.5); - - if (scale != 0.0) scale = Type(0.5) / scale; - - s = (m(j,k) - m(k,j)) * scale; - v[j] = (m(i,j) + m(j,i)) * scale; - v[k] = (m(i,k) + m(k,i)) * scale; - } - return *this; -} - -template -Quat& Quat::FromMat( const Mat33& m ) -{ - Type tr = m.Trace(); - - // check the diagonal - if (tr > 0.0) { - Type scale = Type( sqrt (tr + Type(1.0)) ); - s = scale * Type(0.5); - scale = Type(0.5) / scale; - v.x = (m(1,2) - m(2,1)) * scale; - v.y = (m(2,0) - m(0,2)) * scale; - v.z = (m(0,1) - m(1,0)) * scale; - } else { - // diagonal is negative or zero - int i, j, k; - i = 0; - if (m(1,1) > m(0,0)) i = 1; - if (m(2,2) > m(i,i)) i = 2; - int nxt[3] = {1, 2, 0}; - j = nxt[i]; - k = nxt[j]; - - Type scale = Type( sqrt (Type(1.0) + m(i,i) - (m(j,j) + m(k,k)) ) ); - - v[i] = scale * Type(0.5); - - if (scale != 0.0) scale = Type(0.5) / scale; - - s = (m(j,k) - m(k,j)) * scale; - v[j] = (m(i,j) + m(j,i)) * scale; - v[k] = (m(i,k) + m(k,i)) * scale; - } - return *this; -} - -//---------------------------------------------------------------------------- -// ToAngleAxis (radians) -//---------------------------------------------------------------------------- -// Convert to angle & axis representation -//---------------------------------------------------------------------------- -template -void Quat::ToAngleAxis( Type &angle, qvec &axis ) const -{ - Type cinv = ACos( s ); - angle = Type(2.0) * cinv; - - Type scale; - - scale = Sin( cinv ); - if ( scale < FUDGE() && scale > -FUDGE() ) - axis = qvec::ZERO; - else { - axis = v; - axis /= scale; - } -} - -//---------------------------------------------------------------------------- -// FromAngleAxis (radians) -//---------------------------------------------------------------------------- -// Convert to quat from angle & axis representation -//---------------------------------------------------------------------------- -template -Quat& Quat::FromAngleAxis( Type angle, const qvec &axis ) -{ - /* normalize vector */ - Type length = axis.Length(); - - /* if zero vector passed in, just set to identity quaternion */ - if ( length < FUDGE() ) - { - *this = IDENTITY(); - return *this; - } - length = Type(1.0)/length; - angle *= 0.5; - v = axis; - v *= length; - v *= Sin(angle); - - s = Cos(angle); - return *this; -} - -//---------------------------------------------------------------------------- -// FromTwoVecs -//---------------------------------------------------------------------------- -// Return the quat that rotates vector a into vector b -//---------------------------------------------------------------------------- -template -Quat& Quat::FromTwoVecs(const qvec &a, const qvec& b) -{ - qvec u1(a); - qvec u2(b); - double theta ; /* angle of rotation about axis */ - double theta_complement ; - double crossProductMagnitude ; - - - // Normalize both vectors and take cross product to get rotation axis. - u1.Normalize(); - u2.Normalize(); - qvec axis( u1 ^ u2 ); - - - // | u1 X u2 | = |u1||u2|sin(theta) - // - // Since u1 and u2 are normalized, - // - // theta = arcsin(|axis|) - crossProductMagnitude = axis.Length(); - - // Occasionally, even though the vectors are normalized, the - // magnitude will be calculated to be slightly greater than one. If - // this happens, just set it to 1 or asin() will barf. - if( crossProductMagnitude > Type(1.0) ) - crossProductMagnitude = Type(1.0) ; - - // Take arcsin of magnitude of rotation axis to compute rotation - // angle. Since crossProductMagnitude=[0,1], we will have - // theta=[0,pi/2]. - theta = ASin( crossProductMagnitude ) ; - theta_complement = Type(3.14159265358979323846) - theta ; - - // If cos(theta) < 0, use complement of theta as rotation angle. - if( u1 * u2 < 0.0 ) - { - double tmp = theta; - theta = theta_complement ; - theta_complement = tmp; - } - - // if angle is 0, just return identity quaternion - if( theta < FUDGE() ) - { - *this = IDENTITY(); - } - else - { - if( theta_complement < FUDGE() ) - { - // The two vectors are opposed. Find some arbitrary axis vector. - // First try cross product with x-axis if u1 not parallel to x-axis. - if( (u1.y*u1.y + u1.z*u1.z) >= FUDGE() ) - { - axis.Set( 0.0, u1.z, -u1.y ) ; - } - else - { - // u1 is parallel to to x-axis. Use z-axis as axis of rotation. - axis.Set(0.0, 0.0, 1.0); - } - } - - axis.Normalize(); - FromAngleAxis(Type(theta), axis); - Normalize(); - } - return *this; -} - -//---------------------------------------------------------------------------- -// FromEuler -//---------------------------------------------------------------------------- -// converts 3 euler angles (in radians) to a quaternion -// -// angles are in radians; Assumes roll is rotation about X, pitch is -// rotation about Y, yaw is about Z. (So thinking of -// Z as up) Assumes order of yaw, pitch, roll applied as follows: -// -// p' = roll( pitch( yaw(p) ) ) -// -// Where yaw, pitch, and roll are defined in the BODY coordinate sys. -// In other words these are ZYX-relative (or XYZ-fixed) Euler Angles. -// -// For a complete Euler angle implementation that handles all 24 angle -// sets, see "Euler Angle Conversion" by Ken Shoemake, in "Graphics -// Gems IV", Academic Press, 1994 -//---------------------------------------------------------------------------- -template -Quat& Quat::FromEuler(Type yaw, Type pitch, Type roll) -{ - Type cosYaw, sinYaw, cosPitch, sinPitch, cosRoll, sinRoll; - Type half_roll, half_pitch, half_yaw; - - /* put angles into radians and divide by two, since all angles in formula - * are (angle/2) - */ - const Type HALF(0.5); - half_yaw = yaw * HALF; - half_pitch = pitch * HALF; - half_roll = roll * HALF; - - cosYaw = Cos(half_yaw); - sinYaw = Sin(half_yaw); - - cosPitch = Cos(half_pitch); - sinPitch = Sin(half_pitch); - - cosRoll = Cos(half_roll); - sinRoll = Sin(half_roll); - - Type cpcy = cosPitch * cosYaw; - Type spsy = sinPitch * sinYaw; - - v.x = sinRoll * cpcy - cosRoll * spsy; - v.y = cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw; - v.z = cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw; - s = cosRoll * cpcy + sinRoll * spsy; - - return *this; -} - -//---------------------------------------------------------------------------- -// ToEuler -//---------------------------------------------------------------------------- -// converts a quaternion to 3 euler angles (in radians) -// -// See FromEuler for details of which set of Euler Angles are returned -//---------------------------------------------------------------------------- -template -void Quat::ToEuler(Type& yaw, Type& pitch, Type& roll) const -{ - // This is probably wrong - Mat33 M; - ToMat(M); - const int i = 0, j = 1, k = 2; - double cy = sqrt(M(i,i)*M(i,i) + M(i,j)*M(i,j)); - if (cy > FUDGE()) { - roll = ATan2(M(j,k), M(k,k)); - pitch = ATan2(-M(i,k), cy); - yaw = ATan2(M(i,j), M(i,i)); - } else { - roll = ATan2(-M(k,j), M(j,j)); - pitch = ATan2(-M(i,k), cy); - yaw = 0; - } -} - -//============================================================================ -// QUAT FRIENDS -//============================================================================ - - -template -Quat operator + (const Quat &a, const Quat &b) -{ - return Quat( a.s+b.s, a.v+b.v ); -} - -template -Quat operator - (const Quat &a, const Quat &b) -{ - return Quat( a.s-b.s, a.v-b.v ); -} - -template -Quat operator - (const Quat &a ) -{ - return Quat( -a.s, -a.v ); -} - -template -Quat operator * ( const Quat &a, const Quat &b) -{ -#if 0 - // 16 mults - return Quat( a.s*b.s - a.v*b.v, a.s*b.v + b.s*a.v + a.v^b.v ); -#else - // optimized (12 mults, and no compiler-generated temp objects) - Type A, B, C, D, E, F, G, H; - - A = (a.s + a.v.x)*(b.s + b.v.x); - B = (a.v.z - a.v.y)*(b.v.y - b.v.z); - C = (a.s - a.v.x)*(b.v.y + b.v.z); - D = (a.v.y + a.v.z)*(b.s - b.v.x); - E = (a.v.x + a.v.z)*(b.v.x + b.v.y); - F = (a.v.x - a.v.z)*(b.v.x - b.v.y); - G = (a.s + a.v.y)*(b.s - b.v.z); - H = (a.s - a.v.y)*(b.s + b.v.z); - - return Quat( - B + (-E - F + G + H) * Type(0.5), - A - (E + F + G + H) * Type(0.5), - C + (E - F + G - H) * Type(0.5), - D + (E - F - G + H) * Type(0.5)); -#endif -} - -template -Quat operator * ( const Quat &a, const Type t) -{ - return Quat( a.v * t, a.s * t ); -} - -template -Quat operator * ( const Type t, const Quat &a ) -{ - return Quat( a.v * t, a.s * t ); -} -template -Quat operator / ( const Quat &a, const Type t ) -{ - return Quat( a.v / t, a.s / t ); -} - -template -bool operator == (const Quat &a, const Quat &b) -{ - return (a.s == b.s && a.v == b.v); -} -template -bool operator != (const Quat &a, const Quat &b) -{ - return (a.s != b.s || a.v != b.v); -} - - -//============================================================================ -// UTILS -//============================================================================ -template -inline Type Quat::DEG2RAD(Type d) -{ - return d * Type(0.0174532925199432957692369076848861); -} -template -inline Type Quat::RAD2DEG(Type d) -{ - return d * Type(57.2957795130823208767981548141052); -} - -template -inline Type Quat::Sin(double d) { return Type(sin(d)); } -template -inline Type Quat::Cos(double d) { return Type(cos(d)); } -template -inline Type Quat::ACos(double d) { return Type(acos(d)); } -template -inline Type Quat::ASin(double d) { return Type(asin(d)); } -template -inline Type Quat::ATan(double d) { return Type(atan(d)); } -template -inline Type Quat::ATan2(double n, double d) {return Type(atan2(n,d));} - -template -inline Quat Quat::ZERO() {return Quat(0,0,0,0); } -template -inline Quat Quat::IDENTITY() {return Quat(1,0,0,0); } - -template -inline Type Quat::FUDGE() { return 1e-6; } -template<> -inline double Quat::FUDGE() { return 1e-10; } - -//---------------------------------------------------------------------------- -// QuatSlerp -//---------------------------------------------------------------------------- -template -Quat& QuatSlerp( - Quat &dest, - const Quat &from, const Quat &to, Type t ) -{ -#if 0 - // compact mathematical version - // exp(t*log(to*from^-1))*from - Quat fminv(from); - Quat tofrom(to*fminv.Invert()); - Quat slerp = t*tofrom.Log(); - slerp.Exp(); - slerp *= from; - return slerp; -#endif - Quat to1; - double omega, cosom, sinom, scale0, scale1; - - /* calculate cosine */ - cosom = from.v * to.v + from.s + to.s; - - /* Adjust signs (if necessary) so we take shorter path */ - if ( cosom < 0.0 ) { - cosom = -cosom; - to1 = -to; - } - else - { - to1 = to; - } - - /* Calculate coefficients */ - if ((1.0 - cosom) > Quat::FUDGE ) { - /* standard case (slerp) */ - omega = acos( cosom ); - sinom = sin( omega ); - scale0 = sin((1.0 - t) * omega) / sinom; - scale1 = sin(t * omega) / sinom; - } - else { - /* 'from' and 'to' are very close - just do linear interpolation */ - scale0 = 1.0 - t; - scale1 = t; - } - - dest = from; - dest *= Type(scale0); - dest += Type(scale1) * to1; - return dest; -} - -// This version creates more temporary objects -template -inline Quat QuatSlerp( - const Quat& from, const Quat& to, Type t ) -{ - Quat q; - return QuatSlerp(q, from, to, t); -} - - diff --git a/simgear/scene/sky/clouds3d/quattest.cpp b/simgear/scene/sky/clouds3d/quattest.cpp deleted file mode 100644 index 1c15fea3..00000000 --- a/simgear/scene/sky/clouds3d/quattest.cpp +++ /dev/null @@ -1,196 +0,0 @@ -//------------------------------------------------------------------------------ -// File : quattest.cpp -//------------------------------------------------------------------------------ -// GLVU : Copyright 1997 - 2002 -// The University of North Carolina at Chapel Hill -//------------------------------------------------------------------------------ -// Permission to use, copy, modify, distribute and sell this software and its -// documentation for any purpose is hereby granted without fee, provided that -// the above copyright notice appear in all copies and that both that copyright -// notice and this permission notice appear in supporting documentation. -// Binaries may be compiled with this software without any royalties or -// restrictions. -// -// The University of North Carolina at Chapel Hill makes no representations -// about the suitability of this software for any purpose. It is provided -// "as is" without express or implied warranty. - -//---------------------------------------------------------------------------- -// Quattest.cpp -// Quaternion coverage (and maybe functionality) test. -// The main objective is to just make sure every API gets called -// to flush out lurking template bugs that might not otherwise get tickled. -// A few checks to make sure things are functioning properly are also -// included. -// -// For the API coverage, if the thing simply compiles then it was a success. -//---------------------------------------------------------------------------- - - -#include "quat.hpp" - -void coverage_test() -{ - float x = 0.5f, y = 1.1f, z = -0.1f, s = 0.2f; - // TEST CONSTRUCTORS - Quatf q1; - Quatf q2 = Quatf(x, y, z, s); - Quatf q3(x, y, z); - Quatf q4(Vec3f(1,2,3)); - Quatf q5(Vec3f(2,3,4), 2.0); - Quatf q6(1.0, Vec3f(-1,-2,-3)); - float floatarray[4] = { 1, 2, 3, 4 }; - Quatf q7(floatarray); - Quatf q8(q7); - - // TEST SETTERS - q1.Set(1,2,3); - q2.Set(1,2,3,4); - q3.Set(Vec3f(1.0,1.0,1.0)); - q3.Set(Vec3f(1.0,1.0,1.0),-0.5); - - // TEST OPERATORS - // Quat &operator = ( const Quat &v ); /* assignment of a Quat */ - q4 = q6; - // Quat &operator += ( const Quat &v ); /* incrementation by a Quat */ - q3 += q2; - // Quat &operator -= ( const Quat &v ); /* decrementation by a Quat */ - q3 -= q2; - // Quat &operator *= ( const Type d ); /* multiplication by a scalar */ - q4 *= 0.5f; - // Quat &operator *= ( const Quat &v ); /* quat product (this*v) */ - q2 *= q1; - // Quat &operator /= ( const Type d ); /* division by a scalar */ - q5 /= 2.0f; - // Type &operator [] ( int i); /* indexing x=0, s=3 */ - float c0 = q1[0]; - float c1 = q1[1]; - float c2 = q1[2]; - float c3 = q1[3]; - - // TEST SPECIAL FUNCTIONS - - // Type Length(void) const; /* length of a Quat */ - float l = q4.Length(); - // Type LengthSqr(void) const; /* squared length of a Quat */ - l = q4.LengthSqr(); - // Type LengthSqr(void) const; /* squared length of a Quat */ - l = q4.Norm(); - // Quat &Normalize(void); /* normalize a Quat */ - Quatf q9 = q4.Normalize(); - // Quat &Invert(void); /* q = q^-1 */ - q9 = q4.Invert(); - // Quat &Conjugate(void); /* q = q* */ - q9 = q4.Conjugate(); - // qvec Xform( const qvec &v ); /* q*v*q-1 */ - Vec3f v1 = q4.Xform(Vec3f(1.0,1.0,1.0)); - // Quat &Log(void); /* log(q) */ - q9 = q4.Log(); - // Quat &Exp(void); /* exp(q) */ - q9 = q4.Exp(); - // qvec GetAxis( void ) const; /* Get rot axis */ - v1 = q5.GetAxis(); - // Type GetAngle( void ) const; /* Get rot angle (radians) */ - float a = q5.GetAngle(); - // void SetAngle( Type rad_ang ); /* set rot angle (radians) */ - q2.SetAngle(a); - // void ScaleAngle( Type f ); /* scale rot angle */ - q2.ScaleAngle(1.5); - // void Print( ) const; /* print Quat */ - q3.Print(); - - /* TEST CONVERSIONS */ - Mat44f m44; - Mat33f m33; - //Mat44& ToMat( Mat44 &dest ) const; - //Mat33& ToMat( Mat33 &dest ) const; - // Quat& FromMat( const Mat44& src ) const; - // Quat& FromMat( const Mat33& src ) const; - q3.Normalize(); - m44 = q3.ToMat(m44); - m33 = q3.ToMat(m33); - q5 = q3.FromMat(m44); - q5 = q3.FromMat(m33); - //void ToAngleAxis( Type &ang, qvec &ax ) const; - q3.ToAngleAxis( a, v1 ); - //Quat& FromAngleAxis( Type ang, const qvec &ax ); - q4 = q3.FromAngleAxis( a, v1 ); - //Quat& FromTwoVecs(const qvec &a, const qvec& b); - Vec3f v2(-1,-2,-3); - q4 = q3.FromTwoVecs( v2, v1 ); - //Quat& FromEuler( Type yaw, Type pitch, Type roll); - q4 = q3.FromEuler( 2.2f, 1.2f, -0.4f ); - //void ToEuler(Type &yaw, Type &pitch, Type &roll) const; - float p=0.3f,r=-1.57f; y= 0.1f; - q3.ToEuler( y,p,r ); - - /* TEST FRIENDS */ - - //friend Quat operator - (const Quat &v); /* -q1 */ - q1 = -q2; - //friend Quat operator + (const Quat &a, const Quat &b); /* q1 + q2 */ - q1 = q2 + q3; - //friend Quat operator - (const Quat &a, const Quat &b); /* q1 - q2 */ - q1 = q2 - q3; - //friend Quat operator * (const Quat &a, const Type d); /* q1 * 3.0 */ - q1 = q2 * 0.2f; - //friend Quat operator * (const Type d, const Quat &a); /* 3.0 * q1 */ - q1 = 0.2f * q2; - //friend Quat operator * (const Quat &a, const Quat &b); /* q1 * q2 */ - q1 = q2 * q3; - //friend Quat operator / (const Quat &a, const Type d); /* q1 / 3.0 */ - q1 = q2 / 1.2f; - //friend bool operator == (const Quat &a, const Quat &b); /* q1 == q2 ? */ - bool eq = (q1 == q2); - //friend bool operator != (const Quat &a, const Quat &b); /* q1 != q2 ? */ - bool neq = (q1 != q2); - - // HELPERS - // static Type DEG2RAD(Type d); - // static Type RAD2DEG(Type d); - a = Quatf::RAD2DEG(a); - a = Quatf::DEG2RAD(a); - a = Quatf::Sin(a); - a = Quatf::Cos(a); - a = Quatf::ACos(a); - a = Quatf::ASin(a); - a = Quatf::ATan(a); - a = Quatf::ATan2(a, p); - - // CONSTANTS - // static const Type FUDGE; - // static const Quat ZERO; - // static const Quat IDENTITY; - a = Quatf::FUDGE; - q3 = Quatf::ZERO(); - q4 = Quatf::IDENTITY(); - - q1 = QuatSlerp(q1, q3, q4, 0.5f ); - q1 = QuatSlerp(q3, q4, 0.5f ); - -} - -Quatf StatQuat(Quatf::IDENTITY()); -Quatf StatQuat2 = Quatf::IDENTITY(); - -void functional_test() -{ - printf("The ZERO quat: "); - Quatf::ZERO().Print(); - printf("The IDENTITY quat: "); - Quatf::IDENTITY().Print(); - printf("Statically constructed copy of IDENTITY quat: "); - StatQuat.Print(); - printf("A different static copy of IDENTITY quat: "); - StatQuat2.Print(); - - -} - -int main(int argc, char *argv[]) -{ - coverage_test(); - functional_test(); - - return (0); -} -- 2.39.5