Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 6657 in orxonox.OLD for branches/cd_merge/src/lib


Ignore:
Timestamp:
Jan 23, 2006, 2:25:13 PM (19 years ago)
Author:
bensch
Message:

orxonox/cd_merge: merged the old collision-detection here.

Location:
branches/cd_merge/src/lib
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • branches/cd_merge/src/lib/collision_detection/bounding_sphere.cc

    r4836 r6657  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
    … …  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "bounding_sphere.h"
    … …  
    2424 *  standard constructor
    2525*/
    26 BoundingSphere::BoundingSphere () 
     26BoundingSphere::BoundingSphere ()
    2727{
    28    this->setClassID(CL_BOUNDING_SPHERE, "BoundingSphere"); 
     28   this->setClassID(CL_BOUNDING_SPHERE, "BoundingSphere");
    2929}
    3030
    … …  
    3434
    3535*/
    36 BoundingSphere::~BoundingSphere () 
     36BoundingSphere::~BoundingSphere ()
    3737{
    3838  // delete what has to be deleted here

  • branches/cd_merge/src/lib/collision_detection/bounding_volume.cc

    r5120 r6657  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "bounding_volume.h"
    19 #include "vector.h"
    2019
    2120using namespace std;
    … …  
    2726BoundingVolume::BoundingVolume ()
    2827{
    29    this->setClassID(CL_BOUNDING_VOLUME, "BoundingVolume");
    30    this->center = new Vector();
    31    this->bOrigVertices = true;
    32    this->vertices = NULL;
     28  this->setClassID(CL_BOUNDING_VOLUME, "BoundingVolume");
     29  this->modelInf = NULL;
     30  this->triangleIndexes = NULL;
     31  this->triangleIndexesLength = 0;
    3332}
    3433
    … …  
    4039BoundingVolume::~BoundingVolume ()
    4140{
    42   // delete what has to be deleted here
    43   delete this->center;
    44 
    45   if( this->vertices && !this->bOrigVertices)
    46     delete[] this->vertices;
     41  if( this->triangleIndexes)
     42    delete[] this->triangleIndexes;
    4743}

  • branches/cd_merge/src/lib/collision_detection/bounding_volume.h

    r6022 r6657  
    1111#include "model.h"
    1212
    13 class Vector;
     13
    1414template<class T> class tList;
    1515
    … …  
    2222    virtual ~BoundingVolume();
    2323
    24     inline const Vector* getCenter() const { return this->center; }
     24    inline const Vector& getCenter() const { return this->center; }
     25    inline const modelInfo* getModelInfo() const { return this->modelInf; }
    2526
    26     const sVec3D* getVertices() const { return this->vertices; }
    2727    virtual void mergeWith(const BoundingVolume &bv) = 0;
    2828
    … …  
    3232
    3333  public:
    34     Vector*             center;                     //!< Center point of box
     34    Vector              center;                     //!< Weighter average center point of box
     35    Vector              arithCenter;                //!< Arithmetical center of the box
    3536
    36     const sVec3D*       vertices;                   //!< if CD_STORE_VERTICES enabled, this is the place, where the vert. will be sotred
    37     int                 numOfVertices;              //!< number of vertices in the vertices buffer
    38     bool                bOrigVertices;              //!< is true if the vertices pointer points to the original model data - only important for deleting
     37    const modelInfo*    modelInf;                   //!< Reference to the model's ModelInfo
     38    const int*          triangleIndexes;            //!< Array with the triangle indexes in modelInfo
     39    int                 triangleIndexesLength;      //!< length of the indexes array
    3940};
    4041

  • branches/cd_merge/src/lib/collision_detection/bv_tree.cc

    r5693 r6657  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
    … …  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "bv_tree.h"
    … …  
    2525 *  standard constructor
    2626*/
    27 BVTree::BVTree () 
     27BVTree::BVTree ()
    2828{
    29    this->setClassID(CL_BV_TREE, "BVTree"); 
     29   this->setClassID(CL_BV_TREE, "BVTree");
    3030
    3131}
    … …  
    3636
    3737*/
    38 BVTree::~BVTree () 
     38BVTree::~BVTree ()
    3939{
    4040  // delete what has to be deleted here

  • branches/cd_merge/src/lib/collision_detection/bv_tree.h

    r6022 r6657  
    1818class WorldEntity;
    1919
     20//! draw mode for the bounding volume
    2021typedef enum DrawMode
    2122{
    … …  
    3334
    3435//! A class that represents a bounding volume tree
    35 class BVTree : public BaseObject {
     36class BVTree : public BaseObject
     37{
    3638
    37  public:
    38   BVTree();
    39   virtual ~BVTree();
     39  public:
     40    BVTree();
     41    virtual ~BVTree();
    4042
    41   virtual void spawnBVTree(int depth, sVec3D *verticesList, const int length) = 0;
    42   virtual void spawnBVTree(int depth, const modelInfo& modInfo) = 0;
    43   virtual void flushTree() = 0;
     43    virtual void spawnBVTree(const modelInfo& modelInf) = 0;
     44    virtual void flushTree() = 0;
    4445
    45   virtual void collideWith(BVTree* tree, WorldEntity* nodeA, WorldEntity* nodeB) = 0;
    46   virtual void collideWith(WorldEntity* entity1, WorldEntity* entity2) = 0;
     46    virtual void collideWith(const WorldEntity& entity1, const WorldEntity& entity2) const = 0;
    4747
    48   /** @param depth: depth, @param drawMode: how to draw the Model */
    49   virtual void drawBV(int depth, int drawMode) const = 0;
    50 
    51 
    52  protected:
    53   int numberOfVertices;
    54 
    55  private:
    56 
    57 
     48    virtual void drawBV(int depth, int drawMode) const = 0;
    5849};
    5950

  • branches/cd_merge/src/lib/collision_detection/bv_tree_node.cc

    r4836 r6657  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "bv_tree_node.h"

  • branches/cd_merge/src/lib/collision_detection/bv_tree_node.h

    r6022 r6657  
    88#define _BV_TREE_NODE_H
    99
     10
    1011#include "base_object.h"
    1112#include "model.h"
    1213#include "vector.h"
    1314
    14 // FORWARD DECLARATION
     15
     16// forward declarations
    1517class BoundingVolume;
    1618class BVTree;
    … …  
    1921template<class T> class tList;
    2022
     23
    2124//! A class that represents a bounding volume tree
    2225class BVTreeNode : public BaseObject {
     26
    2327
    2428 public:
    … …  
    2630  virtual ~BVTreeNode();
    2731
    28   virtual void spawnBVTree(const int depth, const sVec3D *verticesList, unsigned int length ) = 0;
    29   virtual void spawnBVTree(const int depth, const modelInfo& modInfo) = 0;
     32  virtual const BoundingVolume* getBV() const = 0;
     33  /** returns the index of this bounding volume tree node @returns index of this index */
     34  inline const int getIndex() const { return this->treeIndex; }
    3035
    31   virtual BoundingVolume* getBV(int index) const = 0;
    32   inline const int getIndex() { return this->treeIndex; }
    33 
    34   virtual void collideWith(BVTreeNode* treeNode, WorldEntity* nodeA, WorldEntity* nodeB) = 0;
    35 
     36  virtual void spawnBVTree(const modelInfo& modInfo, const int* triangleIndexes, int length) = 0;
     37  virtual void collideWith(const BVTreeNode& treeNode, const WorldEntity& nodeA, const WorldEntity& nodeB) const = 0;
    3638  virtual void drawBV(int depth, int drawMode, const Vector& color = Vector(1,0,0), bool top = true) const = 0;
    3739

  • branches/cd_merge/src/lib/collision_detection/cd_engine.cc

    r6316 r6657  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "cd_engine.h"
    … …  
    108108void CDEngine::checkCollisions(std::list<WorldEntity*>& list1, std::list<WorldEntity*>& list2)
    109109{
    110   BVTree* tree;
     110  const BVTree* tree;
    111111  std::list<WorldEntity*>::iterator entity1, entity2, pre1, pre2;
    112   PRINTF(3)("checking for collisions\n");
     112  PRINTF(5)("checking for collisions\n");
    113113
    114114  pre1 = list1.begin();
    … …  
    189189void CDEngine::debugSpawnTree(int depth, sVec3D* vertices, int numVertices)
    190190{
    191   if ( this->rootTree == NULL)
    192     this->rootTree = new OBBTree();
    193   this->rootTree->spawnBVTree(depth, vertices, numVertices);
     191//   if ( this->rootTree == NULL)
     192//     this->rootTree = new OBBTree(depth, vertices, numVertices);
    194193}
    195194

  • branches/cd_merge/src/lib/collision_detection/collision.cc

    r4836 r6657  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
    … …  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "collision.h"
    … …  
    2424 *  standard constructor
    2525*/
    26 Collision::Collision () 
     26Collision::Collision ()
    2727{
    28    this->setClassID(CL_COLLISION, "Collision"); 
     28   this->setClassID(CL_COLLISION, "Collision");
    2929
    3030}
    … …  
    3535
    3636*/
    37 Collision::~Collision () 
     37Collision::~Collision ()
    3838{
    3939  // delete what has to be deleted here

  • branches/cd_merge/src/lib/collision_detection/obb.cc

    r6222 r6657  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "obb.h"
    … …  
    2828{
    2929   this->setClassID(CL_OBB, "OBB");
    30    this->axis = new Vector[3];
    31    this->halfLength = new float[3];
     30   this->halfLength[0] = this->halfLength[1] = this->halfLength[2] = 0.0f;
    3231   this->bCollided = false;
    3332}
    … …  
    4039OBB::~OBB ()
    4140{
    42   delete [] this->axis;
    43   delete [] this->halfLength;
    4441}
    4542

  • branches/cd_merge/src/lib/collision_detection/obb.h

    r5039 r6657  
    2121
    2222
    23   inline Vector* getAxis () const { return this->axis; }
     23  inline Vector getAxisX () const { return this->axis[0]; }
     24  inline Vector getAxisY () const { return this->axis[1]; }
     25  inline Vector getAxisZ () const { return this->axis[2]; }
     26
    2427  inline const float* getHalfLength() const { return this->halfLength; }
    2528
    … …  
    3134
    3235 public:
    33   Vector*          axis;                       //!< Axes of oriented box [x,y,z]
    34   float*           halfLength;                 //!< Half lengths of the box along the axis
     36  Vector           axis[3];                    //!< Axes of oriented box [x,y,z]
     37  float            halfLength[3];              //!< Half lengths of the box along the axis
    3538  float            covarianceMatrix[3][3];     //!< the covariance matrix
    3639

  • branches/cd_merge/src/lib/collision_detection/obb_tree.cc

    r5684 r6657  
    1414*/
    1515
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1717
    1818#include "obb_tree.h"
    … …  
    3131 *  standard constructor
    3232*/
    33 OBBTree::OBBTree ()
     33OBBTree::OBBTree(int depth, const modelInfo& modelInf)
     34  : BVTree()
    3435{
     36  this->depth = depth;
    3537  this->init();
    36 }
    37 
    38 OBBTree::OBBTree(int depth, sVec3D *verticesList, const int length)
    39 {
    40   this->init();
    41   this->spawnBVTree(depth, verticesList, length);
    42 }
    43 
    44 OBBTree::OBBTree(int depth, const modelInfo& modInfo)
    45 {
    46   this->init();
    47   this->spawnBVTree(depth, modInfo);
     38  this->spawnBVTree(modelInf);
    4839}
    4940
    … …  
    5344{
    5445  this->setClassID(CL_OBB_TREE, "OBBTree");
    55 
    5646  this->rootNode = NULL;
    57 
    5847  this->id = 0;
    5948}
    … …  
    6958
    7059
    71 void OBBTree::spawnBVTree(int depth, sVec3D *verticesList, const int length)
    72 {
    73   if( unlikely(this->rootNode != NULL))
    74     {
    75       PRINTF(2)("The BVTree has already been spawned, flushing and respawning again...\n");
    76       this->flushTree();
    77     }
    78   OBBTreeNode* node = new OBBTreeNode();
    79   this->rootNode = node;
    80   this->rootNode->setTreeRef(this);
    81   this->rootNode->spawnBVTree(--depth, verticesList, length);
    82 }
    83 
    84 
    85 void OBBTree::spawnBVTree(int depth, const modelInfo& modInfo)
     60/**
     61 *  this function creates a bv tree out of a modelInf structure
     62 * @param modelInf the model info of a model (modelInfo), containing vertices, triangle and normal infos
     63 */
     64void OBBTree::spawnBVTree(const modelInfo& modelInf)
    8665{
    8766  if( unlikely(this->rootNode != NULL))
    … …  
    9069    this->flushTree();
    9170  }
    92   OBBTreeNode* node = new OBBTreeNode();
    93   this->rootNode = node;
    94   this->rootNode->setTreeRef(this);
    95   this->rootNode->spawnBVTree(--depth, modInfo);
     71  this->rootNode = new OBBTreeNode(*this, NULL, depth-1);
     72
     73  /* triangles indexes created */
     74  int* triangleIndexes = new int[modelInf.numTriangles];
     75  for( int i = 0; i < modelInf.numTriangles; ++i)
     76    triangleIndexes[i] = i;
     77
     78  this->rootNode->spawnBVTree(modelInf, triangleIndexes, modelInf.numTriangles);
    9679}
    9780
    9881
     82/**
     83 *  release the current bv tree if any
     84 */
    9985void OBBTree:: flushTree()
    10086{}
    10187
    10288
    103 void OBBTree::collideWith(WorldEntity* entity1, WorldEntity* entity2)
     89/**
     90 * this collides two bvtrees together. the trees are attached to pnodes Objects A and B
     91 * @param nodeA: PNode of object A
     92 * @param nodeB: Pnode of object B
     93 */
     94void OBBTree::collideWith(const WorldEntity& entity1, const WorldEntity& entity2) const
    10495{
    105   if( likely(entity2->getOBBTree() != NULL) )
    106     this->rootNode->collideWith(((OBBTree*)entity2->getOBBTree())->getRootNode(), entity1, entity2);
     96  if( likely(entity2.getOBBTree() != NULL) )
     97    this->rootNode->collideWith(*(((OBBTree*)entity2.getOBBTree())->getRootNode()), entity1, entity2);
    10798}
    10899
    109100
    110101/**
    111  * this collides two bvtrees together. the trees are attached to pnodes Objects A and B
    112  * @param tree: the other tree to collide with (Object B)
    113  * @param nodeA: PNode of object A
    114  * @param nodeB: Pnode of object B
     102 *  draw bv tree
    115103 */
    116 void OBBTree::collideWith(BVTree* tree, WorldEntity* nodeA, WorldEntity* nodeB)
    117 {
    118   this->rootNode->collideWith(((OBBTree*)tree)->getRootNode(), nodeA, nodeB);
    119 }
    120 
    121 
    122104void OBBTree::drawBV(int depth, int drawMode) const
    123105{
    … …  
    129111
    130112
    131 
     113/**
     114 *  some debug output and creation function
     115 *
     116 * doesn't work at the moment
     117 */
    132118void OBBTree::debug()
    133119{
    … …  
    153139    }
    154140
    155   this->spawnBVTree(3, vertList, length);
     141//   this->spawnBVTree(vertList, length);
    156142
    157143  PRINT(0)("=  Spawning Tree: Finished\n");

  • branches/cd_merge/src/lib/collision_detection/obb_tree.h

    r6022 r6657  
    1717
    1818//! A class for representing an obb tree
    19 class OBBTree : public BVTree {
     19class OBBTree : public BVTree
     20{
    2021
    2122  public:
    22     OBBTree();
    23     OBBTree(int depth, sVec3D *verticesList, const int length);
    2423    OBBTree(int depth, const modelInfo& modInfo);
    2524    virtual ~OBBTree();
    2625    void init();
    2726
    28     virtual void spawnBVTree(int depth, sVec3D *verticesList, const int length);
    29     virtual void spawnBVTree(int depth, const modelInfo& modInfo);
     27    virtual void spawnBVTree(const modelInfo& modelInf);
    3028    virtual void flushTree();
    3129
    32     virtual void collideWith(BVTree* tree, WorldEntity* nodeA, WorldEntity* nodeB);
    33     virtual void collideWith(WorldEntity* entity1, WorldEntity* entity2);
    34 
     30    virtual void collideWith(const WorldEntity& entity1, const WorldEntity& entity2) const;
    3531    virtual void drawBV(int depth, int drawMode) const;
    3632
    37     int getID() { return ++this->id;}
    38     inline OBBTreeNode* getRootNode() { return this->rootNode; }
     33    /** returns the next if for the obb tree node @return integer id number of the next node */
     34    inline const int getID() { return ++this->id;}
     35    /** returns the root node of the bounding volume tree @return reference to the root node */
     36    inline const OBBTreeNode* getRootNode() const { return this->rootNode; }
    3937
    4038    void debug();
    … …  
    4240  private:
    4341    OBBTreeNode*         rootNode;                        //!< reference to the root node of the tree
    44     int                  id;
     42    int                  id;                              //!< the next id of a obb tree node
     43    int                  depth;                           //!< the depth of the tree to generate
    4544};
    4645

  • branches/cd_merge/src/lib/collision_detection/obb_tree_node.cc

    r6617 r6657  
    1111### File Specific:
    1212   main-programmer: Patrick Boenzli
    13    co-programmer: ...
    1413*/
    1514
    16 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION
     15#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_DETECTION
    1716
    1817#include "obb_tree_node.h"
    19 #include "list.h"
     18#include "obb_tree.h"
    2019#include "obb.h"
    21 #include "obb_tree.h"
     20
    2221#include "matrix.h"
    2322#include "model.h"
    … …  
    2625
    2726#include "color.h"
    28 
     27#include "glincl.h"
     28
     29#include <list>
     30#include <vector>
    2931#include "debug.h"
    30 #include "glincl.h"
    3132
    3233
    … …  
    3435using namespace std;
    3536
    36 OBBTree*  OBBTreeNode::obbTree = NULL;
    37 
    38 float**  OBBTreeNode::coMat = NULL;
    39 float**  OBBTreeNode::eigvMat = NULL;
    40 float*   OBBTreeNode::eigvlMat = NULL;
    41 int*     OBBTreeNode::rotCount = NULL;
     37
    4238GLUquadricObj* OBBTreeNode_sphereObj = NULL;
     39
    4340
    4441/**
    4542 *  standard constructor
     43 * @param tree: reference to the obb tree
     44 * @param depth: the depth of the obb tree to generate
    4645 */
    47 OBBTreeNode::OBBTreeNode ()
     46OBBTreeNode::OBBTreeNode (const OBBTree& tree, OBBTreeNode* prev, int depth)
     47    : BVTreeNode()
    4848{
    4949  this->setClassID(CL_OBB_TREE_NODE, "OBBTreeNode");
     50
     51  this->obbTree = &tree;
     52  this->nodePrev = prev;
     53  this->depth = depth;
     54  this->nextID = 0;
     55
    5056  this->nodeLeft = NULL;
    5157  this->nodeRight = NULL;
    5258  this->bvElement = NULL;
    5359
    54   if( OBBTreeNode::coMat == NULL)
    55   {
    56     OBBTreeNode::coMat = new float*[4];
    57     for(int i = 0; i < 4; i++)
    58       OBBTreeNode::coMat[i] = new float[4];
    59   }
    60   if( OBBTreeNode::eigvMat == NULL)
    61   {
    62     OBBTreeNode::eigvMat = new float*[4];
    63     for( int i = 0; i < 4; i++)
    64       OBBTreeNode::eigvMat[i] = new float[4];
    65   }
    66   if( OBBTreeNode::eigvlMat == NULL)
    67   {
    68     OBBTreeNode::eigvlMat = new float[4];
    69   }
    70   if( OBBTreeNode::rotCount == NULL)
    71     OBBTreeNode::rotCount = new int;
     60  this->triangleIndexList1 = NULL;
     61  this->triangleIndexList2 = NULL;
     62
     63  this->modelInf = NULL;
     64  this->triangleIndexes = NULL;
    7265
    7366  if( OBBTreeNode_sphereObj == NULL)
    7467    OBBTreeNode_sphereObj = gluNewQuadric();
     68
     69  /* debug ids */
     70  if( this->nodePrev)
     71    this->treeIndex = 100 * this->depth + this->nodePrev->getID();
     72  else
     73    this->treeIndex = 0;
    7574}
    7675
    … …  
    8281{
    8382  if( this->nodeLeft)
    84   {
    8583    delete this->nodeLeft;
    86     this->nodeLeft = NULL;
    87   }
    8884  if( this->nodeRight)
    89   {
    9085    delete this->nodeRight;
    91     this->nodeRight = NULL;
    92   }
     86
    9387  if( this->bvElement)
    9488    delete this->bvElement;
    95   this->bvElement = NULL;
     89
     90  if( this->triangleIndexList1 != NULL)
     91    delete [] this->triangleIndexList1;
     92  if( this->triangleIndexList2 != NULL)
     93    delete [] this->triangleIndexList2;
    9694}
    9795
    … …  
    105103 * on the triangle informations (triangle soup not polygon soup)
    106104 */
    107 void OBBTreeNode::spawnBVTree(const int depth, const modelInfo& modInfo)
    108 {
    109   int length = 0;
    110   sVec3D* verticesList;
    111 
    112   PRINT(3)("\n");
    113   this->treeIndex = this->obbTree->getID();
    114   PRINTF(3)("OBB Depth: %i, tree index: %i, numVertices: %i\n", depth, treeIndex, length);
     105void OBBTreeNode::spawnBVTree(const modelInfo& modelInf, const int* triangleIndexes, int length)
     106{
     107  PRINTF(3)("\n==============================Creating OBB Tree Node==================\n");
     108  PRINT(3)(" OBB Tree Infos: \n");
     109  PRINT(3)("\tDepth: %i \n\tTree Index: %i \n\tNumber of Triangles: %i\n", depth, this->treeIndex, length);
    115110  this->depth = depth;
    116111
    117 
    118112  this->bvElement = new OBB();
    119   this->bvElement->vertices = verticesList;
    120   this->bvElement->numOfVertices = length;
    121   PRINTF(3)("Created OBBox\n");
    122   this->calculateBoxCovariance(this->bvElement, modInfo);
    123   PRINTF(3)("Calculated attributes1\n");
    124   this->calculateBoxEigenvectors(this->bvElement, modInfo);
    125   PRINTF(3)("Calculated attributes2\n");
    126   this->calculateBoxAxis(this->bvElement,modInfo);
    127   PRINTF(3)("Calculated attributes3\n");
    128 
    129   /* if this is the first node, the vertices data are the original ones of the model itself, so dont delete them in cleanup */
    130   if( this->treeIndex == 1)
    131     this->bvElement->bOrigVertices = true;
    132 
     113  this->bvElement->modelInf = &modelInf;
     114  this->bvElement->triangleIndexes = triangleIndexes;
     115  this->bvElement->triangleIndexesLength = length;
     116
     117  /* create the bounding boxes in three steps */
     118  this->calculateBoxCovariance(*this->bvElement, modelInf, triangleIndexes, length);
     119  this->calculateBoxEigenvectors(*this->bvElement, modelInf, triangleIndexes, length);
     120  this->calculateBoxAxis(*this->bvElement, modelInf, triangleIndexes, length);
     121
     122  /* do we need to descent further in the obb tree?*/
    133123  if( likely( this->depth > 0))
    134124  {
    135     this->forkBox(this->bvElement);
    136 
    137 
    138 //     if(this->tmpLen1 > 2)
    139 //     {
    140 //       OBBTreeNode* node1 = new OBBTreeNode();
    141 //       this->nodeLeft = node1;
    142 //       this->nodeLeft->spawnBVTree(depth - 1, this->tmpVert1, this->tmpLen1);
    143 //     }
    144 //     else
    145 //     {
    146 //       PRINTF(3)("Aboarding tree walk: less than 3 vertices left\n");
    147 //     }
    148 //
    149 //     if( this->tmpLen2 > 2)
    150 //     {
    151 //       OBBTreeNode* node2 = new OBBTreeNode();
    152 //       this->nodeRight = node2;
    153 //       this->nodeRight->spawnBVTree(depth - 1, this->tmpVert2, this->tmpLen2);
    154 //     }
    155 //     else
    156 //     {
    157 //       PRINTF(3)("Abording tree walk: less than 3 vertices left\n");
    158 //     }
    159 
    160   }
    161 }
     125    this->forkBox(*this->bvElement);
     126
     127    if( this->triangleIndexLength1 >= 3)
     128    {
     129      this->nodeLeft = new OBBTreeNode(*this->obbTree, this, depth - 1);
     130      this->nodeLeft->spawnBVTree(modelInf, this->triangleIndexList1, this->triangleIndexLength1);
     131    }
     132    if( this->triangleIndexLength2 >= 3)
     133    {
     134      this->nodeRight = new OBBTreeNode(*this->obbTree, this, depth - 1);
     135      this->nodeRight->spawnBVTree(modelInf, this->triangleIndexList2, this->triangleIndexLength2);
     136    }
     137  }
     138}
     139
    162140
    163141
    164142/**
    165  *  creates a new BVTree or BVTree partition
    166  * @param depth: how much more depth-steps to go: if == 1 don't go any deeper!
    167  * @param verticesList: the list of vertices of the object - each vertices triple is interpreted as a triangle
    168  *
    169  * this function creates an Bounding Volume tree from a vertices soup (no triangle data)
     143 *  calculate the box covariance matrix
     144 * @param box: reference to the box
     145 * @param modelInf: the model info structure of the model
     146 * @param tirangleIndexes: an array with the indexes of the triangles inside this
     147 * @param length: the length of the indexes array
    170148 */
    171 void OBBTreeNode::spawnBVTree(const int depth, const sVec3D *verticesList, unsigned int length)
    172 {
    173   PRINT(3)("\n");
    174   this->treeIndex = this->obbTree->getID();
    175   PRINTF(3)("OBB Depth: %i, tree index: %i, numVertices: %i\n", depth, treeIndex, length);
    176   this->depth = depth;
    177 
    178 
    179   this->bvElement = new OBB();
    180   this->bvElement->vertices = verticesList;
    181   this->bvElement->numOfVertices = length;
    182   PRINTF(3)("Created OBBox\n");
    183   this->calculateBoxCovariance(this->bvElement, verticesList, length);
    184   PRINTF(3)("Calculated attributes1\n");
    185   this->calculateBoxEigenvectors(this->bvElement, verticesList, length);
    186   PRINTF(3)("Calculated attributes2\n");
    187   this->calculateBoxAxis(this->bvElement, verticesList, length);
    188   PRINTF(3)("Calculated attributes3\n");
    189 
    190   /* if this is the first node, the vertices data are the original ones of the model itself, so dont delete them in cleanup */
    191   if( this->treeIndex == 1)
    192     this->bvElement->bOrigVertices = true;
    193 
    194   if( likely( this->depth > 0))
    195   {
    196     this->forkBox(this->bvElement);
    197 
    198 
    199     if(this->tmpLen1 > 2)
    200     {
    201       OBBTreeNode* node1 = new OBBTreeNode();
    202       this->nodeLeft = node1;
    203       this->nodeLeft->spawnBVTree(depth - 1, this->tmpVert1, this->tmpLen1);
    204     }
    205     else
    206     {
    207       PRINTF(3)("Aboarding tree walk: less than 3 vertices left\n");
    208     }
    209 
    210     if( this->tmpLen2 > 2)
    211     {
    212       OBBTreeNode* node2 = new OBBTreeNode();
    213       this->nodeRight = node2;
    214       this->nodeRight->spawnBVTree(depth - 1, this->tmpVert2, this->tmpLen2);
    215     }
    216     else
    217     {
    218       PRINTF(3)("Abording tree walk: less than 3 vertices left\n");
    219     }
    220   }
    221 }
    222 
    223 
    224 void OBBTreeNode::calculateBoxCovariance(OBB* box, const modelInfo& modInfo)
    225 {}
    226 
    227 
    228 void OBBTreeNode::calculateBoxCovariance(OBB* box, const sVec3D* verticesList, unsigned int length)
     149void OBBTreeNode::calculateBoxCovariance(OBB& box, const modelInfo& modelInf, const int* triangleIndexes, int length)
    229150{
    230151  float     facelet[length];                         //!< surface area of the i'th triangle of the convex hull
    … …  
    235156  Vector    t1, t2;                                  //!< temporary values
    236157  float     covariance[3][3] = {0,0,0, 0,0,0, 0,0,0};//!< the covariance matrix
    237   int       mode = 0;                                //!< mode = 0: vertex soup, no connections, mode = 1: 3 following verteces build a triangle
    238 
    239   this->numOfVertices = length;
    240   this->vertices = verticesList;
    241 
    242 
    243   if( likely(mode == 0))
    244   {
    245     /* fist compute all the convex hull face/facelets and centroids */
    246     for( int i = 0; i+3 < length ; i+=3)          /* FIX-ME-QUICK: hops of 3, array indiscontinuity*/
    247     {
    248       p = verticesList[i];
    249       q = verticesList[i + 1];
    250       r = verticesList[i + 2];
    251 
    252       t1 = p - q; t2 = p - r;
    253 
    254       /* finding the facelet surface via cross-product */
    255       facelet[i] = 0.5f * fabs( t1.cross(t2).len() );
    256       /* update the entire convex hull surface */
    257       face += facelet[i];
    258 
    259       /* calculate the cetroid of the hull triangles */
    260       centroid[i] = (p + q + r) * 1/3;
    261       /* now calculate the centroid of the entire convex hull, weighted average of triangle centroids */
    262       center += centroid[i] * facelet[i];
    263     }
    264     /* take the average of the centroid sum */
    265     center /= face;
    266     PRINTF(3)("-- Calculated Center\n");
    267 
    268 
    269     /* now calculate the covariance matrix - if not written in three for-loops, it would compute faster: minor */
    270     for( int j = 0; j < 3; ++j)
    271     {
    272       for( int k = 0; k < 3; ++k)
     158  sVec3D*   tmpVec = NULL;                           //!< a temp saving place for sVec3Ds
     159
     160
     161  /* fist compute all the convex hull face/facelets and centroids */
     162  for( int i = 0; i < length ; ++i)
     163  {
     164    tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[0]]);
     165    p = *tmpVec;
     166    tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[1]]);
     167    q = *tmpVec;
     168    tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[2]]);
     169    r = *tmpVec;
     170
     171    /* finding the facelet surface via cross-product */
     172    t1 = p - q;
     173    t2 = p - r;
     174    facelet[i] = 0.5f * fabs( t1.cross(t2).len() );
     175    /* update the entire convex hull surface */
     176    face += facelet[i];
     177
     178    /* calculate the cetroid of the hull triangles */
     179    centroid[i] = (p + q + r) / 3.0f;
     180    /* now calculate the centroid of the entire convex hull, weighted average of triangle centroids */
     181    center += centroid[i] * facelet[i];
     182    /* the arithmetical center */
     183  }
     184  /* take the average of the centroid sum */
     185  center /= face;
     186
     187
     188  /* now calculate the covariance matrix - if not written in three for-loops,
     189     it would compute faster: minor */
     190  for( int j = 0; j < 3; ++j)
     191  {
     192    for( int k = 0; k < 3; ++k)
     193    {
     194      for( int i = 0; i < length; ++i)
    273195      {
    274         for( int i = 0; i + 3 < length; i+=3)
    275         {
    276           p = verticesList[i];
    277           q = verticesList[i + 1];
    278           r = verticesList[i + 2];
    279 
    280           covariance[j][k] = facelet[i] / (12.0f * face) * (9.0f * centroid[i][j] * centroid[i][k] + p[j] * p[k] +
    281               q[j] * q[k] + r[j] * r[k]) - center[j] * center[k];
    282         }
     196        tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[0]]);
     197        p = *tmpVec;
     198        tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[1]]);
     199        q = *tmpVec;
     200        tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[i]].indexToVertices[2]]);
     201        r = *tmpVec;
     202
     203        covariance[j][k] = facelet[i] * (9.0f * centroid[i][j] * centroid[i][k] + p[j] * p[k] +
     204                           q[j] * q[k] + r[j] * r[k]);
    283205      }
    284     }
    285     PRINTF(3)("-- Calculated Covariance\n");
    286   }
    287   else if( mode == 1)
    288   {
    289     for( int i = 0; i + 3 < length; i+=3)          /* FIX-ME-QUICK: hops of 3, array indiscontinuity*/
    290     {
    291       p = verticesList[i];
    292       q = verticesList[i + 1];
    293       r = verticesList[i + 2];
    294 
    295       centroid[i] = (p + q + r) / 3.0f;
    296       center += centroid[i];
    297     }
    298     center /= length;
    299 
    300     for( int j = 0; j < 3; ++j)
    301     {
    302       for( int k = 0; k < 3; ++k)
    303       {
    304         for( int i = 0; i + 3 < length; i+=3)
    305         {
    306           p = verticesList[i];
    307           q = verticesList[i +1];
    308           r = verticesList[i + 2];
    309 
    310           covariance[j][k] = p[j] * p[k] + q[j] * q[k] + r[j] + r[k];
    311         }
    312         covariance[j][k] /= (3.0f * length);
    313       }
    314     }
    315     PRINTF(3)("-- Calculated Covariance\n");
    316   }
    317   else if( mode == 2)
    318   {
    319     /* fist compute all the convex hull face/facelets and centroids */
    320     for(int i = 0; i + 3 < length; i+=3)          /* FIX-ME-QUICK: hops of 3, array indiscontinuity*/
    321     {
    322       p = verticesList[i];
    323       q = verticesList[i + 1];
    324       r = verticesList[i + 2];
    325 
    326       t1 = p - q; t2 = p - r;
    327 
    328       /* finding the facelet surface via cross-product */
    329       facelet[i] = 0.5f * fabs( t1.cross(t2).len() );
    330       /* update the entire convex hull surface */
    331       face += facelet[i];
    332 
    333       /* calculate the cetroid of the hull triangles */
    334       centroid[i] = (p + q + r) * 1/3;
    335       /* now calculate the centroid of the entire convex hull, weighted average of triangle centroids */
    336       center += centroid[i] * facelet[i];
    337     }
    338     /* take the average of the centroid sum */
    339     center /= face;
    340     PRINTF(3)("-- Calculated Center\n");
    341 
    342     for( int j = 0; j < 3; ++j)
    343     {
    344       for( int k = 0; k < 3; ++k)
    345       {
    346         for( int i = 0; i + 3 < length; i+=3)
    347         {
    348           p = verticesList[i];
    349           q = verticesList[i +1];
    350           r = verticesList[i + 2];
    351 
    352           covariance[j][k] = p[j] * p[k] + q[j] * q[k] + r[j] + r[k];
    353         }
    354         covariance[j][k] /= (3.0f * length);
    355       }
    356     }
    357     PRINTF(3)("-- Calculated Covariance\n");
    358   }
    359   else
    360   {
    361     for( int i = 0; i < length; ++i)          /* FIX-ME-QUICK: hops of 3, array indiscontinuity*/
    362     {
    363       center += verticesList[i];
    364     }
    365     center /= length;
    366 
    367     for( int j = 0; j < 3; ++j)
    368     {
    369       for( int k = 0; k < 3; ++k)
    370       {
    371         for( int i = 0; i + 3 < length; i+=3)
    372         {
    373           p = verticesList[i];
    374           q = verticesList[i +1];
    375           r = verticesList[i + 2];
    376 
    377           covariance[j][k] = p[j] * p[k] + q[j] * q[k] + r[j] + r[k];
    378         }
    379         covariance[j][k] /= (3.0f * length);
    380       }
    381     }
    382     PRINTF(3)("-- Calculated Covariance\n");
    383   }
    384 
    385   PRINTF(3)("\nVertex Data:\n");
    386   for(int i = 0; i < length; i++)
    387   {
    388     PRINTF(3)("vertex %i: %f, %f, %f\n", i, box->vertices[i][0], box->vertices[i][1], box->vertices[i][2]);
    389   }
    390 
    391 
    392   PRINTF(3)("\nCovariance Matrix:\n");
     206      covariance[j][k] = covariance[j][k] / (12.0f * face) - center[j] * center[k];
     207    }
     208  }
     209  for( int i = 0; i < 3; ++i)
     210  {
     211    box.covarianceMatrix[i][0] = covariance[i][0];
     212    box.covarianceMatrix[i][1] = covariance[i][1];
     213    box.covarianceMatrix[i][2] = covariance[i][2];
     214  }
     215  box.center = center;
     216
     217
     218  std::vector<int>           vertIndexVector;                           //!< vertex indexes list
     219  int                        vertIndex;                                 //!< index to vertex
     220  bool                       vertexFound;                               //!< vertex found flag
     221  Vector                     arithCenter;                               //!< aritmetical center
     222
     223  /* calculate the arithmetical center of the box */
     224
     225  /* go thourgh all vertices, add only the used vertices indexes */
     226//   for( int i = 0; i < length; ++i)
     227//   {
     228//     for(int j = 0; j < 3; ++j)
     229//     {
     230//       vertIndex = modelInf.pTriangles[triangleIndexes[i]].indexToVertices[j];
     231//
     232//       vertexFound = false;
     233//       for( int i = 0; i < vertIndexVector.size(); i++)
     234//       {
     235//         if( vertIndexVector[i] == vertIndex)
     236//           vertexFound = true;
     237//       }
     238//       if( !vertexFound)
     239//         vertIndexVector.push_back(vertIndex);
     240//     }
     241//   }
     242//   /* now realy calculate the center */
     243//   for( int i = 0; i < vertIndexVector.size(); ++i)
     244//   {
     245//     tmpVec = (sVec3D*)(&modelInf.pVertices[vertIndexVector[i]]);
     246//     arithCenter += *tmpVec;
     247//   }
     248//   box.arithCenter = arithCenter / vertIndexVector.size();
     249
     250
     251
     252  /* debug output section*/
     253  PRINTF(3)("\nOBB Covariance Matrix:\n");
    393254  for(int j = 0; j < 3; ++j)
    394255  {
    395     PRINT(3)(" |");
     256    PRINT(3)("\t\t");
    396257    for(int k = 0; k < 3; ++k)
    397258    {
    398       PRINT(3)(" \b%f ", covariance[j][k]);
    399     }
    400     PRINT(3)(" |\n");
    401   }
    402 
    403   PRINTF(3)("center: %f, %f, %f\n", center.x, center.y, center.z);
    404 
    405 
    406   for(int i = 0; i < 3; ++i)
    407   {
    408     box->covarianceMatrix[i][0] = covariance[i][0];
    409     box->covarianceMatrix[i][1] = covariance[i][1];
    410     box->covarianceMatrix[i][2] = covariance[i][2];
    411   }
    412   *box->center = center;
    413   PRINTF(3)("-- Written Result to obb\n");
    414 }
    415 
    416 
    417 void OBBTreeNode::calculateBoxEigenvectors(OBB* box, const modelInfo& modInfo)
    418 {}
    419 
    420 void OBBTreeNode::calculateBoxEigenvectors(OBB* box, const sVec3D* verticesList, unsigned int length)
    421 {
    422 
    423   /* now getting spanning vectors of the sub-space:
     259      PRINT(3)("%11.4f\t", covariance[j][k]);
     260    }
     261    PRINT(3)("\n");
     262  }
     263  PRINTF(3)("\nWeighteed OBB Center:\n\t\t%11.4f\t %11.4f\t %11.4f\n", center.x, center.y, center.z);
     264//   PRINTF(3)("\nArithmetical OBB Center:\n\t\t%11.4f\t %11.4f\t %11.4f\n", box.arithCenter.x, box.arithCenter.y, box.arithCenter.z);
     265
     266  /* write back the covariance matrix data to the object oriented bouning box */
     267}
     268
     269
     270
     271/**
     272 *  calculate the eigenvectors for the object oriented box
     273 * @param box: reference to the box
     274 * @param modelInf: the model info structure of the model
     275 * @param tirangleIndexes: an array with the indexes of the triangles inside this
     276 * @param length: the length of the indexes array
     277 */
     278void OBBTreeNode::calculateBoxEigenvectors(OBB& box, const modelInfo& modelInf,
     279    const int* triangleIndexes, int length)
     280{
     281
     282  Vector         axis[3];                            //!< the references to the obb axis
     283  Matrix         covMat(  box.covarianceMatrix  );   //!< covariance matrix (in the matrix dataform)
     284
     285  /*
     286  now getting spanning vectors of the sub-space:
    424287  the eigenvectors of a symmertric matrix, such as the
    425288  covarience matrix are mutually orthogonal.
    … …  
    427290  vectors
    428291  */
    429   Vector*              axis = new Vector[3];                //!< the references to the obb axis
    430 
    431   Matrix covMat(  box->covarianceMatrix  );
     292
     293  /* calculate the axis */
    432294  covMat.getEigenVectors(axis[0], axis[1], axis[2] );
    433 
    434 
    435   /* new jacobi tests */
    436 //  JacobI(OBBTreeNode::coMat, OBBTreeNode::eigvlMat, OBBTreeNode::eigvMat, OBBTreeNode::rotCount);
    437 //  PRINTF(3)("-- Done Jacobi Decomposition\n");
    438 
    439 
    440 //   PRINTF(0)("Jacobi\n");
    441 //   for(int j = 0; j < 3; ++j)
    442 //   {
    443 //     printf(" |");
    444 //     for(int k = 0; k < 3; ++k)
    445 //     {
    446 //       printf(" \t%f ", OBBTreeNode::OBBTreeNode::eigvMat[j][k]);
    447 //     }
    448 //     printf(" |\n");
    449 //   }
    450 
    451 /*  axis[0].x = OBBTreeNode::eigvMat[0][0]; axis[0].y = OBBTreeNode::eigvMat[1][0]; axis[0].z = OBBTreeNode::eigvMat[2][0];
    452   axis[1].x = OBBTreeNode::eigvMat[0][1]; axis[1].y = OBBTreeNode::eigvMat[1][1]; axis[1].z = OBBTreeNode::eigvMat[2][1];
    453   axis[2].x = OBBTreeNode::eigvMat[0][2]; axis[2].y = OBBTreeNode::eigvMat[1][2]; axis[2].z = OBBTreeNode::eigvMat[2][2];
    454   axis[0].normalize();
    455   axis[1].normalize();
    456   axis[2].normalize();*/
    457   box->axis = axis;
    458 
    459 //   PRINTF(0)("-- Got Axis\n");
    460 //
    461 //   PRINTF(0)("eigenvector: %f, %f, %f\n", box->axis[0].x, box->axis[0].y, box->axis[0].z);
    462 //   PRINTF(0)("eigenvector: %f, %f, %f\n", box->axis[1].x, box->axis[1].y, box->axis[1].z);
    463 //   PRINTF(0)("eigenvector: %f, %f, %f\n", box->axis[2].x, box->axis[2].y, box->axis[2].z);
    464 }
    465 
    466 
    467 void OBBTreeNode::calculateBoxAxis(OBB* box, const modelInfo& modInfo)
    468 {
    469   this->calculateBoxAxis(box, (const sVec3D*)modInfo.pVertices, modInfo.numVertices);
    470 }
    471 
    472 
    473 
    474 void OBBTreeNode::calculateBoxAxis(OBB* box, const sVec3D* verticesList, unsigned int length)
    475 {
    476 
     295  box.axis[0] = axis[0];
     296  box.axis[1] = axis[1];
     297  box.axis[2] = axis[2];
     298
     299  PRINTF(3)("Eigenvectors:\n");
     300  PRINT(3)("\t\t%11.2f \t%11.2f \t%11.2f\n", box.axis[0].x, box.axis[0].y, box.axis[0].z);
     301  PRINT(3)("\t\t%11.2f \t%11.2f \t%11.2f\n", box.axis[1].x, box.axis[1].y, box.axis[1].z);
     302  PRINT(3)("\t\t%11.2f \t%11.2f \t%11.2f\n", box.axis[2].x, box.axis[2].y, box.axis[2].z);
     303}
     304
     305
     306
     307
     308/**
     309 *  calculate the eigenvectors for the object oriented box
     310 * @param box: reference to the box
     311 * @param modelInf: the model info structure of the model
     312 * @param tirangleIndexes: an array with the indexes of the triangles inside this
     313 * @param length: the length of the indexes array
     314 */
     315void OBBTreeNode::calculateBoxAxis(OBB& box, const modelInfo& modelInf, const int* triangleIndexes, int length)
     316{
     317
     318  PRINTF(3)("Calculate Box Axis\n");
    477319  /* now get the axis length */
    478320  Line                ax[3];                                 //!< the axis
    479   float*              halfLength = new float[3];             //!< half length of the axis
     321  float               halfLength[3];                         //!< half length of the axis
    480322  float               tmpLength;                             //!< tmp save point for the length
    481   Plane               p0(box->axis[0], *box->center);       //!< the axis planes
    482   Plane               p1(box->axis[1], *box->center);
    483   Plane               p2(box->axis[2], *box->center);
    484   float               maxLength[3];
    485   float               minLength[3];
    486 
    487 
    488   /* get a bad bounding box */
    489   halfLength[0] = -1.0f;
    490   for(int j = 0; j < length; ++j)
    491     {
    492       tmpLength = fabs(p0.distancePoint(vertices[j]));
    493       if( tmpLength > halfLength[0])
    494         halfLength[0] = tmpLength;
    495     }
    496 
    497   halfLength[1] = -1.0f;
    498   for(int j = 0; j < length; ++j)
    499     {
    500       tmpLength = fabs(p1.distancePoint(vertices[j]));
    501       if( tmpLength > halfLength[1])
    502         halfLength[1] = tmpLength;
    503     }
    504 
    505   halfLength[2] = -1.0f;
    506   for(int j = 0; j < length; ++j)
    507     {
    508       tmpLength = fabs(p2.distancePoint(vertices[j]));
    509       if( tmpLength > halfLength[2])
    510         halfLength[2] = tmpLength;
    511     }
    512 
     323  Plane               p0(box.axis[0], box.center);           //!< the axis planes
     324  Plane               p1(box.axis[1], box.center);           //!< the axis planes
     325  Plane               p2(box.axis[2], box.center);           //!< the axis planes
     326  float               maxLength[3];                          //!< maximal lenth of the axis
     327  float               minLength[3];                          //!< minimal length of the axis
     328  const sVec3D*       tmpVec;                                //!< variable taking tmp vectors
    513329
    514330
    515331  /* get the maximal dimensions of the body in all directions */
    516     maxLength[0] = p0.distancePoint(vertices[0]);
    517     minLength[0] = p0.distancePoint(vertices[0]);
    518    for(int j = 0; j < length; ++j)
    519    {
    520      tmpLength = p0.distancePoint(vertices[j]);
    521      if( tmpLength > maxLength[0])
    522        maxLength[0] = tmpLength;
    523      else if( tmpLength < minLength[0])
    524        minLength[0] = tmpLength;
    525    }
    526 
    527    maxLength[1] = p1.distancePoint(vertices[0]);
    528    minLength[1] = p1.distancePoint(vertices[0]);
    529    for(int j = 0; j < length; ++j)
    530    {
    531      tmpLength = p1.distancePoint(vertices[j]);
    532      if( tmpLength > maxLength[1])
    533        maxLength[1] = tmpLength;
    534      else if( tmpLength < minLength[1])
    535        minLength[1] = tmpLength;
    536    }
    537 
    538    maxLength[2] = p2.distancePoint(vertices[0]);
    539    minLength[2] = p2.distancePoint(vertices[0]);
    540    for(int j = 0; j < length; ++j)
    541    {
    542      tmpLength = p2.distancePoint(vertices[j]);
    543      if( tmpLength > maxLength[2])
    544        maxLength[2] = tmpLength;
    545      else if( tmpLength < minLength[2])
    546        minLength[2] = tmpLength;
    547    }
    548 
    549 
    550    /* calculate the real centre of the body by using the axis length */
    551    float centerOffset[3];
    552    float newHalfLength[3];
    553    for(int i = 0; i < 3; ++i)
    554      {
    555        PRINTF(3)("max: %f, min: %f \n", maxLength[i], minLength[i]);
    556        centerOffset[i] = (maxLength[i] + minLength[i]) / 2.0f;       // min length is negatie
    557        newHalfLength[i] = (maxLength[i] - minLength[i]) / 2.0f;      // min length is negative
    558        *box->center +=  (box->axis[i] * centerOffset[i]);            // update the new center vector
    559        halfLength[i] = newHalfLength[i];
    560      }
    561 
    562 
    563 
    564   box->halfLength = halfLength;
    565   PRINTF(3)("-- Written Axis to obb\n");
    566   PRINTF(3)("-- Finished Calculating Attributes\n");
     332  /* for the initialisation the value just has to be inside of the polygon soup -> first vertices (rand) */
     333  tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[0]].indexToVertices[0]]);
     334  maxLength[0] = p0.distancePoint(*tmpVec);
     335  minLength[0] = p0.distancePoint(*tmpVec);
     336  for( int j = 0; j < length; ++j)
     337  {
     338    for( int i = 0; i < 3; ++i)
     339    {
     340      tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[j]].indexToVertices[i]]);
     341      tmpLength = p0.distancePoint(*tmpVec);
     342      if( tmpLength > maxLength[0])
     343        maxLength[0] = tmpLength;
     344      else if( tmpLength < minLength[0])
     345        minLength[0] = tmpLength;
     346    }
     347  }
     348
     349  /* for the initialisation the value just has to be inside of the polygon soup -> first vertices (rand) */
     350  tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[0]].indexToVertices[0]]);
     351  maxLength[1] = p1.distancePoint(*tmpVec);
     352  minLength[1] = p1.distancePoint(*tmpVec);
     353  for( int j = 0; j < length; ++j)
     354  {
     355    for( int i = 0; i < 3; ++i)
     356    {
     357      tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[j]].indexToVertices[i]]);
     358      tmpLength = p1.distancePoint(*tmpVec);
     359      if( tmpLength > maxLength[1])
     360        maxLength[1] = tmpLength;
     361      else if( tmpLength < minLength[1])
     362        minLength[1] = tmpLength;
     363    }
     364  }
     365
     366  /* for the initialisation the value just has to be inside of the polygon soup -> first vertices (rand) */
     367  tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[0]].indexToVertices[0]]);
     368  maxLength[2] = p2.distancePoint(*tmpVec);
     369  minLength[2] = p2.distancePoint(*tmpVec);
     370  for( int j = 0; j < length; ++j)
     371  {
     372    for( int i = 0; i < 3; ++i)
     373    {
     374      tmpVec = (sVec3D*)(&modelInf.pVertices[modelInf.pTriangles[triangleIndexes[j]].indexToVertices[i]]);
     375      tmpLength = p2.distancePoint(*tmpVec);
     376      if( tmpLength > maxLength[2])
     377        maxLength[2] = tmpLength;
     378      else if( tmpLength < minLength[2])
     379        minLength[2] = tmpLength;
     380    }
     381  }
     382
     383
     384  /* calculate the real centre of the body by using the axis length */
     385  float               centerOffset[3];
     386
     387  for( int i = 0; i < 3; ++i)
     388  {
     389    centerOffset[i] = (maxLength[i] + minLength[i]) / 2.0f;       // min length is negatie
     390    box.halfLength[i] = (maxLength[i] - minLength[i]) / 2.0f;      // min length is negative
     391  }
     392  box.center.x += centerOffset[0];
     393  box.center.y += centerOffset[1];
     394  box.center.z += centerOffset[2];
     395
     396  PRINTF(3)("\n");
     397  PRINT(3)("\tAxis Length x: %f (max: %11.2f, \tmin: %11.2f)\n", halfLength[0], maxLength[0], minLength[0]);
     398  PRINT(3)("\tAxis Length x: %f (max: %11.2f, \tmin: %11.2f)\n", halfLength[1], maxLength[1], minLength[1]);
     399  PRINT(3)("\tAxis Length x: %f (max: %11.2f, \tmin: %11.2f)\n", halfLength[2], maxLength[2], minLength[2]);
     400
     401
     402//   box.halfLength[0] = halfLength[0];
     403//   box.halfLength[1] = halfLength[1];
     404//   box.halfLength[2] = halfLength[2];
    567405}
    568406
    … …  
    570408
    571409/**
    572   \brief this separates an ob-box in the middle
    573 * @param box: the box to separate
    574 
    575   this will separate the box into to smaller boxes. the separation is done along the middle of the longest axis
     410 * this separates an ob-box in the middle
     411 * @param box: the box to separate
     412 *
     413 * this will separate the box into to smaller boxes. the separation is done along the middle of the longest axis
    576414 */
    577 void OBBTreeNode::forkBox(OBB* box)
    578 {
     415void OBBTreeNode::forkBox(OBB& box)
     416{
     417
     418  PRINTF(3)("Fork Box\n");
     419  PRINTF(4)("Calculating the longest Axis\n");
    579420  /* get the longest axis of the box */
    580   float               aLength = -1.0f;                     //!< the length of the longest axis
    581   int                 axisIndex = 0;                       //!< this is the nr of the longest axis
    582 
    583   for(int i = 0; i < 3; ++i)
    584   {
    585     if( aLength < box->halfLength[i])
    586     {
    587       aLength = box->halfLength[i];
    588       axisIndex = i;
    589     }
    590   }
    591 
    592    PRINTF(3)("longest axis is: nr %i with a half-length of: %f\n", axisIndex, aLength);
    593 
    594 
     421  float               longestAxis = -1.0f;                 //!< the length of the longest axis
     422  int                 longestAxisIndex = 0;                //!< this is the nr of the longest axis
     423
     424
     425  /* now get the longest axis of the three exiting */
     426  for( int i = 0; i < 3; ++i)
     427  {
     428    if( longestAxis < box.halfLength[i])
     429    {
     430      longestAxis = box.halfLength[i];
     431      longestAxisIndex = i;
     432    }
     433  }
     434  PRINTF(3)("\nLongest Axis is: Nr %i with a half-length of:%11.2f\n", longestAxisIndex, longestAxis);
     435
     436
     437  PRINTF(4)("Separating along the longest axis\n");
    595438  /* get the closest vertex near the center */
    596439  float               dist = 999999.0f;                    //!< the smallest distance to each vertex
    597   float               tmpDist;                             //!< temporary distance
    598   int                 vertexIndex;
    599   Plane               middlePlane(box->axis[axisIndex], *box->center); //!< the middle plane
    600 
    601   vertexIndex = 0;
    602   for(int i = 0; i < box->numOfVertices; ++i)
    603   {
    604     tmpDist = fabs(middlePlane.distancePoint(box->vertices[i]));
    605     if( tmpDist < dist)
    606     {
    607       dist = tmpDist;
    608       vertexIndex = i;
    609     }
    610   }
    611 
    612   PRINTF(3)("\nthe clostest vertex is nr: %i, with a dist of: %f\n", vertexIndex ,dist);
     440  float               tmpDist;                             //!< variable to save diverse distances temporarily
     441  int                 vertexIndex;                         //!< index of the vertex near the center
     442  Plane               middlePlane(box.axis[longestAxisIndex], box.center); //!< the middle plane
     443  const sVec3D*       tmpVec;                              //!< temp simple 3D vector
    613444
    614445
    … …  
    616447  the points depending on which side they are located
    617448  */
    618   tList<const sVec3D>      partition1;                           //!< the vertex partition 1
    619   tList<const sVec3D>      partition2;                           //!< the vertex partition 2
    620 
    621 
    622   PRINTF(3)("vertex index: %i, of %i\n", vertexIndex, box->numOfVertices);
    623   this->separationPlane = new Plane(box->axis[axisIndex], box->vertices[vertexIndex]);  //!< separation plane
    624   this->sepPlaneCenter = &box->vertices[vertexIndex];
    625   this->longestAxisIndex = axisIndex;
    626 
    627   for(int i = 0; i < box->numOfVertices; ++i)
    628   {
    629     if( i == vertexIndex) continue;
    630     tmpDist = this->separationPlane->distancePoint(box->vertices[i]);
    631     if( tmpDist > 0.0)
    632       partition1.add(&box->vertices[i]); /* positive numbers plus zero */
    633     else
    634       partition2.add(&box->vertices[i]); /* negatice numbers */
    635   }
    636   partition1.add(&box->vertices[vertexIndex]);
    637   partition2.add(&box->vertices[vertexIndex]);
    638 
    639   PRINTF(3)("\npartition1: got %i vertices/ partition 2: got %i vertices\n", partition1.getSize(), partition2.getSize());
     449  std::list<int>           partition1;                           //!< the vertex partition 1
     450  std::list<int>           partition2;                           //!< the vertex partition 2
     451  float*                   triangleCenter = new float[3];        //!< the center of the triangle
     452  const float*             a;                                    //!< triangle  edge a
     453  const float*             b;                                    //!< triangle  edge b
     454  const float*             c;                                    //!< triangle  edge c
     455
     456
     457  /* find the center of the box */
     458  this->separationPlane = Plane(box.axis[longestAxisIndex], box.center);
     459  this->sepPlaneCenter[0] = box.center.x;
     460  this->sepPlaneCenter[1] = box.center.y;
     461  this->sepPlaneCenter[2] = box.center.z;
     462  this->longestAxisIndex = longestAxisIndex;
     463
     464  for( int i = 0; i < box.triangleIndexesLength; ++i)
     465  {
     466    /* first calculate the middle of the triangle */
     467    a = &box.modelInf->pVertices[box.modelInf->pTriangles[box.triangleIndexes[i]].indexToVertices[0]];
     468    b = &box.modelInf->pVertices[box.modelInf->pTriangles[box.triangleIndexes[i]].indexToVertices[1]];
     469    c = &box.modelInf->pVertices[box.modelInf->pTriangles[box.triangleIndexes[i]].indexToVertices[2]];
     470
     471    triangleCenter[0] = (a[0] + b[0] + c[0]) / 3.0f;
     472    triangleCenter[1] = (a[1] + b[1] + c[1]) / 3.0f;
     473    triangleCenter[2] = (a[2] + b[2] + c[2]) / 3.0f;
     474    tmpDist = this->separationPlane.distancePoint(*((sVec3D*)triangleCenter));
     475
     476    if( tmpDist > 0.0f)
     477      partition1.push_back(box.triangleIndexes[i]); /* positive numbers plus zero */
     478    else if( tmpDist < 0.0f)
     479      partition2.push_back(box.triangleIndexes[i]); /* negatice numbers */
     480    else {
     481      partition1.push_back(box.triangleIndexes[i]); /* 0.0f? unprobable... */
     482      partition2.push_back(box.triangleIndexes[i]);
     483    }
     484  }
     485  PRINTF(3)("\nPartition1: got \t%i Vertices \nPartition2: got \t%i Vertices\n", partition1.size(), partition2.size());
    640486
    641487
    642488  /* now comes the separation into two different sVec3D arrays */
    643   tIterator<const sVec3D>* iterator;                       //!< the iterator to go through the lists
    644   const sVec3D*      element;                              //!< the elements
    645489  int                index;                                //!< index storage place
    646   sVec3D*            vertList1;                            //!< the vertex list 1
    647   sVec3D*            vertList2;                            //!< the vertex list 2
    648 
    649   vertList1 = new sVec3D[partition1.getSize()];
    650   vertList2 = new sVec3D[partition2.getSize()];
    651 
    652   iterator = partition1.getIterator();
    653   element = iterator->firstElement();
    654   index = 0;
    655   while( element != NULL)
    656   {
    657     vertList1[index][0] = element[0][0];
    658     vertList1[index][1] = element[0][1];
    659     vertList1[index][2] = element[0][2];
    660     ++index;
    661     element = iterator->nextElement();
    662   }
    663 
    664 //   PRINTF(0)("\npartition 1:\n");
    665 //   for(int i = 0; i < partition1.getSize(); ++i)
    666 //   {
    667 //     PRINTF(0)("v[%i][0] = %f,\tv[%i][1] = %f,\tv[%i][1] = %f\n", i, vertList1[i][0], i, vertList1[i][1], i, vertList1[i][2]);
    668 //   }
    669 
    670   iterator = partition2.getIterator();
    671   element = iterator->firstElement();
    672   index = 0;
    673   while( element != NULL)
    674   {
    675     vertList2[index][0] = element[0][0];
    676     vertList2[index][1] = element[0][1];
    677     vertList2[index][2] = element[0][2];
    678     ++index;
    679     element = iterator->nextElement();
    680   }
    681 
    682   this->tmpVert1 = vertList1;
    683   this->tmpVert2 = vertList2;
    684   this->tmpLen1 = partition1.getSize();
    685   this->tmpLen2 = partition2.getSize();
    686 
    687   delete iterator;
    688 
    689 //   PRINTF(0)("\npartition 2:\n");
    690 //   for(int i = 0; i < partition2.getSize(); ++i)
    691 //   {
    692 //     PRINTF(0)("v[%i][0] = %f,\tv[%i][1] = %f,\tv[%i][1] = %f\n", i, vertList2[i][0], i,  vertList2[i][1], i, vertList2[i][2]);
    693 //   }
    694 }
    695 
    696 
    697 
    698 
    699 void OBBTreeNode::collideWith(BVTreeNode* treeNode, WorldEntity* nodeA, WorldEntity* nodeB)
     490  int*               triangleIndexList1;                   //!< the vertex list 1
     491  int*               triangleIndexList2;                   //!< the vertex list 2
     492  std::list<int>::iterator element;                        //!< the list iterator
     493
     494  triangleIndexList1 = new int[partition1.size()];
     495  triangleIndexList2 = new int[partition2.size()];
     496
     497  for( element = partition1.begin(), index = 0; element != partition1.end(); element++, index++)
     498    triangleIndexList1[index] = (*element);
     499
     500  for( element = partition2.begin(), index = 0; element != partition2.end(); element++, index++)
     501    triangleIndexList2[index] = (*element);
     502
     503  if( this->triangleIndexList1!= NULL)
     504    delete[] this->triangleIndexList1;
     505  this->triangleIndexList1 = triangleIndexList1;
     506  this->triangleIndexLength1 = partition1.size();
     507
     508  if( this->triangleIndexList2 != NULL)
     509    delete[] this->triangleIndexList2;
     510  this->triangleIndexList2 = triangleIndexList2;
     511  this->triangleIndexLength2 = partition2.size();
     512}
     513
     514
     515
     516
     517void OBBTreeNode::collideWith(const BVTreeNode& treeNode, const WorldEntity& nodeA, const WorldEntity& nodeB) const
    700518{
    701519  PRINTF(3)("collideWith\n");
    702520  /* if the obb overlap, make subtests: check which node is realy overlaping  */
    703   PRINT(3)("Checking OBB %i vs %i: ", this->getIndex(), treeNode->getIndex());
    704   if( unlikely(treeNode == NULL)) return;
    705 
    706   if( this->overlapTest(this->bvElement, ((OBBTreeNode*)treeNode)->bvElement, nodeA, nodeB))
    707   {
    708     PRINTF(3)("collision @ lvl %i, object %s vs. %s, (%p, %p)\n", this->depth, nodeA->getClassName(), nodeB->getClassName(), this->nodeLeft, this->nodeRight);
     521  PRINTF(3)("Checking OBB %i vs %i: ", this->getIndex(), treeNode.getIndex());
     522  //   if( unlikely(treeNode == NULL)) return;
     523
     524
     525  if( this->overlapTest(*this->bvElement, *(((const OBBTreeNode*)&treeNode)->bvElement), nodeA, nodeB))
     526  {
     527    PRINTF(3)("collision @ lvl %i, object %s vs. %s, (%p, %p)\n", this->depth, nodeA.getClassName(), nodeB.getClassName(), this->nodeLeft, this->nodeRight);
    709528
    710529    /* check if left node overlaps */
    711530    if( likely( this->nodeLeft != NULL))
    712531    {
    713       PRINT(3)("Checking OBB %i vs %i: ", this->nodeLeft->getIndex(), treeNode->getIndex());
    714       if( this->overlapTest(this->nodeLeft->bvElement, ((OBBTreeNode*)treeNode)->bvElement, nodeA, nodeB))
     532      PRINTF(3)("Checking OBB %i vs %i: ", this->nodeLeft->getIndex(), treeNode.getIndex());
     533      if( this->overlapTest(*this->nodeLeft->bvElement, *(((const OBBTreeNode*)&treeNode)->bvElement), nodeA, nodeB))
    715534      {
    716         this->nodeLeft->collideWith(((OBBTreeNode*)treeNode)->nodeLeft, nodeA, nodeB);
    717         this->nodeLeft->collideWith(((OBBTreeNode*)treeNode)->nodeRight, nodeA, nodeB);
     535        this->nodeLeft->collideWith(*(((const OBBTreeNode*)&treeNode)->nodeLeft), nodeA, nodeB);
     536        this->nodeLeft->collideWith(*(((const OBBTreeNode*)&treeNode)->nodeRight), nodeA, nodeB);
    718537      }
    719538    }
    … …  
    721540    if( likely( this->nodeRight != NULL))
    722541    {
    723       PRINT(3)("Checking OBB %i vs %i: ", this->nodeRight->getIndex(), treeNode->getIndex());
    724       if(this->overlapTest(this->nodeRight->bvElement, ((OBBTreeNode*)treeNode)->bvElement, nodeA, nodeB))
     542      PRINTF(3)("Checking OBB %i vs %i: ", this->nodeRight->getIndex(), treeNode.getIndex());
     543      if(this->overlapTest(*this->nodeRight->bvElement, *(((const OBBTreeNode*)&treeNode)->bvElement), nodeA, nodeB))
    725544      {
    726        this->nodeRight->collideWith(((OBBTreeNode*)treeNode)->nodeLeft, nodeA, nodeB);
    727        this->nodeRight->collideWith(((OBBTreeNode*)treeNode)->nodeRight, nodeA, nodeB);
     545        this->nodeRight->collideWith(*(((const OBBTreeNode*)&treeNode)->nodeLeft), nodeA, nodeB);
     546        this->nodeRight->collideWith(*(((const OBBTreeNode*)&treeNode)->nodeRight), nodeA, nodeB);
    728547      }
    729548    }
    730549
    731550    /* so there is a collision and this is the last box in the tree (i.e. leaf) */
     551    /* FIXME: If we would choose || insead of && there would also be asymmetrical cases supported */
    732552    if( unlikely(this->nodeRight == NULL && this->nodeLeft == NULL))
    733553    {
    734       nodeA->collidesWith(nodeB, *((OBBTreeNode*)treeNode)->bvElement->center);
    735 
    736       nodeB->collidesWith(nodeA, *this->bvElement->center);
    737     }
    738 
    739   }
    740 }
    741 
    742 
    743 
    744 bool OBBTreeNode::overlapTest(OBB* boxA, OBB* boxB, WorldEntity* nodeA, WorldEntity* nodeB)
    745 {
     554      nodeA.collidesWith(nodeB, (((const OBBTreeNode*)&treeNode)->bvElement->center));
     555
     556      nodeB.collidesWith(nodeA, this->bvElement->center);
     557    }
     558
     559  }
     560}
     561
     562
     563
     564bool OBBTreeNode::overlapTest(const OBB& boxA, const OBB& boxB, const WorldEntity& nodeA, const WorldEntity& nodeB) const
     565{
     566  //   if( boxB == NULL || boxA == NULL)
     567  //     return false;
     568
    746569  /* first check all axis */
    747570  Vector t;
    … …  
    752575  Vector rotAxisB[3];
    753576
    754   rotAxisA[0] =  nodeA->getAbsDir().apply(boxA->axis[0]);
    755   rotAxisA[1] =  nodeA->getAbsDir().apply(boxA->axis[1]);
    756   rotAxisA[2] =  nodeA->getAbsDir().apply(boxA->axis[2]);
    757 
    758   rotAxisB[0] =  nodeB->getAbsDir().apply(boxB->axis[0]);
    759   rotAxisB[1] =  nodeB->getAbsDir().apply(boxB->axis[1]);
    760   rotAxisB[2] =  nodeB->getAbsDir().apply(boxB->axis[2]);
    761 
    762   t = nodeA->getAbsCoor() + nodeA->getAbsDir().apply(*boxA->center) - ( nodeB->getAbsCoor() + nodeB->getAbsDir().apply(*boxB->center));
    763 
    764 //   printf("\n");
    765 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[0].x, boxA->axis[0].y, boxA->axis[0].z, rotAxisA[0].x, rotAxisA[0].y, rotAxisA[0].z);
    766 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[1].x, boxA->axis[1].y, boxA->axis[1].z, rotAxisA[1].x, rotAxisA[1].y, rotAxisA[1].z);
    767 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[2].x, boxA->axis[2].y, boxA->axis[2].z, rotAxisA[2].x, rotAxisA[2].y, rotAxisA[2].z);
    768 //
    769 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[0].x, boxB->axis[0].y, boxB->axis[0].z, rotAxisB[0].x, rotAxisB[0].y, rotAxisB[0].z);
    770 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[1].x, boxB->axis[1].y, boxB->axis[1].z, rotAxisB[1].x, rotAxisB[1].y, rotAxisB[1].z);
    771 //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[2].x, boxB->axis[2].y, boxB->axis[2].z, rotAxisB[2].x, rotAxisB[2].y, rotAxisB[2].z);
     577  rotAxisA[0] =  nodeA.getAbsDir().apply(boxA.axis[0]);
     578  rotAxisA[1] =  nodeA.getAbsDir().apply(boxA.axis[1]);
     579  rotAxisA[2] =  nodeA.getAbsDir().apply(boxA.axis[2]);
     580
     581  rotAxisB[0] =  nodeB.getAbsDir().apply(boxB.axis[0]);
     582  rotAxisB[1] =  nodeB.getAbsDir().apply(boxB.axis[1]);
     583  rotAxisB[2] =  nodeB.getAbsDir().apply(boxB.axis[2]);
     584
     585
     586  t = nodeA.getAbsCoor() + nodeA.getAbsDir().apply(boxA.center) - ( nodeB.getAbsCoor() + nodeB.getAbsDir().apply(boxB.center));
     587
     588  //   printf("\n");
     589  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[0].x, boxA->axis[0].y, boxA->axis[0].z, rotAxisA[0].x, rotAxisA[0].y, rotAxisA[0].z);
     590  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[1].x, boxA->axis[1].y, boxA->axis[1].z, rotAxisA[1].x, rotAxisA[1].y, rotAxisA[1].z);
     591  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxA->axis[2].x, boxA->axis[2].y, boxA->axis[2].z, rotAxisA[2].x, rotAxisA[2].y, rotAxisA[2].z);
     592  //
     593  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[0].x, boxB->axis[0].y, boxB->axis[0].z, rotAxisB[0].x, rotAxisB[0].y, rotAxisB[0].z);
     594  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[1].x, boxB->axis[1].y, boxB->axis[1].z, rotAxisB[1].x, rotAxisB[1].y, rotAxisB[1].z);
     595  //   printf("(%f, %f, %f) -> (%f, %f, %f)\n", boxB->axis[2].x, boxB->axis[2].y, boxB->axis[2].z, rotAxisB[2].x, rotAxisB[2].y, rotAxisB[2].z);
    772596
    773597
    … …  
    779603    l = rotAxisA[j];
    780604
    781     rA += fabs(boxA->halfLength[0] * rotAxisA[0].dot(l));
    782     rA += fabs(boxA->halfLength[1] * rotAxisA[1].dot(l));
    783     rA += fabs(boxA->halfLength[2] * rotAxisA[2].dot(l));
    784 
    785     rB += fabs(boxB->halfLength[0] * rotAxisB[0].dot(l));
    786     rB += fabs(boxB->halfLength[1] * rotAxisB[1].dot(l));
    787     rB += fabs(boxB->halfLength[2] * rotAxisB[2].dot(l));
     605    rA += fabs(boxA.halfLength[0] * rotAxisA[0].dot(l));
     606    rA += fabs(boxA.halfLength[1] * rotAxisA[1].dot(l));
     607    rA += fabs(boxA.halfLength[2] * rotAxisA[2].dot(l));
     608
     609    rB += fabs(boxB.halfLength[0] * rotAxisB[0].dot(l));
     610    rB += fabs(boxB.halfLength[1] * rotAxisB[1].dot(l));
     611    rB += fabs(boxB.halfLength[2] * rotAxisB[2].dot(l));
    788612
    789613    PRINTF(3)("s = %f, rA+rB = %f\n", fabs(t.dot(l)), rA+rB);
    … …  
    791615    if( (rA + rB) < fabs(t.dot(l)))
    792616    {
    793       PRINT(3)("no Collision\n");
     617      PRINTF(3)("no Collision\n");
    794618      return false;
    795619    }
    … …  
    803627    l = rotAxisB[j];
    804628
    805     rA += fabs(boxA->halfLength[0] * rotAxisA[0].dot(l));
    806     rA += fabs(boxA->halfLength[1] * rotAxisA[1].dot(l));
    807     rA += fabs(boxA->halfLength[2] * rotAxisA[2].dot(l));
    808 
    809     rB += fabs(boxB->halfLength[0] * rotAxisB[0].dot(l));
    810     rB += fabs(boxB->halfLength[1] * rotAxisB[1].dot(l));
    811     rB += fabs(boxB->halfLength[2] * rotAxisB[2].dot(l));
     629    rA += fabs(boxA.halfLength[0] * rotAxisA[0].dot(l));
     630    rA += fabs(boxA.halfLength[1] * rotAxisA[1].dot(l));
     631    rA += fabs(boxA.halfLength[2] * rotAxisA[2].dot(l));
     632
     633    rB += fabs(boxB.halfLength[0] * rotAxisB[0].dot(l));
     634    rB += fabs(boxB.halfLength[1] * rotAxisB[1].dot(l));
     635    rB += fabs(boxB.halfLength[2] * rotAxisB[2].dot(l));
    812636
    813637    PRINTF(3)("s = %f, rA+rB = %f\n", fabs(t.dot(l)), rA+rB);
    … …  
    815639    if( (rA + rB) < fabs(t.dot(l)))
    816640    {
    817       PRINT(3)("no Collision\n");
     641      PRINTF(3)("no Collision\n");
    818642      return false;
    819643    }
    … …  
    831655      l = rotAxisA[j].cross(rotAxisB[k]);
    832656
    833       rA += fabs(boxA->halfLength[0] * rotAxisA[0].dot(l));
    834       rA += fabs(boxA->halfLength[1] * rotAxisA[1].dot(l));
    835       rA += fabs(boxA->halfLength[2] * rotAxisA[2].dot(l));
    836 
    837       rB += fabs(boxB->halfLength[0] * rotAxisB[0].dot(l));
    838       rB += fabs(boxB->halfLength[1] * rotAxisB[1].dot(l));
    839       rB += fabs(boxB->halfLength[2] * rotAxisB[2].dot(l));
     657      rA += fabs(boxA.halfLength[0] * rotAxisA[0].dot(l));
     658      rA += fabs(boxA.halfLength[1] * rotAxisA[1].dot(l));
     659      rA += fabs(boxA.halfLength[2] * rotAxisA[2].dot(l));
     660
     661      rB += fabs(boxB.halfLength[0] * rotAxisB[0].dot(l));
     662      rB += fabs(boxB.halfLength[1] * rotAxisB[1].dot(l));
     663      rB += fabs(boxB.halfLength[2] * rotAxisB[2].dot(l));
    840664
    841665      PRINTF(3)("s = %f, rA+rB = %f\n", fabs(t.dot(l)), rA+rB);
    … …  
    843667      if( (rA + rB) < fabs(t.dot(l)))
    844668      {
    845         PRINT(3)("keine Kollision\n");
     669        PRINTF(3)("keine Kollision\n");
    846670        return false;
    847671      }
    … …  
    849673  }
    850674
    851 
    852   boxA->bCollided = true; /* use this ONLY(!!!!) for drawing operations */
    853   boxB->bCollided = true;
    854   PRINT(3)("Kollision!\n");
     675  /* FIXME: there is no collision mark set now */
     676  //   boxA.bCollided = true; /* use this ONLY(!!!!) for drawing operations */
     677  //   boxB.bCollided = true;
     678
     679
     680  PRINTF(3)("Kollision!\n");
    855681  return true;
    856682}
    … …  
    863689{
    864690
    865   /* draw the model itself, there is some problem concerning this: the vertices are drawn multiple times */
     691
     692  /* this function can be used to draw the triangles and/or the points only  */
    866693  if( drawMode & DRAW_MODEL || drawMode & DRAW_ALL)
    867694  {
    … …  
    869696    {
    870697      if( drawMode & DRAW_POINTS)
     698      {
    871699        glBegin(GL_POINTS);
    872       for(int i = 0; i < this->bvElement->numOfVertices; ++i)
    873       {
    874         if( drawMode & DRAW_POINTS)
    875           glVertex3f(this->bvElement->vertices[i][0], this->bvElement->vertices[i][1], this->bvElement->vertices[i][2]);
    876         else
    877         {
    878           glPushMatrix();
    879           glTranslatef(this->bvElement->vertices[i][0], this->bvElement->vertices[i][1], this->bvElement->vertices[i][2]);
    880           gluSphere(OBBTreeNode_sphereObj, 0.1, 10, 10);
    881           glPopMatrix();
    882         }
     700        for( int i = 0; i < this->bvElement->modelInf->numVertices*3; i+=3)
     701          glVertex3f(this->bvElement->modelInf->pVertices[i],
     702                     this->bvElement->modelInf->pVertices[i+1],
     703                     this->bvElement->modelInf->pVertices[i+2]);
     704        glEnd();
    883705      }
    884       if( drawMode & DRAW_POINTS)
    885         glEnd();
    886706    }
    887707  }
    … …  
    915735
    916736
    917   if( drawMode & DRAW_BV_AXIS || drawMode & DRAW_ALL)
    918   {
    919     if( !(drawMode & DRAW_SINGLE && depth != 0))
     737  if( 1/*drawMode & DRAW_BV_AXIS || drawMode & DRAW_ALL*/)
     738  {
     739    if(1 /*!(drawMode & DRAW_SINGLE && depth != 0)*/)
    920740    {
    921741      /* draw the obb axes */
    922742      glBegin(GL_LINES);
    923       glColor3f(0.0, 0.4, 0.3);
    924       glVertex3f(this->bvElement->center->x, this->bvElement->center->y, this->bvElement->center->z);
    925       glVertex3f(this->bvElement->center->x + this->bvElement->axis[0].x * this->bvElement->halfLength[0],
    926                  this->bvElement->center->y + this->bvElement->axis[0].y * this->bvElement->halfLength[0],
    927                  this->bvElement->center->z + this->bvElement->axis[0].z * this->bvElement->halfLength[0]);
    928 
    929       glVertex3f(this->bvElement->center->x, this->bvElement->center->y, this->bvElement->center->z);
    930       glVertex3f(this->bvElement->center->x + this->bvElement->axis[1].x * this->bvElement->halfLength[1],
    931                  this->bvElement->center->y + this->bvElement->axis[1].y * this->bvElement->halfLength[1],
    932                  this->bvElement->center->z + this->bvElement->axis[1].z * this->bvElement->halfLength[1]);
    933 
    934       glVertex3f(this->bvElement->center->x, this->bvElement->center->y, this->bvElement->center->z);
    935       glVertex3f(this->bvElement->center->x + this->bvElement->axis[2].x * this->bvElement->halfLength[2],
    936                  this->bvElement->center->y + this->bvElement->axis[2].y * this->bvElement->halfLength[2],
    937                  this->bvElement->center->z + this->bvElement->axis[2].z * this->bvElement->halfLength[2]);
     743      glColor3f(1.0, 0.0, 0.0);
     744      glVertex3f(this->bvElement->center.x, this->bvElement->center.y, this->bvElement->center.z);
     745      glVertex3f(this->bvElement->center.x + this->bvElement->axis[0].x * this->bvElement->halfLength[0],
     746                 this->bvElement->center.y + this->bvElement->axis[0].y * this->bvElement->halfLength[0],
     747                 this->bvElement->center.z + this->bvElement->axis[0].z * this->bvElement->halfLength[0]);
     748
     749      glColor3f(0.0, 1.0, 0.0);
     750      glVertex3f(this->bvElement->center.x, this->bvElement->center.y, this->bvElement->center.z);
     751      glVertex3f(this->bvElement->center.x + this->bvElement->axis[1].x * this->bvElement->halfLength[1],
     752                 this->bvElement->center.y + this->bvElement->axis[1].y * this->bvElement->halfLength[1],
     753                 this->bvElement->center.z + this->bvElement->axis[1].z * this->bvElement->halfLength[1]);
     754
     755      glColor3f(0.0, 0.0, 1.0);
     756      glVertex3f(this->bvElement->center.x, this->bvElement->center.y, this->bvElement->center.z);
     757      glVertex3f(this->bvElement->center.x + this->bvElement->axis[2].x * this->bvElement->halfLength[2],
     758                 this->bvElement->center.y + this->bvElement->axis[2].y * this->bvElement->halfLength[2],
     759                 this->bvElement->center.z + this->bvElement->axis[2].z * this->bvElement->halfLength[2]);
    938760      glEnd();
    939761    }
    … …  
    950772    }
    951773
    952     if(this->nodeLeft == NULL || this->nodeRight == NULL)
     774    if( this->nodeLeft == NULL || this->nodeRight == NULL)
    953775      depth = 0;
    954776    if( !(drawMode & DRAW_SINGLE && depth != 0))
    955777    {
    956     Vector cen = *this->bvElement->center;
    957     Vector* axis = this->bvElement->axis;
    958     float* len = this->bvElement->halfLength;
    959 
    960     if( this->bvElement->bCollided)
    961     {
    962       glColor4f(1.0, 1.0, 1.0, .5); // COLLISION COLOR
    963     }
    964     else if( drawMode & DRAW_BV_BLENDED)
    965     {
    966       glColor4f(color.x, color.y, color.z, .5);
    967     }
    968 
    969     /* draw bounding box */
    970     if( drawMode & DRAW_BV_BLENDED)
    971       glBegin(GL_QUADS);
    972     else
    973       glBegin(GL_LINE_LOOP);
    974     glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
    975                cen.y + axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    976                cen.z + axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    977     glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    978                cen.y + axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    979                cen.z + axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    980     glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
    981                cen.y + axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    982                cen.z + axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
    983     glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    984                cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    985                cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    986     glEnd();
    987 
    988     if( drawMode & DRAW_BV_BLENDED)
    989       glBegin(GL_QUADS);
    990     else
    991       glBegin(GL_LINE_LOOP);
    992     glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    993                cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    994                cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    995     glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
    996                cen.y + axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    997                cen.z + axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
    998     glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
    999                cen.y - axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    1000                cen.z - axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
    1001     glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    1002                cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    1003                cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    1004     glEnd();
    1005 
    1006     if( drawMode & DRAW_BV_BLENDED)
    1007       glBegin(GL_QUADS);
    1008     else
    1009       glBegin(GL_LINE_LOOP);
    1010     glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    1011                cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    1012                cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    1013     glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
    1014                cen.y - axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    1015                cen.z - axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
    1016     glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    1017                cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    1018                cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    1019     glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
    1020                cen.y - axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    1021                cen.z - axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    1022     glEnd();
    1023 
    1024     if( drawMode & DRAW_BV_BLENDED)
    1025       glBegin(GL_QUADS);
    1026     else
    1027       glBegin(GL_LINE_LOOP);
    1028     glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    1029                cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    1030                cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    1031     glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
    1032                cen.y - axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    1033                cen.z - axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    1034     glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
    1035                cen.y + axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    1036                cen.z + axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    1037     glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    1038                cen.y + axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    1039                cen.z + axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    1040     glEnd();
    1041 
    1042 
    1043     if( drawMode & DRAW_BV_BLENDED)
    1044     {
    1045       glBegin(GL_QUADS);
    1046       glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    1047                  cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    1048                  cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
     778      Vector cen = this->bvElement->center;
     779      Vector* axis = this->bvElement->axis;
     780      float* len = this->bvElement->halfLength;
     781
     782      if( this->bvElement->bCollided)
     783      {
     784        glColor4f(1.0, 1.0, 1.0, .5); // COLLISION COLOR
     785      }
     786      else if( drawMode & DRAW_BV_BLENDED)
     787      {
     788        glColor4f(color.x, color.y, color.z, .5);
     789      }
     790
     791      /* draw bounding box */
     792      if( drawMode & DRAW_BV_BLENDED)
     793        glBegin(GL_QUADS);
     794      else
     795        glBegin(GL_LINE_LOOP);
     796      glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
     797                 cen.y + axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
     798                 cen.z + axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    1049799      glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
    1050800                 cen.y + axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
    … …  
    1053803                 cen.y + axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    1054804                 cen.z + axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
     805      glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     806                 cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     807                 cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     808      glEnd();
     809
     810      if( drawMode & DRAW_BV_BLENDED)
     811        glBegin(GL_QUADS);
     812      else
     813        glBegin(GL_LINE_LOOP);
     814      glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     815                 cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     816                 cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     817      glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
     818                 cen.y + axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
     819                 cen.z + axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
    1055820      glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
    1056821                 cen.y - axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
    1057822                 cen.z - axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
     823      glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     824                 cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     825                 cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    1058826      glEnd();
    1059827
    1060       glBegin(GL_QUADS);
     828      if( drawMode & DRAW_BV_BLENDED)
     829        glBegin(GL_QUADS);
     830      else
     831        glBegin(GL_LINE_LOOP);
     832      glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     833                 cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     834                 cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     835      glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
     836                 cen.y - axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
     837                 cen.z - axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
     838      glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
     839                 cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
     840                 cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
     841      glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
     842                 cen.y - axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
     843                 cen.z - axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
     844      glEnd();
     845
     846      if( drawMode & DRAW_BV_BLENDED)
     847        glBegin(GL_QUADS);
     848      else
     849        glBegin(GL_LINE_LOOP);
     850      glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
     851                 cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
     852                 cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    1061853      glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
    1062854                 cen.y - axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    … …  
    1065857                 cen.y + axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
    1066858                 cen.z + axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
    1067       glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    1068                  cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    1069                  cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
    1070       glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
    1071                  cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
    1072                  cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     859      glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
     860                 cen.y + axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
     861                 cen.z + axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
    1073862      glEnd();
    1074     }
    1075 
    1076 
    1077     if( drawMode & DRAW_BV_BLENDED)
    1078       glColor3f(color.x, color.y, color.z);
     863
     864
     865      if( drawMode & DRAW_BV_BLENDED)
     866      {
     867        glBegin(GL_QUADS);
     868        glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
     869                   cen.y - axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
     870                   cen.z - axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
     871        glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] - axis[2].x * len[2],
     872                   cen.y + axis[0].y * len[0] + axis[1].y * len[1] - axis[2].y * len[2],
     873                   cen.z + axis[0].z * len[0] + axis[1].z * len[1] - axis[2].z * len[2]);
     874        glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
     875                   cen.y + axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
     876                   cen.z + axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
     877        glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] - axis[2].x * len[2],
     878                   cen.y - axis[0].y * len[0] - axis[1].y * len[1] - axis[2].y * len[2],
     879                   cen.z - axis[0].z * len[0] - axis[1].z * len[1] - axis[2].z * len[2]);
     880        glEnd();
     881
     882        glBegin(GL_QUADS);
     883        glVertex3f(cen.x - axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
     884                   cen.y - axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
     885                   cen.z - axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
     886        glVertex3f(cen.x + axis[0].x * len[0] + axis[1].x * len[1] + axis[2].x * len[2],
     887                   cen.y + axis[0].y * len[0] + axis[1].y * len[1] + axis[2].y * len[2],
     888                   cen.z + axis[0].z * len[0] + axis[1].z * len[1] + axis[2].z * len[2]);
     889        glVertex3f(cen.x + axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     890                   cen.y + axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     891                   cen.z + axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     892        glVertex3f(cen.x - axis[0].x * len[0] - axis[1].x * len[1] + axis[2].x * len[2],
     893                   cen.y - axis[0].y * len[0] - axis[1].y * len[1] + axis[2].y * len[2],
     894                   cen.z - axis[0].z * len[0] - axis[1].z * len[1] + axis[2].z * len[2]);
     895        glEnd();
     896      }
     897
     898
     899      if( drawMode & DRAW_BV_BLENDED)
     900        glColor3f(color.x, color.y, color.z);
    1079901    }
    1080902
    … …  
    1089911        glColor4f(color.x, color.y, color.z, .6);
    1090912
    1091     /* now draw the separation plane */
    1092     Vector a1 = this->bvElement->axis[(this->longestAxisIndex + 1)%3];
    1093     Vector a2 = this->bvElement->axis[(this->longestAxisIndex + 2)%3];
    1094     Vector c = *this->bvElement->center;
    1095     float l1 = this->bvElement->halfLength[(this->longestAxisIndex + 1)%3];
    1096     float l2 = this->bvElement->halfLength[(this->longestAxisIndex + 2)%3];
    1097     glBegin(GL_QUADS);
    1098     glVertex3f(c.x + a1.x * l1 + a2.x * l2, c.y + a1.y * l1+ a2.y * l2, c.z + a1.z * l1 + a2.z * l2);
    1099     glVertex3f(c.x - a1.x * l1 + a2.x * l2, c.y - a1.y * l1+ a2.y * l2, c.z - a1.z * l1 + a2.z * l2);
    1100     glVertex3f(c.x - a1.x * l1 - a2.x * l2, c.y - a1.y * l1- a2.y * l2, c.z - a1.z * l1 - a2.z * l2);
    1101     glVertex3f(c.x + a1.x * l1 - a2.x * l2, c.y + a1.y * l1- a2.y * l2, c.z + a1.z * l1 - a2.z * l2);
    1102     glEnd();
    1103 
    1104     if( drawMode & DRAW_BV_BLENDED)
    1105       glColor4f(color.x, color.y, color.z, 1.0);
     913      /* now draw the separation plane */
     914      Vector a1 = this->bvElement->axis[(this->longestAxisIndex + 1)%3];
     915      Vector a2 = this->bvElement->axis[(this->longestAxisIndex + 2)%3];
     916      Vector c = this->bvElement->center;
     917      float l1 = this->bvElement->halfLength[(this->longestAxisIndex + 1)%3];
     918      float l2 = this->bvElement->halfLength[(this->longestAxisIndex + 2)%3];
     919      glBegin(GL_QUADS);
     920      glVertex3f(c.x + a1.x * l1 + a2.x * l2, c.y + a1.y * l1+ a2.y * l2, c.z + a1.z * l1 + a2.z * l2);
     921      glVertex3f(c.x - a1.x * l1 + a2.x * l2, c.y - a1.y * l1+ a2.y * l2, c.z - a1.z * l1 + a2.z * l2);
     922      glVertex3f(c.x - a1.x * l1 - a2.x * l2, c.y - a1.y * l1- a2.y * l2, c.z - a1.z * l1 - a2.z * l2);
     923      glVertex3f(c.x + a1.x * l1 - a2.x * l2, c.y + a1.y * l1- a2.y * l2, c.z + a1.z * l1 - a2.z * l2);
     924      glEnd();
     925
     926      if( drawMode & DRAW_BV_BLENDED)
     927        glColor4f(color.x, color.y, color.z, 1.0);
    1106928
    1107929    }
    … …  
    1127949void OBBTreeNode::debug() const
    1128950{
    1129 
    1130   /*
    1131   for(int i = 0; i < length; i++)
    1132   {
    1133   PRINTF(3)("vertex %i: %f, %f, %f\n", i, verticesList[i][0], verticesList[i][1], verticesList[i][2]);
    1134 }
    1135   */
    1136 }
     951  PRINT(0)("========OBBTreeNode::debug()=====\n");
     952  PRINT(0)(" Current depth: %i", this->depth);
     953  PRINT(0)(" ");
     954  PRINT(0)("=================================\n");
     955}

  • branches/cd_merge/src/lib/collision_detection/obb_tree_node.h

    r5693 r6657  
    11/*!
    22 * @file bv_tree.h
    3   *  Definition of a bounding volume tree
    4 
     3 *  Definition of a bounding volume tree
    54 */
    65
    … …  
    87#define _OBB_TREE_NODE_H
    98
     9
    1010#include "bv_tree_node.h"
    1111
    1212
    13 
    14 // FORWARD DECLARATION
    1513class BoundingVolume;
    1614class OBB;
    … …  
    1816class Plane;
    1917class PNode;
    20 //struct sVec3D;
     18
    2119
    2220//! A class that represents a bounding volume tree
    23 class OBBTreeNode : public BVTreeNode {
     21class OBBTreeNode : public BVTreeNode
     22{
    2423
    2524
    2625  public:
    27     OBBTreeNode();
     26    OBBTreeNode(const OBBTree& tree, OBBTreeNode* prev, int depth);
    2827    virtual ~OBBTreeNode();
    2928
    30     virtual void spawnBVTree(const int depth, const sVec3D *verticesList, unsigned int length);
    31     virtual void spawnBVTree(const int depth, const modelInfo& modInfo);
     29    /**  this function returns the bounding volume of this tree node @return: returns the BV */
     30    virtual inline const BoundingVolume* getBV() const { return (BoundingVolume*)this->bvElement; }
    3231
    33     BoundingVolume* getBV(int index) const { return (BoundingVolume*)this->bvElement; }
    34     inline const int getIndex() { return this->treeIndex; }
    35     inline void setTreeRef(OBBTree* tree) { this->obbTree = tree;}
     32    virtual void spawnBVTree(const modelInfo& modelInf, const int* triangleIndexes, int length);
    3633
    37     virtual void collideWith(BVTreeNode* treeNode, WorldEntity* nodeA, WorldEntity* nodeB);
    38 
     34    virtual void collideWith(const BVTreeNode& treeNode, const WorldEntity& nodeA, const WorldEntity& nodeB) const;
    3935    virtual void drawBV(int depth, int drawMode, const Vector& color = Vector(1,0,0), bool top = true) const;
    40 
    4136    void debug() const;
    4237
    43   private:
    44     void calculateBoxCovariance(OBB* box, const sVec3D* verticesList, unsigned int length);
    45     void calculateBoxEigenvectors(OBB* box, const sVec3D* verticesList, unsigned int length);
    46     void calculateBoxAxis(OBB* box, const sVec3D* verticesList, unsigned int length);
    47 
    48     void calculateBoxCovariance(OBB* box, const modelInfo& modInfo);
    49     void calculateBoxEigenvectors(OBB* box, const modelInfo& modInfo);
    50     void calculateBoxAxis(OBB* box, const modelInfo& modInfo);
     38    /**  gets the id of the current child @return id of the child */
     39    inline const int getID() { return this->nextID++; }
    5140
    5241
    53     void forkBox(OBB* box);
     42  private:
     43    void calculateBoxAxis(OBB& box, const sVec3D* verticesList, unsigned int length);
    5444
    55     bool overlapTest(OBB* boxA, OBB* boxB, WorldEntity* nodeA, WorldEntity* nodeB);
     45    void calculateBoxCovariance(OBB& box, const modelInfo& modelInf, const int* triangleIndexes, int length);
     46    void calculateBoxEigenvectors(OBB& box, const modelInfo& modelInf, const int* triangleIndexes, int length);
     47    void calculateBoxAxis(OBB& box, const modelInfo& modelInf, const int* triangleIndexes, int length);
     48    void forkBox(OBB& box);
     49
     50    bool overlapTest(const OBB& boxA, const OBB& boxB, const WorldEntity& nodeA, const WorldEntity& nodeB) const;
     51
    5652
    5753  protected:
    5854    OBB*                bvElement;                  //!< the obb element
     55    OBBTreeNode*        nodePrev;                   //!< ref to the previous (parent) tree node = NULL if first
    5956    OBBTreeNode*        nodeLeft;                   //!< ref to the left tree node
    6057    OBBTreeNode*        nodeRight;                  //!< ref to the right tree node
    6158
     59
    6260  private:
    63     unsigned int        treeIndex;                  //!< Index number of the BV in the tree
    64     const sVec3D*       vertices;                   //!< pointer to the vertices data
    65     int                 numOfVertices;              //!< number of vertices in vertices data
     61    int                 treeIndex;                  //!< Index number of the BV in the tree
     62    int                 nextID;                     //!< the id of the next child
    6663    int                 depth;                      //!< the depth of the node in the tree
    67     static OBBTree*     obbTree;                    //!< reference to the obb tree
    68     Plane*              separationPlane;            //!< the separation plane of the obb
    69     const sVec3D*       sepPlaneCenter;             //!< only needed to draw plane
     64    const OBBTree*      obbTree;                    //!< reference to the obb tree
     65
     66    const modelInfo*    modelInf;                   //!< pointer to the models modelInfo object
     67    const int*          triangleIndexes;            //!< indexes to the used model triangles
     68
     69    Plane               separationPlane;            //!< the separation plane of the obb
     70    sVec3D              sepPlaneCenter;             //!< only needed to draw plane
    7071    int                 longestAxisIndex;           //!< only needed to draw plane
    7172
    7273    /* tmp saving place for obb variables */
    73     sVec3D*             tmpVert1;                   //!< pointer to the vert data of obbox1
    74     sVec3D*             tmpVert2;                   //!< pointer to the vert data of obbox1
    75     int                 tmpLen1;                    //!< len vert data obbox1
    76     int                 tmpLen2;                    //!< len vert data obbox2
    77 
    78     static float**      coMat;
    79     static float**      eigvMat;
    80     static float*       eigvlMat;
    81     static int*         rotCount;
     74    int*                triangleIndexList1;         //!< pointer to the vert data of obbox1
     75    int*                triangleIndexList2;         //!< pointer to the vert data of obbox1
     76    int                 triangleIndexLength1;       //!< len vert data obbox1
     77    int                 triangleIndexLength2;       //!< len vert data obbox2
    8278};
    8379

  • branches/cd_merge/src/lib/math/matrix.cc

    r5696 r6657  
    244244
    245245    eigVc3 = eigVc1.cross(eigVc2);
     246
     247    eigVc2 = eigVc3.cross(eigVc1);
    246248  }
    247249  else if (eigenValuesCount == 1)
    … …  
    254256  eigVc2.normalize();
    255257  eigVc3.normalize();
     258
     259  if (!(eigVc1.cross(eigVc3) == eigVc2))
     260  {
     261    eigVc3.cross(eigVc1).debug();
     262    eigVc2.debug();
     263  }
     264  printf("ok\n");
    256265}
    257266

  • branches/cd_merge/src/lib/util/executor/executor_specials.h

    r5944 r6657  
    88
    99#include "executor.h"
     10#include "compiler.h"
    1011
    1112#include "compiler.h"
Note: See TracChangeset for help on using the changeset viewer.