Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 3966 in orxonox.OLD for orxonox/trunk/src/lib


Ignore:
Timestamp:
Apr 26, 2005, 12:23:38 AM (20 years ago)
Author:
bensch
Message:

orxonox/trunk: merged branches/particleEngine into the trunk, because of the new vector class
merged with command:
svn merge -r 3922:HEAD particleEngine/ ../trunk/

not merged src/story_entities/world.cc. will do this at a later time (do not forget)

Location:
orxonox/trunk/src/lib
Files:
2 deleted
8 edited
7 copied

Legend:

Unmodified
Added
Removed

  • orxonox/trunk/src/lib/coord/null_parent.cc

    r3809 r3966  
    5454  this->parent = this;
    5555  this->mode = PNODE_ALL;
    56   *this->absCoordinate = absCoordinate;
     56  this->absCoordinate = absCoordinate;
    5757  this->setName("NullParent");
    5858}
    … …  
    8080{
    8181
    82   PRINTF(4)("NullParent::update - (%f, %f, %f)\n", this->absCoordinate->x, this->absCoordinate->y, this->absCoordinate->z);
    83   *this->absCoordinate = *this->relCoordinate;
    84   *this->absDirection = parent->getAbsDir () * *this->relDirection;
     82  PRINTF(4)("NullParent::update - (%f, %f, %f)\n", this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z);
     83  this->absCoordinate = this->relCoordinate;
     84  this->absDirection = parent->getAbsDir () * this->relDirection;
    8585
    8686  tIterator<PNode>* iterator = this->children->getIterator();

  • orxonox/trunk/src/lib/coord/p_node.cc

    r3860 r3966  
    6060  this->init(parent);
    6161
    62   *this->absCoordinate = absCoordinate;
     62  this->absCoordinate = absCoordinate;
    6363
    6464  if (likely(parent != NULL))
    6565  {
    66     *this->relCoordinate = *this->absCoordinate - parent->getAbsCoor ();
     66    this->relCoordinate = this->absCoordinate - parent->getAbsCoor();
    6767    parent->addChild (this);
    6868  }
    69   else
    70     this->relCoordinate = new Vector();
    7169}
    7270
    … …  
    8987  delete []this->objectName;
    9088
    91   delete this->relCoordinate;
    92   delete this->absCoordinate;
    93   delete this->relDirection;
    94   delete this->absDirection;
    95   delete this->lastAbsCoordinate;
    96   delete this->diffCoordinate;
    9789}
    9890
    … …  
    108100  this->objectName = NULL;
    109101  this->time = 1.0; /* set time to 1 to make divisions by zero impossible */
    110 
    111   this->absCoordinate = new Vector();
    112   this->relCoordinate = new Vector();
    113   this->absDirection = new Quaternion();
    114   this->relDirection = new Quaternion();
    115   this->lastAbsCoordinate = new Vector();
    116   this->diffCoordinate = new Vector();
    117102}
    118103
    … …  
    158143{
    159144  this->bRelCoorChanged = true;
    160   *this->relCoordinate = relCoord;
     145  this->relCoordinate = relCoord;
    161146}
    162147
    … …  
    182167{
    183168  this->bAbsCoorChanged = true;
    184   *this->absCoordinate = absCoord;
     169  this->absCoordinate = absCoord;
    185170}
    186171
    … …  
    211196  if( unlikely(this->bAbsCoorChanged))
    212197    {
    213       *this->absCoordinate = *this->absCoordinate + shift;
     198      this->absCoordinate += shift;
    214199    }
    215200  else
    216201    {
    217       *this->relCoordinate = *this->relCoordinate + shift;
     202      this->relCoordinate += shift;
    218203      this->bRelCoorChanged = true;
    219204    }
    … …  
    241226{
    242227  this->bRelCoorChanged = true;
    243   *this->relDirection = relDir;
     228  this->relDirection = relDir;
    244229}
    245230
    … …  
    264249{
    265250  this->bAbsDirChanged = true;
    266   *this->absDirection = absDir;
     251  this->absDirection = absDir;
    267252}
    268253
    … …  
    293278{
    294279  this->bRelDirChanged = true;
    295   *this->relDirection = *this->relDirection * shift;
     280  this->relDirection = this->relDirection * shift;
    296281}
    297282
    … …  
    303288float PNode::getSpeed() const
    304289{
    305   *this->diffCoordinate = *this->absCoordinate - *this->lastAbsCoordinate;
    306   return this->diffCoordinate->len() / this->time;
    307 }
    308 
     290  return (this->absCoordinate - this->lastAbsCoordinate).len() / this->time;
     291}
     292
     293/**
     294   \returns the Velocity of the PNode
     295*/
     296Vector PNode::getVelocity() const
     297{
     298  return (this->absCoordinate - this->lastAbsCoordinate) / this->time;
     299}
    309300
    310301/**
    … …  
    432423void PNode::update (float dt)
    433424{
    434   *this->lastAbsCoordinate = *this->absCoordinate;
     425  this->lastAbsCoordinate = this->absCoordinate;
    435426  this->time = dt;
    436   PRINTF(4)("PNode::update - %s - (%f, %f, %f)\n", this->objectName, this->absCoordinate->x, this->absCoordinate->y, this->absCoordinate->z);
     427  PRINTF(4)("PNode::update - %s - (%f, %f, %f)\n", this->objectName, this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z);
    437428
    438429
    … …  
    442433        {
    443434          /* if you have set the absolute coordinates this overrides all other changes */
    444           *this->relCoordinate = *this->absCoordinate - parent->getAbsCoor ();
     435          this->relCoordinate = this->absCoordinate - parent->getAbsCoor ();
    445436        }
    446437      if( likely(this->bRelCoorChanged) /*&& this->timeStamp != DataTank::timeStamp*/)
    … …  
    455446            }
    456447            else */
    457           *this->absCoordinate = parent->getAbsCoor() + *this->relCoordinate;         /* update the current absCoordinate */
     448          this->absCoordinate = parent->getAbsCoor() + this->relCoordinate;           /* update the current absCoordinate */
    458449        }
    459450    }
    … …  
    464455        {
    465456          /* if you have set the absolute coordinates this overrides all other changes */
    466           *this->relDirection = *this->absDirection - parent->getAbsDir();
     457          this->relDirection = this->absDirection - parent->getAbsDir();
    467458        }
    468459      else if( likely(this->bRelDirChanged) /*&& this->timeStamp != DataTank::timeStamp*/)
    469460        {
    470461          /* update the current absDirection - remember * means rotation around sth.*/
    471           *this->absDirection = parent->getAbsDir() * *this->relDirection;
     462          this->absDirection = parent->getAbsDir() * this->relDirection;
    472463        }
    473464    }
    … …  
    478469        {
    479470          /* if you have set the absolute coordinates this overrides all other changes */
    480           *this->relCoordinate = *this->absCoordinate - parent->getAbsCoor ();
     471          this->relCoordinate = this->absCoordinate - parent->getAbsCoor ();
    481472        }
    482473      else if( likely(this->bRelCoorChanged) /*&& this->timeStamp != DataTank::timeStamp*/)
    … …  
    486477            *this->absCoordinate = *this->relCoordinate;
    487478            else*/
    488           *this->absCoordinate = parent->getAbsCoor() + parent->getAbsDir().apply(*this->relCoordinate);              /* update the current absCoordinate */
     479          this->absCoordinate = parent->getAbsCoor() + parent->getAbsDir().apply(this->relCoordinate);        /* update the current absCoordinate */
    489480        }
    490481    }
    … …  
    540531{
    541532  PRINTF(2)("PNode::debug() - absCoord: (%f, %f, %f)\n",
    542          this->absCoordinate->x,
    543          this->absCoordinate->y,
    544          this->absCoordinate->z);
     533         this->absCoordinate.x,
     534         this->absCoordinate.y,
     535         this->absCoordinate.z);
    545536}
    546537
    … …  
    551542  for debug purposes realy usefull, not used to work properly
    552543*/
    553 void PNode::setName (char* newName)
     544void PNode::setName (const char* newName)
    554545{
    555546  this->objectName = new char[strlen(newName)+1];
    … …  
    561552  \brief gets the name of the node
    562553*/
    563 char* PNode::getName ()
     554const char* PNode::getName ()
    564555{
    565556  return this->objectName;

  • orxonox/trunk/src/lib/coord/p_node.h

    r3813 r3966  
    5757
    5858
    59   inline Vector* getRelCoor () const { return this->relCoordinate; }
     59  inline const Vector& getRelCoor () const { return this->relCoordinate; }
    6060  void setRelCoor (const Vector& relCoord);
    61   inline Vector getAbsCoor () const { return *this->absCoordinate; }
     61  inline const Vector& getAbsCoor () const { return this->absCoordinate; }
    6262  void setAbsCoor (const Vector& absCoord);
    6363  void shiftCoor (const Vector& shift);
    6464
    65   inline Quaternion getRelDir () const { return *this->relDirection; }
     65  inline const Quaternion& getRelDir () const { return this->relDirection; }
    6666  void setRelDir (const Quaternion& relDir);
    67   inline Quaternion getAbsDir () const { return *this->absDirection; }
     67  inline const Quaternion& getAbsDir () const { return this->absDirection; }
    6868  void setAbsDir (const Quaternion& absDir);
    6969  void shiftDir (const Quaternion& shift);
    7070
    7171  float getSpeed() const;
     72  Vector getVelocity() const;
    7273
    7374  void addChild (PNode* pNode, int parentingMode = DEFAULT_MODE);
    … …  
    8586  void processTick (float dt);
    8687
    87   void setName (char* newName);
    88   char* getName ();
     88  void setName (const char* newName);
     89  const char* getName ();
    8990
    9091
    … …  
    99100  bool bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
    100101
    101   Vector* relCoordinate;    //!< coordinates relative to the parent
    102   Vector* absCoordinate;    //!< absolute coordinates in the world ( from (0,0,0) )
    103   Quaternion* relDirection; //!< direction relative to the parent
    104   Quaternion* absDirection; //!< absolute direvtion in the world ( from (0,0,1) )
     102  Vector relCoordinate;    //!< coordinates relative to the parent
     103  Vector absCoordinate;    //!< absolute coordinates in the world ( from (0,0,0) )
     104  Quaternion relDirection; //!< direction relative to the parent
     105  Quaternion absDirection; //!< absolute direvtion in the world ( from (0,0,1) )
    105106
    106107  int mode;                //!< the mode of the binding
    … …  
    109110  void init(PNode* parent);
    110111
    111   Vector* lastAbsCoordinate; //!< this is used for speedcalculation, it stores the last coordinate
    112   Vector* diffCoordinate;    //!< this is stored here for performance reasons, difference to the last vector
     112  Vector lastAbsCoordinate; //!< this is used for speedcalculation, it stores the last coordinate
     113  Vector diffCoordinate;    //!< this is stored here for performance reasons, difference to the last vector
    113114  float time;                //!< time since last update
    114115};

  • orxonox/trunk/src/lib/graphics/importer/material.cc

    r3914 r3966  
    8888 
    8989  // setting the transparency
    90   if (this->transparency == 1.0)
    91     {
    92       glDisable(GL_BLEND);
    93     }
    94   else
     90  if (this->transparency < 1.0)
    9591    {
    9692      glEnable(GL_BLEND);
    … …  
    9894      glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    9995    }
     96  else
     97    {
     98      glDisable(GL_BLEND);
     99      glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
     100    }
     101
    100102
    101103  // setting illumination Model
    … …  
    109111      glEnable(GL_TEXTURE_2D);
    110112      glBindTexture(GL_TEXTURE_2D, this->diffuseTexture->getTexture());
     113
     114      /* This allows alpha blending of 2D textures with the scene */
     115      if (this->diffuseTexture->hasAlpha())
     116        {
     117          glEnable(GL_BLEND);
     118          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     119        }
    111120    }
    112121  else

  • orxonox/trunk/src/lib/graphics/importer/texture.cc

    r3905 r3966  
    2525Texture::Texture(const char* imageName)
    2626{
     27  bAlpha = false;
    2728  this->texture = 0;
    2829  if (imageName)
    … …  
    112113      if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
    113114        SDL_SetAlpha(surface, saved_flags | SDL_OPENGL, saved_alpha);
     115        this->bAlpha = true;
    114116      }
    115117     
    … …  
    119121      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    120122      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    121       /*      glTexImage2D(GL_TEXTURE_2D,
     123      // build the Texture
     124      glTexImage2D(GL_TEXTURE_2D,
    122125                   0,
    123126                   GL_RGBA,
    … …  
    127130                   GL_UNSIGNED_BYTE,
    128131                   image->pixels);
    129       */
     132      // build the MipMaps
    130133      gluBuild2DMipmaps(GL_TEXTURE_2D,
    131                         3,
     134                        GL_RGBA,
    132135                        w,
    133136                        h,
    … …  
    135138                        GL_UNSIGNED_BYTE,
    136139                        image->pixels);
    137 
     140     
    138141      SDL_FreeSurface(image); /* No longer needed */
    139142     

  • orxonox/trunk/src/lib/graphics/importer/texture.h

    r3905 r3966  
    2323  char* searchTextureInPaths(const char* texName) const;
    2424  void swap(unsigned char &a, unsigned char &b);
     25
     26  bool bAlpha;           //!< if the texture has an alpha channel.
    2527 public:
    2628  Texture(const char* imageName = NULL);
    … …  
    3032  inline GLuint getTexture(void) {return this->texture;}
    3133  GLuint loadTexToGL (SDL_Surface* surface);
     34  inline bool hasAlpha(void) {return bAlpha;}
    3235
    3336  bool loadImage(const char* imageName);

  • orxonox/trunk/src/lib/math/vector.cc

    r3860 r3966  
    100100*/
    101101
    102 Vector* Vector::getNormalized()
     102Vector Vector::getNormalized()
    103103{
    104104  float l = len();
    105105  if(unlikely(l != 1.0))
    106106    {
    107       return this;
     107      return *this;
    108108    }
    109109  else if(unlikely(l == 0.0))
    110110    {
    111       return 0;
     111      return *this;
    112112    }
    113113
    114   return new Vector(x / l, y /l, z / l);
     114  return *this / l;
    115115}
    116116
    … …  
    172172   \brief Outputs the values of the Vector
    173173*/
    174 void Vector::debug(void)
     174void Vector::debug(void) const
    175175{
    176176  PRINT(0)("Vector Debug information\n");
    … …  
    438438   \param to to where
    439439   \param t the time this transformation should take
    440    \param res The approximation-density
    441 */
    442 void Quaternion::quatSlerp(const Quaternion* from, const Quaternion* to, float t, Quaternion* res)
     440
     441   \returns the Result of the smooth move
     442*/
     443Quaternion Quaternion::quatSlerp(const Quaternion& from, const Quaternion& to, float t)
    443444{
    444445  float tol[4];
    … …  
    446447  DELTA = 0.2;
    447448
    448   cosom = from->v.x * to->v.x + from->v.y * to->v.y + from->v.z * to->v.z + from->w * to->w;
     449  cosom = from.v.x * to.v.x + from.v.y * to.v.y + from.v.z * to.v.z + from.w * to.w;
    449450
    450451  if( cosom < 0.0 )
    451452    {
    452453      cosom = -cosom;
    453       tol[0] = -to->v.x;
    454       tol[1] = -to->v.y;
    455       tol[2] = -to->v.z;
    456       tol[3] = -to->w;
     454      tol[0] = -to.v.x;
     455      tol[1] = -to.v.y;
     456      tol[2] = -to.v.z;
     457      tol[3] = -to.w;
    457458    }
    458459  else
    459460    {
    460       tol[0] = to->v.x;
    461       tol[1] = to->v.y;
    462       tol[2] = to->v.z;
    463       tol[3] = to->w;
     461      tol[0] = to.v.x;
     462      tol[1] = to.v.y;
     463      tol[2] = to.v.z;
     464      tol[3] = to.w;
    464465    }
    465466 
    466467  //if( (1.0 - cosom) > DELTA )
    467468  //{
    468       omega = acos(cosom);
    469       sinom = sin(omega);
    470       scale0 = sin((1.0 - t) * omega) / sinom;
    471       scale1 = sin(t * omega) / sinom;
    472       //}
    473       /*
    474   else
     469  omega = acos(cosom);
     470  sinom = sin(omega);
     471  scale0 = sin((1.0 - t) * omega) / sinom;
     472  scale1 = sin(t * omega) / sinom;
     473  //}
     474  /*
     475    else
    475476    {
    476       scale0 = 1.0 - t;
    477       scale1 = t;
     477    scale0 = 1.0 - t;
     478    scale1 = t;
    478479    }
    479       */
    480   res->v.x = scale0 * from->v.x + scale1 * tol[0];
    481   res->v.y = scale0 * from->v.y + scale1 * tol[1];
    482   res->v.z = scale0 * from->v.z + scale1 * tol[2];
    483   res->w = scale0 * from->w + scale1 * tol[3];
     480  */
     481
     482
     483  /*
     484    Quaternion res;
     485    res.v.x = scale0 * from.v.x + scale1 * tol[0];
     486    res.v.y = scale0 * from.v.y + scale1 * tol[1];
     487    res.v.z = scale0 * from.v.z + scale1 * tol[2];
     488    res.w = scale0 * from.w + scale1 * tol[3];
     489  */
     490  return Quaternion(scale0 * from.w + scale1 * tol[3],
     491                    Vector(scale0 * from.v.x + scale1 * tol[0],
     492                           scale0 * from.v.y + scale1 * tol[1],
     493                           scale0 * from.v.z + scale1 * tol[2]));
    484494}
    485495

  • orxonox/trunk/src/lib/math/vector.h

    r3860 r3966  
    3131
    3232  inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }
     33  inline const Vector& operator+= (const Vector& v) {this->x += v.x; this->y += v.y; this->z += v.z; return *this;}
    3334  inline Vector operator- (const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
     35  inline const Vector& operator-= (const Vector& v) {this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this;}
    3436  inline float operator* (const Vector& v) const { return x * v.x + y * v.y + z * v.z; }
     37  inline const Vector& operator*= (const Vector& v) {this->x *= v.x; this->y *= v.y; this->z *= v.z; return *this;}
    3538  inline Vector operator* (float f) const { return Vector(x * f, y * f, z * f); }
     39  inline const Vector& operator*= (float f) {this->x *= f; this->y *= f; this->z *= f; return *this;}
    3640  Vector operator/ (float f) const;
     41  inline const Vector& operator/= (float f) {this->x /= f; this->y /= f; this->z /= f; return *this;}
     42  inline const Vector& operator= (const Vector& v) {this->x = v.x; this->y = v.y; this->z = v.z; return *this;}
    3743  float dot (const Vector& v) const;
    38   inline Vector cross (const Vector& v) const {  return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
     44  inline Vector cross (const Vector& v) const { return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
    3945  void scale(const Vector& v);
    4046  inline float len() const { return sqrt (x*x+y*y+z*z); }
    … …  
    5056                      z = z / l;
    5157                    }
    52   Vector* getNormalized();
     58  Vector getNormalized();
    5359  Vector abs();
    5460
    55   void debug();
     61  void debug() const;
    5662};
    5763
    … …  
    7682  Quaternion (float roll, float pitch, float yaw);
    7783  Quaternion operator/ (const float& f) const;
     84  inline const Quaternion operator/= (const float& f) {*this = *this / f; return *this;}
    7885  Quaternion operator* (const float& f) const;
     86  inline const Quaternion operator*= (const float& f) {*this = *this * f; return *this;}
    7987  Quaternion operator* (const Quaternion& q) const;
     88  inline const Quaternion operator*= (const Quaternion& q) {*this = *this * q; return *this;}
    8089  inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); }
     90  inline const Quaternion& operator+= (const Quaternion& q) {this->v += q.v; this->w += q.w; return *this;}
    8191  inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); }
     92  inline const Quaternion& operator-= (const Quaternion& q) {this->v -= q.v; this->w -= q.w; return *this;}
     93  inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
    8294  Quaternion conjugate () const {  Quaternion r(*this);
    8395  r.v = Vector() - r.v;
    … …  
    8799  float norm () const;
    88100  void matrix (float m[4][4]) const;
    89   void quatSlerp(const Quaternion* from, const Quaternion* to, const float t, Quaternion* res);
     101  Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
    90102 
    91103  void debug();
Note: See TracChangeset for help on using the changeset viewer.