---

c:/home/kevn/src/animaniac/ani/KeyFrame/PosQuatKey.h

Go to the documentation of this file.

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * Animaniac is (C) Copyright 2000,2001 Kevin Meinert
 *
 * Original Authors:
 *   Kevin Meinert
 *
 *
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: PosQuatKey.h,v $
 * Date modified: $Date: 2002/06/10 03:08:01 $
 * Version:       $Revision: 1.8 $
 * -----------------------------------------------------------------
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/


// NOTE: for best results, read this file using an editor that supports
// color syntax highlighting.  (i.e. nedit, gvim, visual studio, visual 
// slick edit)

#ifndef ANIMANIAC_POSITION_ORIENTATION_KEY
#define ANIMANIAC_POSITION_ORIENTATION_KEY

#include <assert.h>
#include <gmtl/Vec.h>
#include <gmtl/Matrix.h>
#include <gmtl/Quat.h>
#include <gmtl/Math.h>
#include <gmtl/Generate.h>

#include "ani/KeyFrame/Key.h"

namespace ani
{
   //: One Key for the KeyFramer
   class PosQuatKey : public ani::Key
   {
   public:
      PosQuatKey() : Key(), mRot(), mPos()
      {
      }
      // matrix constructor
      PosQuatKey( const float& timeVal, const gmtl::Matrix44f& mat ) : Key( timeVal )
      {
         this->setTime( timeVal );
         gmtl::set( mRot, mat );
         //mRot.makeRot( mat ); // juggler
         gmtl::setTrans( mPos, mat ); 
      }
      // pos/quat constructor
      PosQuatKey( const float& timeVal, const gmtl::Vec3f& pos, const gmtl::Quatf& rot ) : Key( timeVal )
      {
         this->setTime( timeVal );
         mRot = rot;
         mPos = pos;
      }
      
      PosQuatKey( const PosQuatKey& key )
      {
         this->set( key );
      }

      PosQuatKey& operator=( const PosQuatKey& key ) 
      {
         this->set( key );
         return *this;
      }  
      
      virtual void set( const PosQuatKey& key )
      {
         // base class functionality 
         this->setTime( key.time() );
         
         mRot = key.mRot;
         mPos = key.mPos;
      }
      
   // set/get
   public:
      // quat/pos -> matrix conversion
      // navMatrix == false for animating objects
      //              true if you are animating a nav matrix
      inline void getMatrix( gmtl::Matrix44f& mat, bool navMatrix = true ) const
      {  
         // premult if doing navigation, post if not...
         if (navMatrix == true)
         {
            gmtl::Matrix44f rot;
            gmtl::Matrix44f pos;
            gmtl::set( rot, mRot );
            // rot.makekev::Quaternion( mRot );
            gmtl::setTrans( pos, mPos );
            mat = rot * pos;
         }
         else
         {
            gmtl::set( mat, mRot );
            //mat.makeQuaternion( mRot );
            gmtl::setTrans( mat, mPos );
         }
      }

      //: set this key to the interpolated value of key0 to key1
      //  interp is a number from key0.time() to key1.time(), 
      // 
      // where: 
      //  interp == key0.time()              sets the Key to key0
      //  key0.time() < interp < key1.time() sets the Key to interpolated 
      //                                      value of key0 to key1
      //  interp == key1.time()              sets the Key to key1
      //
      virtual void setInterpolate( float interp, const PosQuatKey& key0, const PosQuatKey& key1 )
      {
         float time_needed( interp );
         assert( (time_needed >= key1.time() && time_needed <= key0.time()) ||
                 (time_needed >= key0.time() && time_needed <= key1.time()) && 
                 "time_needed need to be in between the two times" );
         float size = gmtl::Math::abs( key1.time() - key0.time() );

         // degenerate case where you're interpolating between two keys of the same time value..
         if (size <= 0.00001f)
         {
            this->set( key1 );
            return;
         }

         // find the distance between [key0Time, time_needed, key1Time] to  [0, normalize, 1]
         time_needed -= gmtl::Math::Min( key0.time(), key1.time() );
         float normalize = time_needed / size;

         // interpolate. 
         // TODO: change the lerps to bezier curve interpolation funcs (TODO: implement those funcs too!!!)
         gmtl::Math::lerp( this->time(), normalize, key0.time(), key1.time() );
         gmtl::lerp( this->position(), normalize, key0.position(), key1.position() );
         gmtl::slerp( this->rotation(), normalize, key0.rotation(), key1.rotation() );
      }
   
   // aliases
   public:
      const gmtl::Quatf&   rotation() const { return mRot; }
      const gmtl::Vec3f&   position() const { return mPos; }
      gmtl::Quatf&         rotation() { return mRot; }
      gmtl::Vec3f&         position() { return mPos; }

   private:
      gmtl::Quatf      mRot;
      gmtl::Vec3f      mPos;
   };

};

#endif

---