Rotate.h

Go to the documentation of this file.

// RC  6/11/2002  \Randy95\Include\Rotate.h

#define __ROTATE_H

#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __QUATERNI_H
#include "Quaterni.h"
#endif

class Rotate {
public:   
   float          swivel, tilt, roll;
   //                x      z     y

   Rotate() {}
   Rotate( const float scalar ) { swivel = tilt = roll = scalar; }
   Rotate( const float pswivel, const float ptilt, const float proll )
    { swivel = pswivel; tilt = ptilt; roll = proll; }
   int operator == ( const Rotate &a ) const { return swivel==a.swivel && tilt == a.tilt && roll==a.roll; }
   int operator != ( const Rotate &a ) const { return !(*this == a); }   
};

class RotateSphere;
class RotateEuler;

class RotateVector {
public:
   Vector               end;
   float                roll;
   
   RotateVector() {}
   RotateVector( const Vector &pend, float proll ) { end=pend; roll=proll; }
   ~RotateVector() {}
   RotateVector( const RotateSphere &sphere );
   RotateVector( const RotateEuler &euler );
   RotateVector( const Matrix34 &matrix );
   RotateVector( const Quaternion &quat );

   friend int operator != ( const RotateVector &a, const RotateVector &b )
    { return a.end!=b.end || a.roll!=b.roll; }
};

class RotateSphere {
public:
   float                latitude,
                        longitude,
                        roll;
   RotateSphere() {}
   ~RotateSphere() {}
   RotateSphere( const Vector &vec );
   RotateSphere( const RotateVector &rotateend );
   RotateSphere( const Quaternion &quat );
   RotateSphere( const Quaternion &quat, Bone *bone );
};

class RotateEuler { 
public:   
   float          x, y, z;

   RotateEuler() {}
   ~RotateEuler() {}
   RotateEuler( float px, float py, float pz ) { x=px; y=py; z=pz; }
   RotateEuler( const Matrix34 &t );
   RotateEuler( const RotateVector &rotateend );
   RotateEuler( const Quaternion &quat );
   void ToEuler( const Matrix34 &t );
   RotateEuler operator * ( float scale ) { RotateEuler other; other.x = x * scale; other.y  = y * scale; other.z = z * scale; return other; }
   float operator[]( int i ) const
   {
      return (&x)[i];
   }
   float &operator[]( int i )
   {
      return (&x)[i];
   }
};

class TSR {
public:
   Vector            translate;
   Vector            scale;
   RotateVector      rotate;
   
   friend int operator != ( const TSR &a, const TSR &b )
    { return a.rotate!=b.rotate || a.translate!=b.translate || a.scale!=b.scale; }
   void SetDefault()
    { translate.Set(0.0f); scale.Set(1.0f); rotate.end.Set(0.0f,0.0f,1.0f); rotate.roll=0.0f; }
};

class MATRIXEXPORT TSQ {
public:
   Vector            translate;
   Vector            scale;
   Quaternion        quat;
   float             roll;
   BOOL              m_isrollcomputed;
   
   TSQ(){}
   TSQ(const Matrix34 &actionmatrix);
   TSQ(const Vector &ptranslate, const Vector &pscale, const Quaternion &pquat)
   {
      translate = ptranslate;
      scale = pscale;
      quat = pquat;
   }
   
   int operator != ( const TSQ &b ) const
    { return quat!=b.quat || translate!=b.translate || scale!=b.scale; }
   void SetDefault()
    { translate.Set(0.0f); scale.Set(1.0f); quat.SetIdentity(); }
   TSQ &operator += ( const TSQ &other )
   {
      translate += other.translate;
      scale += other.scale;
      quat += other.quat;
      return *this;
   }
   TSQ &operator *= ( float scalar )
   {
      translate *= scalar;
      scale *= scalar;
      quat *= scalar;
      return *this;
   }
   void PostBlend()
   {
      quat.Normalize();
   }
   void FillMatrices( Matrix34 &matrix, Matrix34 &inverse );
};

// ANY ROTATION TYPE TO AND FROM QUATERNION

inline RotateEuler::RotateEuler( const Quaternion &quat )
{
   Vector end( quat.GetZAxis());
   y = (float)(atan2( end.x, end.z ) * RADIANS);
   x = (float)(atan2( -end.y, sqrt(end.x*end.x + end.z*end.z)) * RADIANS);
   Vector rolldir( quat.GetYAxis());
   rolldir *= YXRotateQ( y, x ).Inverse();
   z = (float)(atan2( -rolldir.x, rolldir.y ) * RADIANS);
}

inline RotateVector::RotateVector( const Quaternion &quat )  // SOB STYLE ROLL
{
   end = quat.GetZAxis();
   float y = (float)atan2( end.x, end.z );
   float x = (float)atan2( -end.y, (float)sqrt(end.x*end.x + end.z*end.z));
   Vector rolldir = quat.GetYAxis();
   rolldir *= YXRotateRadiansQ( y, x ).Inverse();
   roll = (float)atan2( -rolldir.x, rolldir.y ) * RADIANS;
}

inline Quaternion::Quaternion( const RotateVector &rv )  // SOB STYLE ROLL
{
   float y = (float)atan2( rv.end.x, rv.end.z );
   float x = (float)atan2( -rv.end.y, (float)sqrt(rv.end.x*rv.end.x + rv.end.z*rv.end.z));
   if ( rv.roll )
      *this = YXZRotateRadiansQ( y, x, rv.roll / RADIANS );
   else
      *this = YXRotateRadiansQ( y, x );
}

inline RotateSphere::RotateSphere( const Quaternion &quat )
{
   *this = RotateSphere(RotateVector(quat));
}

inline Quaternion::Quaternion( const RotateSphere &rs )
{
   *this = Quaternion(RotateVector(rs));
}

inline Quaternion::Quaternion( const RotateEuler &re )
{
   if ( re.z )
      *this = YXZRotateQ( re.y, re.x, re.z );
   else
      *this = YXRotateQ( re.y, re.x );
}

inline Quaternion::Quaternion( const RotateEuler &re, BOOL isyxz )
{
   if (isyxz) {
      if ( re.z )
         *this = YXZRotateQ( re.y, re.x, re.z );
      else
         *this = YXRotateQ( re.y, re.x );
   }
   else {
      if ( re.z )
         *this = XYZRotateQ( re.x, re.y, re.z );
      else
         *this = XYRotateQ( re.x, re.y );
   }
}

// CONVERSIONS BETWEEN ROTATE TYPES

inline RotateSphere::RotateSphere( const Vector &vec )
{
   longitude = (float)atan2( -vec.x, vec.y )*RADIANS;
   latitude = (float)atan2( (float)sqrt(vec.x*vec.x + vec.y*vec.y), vec.z )*RADIANS;
}

inline RotateSphere::RotateSphere( const RotateVector &rotate )
{
   longitude = (float)atan2( -rotate.end.x, rotate.end.y )*RADIANS;
   latitude = (float)atan2( (float)sqrt(rotate.end.x*rotate.end.x + rotate.end.y*rotate.end.y),
    rotate.end.z )*RADIANS;
   roll = rotate.roll; 
}

inline RotateVector::RotateVector( const RotateSphere &sphere )
{
    float r = (float)sin( sphere.latitude/RADIANS );
    end.z = (float)cos( sphere.latitude/RADIANS );
    end.y = r * (float)cos( sphere.longitude/RADIANS );
    end.x = -r * (float)sin( sphere.longitude/RADIANS );
    roll = sphere.roll;
}

inline RotateVector::RotateVector( const RotateEuler &euler )
{
   float cy = (float)cos( euler.y / RADIANS ),
         sy = (float)sin( euler.y / RADIANS ),
         cx = (float)cos( euler.x / RADIANS ),
         sx = (float)sin( euler.x / RADIANS );
   end.Set( sy*cx, -sx, cy*cx );  // SPEED UP: THESE ARE THE Z COLUMN OUT OF YXROTATE, WHICH IS THE SAME AS BUILDING THAT MATRIX, THEN TRANSFORMING (0,0,1) BY IT
   roll = euler.z;
 }

inline RotateEuler::RotateEuler( const RotateVector &rotatev )
{
   y = (float)atan2( rotatev.end.x, rotatev.end.z ) * RADIANS;
   x = (float)atan2( -rotatev.end.y, (float)sqrt(rotatev.end.x*rotatev.end.x +
    rotatev.end.z*rotatev.end.z)) * RADIANS;
   z = rotatev.roll;
}

// THE 4 FUNCTIONS BELOW WORK ONLY 0 TO 90 DEGREES

inline float VectorsToLinear( const Vector &v, const Vector &v1 )
{
   float cosa = Dot(v.Normalized(), v1.Normalized());
   if ( cosa == 0.0f )
      return 0.0f;
   float sina = (float)sqrt( 1.0f - cosa*cosa );
   float slope = sina / cosa;
   float percent = slope / (slope + 1.0f);
   return percent *= 90.0f;
}

inline float VectorsToAngle( const Vector &v, const Vector &v1 )
{
   return (float)acos(Dot(v.Normalized(), v1.Normalized())) * RADIANS;
}

inline float LinearToAngle( float linear )
{
   return (float)atan( linear / (90-linear)) * RADIANS;
}

inline float LinearToAngle360( float linear )
{
   if ( linear < 0 )
      return -LinearToAngle360( -linear );
   if ( linear <= 90 )
      return LinearToAngle( linear );
   float remainder = (float)fmod( linear, 90 );
   float excess = linear - remainder;
   return excess + LinearToAngle( remainder );
}

---