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

Timestamp:

Aug 13, 2005, 10:02:40 AM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: optimizations

Location:

orxonox/trunk/src/lib

Files:

• coord/p_node.cc (modified) (12 diffs)
• coord/p_node.h (modified) (4 diffs)
• math/vector.h (modified) (3 diffs)

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

@@ -114 +114 @@
   this->toPosition = NULL;
   this->toDirection = NULL;
+  this->bias = 1.0;
 }
 
@@ -182 +183 @@
 }
 
-void PNode::setRelCoorSoft(const Vector& relCoordSoft)
+/**
+ * sets a new relative position smoothely
+ * @param relCoordSoft the new Position to iterate to
+ * @param bias how fast to iterate to this position
+ */
+void PNode::setRelCoorSoft(const Vector& relCoordSoft, float bias)
 {
   if (likely(this->toPosition == NULL))
@@ -188 +194 @@
 
   *this->toPosition = relCoordSoft;
-}
-
-
-/**
- *  set relative coordinates
+  this->bias = bias;
+}
+
+
+/**
+ *  set relative coordinates smoothely
  * @param x x-relative coordinates to its parent
  * @param y y-relative coordinates to its parent
  * @param z z-relative coordinates to its parent
-   \see  void PNode::setRelCoor (const Vector& relCoord)
- */
-void PNode::setRelCoorSoft (float x, float y, float z)
-{
-  this->setRelCoorSoft(Vector(x, y, z));
+   \see  void PNode::setRelCoorSoft (const Vector&, float)
+ */
+void PNode::setRelCoorSoft (float x, float y, float z, float bias)
+{
+  this->setRelCoorSoft(Vector(x, y, z), bias);
 }
 
@@ -295 +302 @@
  * sets the Relative Direction of this node to its parent in a Smoothed way
  * @param relDirSoft the direction to iterate to smoothely.
- */
-void PNode::setRelDirSoft(const Quaternion& relDirSoft)
+ * @param bias how fast to iterate to the new Direction
+ */
+void PNode::setRelDirSoft(const Quaternion& relDirSoft, float bias)
 {
   if (likely(this->toDirection == NULL))
@@ -302 +310 @@
 
   *this->toDirection = relDirSoft;
+  this->bias = bias;
 }
 
@@ -312 +321 @@
  * main difference is, that here you give a directional vector, that will be translated into a Quaternion
  */
-void PNode::setRelDirSoft(float x, float y, float z)
-{
-  this->setRelDirSoft(Quaternion(Vector(x,y,z), Vector(0,1,0)));
+void PNode::setRelDirSoft(float x, float y, float z, float bias)
+{
+  this->setRelDirSoft(Quaternion(Vector(x,y,z), Vector(0,1,0)), bias);
 }
 
@@ -383 +392 @@
   if( likely(pNode->parent != NULL))
     {
-      PRINTF(3)("PNode::addChild() - reparenting node: removing it and adding it again\n");
+      PRINTF(4)("PNode::addChild() - reparenting node: removing it and adding it again\n");
       pNode->parent->children->remove(pNode);
     }
@@ -463 +472 @@
  * @param parentNode the new Node to connect this node to.
  */
-void PNode::softReparent(PNode* parentNode)
-{
+void PNode::softReparent(PNode* parentNode, float bias)
+{
+  if (this->parent == parentNode)
+    return;
+
   //this->setRelCoorSoft(this->getRelCoor());
   if (likely(this->toPosition == NULL))
@@ -476 +488 @@
     *this->toDirection = this->getRelDir();
   }
+  this->bias = bias;
 
 
@@ -491 +504 @@
 }
 
-void PNode::softReparent(const char* parentName)
+void PNode::softReparent(const char* parentName, float bias)
 {
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
   if (parentNode != NULL)
-    this->softReparent(parentNode);
+    this->softReparent(parentNode, bias);
 }
 
@@ -555 +568 @@
       if (unlikely(this->toPosition != NULL))
       {
-        Vector moveVect = (*this->toPosition - this->getRelCoor()) *dt;
+        Vector moveVect = (*this->toPosition - this->getRelCoor()) *dt*bias;
 
         if (likely(moveVect.len() >= .001))
@@ -570 +583 @@
       if (unlikely(this->toDirection != NULL))
       {
-        Quaternion rotQuat = (*this->toDirection - this->getRelDir()) *dt;
+        Quaternion rotQuat = (*this->toDirection - this->getRelDir()) *dt*bias;
 
 //        if (likely(rotQuat.len() >= .001))

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

@@ -62 +62 @@
   void setRelCoor (const Vector& relCoord);
   void setRelCoor (float x, float y, float z);
-  void setRelCoorSoft(const Vector& relCoordSoft);
-  void setRelCoorSoft(float x, float y, float z);
+  void setRelCoorSoft(const Vector& relCoordSoft, float bias = 1.0);
+  void setRelCoorSoft(float x, float y, float z, float bias = 1.0);
   /** @returns the relative position */
   inline const Vector& getRelCoor () const { return this->relCoordinate; };
@@ -74 +74 @@
   void setRelDir (const Quaternion& relDir);
   void setRelDir (float x, float y, float z);
-  void setRelDirSoft(const Quaternion& relDirSoft);
-  void setRelDirSoft(float x, float y, float z);
+  void setRelDirSoft(const Quaternion& relDirSoft, float bias = 1.0);
+  void setRelDirSoft(float x, float y, float z, float bias = 1.0);
   /** @returns the relative Direction */
   inline const Quaternion& getRelDir () const { return this->relDirection; };
@@ -104 +104 @@
   PNode* getParent () const { return this->parent; };
 
-  void softReparent(PNode* parentNode);
-  void softReparent(const char* parentName);
+  void softReparent(PNode* parentNode, float bias = 1.0);
+  void softReparent(const char* parentName, float bias = 1.0);
 
   void setParentMode (PARENT_MODE parentMode);
@@ -144 +144 @@
   Vector*         toPosition;         //!< a position to which to iterate. (This is used in conjunction with softReparent.and set*CoorSoft)
   Quaternion*     toDirection;        //!< a direction to which to iterate. (This is used in conjunction with softReparent and set*DirSoft)
+  float           bias;               //!< how fast to iterate to the given position (default is 1)
 
   PNode*          parent;             //!< a pointer to the parent node

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

@@ -29 +29 @@
   /** @param index The index of the "array" @returns the x/y/z coordinate */
   inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; }
-  /*** @param v The vector to add @returns the addition between two vectors (this + v) */
+  /** @param v The vector to add @returns the addition between two vectors (this + v) */
   inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); };
-  /*** @param v The vector to add @returns the addition between two vectors (this + v) */
+  /** @param v The vector to add @returns the addition between two vectors (this + v) */
   inline Vector operator+ (const sVec3D& v) const { return Vector(x + v[0], y + v[1], z + v[2]); };
   /** @param v The vector to add  @returns the addition between two vectors (this += v) */
@@ -57 +57 @@
   /** @param f a factor to divide the vector with @returns the vector divided by f (this /= f) */
   inline const Vector& operator/= (float f) {if (unlikely(f == 0.0)) {this->x=0;this->y=0;this->z=0;} else {this->x /= f; this->y /= f; this->z /= f;} return *this; };
-  /** \brief copy constructor @todo (i do not know it this is faster) @param v the vector to assign to this vector. @returns the vector v */
+  /**  copy constructor @todo (i do not know it this is faster) @param v the vector to assign to this vector. @returns the vector v */
   inline const Vector& operator= (const Vector& v) { this->x = v.x; this->y = v.y; this->z = v.z; return *this; };
-  /** \brief copy constructor* @param v the sVec3D to assign to this vector. @returns the vector v */
+  /** copy constructor* @param v the sVec3D to assign to this vector. @returns the vector v */
   inline const Vector& operator= (const sVec3D& v) { this->x = v[0]; this->y = v[1]; this->z = v[2]; }
   /** @param v: the other vector \return the dot product of the vectors */
@@ -65 +65 @@
   /** @param v: the corss-product partner @returns the cross-product between this and v (this (x) v) */
   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 ); }
-  /** \brief scales the this vector with v* @param v the vector to scale this with */
+  /** scales the this vector with v* @param v the vector to scale this with */
   void scale(const Vector& v) {   x *= v.x;  y *= v.y; z *= v.z; };
   /** @returns the length of the vector */
   inline float len() const { return sqrt (x*x+y*y+z*z); }
-  /** \brief normalizes the vector */
+  /** normalizes the vector */
   inline void normalize() {
                       float l = len();