Changeset 8081 in orxonox.OLD for branches/bsp_model

Timestamp:

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

Author:

bottac

Message:

Loadable from .oxw

Location:

branches/bsp_model/src

Files:

• defs/class_id.h (modified) (3 diffs)
• lib/graphics/importer/bsp_file.cc (modified) (7 diffs)
• lib/graphics/importer/bsp_file.h (modified) (1 diff)
• lib/graphics/importer/bsp_manager.cc (modified) (14 diffs)
• lib/graphics/importer/bsp_manager.h (modified) (4 diffs)
• world_entities/WorldEntities.am (modified) (2 diffs)
• world_entities/bsp_entity.cc (copied) (copied from branches/bsp_model/src/proto/proto_world_entity.cc) (5 diffs)
• world_entities/bsp_entity.h (copied) (copied from branches/bsp_model/src/proto/proto_world_entity.h) (2 diffs)
• world_entities/terrain.cc (modified) (3 diffs)

branches/bsp_model/src/defs/class_id.h

@@ -173 +173 @@
   CL_PLANET                     =    0x00000309,
   CL_BUILDING                   =    0x00000310,
+  CL_BSP_ENTITY                 =    0x00000311,
 
   // Playables
@@ -248 +249 @@
   CL_OBB                        =    0x00720000,
   CL_BOUNDING_SPHERE            =    0x00740000,
+  
 
 
@@ -273 +275 @@
   CL_HEIGHT_MAP                 =    0x0000090a,
   CL_GRID                       =    0x0000090b,
-
+  CL_BSP_MODEL                  =    0x0000090c, //!FIXME 
+  
   CL_MATERIAL                   =    0x00000810,
   CL_SHADER                     =    0x00000811,

branches/bsp_model/src/lib/graphics/importer/bsp_file.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/
+   Quake 3 Collision Detection by Nathan Ostgard        http://www.devmaster.net/articles/quake3collision/
 */
 
@@ -43 +48 @@
 int BspFile::read(const char* name)
 {
-  this->scale = 0.4;
+  //this->scale = 0.4;
   int offset;
   int size;
@@ -592 +597 @@
   int      mipmapLevel = 0;         //!< the maximum mipmap level for this texture
   int      mipmapWidth = 0;         //!< the width of the mipmap
-  int      mipmapHight = 0;         //!< the height of the mipmap
-
+  int      mipmapHight = 0;         //!< the height of the mipmap3
   float sc, scale, temp;
   for(int i = 0; i < 128*128*3 ; i++)
@@ -599 +603 @@
   sc =  ((unsigned char *)(&lightMapTexture))[i];
   sc *= 1/255.0;
-  scale = 1.4;
+  scale = 2.0;
   if(sc > 1.0f && (temp = (1.0f/sc)) < scale) scale=temp;
   scale*=255.0;
@@ -606 +610 @@
     ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc + 75; 
   else
-    ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc;
+    ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc ;
   }
   
@@ -982 +986 @@
 }
 
+//!TODO: This is a good place to do LittleEndian to BigEndian conversion!
 void BspFile::swapAllBspCoordinates()
 {
@@ -1015 +1020 @@
   }
   
-    
- 
-
-  
 }
 
 void BspFile::swapCoords(int *array)
 {
+  if( scale < 1)
+  {
   int sto  =  array[0];
   array[0] =  array[1] / (int) ( 1/ scale);
   array[1] = array[2] / (int) (1/scale);
   array[2] =  sto / (int) (1/scale);
+  }
+  else
+  {
+    int sto  =  array[0];
+    array[0] =  scale * array[1] ;
+    array[1] =  scale * array[2];
+    array[2] =  scale * sto ; 
+  }
   
 }

branches/bsp_model/src/lib/graphics/importer/bsp_file.h

@@ -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/
+  Quake 3 Collision Detection by Nathan Ostgard        http://www.devmaster.net/articles/quake3collision/
 */
 

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);
   
   }

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

@@ -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/
 */
 
 #include <vector>
 #include <deque>
-
 
 // FORWARD DECLARATIONS
@@ -29 +35 @@
 class WorldEntity;
 
+struct BspCollisionEvent
+{
+  Vector normal; //!< normal Vector, length 1
+  Vector place;  //!< Absoloute coordinates of collision
+};
+
 class BspManager
 {
@@ -34 +46 @@
   // Constructors
   BspManager();
+  
+  BspManager(const char* fileName, float scale = 0.4f);
+  void load(const char* fileName, float scale);
 
   // Functions
-  void draw();
+  const void draw();
   void draw_debug_face(int Face); 
   void draw_face(int Face);
   void draw_patch(face* Face);
+  
 
   void checkCollision(WorldEntity* worldEntity);
@@ -48 +64 @@
   void  checkCollision(BspTreeNode* node, Vector* cam);
   void  checkCollisionRay(BspTreeNode * node,float startFraction, float endFraction, Vector* start, Vector* end); 
+  void  checkCollisionRayN(BspTreeNode * node,float startFraction, float endFraction, Vector* start, Vector* end); 
   void  checkBrushRay(brush* curBrush);
+  void  checkBrushRayN(brush* curBrush);
   void drawDebugCube(Vector* cam);
   bool isAlreadyVisible(int Face);

branches/bsp_model/src/world_entities/WorldEntities.am

@@ -15 +15 @@
                 world_entities/test_entity.cc \
                 world_entities/planet.cc \
+                world_entities/bsp_entity.cc \
                 \
                 world_entities/weapons/test_gun.cc \
@@ -65 +66 @@
                 test_entity.h \
                 planet.h \
+                bsp_entity.h \
                 \
                 weapons/test_gun.h \

branches/bsp_model/src/world_entities/bsp_entity.cc

@@ -14 +14 @@
 */
 
-#include "proto_world_entity.h"
-
+#include "bsp_entity.h"
+#include "util/loading/resource_manager.h"
 using namespace std;
 
-
+CREATE_FACTORY(BSPEntity, CL_BSP_ENTITY);
 /**
- * constructs and loads a ProtoWorldEntity from a XML-element
+ * constructs and loads a BSPEntity from a XML-element
  * @param root the XML-element to load from
  */
-ProtoWorldEntity::ProtoWorldEntity(const TiXmlElement* root)
+BSPEntity::BSPEntity(const TiXmlElement* root)
 {
   this->init();
@@ -34 +34 @@
  * standard deconstructor
  */
-ProtoWorldEntity::~ProtoWorldEntity ()
+BSPEntity::~BSPEntity ()
 {
 
 }
 
+void BSPEntity::setName(const std::string& name)
+{
+  printf("+++++++++++ LOADING NAME %s\n", name.c_str());
+  
+  this->bspManager->load(name.c_str(), 0.1f);
+}
+
+
 
 /**
- * initializes the ProtoWorldEntity
+ * initializes the BSPEntity
  * @todo change this to what you wish
  */
-void ProtoWorldEntity::init()
+void BSPEntity::init()
 {
-  this->setClassID(CL_PROTO_WORLD_ENTITY, "ProtoWorldEntity");
+  this->bspManager = new BspManager();
+  this->setClassID(CL_BSP_ENTITY, "BSPEntity");
 
+  this->toList(OM_ENVIRON);
+  
   /**
-   * @todo: Write CL_PROTO_WORLD_ENTITY INTO THE src/defs/class_id.h (your own definition)
+   * @todo: Write CL_BSP_ENTITY INTO THE src/defs/class_id.h (your own definition)
    */
 
@@ -56 +67 @@
 
 /**
- * loads a ProtoWorldEntity from a XML-element
+ * loads a BSPEntity from a XML-element
  * @param root the XML-element to load from
  * @todo make the class Loadable
  */
-void ProtoWorldEntity::loadParams(const TiXmlElement* root)
+void BSPEntity::loadParams(const TiXmlElement* root)
 {
   // all the clases this Entity is directly derived from must be called in this way, to load all settings.
-  WorldEntity::loadParam(root);
+ // WorldEntity::loadParam(root);
+  
+  LoadParam(root, "Name", this, BSPEntity, setName)
+      .describe("Sets the of the BSP file.");
 
+/*  LoadParam(root, "Scale", this, BSpEntity, setScale)
+      .describe("Sets the scale factore of the bsp level.");
+*/
 
   /**
@@ -73 +90 @@
 
 /**
- * advances the ProtoWorldEntity about time seconds
+ * advances the BSPEntity about time seconds
  * @param time the Time to step
  */
-ProtoWorldEntity::tick(float time)
+void BSPEntity::tick(float time)
 {
 
 }
 
+
 /**
  * draws this worldEntity
  */
-void ProtoWorldEntity::draw () const
+void BSPEntity::draw () const
 {
-  glMatrixMode(GL_MODELVIEW);
-  glPushMatrix();
-  float matrix[4][4];
-
-  /* translate */
-  glTranslatef (this->getAbsCoor ().x,
-                this->getAbsCoor ().y,
-                this->getAbsCoor ().z);
-  /* rotate */
-  this->getAbsDir().matrix(matrix);
-  glMultMatrixf((float*)matrix);
-
-  if (model)
-    model->draw();
-  glPopMatrix();
+  this->bspManager->draw();
 }
 
@@ -108 +112 @@
  *
  */
-void ProtoWorldEntity::collidesWith (WorldEntity* entity, const Vector& location)
+void BSPEntity::collidesWith (WorldEntity* entity, const Vector& location)
 {
 

branches/bsp_model/src/world_entities/bsp_entity.h

@@ -1 +1 @@
 /*!
- * @file proto_world_entity.h
+ * @file bsp_entity.h
  * @brief description
 */
 
-#ifndef _PROTO_WORLD_ENTITY_H
-#define _PROTO_WORLD_ENTITY_H
+#ifndef _BSP_ENTITY_H
+#define _BSP_ENTITY_H
 
 #include "world_entity.h"
+#include "bsp_manager.h"
+
+#include "util/loading/factory.h"
+#include "util/loading/load_param.h"
+
+
 
 //! A Class to ...
-class ProtoWorldEntity : public WorldEntity
+class BSPEntity : public WorldEntity
 {
-
+ 
  public:
-  ProtoWorldEntity(const TiXmlElement* root = NULL);
-  virtual ~ProtoWorldEntity();
+  BSPEntity(const TiXmlElement* root = NULL);
+  virtual ~BSPEntity();
 
   virtual void loadParams(const TiXmlElement* root);
+  
+  void setName(const std::string& name);
+
   void init();
-
-  virtual void postSpawn ();
-  virtual void leftWorld ();
-
 
   virtual void draw() const;
@@ -29 +34 @@
 
  private:
+   BspManager* bspManager;
 
 };
 
-#endif /* _PROTO_WORLD_ENTITY_H */
+#endif /* _BSP_ENTITY_H */

branches/bsp_model/src/world_entities/terrain.cc

@@ -117 +117 @@
         
   this->bspManager = new BspManager();
+  this->bspManager->load("test.bsp", 0.4);
   //this->loadTexture("maps/wall1.jpeg");
 }
@@ -208 +209 @@
   // Vector tmpRot = this->getAbsDir().getSpacialAxis();
   //glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
-/*
+
   if (this->objectList)
     glCallList(this->objectList);
@@ -226 +227 @@
   }
 
-*/
-
-  this->bspManager->draw();
+
+
+ // this->bspManager->draw();
   glPopMatrix();