Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 13, 2005, 11:16:33 PM (19 years ago)
Author:
bensch
Message:

orxonox/branches/physics: merged the Trunk into the physics Branche again:
merged with command:
svn merge ../trunk physics -r 3953:HEAD
no important conflicts

Location:
orxonox/branches/physics
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • orxonox/branches/physics

    • Property svn:externals

      •  

        old new  
        1 data http://svn.orxonox.ethz.ch/data
         1

  • orxonox/branches/physics/src/util/animation/animation3d.cc

    r3953 r4178  
    1515   2005-04-17: Benjamin Grauer
    1616          Rewritte all functions, so it will fit into the Animation-class
     17   2005-04-25: Patrick Boenzli
     18          Extended the framework to support quatSlerp rotations. Each frame now supports diff mov/rot types. Implemented mov/rot functions
    1719*/
    1820
    … …  
    4244  this->nextKeyFrame = tmpKeyFrame;
    4345
    44   this->animFunc = &Animation3D::linear;
     46  this->animFuncMov = &Animation3D::mLinear;
     47  this->animFuncRot = &Animation3D::rLinear;
     48
    4549}
    4650
    … …  
    7276  this->nextKeyFrame = keyFrameList->nextElement(keyFrameList->firstElement());
    7377  this->localTime = 0.0;
    74   this->setAnimFunc(this->currentKeyFrame->animFunc);
     78  this->setAnimFuncMov(this->currentKeyFrame->animFuncMov);
     79  this->setAnimFuncRot(this->currentKeyFrame->animFuncRot);
    7580}
    7681
    … …  
    8085   \param direction The direction of the new Keyframe.
    8186   \param duration The duration from the new KeyFrame to the next one
    82    \param animFunc The function to animate between this keyFrame and the next one
    83 */
    84 void Animation3D::addKeyFrame(Vector position, Quaternion direction, float duration, ANIM_FUNCTION animFunc)
     87   \param animFuncMov The function to animate position between this keyFrame and the next one
     88   \param animFuncMov The function to animate rotation between this keyFrame and the next one
     89*/
     90void Animation3D::addKeyFrame(Vector position, Quaternion direction, float duration, ANIM_FUNCTION animFuncMov, ANIM_FUNCTION animFuncRot)
    8591{
    8692  // some small check
    8793  if (duration <= 0.0)
    8894    duration = 1.0;
     95  // if the Rotation-Animation-function is set ANIM_NULL, animFuncRot will match animFuncRot
     96  if (animFuncMov == ANIM_NULL)
     97    animFuncMov = ANIM_DEFAULT_FUNCTION;
     98  if (animFuncRot == ANIM_NULL)
     99    animFuncRot = animFuncMov;
    89100
    90101  KeyFrame3D* tmpKeyFrame;
    … …  
    94105    {
    95106      tmpKeyFrame = this->keyFrameList->firstElement();
    96       this->setAnimFunc(animFunc);
     107      //this->setAnimFuncMov(animFuncMov);
     108      //this->setAnimFuncRot(animFuncRot);
    97109    }
    98110  else
    … …  
    106118
    107119  tmpKeyFrame->position = position;
     120  //tmpKeyFrame->lastPosition = position;
    108121  tmpKeyFrame->direction = direction;
    109122  tmpKeyFrame->duration = duration;
    110   tmpKeyFrame->animFunc = animFunc;
     123  tmpKeyFrame->animFuncMov = animFuncMov;
     124  tmpKeyFrame->animFuncRot = animFuncRot;
    111125  this->keyFrameCount++;
    112126}
     127
     128
    113129
    114130/**
    … …  
    123139      if (localTime >= this->currentKeyFrame->duration)
    124140        {
    125           // switching to the next Key-Frame
    126           this->localTime -= this->currentKeyFrame->duration;
    127           this->currentKeyFrame = this->nextKeyFrame;
    128           // checking, if we should still Play the animation
    129           if (this->currentKeyFrame == this->keyFrameList->lastElement())
    130             this->handleInfinity();
    131           this->nextKeyFrame = this->keyFrameList->nextElement(this->currentKeyFrame);
    132           this->setAnimFunc(this->currentKeyFrame->animFunc);     
    133          
    134           if( this->currentKeyFrame->animFunc == ANIM_NEG_EXP)
     141          if (likely(this->keyFramesToPlay != 0))
    135142            {
    136               this->tmpVect = this->nextKeyFrame->position - this->currentKeyFrame->position;
    137               this->deltaT = 1/this->currentKeyFrame->duration * logf(1.0 + 600.0/this->tmpVect.len());
     143              if (unlikely(this->keyFramesToPlay > 0))
     144                --this->keyFramesToPlay;
     145              // switching to the next Key-Frame
     146              this->localTime -= this->currentKeyFrame->duration;
     147              this->currentKeyFrame = this->nextKeyFrame;
     148              // checking, if we should still Play the animation
     149              if (this->currentKeyFrame == this->keyFrameList->lastElement())
     150                this->handleInfinity();
     151              this->nextKeyFrame = this->keyFrameList->nextElement(this->currentKeyFrame);
     152              this->setAnimFuncMov(this->currentKeyFrame->animFuncMov);
     153              this->setAnimFuncRot(this->currentKeyFrame->animFuncRot);
    138154            }
    139         }
    140 
     155          else
     156            this->pause();
     157        }     
    141158      /* now animate it */
    142       (this->*animFunc)(this->localTime);
    143       /*
    144       switch( this->movMode)
    145         {
    146         case LINEAR:
    147           *this->tmpVect = *this->currentFrame->position - *this->lastFrame->position;
    148           *this->tmpVect = *this->tmpVect * this->localTime / this->currentFrame->time;
    149           this->currentFrame->object->setRelCoor(*this->lastFrame->position + *this->tmpVect);
    150           *this->lastPosition = *this->tmpVect;
    151           break;
    152         case EXP:
    153              
    154           break;
    155         case NEG_EXP:
    156           *this->tmpVect = *this->currentFrame->position - *this->lastFrame->position;
    157           *this->tmpVect = *this->tmpVect * (1 - expf(- this->localTime * this->deltaT));     
    158           this->currentFrame->object->setRelCoor(*this->lastFrame->position + *this->tmpVect);
    159           *this->lastPosition = *this->tmpVect;
    160           break;
    161         case SIN:
    162           *this->tmpVect = *this->currentFrame->position - *this->lastFrame->position;
    163           *this->tmpVect = *this->tmpVect * 0.5*(1 - cos(M_PI * this->localTime / this->currentFrame->time));     
    164           this->currentFrame->object->setRelCoor(*this->lastFrame->position + *this->tmpVect);
    165           *this->lastPosition = *this->tmpVect;
    166           break;
    167         case COS:
    168              
    169           break;
    170         case QUADRATIC:
    171           *this->tmpVect = *this->currentFrame->position - *this->lastFrame->position;
    172           *this->tmpVect = *this->tmpVect * 1/3 * ldexpf(this->localTime, 3);
    173           break;
    174         default:
    175           break;
    176         }
    177       */
    178     }
    179 }
    180 
    181 
    182 /**
    183    \brief Sets The kind of Animation between this keyframe and the next one
     159      (this->*animFuncMov)(this->localTime);
     160      (this->*animFuncRot)(this->localTime);
     161    }
     162}
     163
     164
     165/*==Movement Section==========================================================*/
     166
     167/**
     168   \brief Sets The kind of movment Animation between this keyframe and the next one
    184169   \param animFunc The Type of Animation to set
    185170*/
    186 void Animation3D::setAnimFunc(ANIM_FUNCTION animFunc)
    187 {
    188   switch (animFunc)
     171void Animation3D::setAnimFuncMov(ANIM_FUNCTION animFuncMov)
     172{
     173  switch (animFuncMov)
    189174    {
     175    case ANIM_CONSTANT:
     176      this->animFuncMov = &Animation3D::mConstant;
     177      break;
     178    case ANIM_LINEAR:
     179      this->animFuncMov = &Animation3D::mLinear;
     180      this->object->setRelCoor(this->currentKeyFrame->position);
     181      this->currentKeyFrame->lastPosition = Vector();
     182      break;
     183    case ANIM_SINE:
     184      this->animFuncMov = &Animation3D::mSine;
     185      this->object->setRelCoor(this->currentKeyFrame->position);
     186      this->currentKeyFrame->lastPosition = Vector();
     187      break;
     188    case ANIM_COSINE:
     189      this->animFuncMov = &Animation3D::mCosine;
     190      this->object->setRelCoor(this->currentKeyFrame->position);
     191      this->currentKeyFrame->lastPosition = Vector();
     192      break;
     193    case ANIM_EXP:
     194      this->object->setRelCoor(this->currentKeyFrame->position);
     195      this->animFuncMov = &Animation3D::mExp;
     196      break;
     197    case ANIM_NEG_EXP:
     198      this->animFuncMov = &Animation3D::mNegExp;
     199      this->object->setRelCoor(this->currentKeyFrame->position);
     200      this->expFactorMov = -1.0 / this->currentKeyFrame->duration * logf(DELTA_X_3D);
     201      this->currentKeyFrame->lastPosition = Vector();
     202      break;
     203    case ANIM_QUADRATIC:
     204      this->object->setRelCoor(this->currentKeyFrame->position);
     205      this->animFuncMov = &Animation3D::mQuadratic;
     206      break;
     207    case ANIM_RANDOM:
     208      this->object->setRelCoor(this->currentKeyFrame->position);
     209      this->animFuncMov = &Animation3D::mRandom;
     210      break;
    190211    default:
    191     case ANIM_CONSTANT:
    192       this->animFunc = &Animation3D::constant;
    193       break;
    194     case ANIM_LINEAR:
    195       this->animFunc = &Animation3D::linear;
    196       break;
    197     case ANIM_SINE:
    198       this->animFunc = &Animation3D::sine;
    199       break;
    200     case ANIM_COSINE:
    201       this->animFunc = &Animation3D::cosine;
    202       break;
    203     case ANIM_EXP:
    204       this->animFunc = &Animation3D::exp;
    205       break;
    206     case ANIM_NEG_EXP:
    207       this->animFunc = &Animation3D::negExp;
    208       break;
    209     case ANIM_QUADRATIC:
    210       this->animFunc = &Animation3D::quadratic;
    211       break;
    212     case ANIM_RANDOM:
    213       this->animFunc = &Animation3D::random;
    214       break;
    215     }
    216 }
     212      break;
     213    }
     214}
     215
     216
    217217
    218218/**
    … …  
    220220   \param timePassed The time passed since this Keyframe began
    221221*/
    222 void Animation3D::constant(float timePassed) const
    223 {
    224   this->object->setRelCoor(this->currentKeyFrame->position);
     222void Animation3D::mConstant(float timePassed) const
     223{
     224  //this->object->setRelCoor(this->currentKeyFrame->position);
    225225
    226226  /*
    … …  
    238238   \todo implement also do this for direction
    239239*/
    240 void Animation3D::linear(float timePassed) const
    241 {
    242   this->object->setRelCoor(this->currentKeyFrame->position +
    243                           (this->nextKeyFrame->position - this->currentKeyFrame->position) *
    244                           (timePassed/this->currentKeyFrame->duration));
     240void Animation3D::mLinear(float timePassed) const
     241{
     242  Vector v = (this->nextKeyFrame->position - this->currentKeyFrame->position) * (timePassed/this->currentKeyFrame->duration);
     243  this->object->shiftCoor(v - this->currentKeyFrame->lastPosition);
     244  this->currentKeyFrame->lastPosition = v;
    245245}
    246246
    … …  
    251251   \todo implement
    252252*/
    253 void Animation3D::sine(float timePassed) const
    254 {
    255   this->linear(timePassed);
    256 }
     253void Animation3D::mSine(float timePassed) const
     254{
     255  Vector v;
     256  if( timePassed  < this->currentKeyFrame->duration/2.0)
     257    v = (this->nextKeyFrame->position - this->currentKeyFrame->position) * sin( M_PI * timePassed /this->currentKeyFrame->duration) / 2.0;
     258  else
     259    v = (this->nextKeyFrame->position - this->currentKeyFrame->position) * (2.0 + sin( M_PI * (- timePassed /this->currentKeyFrame->duration)) )/ 2.0;
     260 
     261  this->object->shiftCoor(v - this->currentKeyFrame->lastPosition);
     262  this->currentKeyFrame->lastPosition = v;
     263}
     264
    257265
    258266/**
    … …  
    262270   \todo implement
    263271*/
    264 void Animation3D::cosine(float timePassed) const
    265 {
    266   this->linear(timePassed);
    267 }
     272void Animation3D::mCosine(float timePassed) const
     273{
     274  Vector v;
     275  v = (this->nextKeyFrame->position - this->currentKeyFrame->position) * (1.0 + cos( M_PI * timePassed / this->currentKeyFrame->duration))/2.0;
     276  this->object->shiftCoor(v - this->currentKeyFrame->lastPosition);
     277  this->currentKeyFrame->lastPosition = v;
     278
     279
     280  /*
     281  this->object->setRelCoor( this->nextKeyFrame->position -
     282                            (this->nextKeyFrame->position - this->currentKeyFrame->position) *
     283                            (1.0 + cos( M_PI * timePassed / this->currentKeyFrame->duration))/2.0);
     284  */
     285}
     286
     287
    268288
    269289/**
    … …  
    271291   \param timePassed The time passed since this Keyframe began
    272292*/
    273 void Animation3D::exp(float timePassed) const
    274 {
    275   this->linear(timePassed);
     293void Animation3D::mExp(float timePassed) const
     294{
     295  PRINTF(0)("no exp animation3d defined\n");
     296  this->mLinear(timePassed);
    276297}
    277298
    … …  
    279300   \brief a negative exponential interpolation between this keyframe and the next one
    280301   \param timePassed The time passed since this Keyframe began
    281 
    282    \todo implement
    283 */
    284 void Animation3D::negExp(float timePassed) const
    285 {
    286   this->linear(timePassed);
    287 }
     302*/
     303void Animation3D::mNegExp(float timePassed) const
     304{
     305  Vector v;
     306  v = (this->nextKeyFrame->position - this->currentKeyFrame->position) * (1.0 - expf(- timePassed * expFactorMov));
     307  this->object->shiftCoor(v - this->currentKeyFrame->lastPosition);
     308  this->currentKeyFrame->lastPosition = v;
     309
     310  /*
     311  this->object->setRelCoor( this->currentKeyFrame->position +
     312                            (this->nextKeyFrame->position - this->currentKeyFrame->position) *
     313                            (1.0 - expf(- timePassed * expFactorMov)) );
     314  */
     315}
     316
    288317
    289318/**
    … …  
    293322   \todo implement
    294323*/
    295 void Animation3D::quadratic(float timePassed) const
    296 {
    297   this->linear(timePassed);
     324void Animation3D::mQuadratic(float timePassed) const
     325{
     326  PRINTF(0)("no quadratic animation3d defined\n");
     327  this->mLinear(timePassed);
    298328}
    299329
    … …  
    302332   \param timePassed The time passed since this Keyframe began
    303333*/
    304 void Animation3D::random(float timePassed) const
    305 {
     334void Animation3D::mRandom(float timePassed) const
     335{
     336  /*
    306337  this->object->setRelCoor(this->currentKeyFrame->position +
    307338                           (this->nextKeyFrame->position - this->currentKeyFrame->position) * (float)rand()/(float)RAND_MAX);
    308339  this->object->setRelDir(this->currentKeyFrame->direction +
    309340                          (this->nextKeyFrame->direction - this->currentKeyFrame->direction)* (float)rand()/(float)RAND_MAX);
    310 }
     341  */
     342}
     343
     344
     345/*==Rotation Section==========================================================*/
     346
     347
     348/**
     349   \brief Sets The kind of rotation Animation between this keyframe and the next one
     350   \param animFunc The Type of Animation to set
     351*/
     352void Animation3D::setAnimFuncRot(ANIM_FUNCTION animFuncRot)
     353{
     354  switch (animFuncRot)
     355    {
     356    default:
     357    case ANIM_CONSTANT:
     358      this->animFuncRot = &Animation3D::rConstant;
     359      break;
     360    case ANIM_LINEAR:
     361      this->animFuncRot = &Animation3D::rLinear;
     362      break;
     363    case ANIM_SINE:
     364      this->animFuncRot = &Animation3D::rSine;
     365      break;
     366    case ANIM_COSINE:
     367      this->animFuncRot = &Animation3D::rCosine;
     368      break;
     369    case ANIM_EXP:
     370      this->animFuncRot = &Animation3D::rExp;
     371      break;
     372    case ANIM_NEG_EXP:
     373      this->animFuncRot = &Animation3D::rNegExp;
     374      this->expFactorRot = -1.0 / this->currentKeyFrame->duration * logf(DELTA_X_3D);
     375      break;
     376    case ANIM_QUADRATIC:
     377      this->animFuncRot = &Animation3D::rQuadratic;
     378      break;
     379    case ANIM_RANDOM:
     380      this->animFuncRot = &Animation3D::rRandom;
     381      break;
     382
     383    }
     384}
     385
     386
     387/**
     388   \brief stays at the value of the currentKeyFrame
     389   \param timePassed The time passed since this Keyframe began
     390*/
     391void Animation3D::rConstant(float timePassed) const
     392{
     393  this->object->setRelDir(this->currentKeyFrame->direction);
     394}
     395
     396/**
     397   \brief linear interpolation between this keyframe and the next one
     398   \param timePassed The time passed since this Keyframe began
     399
     400   \todo implement also do this for direction
     401*/
     402void Animation3D::rLinear(float timePassed) const
     403{
     404  this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
     405                                     this->currentKeyFrame->direction,
     406                                     timePassed/this->currentKeyFrame->duration) );
     407}
     408
     409/**
     410   \brief a Sinusodial Interpolation between this keyframe and the next one
     411   \param timePassed The time passed since this Keyframe began
     412
     413   \todo implement
     414*/
     415void Animation3D::rSine(float timePassed) const
     416{
     417  float scale;
     418  if( timePassed < this->currentKeyFrame->duration / 2.0)
     419    scale = sin( M_PI * timePassed / this->currentKeyFrame->duration);
     420  else
     421    scale = 1.0 - sin( M_PI * timePassed / this->currentKeyFrame->duration);
     422
     423  this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
     424                                     this->currentKeyFrame->direction,
     425                                     scale) );
     426}
     427
     428
     429/**
     430   \brief a cosine interpolation between this keyframe and the next one
     431   \param timePassed The time passed since this Keyframe began
     432
     433   \todo implement
     434*/
     435void Animation3D::rCosine(float timePassed) const
     436{
     437  float scale = cos(M_PI * timePassed / this->currentKeyFrame->duration);
     438  this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
     439                                     this->currentKeyFrame->direction,
     440                                     scale) );
     441}
     442
     443
     444
     445/**
     446   \brief an exponential interpolation between this keyframe and the next one
     447   \param timePassed The time passed since this Keyframe began
     448*/
     449void Animation3D::rExp(float timePassed) const
     450{
     451  PRINTF(0)("exp rotation function not implemented\n");
     452}
     453
     454/**
     455   \brief a negative exponential interpolation between this keyframe and the next one
     456   \param timePassed The time passed since this Keyframe began
     457*/
     458void Animation3D::rNegExp(float timePassed) const
     459{
     460  float scale = (1.0 - expf(- timePassed * expFactorRot));
     461  this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
     462                                     this->currentKeyFrame->direction,
     463                                     scale) );
     464}
     465
     466
     467/**
     468   \brief a quadratic interpolation between this keyframe and the next one
     469   \param timePassed The time passed since this Keyframe began
     470
     471   \todo implement
     472*/
     473void Animation3D::rQuadratic(float timePassed) const
     474{
     475  PRINTF(0)("quadratic rotation alg not implemented\n");
     476}
     477
     478/**
     479   \brief some random animation (fluctuating)
     480   \param timePassed The time passed since this Keyframe began
     481*/
     482void Animation3D::rRandom(float timePassed) const
     483{
     484  PRINTF(0)("random rotation alg not implemented\n");
     485}
Note: See TracChangeset for help on using the changeset viewer.