Index: /branches/bsp_model/src/defs/class_id.h
===================================================================
--- /branches/bsp_model/src/defs/class_id.h	(revision 8080)
+++ /branches/bsp_model/src/defs/class_id.h	(revision 8081)
@@ -173,4 +173,5 @@
   CL_PLANET                     =    0x00000309,
   CL_BUILDING                   =    0x00000310,
+  CL_BSP_ENTITY                 =    0x00000311,
 
   // Playables
@@ -248,4 +249,5 @@
   CL_OBB                        =    0x00720000,
   CL_BOUNDING_SPHERE            =    0x00740000,
+  
 
 
@@ -273,5 +275,6 @@
   CL_HEIGHT_MAP                 =    0x0000090a,
   CL_GRID                       =    0x0000090b,
-
+  CL_BSP_MODEL                  =    0x0000090c, //!FIXME 
+  
   CL_MATERIAL                   =    0x00000810,
   CL_SHADER                     =    0x00000811,
Index: /branches/bsp_model/src/lib/graphics/importer/bsp_file.cc
===================================================================
--- /branches/bsp_model/src/lib/graphics/importer/bsp_file.cc	(revision 8080)
+++ /branches/bsp_model/src/lib/graphics/importer/bsp_file.cc	(revision 8081)
@@ -11,4 +11,9 @@
    ### 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,5 +48,5 @@
 int BspFile::read(const char* name)
 {
-  this->scale = 0.4;
+  //this->scale = 0.4;
   int offset;
   int size;
@@ -592,6 +597,5 @@
   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,5 +603,5 @@
   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,5 +610,5 @@
     ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc + 75; 
   else
-    ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc;
+    ((unsigned char *)(&lightMapTexture))[i] = (unsigned char)sc ;
   }
   
@@ -982,4 +986,5 @@
 }
 
+//!TODO: This is a good place to do LittleEndian to BigEndian conversion!
 void BspFile::swapAllBspCoordinates()
 {
@@ -1015,16 +1020,22 @@
   }
   
-    
- 
-
-  
 }
 
 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 ; 
+  }
   
 }
Index: /branches/bsp_model/src/lib/graphics/importer/bsp_file.h
===================================================================
--- /branches/bsp_model/src/lib/graphics/importer/bsp_file.h	(revision 8080)
+++ /branches/bsp_model/src/lib/graphics/importer/bsp_file.h	(revision 8081)
@@ -11,4 +11,9 @@
  ### 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/
 */
 
Index: /branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc
===================================================================
--- /branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc	(revision 8080)
+++ /branches/bsp_model/src/lib/graphics/importer/bsp_manager.cc	(revision 8081)
@@ -11,4 +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,20 +43,70 @@
 #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,5 +124,5 @@
   this->drawDebugCube(&this->out1);
   this->drawDebugCube(&this->out2);
-  
+  */ 
   // Draw Debug Terrain
   /*
@@ -192,5 +249,5 @@
         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,7 +280,9 @@
     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,4 +538,73 @@
       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,4 +636,5 @@
 
 }
+
 
 void BspManager::checkCollisionRay(BspTreeNode* node, float startFraction, float endFraction, Vector* start, Vector* end)
@@ -604,7 +733,102 @@
 
 
+
+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,4 +847,8 @@
   Vector out = Vector(-1875.0,-1875.0,-1875.0);
   if(!worldEntity->isA(CL_PLAYABLE)) {
+    
+    
+    
+ 
   }
   else {
@@ -634,5 +862,5 @@
     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,5 +872,5 @@
     }
 
-    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,5 +883,5 @@
     }
     
-    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,8 +892,8 @@
     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,5 +903,6 @@
     }
    
-   // if(collision) worldEntity->collidesWithGround(out,out1,out2);
+    // Return the normal here: Normal's stored in this->collPlane;
+    if(collision) worldEntity->collidesWithGround(out,out1,out2);
   
   }
Index: /branches/bsp_model/src/lib/graphics/importer/bsp_manager.h
===================================================================
--- /branches/bsp_model/src/lib/graphics/importer/bsp_manager.h	(revision 8080)
+++ /branches/bsp_model/src/lib/graphics/importer/bsp_manager.h	(revision 8081)
@@ -11,9 +11,15 @@
    ### 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,4 +35,10 @@
 class WorldEntity;
 
+struct BspCollisionEvent
+{
+  Vector normal; //!< normal Vector, length 1
+  Vector place;  //!< Absoloute coordinates of collision
+};
+
 class BspManager
 {
@@ -34,10 +46,14 @@
   // 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,5 +64,7 @@
   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);
Index: /branches/bsp_model/src/world_entities/WorldEntities.am
===================================================================
--- /branches/bsp_model/src/world_entities/WorldEntities.am	(revision 8080)
+++ /branches/bsp_model/src/world_entities/WorldEntities.am	(revision 8081)
@@ -15,4 +15,5 @@
 		world_entities/test_entity.cc \
 		world_entities/planet.cc \
+		world_entities/bsp_entity.cc \
 		\
 		world_entities/weapons/test_gun.cc \
@@ -65,4 +66,5 @@
 		test_entity.h \
 		planet.h \
+		bsp_entity.h \
 		\
 		weapons/test_gun.h \
Index: /branches/bsp_model/src/world_entities/bsp_entity.cc
===================================================================
--- /branches/bsp_model/src/world_entities/bsp_entity.cc	(revision 8081)
+++ /branches/bsp_model/src/world_entities/bsp_entity.cc	(revision 8081)
@@ -0,0 +1,117 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   ### File Specific:
+   main-programmer: ...
+   co-programmer: ...
+*/
+
+#include "bsp_entity.h"
+#include "util/loading/resource_manager.h"
+using namespace std;
+
+CREATE_FACTORY(BSPEntity, CL_BSP_ENTITY);
+/**
+ * constructs and loads a BSPEntity from a XML-element
+ * @param root the XML-element to load from
+ */
+BSPEntity::BSPEntity(const TiXmlElement* root)
+{
+  this->init();
+  if (root != NULL)
+    this->loadParams(root);
+}
+
+
+/**
+ * standard deconstructor
+ */
+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 BSPEntity
+ * @todo change this to what you wish
+ */
+void BSPEntity::init()
+{
+  this->bspManager = new BspManager();
+  this->setClassID(CL_BSP_ENTITY, "BSPEntity");
+
+  this->toList(OM_ENVIRON);
+  
+  /**
+   * @todo: Write CL_BSP_ENTITY INTO THE src/defs/class_id.h (your own definition)
+   */
+
+}
+
+
+/**
+ * loads a BSPEntity from a XML-element
+ * @param root the XML-element to load from
+ * @todo make the class Loadable
+ */
+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);
+  
+  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.");
+*/
+
+  /**
+   * @todo: make the class Loadable
+   */
+}
+
+
+/**
+ * advances the BSPEntity about time seconds
+ * @param time the Time to step
+ */
+void BSPEntity::tick(float time)
+{
+
+}
+
+
+/**
+ * draws this worldEntity
+ */
+void BSPEntity::draw () const
+{
+  this->bspManager->draw();
+}
+
+
+/**
+ *
+ *
+ */
+void BSPEntity::collidesWith (WorldEntity* entity, const Vector& location)
+{
+
+}
Index: /branches/bsp_model/src/world_entities/bsp_entity.h
===================================================================
--- /branches/bsp_model/src/world_entities/bsp_entity.h	(revision 8081)
+++ /branches/bsp_model/src/world_entities/bsp_entity.h	(revision 8081)
@@ -0,0 +1,40 @@
+/*!
+ * @file bsp_entity.h
+ * @brief description
+*/
+
+#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 BSPEntity : public WorldEntity
+{
+ 
+ public:
+  BSPEntity(const TiXmlElement* root = NULL);
+  virtual ~BSPEntity();
+
+  virtual void loadParams(const TiXmlElement* root);
+  
+  void setName(const std::string& name);
+
+  void init();
+
+  virtual void draw() const;
+  virtual void tick(float time);
+  virtual void collidesWith (WorldEntity* entity, const Vector& location);
+
+ private:
+   BspManager* bspManager;
+
+};
+
+#endif /* _BSP_ENTITY_H */
Index: /branches/bsp_model/src/world_entities/terrain.cc
===================================================================
--- /branches/bsp_model/src/world_entities/terrain.cc	(revision 8080)
+++ /branches/bsp_model/src/world_entities/terrain.cc	(revision 8081)
@@ -117,4 +117,5 @@
 	
   this->bspManager = new BspManager();
+  this->bspManager->load("test.bsp", 0.4);
   //this->loadTexture("maps/wall1.jpeg");
 }
@@ -208,5 +209,5 @@
   // Vector tmpRot = this->getAbsDir().getSpacialAxis();
   //glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
-/*
+
   if (this->objectList)
     glCallList(this->objectList);
@@ -226,7 +227,7 @@
   }
 
-*/
-
-  this->bspManager->draw();
+
+
+ // this->bspManager->draw();
   glPopMatrix();
 
