Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 4998 in orxonox.OLD for orxonox


Ignore:
Timestamp:
Aug 13, 2005, 7:19:51 PM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: more optimizations of the Quaternion Class.
Now the 3D-rotation is much faster through this code:

Vector tmpRot = this→getAbsDir().getSpacialAxis();
glRotatef (this→getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );

instead of the old Matrix-approach. furthermore glRotate is optimized much better in openGL as is clearly stated in the red book

also implemented some other really useless functions for Quaternion

Location:
orxonox/trunk/src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • orxonox/trunk/src/lib/coord/p_node.cc

    r4997 r4998  
    327327}
    328328
    329 
    330329/**
    331330 *  sets the absolute direction (0,0,1)
     
    543542      if (unlikely(this->toDirection != NULL))
    544543      {
    545         Quaternion rotQuat = (*this->toDirection / this->getRelDir()) *dt*bias;
    546         rotQuat.debug();
    547 //        if (likely(rotQuat.len() >= .001))
     544        Quaternion rotQuat = Quaternion(.1, Vector(0,1,0));// (*this->toDirection / this->relDirection);
     545//         printf("1: ");
     546//         this->relDirection.debug();
     547//         printf("2: ");
     548//         this->toDirection->debug();
     549//         printf("3: ");
     550//         rotQuat.debug();
     551
     552        if (true)//likely(rotQuat.len() >= .001))
    548553        {
    549554          this->shiftDir(rotQuat);
    550555        }
    551 /*        else
     556        else
    552557        {
    553558          delete this->toCoordinate;
    554559          this->toCoordinate = NULL;
    555560          PRINTF(5)("SmoothMove of %s finished\n", this->getName());
    556         }*/
     561        }
    557562      }
    558563
     
    664669  glMatrixMode(GL_MODELVIEW);
    665670  glPushMatrix();
    666   float matrix[4][4];
    667671
    668672  /* translate */
     
    671675                this->getAbsCoor ().z);
    672676  /* rotate */
    673   this->getAbsDir ().matrix (matrix);
    674   glMultMatrixf((float*)matrix);
     677//  this->getAbsDir ().matrix (matrix);
     678//  glMultMatrixf((float*)matrix);
     679
     680  Vector tmpRot = this->getAbsDir().getSpacialAxis();
     681  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    675682  {
    676683    glBegin(GL_LINE_STRIP);
  • orxonox/trunk/src/lib/math/vector.cc

    r4997 r4998  
    197197 * @returns the Result of the smooth move
    198198*/
    199 Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t)
     199Quaternion Quaternion::quatSlerp(const Quaternion& from, const Quaternion& to, float t)
    200200{
    201201  float tol[4];
     
    306306void Quaternion::debug()
    307307{
    308   PRINT(0)("Quaternion Debug Information\n");
    309308  PRINT(0)("real a=%f; imag: x=%f y=%f z=%f\n", w, v.x, v.y, v.z);
    310309}
  • orxonox/trunk/src/lib/math/vector.h

    r4997 r4998  
    150150  inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
    151151  /** conjugates this Quaternion @returns the conjugate */
    152   inline Quaternion conjugate () const { Quaternion r(*this); r.v = Vector() - r.v; return r; };
     152  inline Quaternion conjugate () const { return Quaternion(Vector(-v.x, -v.y, -v.z), this->w); };
    153153  /** @returns the norm of The Quaternion */
    154154  inline float norm () const { return w*w + v.x*v.x + v.y*v.y + v.z*v.z; };
     
    158158  inline Vector apply (const Vector& v) const { return (*this * Quaternion(v, 0) * conjugate()).v; };
    159159  void matrix (float m[4][4]) const;
     160  /** @returns the normalized Quaternion (|this|) */
     161  inline Quaternion getNormalized() const { float n = this->norm(); return Quaternion(this->v/n, this->w/n); };
     162  /** normalizes the current Quaternion */
     163  inline void normalize() { float n = this->norm(); this->v /= n; this->w/=n; };
     164
     165  /** @returns the rotational axis of this Quaternion */
     166  inline Vector getSpacialAxis() const { return this->v / sin(acos(w));/*sqrt(v.x*v.x + v.y*v.y + v.z+v.z);*/ };
     167  /** @returns the rotational angle of this Quaternion around getSpacialAxis()  !! IN DEGREE !! */
     168  inline float getSpacialAxisAngle() const { return 360 / M_PI * acos(this->w); };
     169
     170  static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
    160171
    161172  void debug();
     173
    162174
    163175 public:
     
    167179};
    168180
    169 Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
    170181
    171182
  • orxonox/trunk/src/util/animation/animation3d.cc

    r4836 r4998  
    401401void Animation3D::rLinear(float timePassed) const
    402402{
    403   this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
    404                                      this->currentKeyFrame->direction,
    405                                      timePassed/this->currentKeyFrame->duration) );
     403  this->object->setRelDir(Quaternion::quatSlerp( this->nextKeyFrame->direction,
     404                          this->currentKeyFrame->direction,
     405                          timePassed/this->currentKeyFrame->duration) );
    406406}
    407407
     
    420420    scale = 1.0 - sin( M_PI * timePassed / this->currentKeyFrame->duration);
    421421
    422   this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
    423                                      this->currentKeyFrame->direction,
    424                                      scale) );
     422  this->object->setRelDir(Quaternion::quatSlerp( this->nextKeyFrame->direction,
     423                          this->currentKeyFrame->direction,
     424                          scale) );
    425425}
    426426
     
    435435{
    436436  float scale = cos(M_PI * timePassed / this->currentKeyFrame->duration);
    437   this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
    438                                      this->currentKeyFrame->direction,
    439                                      scale) );
     437  this->object->setRelDir(Quaternion::quatSlerp( this->nextKeyFrame->direction,
     438                          this->currentKeyFrame->direction,
     439                          scale) );
    440440}
    441441
     
    458458{
    459459  float scale = (1.0 - expf(- timePassed * expFactorRot));
    460   this->object->setRelDir(quatSlerp( this->nextKeyFrame->direction,
    461                                      this->currentKeyFrame->direction,
    462                                      scale) );
     460  this->object->setRelDir(Quaternion::quatSlerp( this->nextKeyFrame->direction,
     461                          this->currentKeyFrame->direction,
     462                          scale) );
    463463}
    464464
  • orxonox/trunk/src/world_entities/camera.cc

    r4997 r4998  
    142142    case VIEW_FRONT:
    143143      this->toFovy = 120.0;
    144       this->softReparent("Player");
    145       this->target->softReparent("Player");
    146       this->setRelCoorSoft(4, 0, 0);
    147       this->target->setRelCoorSoft(10,0,0);
     144//       this->softReparent("Player");
     145//       this->target->softReparent("Player");
     146//       this->setRelCoorSoft(4, 0, 0);
     147//       this->target->setRelCoorSoft(10,0,0);
     148      this->target->setRelDirSoft(Quaternion(M_PI/4.0, Vector(0,1,0)));
    148149      break;
    149150    case VIEW_LEFT:
  • orxonox/trunk/src/world_entities/player.cc

    r4997 r4998  
    222222  glMatrixMode(GL_MODELVIEW);
    223223  glPushMatrix();
    224   float matrix[4][4];
    225 
    226224  /* translate */
    227225  glTranslatef (this->getAbsCoor ().x,
     
    229227                this->getAbsCoor ().z);
    230228  /* rotate */
    231   this->getAbsDir ().matrix (matrix);
    232   glMultMatrixf((float*)matrix);
    233 
     229  Vector tmpRot = this->getAbsDir().getSpacialAxis();
     230  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    234231  this->model->draw();
    235232  glPopMatrix();
  • orxonox/trunk/src/world_entities/skybox.cc

    r4836 r4998  
    167167  this->size = size;
    168168}
    169 
    170 /**
    171  *  draws the SkyBox
    172 */
    173 void SkyBox::draw()
    174 {
    175   glPushMatrix();
    176   glMatrixMode(GL_MODELVIEW);
    177   Vector r = this->getAbsCoor();
    178   glTranslatef(r.x, r.y, r.z);
    179 
    180   this->model->draw();
    181 
    182   glPopMatrix();
    183 }
    184 
    185169
    186170/**
  • orxonox/trunk/src/world_entities/skybox.h

    r4836 r4998  
    3434
    3535  void setSize(float size);
    36   /** \brief assumes jpg as input-format */
     36  /** assumes jpg as input-format */
    3737  void setTexture(const char* name) { setTextureAndType (name, "jpg"); };
    3838
     
    4040  void setTextures(const char* top, const char* bottom, const char* left,
    4141                   const char* right, const char* front, const char* back);
    42 
    43   virtual void draw();
    4442
    4543 private:
  • orxonox/trunk/src/world_entities/terrain.cc

    r4924 r4998  
    106106  glMatrixMode(GL_MODELVIEW);
    107107  glPushMatrix();
    108   float matrix[4][4];
    109108
    110109  /* translate */
     
    113112                this->getAbsCoor ().z);
    114113  /* rotate */
    115   this->getAbsDir ().matrix (matrix);
    116   glMultMatrixf((float*)matrix);
     114  Vector tmpRot = this->getAbsDir().getSpacialAxis();
     115  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    117116
    118117  if (this->objectList)
  • orxonox/trunk/src/world_entities/world_entity.cc

    r4885 r4998  
    179179  glMatrixMode(GL_MODELVIEW);
    180180  glPushMatrix();
    181   float matrix[4][4];
    182 
    183181  /* translate */
    184182  glTranslatef (this->getAbsCoor ().x,
     
    186184                this->getAbsCoor ().z);
    187185  /* rotate */
    188   this->getAbsDir ().matrix (matrix);
    189   glMultMatrixf((float*)matrix);
     186  Vector tmpRot = this->getAbsDir().getSpacialAxis();
     187  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    190188
    191189  if (this->obbTree)
Note: See TracChangeset for help on using the changeset viewer.