Changeset 4609 in orxonox.OLD

Timestamp:

Jun 12, 2005, 11:37:57 PM (19 years ago)

Author:

patrick

Message:

orxonox/trunk: obb subdivision algorithm started, some modifications in the vector class to support additions with sVec3D

Location:

orxonox/trunk/src/lib

Files:

• collision_detection/obb_tree.cc (modified) (1 diff)
• collision_detection/obb_tree_node.cc (modified) (5 diffs)
• math/vector.h (modified) (1 diff)

orxonox/trunk/src/lib/collision_detection/obb_tree.cc

@@ -98 +98 @@
   int const length = 3;
   sVec3D* vertList = new sVec3D[length];
-  sVec3D data[length]  = {{5.0, 0.0, 0.0},{2.0, 0.0, 5.0},{14.0, 0.0, 0.0}};//, {5.0, 0.0, 1.0}, {12.0, 0.0, 8.0}, {3.0, 5.0, 4.9}};
+  sVec3D data[length]  = {{5.0, 0.0, 0.0},{2.0, 0.0, 0.5},{14.0, 0.0, 0.0}};//, {5.0, 0.0, 1.0}, {12.0, 0.0, 8.0}, {3.0, 5.0, 4.9}};
 
   for(int i = 0; i < length; ++i)

orxonox/trunk/src/lib/collision_detection/obb_tree_node.cc

@@ -190 +190 @@
   Jacobi(C, D, V);                                            /* do the jacobi decomposition */
 
-  printf("we got a result! YES: \n");
+  printf("\nwe got a result! YES: \n");
 
   for(int j = 1; j < 4; ++j)
@@ -207 +207 @@
   box->axis = axis;
 
-  printf("eigenvector: %f, %f, %f\n", box->axis[0]->x, box->axis[0]->y, box->axis[0]->z);
+  printf("\neigenvector: %f, %f, %f\n", box->axis[0]->x, box->axis[0]->y, box->axis[0]->z);
   printf("eigenvector: %f, %f, %f\n", box->axis[1]->x, box->axis[1]->y, box->axis[1]->z);
   printf("eigenvector: %f, %f, %f\n", box->axis[2]->x, box->axis[2]->y, box->axis[2]->z);
@@ -216 +216 @@
   float*              halfLength = new float[3];             //!< half length of the axis
   float               tmpLength;                             //!< tmp save point for the length
-
-
-  Plane p0(*box->axis[0], *box->center);
-  Plane p1(*box->axis[1], *box->center);
-  Plane p2(*box->axis[2], *box->center);
+  Plane               p0(*box->axis[0], *box->center);       //!< the axis planes
+  Plane               p1(*box->axis[1], *box->center);
+  Plane               p2(*box->axis[2], *box->center);
 
   halfLength[0] = -1.0f;
@@ -249 +247 @@
 
 
-  printf("we got length: \n");
+  printf("\nwe got length: \n");
   for(int i = 0; i < 3; ++i)
     printf("length[%i] = %f\n", i, box->halfLength[i]);
@@ -255 +253 @@
 
 
+
+/**
+  \brief this separates an ob-box in the middle
+  \param box: the box to separate
+
+  this will separate the box into to smaller boxes. the separation is done along the middle of the longest axis
+ */
 void OBBTreeNode::forkBox(OBB* box)
 {
   /* get the longest axis of the box */
-  float aLength = -1.0f;
-  int axisNr = 0;
+  float               aLength = -1.0f;                     //!< the length of the longest axis
+  int                 axisIndex = 0;                       //!< this is the nr of the longest axis
+
   for(int i = 0; i < 3; ++i)
-    {
-      if( aLength < box->axis[i]->len())
-        {
-          aLength = box->axis[i]->len();
-          axisNr = i;
-        }
-    }
+  {
+    if( aLength < box->halfLength[i])
+    {
+      aLength = box->halfLength[i];
+      axisIndex = i;
+    }
+  }
+
+  printf("\nlongest axis is: nr %i with a half-length of: %f\n", axisIndex, aLength);
+
 
   /* get the closest vertex near the center */
+  float               dist = 0.0f;                         //!< the smallest distance to each vertex
+  float               tmpDist;                             //!< temporary distance
+  int                 vertexIndex;
+  Plane               separationPlane(*box->axis[axisIndex], *box->center); //!< the separation plane definition
+
+  for(int i = 0; i < box->numOfVertices; ++i)
+  {
+    tmpDist = fabs(separationPlane.distancePoint(vertices[i]));
+    if( tmpDist > dist)
+      dist = tmpDist;
+  }
+
+
+  printf("\nthe clostest vertex is nr: %i, with a dist of: %f\n", vertexIndex ,dist);
+
 
 }

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

@@ -31 +31 @@
   /**  \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) */
+  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) */
   inline const Vector& operator+= (const Vector& v) { this->x += v.x; this->y += v.y; this->z += v.z; return *this; };
   /** \param v The vector to substract  \returns the substraction between two vectors (this - v) */
+  inline const Vector& operator+= (const sVec3D& v) { this->x += v[0]; this->y += v[1]; this->z += v[2]; return *this; };
+  /** \param v The vector to substract  \returns the substraction 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 substract  \returns the substraction 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 substract  \returns the substraction between two vectors (this -= v) */
   inline const Vector& operator-= (const Vector& v) { this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this; };
+  /** \param v The vector to substract  \returns the substraction between two vectors (this -= v) */
+  inline const Vector& operator-= (const sVec3D& v) { this->x -= v[0]; this->y -= v[1]; this->z -= v[2]; return *this; };
   /** \param v the second vector  \returns The dotProduct between two vector (this (dot) v) */
   inline float operator* (const Vector& v) const { return x * v.x + y * v.y + z * v.z; };