Changeset 8081 in orxonox.OLD for branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc

Timestamp:

Jun 1, 2006, 4:42:01 PM (18 years ago)

Author:

bottac

Message:

Loadable from .oxw

File:

• branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc (modified) (14 diffs)

branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc

@@ -11 +11 @@
    ### File Specific:
    main-programmer: bottac@ee.ethz.ch
+   
+   Inspired by:
+   Rendering Q3 Maps by Morgan McGuire                  http://graphics.cs.brown.edu/games/quake/quake3.html
+   Unofficial Quake 3 Map Specs by Kekoa Proudfoot      http://graphics.stanford.edu/~kekoa/q3/
+   
+   Collision detection adapted from:
+   Quake 3 Collision Detection by Nathan Ostgard        http://www.devmaster.net/articles/quake3collision/
 */
 
@@ -36 +43 @@
 #include "world_entity.h"
 
+#include "util/loading/load_param.h"
+#include "util/loading/factory.h"
+
+
+//CREATE_FACTORY( BspManager, CL_BSP_MODEL);
+
 BspManager::BspManager()
 {
-  // open a BSP file
+  /*// open a BSP file
   this->bspFile = new BspFile();
+  this->bspFile->scale = 0.4f;
   this->bspFile->read(ResourceManager::getFullName("test.bsp").c_str());
   this->bspFile->build_tree();
   this->root  = this->bspFile->get_root();
   this->alreadyVisible = new bool [this->bspFile->numFaces];
-
+  */
   CDEngine::getInstance()->setBSPModel(this);
-}
-
-void BspManager::draw()
-{
-
-
+  
+  
+  
+}
+
+
+/*
+BspManager::BspManager(const TiXmlElement* root)
+{
+
+  
+  if( root != NULL)
+    this->loadParams(root);
+  
+  CDEngine::getInstance()->setBSPModel(this);
+} */
+
+void BspManager::load(const char* fileName, float scale)
+{
+  //this->setClassID(CL_BSP_MODEL, "BspManager");
+    // open a BSP file
+  this->bspFile = new BspFile();
+  this->bspFile->scale =  scale;
+  this->bspFile->read(ResourceManager::getFullName(fileName).c_str());
+  this->bspFile->build_tree();
+  this->root  = this->bspFile->get_root();
+  this->alreadyVisible = new bool [this->bspFile->numFaces];
+
+
+}
+/*
+BspManager::BspManager(const char* fileName, float scale)
+{
+  // open a BSP file
+  this->bspFile = new BspFile();
+  this->bspFile->scale =  scale;
+  this->bspFile->read(fileName);
+  this->bspFile->build_tree();
+  this->root  = this->bspFile->get_root();
+  this->alreadyVisible = new bool [this->bspFile->numFaces];
+
+  CDEngine::getInstance()->setBSPModel(this);
+}
+*/
+
+const void BspManager::draw()
+{
+
+  /*
   this->drawDebugCube(&this->out);
   this->out1 = this->out;
@@ -67 +124 @@
   this->drawDebugCube(&this->out1);
   this->drawDebugCube(&this->out2);
-  
+  */ 
   // Draw Debug Terrain
   /*
@@ -192 +249 @@
         const float dMaxs = dir.x*(float)curLeaf.maxs[0] +dir.y*(float)curLeaf.maxs[1] +dir.z*(float)curLeaf.maxs[2] - dist;
 
-        if(dMins < -100.0 && dMaxs < -  100.0) {
+        if(dMins < -50.0 && dMaxs < -  50.0) {
           continue;
         }
@@ -223 +280 @@
     this->trasparent.pop_back();
   }
+  //glEnable(GL_TEXTURE_2D);
   glActiveTextureARB(GL_TEXTURE1_ARB);
   glBindTexture(GL_TEXTURE_2D, this->bspFile->whiteLightMap);
-  glEnable(GL_TEXTURE_2D);
+  
+ 
 
 }//draw
@@ -479 +538 @@
       if (fraction > startFraction)
         startFraction = fraction;
+      // don't store plane
+      // this->collPlane = &curPlane;
+      
+    } else {   // line is leaving the brush
+      float fraction = (startDistance + EPSILON) / (startDistance - endDistance);  // *
+      if (fraction < endFraction)
+        endFraction = fraction;
+      // don't store plane
+      //this->collPlane = & curPlane;
+      
+    }
+
+  }
+  if (startsOut == false) {
+    this->outputStartsOut = false;
+    if (endsOut == false)
+      this->outputAllSolid = true;
+    return;
+  }
+
+  if (startFraction < endFraction) {
+    if (startFraction > -1.0f && startFraction < outputFraction) {
+      if (startFraction < 0)
+        startFraction = 0;
+      this->outputFraction = startFraction; 
+    }
+  }
+
+}
+
+void BspManager::checkBrushRayN(brush* curBrush)
+{
+  float EPSILON = 0.000001;
+  float startDistance;
+  float endDistance;
+
+  float startFraction = -1.0f;
+  float endFraction = 1.0f;
+  bool startsOut = false;
+  bool endsOut = false;
+
+  Vector inputStart = State::getCameraTargetNode()->getLastAbsCoor();
+  Vector inputEnd   = State::getCameraTargetNode()->getAbsCoor();
+
+  for (int i = 0; i < curBrush->n_brushsides; i++) {
+    brushside& curBrushSide =   this->bspFile->brushSides[curBrush->brushside + i]   ;
+    plane& curPlane  =   this->bspFile->planes[curBrushSide.plane] ;
+
+    startDistance = inputStart.x * curPlane.x + inputStart.y * curPlane.y+ inputStart.z * curPlane.z - curPlane.d;
+    endDistance = inputEnd.x * curPlane.x +inputEnd.y * curPlane.y +inputEnd.z * curPlane.z -curPlane.d;
+
+    if (startDistance > 0)
+      startsOut = true;
+    if (endDistance > 0)
+      endsOut = true;
+
+    // make sure the trace isn't completely on one side of the brush
+    if (startDistance > 0 && endDistance > 0) {   // both are in front of the plane, its outside of this brush
+      return;
+    }
+    if (startDistance <= 0 && endDistance <= 0) {   // both are behind this plane, it will get clipped by another one
+      continue;
+    }
+
+    // MMM... BEEFY
+    if (startDistance > endDistance) {   // line is entering into the brush
+      float fraction = (startDistance - EPSILON) / (startDistance - endDistance);  // *
+      if (fraction > startFraction)
+        startFraction = fraction;
       // store plane
       this->collPlane = &curPlane;
@@ -508 +636 @@
 
 }
+
 
 void BspManager::checkCollisionRay(BspTreeNode* node, float startFraction, float endFraction, Vector* start, Vector* end)
@@ -604 +733 @@
 
 
+
+void BspManager::checkCollisionRayN(BspTreeNode* node, float startFraction, float endFraction, Vector* start, Vector* end)
+{
+
+
+  float EPSILON = 0.000001;
+  float  endDistance = (end)->x * (node->plane.x) +(end)->y * (node->plane.y) +(end)->z * (node->plane.z)  - node->d;
+  float  startDistance = (start)->x * (node->plane.x)+ (start)->y * (node->plane.y)+ (start)->z * (node->plane.z)- node->d;
+
+
+  if(node->isLeaf) {
+    leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
+    for (int i = 0; i <  curLeaf.n_leafbrushes ; i++) {
+      brush& curBrush = this->bspFile->brushes[((int*)(this->bspFile->leafBrushes))[curLeaf.leafbrush_first+i]];
+      //object *brush = &BSP.brushes[BSP.leafBrushes[leaf->firstLeafBrush + i]];
+      if (curBrush.n_brushsides > 0   &&
+          ((((BspTexture*)(this->bspFile->textures))[curBrush.texture]).contents & 1))
+        // CheckBrush( brush );
+        this->checkBrushRayN(&curBrush);
+      if(curBrush.n_brushsides <=0) this->outputAllSolid = true;
+    }
+    return;
+  }
+
+
+  if (startDistance >= 0 && endDistance >= 0)     // A
+  {   // both points are in front of the plane
+    // so check the front child
+    this->checkCollisionRayN(node->left,0,0,start,end);
+  } else if (startDistance < 0 && endDistance < 0)  // B
+  {   // both points are behind the plane
+    // so check the back child
+    this->checkCollisionRayN(node->right,0,0,start,end);
+  } else                                            // C
+  {   // the line spans the splitting plane
+    int side;
+    float fraction1, fraction2, middleFraction;
+    Vector middle;
+
+    // STEP 1: split the segment into two
+    if (startDistance < endDistance) {
+      side = 1; // back
+      float inverseDistance = 1.0f / (startDistance - endDistance);
+      fraction1 = (startDistance + EPSILON) * inverseDistance;
+      fraction2 = (startDistance + EPSILON) * inverseDistance;
+    } else if (endDistance < startDistance) {
+      side = 0; // front(start)->x * (node->plane.x)+
+      float inverseDistance = 1.0f / (startDistance - endDistance);
+      fraction1 = (startDistance + EPSILON) * inverseDistance;
+      fraction2 = (startDistance - EPSILON) * inverseDistance;
+    } else {
+      side = 0; // front
+      fraction1 = 1.0f;
+      fraction2 = 0.0f;
+    }
+
+    // STEP 2: make sure the numbers are valid
+    if (fraction1 < 0.0f) fraction1 = 0.0f;
+    else if (fraction1 > 1.0f) fraction1 = 1.0f;
+    if (fraction2 < 0.0f) fraction2 = 0.0f;
+    else if (fraction2 > 1.0f) fraction2 = 1.0f;
+
+    // STEP 3: calculate the middle point for the first side
+    middleFraction = startFraction +
+        (endFraction - startFraction) * fraction1;
+
+    middle.x = start->x + fraction1 * (end->x - start->x);
+    middle.y = start->y + fraction1 * (end->y - start->y);
+    middle.z = start->z + fraction1 * (end->z - start->z);
+
+    // STEP 4: check the first side
+    //CheckNode( node->children[side], startFraction, middleFraction, start, middle );
+    if(side == 0) this->checkCollisionRayN(node->left,startFraction, middleFraction, start, &middle );
+
+    else this->checkCollisionRayN(node->right,startFraction, middleFraction,
+                                 start, &middle );
+
+    // STEP 5: calculate the middle point for the second side
+    middleFraction = startFraction +
+        (endFraction - startFraction) * fraction2;
+
+    middle.x = start->x + fraction2 * (end->x - start->x);
+    middle.y = start->y + fraction2 * (end->y - start->y);
+    middle.z = start->z + fraction2 * (end->z - start->z);
+
+    // STEP 6: check the second side
+    if(side == 1)this->checkCollisionRayN(node->left,middleFraction, endFraction, &middle, end);
+
+    else this->checkCollisionRayN(node->right,middleFraction, endFraction,&middle, end );
+
+
+  }
+
+}
+
 void BspManager::checkCollision(WorldEntity* worldEntity)
 {
- // return;
+  return;
   
   Vector position = worldEntity->getAbsCoor();
@@ -623 +847 @@
   Vector out = Vector(-1875.0,-1875.0,-1875.0);
   if(!worldEntity->isA(CL_PLAYABLE)) {
+    
+    
+    
+ 
   }
   else {
@@ -634 +862 @@
     Vector out2;
 
-    this->checkCollisionRay(this->root,0.0f,1.0f, &position1, &dest1 );
+    this->checkCollisionRayN(this->root,0.0f,1.0f, &position1, &dest1 );
     if(this->outputFraction == 1.0f)  out1 = dest;
     else {
@@ -644 +872 @@
     }
 
-    this->checkCollisionRay(this->root,0.0f,1.0f, &position2, &dest2 );
+    this->checkCollisionRayN(this->root,0.0f,1.0f, &position2, &dest2 );
     if(this->outputFraction == 1.0f) out2= dest;
     else
@@ -655 +883 @@
     }
     
-    this->checkCollisionRay(this->root,0.0f,1.0f, &position, &dest );
+    this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &dest );
     if(this->outputFraction == 1.0f) out = dest;
     else
@@ -664 +892 @@
     out.z = position.z + (dest.z -position.z) * this->outputFraction;
     
-    Vector out3 = out + Vector(3*this->collPlane->x,3*this->collPlane->y,3*this->collPlane->z);
-    this->out = out;
-    this->out1 = out1;
-    this->out2 = out2;
+    //Vector out3 = out + Vector(3*this->collPlane->x,3*this->collPlane->y,3*this->collPlane->z);
+    //this->out = out;
+    //this->out1 = out1;
+    //this->out2 = out2;
     //this->drawDebugCube(&out1);
     //this->drawDebugCube(&out2);
@@ -675 +903 @@
     }
    
-   // if(collision) worldEntity->collidesWithGround(out,out1,out2);
+    // Return the normal here: Normal's stored in this->collPlane;
+    if(collision) worldEntity->collidesWithGround(out,out1,out2);
   
   }